feat(base repository): implemented base repository

* Created BaseRepository class
* Implemented UserRepository class

Author: devalexanderdaza

package.json

@@ -45,6 +45,7 @@
     "prepare": "husky install"
   },
   "dependencies": {
+    "bcrypt": "5.0.1",
     "body-parser": "1.19.0",
     "cookie-parser": "1.4.5",
     "cors": "2.8.5",
@@ -64,6 +65,7 @@
     "@commitlint/config-conventional": "^14.1.0",
     "@semantic-release/changelog": "6.0.1",
     "@semantic-release/git": "10.0.1",
+    "@types/bcrypt": "5.0.0",
     "@types/body-parser": "1.19.1",
     "@types/chai": "^4.2.22",
     "@types/cookie-parser": "1.4.2",
@@ -72,9 +74,9 @@
     "@types/express": "^4.17.13",
     "@types/express-session": "1.17.4",
     "@types/helmet": "^4.0.0",
-    "@types/node": "^16.11.6",
     "@types/mocha": "^9.0.0",
     "@types/mongoose": "5.11.97",
+    "@types/node": "^16.11.6",
     "@types/socket.io": "^3.0.2",
     "@typescript-eslint/eslint-plugin": "^5.3.0",
     "@typescript-eslint/parser": "^5.3.0",

src/controllers/rest/PublicController.ts

@@ -1,5 +1,8 @@
 import { NextFunction, Request, Response } from "express";
 import { iResponse } from "../../interfaces/IResponse";
+import UserModel from "../../models/UserModel";
+import UserRepository from "../../repositories/UserRepository";
+import { Logger } from "../../utils/Logger";
 
 class PublicController {
 
@@ -11,6 +14,13 @@ class PublicController {
    */
   public async indexAction(req: Request, res: Response, next: NextFunction): Promise<void> {
     try {
+      const usersRepository: UserRepository = new UserRepository(UserModel);
+      await usersRepository.createUserAccount({
+                                                username: "admin",
+                                                email: "admin@domain.com",
+                                                avatar: "",
+                                                password: "admin"
+                                              });
       const response: iResponse = {
         error: false,
         statusCode: 200,

src/interfaces/models/IUserModel.ts

@@ -0,0 +1,16 @@
+import {Document} from 'mongoose';
+
+export interface iUser {
+  _id?: string,
+  username: string,
+  email: string,
+  password: string,
+  avatar?: string,
+  roles?: string[],
+  active?: boolean,
+  enabled?: boolean,
+  otpCode?: number,
+  lastLogin?: Date,
+  createdAt?: Date,
+  updatedAt?: Date
+}

src/models/UserModel.ts

@@ -0,0 +1,52 @@
+import { Schema, model } from "mongoose";
+import { iUser } from "../interfaces/models/IUserModel";
+
+const UserSchema = new Schema({
+                                username: {
+                                  type: String,
+                                  required: true,
+                                  unique: true,
+                                  index: true,
+                                },
+                                email: {
+                                  type: String,
+                                  required: true,
+                                  unique: true,
+                                  index: true,
+                                },
+                                password: {
+                                  type: String,
+                                  required: true,
+                                },
+                                avatar: {
+                                  type: String,
+                                  required: false,
+                                },
+                                roles: {
+                                  type: Array,
+                                  required: true,
+                                  default: ["ROLE_USER"],
+                                },
+                                active: {
+                                  type: Boolean,
+                                  required: true,
+                                  default: false,
+                                },
+                                enabled: {
+                                  type: Boolean,
+                                  required: true,
+                                  default: false,
+                                },
+                                otpCode: {
+                                  type: Number,
+                                  required: false,
+                                },
+                                lastLogin: {
+                                  type: Date,
+                                  required: false,
+                                },
+                              }, {
+                                timestamps: true,
+                              });
+
+export default model<iUser>("User", UserSchema);

src/repositories/BaseRepository.ts

@@ -0,0 +1,84 @@
+import { Model } from "mongoose";
+
+export default class BaseRepository<T> {
+
+  private readonly entityInstance: Model<T>;
+
+  // Constructor
+  constructor(entity: Model<T>) {
+    this.entityInstance = entity;
+  }
+
+  protected createDocument<I>(documentObject: I): Promise<Document> {
+    return new Promise(async (resolve, reject): Promise<void> => {
+      try {
+        const newDocumentInstance = new this.entityInstance(documentObject);
+        await newDocumentInstance.save();
+        resolve(newDocumentInstance._id);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  // Método encargado de obtener todos los documentos de una entidad
+  protected getAllDocuments() {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const documents = await this.entityInstance.find();
+        resolve(documents);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  // Método encargado de obtener un documento en base a parámetros
+  protected getOneDocumentByParameters(parameters: object): Promise<object> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const document = await this.entityInstance.findOne(parameters);
+        resolve(document);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  // Método encargado de obtener todos los documentos de una entidad en base a parámetros
+  protected getAllDocumentsByParameters(parameters: object = {}) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const documents = await this.entityInstance.find(parameters);
+        resolve(documents);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  // Método encargado de actualizar un documento de una entidad
+  protected updateDocument(documentId: string, document: object = {}) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const documentUpdated = await this.entityInstance.findByIdAndUpdate(documentId, document);
+        resolve(documentUpdated);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  // Método encargado de eliminar un documento de una entidad
+  protected deleteDocument(documentId: string) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await this.entityInstance.findByIdAndDelete(documentId);
+        resolve(true);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+}

src/repositories/UserRepository.ts

@@ -0,0 +1,35 @@
+import { genSaltSync, hashSync } from "bcrypt";
+import { iUser } from "../interfaces/models/IUserModel";
+import BaseRepository from "./BaseRepository";
+
+export default class UserRepository extends BaseRepository<iUser> {
+
+  public countUsers () {
+    return this.getAllDocuments();
+  }
+
+  public async createUserAccount(userData: iUser) {
+    try {
+      let response = {
+        exist: true,
+        user: {}
+      };
+      const salt = genSaltSync(10);
+      userData.password = hashSync(userData.password, salt);
+      userData.otpCode = (userData.hasOwnProperty('otpCode')) ? userData.otpCode : 0;
+      userData.active = (userData.hasOwnProperty('active')) ? userData.active : false;
+      userData.enabled = (userData.hasOwnProperty('enabled')) ? userData.enabled : false;
+      userData.roles = (userData.hasOwnProperty('roles')) ? userData.roles : ["ROLE_USER"];
+      await this.createDocument(userData);
+      const createdUser = await this.getOneDocumentByParameters({email: userData.email});
+      // TODO - Enviar correo electrónico notificando el OTP para activar la cuenta
+      response.exist = false;
+      response.user = createdUser;
+      return response;
+    } catch (e) {
+      console.log(e);
+      throw new Error(e);
+    }
+  }
+
+}