@drax/identity-front 0.36.0 → 0.37.1

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.36.0",
+  "version": "0.37.1",
   "type": "module",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
@@ -25,9 +25,9 @@
     "format": "prettier --write src/"
   },
   "dependencies": {
-    "@drax/common-front": "^0.36.0",
-    "@drax/crud-share": "^0.36.0",
-    "@drax/identity-share": "^0.36.0"
+    "@drax/common-front": "^0.37.0",
+    "@drax/crud-share": "^0.37.0",
+    "@drax/identity-share": "^0.37.0"
   },
   "devDependencies": {
     "@rushstack/eslint-patch": "^1.8.0",
@@ -49,5 +49,5 @@
     "vite-plugin-dts": "^3.9.1",
     "vitest": "^1.4.0"
   },
-  "gitHead": "096f17a9a7f6e6969b8367a978137e090916f16d"
+  "gitHead": "e4be12cd506bf5255e0f8b26b89cdd2a660a523d"
 }

package/src/factory/UserLoginFailSystemFactory.ts

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

package/src/factory/UserSessionSystemFactory.ts

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

package/src/index.ts

@@ -29,6 +29,17 @@ import TenantSystem from "./system/TenantSystem.js"
 import TenantSystemFactory from "./factory/TenantSystemFactory.js"
 
 
+import UserSessionRestProvider from "./providers/rest/UserSessionRestProvider.js";
+import UserSessionGqlProvider from "./providers/gql/UserSessionGqlProvider.js";
+import UserSessionSystem from "./system/UserSessionSystem.js"
+import UserSessionSystemFactory from "./factory/UserSessionSystemFactory.js"
+
+import UserLoginFailRestProvider from "./providers/rest/UserLoginFailRestProvider.js";
+import UserLoginFailGqlProvider from "./providers/gql/UserLoginFailGqlProvider.js";
+import UserLoginFailSystem from "./system/UserLoginFailSystem.js"
+import UserLoginFailSystemFactory from "./factory/UserLoginFailSystemFactory.js"
+
+
 import {IdentityI18nMessages} from "./i18n/index.js"
 
 import type {IAuthProvider} from "./interfaces/IAuthProvider"
