@drax/identity-back 0.0.3

package/src/utils/AuthUtils.ts

@@ -0,0 +1,51 @@
+import bcryptjs from "bcryptjs";
+import jsonwebtoken, {SignOptions} from "jsonwebtoken";
+
+class AuthUtils{
+
+    static hashPassword(password : string) :string {
+        if (!password) {
+            throw new Error("password must be provided")
+        }
+
+        let salt = bcryptjs.genSaltSync(10);
+        let hashPassword = bcryptjs.hashSync(password, salt);
+        return hashPassword;
+    }
+
+    static checkPassword(password : string, hashPassword : string) {
+        return bcryptjs.compareSync(password, hashPassword);
+    }
+
+    static tokenSignPayload(userId : string, username: string, session : string) {
+        return {
+            id: userId,
+            username: username,
+            session: session
+        };
+    }
+
+    static generateToken(userId : string, username: string, session : string) {
+        const payload = AuthUtils.tokenSignPayload(userId, username, session)
+
+        const JWT_SECRET = process.env.JWT_SECRET ? process.env.JWT_SECRET :'KRgDV3CeR5lVhsFF'
+
+        const options : SignOptions = {
+            expiresIn: process.env.JWT_LOGIN_EXPIRED_IN || '1h',
+            jwtid: userId,
+            algorithm: 'HS256',
+            audience: username,
+            issuer: process.env.ISSUER? process.env.ISSUER : 'drax'
+        }
+
+        let token = jsonwebtoken.sign(
+            payload,
+            JWT_SECRET,
+            options
+        )
+
+        return token
+    }
+}
+
+export default AuthUtils

package/test/data-json/roles/admin-role.json

@@ -0,0 +1,5 @@
+{
+  "_id": "646a661e44c93567c23d8d62",
+  "name": "admin",
+  "permissions": []
+}

package/test/data-json/users/root-user.json

@@ -0,0 +1,7 @@
+{
+  "username": "root",
+  "email": "root@example.com",
+  "password": "123",
+  "name": "root",
+  "role": "646a661e44c93567c23d8d62"
+}

package/test/data-obj/roles/admin-role.ts

@@ -0,0 +1,12 @@
+import {mongoose} from "@drax/common-back"
+import {IRole} from "../../../src/interfaces/IRole"
+
+const role: IRole = {
+  _id: new mongoose.Types.ObjectId("646a661e44c93567c23d8d62"),
+  name: "Admin",
+  permissions: [],
+  childRoles: [],
+  readonly: false
+}
+
+export default role

package/test/data-obj/users/root-user.ts

@@ -0,0 +1,15 @@
+import {mongoose} from "@drax/common-back"
+import {IUser} from "../../../src/interfaces/IUser"
+
+const user: IUser = {
+  _id: new mongoose.Types.ObjectId("646a661e44c93567c23d8d61"),
+  active: false,
+  groups: [],
+  username:  "root",
+  email: "root@example.com",
+  password: "123",
+  name: "root",
+  role: new mongoose.Types.ObjectId("646a661e44c93567c23d8d62")
+}
+
+export default user

package/test/initializers/MongoInMemory.mjs

@@ -0,0 +1,34 @@
+import { mongoose } from '@drax/common-back';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+const mongoServer = await MongoMemoryServer.create();
+class MongoInMemory {
+    static async connect() {
+        if (mongoServer.state == "new") {
+            await mongoServer.start();
+        }
+        if (!mongoose.connection.readyState) {
+            await mongoose.connect(mongoServer.getUri(), { dbName: "verifyMASTER" });
+        }
+        return;
+    }
+    static get mongooseStatus() {
+        return mongoose.connection.readyState;
+    }
+    static get serverStatus() {
+        return mongoServer.state;
+    }
+    static get status() {
+        return mongoose.connection.readyState;
+    }
+    static async disconnect() {
+        await mongoose.disconnect();
+    }
+    static async DropAndClose() {
+        if (mongoServer) {
+            await mongoose.connection.dropDatabase();
+            await mongoose.connection.close();
+            await mongoServer.stop();
+        }
+    }
+}
+export default MongoInMemory;

package/test/initializers/MongoInMemory.ts

@@ -0,0 +1,42 @@
+import {mongoose} from '@drax/common-back';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+
+const mongoServer = await MongoMemoryServer.create();
+
+class MongoInMemory{
+
+    static async connect(){
+        if(mongoServer.state == "new"){
+            await mongoServer.start()
+        }
+        if(!mongoose.connection.readyState){
+            await mongoose.connect(mongoServer.getUri(), { dbName: "verifyMASTER" });
+        }
+        return
+    }
+    static get mongooseStatus(){
+        return mongoose.connection.readyState
+    }
+
+    static get serverStatus(){
+        return mongoServer.state
+    }
+
+    static get status(){
+        return mongoose.connection.readyState
+    }
+
+    static async disconnect(){
+        await mongoose.disconnect();
+    }
+
+    static async DropAndClose(){
+        if (mongoServer) {
+            await mongoose.connection.dropDatabase();
+            await mongoose.connection.close();
+            await mongoServer.stop();
+        }
+    }
+}
+
+export default MongoInMemory

