@drax/identity-back 0.0.21 → 0.0.24

package/src/repository/sqlite/UserSqliteRepository.ts

@@ -1,13 +1,12 @@
-import {IUser, IUserCreate, IUserUpdate} from "../../interfaces/IUser";
+import {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
 import {UUID} from "crypto";
 import {IUserRepository} from "../../interfaces/IUserRepository";
-import type {IPaginateFilter, IPaginateResult} from "@drax/common-back";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
 import { SqliteErrorToValidationError, ValidationError} from "@drax/common-back";
 import RoleSqliteRepository from "./RoleSqliteRepository.js";
 import TenantSqliteRepository from "./TenantSqliteRepository.js";
-import {IID} from "../../interfaces/IID";
 
 
 const userTableSQL: string = `
@@ -81,7 +80,7 @@ class UserSqliteRepository implements IUserRepository {
 
     }
 
-    async update(id: UUID, userData: IUserUpdate): Promise<IUser> {
+    async update(id: string, userData: IUserUpdate): Promise<IUser> {
         try {
             if (!await this.findRoleById(userData.role)) {
                 throw new ValidationError([{field: 'role', reason: 'validation.notfound', value: userData.role}])
@@ -103,7 +102,7 @@ class UserSqliteRepository implements IUserRepository {
         return this.findById(id)
     }
 
-    async delete(id: UUID): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const stmt = this.db.prepare('DELETE FROM users WHERE id = ?');
         stmt.run(id);
         return true
@@ -115,7 +114,7 @@ class UserSqliteRepository implements IUserRepository {
         return true
     }
 
-    async findById(id: UUID): Promise<IUser> {
+    async findById(id: string): Promise<IUser> {
         const user = this.db.prepare('SELECT * FROM users WHERE id = ?').get(id);
         if (!user) {
             return null
@@ -135,7 +134,13 @@ class UserSqliteRepository implements IUserRepository {
         return user
     }
 
-    async paginate(page: number = 1, limit: number = 5, search: string = "", filters:IPaginateFilter[] = []): Promise<IPaginateResult> {
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
 
         const offset = page > 1 ? (page - 1) * limit : 0
 
@@ -186,15 +191,15 @@ class UserSqliteRepository implements IUserRepository {
         }
     }
 
-    async findRoleById(id: IID) {
+    async findRoleById(id: string) {
         return await this.roleRepository.findById(id)
     }
 
-    async findTenantById(id: IID) {
+    async findTenantById(id: string) {
         return await this.tenantRepository.findById(id)
     }
 
-    async changePassword(id: IID, password: string): Promise<boolean> {
+    async changePassword(id: string, password: string): Promise<boolean> {
         const stmt = this.db.prepare(`UPDATE users
                                       SET password = @password
                                       WHERE id = @id `);

package/src/routes/RoleRoutes.ts

@@ -1,9 +1,10 @@
-import {IPaginateResult, ValidationError} from "@drax/common-back";
+import { ValidationError} from "@drax/common-back";
 import RoleServiceFactory from "../factory/RoleServiceFactory.js";
-import {IRole} from "../interfaces/IRole";
+import {IRole} from "@drax/identity-share";
 import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
 import {PermissionService} from "../services/PermissionService.js";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
+import {IDraxPaginateResult} from "@drax/common-share";
 
 
 
@@ -95,14 +96,16 @@ async function RoleRoutes(fastify, options) {
         }
     })
 
-    fastify.get('/api/roles', async (request, reply): Promise<IPaginateResult> => {
+    fastify.get('/api/roles', async (request, reply): Promise<IDraxPaginateResult<IRole>> => {
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewRole)
             const page = request.query.page
             const limit = request.query.limit
+            const orderBy = request.query.orderBy
+            const orderDesc = request.query.orderDesc
             const search = request.query.search
             const roleService = RoleServiceFactory()
-            let paginateResult = await roleService.paginate(page, limit, search)
+            let paginateResult = await roleService.paginate({page, limit, search, orderBy, orderDesc})
             return paginateResult
         } catch (e) {
             console.error(e)

package/src/routes/TenantRoutes.ts

@@ -1,9 +1,9 @@
-import {IPaginateResult, ValidationError} from "@drax/common-back";
+import { ValidationError} from "@drax/common-back";
 import TenantServiceFactory from "../factory/TenantServiceFactory.js";
-import {ITenant} from "../interfaces/ITenant";
+import {ITenant} from "@drax/identity-share";
 import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
-import {PermissionService} from "../services/PermissionService.js";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
+import {IDraxPaginateResult} from "@drax/common-share";
 
 
 
@@ -78,14 +78,16 @@ async function TenantRoutes(fastify, options) {
         }
     })
 
-    fastify.get('/api/tenants', async (request, reply): Promise<IPaginateResult> => {
+    fastify.get('/api/tenants', async (request, reply): Promise<IDraxPaginateResult<ITenant>> => {
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewTenant)
             const page = request.query.page
             const limit = request.query.limit
+            const orderBy = request.query.orderBy
+            const orderDesc = request.query.orderDesc
             const search = request.query.search
             const tenantService = TenantServiceFactory()
-            let paginateResult = await tenantService.paginate(page, limit, search)
+            let paginateResult = await tenantService.paginate({page, limit,orderBy, orderDesc, search})
             return paginateResult
         } catch (e) {
             console.error(e)

package/src/routes/UserRoutes.ts

@@ -1,9 +1,10 @@
 import UserServiceFactory from "../factory/UserServiceFactory.js";
-import {IUser} from "../interfaces/IUser";
-import {IPaginateResult, ValidationError} from "@drax/common-back";
+import {IUser} from "@drax/identity-share";
+import {ValidationError} from "@drax/common-back";
 import {IdentityPermissions} from "../permissions/IdentityPermissions.js";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
 import BadCredentialsError from "../errors/BadCredentialsError.js";
+import {IDraxPaginateResult} from "@drax/common-share";
 
 async function UserRoutes(fastify, options) {
     fastify.post('/api/auth', async (request, reply) => {
@@ -53,19 +54,21 @@ async function UserRoutes(fastify, options) {
 
     })
 
-    fastify.get('/api/users', async (request, reply): Promise<IPaginateResult> => {
+    fastify.get('/api/users', async (request, reply): Promise<IDraxPaginateResult<IUser>> => {
 
         try {
             request.rbac.assertPermission(IdentityPermissions.ViewUser)
             const page = request.query.page
             const limit = request.query.limit
+            const orderBy = request.query.orderBy
+            const orderDesc = request.query.orderDesc
             const search = request.query.search
             const userService = UserServiceFactory()
             const filters = []
             if(request.rbac.getAuthUser.tenantId){
                 filters.push({field: 'tenant', operator: '$eq', value: request.rbac.getAuthUser.tenantId})
             }
-            let paginateResult = await userService.paginate(page, limit, search, filters)
+            let paginateResult = await userService.paginate({page, limit, orderBy, orderDesc, search, filters})
             return paginateResult
         } catch (e) {
             console.log("/api/users",e)
@@ -87,6 +90,9 @@ async function UserRoutes(fastify, options) {
             request.rbac.assertPermission(IdentityPermissions.CreateUser)
             const payload = request.body
             const userService = UserServiceFactory()
+            if(request.rbac.getAuthUser.tenantId){
+                payload.tenant = request.rbac.getAuthUser.tenantId
+            }
             let user = await userService.create(payload)
             return user
         } catch (e) {
@@ -110,6 +116,9 @@ async function UserRoutes(fastify, options) {
             const id = request.params.id
             const payload = request.body
             const userService = UserServiceFactory()
+            if(request.rbac.getAuthUser.tenantId){
+                payload.tenant = request.rbac.getAuthUser.tenantId
+            }
             let user = await userService.update(id, payload)
             return user
         } catch (e) {

package/src/services/RoleService.ts

@@ -1,9 +1,10 @@
-import {IRole} from "../interfaces/IRole";
 import {IRoleRepository} from "../interfaces/IRoleRepository";
-import {IPaginateFilter, IPaginateResult, ValidationError, ZodErrorToValidationError} from "@drax/common-back"
+import { ValidationError, ZodErrorToValidationError} from "@drax/common-back"
 import {roleSchema} from "../zod/RoleZod.js";
 import {ZodError} from "zod";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {IRoleBase, IRole} from "@drax/identity-share";
 
 class RoleService {
 
@@ -14,7 +15,7 @@ class RoleService {
         console.log("RoleService constructor")
     }
 
-    async create(roleData: IRole): Promise<IRole> {
+    async create(roleData: IRoleBase): Promise<IRole> {
         try {
             roleData.name = roleData?.name?.trim()
             await roleSchema.parseAsync(roleData)
@@ -28,7 +29,7 @@ class RoleService {
         }
     }
 
-    async update(id: any, roleData: IRole) {
+    async update(id: string, roleData: IRoleBase) {
         try {
             roleData.name = roleData?.name?.trim()
             await roleSchema.parseAsync(roleData)
@@ -42,13 +43,13 @@ class RoleService {
         }
     }
 
-    async delete(id: any): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
 
         const deletedRole = await this._repository.delete(id);
         return deletedRole;
     }
 
-    async findById(id: any): Promise<IRole | null> {
+    async findById(id: string): Promise<IRole | null> {
         const role: IRole = await this._repository.findById(id);
         return role
     }
@@ -63,8 +64,14 @@ class RoleService {
         return roles
     }
 
-    async paginate(page: number = 1, limit: number = 5, search?:string, filters ?: IPaginateFilter[]): Promise<IPaginateResult> {
-        const pagination = await this._repository.paginate(page, limit, search, filters);
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>>{
+        const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
         return pagination;
     }
 

package/src/services/TenantService.ts

@@ -1,9 +1,9 @@
-import {ITenant} from "../interfaces/ITenant";
 import {ITenantRepository} from "../interfaces/ITenantRepository";
-import {IPaginateFilter, IPaginateResult, ValidationError, ZodErrorToValidationError} from "@drax/common-back"
+import {ValidationError, ZodErrorToValidationError} from "@drax/common-back"
 import {tenantSchema} from "../zod/TenantZod.js";
 import {ZodError} from "zod";
-import UnauthorizedError from "../errors/UnauthorizedError.js";
+import {ITenantBase, ITenant} from "@drax/identity-share";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
 
 class TenantService {
 
@@ -14,7 +14,7 @@ class TenantService {
         console.log("TenantService constructor")
     }
 
-    async create(tenantData: ITenant): Promise<ITenant> {
+    async create(tenantData: ITenantBase): Promise<ITenant> {
         try {
             tenantData.name = tenantData?.name?.trim()
             await tenantSchema.parseAsync(tenantData)
@@ -28,7 +28,7 @@ class TenantService {
         }
     }
 
-    async update(id: any, tenantData: ITenant) {
+    async update(id: string, tenantData: ITenantBase) {
         try {
             tenantData.name = tenantData?.name?.trim()
             await tenantSchema.parseAsync(tenantData)
@@ -42,13 +42,13 @@ class TenantService {
         }
     }
 
-    async delete(id: any): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const currentTenant = await this.findById(id)
         const deletedTenant = await this._repository.delete(id);
         return deletedTenant;
     }
 
-    async findById(id: any): Promise<ITenant | null> {
+    async findById(id: string): Promise<ITenant | null> {
         const tenant: ITenant = await this._repository.findById(id);
         return tenant
     }
@@ -63,8 +63,14 @@ class TenantService {
         return tenants
     }
 
-    async paginate(page: number = 1, limit: number = 5, search?:string, filters ?: IPaginateFilter[]): Promise<IPaginateResult> {
-        const pagination = await this._repository.paginate(page, limit, search, filters);
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>>{
+        const pagination = await this._repository.paginate({page, limit, orderBy, orderDesc, search, filters});
         return pagination;
     }
 

package/src/services/UserService.ts

@@ -1,11 +1,11 @@
-import type {IUser, IUserCreate, IUserUpdate} from "../interfaces/IUser";
+import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
 import type {IUserRepository} from "../interfaces/IUserRepository";
-import type {IPaginateFilter, IPaginateResult} from "@drax/common-back"
 import {ZodError} from "zod";
 import {ValidationError, ZodErrorToValidationError} from "@drax/common-back";
 import AuthUtils from "../utils/AuthUtils.js";
 import {createUserSchema, editUserSchema,} from "../zod/UserZod.js";
 import BadCredentialsError from "../errors/BadCredentialsError.js";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
 
 class UserService {
 
@@ -64,6 +64,7 @@ class UserService {
             userData.name = userData?.name?.trim()
             userData.username = userData.username.trim()
             userData.password = userData.password.trim()
+            userData.tenant = userData.tenant === "" ? null : userData.tenant
 
             await createUserSchema.parseAsync(userData)
 
@@ -81,11 +82,12 @@ class UserService {
 
     }
 
-    async update(id: any, userData: IUserUpdate) {
+    async update(id: string, userData: IUserUpdate) {
         try{
         userData.name = userData.name.trim()
         userData.username = userData.username.trim()
         delete userData.password
+        userData.tenant = userData.tenant === "" ? null : userData.tenant
 
         await editUserSchema.parseAsync(userData)
 
@@ -100,12 +102,12 @@ class UserService {
         }
     }
 
-    async delete(id: any): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const deletedRole: boolean = await this._repository.delete(id);
         return deletedRole;
     }
 
-    async findById(id: any): Promise<IUser> {
+    async findById(id: string): Promise<IUser> {
         const user: IUser = await this._repository.findById(id);
         return user
     }
@@ -115,9 +117,15 @@ class UserService {
         return user
     }
 
-    async paginate( page : number = 1, limit : number = 10, search?: string, filters ?: IPaginateFilter[]): Promise<IPaginateResult> {
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>>{
 
-        const pagination = await this._repository.paginate( page, limit, search, filters);
+        const pagination = await this._repository.paginate( {page, limit, orderBy, orderDesc, search, filters});
         return pagination;
     }
 }

package/src/setup/CreateOrUpdateRole.ts

@@ -1,7 +1,7 @@
-import type {IRole} from "../interfaces/IRole"
+import type {IRoleBase} from "@drax/identity-share"
 import RoleServiceFactory from "../factory/RoleServiceFactory.js"
 
-async function CreateOrUpdateRole(roleData: IRole) {
+async function CreateOrUpdateRole(roleData: IRoleBase) {
     const roleService = RoleServiceFactory()
     const role = await roleService.findByName(roleData.name)
     if(role){

package/src/setup/CreateUserIfNotExist.ts

@@ -1,6 +1,6 @@
 import RoleServiceFactory from "../factory/RoleServiceFactory.js"
 import UserServiceFactory from "../factory/UserServiceFactory.js"
-import {IUserCreate} from "../interfaces/IUser";
+import {IUserCreate} from "@drax/identity-share";
 
 async function CreateUserIfNotExist(userData: IUserCreate) {
     const userService = UserServiceFactory()

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

@@ -1,5 +1,5 @@
 import {mongoose} from "@drax/common-back"
-import {IRole} from "../../../src/interfaces/IRole"
+import {IRole} from "../../../../identity-share/src/interfaces/IRole"
 
 
 const role = {

package/test/initializers/RoleMongoInitializer.ts

@@ -1,5 +1,5 @@
 import RoleService from "../../src/services/RoleService";
-import {IRole} from "../../src/interfaces/IRole";
+import {IRole} from "../../../identity-share/src/interfaces/IRole";
 import RoleMongoRepository from "../../src/repository/mongo/RoleMongoRepository";
 
 class RoleMongoInitializer {

package/test/initializers/RoleSqliteInitializer.ts

@@ -1,5 +1,5 @@
 import RoleService from "../../src/services/RoleService";
-import {IRole} from "../../src/interfaces/IRole";
+import {IRole} from "../../../identity-share/src/interfaces/IRole";
 import RoleSqliteRepository from "../../src/repository/sqlite/RoleSqliteRepository";
 import {UUID} from "crypto";
 

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

@@ -2,7 +2,7 @@ import  {describe,it, before, after} from "node:test"
 import {equal} from "assert";
 import RoleMongoRepository from "../../../src/repository/mongo/RoleMongoRepository";
 import MongoInMemory from "../../db/MongoInMemory";
-import {IRole} from "../../../src/interfaces/IRole";
+import {IRole} from "../../../../identity-share/src/interfaces/IRole";
 import {PaginateResult} from "mongoose";
 import {IPaginateResult} from "@drax/common-back";
 

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

@@ -3,7 +3,7 @@ import assert, {equal} from "assert";
 import UserMongoRepository from "../../../src/repository/mongo/UserMongoRepository";
 import MongoInMemory from "../../db/MongoInMemory";
 import RoleMongoInitializer from "../../initializers/RoleMongoInitializer";
-import {IUser} from "../../../src/interfaces/IUser";
+import {IUser} from "../../../../identity-share/src/interfaces/IUser";
 import type {IPaginateResult} from "@drax/common-back";
 import {mongoose, ValidationError} from "@drax/common-back";
 

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

@@ -1,6 +1,6 @@
 import  {describe,it, before, after} from "node:test"
 import {equal} from "assert";
-import {IRole} from "../../../src/interfaces/IRole";
+import {IRole} from "../../../../identity-share/src/interfaces/IRole";
 import {IPaginateResult} from "@drax/common-back";
 import RoleSqliteRepository from "../../../src/repository/sqlite/RoleSqliteRepository";
 import {UUID} from "crypto";

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

@@ -1,8 +1,8 @@
 import  {before, after, describe, it, test} from "node:test"
 import assert, {equal} from "assert";
 import UserSqliteRepository from "../../../src/repository/sqlite/UserSqliteRepository";
-import {IUser} from "../../../src/interfaces/IUser";
-import {IRole} from "../../../src/interfaces/IRole";
+import {IUser} from "../../../../identity-share/src/interfaces/IUser";
+import {IRole} from "../../../../identity-share/src/interfaces/IRole";
 
 import {ValidationError} from "@drax/common-back";
 import {UUID} from "crypto";

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

@@ -18,8 +18,8 @@ describe("MockTest", function () {
     })
 
 
-    it("should createUser MOCK", function () {
-        console.log("should createUser mock")
+    it("should create MOCK", function () {
+        console.log("should create mock")
 
     })
 })

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

@@ -2,7 +2,7 @@ import  {describe,it, before, after} from "node:test"
 import assert from "assert";
 import RoleService from "../../src/services/RoleService";
 import MongoInMemory from "../db/MongoInMemory";
-import {IRole} from "../../src/interfaces/IRole";
+import {IRole} from "../../../identity-share/src/interfaces/IRole";
 import RoleMongoRepository from "../../src/repository/mongo/RoleMongoRepository";
 import {IRoleRepository} from "../../src/interfaces/IRoleRepository";
 
@@ -21,7 +21,7 @@ describe("RoleServiceTest",  function() {
         return
     })
 
-    it("should createUser role",  async function() {
+    it("should create role",  async function() {
         let roleData = (await import("../data-obj/roles/admin-mongo-role")).default
         let roleCreated: IRole = await roleService.create(roleData)
 

package/test/service/user-service.test.ts

@@ -3,7 +3,7 @@ import assert from "assert";
 import UserService from "../../src/services/UserService";
 import MongoInMemory from "../db/MongoInMemory";
 import RoleMongoInitializer from "../initializers/RoleMongoInitializer";
-import {IRole} from "../../src/interfaces/IRole";
+import {IRole} from "../../../identity-share/src/interfaces/IRole";
 import UserMongoRepository from "../../src/repository/mongo/UserMongoRepository";
 import {IUserRepository} from "../../src/interfaces/IUserRepository";
 import {ValidationError} from "@drax/common-back";
@@ -28,7 +28,7 @@ describe("UserServiceTest", function () {
         return
     })
 
-    it("should createUser user", async function () {
+    it("should create user", async function () {
         const user = {...userAdminData}
         let userCreated = await userService.create(user)
         assert.equal(userCreated.username, userAdminData.username)
@@ -49,7 +49,7 @@ describe("UserServiceTest", function () {
         assert.equal(passwordChangedResult, true)
     })
 
-    it("should fail createUser user with short password", async function () {
+    it("should fail create user with short password", async function () {
         let userData = {...userAdminData, password: "123"}
         await assert.rejects(
             async () => {