@drax/identity-back 0.11.5 → 0.12.2

package/test/routes/helpers/InitializePermissions.ts

@@ -0,0 +1,23 @@
+import {LoadPermissions,
+    UserPermissions, RolePermissions, TenantPermissions, UserApiKeyPermissions
+} from "../../../src/index.js";
+
+
+function InitializePermissions() {
+
+    //Merge All Permissions
+    const permissions = [
+        ...Object.values(UserPermissions),
+        ...Object.values(RolePermissions),
+        ...Object.values(TenantPermissions),
+        ...Object.values(UserApiKeyPermissions),
+    ]
+
+    //Load All Permissions
+    LoadPermissions(permissions)
+}
+
+export default InitializePermissions
+
+export {InitializePermissions}
+

package/test/routes/helpers/SetupIdentityDrax.ts

@@ -0,0 +1,22 @@
+import { LoadCommonConfigFromEnv} from "@drax/common-back";
+import {LoadIdentityConfigFromEnv} from "@drax/identity-back";
+import InitializePermissions from "./InitializePermissions.js";
+import CreateRootUserAndAdminRole from "./CreateRootUserAndAdminRole.js";
+
+
+async function SetupIdentityDrax(){
+
+    //Load Identity Drax Config from enviroment variables
+    LoadCommonConfigFromEnv()
+    LoadIdentityConfigFromEnv()
+
+    //Setup Permissions
+    InitializePermissions()
+
+    //Create Root User and Admin Role
+    return await CreateRootUserAndAdminRole()
+
+}
+
+export default SetupIdentityDrax
+export {SetupIdentityDrax}

package/test/routes/tenant-route.test.ts