package/test/initializers/RoleInitializer.mjs

@@ -0,0 +1,11 @@
+import RoleService from "../../src/services/RoleService.mjs";
+import RoleRepository from "../../src/repository/RoleRepository.mjs";
+class RoleInitializer {
+    static async initAdminRole() {
+        const roleService = new RoleService(new RoleRepository());
+        let roleData = (await import("../data-obj/roles/admin-role.mjs")).default;
+        let roleCreated = await roleService.create(roleData);
+        return roleCreated;
+    }
+}
+export default RoleInitializer;

package/test/initializers/RoleInitializer.ts

@@ -0,0 +1,15 @@
+import RoleService from "../../src/services/RoleService";
+import {IRole} from "../../src/interfaces/IRole";
+import RoleRepository from "../../src/repository/RoleRepository";
+
+class RoleInitializer{
+
+    static async initAdminRole(): Promise<IRole>{
+        const roleService = new RoleService(new RoleRepository())
+        let roleData = (await import("../data-obj/roles/admin-role")).default
+        let roleCreated = await roleService.create(roleData)
+        return roleCreated
+    }
+}
+
+export default RoleInitializer

package/test/repository/role-repository.test.ts

@@ -0,0 +1,75 @@
+import  {describe,it, before, after} from "node:test"
+import {equal} from "assert";
+import RoleRepository from "../../src/repository/RoleRepository";
+import MongoInMemory from "../initializers/MongoInMemory";
+import {IRole} from "../../src/interfaces/IRole";
+import {PaginateResult} from "mongoose";
+
+describe("RoleRepositoryTest",  function() {
+
+    const roleReposirory = new RoleRepository()
+
+    before(async () => {
+        await MongoInMemory.connect()
+       // console.log("BEFORE ROLE", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
+        return
+    })
+
+    after(async () => {
+        await MongoInMemory.DropAndClose()
+        //console.log("AFTER ROLE", MongoInMemory.status, MongoInMemory.serverStatus)
+        return
+    })
+
+    it("Create a role successfully.",  async function() {
+        let roleData = (await import("../data-obj/roles/admin-role")).default
+        let roleCreated: IRole = await roleReposirory.create(roleData)
+        equal(roleCreated.name,roleData.name)
+    })
+
+    it("Update a role successfully.",  async function() {
+        let roleData = (await import("../data-obj/roles/admin-role")).default
+        roleData.name = "AdminUpdated"
+        let roleUpdated: IRole = await roleReposirory.update(roleData._id, roleData)
+        equal(roleUpdated.name,roleData.name)
+    })
+
+
+
+
+    it("Find role by ID successfully.",  async function() {
+        let roleData = (await import("../data-obj/roles/admin-role")).default
+        let role: IRole = await roleReposirory.findById(roleData._id)
+        equal(role.name,roleData.name)
+    })
+
+    it("Retrieving all roles successfully.",  async function() {
+        let roles: IRole[] = await roleReposirory.fetch()
+        equal(roles.length,1)
+    })
+
+    it("Paginate roles successfully.",  async function() {
+        let paginateRoles: PaginateResult<IRole> = await roleReposirory.paginate()
+        equal(paginateRoles.docs.length,1)
+        equal(paginateRoles.totalDocs,1)
+        equal(paginateRoles.page,1)
+    })
+
+    it("Delete a role successfully.",  async function() {
+        let roleData = (await import("../data-obj/roles/admin-role")).default
+        let roleDeleted: Boolean = await roleReposirory.delete(roleData._id)
+        equal(roleDeleted,true)
+    })
+
+    it("Fail create role when name has two spaces",  async function() {
+        let roleData = (await import("../data-obj/roles/admin-role")).default
+        roleData.name = "Admin  Role"
+        try{
+            let roleCreated: IRole = await roleReposirory.create(roleData)
+            equal("Not error throw it","Error expected")
+        }catch (e) {
+            equal(e.errors['name'].message,"Role name cant contain two spaces")
+        }
+
+    })
+})

package/test/repository/user-repository.test.ts

