@drax/identity-vue 0.40.0 → 0.43.0

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.40.0",
+  "version": "0.43.0",
   "type": "module",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
@@ -24,12 +24,12 @@
     "format": "prettier --write src/"
   },
   "dependencies": {
-    "@drax/common-front": "^0.40.0",
-    "@drax/common-vue": "^0.40.0",
-    "@drax/crud-front": "^0.40.0",
-    "@drax/crud-share": "^0.40.0",
-    "@drax/crud-vue": "^0.40.0",
-    "@drax/identity-share": "^0.40.0"
+    "@drax/common-front": "^0.43.0",
+    "@drax/common-vue": "^0.43.0",
+    "@drax/crud-front": "^0.43.0",
+    "@drax/crud-share": "^0.43.0",
+    "@drax/crud-vue": "^0.43.0",
+    "@drax/identity-share": "^0.43.0"
   },
   "peerDependencies": {
     "pinia": "^2.2.2",
@@ -66,5 +66,5 @@
     "vue-tsc": "^2.1.6",
     "vuetify": "^3.7.1"
   },
-  "gitHead": "269ec7921d83364dfba091cd74bd3f45a8135c26"
+  "gitHead": "3451a1c66eaf3facd4fef67d96750bf5d38a1d5c"
 }

package/src/combobox/RoleCombobox.vue