@@ -71,12 +82,21 @@ export {
     UserApiKeyRestProvider,
     UserApiKeyGqlProvider,
 
+    UserSessionRestProvider,
+    UserSessionGqlProvider,
+
+    UserLoginFailRestProvider,
+    UserLoginFailGqlProvider,
+
+
     //Systems
     AuthSystem,
     UserSystem,
     RoleSystem,
     TenantSystem,
     UserApiKeySystem,
+    UserSessionSystem,
+    UserLoginFailSystem,
 
     //Factory
     AuthSystemFactory,
@@ -84,6 +104,8 @@ export {
     RoleSystemFactory,
     TenantSystemFactory,
     UserApiKeySystemFactory,
+    UserSessionSystemFactory,
+    UserLoginFailSystemFactory,
 
     //Helpers
     AuthHelper,

package/src/interfaces/IUserLoginFailProvider.ts

@@ -0,0 +1,17 @@
+import type {IUserLoginFail} from "@drax/identity-share";
+import type {
+    IDraxCrudProviderExportResult,
+    IDraxExportOptions,
+    IDraxPaginateOptions,
+    IDraxPaginateResult,
+    IDraxGroupByOptions
+} from "@drax/crud-share";
+
+
+interface IUserLoginFailProvider{
+    paginate(options: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserLoginFail>>
+    groupBy?(options: IDraxGroupByOptions): Promise<Array<any>>
+    export?(options: IDraxExportOptions): Promise<IDraxCrudProviderExportResult>
+}
+
+export type {IUserLoginFailProvider}

package/src/interfaces/IUserSessionProvider.ts

@@ -0,0 +1,17 @@
+import type {IUserSession} from "@drax/identity-share";
+import type {
+    IDraxCrudProviderExportResult,
+    IDraxExportOptions,
+    IDraxPaginateOptions,
+    IDraxPaginateResult,
+    IDraxGroupByOptions
+} from "@drax/crud-share";
+
+
+interface IUserSessionProvider{
+    paginate(options: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserSession>>
+    groupBy?(options: IDraxGroupByOptions): Promise<Array<any>>
+    export?(options: IDraxExportOptions): Promise<IDraxCrudProviderExportResult>
+}
+
+export type {IUserSessionProvider}

package/src/providers/gql/UserLoginFailGqlProvider.ts

@@ -0,0 +1,43 @@
+import type {IGqlClient} from '@drax/common-front'
+import type {IUserLoginFailProvider} from "../../interfaces/IUserLoginFailProvider";
+import type {IUserLoginFail} from "@drax/identity-share";
+import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+
+
+class UserLoginFailGqlProvider implements IUserLoginFailProvider {
+
+    gqlClient: IGqlClient
+
+    constructor(gqlClient: IGqlClient) {
+        this.gqlClient = gqlClient
+    }
+
+    setHttpClientToken(token: string): void {
+        this.gqlClient.addHeader('Authorization', `Bearer ${token}`)
+    }
+
+    removeHttpClientToken(): void {
+        this.gqlClient.removeHeader('Authorization')
+    }
+
+    get gqlFields(){
+        return `_id user{_id username} agent ip createdAt`
+    }
+
+
+
+    async paginate({page= 1, limit= 5, orderBy="", order='asc', search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserLoginFail>> {
+        const query: string = `query paginateUserLoginFail($options: PaginateOptions) { 
+            paginateUserLoginFail(options: $options) { 
+                total, page, limit, items{ ${this.gqlFields} } 
+            } 
+        }`
+        const variables = {options: {page, limit, orderBy, order, search}}
+        let data = await this.gqlClient.query(query, variables)
+        return data.paginateUserLoginFail
+    }
+
+
+}
+
+export default UserLoginFailGqlProvider

package/src/providers/gql/UserSessionGqlProvider.ts

@@ -0,0 +1,42 @@
+import type {IGqlClient} from '@drax/common-front'
+import type {IUserSessionProvider} from "../../interfaces/IUserSessionProvider";
+import type {IUserSession} from "@drax/identity-share";
+import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+
+
+class UserSessionProvider implements IUserSessionProvider {
+
+    gqlClient: IGqlClient
+
+    constructor(gqlClient: IGqlClient) {
+        this.gqlClient = gqlClient
+    }
+
+    setHttpClientToken(token: string): void {
+        this.gqlClient.addHeader('Authorization', `Bearer ${token}`)
+    }
+
+    removeHttpClientToken(): void {
+        this.gqlClient.removeHeader('Authorization')
+    }
+
+    get gqlFields(){
+        return `_id uuid user{_id username} agent ip createdAt`
+    }
+
+
+    async paginate({page= 1, limit= 5, orderBy="", order='asc', search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserSession>> {
+        const query: string = `query paginateUserSession($options: PaginateOptions) { 
+            paginateUserLoginFail(options: $options) { 
+                total, page, limit, items{ ${this.gqlFields} } 
+            } 
+        }`
+        const variables = {options: {page, limit, orderBy, order, search}}
+        let data = await this.gqlClient.query(query, variables)
+        return data.paginateUserLoginFail
+    }
+
+
+}
+
+export default UserSessionProvider

package/src/providers/rest/RoleRestProvider.ts

@@ -3,16 +3,18 @@ import type {IRoleProvider} from "../../interfaces/IRoleProvider.ts";
 import type {IRole, IRoleBase} from "@drax/identity-share";
 import type {
     IDraxCrudProviderExportResult,
-    IDraxExportOptions, IDraxFieldFilter,
+    IDraxExportOptions,
     IDraxPaginateOptions,
     IDraxPaginateResult
 } from "@drax/crud-share";
+import {AbstractBaseRestProvider} from "@drax/crud-front";
 
-class RoleRestProvider implements IRoleProvider {
+class RoleRestProvider extends AbstractBaseRestProvider implements IRoleProvider {
 
     httpClient: IHttpClient
 
     constructor(httpClient: IHttpClient) {
+        super('/api/roles');
         this.httpClient = httpClient
     }
 
@@ -72,8 +74,7 @@ class RoleRestProvider implements IRoleProvider {
                      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}
+        const params: any = {format, headers, separator, limit, orderBy, order, search, filters: this.prepareFilters(filters)}
         return await this.httpClient.get(url, {params}) as IDraxCrudProviderExportResult
     }
 

package/src/providers/rest/TenantRestProvider.ts

@@ -3,21 +3,21 @@ import type {ITenantProvider} from "../../interfaces/ITenantProvider.ts";
 import type {ITenant, ITenantBase} from "@drax/identity-share";
 import type {
     IDraxCrudProviderExportResult,
-    IDraxExportOptions, IDraxFieldFilter,
+    IDraxExportOptions,
     IDraxPaginateOptions,
     IDraxPaginateResult
 } from "@drax/crud-share";
+import {AbstractBaseRestProvider} from "@drax/crud-front";
 
-class TenantRestProvider implements ITenantProvider {
+class TenantRestProvider extends AbstractBaseRestProvider implements ITenantProvider {
 
     httpClient: IHttpClient
 
     constructor(httpClient: IHttpClient) {
+        super('/api/tenants');
         this.httpClient = httpClient
     }
 
-
-
     async fetchTenant(): Promise<any> {
         const url = '/api/tenants/all'
         let tenant = await this.httpClient.get(url)
@@ -41,9 +41,9 @@ class TenantRestProvider implements ITenantProvider {
         return user
     }
 
-    async paginate({page= 1, limit= 5, orderBy="", order= "asc", search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
+    async paginate({page= 1, limit= 5, orderBy="", order= "asc", search = "", filters= []}: IDraxPaginateOptions): Promise<IDraxPaginateResult<ITenant>> {
         const url = '/api/tenants'
-        const params = {page, limit, orderBy, order, search}
+        const params = {page, limit, orderBy, order, search, filters: this.prepareFilters(filters)}
         let paginatedTenants = await this.httpClient.get(url, {params})
         return paginatedTenants as IDraxPaginateResult<ITenant>
 
@@ -60,8 +60,7 @@ class TenantRestProvider implements ITenantProvider {
                      filters = []
                  }: IDraxExportOptions): Promise<IDraxCrudProviderExportResult> {
         const url =  '/api/tenants/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}
+        const params: any = {format, headers, separator, limit, orderBy, order, search, filters: this.prepareFilters(filters)}
         return await this.httpClient.get(url, {params}) as IDraxCrudProviderExportResult
     }
 

package/src/providers/rest/UserApiKeyRestProvider.ts

@@ -2,13 +2,15 @@ import type {IHttpClient} from '@drax/common-front'
 import type {IUserApiKeyProvider} from "../../interfaces/IUserApiKeyProvider";
 import type {IUserApiKey, IUserApiKeyBase} from "@drax/identity-share";
 import type {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/crud-share";
+import {AbstractBaseRestProvider} from "@drax/crud-front";
 
 
-class UserApiKeyRestProvider implements IUserApiKeyProvider {
+class UserApiKeyRestProvider extends AbstractBaseRestProvider implements IUserApiKeyProvider {
 
     httpClient: IHttpClient
 
     constructor(httpClient: IHttpClient) {
+        super('/api/user-api-keys');
         this.httpClient = httpClient
     }
 
@@ -31,9 +33,9 @@ class UserApiKeyRestProvider implements IUserApiKeyProvider {
             return result
     }
 
-    async paginate({page= 1, limit= 5, orderBy="", order="asc", search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
+    async paginate({page= 1, limit= 5, orderBy="", order="asc", search = "", filters=[]}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
         const url = '/api/user-api-keys'
-        const params = {page, limit, orderBy, order, search}
+        const params = {page, limit, orderBy, order, search, filters: this.prepareFilters(filters)  }
             let paginatedUserApiKeys = await this.httpClient.get(url, {params})
             return paginatedUserApiKeys as IDraxPaginateResult<IUserApiKey>
 

package/src/providers/rest/UserLoginFailRestProvider.ts

@@ -0,0 +1,54 @@
+import type {IHttpClient} from "@drax/common-front";
+import type {
+  IDraxCrudProviderExportResult,
+  IDraxExportOptions,
+  IDraxGroupByOptions,
+  IDraxPaginateOptions,
+  IDraxPaginateResult
+} from "@drax/crud-share";
+import {AbstractBaseRestProvider} from "@drax/crud-front";
+import type {IUserLoginFail} from "@drax/identity-share";
+import type {IUserLoginFailProvider} from "../../interfaces/IUserLoginFailProvider";
+
+class UserLoginFailRestProvider extends AbstractBaseRestProvider implements IUserLoginFailProvider {
+
+  httpClient: IHttpClient
+
+  constructor(httpClient: IHttpClient) {
+      super('/api/user-login-fails');
+      this.httpClient = httpClient
+  }
+
+  async paginate({page= 1, limit= 5, orderBy="",order= "asc", search = "", filters= []}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserLoginFail>> {
+    const url = '/api/user-login-fails'
+    const params = {page, limit, orderBy, order, search, filters: this.prepareFilters(filters)}
+    let paginatedUsers = await this.httpClient.get(url, {params})
+    return paginatedUsers as IDraxPaginateResult<IUserLoginFail>
+  }
+
+  async groupBy({fields = [], filters = []}: IDraxGroupByOptions): Promise<Array<any>> {
+    const url =  '/api/user-login-fails/group-by'
+    const params = {fields: fields ? fields.join(',') : '',filters: this.prepareFilters(filters)}
+    const items = await this.httpClient.get(url, {params})
+    return items as any[]
+  }
+
+  async export({
+                 format = 'JSON',
+                 headers = [],
+                 separator = ';',
+                 limit = 0,
+                 orderBy = "",
+                 order = false,
+                 search = "",
+                 filters = []
+               }: IDraxExportOptions): Promise<IDraxCrudProviderExportResult> {
+    const url =  '/api/user-login-fails/export'
+    const params: any = {format, headers, separator, limit, orderBy, order, search,  filters: this.prepareFilters(filters)}
+    return await this.httpClient.get(url, {params}) as IDraxCrudProviderExportResult
+  }
+
+}
+
+export default UserLoginFailRestProvider
+

package/src/providers/rest/UserRestProvider.ts

@@ -3,17 +3,19 @@ import type {IUserProvider} from "../../interfaces/IUserProvider.ts";
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
 import type {
     IDraxCrudProviderExportResult,
-    IDraxExportOptions, IDraxFieldFilter,
+    IDraxExportOptions,  IDraxGroupByOptions,
     IDraxPaginateOptions,
     IDraxPaginateResult
 } from "@drax/crud-share";
+import {AbstractBaseRestProvider} from "@drax/crud-front";
 
 
-class UserRestProvider implements IUserProvider {
+class UserRestProvider extends AbstractBaseRestProvider implements IUserProvider {
 
     httpClient: IHttpClient
 
     constructor(httpClient: IHttpClient) {
+        super('/api/users');
         this.httpClient = httpClient
     }
 
@@ -36,9 +38,9 @@ class UserRestProvider implements IUserProvider {
             return user
     }
 
-    async paginate({page= 1, limit= 5, orderBy="",order= "asc", search = ""}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
+    async paginate({page= 1, limit= 5, orderBy="",order= "asc", search = "", filters=[]}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUser>> {
         const url = '/api/users'
-        const params = {page, limit, orderBy, order, search}
+        const params = {page, limit, orderBy, order, search, filters: this.prepareFilters(filters)}
             let paginatedUsers = await this.httpClient.get(url, {params})
             return paginatedUsers as IDraxPaginateResult<IUser>
 
@@ -70,11 +72,17 @@ class UserRestProvider implements IUserProvider {
                      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}
+        const params: any = {format, headers, separator, limit, orderBy, order, search, filters: this.prepareFilters(filters)}
         return await this.httpClient.get(url, {params}) as IDraxCrudProviderExportResult
     }
 
+    async groupBy({fields = [], filters = []}: IDraxGroupByOptions): Promise<Array<any>> {
+        const url =  '/api/users/group-by'
+        const params = {fields: fields ? fields.join(',') : '',filters: this.prepareFilters(filters)}
+        const items = await this.httpClient.get(url, {params})
+        return items as any[]
+    }
+
 
 }
 

package/src/providers/rest/UserSessionRestProvider.ts

@@ -0,0 +1,55 @@
+import type {IHttpClient} from "@drax/common-front";
+import type {
+  IDraxCrudProviderExportResult,
+  IDraxExportOptions,
+  IDraxGroupByOptions,
+  IDraxPaginateOptions,
+  IDraxPaginateResult
+} from "@drax/crud-share";
+import type {IUserSession} from "@drax/identity-share";
+import type {IUserSessionProvider} from "../../interfaces/IUserSessionProvider";
+import {AbstractBaseRestProvider} from "@drax/crud-front";
+
+class UserSessionRestProvider extends AbstractBaseRestProvider implements IUserSessionProvider {
+
+  httpClient: IHttpClient
+
+  constructor(httpClient: IHttpClient) {
+      super('/api/user-sessions');
+      this.httpClient = httpClient
+  }
+
+
+  async paginate({page= 1, limit= 5, orderBy="",order= "asc", search = "", filters=[]}: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserSession>> {
+    const url = '/api/user-sessions'
+    const params = {page, limit, orderBy, order, search, filters: this.prepareFilters(filters)}
+    let paginatedUsers = await this.httpClient.get(url, {params})
+    return paginatedUsers as IDraxPaginateResult<IUserSession>
+  }
+
+  async groupBy({fields = [], filters = []}: IDraxGroupByOptions): Promise<Array<any>> {
+    const url =  '/api/user-sessions/group-by'
+    const params = {fields: fields ? fields.join(',') : '',filters: this.prepareFilters(filters)}
+    const items = await this.httpClient.get(url, {params})
+    return items as any[]
+  }
+
+  async export({
+                 format = 'JSON',
+                 headers = [],
+                 separator = ';',
+                 limit = 0,
+                 orderBy = "",
+                 order = false,
+                 search = "",
+                 filters = []
+               }: IDraxExportOptions): Promise<IDraxCrudProviderExportResult> {
+    const url =  '/api/user-sessions/export'
+    const params: any = {format, headers, separator, limit, orderBy, order, search, filters: this.prepareFilters(filters)}
+    return await this.httpClient.get(url, {params}) as IDraxCrudProviderExportResult
+  }
+
+}
+
+export default UserSessionRestProvider
+

package/src/system/RoleSystem.ts

@@ -40,14 +40,26 @@ class RoleSystem implements IRoleProvider {
     }
 
     async create(userPayload: IRoleBase):Promise<IRole> {
+        if(!this._provider.create){
+            throw new Error("Create method not implemented")
+        }
+
         return this._provider.create(userPayload)
     }
 
     async update(id:string, userPayload: IRoleBase):Promise<IRole> {
+        if(!this._provider.update){
+            throw new Error("Update method not implemented")
+        }
+
         return this._provider.update(id, userPayload)
     }
 
     async delete(id: string):Promise<any> {
+        if(!this._provider.delete){
+            throw new Error("Delete method not implemented")
+        }
+
         return this._provider.delete(id)
     }
 
@@ -63,7 +75,7 @@ class RoleSystem implements IRoleProvider {
                  }: 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
+            throw new Error(`RoleSystem.provider does not support export`)
         }
 
         return this._provider.export({

package/src/system/TenantSystem.ts

@@ -43,14 +43,26 @@ class TenantSystem implements IDraxCrudProvider<ITenant, ITenantBase, ITenantBas
     }
 
     async create(userPayload: ITenantBase): Promise<ITenant> {
+        if(!this._provider.create){
+            throw new Error("Create method not implemented")
+        }
+
         return this._provider.create(userPayload)
     }
 
     async update(id: string, userPayload: ITenantBase): Promise<ITenant> {
+        if(!this._provider.update){
+            throw new Error("Update method not implemented")
+        }
+
         return this._provider.update(id, userPayload)
     }
 
     async delete(id: string): Promise<any> {
+        if(!this._provider.delete){
+            throw new Error("Delete method not implemented")
+        }
+
         return this._provider.delete(id)
     }
 
@@ -66,7 +78,7 @@ class TenantSystem implements IDraxCrudProvider<ITenant, ITenantBase, ITenantBas
                  }: IDraxExportOptions): Promise<IDraxCrudProviderExportResult> {
 
         if(!this._provider.export){
-            throw new Error(`TenantSystem.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
+            throw new Error(`TenantSystem.provider does not support export`)
         }
 
         return this._provider.export({

package/src/system/UserApiKeySystem.ts

@@ -27,14 +27,26 @@ class UserApiKeySystem implements IUserApiKeyProvider{
     }
 
     async create(userPayload: IUserApiKeyBase):Promise<IUserApiKey> {
+        if(!this._provider.create){
+            throw new Error("Create method not implemented")
+        }
+
         return this._provider.create(userPayload)
     }
 
     async update(id:string, userPayload: IUserApiKeyBase):Promise<IUserApiKey> {
+        if(!this._provider.update){
+            throw new Error("Update method not implemented")
+        }
+
         return this._provider.update(id, userPayload)
     }
 
     async delete(id: string):Promise<any> {
+        if(!this._provider.delete){
+            throw new Error("Delete method not implemented")
+        }
+
         return this._provider.delete(id)
     }
 

package/src/system/UserLoginFailSystem.ts

@@ -0,0 +1,64 @@
+import type {IUserLoginFailProvider} from "../interfaces/IUserLoginFailProvider";
+import type {IUserLoginFail} from "@drax/identity-share";
+import type {
+    IDraxCrudProviderExportResult,
+    IDraxExportOptions, IDraxGroupByOptions,
+    IDraxPaginateOptions,
+    IDraxPaginateResult
+} from "@drax/crud-share";
+
+
+class UserLoginFailSystem implements IUserLoginFailProvider{
+
+    _provider: IUserLoginFailProvider
+    prototype: string;
+
+    constructor(provider: IUserLoginFailProvider) {
+        this._provider = provider;
+        this.prototype = 'UserLoginFailSystem'
+    }
+
+    async paginate({page= 1, limit= 5, orderBy= "", order= "asc", search = "", filters = []}: IDraxPaginateOptions):Promise<IDraxPaginateResult<IUserLoginFail>> {
+        return this._provider.paginate({page, limit, orderBy, order, search, filters})
+    }
+
+    async groupBy({fields = [], filters = []}: IDraxGroupByOptions): Promise<Array<any>> {
+        if(!this._provider.groupBy){
+            throw new Error("groupBy method not implemented")
+        }
+
+        const result: any[] = await this._provider.groupBy({fields,filters})
+        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(`export method not implemented`)  // 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 UserLoginFailSystem
+export {UserLoginFailSystem}

package/src/system/UserSessionSystem.ts

@@ -0,0 +1,64 @@
+import type {IUserSessionProvider} from "../interfaces/IUserSessionProvider";
+import type {IUserSession} from "@drax/identity-share";
+import type {
+    IDraxCrudProviderExportResult,
+    IDraxExportOptions, IDraxGroupByOptions,
+    IDraxPaginateOptions,
+    IDraxPaginateResult
+} from "@drax/crud-share";
+
+
+class UserSessionSystem implements IUserSessionProvider{
+
+    _provider: IUserSessionProvider
+    prototype: string;
+
+    constructor(provider: IUserSessionProvider) {
+        this._provider = provider;
+        this.prototype = 'UserSessionSystem'
+    }
+
+    async paginate({page= 1, limit= 5, orderBy= "", order= "asc", search = "", filters = []}: IDraxPaginateOptions):Promise<IDraxPaginateResult<IUserSession>> {
+        return this._provider.paginate({page, limit, orderBy, order, search, filters})
+    }
+
+    async groupBy({fields = [], filters = []}: IDraxGroupByOptions): Promise<Array<any>> {
+        if(!this._provider.groupBy){
+            throw new Error("groupBy method not implemented")
+        }
+
+        const result: any[] = await this._provider.groupBy({fields,filters})
+        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(`export method not implemented`)  // 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 UserSessionSystem
+export {UserSessionSystem}

package/src/system/UserSystem.ts

@@ -2,7 +2,7 @@ import type {IUserProvider} from "../interfaces/IUserProvider";
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
 import type {
     IDraxCrudProviderExportResult,
-    IDraxExportOptions,
+    IDraxExportOptions, IDraxGroupByOptions,
     IDraxPaginateOptions,
     IDraxPaginateResult
 } from "@drax/crud-share";
@@ -21,7 +21,7 @@ class UserSystem implements IUserProvider{
     async search(value: any):Promise<IUser[]> {
 
         if(!this._provider.search){
-            throw new Error("Search method not implemented")
+            throw new Error("search method not implemented")
         }
 
         return this._provider.search(value)
@@ -32,23 +32,47 @@ class UserSystem implements IUserProvider{
     }
 
     async create(userPayload: IUserCreate):Promise<IUser> {
+        if(!this._provider.create){
+            throw new Error("Create method not implemented")
+        }
+
         return this._provider.create(userPayload)
     }
 
     async update(id:string, userPayload: IUserUpdate):Promise<IUser> {
+        if(!this._provider.update){
+            throw new Error("Update method not implemented")
+        }
+
         return this._provider.update(id, userPayload)
     }
 
     async delete(id: string):Promise<any> {
+        if(!this._provider.delete){
+            throw new Error("Delete method not implemented")
+        }
+
         return this._provider.delete(id)
     }
 
     async changeUserPassword(userId:string, newPassword:string):Promise<boolean> {
-        console.log("UserSystem",userId, newPassword)
+        if(!this._provider.changeUserPassword){
+            throw new Error("changeUserPassword method not implemented")
+        }
+
         const result: boolean = await this._provider.changeUserPassword(userId,newPassword)
         return result
     }
 
+    async groupBy({fields = [], filters = []}: IDraxGroupByOptions): Promise<Array<any>> {
+        if(!this._provider.groupBy){
+            throw new Error("groupBy method not implemented")
+        }
+
+        const result: any[] = await this._provider.groupBy({fields,filters})
+        return result
+    }
+
     async export({
                      format = 'JSON',
                      headers = [],
@@ -61,7 +85,7 @@ class UserSystem implements IUserProvider{
                  }: 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
+            throw new Error(`export method not implemented`)
         }
 
         return this._provider.export({