¿Llamar a una función "local" dentro de module.exports desde otra función en module.exports?

¿Cómo se llama a una función desde otra función en una module.exportsdeclaración?

var bla = require('./bla.js');
console.log(bla.bar());

module.exports = {

  foo: function (req, res, next) {
    return ('foo');
  },

  bar: function(req, res, next) {
    this.foo();
  }

}

Estoy tratando de acceder a la función foodesde dentro de la función bary obtengo:

TypeError: Object # no tiene el método 'foo'

Si cambio this.foo()a solo foo()obtengo:

ReferenceError: foo no está definido

Cambiar this.foo()amodule.exports.foo()

Puede declarar sus funciones fuera del module.exportsbloque.

var foo = function (req, res, next) {
  return ('foo');
}

var bar = function (req, res, next) {
  return foo();
}

Luego:

module.exports = {
  foo: foo,
  bar: bar
}

También puede hacer esto para hacerlo más conciso y legible. Esto es lo que he visto hacer en varios de los módulos de código abierto bien escritos:

var self = module.exports = {

  foo: function (req, res, next) {
    return ('foo');
  },

  bar: function(req, res, next) {
    self.foo();
  }

}

También puede guardar una referencia al alcance global del módulo fuera de la definición (module.) Exports.somemodule:

var _this = this;

exports.somefunction = function() {
   console.log('hello');
}

exports.someotherfunction = function() {
   _this.somefunction();
}

Otra opción, y más cercana al estilo original del OP, es colocar el objeto que desea exportar en una variable y hacer referencia a esa variable para realizar llamadas a otros métodos en el objeto. Luego puede exportar esa variable y listo.

var self = {
  foo: function (req, res, next) {
    return ('foo');
  },
  bar: function (req, res, next) {
    return self.foo();
  }
};
module.exports = self;

const Service = {
  foo: (a, b) => a + b,
  bar: (a, b) => Service.foo(a, b) * b
}

module.exports = Service

A partir de la versión 13 de Node.js , puede aprovechar los módulos ES6 .

export function foo() {
    return 'foo';
}

export function bar() {
    return foo();
}

Siguiendo el enfoque de clase:

class MyClass {

    foo() {
        return 'foo';
    }

    bar() {
        return this.foo();
    }
}

module.exports = new MyClass();

Esto creará una instancia de la clase solo una vez, debido al almacenamiento en caché del módulo de Node:
https://nodejs.org/api/modules.html#modules_caching

Para solucionar su problema, he realizado algunos cambios en bla.js y está funcionando,

var foo= function (req, res, next) {
  console.log('inside foo');
  return ("foo");
}

var  bar= function(req, res, next) {
  this.foo();
}
module.exports = {bar,foo};

y ninguna modificación en app.js

var bla = require('./bla.js');
console.log(bla.bar());