Chame uma função "local" em module.exports de outra função em module.exports?

Como você chama uma função de outra função em uma module.exportsdeclaração?

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();
  }

}

Estou tentando acessar a função foode dentro da função bare estou obtendo:

TypeError: o objeto # não possui o método 'foo'

Se eu mudar this.foo()para apenas foo()eu recebo:

ReferenceError: foo não está definido

Mude this.foo()paramodule.exports.foo()

Você pode declarar suas funções fora do module.exportsbloco.

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

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

Então:

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

Você também pode fazer isso para torná-lo mais conciso e legível. Isto é o que eu vi feito em vários dos módulos de código aberto bem escritos:

var self = module.exports = {

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

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

}

Você também pode salvar uma referência ao escopo global do módulo fora da definição (module.) Imports.somemodule:

var _this = this;

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

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

Outra opção, e mais próxima do estilo original do OP, é colocar o objeto que você deseja exportar em uma variável e fazer referência a essa variável para fazer chamadas para outros métodos no objeto. Você pode exportar essa variável e pronto.

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 da versão 13 do Node.js., você pode aproveitar os Módulos ES6 .

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

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

Seguindo a abordagem de classe:

class MyClass {

    foo() {
        return 'foo';
    }

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

module.exports = new MyClass();

Isso instanciará a classe apenas uma vez, devido ao cache do módulo do Node:
https://nodejs.org/api/modules.html#modules_caching

Para corrigir seu problema, fiz algumas alterações no bla.js e ele 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};

e nenhuma modificação no app.js

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