@drax/identity-back 1.0.0 → 1.1.1

package/dist/models/UserLoginFailModel.js

@@ -15,6 +15,17 @@ UserLoginFailMongoSchema.set('toJSON', { getters: true, virtuals: true });
 UserLoginFailMongoSchema.set('toObject', { getters: true, virtuals: true });
 const MODEL_NAME = 'UserLoginFail';
 const COLLECTION_NAME = 'UserLoginFail';
-const UserLoginFailModel = mongoose.model(MODEL_NAME, UserLoginFailMongoSchema, COLLECTION_NAME);
+let UserLoginFailModel;
+try {
+    UserLoginFailModel = mongoose.model(MODEL_NAME, UserLoginFailMongoSchema, COLLECTION_NAME);
+}
+catch (e) {
+    if (e.name === 'OverwriteModelError') {
+        UserLoginFailModel = mongoose.model(MODEL_NAME);
+    }
+    else {
+        throw e;
+    }
+}
 export { UserLoginFailMongoSchema, UserLoginFailModel };
 export default UserLoginFailModel;

package/dist/models/UserSessionModel.js

@@ -16,6 +16,17 @@ UserSessionMongoSchema.set('toJSON', { getters: true, virtuals: true });
 UserSessionMongoSchema.set('toObject', { getters: true, virtuals: true });
 const MODEL_NAME = 'UserSession';
 const COLLECTION_NAME = 'UserSession';
-const UserSessionModel = mongoose.model(MODEL_NAME, UserSessionMongoSchema, COLLECTION_NAME);
+let UserSessionModel;
+try {
+    UserSessionModel = mongoose.model(MODEL_NAME, UserSessionMongoSchema, COLLECTION_NAME);
+}
+catch (e) {
+    if (e.name === 'OverwriteModelError') {
+        UserSessionModel = mongoose.model(MODEL_NAME);
+    }
+    else {
+        throw e;
+    }
+}
 export { UserSessionMongoSchema, UserSessionModel };
 export default UserSessionModel;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -21,15 +21,15 @@
     "testMongoRepositoryUserApiKey": "node --import tsx --test test/repository/mongo/user-apikey-mongo*",
     "testSqliteRepositoryUser": "node --import tsx --test test/repository/sqlite/user*",
     "testSqliteRepositoryRole": "node --import tsx --test test/repository/sqlite/role*",
-    "testServiceRole": "node --import tsx --test test/service/role*",
-    "testServiceUser": "node --import tsx --test test/service/user*",
-    "testcoverage": "node --import tsx --experimental-test-coverage  test/service/*"
+    "testServiceRole": "node --import tsx --test test/services/role*",
+    "testServiceUser": "node --import tsx --test test/services/user*",
+    "testcoverage": "node --import tsx --experimental-test-coverage  test/services/*"
   },
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^1.0.0",
-    "@drax/crud-back": "^1.0.0",
+    "@drax/common-back": "^1.1.1",
+    "@drax/crud-back": "^1.1.1",
     "@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": "8e60f7548448f339e7e9bb665ceacd3e051ef32e"
+  "gitHead": "cb36d1f5654d6d8f7d10498037f9b87e72a11e42"
 }

package/src/models/UserLoginFailModel.ts

@@ -24,7 +24,20 @@ UserLoginFailMongoSchema.set('toObject', {getters: true, virtuals: true});
 
 const MODEL_NAME = 'UserLoginFail';
 const COLLECTION_NAME = 'UserLoginFail';
