如何从 Mongodb 获取文档 object

Question

I have recorded some documents in MongoDB and I need to return one of my documents to compare.

For example:

{user_mail:'MAIL' , user_pass:'PASS'}

I know how to find it but how can I access it? I want a function which would give me the document as output.

In other words:

var A = function (*(data base name), (collection name), (condition to find document)*)

Where A should be my document.

PS I am not interested in using Express module

Answer 1

Try this:
File mongo-conn.js :

const mongo = require('mongodb');
const mongoClient = mongo.MongoClient;
const mongoConn = 'mongodb://localhost:27017/auth';
class MongoQuery {

  async getCollections(dbName) {
    try {
      const client = this.db;
      let list = await client.db(dbName).listCollections().toArray();
      list = list.map(function (col) {
        return col.name
      })
      await client.close();
      return list;
    }
    catch (Ex) {
      throw new Error(Ex);
    }
  }
  async getResult(dbName, collectionName, condition = {}, limit = 0, skip = false, sort = { createdOn: -1 }, fields = { __v: 0 }) {
    // console.log(`\ndbName ==> `, dbName, `,\ncollectionName ==> `, collectionName, `,\ncondition ==> `, condition, `,\nsort ==> `, sort, `,\nlimit ==> `, limit, `,\nskip ==> `, skip, `,\nfields ==> `, fields)
    if (!this.db)
      throw new Error('no connection established');
    if (!dbName)
      throw new Error('invalid dbName');
    if (!collectionName)
      throw new Error('invalid collectionName');
    if (!sort || typeof sort != 'object')
      throw new Error('invalid sort');

    try {
      let client = this.db, data = [];
      if (limit && skip)
        data = await client.db(dbName).collection(collectionName).find(condition, fields).sort(sort).skip(parseInt(skip)).limit(parseInt(limit)).toArray()
      else if (limit)
        data = await client.db(dbName).collection(collectionName).find(condition, fields).sort(sort).limit(parseInt(limit)).toArray()
      else if (skip)
        data = await client.db(dbName).collection(collectionName).find(condition, fields).sort(sort).skip(parseInt(skip)).toArray()
      else {
        data = await client.db(dbName).collection(collectionName).find(condition, fields).sort(sort).toArray()
      }
      await client.close();
      return data;
    }
    catch (Ex) {
      throw new Error(Ex);
    }
  }
  async getAggregate(dbName, collectionName, aggregateArr) {

    if (!this.db)
      throw new Error('no connection established');
    if (!dbName)
      throw new Error('invalid dbName');
    if (!collectionName)
      throw new Error('invalid collectionName');
    if (!Array.isArray(aggregateArr))
      throw new Error('invalid aggregateArr');
    console.log(dbName, collectionName, JSON.stringify(aggregateArr))
    try {
      let client = this.db, data = [];
      data = await client.db(dbName).collection(collectionName).aggregate(aggregateArr).toArray()
      await client.close();
      return data;
    }
    catch (Ex) {
      throw new Error(Ex);
    }
  }
  async getResultCount(dbName, collectionName, condition = {}) {
    if (!this.db)
      throw new Error('no connection established');
    if (!dbName)
      throw new Error('invalid dbName');
    if (!collectionName)
      throw new Error('invalid collectionName');

    console.log(`\ndbName ==> `, dbName, `,\ncollectionName ==> `, collectionName, `,\ncondition ==> `, condition)
    try {
      let client = this.db, count = 0;
      count = await client.db(dbName).collection(collectionName).count(condition)
      await client.close();
      return count;
    }
    catch (Ex) {
      throw new Error(Ex);
    }
  }
  async getDistinctResult(dbName, collectionName, distinctKey, condition = {}) {
    if (!this.db)
      throw new Error('no connection established');
    if (!dbName)
      throw new Error('invalid dbName');
    if (!collectionName)
      throw new Error('invalid collectionName');
    if (!distinctKey)
      throw new Error('invalid distinctKey');

    console.log(`\ndbName ==> `, dbName, `,\ncollectionName ==> `, collectionName, `,\distinctKey ==> `, distinctKey, `,\ncondition ==> `, condition)
    try {
      let client = this.db, data = [];
      data = await client.db(dbName).collection(collectionName).distinct(distinctKey.toString(), condition)
      await client.close();
      return data;
    }
    catch (Ex) {
      throw new Error(Ex);
    }
  }
  async getDistinctResultCount(dbName, collectionName, distinctKey, condition = {}) {
    if (!this.db)
      throw new Error('no connection established');
    if (!dbName)
      throw new Error('invalid dbName');
    if (!collectionName)
      throw new Error('invalid collectionName');
    if (!distinctKey)
      throw new Error('invalid distinctKey');

    console.log(`\ndbName ==> `, dbName, `,\ncollectionName ==> `, collectionName, `,\distinctKey ==> `, distinctKey, `,\ncondition ==> `, condition)
    try {
      let client = this.db, count = 0;
      count = await client.db(dbName).collection(collectionName).distinct(distinctKey.toString(), condition).length
      await client.close();
      return count;
    }
    catch (Ex) {
      throw new Error(Ex);
    }
  }
  async saveResult(dbName, collectionName, result) {
    if (!this.db)
      throw new Error('no connection established');
    if (!dbName)
      throw new Error('invalid dbName');
    if (!collectionName)
      throw new Error('invalid collectionName');

    console.log(`\ndbName ==> save `, dbName, `,\ncollectionName ==> `, collectionName)
    try {
      let db = this.db, savedResult = {};
      savedResult = await db.collection(collectionName).insert(result);
      await db.close();
      return savedResult;
    }
    catch (Ex) {
      throw new Error(Ex);
    }
  }

