@drax/identity-front 0.5.3 → 0.5.5

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.3",
+  "version": "0.5.5",
   "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.3",
+    "@drax/common-front": "^0.5.5",
+    "@drax/crud-share": "^0.5.5",
     "@drax/identity-share": "^0.5.1"
   },
   "devDependencies": {
@@ -48,5 +48,5 @@
     "vite-plugin-dts": "^3.9.1",
     "vitest": "^1.4.0"
   },
-  "gitHead": "56ea5a743bce196d6322ae6c26ea5b041450d7a3"
+  "gitHead": "c89751dd8eb2ede7d565b596f698c2b83e0c2fed"
 }

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/i18n/identity-role-i18n.ts

@@ -1,26 +1,28 @@
 const messages = {
     en: {
         role: {
-            name: "Name",
-            permissions: "Username",
-            childRoles: "ChildRoles",
-            readonly: "Read Only",
-            updating: "Updating Role",
-            creating: "Creating Role",
-            deleting: "Deleting Role",
-            managing: 'Managing Role',
+            entity: 'Role',
+            menu: 'Roles',
+            crud: 'Manage Roles',
+            field:{
+                name: "Name",
+                permissions: "Username",
+                childRoles: "ChildRoles",
+                readonly: "Read Only",
+            }
         }
     },
     es: {
         role:{
-            name: "Nombre",
-            permissions: "Permisos",
-            childRoles: "Roles gestionados",
-            readonly: "Solo lectura",
-            updating: "Actualizando Rol",
-            creating: "Creando Rol",
-            deleting: "Eliminando Rol",
-            managing: 'Gestionando Rol',
+            entity: 'Rol',
+            menu: 'Roles',
+            crud: 'Gestionando Roles',
+            field:{
+                name: "Nombre",
+                permissions: "Permisos",
+                childRoles: "Roles gestionados",
+                readonly: "Solo lectura",
+            }
         }
     }
 }

package/src/i18n/identity-tenant-i18n.ts