-const UserLoginFailModel = mongoose.model<IUserLoginFail, PaginateModel<IUserLoginFail>>(MODEL_NAME, UserLoginFailMongoSchema,COLLECTION_NAME);
+
+let UserLoginFailModel;
+
+try {
+    UserLoginFailModel = mongoose.model<IUserLoginFail, PaginateModel<IUserLoginFail>>(MODEL_NAME, UserLoginFailMongoSchema, COLLECTION_NAME);
+} catch (e) {
+    if (e.name === 'OverwriteModelError') {
+        UserLoginFailModel = mongoose.model<IUserLoginFail, PaginateModel<IUserLoginFail>>(MODEL_NAME);
+    } else {
+        throw e;
+    }
+}
+
+
 
 export {
     UserLoginFailMongoSchema,

package/src/models/UserSessionModel.ts

@@ -26,7 +26,19 @@ UserSessionMongoSchema.set('toObject', {getters: true, virtuals: true});
 
 const MODEL_NAME = 'UserSession';
 const COLLECTION_NAME = 'UserSession';
-const UserSessionModel = mongoose.model<IUserSession, PaginateModel<IUserSession>>(MODEL_NAME, UserSessionMongoSchema,COLLECTION_NAME);
+
+let UserSessionModel;
+
+try {
+    UserSessionModel = mongoose.model<IUserSession, PaginateModel<IUserSession>>(MODEL_NAME, UserSessionMongoSchema,COLLECTION_NAME);
+} catch (e) {
+    if (e.name === 'OverwriteModelError') {
+        UserSessionModel = mongoose.model<IUserSession, PaginateModel<IUserSession>>(MODEL_NAME);
+    } else {
+        throw e;
+    }
+}
+
 
 export {
     UserSessionMongoSchema,

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

@@ -1,32 +1,36 @@
 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 {FastifyTestServerFactory} from './helpers/FastifyTestServerFactory'
+import TestSetup from "../setup/TestSetup";
 
 
 describe("Tenant Route Test", function () {
 
-    let FastifyTestServer = FastifyTestServerFactory()
-    FastifyTestServer.register(TenantRoute)
+    let testSetup = new TestSetup()
+    let FASTIFY_TEST_SERVER: any;
+    let ACCESS_TOKEN: any;
 
     beforeAll(async () => {
-        await MongoInMemory.connect()
-        console.log("BEFORE MOCK", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
-        // const tenantService = TenantServiceFactory()
-        // await tenantService.create({name: "TestTenant"})
-
-
-        return
+        await testSetup.setup()
+        FASTIFY_TEST_SERVER = testSetup.fastifyInstance
+        const {accessToken} = await testSetup.login()
+        ACCESS_TOKEN = accessToken
     })
 
     afterAll(async () => {
-        await MongoInMemory.DropAndClose()
-        console.log("AFTER MOCK", MongoInMemory.status, MongoInMemory.serverStatus)
+        await testSetup.mongoInMemory.DropAndClose()
         return
     })
 
+    it("Me", async () => {
+
+        const resp = await FASTIFY_TEST_SERVER.inject({
+            method: 'get',
+            url: '/api/auth/me',
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
+        });
+        let body = resp.json()
+        console.log("me", body)
+    })
 
     it("Should paginate tenant", async () => {
         // First, create a few tenants
@@ -37,17 +41,18 @@ describe("Tenant Route Test", function () {
         ];
 
         for (const data of tenantData) {
-            await FastifyTestServer.inject({
+            await FASTIFY_TEST_SERVER.inject({
                 method: 'POST',
                 url: '/api/tenants',
-                payload: data
+                payload: data,
+                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
             });
         }
 
-        const resp = await FastifyTestServer.inject({
+        const resp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
             url: '/api/tenants',
-
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         })
 
         const result = await resp.json()
@@ -65,10 +70,11 @@ describe("Tenant Route Test", function () {
             name: "NewTestTenant"
         };
 
-        const resp = await FastifyTestServer.inject({
+        const resp = await FASTIFY_TEST_SERVER.inject({
             method: 'POST',
             url: '/api/tenants',
-            payload: newTenant
+            payload: newTenant,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const result = await resp.json();
@@ -77,9 +83,10 @@ describe("Tenant Route Test", function () {
         expect(result._id).toBeDefined();
 
         // Verify tenant was created by fetching it
-        const getResp = await FastifyTestServer.inject({
+        const getResp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
-            url: '/api/tenants/' + result.id
+            url: '/api/tenants/' + result.id,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const getTenant = await getResp.json();
@@ -93,16 +100,18 @@ describe("Tenant Route Test", function () {
             name: "ExistTenant"
         };
 
-        const resp = await FastifyTestServer.inject({
+        const resp = await FASTIFY_TEST_SERVER.inject({
             method: 'POST',
             url: '/api/tenants',
-            payload: newTenant
+            payload: newTenant,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         // First, get existing tenants to extract the id
-        const getResp = await FastifyTestServer.inject({
+        const getResp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
             url: '/api/tenants',
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         })
 
         const result = await getResp.json()
@@ -114,10 +123,11 @@ describe("Tenant Route Test", function () {
         }
 
         // Send update request
-        const updateResp = await FastifyTestServer.inject({
+        const updateResp = await FASTIFY_TEST_SERVER.inject({
             method: 'PUT',
             url: `/api/tenants/${tenantId}`,
-            payload: updateData
+            payload: updateData,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         })
 
         // Verify update response
@@ -126,9 +136,10 @@ describe("Tenant Route Test", function () {
         expect(updatedTenant.name).toBe("UpdatedTenantName")
 
         // Verify the tenant was actually updated by fetching it again
-        const verifyResp = await FastifyTestServer.inject({
+        const verifyResp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
             url: `/api/tenants/${tenantId}`,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         })
 
         const verifiedTenant = await verifyResp.json()
@@ -136,10 +147,11 @@ describe("Tenant Route Test", function () {
         expect(verifiedTenant.name).toBe("UpdatedTenantName")
 
         // Send update inexistingId should return 404
-        const updateRespNotFound = await FastifyTestServer.inject({
+        const updateRespNotFound = await FASTIFY_TEST_SERVER.inject({
             method: 'PUT',
             url: `/api/tenants/66761bed94d57a42c3277bab`,
-            payload: updateData
+            payload: updateData,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         })
 
         // Verify update response
@@ -153,10 +165,11 @@ describe("Tenant Route Test", function () {
             name: "TenantToDelete"
         };
 
-        const createResp = await FastifyTestServer.inject({
+        const createResp = await FASTIFY_TEST_SERVER.inject({
             method: 'POST',
             url: '/api/tenants',
-            payload: newTenant
+            payload: newTenant,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const createdTenant = await createResp.json();
@@ -164,9 +177,10 @@ describe("Tenant Route Test", function () {
         const tenantId = createdTenant.id;
 
         // Delete the tenant
-        const deleteResp = await FastifyTestServer.inject({
+        const deleteResp = await FASTIFY_TEST_SERVER.inject({
             method: 'DELETE',
-            url: `/api/tenants/${tenantId}`
+            url: `/api/tenants/${tenantId}`,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         // Verify delete response
@@ -175,9 +189,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 FastifyTestServer.inject({
+        const verifyResp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
-            url: `/api/tenants/${tenantId}`
+            url: `/api/tenants/${tenantId}`,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         // Should return 404 or empty response
@@ -190,10 +205,11 @@ describe("Tenant Route Test", function () {
             name: "FindByIdTenant"
         };
 
-        const createResp = await FastifyTestServer.inject({
+        const createResp = await FASTIFY_TEST_SERVER.inject({
             method: 'POST',
             url: '/api/tenants',
-            payload: newTenant
+            payload: newTenant,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const createdTenant = await createResp.json();
@@ -201,9 +217,10 @@ describe("Tenant Route Test", function () {
         const tenantId = createdTenant.id;
 
         // Now fetch the tenant by ID
-        const getResp = await FastifyTestServer.inject({
+        const getResp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
-            url: `/api/tenants/${tenantId}`
+            url: `/api/tenants/${tenantId}`,
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         // Verify the response
@@ -223,17 +240,19 @@ describe("Tenant Route Test", function () {
 
         // Create the test tenants
         for (const data of tenantData) {
-            await FastifyTestServer.inject({
+            await FASTIFY_TEST_SERVER.inject({
                 method: 'POST',
                 url: '/api/tenants',
-                payload: data
+                payload: data,
+                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
             });
         }
 
         // Test searching with a matching term
-        const searchResp = await FastifyTestServer.inject({
+        const searchResp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
             url: '/api/tenants/search?search=Search',
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const searchResult = await searchResp.json();
@@ -256,17 +275,19 @@ describe("Tenant Route Test", function () {
         ];
 
         for (const data of tenantData) {
-            await FastifyTestServer.inject({
+            await FASTIFY_TEST_SERVER.inject({
                 method: 'POST',
                 url: '/api/tenants',
-                payload: data
+                payload: data,
+                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
             });
         }
 
         // Get all tenants
-        const resp = await FastifyTestServer.inject({
+        const resp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
             url: '/api/tenants/all',
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const result = await resp.json();
@@ -291,17 +312,19 @@ describe("Tenant Route Test", function () {
 
         // Create the test tenants
         for (const data of tenantData) {
-            await FastifyTestServer.inject({
+            await FASTIFY_TEST_SERVER.inject({
                 method: 'POST',
                 url: '/api/tenants',
-                payload: data
+                payload: data,
+                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
             });
         }
 
         // Test finding by description field with value "Special"
-        const findByResp = await FastifyTestServer.inject({
+        const findByResp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
             url: '/api/tenants/find-by/name/FieldTenantA',
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const findByResult = await findByResp.json();
@@ -317,9 +340,10 @@ describe("Tenant Route Test", function () {
     // Try to fetch a non-existent tenant
     const nonExistentId = "123456789012345678901234"; // Valid MongoDB ObjectId that doesn't exist
 
-    const resp = await FastifyTestServer.inject({
+    const resp = await FASTIFY_TEST_SERVER.inject({
         method: 'GET',
-        url: `/api/tenants/${nonExistentId}`
+        url: `/api/tenants/${nonExistentId}`,
+        headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
     });
 
     // Verify response status code should be 404 Not Found

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

@@ -1,14 +1,9 @@
 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 {TestSetup} from "../setup/TestSetup"
+import {IUserCreate} from "@drax/identity-share";
 
 
-import {SetupIdentityDrax} from "./helpers/SetupIdentityDrax.js"
-import {FastifyTestServerFactory} from './helpers/FastifyTestServerFactory.js'
-import {IUserCreate} from "@drax/identity-share";
-import {UserRoutes} from "../../src/index.js"
 
 
 const USER1: IUserCreate = {
@@ -41,60 +36,73 @@ const USER3: IUserCreate = {
 
 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;
-    }
+    let testSetup = new TestSetup()
+    let FASTIFY_TEST_SERVER: any;
+    let ROOT_USER: any;
+    let ADMIN_ROLE: any;
+    let ACCESS_TOKEN: any;
 
     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()
+        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 MongoInMemory.DropAndClose()
-        // console.log("AFTER MOCK", MongoInMemory.status, MongoInMemory.serverStatus)
+        await testSetup.mongoInMemory.DropAndClose()
         return
     })
 
-    it("Me", async () => {
-        // console.log("user", adminUser)
-        // console.log("role", roleAdmin)
-        // console.log("accessToken", accessToken)
+    it("Login & Me (express)", async () => {
+        let {accessToken} = await testSetup.login()
+        expect(accessToken).toBeTruthy()
+        let user = await testSetup.me(accessToken)
+        expect(user.username).toBe(testSetup.rootUserData.username)
+    })
+
+    it("Login & Me (detailed)", async () => {
+
+        const loginResp = await testSetup.fastifyInstance.inject({
+            method: 'POST',
+            url: '/api/auth/login',
+            payload: {
+                username: testSetup.rootUserData.username,
+                password: testSetup.rootUserData.password
+            }
+        });
+
+        expect(loginResp.statusCode).toBe(200)
+
+        let loginBody = loginResp.json()
+
+        expect(loginBody.accessToken).toBeTruthy()
+
+        let accessToken = loginBody.accessToken
 
-        const resp = await FastifyTestServer.inject({
+        const resp = await testSetup.fastifyInstance.inject({
             method: 'get',
             url: '/api/auth/me',
             headers: {Authorization: `Bearer ${accessToken}`}
         });
         let body = resp.json()
-        console.log("me", body)
+
+        expect(resp.statusCode).toBe(200)
+        expect(body.name).toBe(testSetup.rootUserData.name)
+
+
     })
 
 
     it("should create a new user", async () => {
 
-        const resp = await FastifyTestServer.inject({
+        const resp = await FASTIFY_TEST_SERVER.inject({
             method: 'POST',
             url: '/api/users',
-            payload: {...USER1, ...{role: roleAdmin._id}},
-            headers: {Authorization: `Bearer ${accessToken}`}
+            payload: {...USER1, ...{role: ADMIN_ROLE._id}},
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const result = await resp.json();
@@ -104,10 +112,10 @@ describe("User Route Test", async function () {
 
 
         // Verify tenant was created by fetching it
-        const getResp = await FastifyTestServer.inject({
+        const getResp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
             url: '/api/users/search?search=' + result._id,
-            headers: {Authorization: `Bearer ${accessToken}`}
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const items = await getResp.json();
@@ -123,24 +131,24 @@ describe("User Route Test", async function () {
         ];
 
         for (const data of users) {
-            await FastifyTestServer.inject({
+            await FASTIFY_TEST_SERVER.inject({
                 method: 'POST',
                 url: '/api/users',
-                payload: {...data, ...{role: roleAdmin._id.toString()}},
-                headers: {Authorization: `Bearer ${accessToken}`}
+                payload: {...data, ...{role: ADMIN_ROLE._id.toString()}},
+                headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
             });
         }
 
-        const resp = await FastifyTestServer.inject({
+        const resp = await FASTIFY_TEST_SERVER.inject({
             method: 'GET',
             url: '/api/users',
-            headers: {Authorization: `Bearer ${accessToken}`}
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         })
 
         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.items[0].name).toBe(ROOT_USER.name)
         expect(result.page).toBe(1)
         expect(result.limit).toBe(10)
         expect(result.total).toBe(4)
@@ -150,11 +158,11 @@ describe("User Route Test", async function () {
     it("should change my password", async () => {
 
 
-        const respPassword = await FastifyTestServer.inject({
+        const respPassword = await FASTIFY_TEST_SERVER.inject({
             method: 'POST',
             url: '/api/users/password/change',
             payload: {currentPassword: "root.123", newPassword: "newpass"},
-            headers: {Authorization: `Bearer ${accessToken}`}
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const resultPassword = await respPassword.json();
@@ -167,11 +175,11 @@ describe("User Route Test", async function () {
     it("should change password", async () => {
 
 
-        const respPassword = await FastifyTestServer.inject({
+        const respPassword = await FASTIFY_TEST_SERVER.inject({
             method: 'POST',
-            url: '/api/users/password/change/'+adminUser._id,
+            url: '/api/users/password/change/'+ROOT_USER._id,
             payload: {currentPassword: "root.123", newPassword: "newpass"},
-            headers: {Authorization: `Bearer ${accessToken}`}
+            headers: {Authorization: `Bearer ${ACCESS_TOKEN}`}
         });
 
         const resultPassword = await respPassword.json();