@drax/identity-front 0.0.22 → 0.0.25

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.22",
+  "version": "0.0.25",
   "type": "module",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
@@ -24,7 +24,9 @@
     "format": "prettier --write src/"
   },
   "dependencies": {
-    "@drax/common-front": "^0.0.22"
+    "@drax/common-front": "^0.0.25",
+    "@drax/common-share": "^0.0.25",
+    "@drax/identity-share": "^0.0.25"
   },
   "devDependencies": {
     "@rushstack/eslint-patch": "^1.8.0",
@@ -46,5 +48,5 @@
     "vite-plugin-dts": "^3.9.1",
     "vitest": "^1.4.0"
   },
-  "gitHead": "2ff21dad6e1e9cc9119bf3c3095c3b291d850e53"
+  "gitHead": "606497ae64684b17c757a72ed57a4a7dda0f1f8e"
 }

package/src/index.ts

@@ -28,9 +28,7 @@ import type {IUserProvider} from "./interfaces/IUserProvider"
 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, IRoleBase} from "./interfaces/IRole"
-import type {ITenant, ITenantBase} from "./interfaces/ITenant"
+import type {IUserPassword} from "./interfaces/IUserPassword"
 import type {ILoginResponse} from "./interfaces/ILoginResponse"
 
 export type {
@@ -39,9 +37,6 @@ export type {
     IRoleProvider,
     ITenantProvider,
     IAuthUser,
-    IUser, IUserCreate, IUserUpdate,
-    IRole, IRoleBase,
-    ITenant, ITenantBase,
     IUserPassword,
     ILoginResponse
 }

package/src/interfaces/IAuthUser.ts

@@ -1,4 +1,4 @@
-import type {IRole} from "./IRole";
+import type {IRole} from "@drax/identity-share";
 
 interface IAuthUser {
     id: string

package/src/interfaces/IRoleProvider.ts

@@ -1,13 +1,9 @@
-import type {IRole, IRoleBase} from "./IRole";
-import type {IPaginateClient} from "@drax/common-front";
+import type {IRole, IRoleBase} from "@drax/identity-share";
+import type {IDraxCrud} from "@drax/common-share";
 
-interface IRoleProvider {
+interface IRoleProvider extends IDraxCrud<IRole, IRoleBase, IRoleBase>{
     fetchRole(): Promise<IRole[]>
     fetchPermissions(): Promise<any>
-    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>
 }
 
 export type {IRoleProvider}

package/src/interfaces/ITenantProvider.ts

@@ -1,12 +1,8 @@
-import type {ITenant, ITenantBase} from "./ITenant";
-import type {IPaginateClient} from "@drax/common-front";
+import type {ITenant, ITenantBase} from "@drax/identity-share";
+import type {IDraxCrud} from "@drax/common-share";
 
-interface ITenantProvider {
+interface ITenantProvider extends IDraxCrud<ITenant, ITenantBase, ITenantBase> {
     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>
 }
 
 export type {ITenantProvider}

package/src/interfaces/IUserPassword.ts

@@ -0,0 +1,6 @@
+interface IUserPassword{
+    newPassword: string
+    confirmPassword: string
+}
+
+export type {IUserPassword}

package/src/interfaces/IUserProvider.ts

@@ -1,13 +1,8 @@
-import type {IUser, IUserCreate, IUserUpdate} from "./IUser";
-import type {IPaginateClient} from "@drax/common-front";
+import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
+import type {IDraxCrud} from "@drax/common-share";
 
 
-
-interface IUserProvider {
-    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>
+interface IUserProvider extends IDraxCrud<IUser, IUserCreate, IUserUpdate>{
     changeUserPassword(id: string, newPassword: string): Promise<boolean>
 }
 

package/src/providers/gql/RoleGqlProvider.ts

@@ -1,6 +1,7 @@
-import type {IGqlClient, IPaginateClient} from '@drax/common-front'
+import type {IGqlClient} from '@drax/common-front'
 import type {IRoleProvider} from "../../interfaces/IRoleProvider";
-import type {IRole, IRoleBase} from "../../interfaces/IRole";
+import type {IRole, IRoleBase} from "@drax/identity-share";
+import type {IDraxPaginateResult} from "@drax/common-share";
 
 
 class RoleGqlProvider implements IRoleProvider {
@@ -33,7 +34,7 @@ class RoleGqlProvider implements IRoleProvider {
         return data.fetchRole
     }
 
-    async createRole(payload: IRoleBase): Promise<IRole> {
+    async create(payload: IRoleBase): Promise<IRole> {
         const query: string = `mutation createRole($input: RoleInput) { 
         createRole(input: $input) {id name permissions childRoles{id name} readonly } 
         }`
@@ -42,7 +43,7 @@ class RoleGqlProvider implements IRoleProvider {
         return data.createRole
     }
 
-    async editRole(id: string, payload: IRoleBase): Promise<IRole> {
+    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  } }`
         const variables = {id, input: payload}
@@ -50,20 +51,20 @@ class RoleGqlProvider implements IRoleProvider {
         return data.createRole
     }
 
-    async deleteRole(id: string): Promise<any> {
+    async delete(id: string): Promise<any> {
         const query: string = `mutation deleteRole($id: ID!) { deleteRole(id: $id) }`
         const variables = {id: id}
         let data = await this.gqlClient.mutation(query, variables)
         return data.createRole
     }
 
-    async paginateRole(page: number, limit: number, search:string = ""): Promise<IPaginateClient<IRole>> {
-        const query: string = `query paginateRole($page: Int, $limit: Int, $search:String) { 
+    async paginate({page= 1, limit= 5, orderBy="", orderDesc=false, search = ""}): Promise<IDraxPaginateResult<IRole>> {
+        const query: string = `query paginateRole($options: PaginateOptions) { 
             paginateRole(page: $page, limit: $limit, search: $search) { 
                 total, page, limit, items{id name permissions childRoles{id name} readonly } 
             } 
         }`
-        const variables = {page, limit,search}
+        const variables = {options: {page, limit, orderBy, orderDesc, search}}
         let data = await this.gqlClient.query(query, variables)
         return data.paginateRole
     }

package/src/providers/gql/TenantGqlProvider.ts

@@ -1,6 +1,7 @@
-import type {IGqlClient, IPaginateClient} from '@drax/common-front'
+import type {IGqlClient} from '@drax/common-front'
 import type {ITenantProvider} from "../../interfaces/ITenantProvider";
-import type {ITenant} from "../../interfaces/ITenant";
+import type {ITenant, ITenantBase} from "@drax/identity-share";
+import type {IDraxPaginateResult} from "@drax/common-share";
 
 
 class TenantGqlProvider implements ITenantProvider {
@@ -27,7 +28,7 @@ class TenantGqlProvider implements ITenantProvider {
         return data.fetchTenant
     }
 
-    async createTenant(payload: ITenant): Promise<any> {
+    async create(payload: ITenantBase): Promise<any> {
         const query: string = `mutation createTenant($input: TenantInput) { 
         createTenant(input: $input) {id name } 
         }`
@@ -36,7 +37,7 @@ class TenantGqlProvider implements ITenantProvider {
         return data.createTenant
     }
 
-    async editTenant(id: string, payload: ITenant): Promise<ITenant> {
+    async update(id: string, payload: ITenantBase): Promise<ITenant> {
         const query: string = `mutation updateTenant($id: ID!, $input: TenantInput) { updateTenant(id: $id, input: $input) {  
         id name  } }`
         const variables = {id, input: payload}
@@ -44,20 +45,20 @@ class TenantGqlProvider implements ITenantProvider {
         return data.createTenant
     }
 
-    async deleteTenant(id: string): Promise<any> {
+    async delete(id: string): Promise<any> {
         const query: string = `mutation deleteTenant($id: ID!) { deleteTenant(id: $id) }`
         const variables = {id: id}
         let data = await this.gqlClient.mutation(query, variables)
         return data.createTenant
     }
 
-    async paginateTenant(page: number, limit: number, search:string = ""): Promise<IPaginateClient<ITenant>> {
-        const query: string = `query paginateTenant($page: Int, $limit: Int, $search:String) { 
+    async paginate({page= 1, limit= 5, orderBy="", orderDesc=false, search = ""}): Promise<IDraxPaginateResult<ITenant>> {
+        const query: string = `query paginateTenant($options: PaginateOptions) { 
             paginateTenant(page: $page, limit: $limit, search: $search) { 
                 total, page, limit, items{id, name } 
             } 
         }`
-        const variables = {page, limit,search}
+        const variables = {options: {page, limit, orderBy, orderDesc, search}}
         let data = await this.gqlClient.query(query, variables)
         return data.paginateTenant
     }

package/src/providers/gql/UserGqlProvider.ts

@@ -1,6 +1,7 @@
-import type {IGqlClient, IPaginateClient} from '@drax/common-front'
+import type {IGqlClient} from '@drax/common-front'
 import type {IUserProvider} from "../../interfaces/IUserProvider";
-import type {IUser, IUserCreate, IUserUpdate} from "../../interfaces/IUser";
+import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
+import type {IDraxPaginateResult} from "@drax/common-share";
 
 class UserGqlProvider implements IUserProvider {
 
@@ -18,7 +19,7 @@ class UserGqlProvider implements IUserProvider {
         this.gqlClient.removeHeader('Authorization')
     }
 
-    async createUser(payload: IUserCreate): Promise<IUser> {
+    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}  } }`
         const variables = {input: payload}
@@ -26,7 +27,7 @@ class UserGqlProvider implements IUserProvider {
         return data.createUser
     }
 
-    async editUser(id: string, payload: IUserUpdate): Promise<IUser> {
+    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}  } }`
         const variables = {id, input: payload}
@@ -41,20 +42,20 @@ class UserGqlProvider implements IUserProvider {
         return data.changeUserPassword
     }
 
-    async deleteUser(id: string): Promise<any> {
+    async delete(id: string): Promise<any> {
         const query: string = `mutation deleteUser($id: ID!) { deleteUser(id: $id) }`
         const variables = {id: id}
         let data = await this.gqlClient.mutation(query, variables)
         return data.createUser
     }
 
-    async paginateUser(page: number, limit: number, search:string = ""): Promise<IPaginateClient<IUser>> {
-        const query: string = `query paginateUser($page: Int, $limit: Int, $search:String) { 
+    async paginate({page= 1, limit= 5, orderBy="", orderDesc=false, search = ""}): Promise<IDraxPaginateResult<IUser>> {
+        const query: string = `query paginateUser($options: PaginateOptions) { 
             paginateUser(page: $page, limit: $limit, search: $search) { 
                 total, page, limit, items{ id, name username, email, phone, active, role{id, name} tenant{id name} } 
             } 
         }`
-        const variables = {page, limit, search}
+        const variables = {options: {page, limit, orderBy, orderDesc, search}}
         let data = await this.gqlClient.query(query, variables)
         return data.paginateUser
     }

package/src/providers/rest/RoleRestProvider.ts

@@ -1,6 +1,7 @@
-import type {IHttpClient, IPaginateClient} from '@drax/common-front'
+import type {IHttpClient} from '@drax/common-front'
 import type {IRoleProvider} from "../../interfaces/IRoleProvider.ts";
-import type {IRole, IRoleBase} from "../../interfaces/IRole";
+import type {IRole, IRoleBase} from "@drax/identity-share";
+import type {IDraxPaginateResult} from "@drax/common-share";
 
 class RoleRestProvider implements IRoleProvider {
 
@@ -10,13 +11,6 @@ class RoleRestProvider implements IRoleProvider {
         this.httpClient = httpClient
     }
 
-    setHttpClientToken(token: string): void {
-        this.httpClient.addHeader('Authorization', `Bearer ${token}`)
-    }
-
-    removeHttpClientToken(): void {
-        this.httpClient.removeHeader('Authorization')
-    }
 
     async fetchPermissions(): Promise<any> {
         const url = '/api/permissions'
@@ -30,28 +24,28 @@ class RoleRestProvider implements IRoleProvider {
         return role
     }
 
-    async createRole(data: IRoleBase): Promise<any> {
+    async create(data: IRoleBase): Promise<any> {
             const url = '/api/roles'
             let role = await this.httpClient.post(url, data)
             return role
     }
-    async editRole(id: string, data: IRoleBase): Promise<IRole> {
+    async update(id: string, data: IRoleBase): Promise<IRole> {
         const url = '/api/roles/' + id
         let user = await this.httpClient.put(url, data)
         return user as IRole
     }
 
-    async deleteRole(id: string): Promise<any> {
+    async delete(id: string): Promise<any> {
         const url = '/api/roles/' + id
         let user = await this.httpClient.delete(url)
         return user
     }
 
-    async paginateRole(page: number = 1, limit: number = 5, search:string=""): Promise<IPaginateClient<IRole>> {
+    async paginate({page= 1, limit= 5, orderBy="", orderDesc=false, search = ""}): Promise<IDraxPaginateResult<IRole>> {
         const url = '/api/roles'
-        const params = {page, limit, search}
+        const params = {page, limit, orderBy, orderDesc, search}
         let paginatedRoles = await this.httpClient.get(url, {params})
-        return paginatedRoles as IPaginateClient<IRole>
+        return paginatedRoles as IDraxPaginateResult<IRole>
 
     }
 

package/src/providers/rest/TenantRestProvider.ts

@@ -1,6 +1,7 @@
-import type {IHttpClient, IPaginateClient} from '@drax/common-front'
+import type {IHttpClient} from '@drax/common-front'
 import type {ITenantProvider} from "../../interfaces/ITenantProvider.ts";
-import type {ITenant} from "../../interfaces/ITenant";
+import type {ITenant, ITenantBase} from "@drax/identity-share";
+import type {IDraxPaginateResult} from "@drax/common-share";
 
 class TenantRestProvider implements ITenantProvider {
 
@@ -10,13 +11,6 @@ class TenantRestProvider implements ITenantProvider {
         this.httpClient = httpClient
     }
 
-    setHttpClientToken(token: string): void {
-        this.httpClient.addHeader('Authorization', `Bearer ${token}`)
-    }
-
-    removeHttpClientToken(): void {
-        this.httpClient.removeHeader('Authorization')
-    }
 
 
     async fetchTenant(): Promise<any> {
@@ -25,28 +19,28 @@ class TenantRestProvider implements ITenantProvider {
         return tenant
     }
 
-    async createTenant(data: ITenant): Promise<any> {
+    async create(data: ITenantBase): Promise<any> {
             const url = '/api/tenants'
             let tenant = await this.httpClient.post(url, data)
             return tenant
     }
-    async editTenant(id: string, data: ITenant): Promise<ITenant> {
+    async update(id: string, data: ITenantBase): Promise<ITenant> {
         const url = '/api/tenants/' + id
         let user = await this.httpClient.put(url, data)
         return user as ITenant
     }
 
-    async deleteTenant(id: string): Promise<any> {
+    async delete(id: string): Promise<any> {
         const url = '/api/tenants/' + id
         let user = await this.httpClient.delete(url)
         return user
     }
 
-    async paginateTenant(page: number = 1, limit: number = 5, search:string=""): Promise<IPaginateClient<ITenant>> {
+    async paginate({page= 1, limit= 5, orderBy="", orderDesc=false, search = ""}): Promise<IDraxPaginateResult<ITenant>> {
         const url = '/api/tenants'
-        const params = {page, limit, search}
+        const params = {page, limit, orderBy, orderDesc, search}
         let paginatedTenants = await this.httpClient.get(url, {params})
-        return paginatedTenants as IPaginateClient<ITenant>
+        return paginatedTenants as IDraxPaginateResult<ITenant>
 
     }
 

package/src/providers/rest/UserRestProvider.ts

@@ -1,6 +1,8 @@
-import type {IHttpClient, IPaginateClient} from '@drax/common-front'
+import type {IHttpClient} from '@drax/common-front'
 import type {IUserProvider} from "../../interfaces/IUserProvider.ts";
-import type {IUser, IUserCreate, IUserUpdate} from "../../interfaces/IUser.ts";
+import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
+import type {IDraxPaginateResult} from "@drax/common-share";
+
 
 class UserRestProvider implements IUserProvider {
 
@@ -10,37 +12,30 @@ class UserRestProvider implements IUserProvider {
         this.httpClient = httpClient
     }
 
-    setHttpClientToken(token: string): void {
-        this.httpClient.addHeader('Authorization', `Bearer ${token}`)
-    }
 
-    removeHttpClientToken(): void {
-        this.httpClient.removeHeader('Authorization')
-    }
-
-    async createUser(data: IUserCreate): Promise<IUser> {
+    async create(data: IUserCreate): Promise<IUser> {
             const url = '/api/users'
             let user = await this.httpClient.post(url, data)
             return user as IUser
     }
 
-    async editUser(id: string, data: IUserUpdate): Promise<IUser> {
+    async update(id: string, data: IUserUpdate): Promise<IUser> {
             const url = '/api/users/' + id
             let user = await this.httpClient.put(url, data)
             return user as IUser
     }
 
-    async deleteUser(id: string): Promise<any> {
+    async delete(id: string): Promise<any> {
             const url = '/api/users/' + id
             let user = await this.httpClient.delete(url)
             return user
     }
 
-    async paginateUser(page: number = 1, limit: number = 5, search:string = ""): Promise<IPaginateClient<IUser>> {
-            const url = '/api/users'
-            const params = {page, limit, search}
+    async paginate({page= 1, limit= 5, orderBy="", orderDesc=false, search = ""}): Promise<IDraxPaginateResult<IUser>> {
+        const url = '/api/users'
+        const params = {page, limit, orderBy, orderDesc, search}
             let paginatedUsers = await this.httpClient.get(url, {params})
-            return paginatedUsers as IPaginateClient<IUser>
+            return paginatedUsers as IDraxPaginateResult<IUser>
 
     }
 

package/src/system/RoleSystem.ts

@@ -1,9 +1,9 @@
 import type {IRoleProvider} from "../interfaces/IRoleProvider";
-import type {IRole, IRoleBase} from "../interfaces/IRole";
-import type {IPaginateClient} from "@drax/common-front";
+import type {IRole, IRoleBase} from "@drax/identity-share";
+import type {IDraxPaginateResult} from "@drax/common-share";
 
 
-class RoleSystem {
+class RoleSystem implements IRoleProvider {
 
     _provider: IRoleProvider
     prototype: string;
@@ -21,20 +21,20 @@ class RoleSystem {
         return this._provider.fetchPermissions()
     }
 
-    async paginateRole(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient<IRole>> {
-        return this._provider.paginateRole(page, perPage,search)
+    async paginate({page= 1, limit= 5, orderBy="", orderDesc=false, search = ""}): Promise<IDraxPaginateResult<IRole>> {
+        return this._provider.paginate({page, limit, orderBy, orderDesc, search})
     }
 
-    async createRole(userPayload: IRoleBase):Promise<IRole> {
-        return this._provider.createRole(userPayload)
+    async create(userPayload: IRoleBase):Promise<IRole> {
+        return this._provider.create(userPayload)
     }
 
-    async editRole(id:string, userPayload: IRoleBase):Promise<IRole> {
-        return this._provider.editRole(id, userPayload)
+    async update(id:string, userPayload: IRoleBase):Promise<IRole> {
+        return this._provider.update(id, userPayload)
     }
 
-    async deleteRole(id: string):Promise<any> {
-        return this._provider.deleteRole(id)
+    async delete(id: string):Promise<any> {
+        return this._provider.delete(id)
     }
 
 }

package/src/system/TenantSystem.ts

@@ -1,6 +1,6 @@
 import type {ITenantProvider} from "../interfaces/ITenantProvider";
-import type {ITenant, ITenantBase} from "../interfaces/ITenant";
-import type {IPaginateClient} from "@drax/common-front";
+import type {ITenant, ITenantBase} from "@drax/identity-share";
+import type {IDraxPaginateResult} from "@drax/common-share";
 
 
 class TenantSystem {
@@ -17,20 +17,20 @@ class TenantSystem {
         return this._provider.fetchTenant()
     }
 
-    async paginateTenant(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient<ITenant>> {
-        return this._provider.paginateTenant(page, perPage,search)
+    async paginate({page= 1, limit= 5, orderBy="", orderDesc=false, search = ""}):Promise<IDraxPaginateResult<ITenant>> {
+        return this._provider.paginate({page, limit, orderBy, orderDesc, search})
     }
 
-    async createTenant(userPayload: ITenantBase):Promise<ITenant> {
-        return this._provider.createTenant(userPayload)
+    async create(userPayload: ITenantBase):Promise<ITenant> {
+        return this._provider.create(userPayload)
     }
 
-    async editTenant(id:string, userPayload: ITenantBase):Promise<ITenant> {
-        return this._provider.editTenant(id, userPayload)
+    async update(id:string, userPayload: ITenantBase):Promise<ITenant> {
+        return this._provider.update(id, userPayload)
     }
 
-    async deleteTenant(id: string):Promise<any> {
-        return this._provider.deleteTenant(id)
+    async delete(id: string):Promise<any> {
+        return this._provider.delete(id)
     }
 
 }

package/src/system/UserSystem.ts

@@ -1,6 +1,6 @@
 import type {IUserProvider} from "../interfaces/IUserProvider";
-import type {IUser, IUserCreate, IUserUpdate} from "../interfaces/IUser";
-import type {IPaginateClient} from "@drax/common-front";
+import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
+import type {IDraxPaginateResult} from "@drax/common-share";
 
 
 class UserSystem {
@@ -13,16 +13,16 @@ class UserSystem {
         this.prototype = 'UserSystem'
     }
 
-    async paginateUser(page:number = 1, perPage:number = 5, search:string=""):Promise<IPaginateClient<IUser>> {
-        return this._provider.paginateUser(page, perPage, search)
+    async paginate({page= 1, limit= 5, orderBy="", orderDesc=false, search = ""}):Promise<IDraxPaginateResult<IUser>> {
+        return this._provider.paginate({page, limit, orderBy, orderDesc, search})
     }
 
-    async createUser(userPayload: IUserCreate):Promise<IUser> {
-        return this._provider.createUser(userPayload)
+    async create(userPayload: IUserCreate):Promise<IUser> {
+        return this._provider.create(userPayload)
     }
 
-    async editUser(id:string, userPayload: IUserUpdate):Promise<IUser> {
-        return this._provider.editUser(id, userPayload)
+    async update(id:string, userPayload: IUserUpdate):Promise<IUser> {
+        return this._provider.update(id, userPayload)
     }
 
     async changeUserPassword(userId:string, newPassword:string):Promise<boolean> {
@@ -31,8 +31,8 @@ class UserSystem {
         return result
     }
 
-    async deleteUser(id: string):Promise<any> {
-        return this._provider.deleteUser(id)
+    async delete(id: string):Promise<any> {
+        return this._provider.delete(id)
     }
 
 }

package/src/interfaces/IRole.ts

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

package/src/interfaces/ITenant.ts

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

package/src/interfaces/IUser.ts

@@ -1,42 +0,0 @@
-import type {IRole} from "./IRole";
-import type {ITenant} from "./ITenant";
-
-interface IUser {
-    id: string
-    name: string
-    username: string
-    email: string
-    active: boolean
-    phone: string
-    avatar: string
-    role: IRole
-    tenant: ITenant
-}
-
-interface IUserCreate {
-    name: string
-    username: string
-    password: string
-    email: string
-    active: boolean
-    phone: string
-    role: string
-    tenant: string
-}
-
-interface IUserUpdate {
-    name: string
-    username: string
-    email: string
-    active: boolean
-    phone: string
-    role: string|undefined
-    tenant: string|undefined
-}
-
-interface IUserPassword {
-    newPassword: string
-    confirmPassword: string
-}
-
-export type {IUser, IUserCreate, IUserUpdate, IUserPassword}