@drax/identity-back 1.1.0 → 1.3.0

package/dist/controllers/UserController.js

@@ -151,7 +151,6 @@ class UserController extends AbstractFastifyController {
                 item.password = undefined;
                 delete item.password;
             }
-            console.log("Paginated users: ", JSON.stringify(paginateResult, null, 4));
             return paginateResult;
         }
         catch (e) {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -28,8 +28,8 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^1.0.0",
-    "@drax/crud-back": "^1.1.0",
+    "@drax/common-back": "^1.1.1",
+    "@drax/crud-back": "^1.3.0",
     "@drax/crud-share": "^1.0.0",
     "@drax/email-back": "^1.0.0",
     "@drax/identity-share": "^1.0.0",
@@ -63,5 +63,5 @@
       "debug": "0"
     }
   },
-  "gitHead": "dbbb8bf014f02236b5a8597c592b0382372eb00f"
+  "gitHead": "45976c72b3d08b4835c3801da839125178ed77a2"
 }

package/src/controllers/UserController.ts

@@ -180,7 +180,7 @@ class UserController extends AbstractFastifyController<IUser, IUserCreate, IUser
                 item.password = undefined
                 delete item.password
             }
-            console.log("Paginated users: ", JSON.stringify(paginateResult,null,4))
+
             return paginateResult
         } catch (e) {
             this.handleError(e, reply)

package/test/endpoints/data/users-data.ts

@@ -0,0 +1,38 @@
+import {IUserCreate} from "@drax/identity-share";
+
+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"
+}
+
+const USERS : IUserCreate[] = [USER1, USER2, USER3]
+
+export {
+    USER1,
+    USER2,
+    USER3,
+    USERS
+}

package/test/{routes → endpoints}/tenant-route.test.ts

