@drax/identity-front 0.5.2 → 0.5.4

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.2",
+  "version": "0.5.4",
   "type": "module",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
@@ -24,8 +24,8 @@
     "format": "prettier --write src/"
   },
   "dependencies": {
-    "@drax/common-front": "^0.5.1",
-    "@drax/crud-share": "^0.5.2",
+    "@drax/common-front": "^0.5.4",
+    "@drax/crud-share": "^0.5.4",
     "@drax/identity-share": "^0.5.1"
   },
   "devDependencies": {
@@ -48,5 +48,5 @@
     "vite-plugin-dts": "^3.9.1",
     "vitest": "^1.4.0"
   },
-  "gitHead": "6f854dbeb2af7bca32ed35bcec2f8e48790a73b9"
+  "gitHead": "6db0bebb2df9edecd2c3caa7288fb5c7001c4243"
 }

package/src/factory/AuthSystemFactory.ts

@@ -0,0 +1,32 @@
+import AuthSystem from "../system/AuthSystem.js";
+import AuthGqlProvider from "../providers/gql/AuthGqlProvider.js";
+import AuthRestClientProvider from "../providers/rest/AuthRestProvider.js";
+import {HttpGqlClientFactory, HttpRestClientFactory} from "@drax/common-front"
+const HTTP_TRANSPORT = import.meta.env.VITE_HTTP_TRANSPORT || 'REST';
+
+class AuthSystemFactory{
+
+    static singleton: AuthSystem
+
+    static getInstance(httpTransport: string = HTTP_TRANSPORT): AuthSystem {
+        if(!AuthSystemFactory.singleton){
+            if(httpTransport === 'GRAPHQL') {
+                const httpGqlClient = HttpGqlClientFactory.getInstance()
+                const provider = new AuthGqlProvider(httpGqlClient)
+                AuthSystemFactory.singleton = new AuthSystem(provider)
+            } else if(httpTransport === 'REST') {
+                const httpRestClient = HttpRestClientFactory.getInstance()
+                const provider = new AuthRestClientProvider(httpRestClient)
+                AuthSystemFactory.singleton = new AuthSystem(provider)
+            }else{
+                throw new Error('AuthSystemFactory ERROR: Invalid HTTP_TRANSPORT environment variable')
+            }
+        }
+        return AuthSystemFactory.singleton
+    }
+
+}
+
+
+export default AuthSystemFactory
+export {AuthSystemFactory}

package/src/factory/RoleSystemFactory.ts

@@ -0,0 +1,32 @@
+import RoleSystem from "../system/RoleSystem.js";
+import RoleGqlProvider from "../providers/gql/RoleGqlProvider.js";
+import RoleRestClientProvider from "../providers/rest/RoleRestProvider.js";
+import {HttpGqlClientFactory, HttpRestClientFactory} from "@drax/common-front"
+const HTTP_TRANSPORT = import.meta.env.VITE_HTTP_TRANSPORT || 'REST';
+
+class RoleSystemFactory{
+
+    static singleton: RoleSystem
+
+    static getInstance(httpTransport: string = HTTP_TRANSPORT): RoleSystem {
+        if(!RoleSystemFactory.singleton){
+            if(httpTransport === 'GRAPHQL') {
+                const httpGqlClient = HttpGqlClientFactory.getInstance()
+                const provider = new RoleGqlProvider(httpGqlClient)
+                RoleSystemFactory.singleton = new RoleSystem(provider)
+            } else if(httpTransport === 'REST') {
+                const httpRestClient = HttpRestClientFactory.getInstance()
+                const provider = new RoleRestClientProvider(httpRestClient)
+                RoleSystemFactory.singleton = new RoleSystem(provider)
+            }else{
+                throw new Error('RoleSystemFactory ERROR: Invalid HTTP_TRANSPORT environment variable')
+            }
+        }
+        return RoleSystemFactory.singleton
+    }
+
+}
+
+
+export default RoleSystemFactory
+export {RoleSystemFactory}

package/src/factory/UserApiKeySystemFactory.ts

