@drax/identity-back 0.11.5 → 0.12.2

package/src/services/UserService.ts

@@ -4,7 +4,7 @@ import type {IUserRepository} from "../interfaces/IUserRepository";
 import {ZodError} from "zod";
 import {SecuritySensitiveError, ValidationError, ZodErrorToValidationError} from "@drax/common-back";
 import AuthUtils from "../utils/AuthUtils.js";
-import {createUserSchema, editUserSchema, userBaseSchema} from "../zod/UserZod.js";
+import {UserCreateSchema, UserUpdateSchema, UserBaseSchema} from "../schemas/UserSchema.js";
 import BadCredentialsError from "../errors/BadCredentialsError.js";
 import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 import {AbstractService} from "@drax/crud-back";
@@ -15,7 +15,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
     _repository: IUserRepository
 
     constructor(userRepository: IUserRepository) {
-        super(userRepository, userBaseSchema);
+        super(userRepository, UserBaseSchema);
         this._repository = userRepository;
         console.log("UserService constructor")
     }
@@ -27,7 +27,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
         if (user && user.active && AuthUtils.checkPassword(password, user.password)) {
             //TODO: Generar session
             const session = randomUUID()
-            const accessToken = AuthUtils.generateToken(user.id.toString(), user.username, user.role.id, user.tenant?.id, session)
+            const accessToken = AuthUtils.generateToken(user._id.toString(), user.username, user.role._id, user.tenant?._id, session)
             return {accessToken: accessToken}
         } else {
             throw new BadCredentialsError()
@@ -47,7 +47,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
 
         if (user && user.active) {
             const session = randomUUID()
-            const accessToken = AuthUtils.generateToken(user.id.toString(), user.username, user.role.id, user.tenant?.id, session)
+            const accessToken = AuthUtils.generateToken(user._id.toString(), user.username, user.role._id, user.tenant?._id, session)
             return {accessToken: accessToken}
         } else {
             throw new BadCredentialsError()
@@ -56,7 +56,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
 
 
     async changeUserPassword(userId: string, newPassword: string) {
-        const user = await this.findById(userId)
+        const user = await this._repository.findByIdWithPassword(userId)
         if (user) {
             newPassword = AuthUtils.hashPassword(newPassword)
             await this._repository.changePassword(userId, newPassword)
@@ -68,8 +68,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
 
 
     async changeOwnPassword(userId: string, currentPassword: string, newPassword: string) {
-        const user = await this.findById(userId)
-
+        const user = await this._repository.findByIdWithPassword(userId)
         if (user && user.active) {
 
             if (currentPassword === newPassword) {
@@ -104,7 +103,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
             const recoveryCode = randomUUID()
             const user = await this._repository.findByEmail(email)
             if(user && user.active){
-                await this._repository.updatePartial(user.id, {recoveryCode: recoveryCode})
+                await this._repository.updatePartial(user._id, {recoveryCode: recoveryCode})
                 return recoveryCode
             }else{
                 throw new SecuritySensitiveError()
@@ -122,8 +121,8 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
             console.log("changeUserPasswordByCode user", user)
             if (user && user.active) {
                 newPassword = AuthUtils.hashPassword(newPassword)
-                await this._repository.changePassword(user.id, newPassword)
-                await this._repository.updatePartial(user.id, {recoveryCode: null})
+                await this._repository.changePassword(user._id, newPassword)
+                await this._repository.updatePartial(user._id, {recoveryCode: null})
                 return true
             } else {
                 throw new ValidationError([{field:'recoveryCode', reason: 'validation.notFound'}])
@@ -160,7 +159,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
     async verifyEmail(emailCode: string): Promise<boolean> {
         const user = await this._repository.findByEmailCode(emailCode)
         if (user && user.emailVerified === false) {
-            await this._repository.updatePartial(user.id, {
+            await this._repository.updatePartial(user._id, {
                 emailVerified: true,
                 active: true
             })
@@ -173,7 +172,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
     async verifyPhone(phoneCode: string): Promise<boolean> {
         const user = await this._repository.findByPhoneCode(phoneCode)
         if (user && user.phoneVerified === false) {
-            await this._repository.updatePartial(user.id, {
+            await this._repository.updatePartial(user._id, {
                 phoneVerified: true,
                 active: true
             })
@@ -190,7 +189,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
             userData.password = userData?.password.trim()
             userData.tenant = userData.tenant === "" ? null : userData.tenant
 
-            await createUserSchema.parseAsync(userData)
+            await UserCreateSchema.parseAsync(userData)
 
             userData.password = AuthUtils.hashPassword(userData.password.trim())
 
@@ -212,7 +211,7 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
             delete userData.password
             userData.tenant = userData.tenant === "" ? null : userData.tenant
 
-            await editUserSchema.parseAsync(userData)
+            await UserUpdateSchema.parseAsync(userData)
 
 
             const user: IUser = await this._repository.update(id, userData)
@@ -285,9 +284,9 @@ class UserService extends AbstractService<IUser, IUserCreate, IUserUpdate> {
 
     async paginate({
                        page = 1,
-                       limit = 5,
+                       limit = 10,
                        orderBy = '',
-                       order = false,
+                       order = "asc",
                        search = '',
                        filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {

package/src/setup/CreateOrUpdateRole.ts

@@ -1,7 +1,7 @@
-import type {IRoleBase} from "@drax/identity-share"
+import type {IRoleBase, IRole} from "@drax/identity-share"
 import RoleServiceFactory from "../factory/RoleServiceFactory.js"
 
-async function CreateOrUpdateRole(roleData: IRoleBase) {
+async function CreateOrUpdateRole(roleData: IRoleBase):Promise<IRole> {
     const roleService = RoleServiceFactory()
     const role = await roleService.findByName(roleData.name)
 
@@ -10,7 +10,7 @@ async function CreateOrUpdateRole(roleData: IRoleBase) {
         roleData.childRoles = await Promise.all(roleData.childRoles.map(async (childRole) => {
             const role = await roleService.findByName(childRole)
             if(role){
-                return role.id
+                return role._id.toString()
             }else{
                 return childRole
             }
@@ -18,11 +18,14 @@ async function CreateOrUpdateRole(roleData: IRoleBase) {
     }
 
     if(role){
-        const r = await roleService.systemUpdate(role.id, roleData)
+        console.log("RoleData",roleData)
+        const r = await roleService.systemUpdate(role._id.toString(), roleData)
         console.log("Role Updated. Name: "+ roleData.name)
+        return r
     }else{
         const r = await roleService.create(roleData)
         console.log("Role Created. Name: "+ roleData.name)
+        return r
     }
 }
 

package/src/setup/CreateUserIfNotExist.ts

@@ -1,17 +1,19 @@
 import RoleServiceFactory from "../factory/RoleServiceFactory.js"
 import UserServiceFactory from "../factory/UserServiceFactory.js"
-import {IUserCreate} from "@drax/identity-share";
+import {IUserCreate, IUser} from "@drax/identity-share";
 
-async function CreateUserIfNotExist(userData: IUserCreate) {
+async function CreateUserIfNotExist(userData: IUserCreate): Promise<IUser> {
     const userService = UserServiceFactory()
     const roleService = RoleServiceFactory()
     const user = await userService.findByUsername(userData.username)
     if (user) {
+        return user
     } else {
         const role = await roleService.findByName(userData.role as string)
-        userData.role = role.id as string
+        userData.role = role._id.toString()
         const r = await userService.create(userData)
         console.log("User Created. Username: " + userData.username)
+        return r
     }
 }
 

package/src/setup/RecoveryUserPassword.ts

@@ -3,7 +3,7 @@ import UserServiceFactory from "../factory/UserServiceFactory.js"
 async function RecoveryUserPassword(username:string, password:string) {
     const userService = UserServiceFactory()
     const user = await userService.findByUsername(username)
-    const r = await userService.changeUserPassword(user.id as string, password)
+    const r = await userService.changeUserPassword(user._id as string, password)
     console.log("User password recovered. Username: " + username)
 }
 

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

@@ -4,7 +4,8 @@ const userApiKey = {
   _id: "646a661e44c93567c23d8c22",
   name: "root",
   secret: "123",
-  user: user._id
+  user: user._id,
+  createdBy: user._id
 };
 
 export default userApiKey

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

@@ -1,7 +1,7 @@
 const role = {
-  id: 'b0465ce9-60f8-4ff2-bdcb-214b4bee9135',
+  _id: 'b0465ce9-60f8-4ff2-bdcb-214b4bee9135',
   name: "Admin",
-  permissions: [],
+  permissions: ['create', 'read', 'update', 'delete'],
   childRoles: [],
   readonly: false
 }

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

@@ -1,5 +1,5 @@
 const role = {
-  id: 'b0465ce9-60f8-4ff2-bdcb-214b4bee8545',
+  _id: 'b0465ce9-60f8-4ff2-bdcb-214b4bee8545',
   name: "Operator",
   permissions: [],
   childRoles: [],

package/test/data-obj/tenants/company-sqlite-tenant.ts

@@ -0,0 +1,6 @@
+const tenant = {
+  _id: 'b0465ce9-60f8-4ff2-bdcb-214b4bee8532',
+  name: "Company",
+}
+
+export default tenant

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

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

package/test/initializers/RoleSqliteInitializer.ts

@@ -8,7 +8,7 @@ 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)
+    let role = await roleRespository.findById(roleData._id as UUID)
     if (!role) {
         role = await roleRespository.create(roleData)
     }

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

@@ -1,4 +1,4 @@
-import  {describe,it, before, after} from "node:test"
+import  {describe,it, beforeAll, afterAll} from "vitest"
 import {equal} from "assert";
 import RoleMongoRepository from "../../../src/repository/mongo/RoleMongoRepository";
 import MongoInMemory from "../../db/MongoInMemory";
@@ -9,13 +9,13 @@ describe("RoleRepositoryTest",  function() {
 
     const roleReposirory = new RoleMongoRepository()
 
-    before(async () => {
+    beforeAll(async () => {
         await MongoInMemory.connect()
        // console.log("BEFORE ROLE", MongoInMemory.mongooseStatus, MongoInMemory.serverStatus)
         return
     })
 
-    after(async () => {
+    afterAll(async () => {
         await MongoInMemory.DropAndClose()
         //console.log("AFTER ROLE", MongoInMemory.status, MongoInMemory.serverStatus)
         return

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

@@ -1,4 +1,4 @@
-import {before, after, describe, it, test} from "node:test"
+import {beforeAll, afterAll, describe, it, test} from "vitest"
 import assert, {equal} from "assert";
 import UserApiKeyMongoRepository from "../../../src/repository/mongo/UserApiKeyMongoRepository";
 import MongoInMemory from "../../db/MongoInMemory";
@@ -9,14 +9,14 @@ import type {IDraxPaginateResult} from "@drax/crud-share";
 import {mongoose, ValidationError} from "@drax/common-back";
 
 
-test.describe("UserApiKeyRepositoryTest", function () {
+describe("UserApiKeyRepositoryTest", function () {
 
     let userApiKeyRepository = new UserApiKeyMongoRepository()
     let data
     let adminRole
     let rootUser
 
-    before(async () => {
+    beforeAll(async () => {
         await MongoInMemory.connect()
         adminRole = await RoleMongoInitializer.initAdminRole()
         rootUser = await UserMongoInitializer.initRootUser()
@@ -25,7 +25,7 @@ test.describe("UserApiKeyRepositoryTest", function () {
         return
     })
 
-    after(async () => {
+    afterAll(async () => {
         await MongoInMemory.DropAndClose()
         //console.log("AFTER USER", MongoInMemory.status, MongoInMemory.serverStatus)
         return
@@ -33,6 +33,7 @@ test.describe("UserApiKeyRepositoryTest", function () {
 
     test("Create mongo user apikey successfully", async function () {
         data = (await import("../../data-obj/apikey/root-mongo-user-apikey")).default
+        console.log("Data:",data)
         let userApiKeyCreated = await userApiKeyRepository.create(data)
         equal(userApiKeyCreated.name, data.name)
     })

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

@@ -1,4 +1,4 @@
-import  {before, after, describe, it, test} from "node:test"
+import  {beforeAll, afterAll, describe, test} from "vitest"
 import assert, {equal} from "assert";
 import UserMongoRepository from "../../../src/repository/mongo/UserMongoRepository";
 import MongoInMemory from "../../db/MongoInMemory";
@@ -8,13 +8,13 @@ import type {IDraxPaginateResult} from "@drax/crud-share";
 import {mongoose, ValidationError} from "@drax/common-back";
 
 
-test.describe("UserRepositoryTest", function () {
+describe("UserRepositoryTest", function () {
 
     let userRepository = new UserMongoRepository()
     let adminRole
     let userAdminData
 
-    before(async () => {
+    beforeAll(async () => {
         await MongoInMemory.connect()
         adminRole = await RoleMongoInitializer.initAdminRole()
 
@@ -22,7 +22,7 @@ test.describe("UserRepositoryTest", function () {
         return
     })
 
-    after(async () => {
+    afterAll(async () => {
         await MongoInMemory.DropAndClose()
         //console.log("AFTER USER", MongoInMemory.status, MongoInMemory.serverStatus)
         return

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

@@ -1,4 +1,4 @@
-import  {describe,it, before, after} from "node:test"
+import  {describe,it, beforeAll, afterAll} from "vitest"
 import {equal} from "assert";
 import {IRole} from "../../../../identity-share/src/interfaces/IRole";
 import {IDraxPaginateResult} from "@drax/crud-share";
@@ -7,18 +7,23 @@ import {UUID} from "crypto";
 
 describe("RoleRepositoryTest",  function() {
 
-    const repository = new RoleSqliteRepository("test.db", false)
+    const repository = new RoleSqliteRepository("test.db", true)
 
-    before(async () => {
-        repository.table()
+    beforeAll(async () => {
+        repository.build()
         return
     })
 
-    after(async () => {
-        await repository.deleteAll()
+    afterAll(async () => {
+        //await repository.deleteAll()
         return
     })
 
+    it("Delete All.",  async function() {
+        let r = await repository.deleteAll()
+        equal(r,true)
+    })
+
     it("Create a role successfully.",  async function() {
         let roleData = (await import("../../data-obj/roles/admin-sqlite-role")).default
         let roleCreated: IRole = await repository.create(roleData)
@@ -33,7 +38,7 @@ describe("RoleRepositoryTest",  function() {
 
     it("Find role by ID successfully.",  async function() {
         let roleData = (await import("../../data-obj/roles/admin-sqlite-role")).default
-        let role: IRole = await repository.findById(roleData.id as UUID)
+        let role: IRole = await repository.findById(roleData._id as UUID)
         equal(role.name,roleData.name)
     })
 
@@ -56,13 +61,20 @@ describe("RoleRepositoryTest",  function() {
     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 repository.update(roleData.id as UUID, roleData)
+        let roleUpdated: IRole = await repository.update(roleData._id as UUID, roleData)
         equal(roleUpdated.name,roleData.name)
     })
 
+    it("UpdatePartial a role successfully.",  async function() {
+        let roleData = (await import("../../data-obj/roles/admin-sqlite-role")).default
+       let partial = {name: "AdminUpdatedPartial"}
+        let roleUpdated: IRole = await repository.updatePartial(roleData._id as UUID, partial)
+        equal(roleUpdated.name,'AdminUpdatedPartial')
+    })
+
     it("Delete a role successfully.",  async function() {
         let roleData = (await import("../../data-obj/roles/admin-sqlite-role")).default
-        let roleDeleted: Boolean = await repository.delete(roleData.id as UUID)
+        let roleDeleted: Boolean = await repository.delete(roleData._id as UUID)
         equal(roleDeleted,true)
     })
 

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

@@ -0,0 +1,74 @@
+import  {describe,it, beforeAll, afterAll} from "vitest"
+import {equal} from "assert";
+import {ITenant} from "../../../../identity-share/src/interfaces/ITenant";
+import {IDraxPaginateResult} from "@drax/crud-share";
+import TenantSqliteRepository from "../../../src/repository/sqlite/TenantSqliteRepository";
+import {UUID} from "crypto";
+
+describe("TenantRepositoryTest",  function() {
+
+    const repository = new TenantSqliteRepository("test.db", true)
+
+    beforeAll(async () => {
+        repository.build()
+        return
+    })
+
+    afterAll(async () => {
+        //await repository.deleteAll()
+        return
+    })
+
+    it("Delete All.",  async function() {
+        let r = await repository.deleteAll()
+        equal(r,true)
+    })
+
+    it("Create a tenant successfully.",  async function() {
+        let tenantData = (await import("../../data-obj/tenants/company-sqlite-tenant")).default
+        let tenantCreated: ITenant = await repository.create(tenantData)
+        equal(tenantCreated.name,tenantData.name)
+    })
+
+    it("Create a second tenant successfully.",  async function() {
+        let tenantCreated: ITenant = await repository.create({name: "Company2"  })
+        equal(tenantCreated.name,"Company2")
+    })
+
+
+    it("Find tenant by ID successfully.",  async function() {
+        let tenantData = (await import("../../data-obj/tenants/company-sqlite-tenant")).default
+        let tenant: ITenant = await repository.findById(tenantData._id as UUID)
+        equal(tenant.name,tenantData.name)
+    })
+
+
+    it("Retrieving all tenants successfully.",  async function() {
+        let tenants: ITenant[] = await repository.fetchAll()
+        equal(tenants.length,2)
+    })
+
+    it("Paginate tenants successfully.",  async function() {
+        let paginateTenants: IDraxPaginateResult<ITenant> = await repository.paginate({page: 1, limit: 5})
+        console.log(paginateTenants)
+        equal(paginateTenants.items.length,2)
+        equal(paginateTenants.total,2)
+        equal(paginateTenants.page,1)
+        equal(paginateTenants.limit,5)
+    })
+
+    it("Update a tenant successfully.",  async function() {
+        let tenantData = (await import("../../data-obj/tenants/company-sqlite-tenant")).default
+        tenantData.name = "AdminUpdated"
+        let tenantUpdated: ITenant = await repository.update(tenantData._id as UUID, tenantData)
+        equal(tenantUpdated.name,tenantData.name)
+    })
+
+    it("Delete a tenant successfully.",  async function() {
+        let tenantData = (await import("../../data-obj/tenants/company-sqlite-tenant")).default
+        let tenantDeleted: Boolean = await repository.delete(tenantData._id as UUID)
+        equal(tenantDeleted,true)
+    })
+
+
+})

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

@@ -1,4 +1,4 @@
-import  {before, after, describe, it, test} from "node:test"
+import  {beforeAll, afterAll, describe, it, test} from "vitest"
 import assert, {equal} from "assert";
 import UserSqliteRepository from "../../../src/repository/sqlite/UserSqliteRepository";
 import {IUser} from "../../../../identity-share/src/interfaces/IUser";
@@ -8,24 +8,30 @@ import {ValidationError} from "@drax/common-back";
 import {UUID} from "crypto";
 import RoleSqliteInitializer from "../../initializers/RoleSqliteInitializer";
 
-test.describe("UserRepositoryTest", function () {
+describe("UserRepositoryTest", function () {
 
     let userRepository = new UserSqliteRepository("test.db", false)
     let userAdminData: any
     let adminRole: IRole
 
-    before(async () => {
-        userRepository.table()
+    beforeAll(async () => {
+        userRepository.build()
         adminRole = (await import("../../data-obj/roles/admin-sqlite-role")).default
         adminRole = await RoleSqliteInitializer()
         return
     })
 
-    after(async () => {
-        await userRepository.deleteAll()
+    afterAll(async () => {
+        // await userRepository.deleteAll()
         return
     })
 
+    it("Delete All.",  async function() {
+        let r = await userRepository.deleteAll()
+        equal(r,true)
+    })
+
+
     test("Create sqlite user successfully", async function () {
         userAdminData = (await import("../../data-obj/users/root-sqlite-user")).default
         let userCreated:IUser = await userRepository.create(userAdminData)
@@ -34,7 +40,7 @@ test.describe("UserRepositoryTest", function () {
 
     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)
+        let userFound = await userRepository.findById(userAdminData._id as UUID)
         equal(userFound.username, userAdminData.username)
         //ROLE POPULATED
         let rolefound = userFound.role as IRole
@@ -60,7 +66,7 @@ test.describe("UserRepositoryTest", function () {
 
     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" }
+        let userData = {...userAdminData, _id: '539f51a6-5d40-4ef2-85c4-f480f042f422', email: "asd123@asd123.com" }
 
         await assert.rejects(
             async () => {
@@ -78,7 +84,7 @@ test.describe("UserRepositoryTest", function () {
     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',
+            _id: '539f51a6-5d40-4ef2-85c4-f480f042f422',
             email: "a456@asd567.com",
             username: "rolenotexist",
             role: "notexist"

package/test/routes/data/admin-role.ts

@@ -0,0 +1,10 @@
+import {PermissionService} from "../../../src/services/PermissionService.js"
+
+const role = {
+  name: "Admin",
+  permissions: PermissionService.getPermissions(),
+  childRoles: [],
+  readonly: true
+}
+
+export default role

package/test/routes/data/root-user.ts

@@ -0,0 +1,13 @@
+
+const user = {
+  active: true,
+  groups: [],
+  name: "Root",
+  username:  "root",
+  password: "root.123",
+  email: "root@example.com",
+  phone: "123456789",
+  role: "Admin"
+};
+
+export default user

package/test/routes/helpers/CreateRootUserAndAdminRole.ts

@@ -0,0 +1,17 @@
+import {CreateOrUpdateRole} from "../../../src/setup/CreateOrUpdateRole";
+import {CreateUserIfNotExist} from "../../../src/setup/CreateUserIfNotExist";
+import rootUser from "../data/root-user";
+import adminRole from "../data/admin-role";
+import {IUser, IRole} from "@drax/identity-share";
+
+async function CreateRootUserAndAdminRole(){
+    const role:IRole = await CreateOrUpdateRole(adminRole)
+    const user:IUser = await CreateUserIfNotExist(rootUser)
+    return {user, role}
+}
+
+export default CreateRootUserAndAdminRole
+
+export {
+    CreateRootUserAndAdminRole
+}

package/test/routes/helpers/FastifyTestServerFactory.ts

@@ -0,0 +1,34 @@
+import Fastify from "fastify";
+import {InternalServerError} from "@drax/common-back";
+
+import {
+    jwtMiddleware, rbacMiddleware, apiKeyMiddleware,
+} from '../../../src/index'
+
+
+const FastifyTestServerFactory = () => {
+    const fastify = Fastify()
+    fastify.setErrorHandler((error, request, reply) => {
+        console.error("Error",error)
+        let serverError = new InternalServerError()
+        reply.status(serverError.statusCode).send(serverError.body)
+    },)
+    fastify.setValidatorCompiler(() => () => true)
+
+    fastify.addHook('onRequest', jwtMiddleware)
+    fastify.addHook('onRequest', rbacMiddleware)
+    fastify.addHook('onRequest', apiKeyMiddleware)
+
+
+    // fastify.addHook('preHandler', async (request, reply) => {
+    //     //@ts-ignore
+    //     request.rbac = {assertPermission: () => true, getAuthUser: {username: 'admin', tenantId: ''}};
+    //     //@ts-ignore
+    //     request.authUser = {id:USER._id, username: USER.username, tenantId: '', roleId: USER.role};
+    // });
+
+    return fastify
+}
+
+export default FastifyTestServerFactory
+export {FastifyTestServerFactory}