@@ -0,0 +1,336 @@
+import {describe, it, beforeAll, afterAll, expect} from "vitest"
+import MongoInMemory from "../db/MongoInMemory";
+import TenantRoute from "../../src/routes/TenantRoutes";
+
+process.env.DRAX_DB_ENGINE = "mongo"
+import TenantServiceFactory from "../../src/factory/TenantServiceFactory";
+import {FastifyTestServerFactory} from './helpers/FastifyTestServerFactory'
+
+
+describe("Tenant Route Test", function () {
+
+    let FastifyTestServer = FastifyTestServerFactory()
+    FastifyTestServer.register(TenantRoute)
+
+    beforeAll(async () => {
+        await MongoInMemory.connect()
+        console.log("BEFORE MOCK", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
+        // const tenantService = TenantServiceFactory()
+        // await tenantService.create({name: "TestTenant"})
+
+
+        return
+    })
+
+    afterAll(async () => {
+        await MongoInMemory.DropAndClose()
+        console.log("AFTER MOCK", MongoInMemory.status, MongoInMemory.serverStatus)
+        return
+    })
+
+
+    it("Should paginate tenant", async () => {
+        // First, create a few tenants
+        const tenantData = [
+            {name: "Tenant1"},
+            {name: "Tenant2"},
+            {name: "Tenant3"}
+        ];
+
+        for (const data of tenantData) {
+            await FastifyTestServer.inject({
+                method: 'POST',
+                url: '/api/tenants',
+                payload: data
+            });
+        }
+
+        const resp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: '/api/tenants',
+
+        })
+
+        const result = await resp.json()
+        expect(resp.statusCode).toBe(200)
+        expect(result.items.length).toBe(3)
+        expect(result.items[0].name).toBe("Tenant1")
+        expect(result.page).toBe(1)
+        expect(result.limit).toBe(10)
+
+
+    })
+
+    it("should create a new tenant", async () => {
+        const newTenant = {
+            name: "NewTestTenant"
+        };
+
+        const resp = await FastifyTestServer.inject({
+            method: 'POST',
+            url: '/api/tenants',
+            payload: newTenant
+        });
+
+        const result = await resp.json();
+        expect(resp.statusCode).toBe(200);
+        expect(result.name).toBe("NewTestTenant");
+        expect(result._id).toBeDefined();
+
+        // Verify tenant was created by fetching it
+        const getResp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: '/api/tenants/' + result.id
+        });
+
+        const getTenant = await getResp.json();
+        expect(getResp.statusCode).toBe(200);
+        expect(getTenant.name).toBe("NewTestTenant");
+    })
+
+    it("should update an existing tenant", async () => {
+
+        const newTenant = {
+            name: "ExistTenant"
+        };
+
+        const resp = await FastifyTestServer.inject({
+            method: 'POST',
+            url: '/api/tenants',
+            payload: newTenant
+        });
+
+        // First, get existing tenants to extract the id
+        const getResp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: '/api/tenants',
+        })
+
+        const result = await getResp.json()
+        const tenantId = result.items[0].id
+
+        // Prepare update data
+        const updateData = {
+            name: "UpdatedTenantName"
+        }
+
+        // Send update request
+        const updateResp = await FastifyTestServer.inject({
+            method: 'PUT',
+            url: `/api/tenants/${tenantId}`,
+            payload: updateData
+        })
+
+        // Verify update response
+        expect(updateResp.statusCode).toBe(200)
+        const updatedTenant = await updateResp.json()
+        expect(updatedTenant.name).toBe("UpdatedTenantName")
+
+        // Verify the tenant was actually updated by fetching it again
+        const verifyResp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: `/api/tenants/${tenantId}`,
+        })
+
+        const verifiedTenant = await verifyResp.json()
+        expect(verifyResp.statusCode).toBe(200)
+        expect(verifiedTenant.name).toBe("UpdatedTenantName")
+
+        // Send update inexistingId should return 404
+        const updateRespNotFound = await FastifyTestServer.inject({
+            method: 'PUT',
+            url: `/api/tenants/66761bed94d57a42c3277bab`,
+            payload: updateData
+        })
+
+        // Verify update response
+        expect(updateRespNotFound.statusCode).toBe(404)
+
+    })
+
+    it("should delete an existing tenant", async () => {
+        // First create a tenant to be deleted
+        const newTenant = {
+            name: "TenantToDelete"
+        };
+
+        const createResp = await FastifyTestServer.inject({
+            method: 'POST',
+            url: '/api/tenants',
+            payload: newTenant
+        });
+
+        const createdTenant = await createResp.json();
+        expect(createResp.statusCode).toBe(200);
+        const tenantId = createdTenant.id;
+
+        // Delete the tenant
+        const deleteResp = await FastifyTestServer.inject({
+            method: 'DELETE',
+            url: `/api/tenants/${tenantId}`
+        });
+
+        // Verify delete response
+        expect(deleteResp.statusCode).toBe(200);
+        const deleteResult = await deleteResp.json();
+        expect(deleteResult.deleted).toBe(true);
+
+        // Verify the tenant was actually deleted by trying to fetch it
+        const verifyResp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: `/api/tenants/${tenantId}`
+        });
+
+        // Should return 404 or empty response
+        expect(verifyResp.statusCode).toBe(404);
+    })
+
+    it("should find a tenant by ID", async () => {
+        // First create a tenant to ensure we have one with known ID
+        const newTenant = {
+            name: "FindByIdTenant"
+        };
+
+        const createResp = await FastifyTestServer.inject({
+            method: 'POST',
+            url: '/api/tenants',
+            payload: newTenant
+        });
+
+        const createdTenant = await createResp.json();
+        expect(createResp.statusCode).toBe(200);
+        const tenantId = createdTenant.id;
+
+        // Now fetch the tenant by ID
+        const getResp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: `/api/tenants/${tenantId}`
+        });
+
+        // Verify the response
+        expect(getResp.statusCode).toBe(200);
+        const fetchedTenant = await getResp.json();
+        expect(fetchedTenant._id).toBe(tenantId);
+        expect(fetchedTenant.name).toBe("FindByIdTenant");
+    })
+
+    it("should search for tenants ", async () => {
+        // First, create a few tenants for search testing
+        const tenantData = [
+            {name: "SearchTenant1"},
+            {name: "SearchTenant2"},
+            {name: "DifferentTenant"}
+        ];
+
+        // Create the test tenants
+        for (const data of tenantData) {
+            await FastifyTestServer.inject({
+                method: 'POST',
+                url: '/api/tenants',
+                payload: data
+            });
+        }
+
+        // Test searching with a matching term
+        const searchResp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: '/api/tenants/search?search=Search',
+        });
+
+        const searchResult = await searchResp.json();
+        console.log("searchResult",searchResult)
+
+        expect(searchResp.statusCode).toBe(200);
+        expect(searchResult.length).toBe(2); // Should find the two tenants with "Search" in their name
+        expect(searchResult.some(tenant => tenant.name === "SearchTenant1")).toBe(true);
+        expect(searchResult.some(tenant => tenant.name === "SearchTenant2")).toBe(true);
+        expect(searchResult.some(tenant => tenant.name === "DifferentTenant")).toBe(false);
+
+    })
+
+    it("Should get all tenants", async () => {
+        // First, create a few tenants
+        const tenantData = [
+            {name: "SearchTenant1"},
+            {name: "SearchTenant2"},
+            {name: "SearchTenant3"}
+        ];
+
+        for (const data of tenantData) {
+            await FastifyTestServer.inject({
+                method: 'POST',
+                url: '/api/tenants',
+                payload: data
+            });
+        }
+
+        // Get all tenants
+        const resp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: '/api/tenants/all',
+        });
+
+        const result = await resp.json();
+        console.log("result",result)
+
+        expect(resp.statusCode).toBe(200);
+
+        // Should be an array with at least 2 tenants
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBeGreaterThanOrEqual(3);
+
+
+    })
+
+    it("should find tenants by specific field-value pair", async () => {
+        // First create tenants with specific field values for testing
+        const tenantData = [
+            {name: "FieldTenantA"},
+            {name: "FieldTenantB"},
+            {name: "ASD"}
+        ];
+
+        // Create the test tenants
+        for (const data of tenantData) {
+            await FastifyTestServer.inject({
+                method: 'POST',
+                url: '/api/tenants',
+                payload: data
+            });
+        }
+
+        // Test finding by description field with value "Special"
+        const findByResp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: '/api/tenants/find-by/name/FieldTenantA',
+        });
+
+        const findByResult = await findByResp.json();
+        expect(findByResp.statusCode).toBe(200);
+        expect(Array.isArray(findByResult)).toBe(true);
+        expect(findByResult.length).toBe(1); // Should find the two tenants with "Special" description
+        expect(findByResult.some(tenant => tenant.name === "FieldTenantA")).toBe(true);
+        expect(findByResult.some(tenant => tenant.name === "FieldTenantB")).toBe(false);
+        expect(findByResult.some(tenant => tenant.name === "FieldTenantC")).toBe(false);
+    })
+
+    it("should handle error responses correctly when tenant is not found", async () => {
+    // Try to fetch a non-existent tenant
+    const nonExistentId = "123456789012345678901234"; // Valid MongoDB ObjectId that doesn't exist
+
+    const resp = await FastifyTestServer.inject({
+        method: 'GET',
+        url: `/api/tenants/${nonExistentId}`
+    });
+
+    // Verify response status code should be 404 Not Found
+    expect(resp.statusCode).toBe(404);
+
+    const result = await resp.json();
+    expect(result.error).toBeDefined();
+    expect(result.message).toContain("Not found");
+
+});
+
+
+})

