@drax/identity-back 0.0.9 → 0.0.10

package/src/utils/DbSetupUtils.ts

@@ -0,0 +1,39 @@
+
+enum DbEngine{
+    Sqlite = "sqlite",
+    Mongo = "mongo",
+}
+
+
+class DbSetupUtils{
+
+
+    static getDbEngine() {
+        if (!process.env.DB_ENGINE) {
+            throw new Error("process.env.DB_ENGINE is not defined");
+        }
+        const dbEngine = process.env.DB_ENGINE as DbEngine;
+        if (!Object.values(DbEngine).includes(dbEngine)) {
+            throw new Error("process.env.DB_ENGINE must be one of " + Object.values(DbEngine).join(", "));
+        }
+        return dbEngine;
+    }
+
+    static getDbUri(){
+        switch (DbSetupUtils.getDbEngine()) {
+            case DbEngine.Mongo:
+                return process.env.MONGO_URI;
+            case DbEngine.Sqlite:
+                return process.env.SQLITE_DATABASE;
+            default:
+                throw new Error("process.env.DB_ENGINE must be one of " + Object.values(DbEngine).join(", "));
+        }
+    }
+
+}
+
+
+export {
+    DbEngine,
+    DbSetupUtils
+}

package/src/zod/RoleZod.ts

@@ -0,0 +1,14 @@
+import { object, string } from "zod"
+
+const roleSchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .regex(/^[A-Z]/, "validation.startWithUpperCase"),
+
+
+})
+
+
+export default roleSchema
+
+export {roleSchema}

package/src/zod/UserZod.ts

@@ -0,0 +1,26 @@
+import { object, string } from "zod"
+
+export const userBaseSchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    username: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    email: string({ required_error: "validation.required" })
+        .email("validation.email.invalid"),
+    role: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+
+})
+
+export const createUserSchema = userBaseSchema.extend({
+    password: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .min(8, "validation.password.min8")
+        .max(32, "validation.password.max32"),
+});
+
+
+export const editUserSchema = userBaseSchema.extend({
+
+});
+

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

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

package/test/data-obj/roles/{admin-role.ts → admin-mongo-role.ts}

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

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

@@ -0,0 +1,9 @@
+const role = {
+  id: 'b0465ce9-60f8-4ff2-bdcb-214b4bee9135',
+  name: "Admin",
+  permissions: [],
+  childRoles: [],
+  readonly: false
+}
+
+export default role

package/test/data-obj/roles/operator-sqlite-role.ts

@@ -0,0 +1,9 @@
+const role = {
+  id: 'b0465ce9-60f8-4ff2-bdcb-214b4bee8545',
+  name: "Operator",
+  permissions: [],
+  childRoles: [],
+  readonly: false
+}
+
+export default role

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

@@ -0,0 +1,15 @@
+import {mongoose} from "@drax/common-back"
+
+const user = {
+  _id: "646a661e44c93567c23d8d61",
+  active: true,
+  groups: [],
+  username:  "root",
+  email: "root@example.com",
+  password: "12345678",
+  name: "root",
+  phone: "123456789",
+  role: "646a661e44c93567c23d8d62",
+};
+
+export default user

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

@@ -0,0 +1,16 @@
+import role from "../roles/admin-sqlite-role";
+
+const user = {
+  id: '539f51a6-5d40-4ef2-85c4-c580f042f422',
+  active: false,
+  groups: [],
+  username:  "root",
+  email: "root@example.com",
+  password: "123",
+  name: "root",
+  phone: "123456789",
+  avatar: "asd",
+  role: role.id
+};
+
+export default user

package/test/{initializers → db}/MongoInMemory.ts

@@ -1,11 +1,12 @@
 import {mongoose} from '@drax/common-back';
 import { MongoMemoryServer } from 'mongodb-memory-server';
 