@@ -25,7 +25,7 @@ defineProps({
 const model = defineModel<any>()
 
 const {fetchRole} = useRole()
-let items = ref<IRole[]>([])
+let items = ref<IRole[]|undefined>([])
 
 onMounted(async () => {
   items.value = await fetchRole()

package/src/combobox/TenantCombobox.vue

@@ -1,5 +1,4 @@
 <script setup lang="ts">
-
 import {ref, onMounted, defineModel} from 'vue'
 import type { PropType } from 'vue'
 import {useI18n} from "vue-i18n";
@@ -9,6 +8,7 @@ defineProps({
   clearable: {type: Boolean, default: false},
   readonly: {type: Boolean, default: false},
   hideDetails: {type: Boolean, default: false},
+  refresh: {type: Boolean, default: false},
   itemTitle: {type: String, default: "name"},
   itemValue: {type: String, default: "_id"},
   rules: {type: Array as PropType<any[]>, default: () => []},
@@ -19,13 +19,18 @@ defineProps({
 
 const model = defineModel<any>()
 import {useTenant} from "../composables/useTenant";
-const {fetchTenant} = useTenant()
+const {fetchTenant, loading} = useTenant()
 let items = ref([])
 
 onMounted(async () => {
-  items.value = await fetchTenant()
+ await fillItems()
 })
 
+async function fillItems() {
+    loading.value = true
+    items.value = await fetchTenant()
+}
+
 
 </script>
 
@@ -43,7 +48,13 @@ onMounted(async () => {
       :readonly="readonly"
       :hide-details="hideDetails"
       :density="density"
-  ></v-select>
+      :loading="loading"
+  >
+    <template v-if="refresh" v-slot:prepend>
+      <v-btn @click="fillItems" icon="mdi-refresh" :loading="loading"></v-btn>
+    </template>
+
+  </v-select>
 </template>
 
 <style scoped>

package/src/components/SwitchTenant/SwitchTenant.vue

@@ -24,7 +24,12 @@ async function changeTenant() {
       <b>{{t('tenant.current')}}:</b> {{authStore.authUser?.tenant ? authStore.authUser?.tenant?.name : '-'}}
     </v-toolbar-title>
     <v-spacer></v-spacer>
-    <tenant-combobox v-model="tenant" hide-details variant="outlined" density="compact" clearable ></tenant-combobox>
+    <tenant-combobox v-model="tenant"
+                     hide-details
+                     variant="outlined"
+                     density="compact"
+                     clearable refresh
+    />
     <v-btn size="small" @click="changeTenant">{{t('action.change')}}</v-btn>
   </v-toolbar>
 

package/src/composables/useRole.ts

@@ -17,23 +17,33 @@ export function useRole() {
 
     async function fetchPermissions(page = 1, perPage = 5) {
         loading.value = true
-        let permissions = roleSystem.fetchPermissions()
+        let permissions = await roleSystem.fetchPermissions()
         loading.value = false
         return permissions
     }
 
     async function fetchRole(page = 1, perPage = 5) {
-        loading.value = true
-        let roles = roleSystem.fetchRole()
-        loading.value = false
-        return roles
+        try {
+            loading.value = true
+            let roles = await roleSystem.fetchRole()
+            return roles
+        } catch (e) {
+            console.error(e)
+        } finally {
+            loading.value = false
+        }
     }
 
     async function paginateRole({page = 1, limit = 5, orderBy = "", order = "asc", search = ""}: IDraxPaginateOptions) {
-        loading.value = true
-        let paginatedrole = roleSystem.paginate({page, limit, orderBy, order, search})
-        loading.value = false
-        return paginatedrole
+        try {
+            loading.value = true
+            let paginatedrole = await roleSystem.paginate({page, limit, orderBy, order, search})
+            return paginatedrole
+        } catch (e) {
+            console.error(e)
+        } finally {
+            loading.value = false
+        }
     }
 
     async function createRole(roleData: IRoleBase) {

package/src/composables/useTenant.ts

@@ -1,47 +1,64 @@
 import {ref} from "vue";
 import type {ITenant, ITenantBase} from "@drax/identity-share";
-import type { TenantSystem} from "@drax/identity-front";
-import { TenantSystemFactory} from "@drax/identity-front";
+import type {TenantSystem} from "@drax/identity-front";
+import {TenantSystemFactory} from "@drax/identity-front";
 import {ClientError} from "@drax/common-front";
-import type { IClientInputError} from "@drax/common-front";
+import type {IClientInputError} from "@drax/common-front";
 import type {IDraxPaginateOptions} from "@drax/crud-share";
 
 
 export function useTenant() {
 
-    const tenantSystem : TenantSystem = TenantSystemFactory.getInstance()
+    const tenantSystem: TenantSystem = TenantSystemFactory.getInstance()
 
     let tenantError = ref<string>('')
     let inputErrors = ref<IClientInputError>()
     let loading = ref(false);
 
     async function fetchTenant(page = 1, perPage = 5) {
-        loading.value = true
-        let tenants = tenantSystem.fetchTenant()
-        loading.value = false
-        return tenants
+        try {
+            loading.value = true
+            let tenants = await tenantSystem.fetchTenant()
+            return tenants
+        } catch (e) {
+            console.error(e)
+        } finally {
+            loading.value = false
+        }
     }
 
-    async function paginateTenant({page= 1, limit= 5, orderBy="", order="asc", search = ""}: IDraxPaginateOptions) {
-        loading.value = true
-        let paginatedtenant = tenantSystem.paginate({page, limit, orderBy, order, search})
-        loading.value = false
-        return paginatedtenant
+    async function paginateTenant({
+                                      page = 1,
+                                      limit = 5,
+                                      orderBy = "",
+                                      order = "asc",
+                                      search = ""
+                                  }: IDraxPaginateOptions) {
+        try {
+            loading.value = true
+            let paginatedtenant = await tenantSystem.paginate({page, limit, orderBy, order, search})
+            return paginatedtenant
+        } catch (e) {
+            console.error(e)
+        } finally {
+            loading.value = false
+        }
     }
 
     async function createTenant(tenantData: ITenantBase) {
         try {
             loading.value = true
-            let tenant: ITenant =  await tenantSystem.create(tenantData)
+            let tenant: ITenant = await tenantSystem.create(tenantData)
             return tenant
         } catch (err) {
             if (err instanceof ClientError) {
                 inputErrors.value = err.inputErrors
-            }if(err instanceof Error) {
+            }
+            if (err instanceof Error) {
                 tenantError.value = err.message
             }
             throw err
-        }finally {
+        } finally {
             loading.value = false
         }
 
@@ -57,11 +74,11 @@ export function useTenant() {
             if (err instanceof ClientError) {
                 inputErrors.value = err.inputErrors
             }
-            if(err instanceof Error) {
+            if (err instanceof Error) {
                 tenantError.value = err.message
             }
             throw err
-        }finally {
+        } finally {
             loading.value = false
         }
     }
@@ -71,19 +88,19 @@ export function useTenant() {
             loading.value = true
             await tenantSystem.delete(id)
         } catch (err) {
-            console.log("composable delete error: ", err, )
+            console.log("composable delete error: ", err,)
             if (err instanceof ClientError) {
                 inputErrors.value = err.inputErrors
             }
-            if(err instanceof Error) {
+            if (err instanceof Error) {
                 tenantError.value = err.message
             }
             throw err
-        }finally {
+        } finally {
             loading.value = false
         }
     }
 
-    return {fetchTenant,  paginateTenant, createTenant, editTenant, deleteTenant, loading, tenantError, inputErrors}
+    return {fetchTenant, paginateTenant, createTenant, editTenant, deleteTenant, loading, tenantError, inputErrors}
 
 }

package/src/composables/useUser.ts

@@ -1,6 +1,6 @@
 import {ref} from "vue";
 import type {UserSystem} from "@drax/identity-front";
-import  {UserSystemFactory} from "@drax/identity-front";
+import {UserSystemFactory} from "@drax/identity-front";
 import type {IClientInputError} from "@drax/common-front";
 import {ClientError} from "@drax/common-front";
 import type {IUser, IUserCreate, IUserUpdate} from "@drax/identity-share";
@@ -15,32 +15,38 @@ export function useUser() {
     let inputErrors = ref<IClientInputError>()
     let loading = ref(false);
 
-    async function paginateUser({page= 1, limit= 5, orderBy="", order = "asc", search = ""}:IDraxPaginateOptions) {
-        loading.value = true
-        let paginatedUser = userSystem.paginate({page, limit, orderBy, order, search})
-        loading.value = false
-        return paginatedUser
+    async function paginateUser({page = 1, limit = 5, orderBy = "", order = "asc", search = ""}: IDraxPaginateOptions) {
+        try {
+            loading.value = true
+            let paginatedUser = await userSystem.paginate({page, limit, orderBy, order, search})
+            return paginatedUser
+        } catch (e) {
+            console.error(e)
+        } finally {
+            loading.value = false
+        }
     }
 
     async function createUser(userData: IUserCreate) {
         try {
             loading.value = true
-            let user: IUser =  await userSystem.create(userData)
+            let user: IUser = await userSystem.create(userData)
             return user
         } catch (err) {
             if (err instanceof ClientError) {
                 inputErrors.value = err.inputErrors
-            }if(err instanceof Error) {
+            }
+            if (err instanceof Error) {
                 userError.value = err.message
             }
             throw err
-        }finally {
+        } finally {
             loading.value = false
         }
 
     }
 
-    async function changeUserPassword(id: string, newPassword: string){
+    async function changeUserPassword(id: string, newPassword: string) {
         try {
             loading.value = true
             return await userSystem.changeUserPassword(id, newPassword)
@@ -48,11 +54,11 @@ export function useUser() {
             if (err instanceof ClientError) {
                 inputErrors.value = err.inputErrors
             }
-            if(err instanceof Error) {
+            if (err instanceof Error) {
                 userError.value = err.message
             }
             throw err
-        }finally {
+        } finally {
             loading.value = false
         }
     }
@@ -66,11 +72,11 @@ export function useUser() {
             if (err instanceof ClientError) {
                 inputErrors.value = err.inputErrors
             }
-            if(err instanceof Error) {
+            if (err instanceof Error) {
                 userError.value = err.message
             }
             throw err
-        }finally {
+        } finally {
             loading.value = false
         }
     }
@@ -80,15 +86,15 @@ export function useUser() {
             loading.value = true
             await userSystem.delete(id)
         } catch (err) {
-            console.log("composable delete error: ", err, )
+            console.log("composable delete error: ", err,)
             if (err instanceof ClientError) {
                 inputErrors.value = err.inputErrors
             }
-            if(err instanceof Error) {
+            if (err instanceof Error) {
                 userError.value = err.message
             }
             throw err
-        }finally {
+        } finally {
             loading.value = false
         }
     }