@drax/identity-back 0.0.22 → 0.0.25

package/src/rbac/Rbac.ts

@@ -1,5 +1,4 @@
-import {IRole} from "../interfaces/IRole";
-import {IJwtUser} from "../interfaces/IJwtUser";
+import {IJwtUser, IRole} from "@drax/identity-share";
 import UnauthorizedError from "../errors/UnauthorizedError.js";
 
 class Rbac{

package/src/repository/mongo/RoleMongoRepository.ts

@@ -1,30 +1,31 @@
 import {RoleModel} from "../../models/RoleModel.js";
-import {IRole} from '../../interfaces/IRole'
 import {IRoleRepository} from '../../interfaces/IRoleRepository'
-import {IPaginateFilter, IPaginateResult, mongoose} from "@drax/common-back";
+import { mongoose} from "@drax/common-back";
 import {FilterQuery, PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {IRoleBase, IRole} from "@drax/identity-share";
 
 class RoleMongoRepository implements IRoleRepository{
 
-    async create(roleData: IRole): Promise<IRole> {
+    async create(roleData: IRoleBase): Promise<IRole> {
         const role : mongoose.HydratedDocument<IRole> = new RoleModel(roleData)
         await role.save()
         await role.populate('childRoles')
         return role
     }
 
-    async update(id: mongoose.Types.ObjectId | string, roleData: IRole): Promise<IRole> {
+    async update(id: string, roleData: IRoleBase): Promise<IRole> {
         const role : mongoose.HydratedDocument<IRole> = await RoleModel.findOneAndUpdate({_id: id}, roleData, {new: true}).populate('childRoles').exec()
         return role
     }
 
-    async delete(id: mongoose.Types.ObjectId): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const result : DeleteResult = await RoleModel.deleteOne({_id: id}).exec()
         return result.deletedCount == 1
     }
 
-    async findById(id: mongoose.Types.ObjectId): Promise<IRole | null>{
+    async findById(id: string): Promise<IRole | null>{
         const role: mongoose.HydratedDocument<IRole> | null = await RoleModel.findById(id).populate('childRoles').exec()
         return role
     }
@@ -39,8 +40,13 @@ class RoleMongoRepository implements IRoleRepository{
         return roles
     }
 
-    async paginate(page:number = 1, limit:number = 5, search:string): Promise<IPaginateResult>{
-
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
         const query = {}
 
         if(search){

package/src/repository/mongo/TenantMongoRepository.ts

@@ -1,29 +1,30 @@
 import {TenantModel} from "../../models/TenantModel.js";
-import {ITenant} from '../../interfaces/ITenant'
 import {ITenantRepository} from '../../interfaces/ITenantRepository'
-import {IPaginateFilter, IPaginateResult, mongoose} from "@drax/common-back";
+import { mongoose} from "@drax/common-back";
 import {FilterQuery, PaginateOptions, PaginateResult} from "mongoose";
 import {DeleteResult} from "mongodb";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {ITenant, ITenantBase} from "@drax/identity-share";
 
 class TenantMongoRepository implements ITenantRepository{
 
-    async create(tenantData: ITenant): Promise<ITenant> {
+    async create(tenantData: ITenantBase): Promise<ITenant> {
         const tenant : mongoose.HydratedDocument<ITenant> = new TenantModel(tenantData)
         await tenant.save()
         return tenant
     }
 
-    async update(id: mongoose.Types.ObjectId | string, tenantData: ITenant): Promise<ITenant> {
+    async update(id: string, tenantData: ITenantBase): Promise<ITenant> {
         const tenant : mongoose.HydratedDocument<ITenant> = await TenantModel.findOneAndUpdate({_id: id}, tenantData, {new: true}).exec()
         return tenant
     }
 
-    async delete(id: mongoose.Types.ObjectId): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const result : DeleteResult = await TenantModel.deleteOne({_id:id}).exec()
         return result.deletedCount == 1
     }
 
-    async findById(id: mongoose.Types.ObjectId): Promise<ITenant | null>{
+    async findById(id: string): Promise<ITenant | null>{
         const tenant: mongoose.HydratedDocument<ITenant> | null = await TenantModel.findById(id).exec()
         return tenant
     }
@@ -38,7 +39,13 @@ class TenantMongoRepository implements ITenantRepository{
         return tenants
     }
 
-    async paginate(page:number = 1, limit:number = 5, search:string): Promise<IPaginateResult>{
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
 
         const query = {}
 

package/src/repository/mongo/UserMongoRepository.ts

@@ -1,11 +1,11 @@
 import {UserModel} from "../../models/UserModel.js";
 import {mongoose, MongooseErrorToValidationError, MongoServerErrorToValidationError, ValidationError} from "@drax/common-back"
-import type {IPaginateFilter, IPaginateResult} from "@drax/common-back"
-import type {IUser, IUserCreate, IUserUpdate} from "../../interfaces/IUser";
+import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
 import {DeleteResult, MongoServerError} from "mongodb";
 import type {IUserRepository} from "../../interfaces/IUserRepository";
 import {PaginateResult} from "mongoose";
 import RoleMongoRepository from "./RoleMongoRepository.js";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
 
 class UserMongoRepository implements IUserRepository {
     private roleRepository: RoleMongoRepository;
@@ -18,7 +18,7 @@ class UserMongoRepository implements IUserRepository {
     async create(userData: IUserCreate): Promise<IUser> {
         try{
 
-            if(!await this.roleRepository.findById(userData.role as mongoose.Types.ObjectId)){
+            if(!await this.roleRepository.findById(userData.role)){
                 throw new ValidationError([{field: 'role', reason: 'validation.notfound', value: userData.role}])
             }
 
@@ -35,7 +35,7 @@ class UserMongoRepository implements IUserRepository {
 
     }
 
-    async update(id: mongoose.Types.ObjectId, userData: IUserUpdate): Promise<IUser> {
+    async update(id: string, userData: IUserUpdate): Promise<IUser> {
         try{
         const user: mongoose.HydratedDocument<IUser> = await UserModel.findOneAndUpdate({_id: id}, userData, {new: true}).populate(['role','tenant']).exec()
         return user
@@ -50,13 +50,13 @@ class UserMongoRepository implements IUserRepository {
         }
     }
 
-    async delete(id: mongoose.Types.ObjectId): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const result: DeleteResult = await UserModel.deleteOne({_id: id}).exec()
         return result.deletedCount == 1
     }
 
 
-    async findById(id: mongoose.Types.ObjectId): Promise<IUser> {
+    async findById(id:string): Promise<IUser> {
         const user: mongoose.HydratedDocument<IUser> = await UserModel.findById(id).populate(['role','tenant']).exec()
         return user
     }
@@ -66,8 +66,13 @@ class UserMongoRepository 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 query = {}
 
@@ -104,7 +109,7 @@ class UserMongoRepository implements IUserRepository {
         }
     }
 
-    async changePassword(id: mongoose.Types.ObjectId, password: string):Promise<boolean> {
+    async changePassword(id: string, password: string):Promise<boolean> {
         try{
         await UserModel.findOneAndUpdate({_id: id}, {password}).exec()
         return true

package/src/repository/sqlite/RoleSqliteRepository.ts

@@ -1,11 +1,10 @@
-import {IRole} from '../../interfaces/IRole'
 import {IRoleRepository} from '../../interfaces/IRoleRepository'
 import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
-import {IPaginateFilter, IPaginateResult, ValidationError} from "@drax/common-back";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
+import {IRole, IRoleBase} from "@drax/identity-share";
 import {SqliteErrorToValidationError} from "@drax/common-back";
-import {IID} from "../../interfaces/IID";
 
 const roleTableSQL: string = `
     CREATE TABLE IF NOT EXISTS roles
@@ -32,7 +31,7 @@ class RoleSqliteRepository implements IRoleRepository{
         this.db.exec(roleTableSQL);
     }
 
-    normalizeData(roleData: IRole){
+    normalizeData(roleData: IRoleBase){
 
         roleData.readonly = roleData.readonly ? 1 : 0
 
@@ -45,7 +44,7 @@ class RoleSqliteRepository implements IRoleRepository{
         }
     }
 
-    async create(roleData: IRole): Promise<IRole> {
+    async create(roleData: IRoleBase): Promise<IRole> {
         try{
 
             if(!roleData.id){
@@ -76,25 +75,9 @@ class RoleSqliteRepository implements IRoleRepository{
         }
     }
 
-    async findById(id: IID): Promise<IRole | null>{
-        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
-        if(role){
-            await this.populateRole(role)
-            return role
-        }
-        return undefined
-    }
 
-    async findByName(name: string): Promise<IRole | null>{
-        const role = this.db.prepare('SELECT * FROM roles WHERE name = ?').get(name);
-        if(role){
-            await this.populateRole(role)
-            return role
-        }
-        return undefined
-    }
 
-    async update(id: IID, roleData: IRole): Promise<IRole> {
+    async update(id: string, roleData: IRoleBase): Promise<IRole> {
         try{
             this.normalizeData(roleData)
             const setClauses = Object.keys(roleData)
@@ -111,27 +94,13 @@ class RoleSqliteRepository implements IRoleRepository{
 
     }
 
-    async delete(id: IID): Promise<boolean> {
-        const stmt = this.db.prepare('DELETE FROM roles WHERE id = ?');
-        stmt.run(id);
-        return true
-    }
-
-    async deleteAll(): Promise<boolean> {
-        const stmt = this.db.prepare('DELETE FROM roles');
-        stmt.run();
-        return true
-    }
-
-    async fetchAll(): Promise<IRole[]>{
-        const roles = this.db.prepare('SELECT * FROM roles').all();
-        for (const role of roles) {
-            await this.populateRole(role)
-        }
-        return roles
-    }
-
-    async paginate(page = 1, limit = 5, search=""): Promise<IPaginateResult>{
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>>{
         const offset = page > 1 ? (page - 1) * limit : 0
 
         let where=""
@@ -154,7 +123,47 @@ class RoleSqliteRepository implements IRoleRepository{
         }
     }
 
-    async findWithoutPopulateById(id: IID): Promise<IRole | null>{
+    async delete(id: string): Promise<boolean> {
+        const stmt = this.db.prepare('DELETE FROM roles WHERE id = ?');
+        stmt.run(id);
+        return true
+    }
+
+    async deleteAll(): Promise<boolean> {
+        const stmt = this.db.prepare('DELETE FROM roles');
+        stmt.run();
+        return true
+    }
+
+    async findById(id: string): Promise<IRole | null>{
+        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
+        if(role){
+            await this.populateRole(role)
+            return role
+        }
+        return undefined
+    }
+
+    async findByName(name: string): Promise<IRole | null>{
+        const role = this.db.prepare('SELECT * FROM roles WHERE name = ?').get(name);
+        if(role){
+            await this.populateRole(role)
+            return role
+        }
+        return undefined
+    }
+
+    async fetchAll(): Promise<IRole[]>{
+        const roles = this.db.prepare('SELECT * FROM roles').all();
+        for (const role of roles) {
+            await this.populateRole(role)
+        }
+        return roles
+    }
+
+
+
+    async findWithoutPopulateById(id: string): Promise<IRole | null>{
         const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
         if(role){
             return role

package/src/repository/sqlite/TenantSqliteRepository.ts

@@ -1,11 +1,10 @@
-import {ITenant} from '../../interfaces/ITenant'
+import {ITenant, ITenantBase} from '@drax/identity-share'
 import {ITenantRepository} from '../../interfaces/ITenantRepository'
 import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
-import {IPaginateFilter, IPaginateResult, ValidationError} from "@drax/common-back";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
 import {SqliteErrorToValidationError} from "@drax/common-back";
-import {IID} from "../../interfaces/IID";
 
 const tenantTableSQL: string = `
     CREATE TABLE IF NOT EXISTS tenants
@@ -30,7 +29,7 @@ class TenantSqliteRepository implements ITenantRepository{
 
 
 
-    async create(tenantData: ITenant): Promise<ITenant> {
+    async create(tenantData: ITenantBase): Promise<ITenant> {
         try{
 
             if(!tenantData.id){
@@ -55,7 +54,7 @@ class TenantSqliteRepository implements ITenantRepository{
         }
     }
 
-    async findById(id: IID): Promise<ITenant | null>{
+    async findById(id: string): Promise<ITenant | null>{
         const tenant = this.db.prepare('SELECT * FROM tenants WHERE id = ?').get(id);
         return tenant
     }
@@ -65,7 +64,7 @@ class TenantSqliteRepository implements ITenantRepository{
         return tenant
     }
 
-    async update(id: IID, tenantData: ITenant): Promise<ITenant> {
+    async update(id: string, tenantData: ITenantBase): Promise<ITenant> {
         try{
             const setClauses = Object.keys(tenantData)
                 .map(field => `${field} = @${field}`)
@@ -81,7 +80,7 @@ class TenantSqliteRepository implements ITenantRepository{
 
     }
 
-    async delete(id: IID): Promise<boolean> {
+    async delete(id: string): Promise<boolean> {
         const stmt = this.db.prepare('DELETE FROM tenants WHERE id = ?');
         stmt.run(id);
         return true
@@ -101,7 +100,13 @@ class TenantSqliteRepository implements ITenantRepository{
         return tenants
     }
 
-    async paginate(page = 1, limit = 5, search=""): Promise<IPaginateResult>{
+    async paginate({
+                       page= 1,
+                       limit= 5,
+                       orderBy= '',
+                       orderDesc= false,
+                       search= '',
+                       filters= []} : IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>>{
         const offset = page > 1 ? (page - 1) * limit : 0
 
         let where=""

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)

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;
     }