@@ -4,11 +4,7 @@ const messages = {
             entity: "Tenant",
             name: "Name",
             createdAt: 'Created At',
-            updating: "Updating Tenant",
-            creating: "Creating Tenant",
-            deleting: "Deleting Tenant",
-            managing: 'Managing Tenant',
-            fields:{
+            field:{
                 id: 'ID',
                 name: 'Name'
             }
@@ -19,11 +15,7 @@ const messages = {
             entity: "Tenant",
             name: "Nombre",
             createdAt: 'Creado',
-            updating: "Actualizando Tenant",
-            creating: "Creando Tenant",
-            deleting: "Eliminando Tenant",
-            managing: 'Gestionando Tenant',
-            fields:{
+            field:{
                 id: 'ID',
                 name: 'Nombre'
             }

package/src/i18n/identity-user-i18n.ts

@@ -1,58 +1,67 @@
 const messages = {
     en: {
         user: {
-            name: "Name",
-            username: "Username",
-            email: "Email",
-            password: "Password",
-            phone: "Phone",
-            avatar: "Avatar",
-            role: "Role",
-            tenant: "Tenant",
-            active: "Active",
-            groups: "Groups",
+            entity: 'User',
+            profile:'Profile',
             code: "Code",
-            currentPassword: "Current Password",
-            newPassword: "New Password",
-            confirmPassword: "Confirm Password",
-            changeOwnPassword: "Change Password",
             passwordChanged: "Password Changed",
-            updating: "Updating User",
-            creating: "Creating User",
-            deleting: "Deleting User",
-            changingPassword: "Changing User Password",
-            managing: 'Managing Users',
-            profile:'Profile',
-            login:'Login',
-            logout:'Logout'
+            operation: {
+                changePassword: "Changing User Password",
+            },
+            action: {
+                changePassword: "Change Password",
+                changeOwnPassword: "Change Password",
+                login:'Login',
+                logout:'Logout',
+            },
+            field: {
+                name: "Name",
+                username: "Username",
+                email: "Email",
+                password: "Password",
+                phone: "Phone",
+                avatar: "Avatar",
+                role: "Role",
+                tenant: "Tenant",
+                active: "Active",
+                groups: "Groups",
+                currentPassword: "Current Password",
+                newPassword: "New Password",
+                confirmPassword: "Confirm Password",
+            }
         }
     },
     es: {
         user:{
-            name: "Nombre",
-            username: "Usuario",
-            email: "Email",
-            password: "Clave",
-            phone: "Télefono",
-            avatar: "Avatar",
-            role: "Rol",
-            tenant: "Tenant",
-            active: "Activo",
-            groups: "Grupos",
+            entity: 'Usuario',
+
+            profile:'Perfil',
             code: "Codigo",
-            currentPassword: "Clave Actual",
-            newPassword: "Nueva Clave",
-            confirmPassword: "Confirmar Clave",
-            changeOwnPassword: "Cambiar Clave",
             passwordChanged: "Clave Cambiada",
-            updating: "Actualizando Usuario",
-            creating: "Creando Usuario",
-            deleting: "Eliminando Usuario",
-            changingPassword: "Cambiando Clave de Usuario",
-            managing: 'Administrando Usuarios',
-            profile:'Perfil',
-            login:'Iniciar Sesión',
-            logout:'Cerrar Sesión'
+            operation: {
+                changePassword: "Cambiando Clave de Usuario",
+            },
+            action: {
+                changePassword: "Cambiar Clave",
+                changeOwnPassword: "Cambiar Clave",
+                login:'Iniciar Sesión',
+                logout:'Cerrar Sesión',
+            },
+            field: {
+                name: "Nombre",
+                username: "Usuario",
+                email: "Email",
+                password: "Clave",
+                phone: "Télefono",
+                avatar: "Avatar",
+                role: "Rol",
+                tenant: "Tenant",
+                active: "Activo",
+                groups: "Grupos",
+                currentPassword: "Clave Actual",
+                newPassword: "Nueva Clave",
+                confirmPassword: "Confirmar Clave",
+            }
         }
     }
 }

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

@@ -1,7 +1,12 @@
 import type {IHttpClient} from '@drax/common-front'
 import type {IRoleProvider} from "../../interfaces/IRoleProvider.ts";
 import type {IRole, IRoleBase} from "@drax/identity-share";
-import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import type {
+    IDraxCrudProviderExportResult,
+    IDraxExportOptions, IDraxFieldFilter,
+    IDraxPaginateOptions,
+    IDraxPaginateResult
+} from "@drax/crud-share";
 
 class RoleRestProvider implements IRoleProvider {
 
@@ -49,6 +54,28 @@ 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
+    }
+
+    async export({
+                     format = 'JSON',
+                     headers = [],
+                     separator = ';',
+                     limit = 0,
+                     orderBy = "",
+                     order = false,
+                     search = "",
+                     filters = []
+                 }: IDraxExportOptions): Promise<IDraxCrudProviderExportResult> {
+        const url =  '/api/roles/export'
+        const sFilters: string  = filters.map((filter : IDraxFieldFilter ) => `${filter.field},${filter.operator},${filter.value}`).join('|')
+        const params: any = {format, headers, separator, limit, orderBy, order, search, filters: sFilters}
+        return await this.httpClient.get(url, {params}) as IDraxCrudProviderExportResult
+    }
 
 }
 

package/src/providers/rest/TenantRestProvider.ts

@@ -63,7 +63,13 @@ class TenantRestProvider implements ITenantProvider {
         const sFilters: string  = filters.map((filter : IDraxFieldFilter ) => `${filter.field},${filter.operator},${filter.value}`).join('|')
         const params: any = {format, headers, separator, limit, orderBy, order, search, filters: sFilters}
         return await this.httpClient.get(url, {params}) as IDraxCrudProviderExportResult
+    }
 
+    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

@@ -1,7 +1,12 @@
 import type {IHttpClient} from '@drax/common-front'
 import type {IUserProvider} from "../../interfaces/IUserProvider.ts";
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
-import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import type {
+    IDraxCrudProviderExportResult,
+    IDraxExportOptions, IDraxFieldFilter,
+    IDraxPaginateOptions,
+    IDraxPaginateResult
+} from "@drax/crud-share";
 
 
 class UserRestProvider implements IUserProvider {
@@ -39,6 +44,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 +59,23 @@ class UserRestProvider implements IUserProvider {
     }
 
 
+    async export({
+                     format = 'JSON',
+                     headers = [],
+                     separator = ';',
+                     limit = 0,
+                     orderBy = "",
+                     order = false,
+                     search = "",
+                     filters = []
+                 }: IDraxExportOptions): Promise<IDraxCrudProviderExportResult> {
+        const url =  '/api/users/export'
+        const sFilters: string  = filters.map((filter : IDraxFieldFilter ) => `${filter.field},${filter.operator},${filter.value}`).join('|')
+        const params: any = {format, headers, separator, limit, orderBy, order, search, filters: sFilters}
+        return await this.httpClient.get(url, {params}) as IDraxCrudProviderExportResult
+    }
+
+
 }
 
 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,6 +1,11 @@
 import type {IRoleProvider} from "../interfaces/IRoleProvider";
-import type {IRole, IRoleBase} from "@drax/identity-share";
-import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import type {IRole, IRoleBase, ITenant} from "@drax/identity-share";
+import type {
+    IDraxCrudProviderExportResult,
+    IDraxExportOptions,
+    IDraxPaginateOptions,
+    IDraxPaginateResult
+} from "@drax/crud-share";
 
 
 class RoleSystem implements IRoleProvider {
@@ -13,7 +18,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 +35,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> {
@@ -37,6 +51,33 @@ class RoleSystem implements IRoleProvider {
         return this._provider.delete(id)
     }
 
+    async export({
+                     format = 'JSON',
+                     headers = [],
+                     separator = ';',
+                     limit = 0,
+                     orderBy = "",
+                     order = false,
+                     search = "",
+                     filters = []
+                 }: IDraxExportOptions): Promise<IDraxCrudProviderExportResult> {
+
+        if(!this._provider.export){
+            throw new Error(`RoleSystem.provider does not support export`)  // assuming we have a custom error for this case  // replace with actual error handling as needed  // see: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-1.html#error-handling-changes for more details on custom error classes in TypeScript 3.1+  // or use a library like 'ts-error' for a more robust and flexible error handling solution  // or use a custom error type if you want to have a specific error type for this operation  // or use a custom interface or class for the export result if you want to have a specific structure for the result  // or use a custom function that returns the result if you want to have a specific function for the result  // or use a custom interface or class if you want to have a specific structure for the result  // or use a custom function that returns the result
+        }
+
+        return this._provider.export({
+            format,
+            headers,
+            separator,
+            limit,
+            orderBy,
+            order,
+            search,
+            filters
+        })
+    }
+
 }
 
 export default RoleSystem

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,14 @@
 import type {IUserProvider} from "../interfaces/IUserProvider";
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
-import type {IDraxPaginateResult} from "@drax/crud-share";
+import type {
+    IDraxCrudProviderExportResult,
+    IDraxExportOptions,
+    IDraxPaginateOptions,
+    IDraxPaginateResult
+} from "@drax/crud-share";
 
 
-class UserSystem {
+class UserSystem implements IUserProvider{
 
     _provider: IUserProvider
     prototype: string;
@@ -13,8 +18,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,16 +39,41 @@ 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)
         return result
     }
 
+    async export({
+                     format = 'JSON',
+                     headers = [],
+                     separator = ';',
+                     limit = 0,
+                     orderBy = "",
+                     order = false,
+                     search = "",
+                     filters = []
+                 }: IDraxExportOptions): Promise<IDraxCrudProviderExportResult> {
 
+        if(!this._provider.export){
+            throw new Error(`RoleSystem.provider does not support export`)  // assuming we have a custom error for this case  // replace with actual error handling as needed  // see: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-1.html#error-handling-changes for more details on custom error classes in TypeScript 3.1+  // or use a library like 'ts-error' for a more robust and flexible error handling solution  // or use a custom error type if you want to have a specific error type for this operation  // or use a custom interface or class for the export result if you want to have a specific structure for the result  // or use a custom function that returns the result if you want to have a specific function for the result  // or use a custom interface or class if you want to have a specific structure for the result  // or use a custom function that returns the result
+        }
 
-    async delete(id: string):Promise<any> {
-        return this._provider.delete(id)
+        return this._provider.export({
+            format,
+            headers,
+            separator,
+            limit,
+            orderBy,
+            order,
+            search,
+            filters
+        })
     }
 
 }