package/test/routes/user-route.test.ts

@@ -0,0 +1,186 @@
+import {describe, it, beforeAll, afterAll, expect} from "vitest"
+import MongoInMemory from "../db/MongoInMemory";
+
+process.env.DRAX_DB_ENGINE = "mongo"
+process.env.DRAX_JWT_SECRET = "asdasdasd"
+
+// import {InitializePermissions} from "./helpers/InitializePermissions.js"
+// import {CreateRootUserAndAdminRole} from "./helpers/CreateRootUserAndAdminRole.js"
+import {SetupIdentityDrax} from "./helpers/SetupIdentityDrax.js"
+import {FastifyTestServerFactory} from './helpers/FastifyTestServerFactory.js'
+import {IRoleBase, IUserCreate} from "@drax/identity-share";
+import {UserRoutes, RoleServiceFactory, UserServiceFactory, PermissionService} from "../../src/index.js"
+
+
+const USER1: IUserCreate = {
+    active: true,
+    password: "12345678",
+    phone: "",
+    role: "",
+    name: "John Wick",
+    username: "johnwick",
+    email: "johnwick@example.com"
+}
+const USER2: IUserCreate = {
+    active: true,
+    password: "12345678",
+    phone: "",
+    role: "",
+    name: "John Rambo",
+    username: "rambo",
+    email: "rambo@example.com"
+}
+const USER3: IUserCreate = {
+    active: true,
+    password: "12345678",
+    phone: "",
+    role: "",
+    name: "John Depp",
+    username: "depp",
+    email: "depp@example.com"
+}
+
+describe("User Route Test", async function () {
+
+    let FastifyTestServer;
+    let adminUser, roleAdmin
+    let accessToken;
+
+    async function login() {
+        const resp = await FastifyTestServer.inject({
+            method: 'POST',
+            url: '/api/auth/login',
+            payload: {username: 'root', password: "root.123"}
+        });
+        console.log("login", resp.statusCode)
+        let body = resp.json()
+        accessToken = body.accessToken;
+    }
+
+    beforeAll(async () => {
+        await MongoInMemory.connect()
+        // console.log("BEFORE MOCK", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
+        let {user, role} = await SetupIdentityDrax()
+        adminUser = user
+        roleAdmin = role
+        FastifyTestServer = FastifyTestServerFactory()
+        FastifyTestServer.register(UserRoutes)
+        await login()
+    })
+
+    afterAll(async () => {
+        await MongoInMemory.DropAndClose()
+        // console.log("AFTER MOCK", MongoInMemory.status, MongoInMemory.serverStatus)
+        return
+    })
+
+    it("Me", async () => {
+        // console.log("user", adminUser)
+        // console.log("role", roleAdmin)
+        // console.log("accessToken", accessToken)
+
+        const resp = await FastifyTestServer.inject({
+            method: 'get',
+            url: '/api/auth/me',
+            headers: {Authorization: `Bearer ${accessToken}`}
+        });
+        let body = resp.json()
+        console.log("me", body)
+    })
+
+
+    it("should create a new user", async () => {
+
+        const resp = await FastifyTestServer.inject({
+            method: 'POST',
+            url: '/api/users',
+            payload: {...USER1, ...{role: roleAdmin._id}},
+            headers: {Authorization: `Bearer ${accessToken}`}
+        });
+
+        const result = await resp.json();
+        expect(resp.statusCode).toBe(200);
+        expect(result.name).toBe(USER1.name);
+        expect(result._id).toBeDefined();
+
+
+        // Verify tenant was created by fetching it
+        const getResp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: '/api/users/search?search=' + result._id,
+            headers: {Authorization: `Bearer ${accessToken}`}
+        });
+
+        const items = await getResp.json();
+        expect(getResp.statusCode).toBe(200);
+        expect(items[0].name).toBe(USER1.name);
+    })
+
+
+    it("Should paginate user", async () => {
+        // First, create a few Users
+        const users = [
+            USER1, USER2, USER3
+        ];
+
+        for (const data of users) {
+            await FastifyTestServer.inject({
+                method: 'POST',
+                url: '/api/users',
+                payload: {...data, ...{role: roleAdmin._id.toString()}},
+                headers: {Authorization: `Bearer ${accessToken}`}
+            });
+        }
+
+        const resp = await FastifyTestServer.inject({
+            method: 'GET',
+            url: '/api/users',
+            headers: {Authorization: `Bearer ${accessToken}`}
+        })
+
+        const result = await resp.json()
+        expect(resp.statusCode).toBe(200)
+        expect(result.items.length).toBe(4)
+        expect(result.items[0].name).toBe(adminUser.name)
+        expect(result.page).toBe(1)
+        expect(result.limit).toBe(10)
+        expect(result.total).toBe(4)
+
+    })
+
+    it("should change my password", async () => {
+
+
+        const respPassword = await FastifyTestServer.inject({
+            method: 'POST',
+            url: '/api/users/password/change',
+            payload: {currentPassword: "root.123", newPassword: "newpass"},
+            headers: {Authorization: `Bearer ${accessToken}`}
+        });
+
+        const resultPassword = await respPassword.json();
+        expect(respPassword.statusCode).toBe(200);
+
+        console.log("resultPassword", resultPassword)
+
+    })
+
+    it("should change password", async () => {
+
+
+        const respPassword = await FastifyTestServer.inject({
+            method: 'POST',
+            url: '/api/users/password/change/'+adminUser._id,
+            payload: {currentPassword: "root.123", newPassword: "newpass"},
+            headers: {Authorization: `Bearer ${accessToken}`}
+        });
+
+        const resultPassword = await respPassword.json();
+        expect(respPassword.statusCode).toBe(200);
+
+        console.log("resultPassword", resultPassword)
+
+    })
+
+
+})

