MongoDB in NodeJS Class Structure

Question

Is there a way to use MongoDB in a class structure in NodeJS?

I understand you can do CRUD operations on the DB within the connection method like

mongo.connect(url, function(err, client){//do some CRUD operation});

but I was wondering if there was a way to open the connection to the DB, have access to it across the class, then close it when you are done working with the class.

For example:

class MyClass {
    constructor(databaseURL) {
      this.url = databaseURL;
    }

    async init() {
      //make connection to database
    }

    async complete_TaskA_onDB() {
      //...
    }

    async complete_TaskB_onDB() {
      //...
    }

    async close_connection() {
      //close connection to database
    }
}

Edit:

I just came across more information in the Node.JS Mongo docs. Maybe something along the lines of this would work?

//constructor()
this.db = new MongoClient(new Server(dbHost, dbPort));

//init()
this.db.open();

//taskA()
this.db.collection(...).update(...);

//close_connection()
this.db.close();

Answer 1

You can create a class of which will act as a wrapper on any core lib, doing so will give you below advantages:

Wrapping any core module with your own service will allow you to:

1. Create a reusable service that you could use on multiple components in your app.
2. Normalize the module's API, and add more methods your app needs and the module doesn’t provide.
3. Easily replace the DB module you chose with another one (if needed).

I have created that service which I use it in my projects for MongoDB:

var mongoClient = require("mongodb").MongoClient,
  db;

function isObject(obj) {
  return Object.keys(obj).length > 0 && obj.constructor === Object;
}

class mongoDbClient {
  async connect(conn, onSuccess, onFailure){
    try {
      var connection = await mongoClient.connect(conn.url, { useNewUrlParser: true });
      this.db = connection.db(conn.dbName);
      logger.info("MongoClient Connection successfull.");
      onSuccess();
    }
    catch(ex) {
      logger.error("Error caught,", ex);
      onFailure(ex);
    }
  }

  async getNextSequence(coll) {
    return await this.db.collection("counters").findOneAndUpdate({
        _id: coll
      },
      {$inc: {seq: 1}},
      {projections: {seq: 1},
        upsert: true,
        returnOriginal: false
      }
    );
  }

  async insertDocumentWithIndex(coll, doc) {
    try {
      if(!isObject(doc)){
        throw Error("mongoClient.insertDocumentWithIndex: document is not an object");
        return;
      }
      var index = await this.getNextSequence(coll);
      doc.idx = index.value.seq;
      return await this.db.collection(coll).insertOne(doc);
    }
    catch(e) {
      logger.error("mongoClient.insertDocumentWithIndex: Error caught,", e);
      return Promise.reject(e);
    }
  }

  async findDocFieldsByFilter(coll, query, projection, lmt) {
    if(!query){
      throw Error("mongoClient.findDocFieldsByFilter: query is not an object");
    }
    return await this.db.collection(coll).find(query, {
      projection: projection || {},
      limit: lmt || 0
    }).toArray();
  }

  async findDocByAggregation(coll, query) {
    if(!query.length){
      throw Error("mongoClient.findDocByAggregation: query is not an object");
    }
    return this.db.collection(coll).aggregate(query).toArray();
  }

  async getDocumentCountByQuery(coll, query) {
    return this.db.collection(coll).estimatedDocumentCount(query || {})
  }

  async findOneAndUpdate(coll, query, values, option) {
    if(!(isObject(values) && isObject(query))){
      throw Error("mongoClient.UpdateDocument: values and query should be an object");
    }
    return this.db.collection(coll).findOneAndUpdate(query, {$set : values}, option || {})
  }

  async modifyOneDocument(coll, query, values, option) {
    if(!(isObject(values) && isObject(query))){
      throw Error("mongoClient.ModifyOneDocument: values, query and option should be an object");
    }
    return await this.db.collection(coll).updateOne(query, values, option || {})
  }

  async close() {
    return await this.db.close();
  }
}

module.exports = {
  mongoDbClient: mongoDbClient
}

For my complete lib access you can refer here