@@ -6,33 +6,35 @@ import TestSetup from "../setup/TestSetup";
 describe("Tenant Route Test", function () {
 
     let testSetup = new TestSetup()
-    let FASTIFY_TEST_SERVER: any;
-    let ACCESS_TOKEN: any;
 
     beforeAll(async () => {
         await testSetup.setup()
-        FASTIFY_TEST_SERVER = testSetup.fastifyInstance
-        const {accessToken} = await testSetup.login()
-        ACCESS_TOKEN = accessToken
     })
 
     afterAll(async () => {
-        await testSetup.mongoInMemory.DropAndClose()
+        await testSetup.dropAndClose()
         return
     })
 
     it("Me", async () => {
 
-        const resp = await FASTIFY_TEST_SERVER.inject({
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
+        const resp = await testSetup.fastifyInstance.inject({
             method: 'get',
             url: '/api/auth/me',
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
         let body = resp.json()
         console.log("me", body)
     })
 
     it("Should paginate tenant", async () => {
+
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
         // First, create a few tenants
         const tenantData = [
             {name: "Tenant1"},
@@ -41,18 +43,18 @@ describe("Tenant Route Test", function () {
         ];
 
         for (const data of tenantData) {
-            await FASTIFY_TEST_SERVER.inject({
+            await testSetup.fastifyInstance.inject({
                 method: 'POST',
                 url: '/api/tenants',
                 payload: data,
-                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+                headers: {Authorization: `Bearer ${accessToken}`}
             });
         }
 
-        const resp = await FASTIFY_TEST_SERVER.inject({
+        const resp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: '/api/tenants',
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         })
 
         const result = await resp.json()
@@ -66,15 +68,19 @@ describe("Tenant Route Test", function () {
     })
 
     it("should create a new tenant", async () => {
+
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
         const newTenant = {
             name: "NewTestTenant"
         };
 
-        const resp = await FASTIFY_TEST_SERVER.inject({
+        const resp = await testSetup.fastifyInstance.inject({
             method: 'POST',
             url: '/api/tenants',
             payload: newTenant,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const result = await resp.json();
@@ -83,10 +89,10 @@ describe("Tenant Route Test", function () {
         expect(result._id).toBeDefined();
 
         // Verify tenant was created by fetching it
-        const getResp = await FASTIFY_TEST_SERVER.inject({
+        const getResp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: '/api/tenants/' + result.id,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const getTenant = await getResp.json();
@@ -96,22 +102,25 @@ describe("Tenant Route Test", function () {
 
     it("should update an existing tenant", async () => {
 
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
         const newTenant = {
             name: "ExistTenant"
         };
 
-        const resp = await FASTIFY_TEST_SERVER.inject({
+        const resp = await testSetup.fastifyInstance.inject({
             method: 'POST',
             url: '/api/tenants',
             payload: newTenant,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         // First, get existing tenants to extract the id
-        const getResp = await FASTIFY_TEST_SERVER.inject({
+        const getResp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: '/api/tenants',
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         })
 
         const result = await getResp.json()
@@ -123,11 +132,11 @@ describe("Tenant Route Test", function () {
         }
 
         // Send update request
-        const updateResp = await FASTIFY_TEST_SERVER.inject({
+        const updateResp = await testSetup.fastifyInstance.inject({
             method: 'PUT',
             url: `/api/tenants/${tenantId}`,
             payload: updateData,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         })
 
         // Verify update response
@@ -136,10 +145,10 @@ describe("Tenant Route Test", function () {
         expect(updatedTenant.name).toBe("UpdatedTenantName")
 
         // Verify the tenant was actually updated by fetching it again
-        const verifyResp = await FASTIFY_TEST_SERVER.inject({
+        const verifyResp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: `/api/tenants/${tenantId}`,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         })
 
         const verifiedTenant = await verifyResp.json()
@@ -147,11 +156,11 @@ describe("Tenant Route Test", function () {
         expect(verifiedTenant.name).toBe("UpdatedTenantName")
 
         // Send update inexistingId should return 404
-        const updateRespNotFound = await FASTIFY_TEST_SERVER.inject({
+        const updateRespNotFound = await testSetup.fastifyInstance.inject({
             method: 'PUT',
             url: `/api/tenants/66761bed94d57a42c3277bab`,
             payload: updateData,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         })
 
         // Verify update response
@@ -160,16 +169,20 @@ describe("Tenant Route Test", function () {
     })
 
     it("should delete an existing tenant", async () => {
+
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
         // First create a tenant to be deleted
         const newTenant = {
             name: "TenantToDelete"
         };
 
-        const createResp = await FASTIFY_TEST_SERVER.inject({
+        const createResp = await testSetup.fastifyInstance.inject({
             method: 'POST',
             url: '/api/tenants',
             payload: newTenant,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const createdTenant = await createResp.json();
@@ -177,10 +190,10 @@ describe("Tenant Route Test", function () {
         const tenantId = createdTenant.id;
 
         // Delete the tenant
-        const deleteResp = await FASTIFY_TEST_SERVER.inject({
+        const deleteResp = await testSetup.fastifyInstance.inject({
             method: 'DELETE',
             url: `/api/tenants/${tenantId}`,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         // Verify delete response
@@ -189,10 +202,10 @@ describe("Tenant Route Test", function () {
         expect(deleteResult.deleted).toBe(true);
 
         // Verify the tenant was actually deleted by trying to fetch it
-        const verifyResp = await FASTIFY_TEST_SERVER.inject({
+        const verifyResp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: `/api/tenants/${tenantId}`,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         // Should return 404 or empty response
@@ -200,16 +213,19 @@ describe("Tenant Route Test", function () {
     })
 
     it("should find a tenant by ID", async () => {
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
         // First create a tenant to ensure we have one with known ID
         const newTenant = {
             name: "FindByIdTenant"
         };
 
-        const createResp = await FASTIFY_TEST_SERVER.inject({
+        const createResp = await testSetup.fastifyInstance.inject({
             method: 'POST',
             url: '/api/tenants',
             payload: newTenant,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const createdTenant = await createResp.json();
@@ -217,10 +233,10 @@ describe("Tenant Route Test", function () {
         const tenantId = createdTenant.id;
 
         // Now fetch the tenant by ID
-        const getResp = await FASTIFY_TEST_SERVER.inject({
+        const getResp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: `/api/tenants/${tenantId}`,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         // Verify the response
@@ -231,6 +247,9 @@ describe("Tenant Route Test", function () {
     })
 
     it("should search for tenants ", async () => {
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
         // First, create a few tenants for search testing
         const tenantData = [
             {name: "SearchTenant1"},
@@ -240,23 +259,23 @@ describe("Tenant Route Test", function () {
 
         // Create the test tenants
         for (const data of tenantData) {
-            await FASTIFY_TEST_SERVER.inject({
+            await testSetup.fastifyInstance.inject({
                 method: 'POST',
                 url: '/api/tenants',
                 payload: data,
-                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+                headers: {Authorization: `Bearer ${accessToken}`}
             });
         }
 
         // Test searching with a matching term
-        const searchResp = await FASTIFY_TEST_SERVER.inject({
+        const searchResp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: '/api/tenants/search?search=Search',
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const searchResult = await searchResp.json();
-        console.log("searchResult",searchResult)
+        console.log("searchResult", searchResult)
 
         expect(searchResp.statusCode).toBe(200);
         expect(searchResult.length).toBe(2); // Should find the two tenants with "Search" in their name
@@ -267,6 +286,9 @@ describe("Tenant Route Test", function () {
     })
 
     it("Should get all tenants", async () => {
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
         // First, create a few tenants
         const tenantData = [
             {name: "SearchTenant1"},
@@ -275,23 +297,23 @@ describe("Tenant Route Test", function () {
         ];
 
         for (const data of tenantData) {
-            await FASTIFY_TEST_SERVER.inject({
+            await testSetup.fastifyInstance.inject({
                 method: 'POST',
                 url: '/api/tenants',
                 payload: data,
-                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+                headers: {Authorization: `Bearer ${accessToken}`}
             });
         }
 
         // Get all tenants
-        const resp = await FASTIFY_TEST_SERVER.inject({
+        const resp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: '/api/tenants/all',
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const result = await resp.json();
-        console.log("result",result)
+        console.log("result", result)
 
         expect(resp.statusCode).toBe(200);
 
@@ -303,6 +325,9 @@ describe("Tenant Route Test", function () {
     })
 
     it("should find tenants by specific field-value pair", async () => {
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
         // First create tenants with specific field values for testing
         const tenantData = [
             {name: "FieldTenantA"},
@@ -312,19 +337,19 @@ describe("Tenant Route Test", function () {
 
         // Create the test tenants
         for (const data of tenantData) {
-            await FASTIFY_TEST_SERVER.inject({
+            await testSetup.fastifyInstance.inject({
                 method: 'POST',
                 url: '/api/tenants',
                 payload: data,
-                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+                headers: {Authorization: `Bearer ${accessToken}`}
             });
         }
 
         // Test finding by description field with value "Special"
-        const findByResp = await FASTIFY_TEST_SERVER.inject({
+        const findByResp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: '/api/tenants/find-by/name/FieldTenantA',
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const findByResult = await findByResp.json();
@@ -337,23 +362,26 @@ describe("Tenant Route Test", function () {
     })
 
     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 {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
 
-    const resp = await FASTIFY_TEST_SERVER.inject({
-        method: 'GET',
-        url: `/api/tenants/${nonExistentId}`,
-        headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
-    });
+        // Try to fetch a non-existent tenant
+        const nonExistentId = "123456789012345678901234"; // Valid MongoDB ObjectId that doesn't exist
 
-    // Verify response status code should be 404 Not Found
-    expect(resp.statusCode).toBe(404);
+        const resp = await testSetup.fastifyInstance.inject({
+            method: 'GET',
+            url: `/api/tenants/${nonExistentId}`,
+            headers: {Authorization: `Bearer ${accessToken}`}
+        });
+
+        // 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");
+        const result = await resp.json();
+        expect(result.error).toBeDefined();
+        expect(result.message).toContain("Not found");
 
-});
+    });
 
 
 })

package/test/{routes → endpoints}/user-route.test.ts

@@ -1,69 +1,37 @@
 import {describe, it, beforeAll, afterAll, expect} from "vitest"
 
 import {TestSetup} from "../setup/TestSetup"
-import {IUserCreate} from "@drax/identity-share";
-
-
-
-
-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"
-}
+import {USER1} from "./data/users-data"
+
 
 describe("User Route Test", async function () {
 
     let testSetup = new TestSetup()
-    let FASTIFY_TEST_SERVER: any;
-    let ROOT_USER: any;
-    let ADMIN_ROLE: any;
-    let ACCESS_TOKEN: any;
 
     beforeAll(async () => {
         await testSetup.setup()
-        FASTIFY_TEST_SERVER = testSetup.fastifyInstance
-        ROOT_USER = testSetup.rootUser
-        ADMIN_ROLE = testSetup.adminRole
-        const {accessToken} = await testSetup.login()
-        ACCESS_TOKEN = accessToken
     })
 
     afterAll(async () => {
-        await testSetup.mongoInMemory.DropAndClose()
+        await testSetup.dropAndClose()
         return
     })
 
-    it("Login & Me (express)", async () => {
-        let {accessToken} = await testSetup.login()
+    it("RootLogin", async () => {
+        let {accessToken} = await testSetup.rootUserLogin()
         expect(accessToken).toBeTruthy()
         let user = await testSetup.me(accessToken)
         expect(user.username).toBe(testSetup.rootUserData.username)
     })
 
-    it("Login & Me (detailed)", async () => {
+    it("BasicUserLogin", async () => {
+        let {accessToken} = await testSetup.basicUserLogin()
+        expect(accessToken).toBeTruthy()
+        let user = await testSetup.me(accessToken)
+        expect(user.username).toBe(testSetup.basicUserData.username)
+    })
+
+    it("Login", async () => {
 
         const loginResp = await testSetup.fastifyInstance.inject({
             method: 'POST',
@@ -98,11 +66,14 @@ describe("User Route Test", async function () {
 
     it("should create a new user", async () => {
 
-        const resp = await FASTIFY_TEST_SERVER.inject({
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
+        const resp = await testSetup.fastifyInstance.inject({
             method: 'POST',
             url: '/api/users',
-            payload: {...USER1, ...{role: ADMIN_ROLE._id}},
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            payload: {...USER1, ...{role: testSetup.adminRole._id}},
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const result = await resp.json();
@@ -111,11 +82,11 @@ describe("User Route Test", async function () {
         expect(result._id).toBeDefined();
 
 
-        // Verify tenant was created by fetching it
-        const getResp = await FASTIFY_TEST_SERVER.inject({
+        // Verify user was created by fetching it
+        const getResp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: '/api/users/search?search=' + result._id,
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const items = await getResp.json();
@@ -125,44 +96,35 @@ describe("User Route Test", async function () {
 
 
     it("Should paginate user", async () => {
-        // First, create a few Users
-        const users = [
-            USER1, USER2, USER3
-        ];
-
-        for (const data of users) {
-            await FASTIFY_TEST_SERVER.inject({
-                method: 'POST',
-                url: '/api/users',
-                payload: {...data, ...{role: ADMIN_ROLE._id.toString()}},
-                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
-            });
-        }
-
-        const resp = await FASTIFY_TEST_SERVER.inject({
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
+
+
+        const resp = await testSetup.fastifyInstance.inject({
             method: 'GET',
             url: '/api/users',
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            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(ROOT_USER.name)
+        expect(result.items.length).toBe(3)
+        expect(result.items[0].name).toBe(testSetup.rootUser.name)
         expect(result.page).toBe(1)
         expect(result.limit).toBe(10)
-        expect(result.total).toBe(4)
+        expect(result.total).toBe(3)
 
     })
 
     it("should change my password", async () => {
+        const {accessToken} = await testSetup.basicUserLogin()
+        expect(accessToken).toBeTruthy()
 
-
-        const respPassword = await FASTIFY_TEST_SERVER.inject({
+        const respPassword = await testSetup.fastifyInstance.inject({
             method: 'POST',
             url: '/api/users/password/change',
-            payload: {currentPassword: "root.123", newPassword: "newpass"},
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            payload: {currentPassword: "basic.123", newPassword: "newpass"},
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const resultPassword = await respPassword.json();
@@ -173,13 +135,14 @@ describe("User Route Test", async function () {
     })
 
     it("should change password", async () => {
+        const {accessToken} = await testSetup.rootUserLogin()
+        expect(accessToken).toBeTruthy()
 
-
-        const respPassword = await FASTIFY_TEST_SERVER.inject({
+        const respPassword = await testSetup.fastifyInstance.inject({
             method: 'POST',
-            url: '/api/users/password/change/'+ROOT_USER._id,
+            url: '/api/users/password/change/'+testSetup.rootUser._id,
             payload: {currentPassword: "root.123", newPassword: "newpass"},
-            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+            headers: {Authorization: `Bearer ${accessToken}`}
         });
 
         const resultPassword = await respPassword.json();