package/test/schemas/lab-schema.test.ts

@@ -0,0 +1,110 @@
+import {describe, it, beforeAll, afterAll} from "vitest"
+import {MongooseConector} from "@drax/common-back";
+import {UserSchema} from "../../src/schemas/UserSchema";
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import TenantServiceFactory from "../../src/factory/TenantServiceFactory";
+import UserServiceFactory from "../../src/factory/UserServiceFactory";
+import fastJson from "fast-json-stringify"
+import z from "zod"
+import {TenantModel, TenantMongoSchema} from "../../src/models/TenantModel";
+
+process.env.DRAX_DB_ENGINE = "mongo"
+let mongooseUri = "mongodb://127.0.0.1:27017/drax"
+const mongooseConector = new MongooseConector(mongooseUri)
+
+const tenantService = TenantServiceFactory()
+const userService = UserServiceFactory()
+
+describe("Test Schema", function () {
+
+    beforeAll(async () => {
+
+        await mongooseConector.connect()
+        return
+    })
+
+    afterAll(async () => {
+        await mongooseConector.disconnect()
+    })
+
+    it("Lab Schema", async () => {
+
+        const zSchema = z.object({
+            name: z.string(),
+            tenant: z.object({
+                _id: z.string(),
+                name: z.string()
+            }).optional().nullable()
+        })
+
+        let jsonSchema = zodToJsonSchema(zSchema,{target:'openApi3'})
+        console.log("jsonUserSchema", JSON.stringify(jsonSchema, null,4))
+
+        let row1 = {
+            name: "mock-tenant",
+            lastname:"mock-lastname",
+            tenant: {
+                _id: "667618bfcd0dd6f880b90d82",
+                name: "mock-tenant"
+            }
+        }
+
+        let row2 = {
+            name: "mock-tenant",
+            lastname:"mock-lastname",
+            tenant: {
+                _id: "667618bfcd0dd6f880b90d82",
+                name: "mock-tenant",
+                createdAt: new Date(),
+                updatedAt: new Date()
+            }
+        }
+
+        let row3 = {
+            name: "mock-tenant",
+            lastname:"mock-lastname",
+            tenant: null
+        }
+
+        let row4 = {
+            name: "mock-tenant",
+            lastname:"mock-lastname",
+        }
+
+
+
+        //@ts-ignore
+        const stringify =  fastJson(jsonSchema  )
+
+         const r1 = stringify(row1)
+         console.log("r1",r1)
+        const r2 = stringify(row2)
+        console.log("r2",r2)
+        const r3 = stringify(row3)
+        console.log("r3",r3)
+        const r4 = stringify(row4)
+        console.log("r4",r4)
+
+    })
+
+
+    it("should create MOCK", async () => {
+        console.log("should create mock")
+
+        let jsonUserSchema = zodToJsonSchema(UserSchema)
+        console.log("jsonUserSchema", JSON.stringify(jsonUserSchema, null,4))
+
+
+
+
+        let user = await userService.search('667618bfcd0dd6f880b90d82')
+        console.log("user",user)
+
+        //@ts-ignore
+        const stringify = fastJson(jsonUserSchema)
+        let ruser = stringify(user[0])
+
+        console.log("ruser",ruser)
+
+    })
+})

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

@@ -1,17 +1,17 @@
-import {describe, it, before, after} from "node:test"
+import {describe, it, beforeAll, afterAll} from "vitest"
 import MongoInMemory from "../db/MongoInMemory";
 
 
 
 describe("MockTest", function () {
 
-    before(async () => {
+    beforeAll(async () => {
         await MongoInMemory.connect()
         console.log("BEFORE MOCK", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
         return
     })
 
-    after(async () => {
+    afterAll(async () => {
         await MongoInMemory.DropAndClose()
         console.log("AFTER MOCK", MongoInMemory.status, MongoInMemory.serverStatus)
         return