obter instância da conexão do mongodb na DAO

Oi Marco, tudo bem? Normalmente o que eu faria seria exportar o MongoClient sem fazer uso do connect, nos demais lugares onde fará uso, ai sim, você faz o connect.

Outro ponto é que você já está informando o banco na string do endereço, então, não precisa informar o nome do banco para o connect.

Fora isso, quais erros estão acontecendo quando você executa o código?

Amigo não era isso que eu queria, Pois fazer o connect la na DAO ocasiona que eu tenha que abrir essa conexão e fechar para cada chamada da minha controller... então depois de praticamente zerar a documentação + teste próprios obtive a seguinte solução:

dbConnection: Aqui eu conecto ao meu banco e exporto essa conexão assim não preciso abri-la e fecha-la em todas as chamadas.

const {MongoClient} = require('mongodb');
const url = 'mongodb://localhost:27017/?readPreference=primary&appname=MongoDB%20Compass&ssl=false';
module.exports = (async () => {
    db = await new MongoClient.connect(url, {useUnifiedTopology: true});
    return await db.db('site'); 
})()

..... Controller:

    const userDao =  new UserDao(' Aqui passo para o construtor na minha DAO o conexão que criei na dbConnection');
    const user = await userDao.searchEmail(email);  // chamada do método da DAO`

..... DAO: Quanto instanciado meu construtor pega a conexão e seleciona a collection referende a classe DAO do momento.

constructor(db){ 
        this.collection = (async () => {   
            return db.then(dbo => dbo.collection('user'))
        })()
    }

... método que foi chamado pela controller:

 async searchEmail(email){
        try{
            return this.collection.then(dbo => dbo.findOne({'email':email}));
        }catch(erro){
             throw new Error;
        }
    }

Oi Marcos, eu havia perguntando quais erros você estava tendo, eu entendi melhor agora com a sua segunda mensagem, mas na primeira, confesso que fiquei um pouco confuso.

Acredito que seu código ainda pode ficar melhor, por que não informar o banco direto na string de conexão? Assim você não precisa do segundo await.

-Então eu não estava tendo erros, só queria uma forma melhor para fazer a conexão pois em todo lugar eu só achava, o pessoal passando a string de conexão para a DAO e lá abria e fechava o connect com o mongoClient para cada função que fosse chamada, ou passava pelo app.locals (que no meu ver fica muito amador e verboso kkkk). utilizei muito tempo assim, desenvolvi essa solução faz pouco tempo. Também não sei se é a mais correta, mas já esta muito melhor do que encontrei em minhas pesquisas em fóruns e nas documentações nesses quase 2 anos.

-Sobre informar o banco na própria string, segue o exemplo de string que utilizo

mongodb://nomeDoBanco:Senha@host:porta/?authSource=userDoBanco&readPreference=primary&appname=MongoDB%20Compass&ssl=false

Desta maneira o que ocorre é que as vezes mesmo colocando o banco que eu quero acessar, o retorno do new MongoClient ainda não me da acesso ao mesmo(vai entender kkk), por isso passei o exemplo 'forçado'.

Entao, o nome do banco está indo no lugar errado na URL de conexão, se você pegar pela documentação, lá tá descrito assim:

mongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[defaultauthdb][?options]]

Traduzindo, deveria ficar assim:

mongodb://usuario:senha@host:porta/nomeDoBanco?authSource=userDoBanco&readPreference=primary&appname=MongoDB%20Compass&ssl=false

Testei aqui mesma coisa. até criei um banco com tudo ''mteste'', pra ter certeza segue como ficou:

mongodb://mteste:senha@kamino.mongodb.umbler.com:41513/mteste?authSource=mteste&readPreference=primary&appname=MongoDB%20Compass&ssl=false

Retorno do new MongoCliente:

MongoClient {
  _events: [Object: null prototype] { newListener: [Function] },
  _eventsCount: 1,
  _maxListeners: undefined,
  s: {
    url: 'mongodb://mteste:senha@kamino.mongodb.umbler.com:41513/mteste?authSource=mteste&readPreference=primary&appname=MongoDB%20Compass&ssl=false',     
    options: {
      servers: [Array],
      authSource: 'mteste',
      readPreference: [ReadPreference],
      appname: 'MongoDB Compass',
      ssl: false,
      caseTranslate: true,
      useUnifiedTopology: true,
      directConnection: true,
      checkServerIdentity: true,
      sslValidate: true,
      appName: 'MongoDB Compass',
      auth: [Object],
      dbName: 'mteste',
      socketTimeoutMS: 0,
      connectTimeoutMS: 10000,
      retryWrites: true,
      useRecoveryToken: true,
      credentials: [MongoCredentials],
      promiseLibrary: [Function: Promise]
    },
    promiseLibrary: [Function: Promise],
    dbCache: Map {},
    sessions: Set {},
    writeConcern: undefined,
    readPreference: ReadPreference {
      mode: 'primary',
      tags: undefined,
      hedge: undefined
    },
    namespace: MongoDBNamespace { db: 'admin', collection: undefined }
  },
  topology: NativeTopology {
    _events: [Object: null prototype] {
      authenticated: [Function],
      error: [Function],
      timeout: [Function],
      close: [Function],
      parseError: [Function],
      fullsetup: [Function],
      all: [Function],
      reconnect: [Function],
      commandStarted: [Function],
      commandSucceeded: [Function],
      commandFailed: [Function],
      serverOpening: [Function],
      serverClosed: [Function],
      serverDescriptionChanged: [Function],
      serverHeartbeatStarted: [Function],
      serverHeartbeatSucceeded: [Function],
      serverHeartbeatFailed: [Function],
      topologyOpening: [Function],
      topologyClosed: [Function],
      topologyDescriptionChanged: [Function],
      joined: [Function],
      left: [Function],
      ping: [Function],
      ha: [Function],
      connectionPoolCreated: [Function],
      connectionPoolClosed: [Function],
      connectionCreated: [Function],
      connectionReady: [Function],
      connectionClosed: [Function],
      connectionCheckOutStarted: [Function],
      connectionCheckOutFailed: [Function],
      connectionCheckedOut: [Function],
      connectionCheckedIn: [Function],
      connectionPoolCleared: [Function]
    },
    _eventsCount: 34,
    _maxListeners: Infinity,
    s: {
      id: 0,
      options: [Object],
      seedlist: [Array],
      state: 'connected',
      description: [TopologyDescription],
      serverSelectionTimeoutMS: 30000,
      heartbeatFrequencyMS: 10000,
      minHeartbeatFrequencyMS: 500,
      Cursor: [Function: Cursor],
      bson: BSON {},
      servers: [Map],
      sessionPool: [ServerSessionPool],
      sessions: Set {},
      promiseLibrary: [Function: Promise],
      credentials: [MongoCredentials],
      clusterTime: null,
      connectionTimers: Set {}
    },
    [Symbol(kCapture)]: false,
    [Symbol(waitQueue)]: Denque {
      _head: 2,
      _tail: 2,
      _capacity: undefined,
      _capacityMask: 3,
      _list: [Array]
    }
  },
  [Symbol(kCapture)]: false
}

Ele ainda não foi para o db certo :(

Estranho, o usuário é mteste e a senha é senha mesmo?