@@ -0,0 +1,32 @@
+import UserApiKeySystem from "../system/UserApiKeySystem.js";
+import UserApiKeyGqlProvider from "../providers/gql/UserApiKeyGqlProvider.js";
+import UserApiKeyRestClientProvider from "../providers/rest/UserApiKeyRestProvider.js";
+import {HttpGqlClientFactory, HttpRestClientFactory} from "@drax/common-front"
+const HTTP_TRANSPORT = import.meta.env.VITE_HTTP_TRANSPORT || 'REST';
+
+class UserApiKeySystemFactory{
+
+    static singleton: UserApiKeySystem
+
+    static getInstance(httpTransport: string = HTTP_TRANSPORT): UserApiKeySystem {
+        if(!UserApiKeySystemFactory.singleton){
+            if(httpTransport === 'GRAPHQL') {
+                const httpGqlClient = HttpGqlClientFactory.getInstance()
+                const provider = new UserApiKeyGqlProvider(httpGqlClient)
+                UserApiKeySystemFactory.singleton = new UserApiKeySystem(provider)
+            } else if(httpTransport === 'REST') {
+                const httpRestClient = HttpRestClientFactory.getInstance()
+                const provider = new UserApiKeyRestClientProvider(httpRestClient)
+                UserApiKeySystemFactory.singleton = new UserApiKeySystem(provider)
+            }else{
+                throw new Error('UserApiKeySystemFactory ERROR: Invalid HTTP_TRANSPORT environment variable')
+            }
+        }
+        return UserApiKeySystemFactory.singleton
+    }
+
+}
+
+
+export default UserApiKeySystemFactory
+export {UserApiKeySystemFactory}

package/src/factory/UserSystemFactory.ts

@@ -0,0 +1,32 @@
+import UserSystem from "../system/UserSystem.js";
+import UserGqlProvider from "../providers/gql/UserGqlProvider.js";
+import UserRestClientProvider from "../providers/rest/UserRestProvider.js";
+import {HttpGqlClientFactory, HttpRestClientFactory} from "@drax/common-front"
+const HTTP_TRANSPORT = import.meta.env.VITE_HTTP_TRANSPORT || 'REST';
+
+class UserSystemFactory{
+
+    static singleton: UserSystem
+
+    static getInstance(httpTransport: string = HTTP_TRANSPORT): UserSystem {
+        if(!UserSystemFactory.singleton){
+            if(httpTransport === 'GRAPHQL') {
+                const httpGqlClient = HttpGqlClientFactory.getInstance()
+                const provider = new UserGqlProvider(httpGqlClient)
+                UserSystemFactory.singleton = new UserSystem(provider)
+            } else if(httpTransport === 'REST') {
+                const httpRestClient = HttpRestClientFactory.getInstance()
+                const provider = new UserRestClientProvider(httpRestClient)
+                UserSystemFactory.singleton = new UserSystem(provider)
+            }else{
+                throw new Error('UserSystemFactory ERROR: Invalid HTTP_TRANSPORT environment variable')
+            }
+        }
+        return UserSystemFactory.singleton
+    }
+
+}
+
+
+export default UserSystemFactory
+export {UserSystemFactory}

package/src/index.ts

@@ -4,22 +4,24 @@ import {jwtDecodeHelper} from "./helpers/JwtDecodeHelper.js"
 import AuthRestProvider from "./providers/rest/AuthRestProvider.js";
 import AuthGqlProvider from "./providers/gql/AuthGqlProvider.js";
 import AuthSystem from "./system/AuthSystem.js"
-
+import AuthSystemFactory from "./factory/AuthSystemFactory.js"
 
 import UserRestProvider from "./providers/rest/UserRestProvider.js";
 import UserGqlProvider from "./providers/gql/UserGqlProvider.js";
 import UserSystem from "./system/UserSystem.js"
+import UserSystemFactory from "./factory/UserSystemFactory.js"
 
 import UserApiKeyRestProvider from "./providers/rest/UserApiKeyRestProvider.js";
 import UserApiKeyGqlProvider from "./providers/gql/UserApiKeyGqlProvider.js";
 import UserApiKeySystem from "./system/UserApiKeySystem.js"
+import UserApiKeySystemFactory from "./factory/UserApiKeySystemFactory.js"
 
 
 
 import RoleRestProvider from "./providers/rest/RoleRestProvider.js";
 import RoleGqlProvider from "./providers/gql/RoleGqlProvider.js";
 import RoleSystem from "./system/RoleSystem.js"
