@drax/identity-front 0.0.20 → 0.0.21

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.20",
+  "version": "0.0.21",
   "type": "module",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
@@ -24,7 +24,7 @@
     "format": "prettier --write src/"
   },
   "dependencies": {
-    "@drax/common-front": "^0.0.20"
+    "@drax/common-front": "^0.0.21"
   },
   "devDependencies": {
     "@rushstack/eslint-patch": "^1.8.0",
@@ -46,5 +46,5 @@
     "vite-plugin-dts": "^3.9.1",
     "vitest": "^1.4.0"
   },
-  "gitHead": "5d01fbe44ee689c8512d7605f4b2fe2fc94fb599"
+  "gitHead": "e69a9b3d6123e94549678dc865b9ba9ffe9816c9"
 }

package/src/index.ts

@@ -29,8 +29,8 @@ import type {IRoleProvider} from "./interfaces/IRoleProvider"
 import type {ITenantProvider} from "./interfaces/ITenantProvider"
 import type {IAuthUser} from "./interfaces/IAuthUser"
 import type {IUser, IUserCreate, IUserUpdate, IUserPassword} from "./interfaces/IUser"
-import type {IRole} from "./interfaces/IRole"
-import type {ITenant} from "./interfaces/ITenant"
+import type {IRole, IRoleBase} from "./interfaces/IRole"
+import type {ITenant, ITenantBase} from "./interfaces/ITenant"
 import type {ILoginResponse} from "./interfaces/ILoginResponse"
 
 export type {
@@ -39,12 +39,10 @@ export type {
     IRoleProvider,
     ITenantProvider,
     IAuthUser,
-    IUser,
-    IUserCreate,
-    IUserUpdate,
+    IUser, IUserCreate, IUserUpdate,
+    IRole, IRoleBase,
+    ITenant, ITenantBase,
     IUserPassword,
-    IRole,
-    ITenant,
     ILoginResponse
 }
 

package/src/interfaces/IRole.ts

@@ -1,10 +1,19 @@
+interface IRoleBase{
+    name: string
+    permissions: string[]
+    childRoles: string[]
+    readonly: boolean
+}
 
 interface IRole{
-    id ?: string
+    id : string
     name: string
     permissions: string[]
-    childRoles?: IRole[]
+    childRoles: IRole[]
     readonly: boolean
 }
 
-export type {IRole}
+
+
+
+export type {IRole, IRoleBase}

package/src/interfaces/IRoleProvider.ts

@@ -1,12 +1,12 @@
-import type {IRole} from "./IRole";
+import type {IRole, IRoleBase} from "./IRole";
 import type {IPaginateClient} from "@drax/common-front";
 
 interface IRoleProvider {
-    fetchRole(): Promise<any>
+    fetchRole(): Promise<IRole[]>
     fetchPermissions(): Promise<any>
-    paginateRole(page: number, limit: number, search:string): Promise<IPaginateClient>
-    createRole(input: IRole): Promise<any>
-    editRole(id: string, input: IRole): Promise<IRole>
+    paginateRole(page: number, limit: number, search:string): Promise<IPaginateClient<IRole>>
+    createRole(input: IRoleBase): Promise<IRole>
+    editRole(id: string, input: IRoleBase): Promise<IRole>
     deleteRole(id: string): Promise<any>
 }
 

package/src/interfaces/ITenant.ts

@@ -1,7 +1,11 @@
+interface ITenantBase{
+    name: string
+}
 
-interface ITenant{
-    id ?: string
+interface ITenant extends ITenantBase{
+    id: string
     name: string
 }
 
-export type {ITenant}
+
+export type {ITenant, ITenantBase}

package/src/interfaces/ITenantProvider.ts

@@ -1,11 +1,11 @@
-import type {ITenant} from "./ITenant";
+import type {ITenant, ITenantBase} from "./ITenant";
 import type {IPaginateClient} from "@drax/common-front";
 
 interface ITenantProvider {
-    fetchTenant(): Promise<any>
-    paginateTenant(page: number, limit: number, search:string): Promise<IPaginateClient>
-    createTenant(input: ITenant): Promise<any>
-    editTenant(id: string, input: ITenant): Promise<ITenant>
+    fetchTenant(): Promise<ITenant[]>
+    paginateTenant(page: number, limit: number, search:string): Promise<IPaginateClient<ITenant>>
+    createTenant(input: ITenantBase): Promise<ITenant>
+    editTenant(id: string, input: ITenantBase): Promise<ITenant>
     deleteTenant(id: string): Promise<any>
 }
 

package/src/interfaces/IUser.ts

@@ -30,8 +30,8 @@ interface IUserUpdate {
     email: string
     active: boolean
     phone: string
-    role: string
-    tenant: string
+    role: string|undefined
+    tenant: string|undefined
 }
 
 interface IUserPassword {

package/src/interfaces/IUserProvider.ts

@@ -4,7 +4,7 @@ import type {IPaginateClient} from "@drax/common-front";
 
 
 interface IUserProvider {
-    paginateUser(page: number, limit: number, search?:string): Promise<IPaginateClient>
+    paginateUser(page: number, limit: number, search?:string): Promise<IPaginateClient<IUser>>
     createUser(input: IUserCreate): Promise<IUser>
     editUser(id: string, input: IUserUpdate): Promise<IUser>
     deleteUser(id: string): Promise<any>

package/src/providers/gql/RoleGqlProvider.ts

@@ -1,6 +1,6 @@
 import type {IGqlClient, IPaginateClient} from '@drax/common-front'
 import type {IRoleProvider} from "../../interfaces/IRoleProvider";
-import type {IRole} from "../../interfaces/IRole";
+import type {IRole, IRoleBase} from "../../interfaces/IRole";
 
 
 class RoleGqlProvider implements IRoleProvider {
@@ -26,14 +26,14 @@ class RoleGqlProvider implements IRoleProvider {
         return data.fetchPermissions
     }
 
-    async fetchRole(): Promise<any> {
+    async fetchRole(): Promise<IRole[]> {
         const query: string = `query fetchRole { fetchRole { id name permissions childRoles{id name} readonly } }`
         const variables = {}
         let data = await this.gqlClient.query(query, variables)
         return data.fetchRole
     }
 
-    async createRole(payload: IRole): Promise<any> {
+    async createRole(payload: IRoleBase): Promise<IRole> {
         const query: string = `mutation createRole($input: RoleInput) { 
         createRole(input: $input) {id name permissions childRoles{id name} readonly } 
         }`
@@ -42,7 +42,7 @@ class RoleGqlProvider implements IRoleProvider {
         return data.createRole
     }
 
-    async editRole(id: string, payload: IRole): Promise<IRole> {
+    async editRole(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  } }`
         const variables = {id, input: payload}
@@ -57,7 +57,7 @@ class RoleGqlProvider implements IRoleProvider {
         return data.createRole
     }
 
-    async paginateRole(page: number, limit: number, search:string = ""): Promise<IPaginateClient> {
+    async paginateRole(page: number, limit: number, search:string = ""): Promise<IPaginateClient<IRole>> {
         const query: string = `query paginateRole($page: Int, $limit: Int, $search:String) { 
             paginateRole(page: $page, limit: $limit, search: $search) { 
                 total, page, limit, items{id name permissions childRoles{id name} readonly } 

package/src/providers/gql/TenantGqlProvider.ts

@@ -20,7 +20,7 @@ class TenantGqlProvider implements ITenantProvider {
     }
 
 
-    async fetchTenant(): Promise<any> {
+    async fetchTenant(): Promise<ITenant[]> {
         const query: string = `query fetchTenant { fetchTenant { id name } }`
         const variables = {}
         let data = await this.gqlClient.query(query, variables)
@@ -51,7 +51,7 @@ class TenantGqlProvider implements ITenantProvider {
         return data.createTenant
     }
 
-    async paginateTenant(page: number, limit: number, search:string = ""): Promise<IPaginateClient> {
+    async paginateTenant(page: number, limit: number, search:string = ""): Promise<IPaginateClient<ITenant>> {
         const query: string = `query paginateTenant($page: Int, $limit: Int, $search:String) { 
             paginateTenant(page: $page, limit: $limit, search: $search) { 
                 total, page, limit, items{id, name } 

package/src/providers/gql/UserGqlProvider.ts

@@ -1,6 +1,6 @@
 import type {IGqlClient, IPaginateClient} from '@drax/common-front'
 import type {IUserProvider} from "../../interfaces/IUserProvider";
-import type {IUser, IUserCreate, IUserPassword, IUserUpdate} from "../../interfaces/IUser";
+import type {IUser, IUserCreate, IUserUpdate} from "../../interfaces/IUser";
 
 class UserGqlProvider implements IUserProvider {
 
@@ -48,7 +48,7 @@ class UserGqlProvider implements IUserProvider {
         return data.createUser
     }
 
-    async paginateUser(page: number, limit: number, search:string = ""): Promise<IPaginateClient> {
+    async paginateUser(page: number, limit: number, search:string = ""): Promise<IPaginateClient<IUser>> {
         const query: string = `query paginateUser($page: Int, $limit: Int, $search:String) { 
             paginateUser(page: $page, limit: $limit, search: $search) { 
                 total, page, limit, items{ id, name username, email, phone, active, role{id, name} tenant{id name} } 

package/src/providers/rest/RoleRestProvider.ts

@@ -1,6 +1,6 @@
 import type {IHttpClient, IPaginateClient} from '@drax/common-front'
 import type {IRoleProvider} from "../../interfaces/IRoleProvider.ts";
-import type {IRole} from "../../interfaces/IRole";
+import type {IRole, IRoleBase} from "../../interfaces/IRole";
 
 class RoleRestProvider implements IRoleProvider {
 
@@ -30,12 +30,12 @@ class RoleRestProvider implements IRoleProvider {
         return role
     }
 
-    async createRole(data: IRole): Promise<any> {
+    async createRole(data: IRoleBase): Promise<any> {
             const url = '/api/roles'
             let role = await this.httpClient.post(url, data)
             return role
     }
-    async editRole(id: string, data: IRole): Promise<IRole> {
+    async editRole(id: string, data: IRoleBase): Promise<IRole> {
         const url = '/api/roles/' + id
         let user = await this.httpClient.put(url, data)
         return user as IRole
@@ -47,11 +47,11 @@ class RoleRestProvider implements IRoleProvider {
         return user
     }
 
-    async paginateRole(page: number = 1, limit: number = 5, search:string=""): Promise<IPaginateClient> {
+    async paginateRole(page: number = 1, limit: number = 5, search:string=""): Promise<IPaginateClient<IRole>> {
         const url = '/api/roles'
         const params = {page, limit, search}
         let paginatedRoles = await this.httpClient.get(url, {params})
-        return paginatedRoles as IPaginateClient
+        return paginatedRoles as IPaginateClient<IRole>
 
     }
 

package/src/providers/rest/TenantRestProvider.ts

@@ -42,11 +42,11 @@ class TenantRestProvider implements ITenantProvider {
         return user
     }
 
-    async paginateTenant(page: number = 1, limit: number = 5, search:string=""): Promise<IPaginateClient> {
+    async paginateTenant(page: number = 1, limit: number = 5, search:string=""): Promise<IPaginateClient<ITenant>> {
         const url = '/api/tenants'
         const params = {page, limit, search}
         let paginatedTenants = await this.httpClient.get(url, {params})
-        return paginatedTenants as IPaginateClient
+        return paginatedTenants as IPaginateClient<ITenant>
 
     }
 

package/src/providers/rest/UserRestProvider.ts

@@ -36,11 +36,11 @@ class UserRestProvider implements IUserProvider {
             return user
     }
 
-    async paginateUser(page: number = 1, limit: number = 5, search:string = ""): Promise<IPaginateClient> {
+    async paginateUser(page: number = 1, limit: number = 5, search:string = ""): Promise<IPaginateClient<IUser>> {
             const url = '/api/users'
             const params = {page, limit, search}
             let paginatedUsers = await this.httpClient.get(url, {params})
-            return paginatedUsers as IPaginateClient
+            return paginatedUsers as IPaginateClient<IUser>
 
     }
 

package/src/system/RoleSystem.ts

@@ -1,5 +1,5 @@
 import type {IRoleProvider} from "../interfaces/IRoleProvider";
-import type {IRole} from "../interfaces/IRole";
+import type {IRole, IRoleBase} from "../interfaces/IRole";
 import type {IPaginateClient} from "@drax/common-front";
 
 
@@ -21,15 +21,15 @@ class RoleSystem {
         return this._provider.fetchPermissions()
     }
 
-    async paginateRole(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient> {
+    async paginateRole(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient<IRole>> {
         return this._provider.paginateRole(page, perPage,search)
     }
 
-    async createRole(userPayload: IRole):Promise<IRole> {
+    async createRole(userPayload: IRoleBase):Promise<IRole> {
         return this._provider.createRole(userPayload)
     }
 
-    async editRole(id:string, userPayload: IRole):Promise<IRole> {
+    async editRole(id:string, userPayload: IRoleBase):Promise<IRole> {
         return this._provider.editRole(id, userPayload)
     }
 

package/src/system/TenantSystem.ts

@@ -1,5 +1,5 @@
 import type {ITenantProvider} from "../interfaces/ITenantProvider";
-import type {ITenant} from "../interfaces/ITenant";
+import type {ITenant, ITenantBase} from "../interfaces/ITenant";
 import type {IPaginateClient} from "@drax/common-front";
 
 
@@ -17,15 +17,15 @@ class TenantSystem {
         return this._provider.fetchTenant()
     }
 
-    async paginateTenant(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient> {
+    async paginateTenant(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient<ITenant>> {
         return this._provider.paginateTenant(page, perPage,search)
     }
 
-    async createTenant(userPayload: ITenant):Promise<ITenant> {
+    async createTenant(userPayload: ITenantBase):Promise<ITenant> {
         return this._provider.createTenant(userPayload)
     }
 
-    async editTenant(id:string, userPayload: ITenant):Promise<ITenant> {
+    async editTenant(id:string, userPayload: ITenantBase):Promise<ITenant> {
         return this._provider.editTenant(id, userPayload)
     }
 

package/src/system/UserSystem.ts

@@ -13,7 +13,7 @@ class UserSystem {
         this.prototype = 'UserSystem'
     }
 
-    async paginateUser(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient> {
+    async paginateUser(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient<IUser>> {
         return this._provider.paginateUser(page, perPage, search)
     }