  async saveResultMultiple(dbName, collectionName, result) {
    if (!this.db)
      throw new Error('no connection established');
    if (!dbName)
      throw new Error('invalid dbName');
    if (!collectionName)
      throw new Error('invalid collectionName');

    console.log(`\ndbName ==> save `, dbName, `,\ncollectionName ==> `, collectionName)
    try {
      let db = this.db, savedResult = {};
      savedResult = await db.collection(collectionName).insertMany(result);
      await db.close();
      return savedResult;
    }
    catch (Ex) {
      throw new Error(Ex);
    }
  }

  makeMongoId(id) {
    // console.log('makeMongoId ==>', id)
    const mongoose = require('mongoose');
    try {
      return mongoose.Types.ObjectId(id)
    }
    catch (Ex) {
      console.log('makeMongoId Ex ==> ', Ex)
      return Ex
    }
  }

  validateMongoId(id) {
    console.log('validateMongoId ==>', id)
    const mongoose = require('mongoose');
    try {
      return mongoose.Types.ObjectId.isValid(id)
    }
    catch (Ex) {
      console.log('validateMongoId Ex ==> ', Ex)
      return false
    }
  }
}
class MongoConnections extends MongoQuery {
  constructor() {
    super()
    this.db = null
  }
  async connectDb(uri) {
    if (uri) {
      mongoConn = uri
    }
    try {
      const options = {
        // autoReconnect: true,
        poolSize: 10,
        socketTimeoutMS: 90000,
        connectTimeoutMS: 90000,
        reconnectTries: 30,
        reconnectInterval: 1000,
        useUnifiedTopology: true
      };
      this.db = await mongoClient.connect(mongoConn, options);
      return
    } catch (dbError) {
      console.log(`MongoDb connection error. ${dbError}`);
      throw new Error(dbError);
    }
  }
}
module.exports = new MongoConnections

File test.js

const mongo = require('./mongo-conn')

async function showData() {
  await mongo.connectDb()
  let condition = {}
  let data = await mongo.getResult('dbName', 'collectionName', condition)
  console.log(data)
}
showData()