-
+import RoleSystemFactory from "./factory/RoleSystemFactory.js"
 
 import TenantRestProvider from "./providers/rest/TenantRestProvider.js";
 import TenantGqlProvider from "./providers/gql/TenantGqlProvider.js";
@@ -75,7 +77,11 @@ export {
     UserApiKeySystem,
 
     //Factory
+    AuthSystemFactory,
+    UserSystemFactory,
+    RoleSystemFactory,
     TenantSystemFactory,
+    UserApiKeySystemFactory,
 
     //Helpers
     AuthHelper,

package/src/interfaces/IRoleProvider.ts

@@ -1,7 +1,7 @@
 import type {IRole, IRoleBase} from "@drax/identity-share";
-import type {IDraxCrud} from "@drax/crud-share";
+import type {IDraxCrudProvider} from "@drax/crud-share";
 
-interface IRoleProvider extends IDraxCrud<IRole, IRoleBase, IRoleBase>{
+interface IRoleProvider extends IDraxCrudProvider<IRole, IRoleBase, IRoleBase>{
     fetchRole(): Promise<IRole[]>
     fetchPermissions(): Promise<any>
 }

package/src/interfaces/IUserApiKeyProvider.ts

@@ -1,8 +1,7 @@
 import type {IUserApiKey, IUserApiKeyBase} from "@drax/identity-share";
-import type {IDraxCrud} from "@drax/crud-share";
+import type {IDraxCrudProvider} from "@drax/crud-share";
 
-interface IUserApiKeyProvider extends IDraxCrud<IUserApiKey, IUserApiKeyBase, IUserApiKeyBase> {
-    //findBySecret(): Promise<IUserApiKey[]>
+interface IUserApiKeyProvider extends IDraxCrudProvider<IUserApiKey, IUserApiKeyBase, IUserApiKeyBase> {
 }
 
 export type {IUserApiKeyProvider}

package/src/interfaces/IUserProvider.ts

@@ -1,8 +1,8 @@
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
-import type {IDraxCrud} from "@drax/crud-share";
+import type {IDraxCrudProvider} from "@drax/crud-share";
 
 
-interface IUserProvider extends IDraxCrud<IUser, IUserCreate, IUserUpdate>{
+interface IUserProvider extends IDraxCrudProvider<IUser, IUserCreate, IUserUpdate>{
     changeUserPassword(id: string, newPassword: string): Promise<boolean>
 }
 

package/src/providers/gql/RoleGqlProvider.ts

@@ -20,6 +20,17 @@ class RoleGqlProvider implements IRoleProvider {
         this.gqlClient.removeHeader('Authorization')
     }
 
+    get gqlFields(){
+        return `id name permissions childRoles{id name} readonly`
+    }
+
+    async search(value: any): Promise<any> {
+        const query: string = `query searchRole($value: String) { searchRole(value: $value) { ${this.gqlFields} } }`
+        const variables = {value}
+        let data = await this.gqlClient.query(query, variables)
+        return data.searchRole
+    }
+
     async fetchPermissions(): Promise<any> {
         const query: string = `query fetchPermissions { fetchPermissions }`
         const variables = {}
@@ -28,15 +39,17 @@ class RoleGqlProvider implements IRoleProvider {
     }
 
     async fetchRole(): Promise<IRole[]> {
-        const query: string = `query fetchRole { fetchRole { id name permissions childRoles{id name} readonly } }`
+        const query: string = `query fetchRole { fetchRole { ${this.gqlFields} } }`
         const variables = {}
         let data = await this.gqlClient.query(query, variables)
         return data.fetchRole
     }
 
+
+
     async create(payload: IRoleBase): Promise<IRole> {
         const query: string = `mutation createRole($input: RoleInput) { 
-        createRole(input: $input) {id name permissions childRoles{id name} readonly } 
+        createRole(input: $input) { ${this.gqlFields} } 
         }`
         const variables = {input: payload}
         let data = await this.gqlClient.mutation(query, variables)
@@ -45,7 +58,7 @@ class RoleGqlProvider implements IRoleProvider {
 
     async update(id: string, payload: IRoleBase): Promise<IRole> {
         const query: string = `mutation updateRole($id: ID!, $input: RoleInput) { updateRole(id: $id, input: $input) {  
-        id name permissions childRoles{id name} readonly  } }`
+        ${this.gqlFields}  } }`
         const variables = {id, input: payload}
         let data = await this.gqlClient.mutation(query, variables)
         return data.updateRole
@@ -61,7 +74,7 @@ class RoleGqlProvider implements IRoleProvider {
     async paginate({page= 1, limit= 5, orderBy="", order=false, search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
         const query: string = `query paginateRole($options: PaginateOptions) { 
             paginateRole(options: $options) { 
-                total, page, limit, items{id name permissions childRoles{id name} readonly } 
+                total, page, limit, items{ ${this.gqlFields} } 
             } 
         }`
         const variables = {options: {page, limit, orderBy, order, search}}

package/src/providers/gql/TenantGqlProvider.ts

@@ -20,17 +20,28 @@ class TenantGqlProvider implements ITenantProvider {
         this.gqlClient.removeHeader('Authorization')
     }
 
+    get gqlFields(){
+        return `id name createdAt updatedAt`
+    }
+
 
     async fetchTenant(): Promise<ITenant[]> {
-        const query: string = `query fetchTenant { fetchTenant { id name } }`
+        const query: string = `query fetchTenant { fetchTenant { ${this.gqlFields} } }`
         const variables = {}
         let data = await this.gqlClient.query(query, variables)
         return data.fetchTenant
     }
 
+    async search(value: any): Promise<any> {
+        const query: string = `query searchTenant($value: String) { searchTenant(value: $value) { ${this.gqlFields} } }`
+        const variables = {value}
+        let data = await this.gqlClient.query(query, variables)
+        return data.searchTenant
+    }
+
     async create(payload: ITenantBase): Promise<any> {
         const query: string = `mutation createTenant($input: TenantInput) { 
-        createTenant(input: $input) {id name } 
+        createTenant(input: $input) { ${this.gqlFields} } 
         }`
         const variables = {input: payload}
         let data = await this.gqlClient.mutation(query, variables)
@@ -39,7 +50,7 @@ class TenantGqlProvider implements ITenantProvider {
 
     async update(id: string, payload: ITenantBase): Promise<ITenant> {
         const query: string = `mutation updateTenant($id: ID!, $input: TenantInput) { updateTenant(id: $id, input: $input) {  
-        id name  } }`
+        ${this.gqlFields}  } }`
         const variables = {id, input: payload}
         let data = await this.gqlClient.mutation(query, variables)
         return data.updateTenant
@@ -55,7 +66,7 @@ class TenantGqlProvider implements ITenantProvider {
     async paginate({page= 1, limit= 5, orderBy="", order=false, search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
         const query: string = `query paginateTenant($options: PaginateOptions) { 
             paginateTenant(options: $options) { 
-                total page limit items{ id name createdAt updatedAt } 
+                total page limit items{ ${this.gqlFields} } 
             } 
         }`
         const variables = {options: {page, limit, orderBy, order, search}}

package/src/providers/gql/UserApiKeyGqlProvider.ts

@@ -19,9 +19,20 @@ class UserApiKeyGqlProvider implements IUserApiKeyProvider {
         this.gqlClient.removeHeader('Authorization')
     }
 
+    get gqlFields(){
+        return `id name secret ipv4 ipv6 createdAt updatedAt`
+    }
+
+    async search(value: any): Promise<IUserApiKey[]> {
+        const query: string = `query searchUserApiKey($value: String) { searchUserApiKey(value: $value) { ${this.gqlFields} } }`
+        const variables = {value}
+        let data = await this.gqlClient.query(query, variables)
+        return data.searchUserApiKey
+    }
+
     async create(payload: IUserApiKeyBase): Promise<IUserApiKey> {
         const query: string = `mutation createUserApiKey($input: UserApiKeyInput) {
-         createUserApiKey(input: $input) {  id name secret ipv4 ipv6 createdAt updatedAt  } 
+         createUserApiKey(input: $input) {  ${this.gqlFields}  } 
          }`
         const variables = {input: payload}
         let data = await this.gqlClient.mutation(query, variables)
@@ -30,7 +41,7 @@ class UserApiKeyGqlProvider implements IUserApiKeyProvider {
 
     async update(id: string, payload: IUserApiKeyBase): Promise<IUserApiKey> {
         const query: string = `mutation updateUserApiKey($id: ID!, $input: UserApiKeyInput) { 
-        updateUserApiKey(id: $id, input: $input) {  id name ipv4 ipv6 createdAt updatedAt  } 
+        updateUserApiKey(id: $id, input: $input) {  ${this.gqlFields}  } 
         }`
         const variables = {id, input: payload}
         let data = await this.gqlClient.mutation(query, variables)
@@ -51,7 +62,7 @@ class UserApiKeyGqlProvider implements IUserApiKeyProvider {
     async paginate({page= 1, limit= 5, orderBy="", order=false, search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
         const query: string = `query paginateUserApiKey($options: PaginateOptions) { 
             paginateUserApiKey(options: $options) { 
-                total page limit items{ id name ipv4 ipv6 user{id username} createdAt updatedAt } 
+                total page limit items{ ${this.gqlFields} } 
             } 
         }`
         const variables = {options: {page, limit, orderBy, order, search}}

package/src/providers/gql/UserGqlProvider.ts

@@ -19,9 +19,20 @@ class UserGqlProvider implements IUserProvider {
         this.gqlClient.removeHeader('Authorization')
     }
 
+    get gqlFields(){
+        return `id username name email phone active role{id name} tenant{id name} createdAt updatedAt`
+    }
+
+    async search(value: any): Promise<IUser[]> {
+        const query: string = `query searchUser($value: String) { searchUser(value: $value) { ${this.gqlFields} } }`
+        const variables = {value}
+        let data = await this.gqlClient.query(query, variables)
+        return data.searchUser
+    }
+
     async create(payload: IUserCreate): Promise<IUser> {
         const query: string = `mutation createUser($input: UserCreateInput) { createUser(input: $input) {  
-        id username name email phone active role{id name} tenant{id name}  } }`
+        ${this.gqlFields}  } }`
         const variables = {input: payload}
         let data = await this.gqlClient.mutation(query, variables)
         return data.createUser
@@ -29,7 +40,7 @@ class UserGqlProvider implements IUserProvider {
 
     async update(id: string, payload: IUserUpdate): Promise<IUser> {
         const query: string = `mutation updateUser($id: ID!, $input: UserUpdateInput) { updateUser(id: $id, input: $input) {  
-        id username name email phone active role{id name} tenant{id name}  } }`
+        ${this.gqlFields}  } }`
         const variables = {id, input: payload}
         let data = await this.gqlClient.mutation(query, variables)
         return data.updateUser
@@ -52,7 +63,7 @@ class UserGqlProvider implements IUserProvider {
     async paginate({page= 1, limit= 5, orderBy="", order=false, search = ""}:IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
         const query: string = `query paginateUser($options: PaginateOptions) { 
             paginateUser(options: $options) { 
-                total page limit items{ id name username email phone active role{id, name} tenant{id name} createdAt updatedAt } 
+                total page limit items{ ${this.gqlFields} createdAt updatedAt } 
             } 
         }`
         const variables = {options: {page, limit, orderBy, order, search}}

package/src/providers/rest/RoleRestProvider.ts

@@ -49,6 +49,12 @@ class RoleRestProvider implements IRoleProvider {
 
     }
 
+    async search(value: any): Promise<any> {
+        const url = '/api/roles/search'
+        let params = {value: value}
+        let roles = await this.httpClient.get(url, {params} )
+        return roles
+    }
 
 }
 

package/src/providers/rest/TenantRestProvider.ts

@@ -66,6 +66,13 @@ class TenantRestProvider implements ITenantProvider {
 
     }
 
+    async search(value: any): Promise<any> {
+        const url = '/api/tenants/search'
+        let params = {value: value}
+        let tenants = await this.httpClient.get(url, {params} )
+        return tenants
+    }
+
 
 }
 

package/src/providers/rest/UserApiKeyRestProvider.ts

@@ -15,31 +15,36 @@ class UserApiKeyRestProvider implements IUserApiKeyProvider {
 
     async create(data: IUserApiKeyBase): Promise<IUserApiKey> {
             const url = '/api/user-api-keys'
-            let user = await this.httpClient.post(url, data)
-            return user as IUserApiKey
+            let userApiKey = await this.httpClient.post(url, data)
+            return userApiKey as IUserApiKey
     }
 
     async update(id: string, data: IUserApiKeyBase): Promise<IUserApiKey> {
             const url = '/api/user-api-keys/' + id
-            let user = await this.httpClient.put(url, data)
-            return user as IUserApiKey
+            let userApiKey = await this.httpClient.put(url, data)
+            return userApiKey as IUserApiKey
     }
 
     async delete(id: string): Promise<any> {
             const url = '/api/user-api-keys/' + id
-            let user = await this.httpClient.delete(url)
-            return user
+            let result = await this.httpClient.delete(url)
+            return result
     }
 
     async paginate({page= 1, limit= 5, orderBy="", order=false, search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
         const url = '/api/user-api-keys'
         const params = {page, limit, orderBy, order, search}
-            let paginatedUsers = await this.httpClient.get(url, {params})
-            return paginatedUsers as IDraxPaginateResult<IUserApiKey>
+            let paginatedUserApiKeys = await this.httpClient.get(url, {params})
+            return paginatedUserApiKeys as IDraxPaginateResult<IUserApiKey>
 
     }
 
-
+    async search(value: any): Promise<any> {
+        const url = '/api/user-api-keys/search'
+        let data = {value: value}
+        let userApiKeys = await this.httpClient.post(url, data )
+        return userApiKeys
+    }
 
 
 }

package/src/providers/rest/UserRestProvider.ts

@@ -39,6 +39,13 @@ class UserRestProvider implements IUserProvider {
 
     }
 
+    async search(value: any): Promise<any> {
+        const url = '/api/users/search'
+        let data = {value: value}
+        let users = await this.httpClient.post(url, data )
+        return users
+    }
+
     async changeUserPassword(userId: string, newPassword: string): Promise<boolean> {
         const url = '/api/password/' + userId
         const data = {userId, newPassword}
@@ -47,6 +54,8 @@ class UserRestProvider implements IUserProvider {
     }
 
 
+
+
 }
 
 export default UserRestProvider

package/src/system/AuthSystem.ts

@@ -2,7 +2,7 @@ import type {IAuthProvider} from "../interfaces/IAuthProvider";
 import type {IAuthUser} from "../interfaces/IAuthUser";
 import type {ILoginResponse} from "../interfaces/ILoginResponse";
 
-class AuthSystem {
+class AuthSystem implements IAuthProvider {
 
     _provider : IAuthProvider
     prototype: string;

package/src/system/RoleSystem.ts

@@ -1,5 +1,5 @@
 import type {IRoleProvider} from "../interfaces/IRoleProvider";
-import type {IRole, IRoleBase} from "@drax/identity-share";
+import type {IRole, IRoleBase, ITenant} from "@drax/identity-share";
 import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 
 
@@ -13,7 +13,16 @@ class RoleSystem implements IRoleProvider {
         this.prototype = 'RoleSystem'
     }
 
-    fetchRole():Promise<any> {
+    async search(value: any):Promise<IRole[]> {
+
+        if(!this._provider.search){
+            throw new Error("Search method not implemented")
+        }
+
+        return this._provider.search(value)
+    }
+
+    fetchRole():Promise<IRole[]> {
         return this._provider.fetchRole()
     }
 
@@ -21,8 +30,8 @@ class RoleSystem implements IRoleProvider {
         return this._provider.fetchPermissions()
     }
 
-    async paginate({page= 1, limit= 5, orderBy="", order=false, search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
-        return this._provider.paginate({page, limit, orderBy, order, search})
+    async paginate({page= 1, limit= 5, orderBy="", order=false, search = "", filters = []}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IRole>> {
+        return this._provider.paginate({page, limit, orderBy, order, search, filters})
     }
 
     async create(userPayload: IRoleBase):Promise<IRole> {

package/src/system/TenantSystem.ts

@@ -1,5 +1,5 @@
 import type {ITenantProvider} from "../interfaces/ITenantProvider";
-import type {ITenant, ITenantBase} from "@drax/identity-share";
+import type {ITenant, ITenantBase, IUser} from "@drax/identity-share";
 import type {
     IDraxCrudProvider,
     IDraxCrudProviderExportResult,
@@ -22,14 +22,24 @@ class TenantSystem implements IDraxCrudProvider<ITenant, ITenantBase, ITenantBas
         return this._provider.fetchTenant()
     }
 
+    async search(value: any):Promise<ITenant[]> {
+
+        if(!this._provider.search){
+            throw new Error("Search method not implemented")
+        }
+
+        return this._provider.search(value)
+    }
+
     async paginate({
                        page = 1,
                        limit = 5,
                        orderBy = "",
                        order = false,
-                       search = ""
+                       search = "",
+                       filters = []
                    }: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
-        return this._provider.paginate({page, limit, orderBy, order, search})
+        return this._provider.paginate({page, limit, orderBy, order, search, filters})
     }
 
     async create(userPayload: ITenantBase): Promise<ITenant> {

package/src/system/UserApiKeySystem.ts

@@ -1,9 +1,9 @@
 import type {IUserApiKeyProvider} from "../interfaces/IUserApiKeyProvider";
-import type {IUserApiKey, IUserApiKeyBase} from "@drax/identity-share";
-import type {IDraxPaginateResult} from "@drax/crud-share";
+import type {IRole, IUserApiKey, IUserApiKeyBase} from "@drax/identity-share";
+import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 
 
-class UserApiKeySystem {
+class UserApiKeySystem implements IUserApiKeyProvider{
 
     _provider: IUserApiKeyProvider
     prototype: string;
@@ -13,8 +13,17 @@ class UserApiKeySystem {
         this.prototype = 'UserSystem'
     }
 
-    async paginate({page= 1, limit= 5, orderBy="", order=false, search = ""}):Promise<IDraxPaginateResult<IUserApiKey>> {
-        return this._provider.paginate({page, limit, orderBy, order, search})
+    async search(value: any):Promise<IUserApiKey[]> {
+
+        if(!this._provider.search){
+            throw new Error("Search method not implemented")
+        }
+
+        return this._provider.search(value)
+    }
+
+    async paginate({page= 1, limit= 5, orderBy="", order=false, search = "", filters = []}: IDraxPaginateOptions):Promise<IDraxPaginateResult<IUserApiKey>> {
+        return this._provider.paginate({page, limit, orderBy, order, search, filters})
     }
 
     async create(userPayload: IUserApiKeyBase):Promise<IUserApiKey> {

package/src/system/UserSystem.ts

@@ -1,9 +1,9 @@
 import type {IUserProvider} from "../interfaces/IUserProvider";
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
-import type {IDraxPaginateResult} from "@drax/crud-share";
+import type { IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
 
 
-class UserSystem {
+class UserSystem implements IUserProvider{
 
     _provider: IUserProvider
     prototype: string;
@@ -13,8 +13,17 @@ class UserSystem {
         this.prototype = 'UserSystem'
     }
 
-    async paginate({page= 1, limit= 5, orderBy="", order=false, search = ""}):Promise<IDraxPaginateResult<IUser>> {
-        return this._provider.paginate({page, limit, orderBy, order, search})
+    async search(value: any):Promise<IUser[]> {
+
+        if(!this._provider.search){
+            throw new Error("Search method not implemented")
+        }
+
+        return this._provider.search(value)
+    }
+
+    async paginate({page= 1, limit= 5, orderBy="", order=false, search = "", filters = []}: IDraxPaginateOptions):Promise<IDraxPaginateResult<IUser>> {
+        return this._provider.paginate({page, limit, orderBy, order, search, filters})
     }
 
     async create(userPayload: IUserCreate):Promise<IUser> {
@@ -25,6 +34,10 @@ class UserSystem {
         return this._provider.update(id, userPayload)
     }
 
+    async delete(id: string):Promise<any> {
+        return this._provider.delete(id)
+    }
+
     async changeUserPassword(userId:string, newPassword:string):Promise<boolean> {
         console.log("UserSystem",userId, newPassword)
         const result: boolean = await this._provider.changeUserPassword(userId,newPassword)
@@ -33,9 +46,7 @@ class UserSystem {
 
 
 
-    async delete(id: string):Promise<any> {
-        return this._provider.delete(id)
-    }
+
 
 }