@@ -0,0 +1,54 @@
+import  {before, after, describe, it} from "node:test"
+import {equal} from "assert";
+import UserRepository from "../../src/repository/UserRepository";
+import MongoInMemory from "../initializers/MongoInMemory";
+import RoleInitializer from "../initializers/RoleInitializer";
+import {IRole} from "../../src/interfaces/IRole";
+import {IUser} from "../../src/interfaces/IUser";
+import {PaginateResult} from "mongoose";
+
+describe("UserRepositoryTest", function () {
+
+    let userRepository = new UserRepository()
+    let adminRole: IRole
+    let userAdminData: IUser
+
+    before(async () => {
+        await MongoInMemory.connect()
+        adminRole = await RoleInitializer.initAdminRole()
+        userAdminData = (await import("../data-obj/users/root-user")).default
+        //console.log("BEFORE USER", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
+        return
+    })
+
+    after(async () => {
+        await MongoInMemory.DropAndClose()
+        //console.log("AFTER USER", MongoInMemory.status, MongoInMemory.serverStatus)
+        return
+    })
+
+    it("Create user successfully", async function () {
+        let userCreated = await userRepository.create(userAdminData)
+       equal(userCreated.username, userAdminData.username)
+    })
+
+    it("Update a user successfully.",  async function() {
+        let adminData = (await import("../data-obj/users/root-user")).default
+        adminData.name = "AdminUpdated"
+        let userUpdated: IUser = await userRepository.update(adminData._id, adminData)
+        equal(userUpdated.name,userUpdated.name)
+    })
+
+    it("Find user by ID successfully", async function () {
+        let userCreated = await userRepository.findById(userAdminData._id)
+        equal(userCreated.username, userAdminData.username)
+    })
+
+    it("Paginate users successfully.",  async function() {
+        let paginateUsers: PaginateResult<IUser> = await userRepository.paginate()
+        //console.log(paginateUsers)
+        equal(paginateUsers.docs.length,1)
+        equal(paginateUsers.totalDocs,1)
+        equal(paginateUsers.page,1)
+    })
+})

package/test/service/mock-service.test.ts

@@ -0,0 +1,25 @@
+import {describe, it, before, after} from "node:test"
+import MongoInMemory from "../initializers/MongoInMemory";
+
+
+
+describe("MockTest", function () {
+
+    before(async () => {
+        await MongoInMemory.connect()
+        console.log("BEFORE MOCK", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
+        return
+    })
+
+    after(async () => {
+        await MongoInMemory.DropAndClose()
+        console.log("AFTER MOCK", MongoInMemory.status, MongoInMemory.serverStatus)
+        return
+    })
+
+
+    it("should create MOCK", function () {
+        console.log("should create mock")
+
+    })
+})

package/test/service/role-service.test.ts

@@ -0,0 +1,30 @@
+import  {describe,it, before, after} from "node:test"
+import assert from "assert";
+import RoleService from "../../src/services/RoleService";
+import MongoInMemory from "../initializers/MongoInMemory";
+import {IRole} from "../../src/interfaces/IRole";
+import RoleRepository from "../../src/repository/RoleRepository";
+import {IRoleRepository} from "../../src/interfaces/IRoleRepository";
+
+describe("RoleServiceTest",  function() {
+    let roleRepository: IRoleRepository = new RoleRepository()
+    let roleService = new RoleService(roleRepository)
+    before(async () => {
+        await MongoInMemory.connect()
+        console.log("BEFORE ROLE", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
+        return
+    })
+
+    after(async () => {
+        await MongoInMemory.DropAndClose()
+        console.log("AFTER ROLE", MongoInMemory.status, MongoInMemory.serverStatus)
+        return
+    })
+
+    it("should create role",  async function() {
+        let roleData = (await import("../data-obj/roles/admin-role")).default
+        let roleCreated: IRole = await roleService.create(roleData)
+
+        assert.equal(roleCreated.name,roleData.name)
+    })
+})

package/test/service/user-service.test.ts

@@ -0,0 +1,44 @@
+import  {before, after, describe, it} from "node:test"
+import assert from "assert";
+import UserService from "../../src/services/UserService";
+import MongoInMemory from "../initializers/MongoInMemory";
+import RoleInitializer from "../initializers/RoleInitializer";
+import {IRole} from "../../src/interfaces/IRole";
+import {IUser} from "../../src/interfaces/IUser";
+import UserRepository from "../../src/repository/UserRepository";
+import {IUserRepository} from "../../src/interfaces/IUserRepository";
+
+describe("UserServiceTest", function () {
+    let userRepository: IUserRepository = new UserRepository()
+    let userService = new UserService(userRepository)
+    let adminRole: IRole
+    let userAdminData: IUser
+
+    before(async () => {
+        await MongoInMemory.connect()
+        adminRole = await RoleInitializer.initAdminRole()
+        userAdminData = (await import("../data-obj/users/root-user")).default
+        console.log("BEFORE USER", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
+        return
+    })
+
+    after(async () => {
+        await MongoInMemory.DropAndClose()
+        console.log("AFTER USER", MongoInMemory.status, MongoInMemory.serverStatus)
+        return
+    })
+
+    it("should create user", async function () {
+
+        let userCreated = await userService.create(userAdminData)
+
+        assert.equal(userCreated.username, userAdminData.username)
+    })
+
+    it("should find one user", async function () {
+        let userCreated = await userService.findById(userAdminData._id)
+
+
+        assert.equal(userCreated.username, userAdminData.username)
+    })
+})

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "declarationDir": "./types"
+  },
+  "exclude": ["test", "types","dist"],
+  "references": [{ "path": "../../common/common-back" }],
+  "ts-node": {
+    "esm": true
+  }
+}