NAS-0: remove bluebird

Author: eldimious

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "nodejs-api-showcase",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "",
   "main": "node src/server.js",
   "scripts": {
@@ -22,7 +22,6 @@
   "dependencies": {
     "@hapi/joi": "^17.1.1",
     "bcryptjs": "^2.4.3",
-    "bluebird": "^3.5.0",
     "body-parser": "^1.18.2",
     "compression": "^1.7.1",
     "cors": "^2.8.5",
@@ -36,7 +35,7 @@
     "moment": "^2.18.1",
     "mongodb": "^4.2.2",
     "mongoose": "^6.1.4",
-    "mongoose-paginate": "5.0.3",
+    "mongoose-paginate": "^5.0.3",
     "mongoose-unique-validator": "^3.0.0",
     "morgan": "^1.9.0",
     "rate-limiter-flexible": "^2.1.13",

package.json

@@ -2,52 +2,43 @@
   It can be published as private npm module shared among all team's projects.
 */
 const mongoose = require('mongoose');
-const schemasFactory = require('./schemas');
+const schemas = require('./schemas');
 const logging = require('../../../common/logging');
-mongoose.Promise = require('bluebird');
 
-module.exports = ({ dbConnectionString }) => {
+module.exports.init = (dbConnectionString) => {
   if (!dbConnectionString) {
     throw new Error('add correct format of config with dbConnectionString');
   }
-  const options = {
-    promiseLibrary: require('bluebird'),
-  };
-
   // Check for errors on connecting to Mongo DB
   mongoose.connection.on('error', (err) => {
     logging.error(`Error! DB Connection failed. Error: ${err}`);
     return err;
   });
-
   // Connection opened successfully
   mongoose.connection.once('open', () => {
     logging.info('Connection to MongoDB established');
     // mongoose.connection.db.dropDatabase()
   });
-
   mongoose.connection.on('disconnected', () => {
     logging.info('Connection to MongoDB closed');
     logging.info('-------------------');
   });
 
-  const schemas = schemasFactory.create(mongoose);
   return Object.assign(
     {
       getConnection() {
         return mongoose.connection;
       },
-
       connect() {
         // Open Connection to Mongo DB
-        return mongoose.connect(dbConnectionString, options);
+        return mongoose.connect(dbConnectionString);
       },
       close() {
         return mongoose.connection.close();
       },
     },
     {
-      schemas,
+      schemas: schemas.create(),
     },
   );
 };

src/data/infrastructure/db/index.js

@@ -1,34 +1,35 @@
 const moment = require('moment');
 const mongoosePaginate = require('mongoose-paginate');
+const mongoose = require('mongoose');
 
-function create(mongoose) {
-  const postSchema = mongoose.Schema({
-    userId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: 'User',
-    },
-    imageUrl: {
-      type: String,
-      required: true,
-    },
-    description: String,
-    publisher: {
-      type: String,
-      required: true,
-    },
-    created: Date,
-  });
+const PostSchema = new mongoose.Schema({
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+  },
+  imageUrl: {
+    type: String,
+    required: true,
+  },
+  description: String,
+  publisher: {
+    type: String,
+    required: true,
+  },
+  created: Date,
+});
 
-  postSchema.pre('save', (next) => {
-    this.created = moment().toJSON();
-    return next();
-  });
+PostSchema.index({ userId: 1 });
 
-  postSchema.index({ created: -1 });
+PostSchema.index({ created: -1 });
 
-  postSchema.plugin(mongoosePaginate);
+PostSchema.plugin(mongoosePaginate);
 
-  return mongoose.model('Post', postSchema);
-}
+PostSchema.pre('save', function (next) {
+  this.created = moment().toJSON();
+  return next();
+});
 
-module.exports = create;
+const PostDao = mongoose.model('Post', PostSchema);
+
+module.exports = { PostDao };

src/data/infrastructure/db/schemas/Post.js

@@ -1,60 +1,58 @@
 const moment = require('moment');
-const mongoosePaginate = require('mongoose-paginate');
 const bcrypt = require('bcryptjs');
 const uniqueValidator = require('mongoose-unique-validator');
-
-function create(mongoose) {
-  const userSchema = mongoose.Schema({
-    name: {
-      type: String,
-      required: true,
-    },
-    surname: {
-      type: String,
-      required: true,
-    },
-    username: {
-      type: String,
-      required: true,
-    },
-    password: {
-      type: String,
-      required: true,
-    },
-    email: {
-      type: String,
-      required: true,
-      unique: true,
-    },
-    created: Date,
-  });
-
-  userSchema.pre('save', function (next) {
-    bcrypt.genSalt(10, (err, salt) => {
-      if (err) {
-        return next(err);
+const {
+  model,
+  Schema,
+} = require('mongoose');
+
+const UserSchema = new Schema({
+  name: {
+    type: String,
+    required: true,
+  },
+  surname: {
+    type: String,
+    required: true,
+  },
+  username: {
+    type: String,
+    required: true,
+  },
+  password: {
+    type: String,
+    required: true,
+  },
+  email: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  created: Date,
+});
+
+UserSchema.index({ name: 1 });
+
+UserSchema.index({ name: 1, created: -1 });
+
+UserSchema.plugin(uniqueValidator);
+
+UserSchema.pre('save', function (next) {
+  bcrypt.genSalt(10, (err, salt) => {
+    if (err) {
+      return next(err);
+    }
+    bcrypt.hash(this.password, salt, (error, hash) => {
+      if (error) {
+        return next(error);
       }
-      bcrypt.hash(this.password, salt, (err, hash) => {
-        if (err) {
-          return next(err);
-        }
-        this.password = hash;
-        this.created = moment().toJSON();
-        return next();
-      });
+      this.password = hash;
+      this.created = moment().toJSON();
+      return next();
     });
   });
+});
 
-  userSchema.index({ name: 1 });
-
-  userSchema.index({ name: 1, created: -1 });
-
-  userSchema.plugin(mongoosePaginate);
-
-  userSchema.plugin(uniqueValidator);
-
-  return mongoose.model('User', userSchema);
-}
-
+const UserDao = model('User', UserSchema);
 
-module.exports = create;
+module.exports = { UserDao };

src/data/infrastructure/db/schemas/User.js

@@ -1,7 +1,7 @@
-const postSchema = require('./Post');
-const userSchema = require('./User');
+const { PostDao } = require('./Post');
+const { UserDao } = require('./User');
 
-module.exports.create = (mongoose) => ({
-  Post: postSchema(mongoose),
-  User: userSchema(mongoose),
+module.exports.create = () => ({
+  Post: PostDao,
+  User: UserDao,
 });

src/data/infrastructure/db/schemas/index.js

@@ -6,7 +6,7 @@ const {
 const setupWorkerProcesses = require('./common/utils/workerProcesses');
 const logging = require('./common/logging');
 const signals = require('./signals');
-const db = require('./data/infrastructure/db')({ dbConnectionString });
+const dbContainer = require('./data/infrastructure/db');
 const postsRepositoryContainer = require('./data/repositories/posts');
 const usersRepositoryContainer = require('./data/repositories/users');
 const authenticationRepositoryContainer = require('./data/repositories/authenticationRepository');
@@ -17,6 +17,7 @@ const usersServiceContainer = require('./domain/users/service');
 const appContainer = require('./presentation/http/app');
 const websocketsContainer = require('./presentation/websockets');
 
+const db = dbContainer.init(dbConnectionString);
 const authenticationRepository = authenticationRepositoryContainer.init();
 const postsRepository = postsRepositoryContainer.init(db.schemas);
 const usersRepository = usersRepositoryContainer.init(db.schemas);
@@ -38,7 +39,7 @@ const app = appContainer.init({
   postsService,
   usersService,
 });
-const websockets = websocketsContainer.init(app);
+websocketsContainer.init(app);
 
 let server;
 
@@ -54,7 +55,6 @@ let server;
   }
 })(true);
 
-
 const shutdown = signals.init(async () => {
   await db.close();
   await server.close();