-const mongoServer = await MongoMemoryServer.create();
+let mongoServer
 
 class MongoInMemory{
 
     static async connect(){
+        mongoServer = await MongoMemoryServer.create();
         if(mongoServer.state == "new"){
             await mongoServer.start()
         }

package/test/initializers/RoleMongoInitializer.ts

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

package/test/initializers/RoleSqliteInitializer.ts

@@ -0,0 +1,18 @@
+import RoleService from "../../src/services/RoleService";
+import {IRole} from "../../src/interfaces/IRole";
+import RoleSqliteRepository from "../../src/repository/sqlite/RoleSqliteRepository";
+import {UUID} from "crypto";
+
+
+async function RoleSqliteInitializer(): Promise<IRole> {
+    const roleRespository = new RoleSqliteRepository('test.db', true)
+    let roleData = (await import("../data-obj/roles/admin-sqlite-role")).default
+
+    let role = await roleRespository.findById(roleData.id as UUID)
+    if (!role) {
+        role = await roleRespository.create(roleData)
+    }
+    return role
+}
+
+export default RoleSqliteInitializer

package/test/repository/{role-repository.test.ts → mongo/role-mongo-repository.test.ts}

@@ -1,13 +1,14 @@
 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 RoleMongoRepository from "../../../src/repository/mongo/RoleMongoRepository";
+import MongoInMemory from "../../db/MongoInMemory";
+import {IRole} from "../../../src/interfaces/IRole";
 import {PaginateResult} from "mongoose";
+import {IPaginateResult} from "@drax/common-back";
 
 describe("RoleRepositoryTest",  function() {
 
-    const roleReposirory = new RoleRepository()
+    const roleReposirory = new RoleMongoRepository()
 
     before(async () => {
         await MongoInMemory.connect()
@@ -22,54 +23,43 @@ describe("RoleRepositoryTest",  function() {
     })
 
     it("Create a role successfully.",  async function() {
-        let roleData = (await import("../data-obj/roles/admin-role")).default
+        let roleData = (await import("../../data-obj/roles/admin-mongo-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
+        let roleData = (await import("../../data-obj/roles/admin-mongo-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 roleData = (await import("../../data-obj/roles/admin-mongo-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()
+        let roles: IRole[] = await roleReposirory.fetchAll()
         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)
+        let paginateRoles: IPaginateResult = await roleReposirory.paginate(1,5)
+        equal(paginateRoles.items.length,1)
+        equal(paginateRoles.total,1)
         equal(paginateRoles.page,1)
+        equal(paginateRoles.limit,5)
     })
 
     it("Delete a role successfully.",  async function() {
-        let roleData = (await import("../data-obj/roles/admin-role")).default
+        let roleData = (await import("../../data-obj/roles/admin-mongo-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/mongo/user-mongo-repository.test.ts

@@ -0,0 +1,121 @@
+import  {before, after, describe, it, test} from "node:test"
+import assert, {equal} from "assert";
+import UserMongoRepository from "../../../src/repository/mongo/UserMongoRepository";
+import MongoInMemory from "../../db/MongoInMemory";
+import RoleMongoInitializer from "../../initializers/RoleMongoInitializer";
+import {IUser} from "../../../src/interfaces/IUser";
+import type {IPaginateResult} from "@drax/common-back";
+import {mongoose, ValidationError} from "@drax/common-back";
+
+
+test.describe("UserRepositoryTest", function () {
+
+    let userRepository = new UserMongoRepository()
+    let adminRole
+    let userAdminData
+
+    before(async () => {
+        await MongoInMemory.connect()
+        adminRole = await RoleMongoInitializer.initAdminRole()
+
+        //console.log("BEFORE USER", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
+        return
+    })
+
+    after(async () => {
+        await MongoInMemory.DropAndClose()
+        //console.log("AFTER USER", MongoInMemory.status, MongoInMemory.serverStatus)
+        return
+    })
+
+    test("Create mongo user successfully", async function () {
+        userAdminData = (await import("../../data-obj/users/root-mongo-user")).default
+        let userCreated = await userRepository.create(userAdminData)
+       equal(userCreated.username, userAdminData.username)
+    })
+
+    test("Create mongo user fail same id", async function () {
+        userAdminData = (await import("../../data-obj/users/root-mongo-user")).default
+        let userData = {...userAdminData, email: "asd123@asd123.com", username: "asd123"}
+
+
+        await assert.rejects(
+            async () => {
+                await userRepository.create(userData)
+            },
+            (error) => {
+                assert(error instanceof ValidationError, 'Expected error to be instance of ValidationError');
+                assert.strictEqual(error.errors[0].field, '_id');
+                return true;
+            },
+        );
+    })
+
+    test("Create mongo user fail same username", async function () {
+        userAdminData = (await import("../../data-obj/users/root-mongo-user")).default
+        let userData = {...userAdminData, _id: new mongoose.Types.ObjectId("646a661e44c93567c23d8d69"),email: "asd123@asd123.com" }
+
+
+        await assert.rejects(
+            async () => {
+                await userRepository.create(userData)
+            },
+            (error) => {
+                assert(error instanceof ValidationError, 'Expected error to be instance of ValidationError');
+                assert.strictEqual(error.errors[0].field, 'username');
+                assert.strictEqual(error.errors[0].reason, 'validation.unique');
+                return true;
+            },
+        );
+    })
+
+    test("Create mongo user fail if role doesnt exist", async function () {
+        userAdminData = (await import("../../data-obj/users/root-mongo-user")).default
+        let userData = {...userAdminData,
+            _id: '646a661e44c93567c23d8d56',
+            email: "a456@asd567.com",
+            username: "rolenotexist",
+            role: "646a661e44c93567c23d8d89"
+        }
+
+        await assert.rejects(
+            async () => {
+                await userRepository.create(userData)
+            },
+            (err) => {
+                //console.log("error",err)
+                assert(err instanceof ValidationError, 'Expected error to be instance of ValidationError');
+                assert.strictEqual(err.errors[0].field, 'role');
+                assert.strictEqual(err.errors[0].reason, 'validation.notfound');
+                return true;
+            },
+        );
+    })
+
+    test("Update mongo user successfully.",  async function() {
+        let adminData = (await import("../../data-obj/users/root-mongo-user")).default
+        adminData.name = "AdminUpdated"
+        let userUpdated: IUser = await userRepository.update(adminData._id, adminData)
+        equal(userUpdated.name,userUpdated.name)
+    })
+
+    test("Find mongo user by ID successfully", async function () {
+        let adminData = (await import("../../data-obj/users/root-mongo-user")).default
+        let userFound = await userRepository.findById(adminData._id)
+        equal(userFound.username, userAdminData.username)
+    })
+
+    test("Find mongo user by username successfully", async function () {
+        let adminData = (await import("../../data-obj/users/root-mongo-user")).default
+        let userFound = await userRepository.findByUsername(adminData.username)
+        equal(userFound.username, userAdminData.username)
+    })
+
+
+    test("Paginate mongo users successfully.",  async function() {
+        let paginateUsers: IPaginateResult = await userRepository.paginate()
+        equal(paginateUsers.items.length,1)
+        equal(paginateUsers.total,1)
+        equal(paginateUsers.page,1)
+    })
+})

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

@@ -0,0 +1,70 @@
+import  {describe,it, before, after} from "node:test"
+import {equal} from "assert";
+import {IRole} from "../../../src/interfaces/IRole";
+import {IPaginateResult} from "@drax/common-back";
+import RoleSqliteRepository from "../../../src/repository/sqlite/RoleSqliteRepository";
+import {UUID} from "crypto";
+
+describe("RoleRepositoryTest",  function() {
+
+    const roleReposirory = new RoleSqliteRepository("test.db", false)
+
+    before(async () => {
+        roleReposirory.table()
+        return
+    })
+
+    after(async () => {
+        await roleReposirory.deleteAll()
+        return
+    })
+
+    it("Create a role successfully.",  async function() {
+        let roleData = (await import("../../data-obj/roles/admin-sqlite-role")).default
+        let roleCreated: IRole = await roleReposirory.create(roleData)
+        equal(roleCreated.name,roleData.name)
+    })
+
+    it("Create a second role successfully.",  async function() {
+        let roleData = (await import("../../data-obj/roles/operator-sqlite-role")).default
+        let roleCreated: IRole = await roleReposirory.create(roleData)
+        equal(roleCreated.name,roleData.name)
+    })
+
+    it("Find role by ID successfully.",  async function() {
+        let roleData = (await import("../../data-obj/roles/admin-sqlite-role")).default
+        let role: IRole = await roleReposirory.findById(roleData.id as UUID)
+        equal(role.name,roleData.name)
+    })
+
+
+
+    it("Retrieving all roles successfully.",  async function() {
+        let roles: IRole[] = await roleReposirory.fetchAll()
+        equal(roles.length,2)
+    })
+
+    it("Paginate roles successfully.",  async function() {
+        let paginateRoles: IPaginateResult = await roleReposirory.paginate(1,5)
+        console.log(paginateRoles)
+        equal(paginateRoles.items.length,2)
+        equal(paginateRoles.total,2)
+        equal(paginateRoles.page,1)
+        equal(paginateRoles.limit,5)
+    })
+
+    it("Update a role successfully.",  async function() {
+        let roleData = (await import("../../data-obj/roles/admin-sqlite-role")).default
+        roleData.name = "AdminUpdated"
+        let roleUpdated: IRole = await roleReposirory.update(roleData.id as UUID, roleData)
+        equal(roleUpdated.name,roleData.name)
+    })
+
+    it("Delete a role successfully.",  async function() {
+        let roleData = (await import("../../data-obj/roles/admin-sqlite-role")).default
+        let roleDeleted: Boolean = await roleReposirory.delete(roleData.id as UUID)
+        equal(roleDeleted,true)
+    })
+
+
+})

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

@@ -0,0 +1,126 @@
+import  {before, after, describe, it, test} from "node:test"
+import assert, {equal} from "assert";
+import UserSqliteRepository from "../../../src/repository/sqlite/UserSqliteRepository";
+import {IUser} from "../../../src/interfaces/IUser";
+import {IRole} from "../../../src/interfaces/IRole";
+
+import {ValidationError} from "@drax/common-back";
+import {UUID} from "crypto";
+import RoleSqliteInitializer from "../../initializers/RoleSqliteInitializer";
+
+test.describe("UserRepositoryTest", function () {
+
+    let userRepository = new UserSqliteRepository("test.db", false)
+    let userAdminData: any
+    let adminRole: IRole
+
+    before(async () => {
+        userRepository.table()
+        adminRole = (await import("../../data-obj/roles/admin-sqlite-role")).default
+        adminRole = await RoleSqliteInitializer()
+        return
+    })
+
+    after(async () => {
+        await userRepository.deleteAll()
+        return
+    })
+
+    test("Create sqlite user successfully", async function () {
+        userAdminData = (await import("../../data-obj/users/root-sqlite-user")).default
+        let userCreated:IUser = await userRepository.create(userAdminData)
+       equal(userCreated.username, userAdminData.username)
+    })
+
+    test("Find user by ID successfully", async function () {
+        userAdminData = (await import("../../data-obj/users/root-sqlite-user")).default
+        let userFound = await userRepository.findById(userAdminData.id as UUID)
+        equal(userFound.username, userAdminData.username)
+        //ROLE POPULATED
+        let rolefound = userFound.role as IRole
+        equal(rolefound.name, adminRole.name)
+    })
+
+    test("Create sqlite user fail same id", async function () {
+        userAdminData = (await import("../../data-obj/users/root-sqlite-user")).default
+        let userData = {...userAdminData, email: "asd123@asd123.com", username: "asd123"}
+
+        await assert.rejects(
+            async () => {
+                await userRepository.create(userData)
+            },
+            (err) => {
+                assert(err instanceof ValidationError, 'Expected error to be instance of ValidationError');
+                assert.strictEqual(err.errors[0].field, 'id');
+                assert.strictEqual(err.errors[0].reason, 'validation.unique');
+                return true;
+            },
+        );
+    })
+
+    test("Create sqlite user fail same username", async function () {
+        userAdminData = (await import("../../data-obj/users/root-sqlite-user")).default
+        let userData = {...userAdminData, id: '539f51a6-5d40-4ef2-85c4-f480f042f422', email: "asd123@asd123.com" }
+
+        await assert.rejects(
+            async () => {
+                await userRepository.create(userData)
+            },
+            (err) => {
+                assert(err instanceof ValidationError, 'Expected error to be instance of ValidationError');
+                assert.strictEqual(err.errors[0].field, 'username');
+                assert.strictEqual(err.errors[0].reason, 'validation.unique');
+                return true;
+            },
+        );
+    })
+
+    test("Create sqlite user fail if role doesnt exist", async function () {
+        userAdminData = (await import("../../data-obj/users/root-sqlite-user")).default
+        let userData = {...userAdminData,
+            id: '539f51a6-5d40-4ef2-85c4-f480f042f422',
+            email: "a456@asd567.com",
+            username: "rolenotexist",
+            role: "notexist"
+        }
+
+        await assert.rejects(
+            async () => {
+                await userRepository.create(userData)
+            },
+            (err) => {
+                assert(err instanceof ValidationError, 'Expected error to be instance of ValidationError');
+                assert.strictEqual(err.errors[0].field, 'role');
+                assert.strictEqual(err.errors[0].reason, 'validation.notfound');
+                return true;
+            },
+        );
+    })
+
+    test("Update a user successfully.",  async function() {
+        userAdminData = (await import("../../data-obj/users/root-sqlite-user")).default
+        let userAdminDataUpdated = {...userAdminData, phone: "66666666"}
+        let userUpdated: IUser = await userRepository.update(userAdminDataUpdated.id as UUID, userAdminDataUpdated)
+        equal(userUpdated.phone,userUpdated.phone)
+    })
+
+
+
+    test("Find user by username successfully", async function () {
+        userAdminData = (await import("../../data-obj/users/root-sqlite-user")).default
+        let userFound = await userRepository.findByUsername(userAdminData.username)
+        equal(userFound.username, userAdminData.username)
+        equal(userFound.id, userAdminData.id)
+    })
+
+    test("Paginate users successfully.",  async function() {
+        let paginateUsers = await userRepository.paginate()
+
+        equal(paginateUsers.total,1)
+        equal(paginateUsers.page,1)
+        equal(paginateUsers.limit,5)
+        equal(paginateUsers.items.length,1)
+        equal(paginateUsers.items[0].role.name,adminRole.name)
+    })
+
+})

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

@@ -1,5 +1,5 @@
 import {describe, it, before, after} from "node:test"
-import MongoInMemory from "../initializers/MongoInMemory";
+import MongoInMemory from "../db/MongoInMemory";
 
 
 
@@ -18,8 +18,8 @@ describe("MockTest", function () {
     })
 
 
-    it("should create MOCK", function () {
-        console.log("should create mock")
+    it("should createUser MOCK", function () {
+        console.log("should createUser mock")
 
     })
 })

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

@@ -1,13 +1,13 @@
 import  {describe,it, before, after} from "node:test"
 import assert from "assert";
 import RoleService from "../../src/services/RoleService";
-import MongoInMemory from "../initializers/MongoInMemory";
+import MongoInMemory from "../db/MongoInMemory";
 import {IRole} from "../../src/interfaces/IRole";
-import RoleRepository from "../../src/repository/RoleRepository";
+import RoleMongoRepository from "../../src/repository/mongo/RoleMongoRepository";
 import {IRoleRepository} from "../../src/interfaces/IRoleRepository";
 
 describe("RoleServiceTest",  function() {
-    let roleRepository: IRoleRepository = new RoleRepository()
+    let roleRepository: IRoleRepository = new RoleMongoRepository()
     let roleService = new RoleService(roleRepository)
     before(async () => {
         await MongoInMemory.connect()
@@ -21,8 +21,8 @@ describe("RoleServiceTest",  function() {
         return
     })
 
-    it("should create role",  async function() {
-        let roleData = (await import("../data-obj/roles/admin-role")).default
+    it("should createUser role",  async function() {
+        let roleData = (await import("../data-obj/roles/admin-mongo-role")).default
         let roleCreated: IRole = await roleService.create(roleData)
 
         assert.equal(roleCreated.name,roleData.name)