adminforth 1.1.12 → 1.1.14

package/index.ts

@@ -1,5 +1,5 @@
 
-import Auth from './auth.js';
+import AdminForthAuth from './auth.js';
 import MongoConnector from './dataConnectors/mongo.js';
 import PostgresConnector from './dataConnectors/postgres.js';
 import SQLiteConnector from './dataConnectors/sqlite.js';
@@ -8,10 +8,13 @@ import { guessLabelFromName } from './modules/utils.js';
 import ExpressServer from './servers/express.js';
 import {v1 as uuid} from 'uuid';
 import fs from 'fs';
-import { ADMINFORTH_VERSION } from './modules/utils.js';
+import { ADMINFORTH_VERSION, listify } from './modules/utils.js';
 import { AdminForthConfig, AdminForthClass, AdminForthComponentDeclaration, AdminForthComponentDeclarationFull,
-  AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages } from './types/AdminForthConfig.js';
-import { getFunctionList } from './modules/utils.js';
+  AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, GenericHttpServer, 
+  BeforeSaveFunction,
+  AfterSaveFunction,
+  BeforeDataSourceRequestFunction,
+  AfterDataSourceResponseFunction} from './types/AdminForthConfig.js';
 import path from 'path';
 import AdminForthPlugin from './plugins/base.js';
 
@@ -26,7 +29,7 @@ class AdminForth implements AdminForthClass {
 
   static Utils = {
     generatePasswordHash: async (password) => {
-      return await Auth.generatePasswordHash(password);
+      return await AdminForthAuth.generatePasswordHash(password);
     }
   }
 
@@ -36,7 +39,7 @@ class AdminForth implements AdminForthClass {
 
   config: AdminForthConfig;
   express: ExpressServer;
-  auth: Auth;
+  auth: AdminForthAuth;
   codeInjector: CodeInjector;
   connectors: any;
   connectorClasses: any;
@@ -57,7 +60,7 @@ class AdminForth implements AdminForthClass {
     this.validateConfig(); // revalidate after plugins
 
     this.express = new ExpressServer(this);
-    this.auth = new Auth();
+    this.auth = new AdminForthAuth(this);
     this.connectors = {};
     this.statuses = {};
 
@@ -83,7 +86,7 @@ class AdminForth implements AdminForthClass {
     return [];
   }
 
-  validateComponent(component: AdminForthComponentDeclaration, errors: Array<string>): AdminForthComponentDeclaration {
+  validateComponent(component: AdminForthComponentDeclaration, errors: Array<string>, ignoreExistsCheck: boolean = false): AdminForthComponentDeclaration {
     if (!component) {
       return component;
     }
@@ -93,7 +96,9 @@ class AdminForth implements AdminForthClass {
     } else {
       obj = component;
     }
-    errors.push(...this.checkCustomFileExists(obj.file));
+    if (!ignoreExistsCheck) {
+      errors.push(...this.checkCustomFileExists(obj.file));
+    }
     
     return obj;
   }
@@ -235,7 +240,7 @@ class AdminForth implements AdminForthClass {
         if(res.options?.bulkActions){
           let bulkActions = res.options.bulkActions;
 
-          if(!Array.isArray(bulkActions)){
+          if (!Array.isArray(bulkActions)) {
             errors.push(`Resource "${res.resourceId}" bulkActions must be an array`);
             bulkActions = [];
           }
@@ -292,7 +297,40 @@ class AdminForth implements AdminForthClass {
         } else {
           res.options.allowedActions = DEFAULT_ALLOWED_ACTIONS;
         }
-      })
+
+        // transform all hooks Functions to array of functions
+        if (res.hooks) {
+          for (const value of [res.hooks.show, res.hooks.list]) {
+            if (value) {
+              if (value.beforeDatasourceRequest) {
+                if (!Array.isArray(value.beforeDatasourceRequest)) {
+                  value.beforeDatasourceRequest = [value.beforeDatasourceRequest];
+                }
+              }
+              if (value.afterDatasourceResponse) {
+                if (!Array.isArray(value.afterDatasourceResponse)) {
+                  value.afterDatasourceResponse = [value.afterDatasourceResponse];
+                }
+              }
+            }
+          }
+          for (const value of [res.hooks.create, res.hooks.edit, res.hooks.delete]) {
+            if (value) {
+
+              if (value.beforeSave) {
+                if (!Array.isArray(value.beforeSave)) {
+                  value.beforeSave = [value.beforeSave];
+                }
+              }
+              if (value.afterSave) {
+                if (!Array.isArray(value.afterSave)) {
+                  value.afterSave = [value.afterSave];
+                }
+              }
+            }
+          }
+        }
+      });
     
 
 
@@ -371,15 +409,15 @@ class AdminForth implements AdminForthClass {
     for (const resource of this.config.resources) {
       for (const column of resource.columns) {
           if (column.components) {
-            console.log('🔧🔧🔧 Validating components for resource', column.components);
 
-            for (const comp of Object.values(column.components) as Array<AdminForthComponentDeclarationFull>) {
-                if (this.codeInjector.allComponentNames[comp.file]) {
-                    // not obvious, but if we are in this if, it means that this is plugin component
-                    // and there is no sense to check if it exists in users folder
-                    continue;
-                }
-                this.validateComponent(comp, errors);
+            for (const [key, comp] of Object.entries(column.components as Record<string, AdminForthComponentDeclarationFull>)) {
+              let ignoreExistsCheck = false;
+              if (this.codeInjector.allComponentNames[comp.file]) {
+                  // not obvious, but if we are in this if, it means that this is plugin component
+                  // and there is no sense to check if it exists in users folder
+                  ignoreExistsCheck = true;
+              }
+              column.components[key] = this.validateComponent(comp, errors, ignoreExistsCheck);
             }
         }
       }
@@ -458,7 +496,24 @@ class AdminForth implements AdminForthClass {
     this.codeInjector.bundleNow({ hotReload, verbose });
   }
 
-  setupEndpoints(server) {
+  async getUserByPk(pk: string) {
+    const resource = this.config.resources.find((res) => res.resourceId === this.config.auth.resourceId);
+    if (!resource) {
+      throw new Error('No auth resource found');
+    }
+    const users = await this.connectors[resource.dataSource].getData({
+      resource,
+      filters: [
+        { field: resource.columns.find((col) => col.primaryKey).name, operator: AdminForthFilterOperators.EQ, value: pk },
+      ],
+      limit: 1,
+      offset: 0,
+      sort: [],
+    });
+    return users.data[0] || null;
+  }
+
+  setupEndpoints(server: GenericHttpServer) {
     server.endpoint({
       noAuth: true,
       method: 'POST',
@@ -504,7 +559,7 @@ class AdminForth implements AdminForthClass {
 
           const passwordHash = userRecord[this.config.auth.passwordHashField];
           console.log('User record', userRecord, passwordHash)  // why does it has no hash?
-          const valid = await Auth.verifyPassword(password, passwordHash);
+          const valid = await AdminForthAuth.verifyPassword(password, passwordHash);
           if (valid) {
             token = this.auth.issueJWT({ 
               username, pk: userRecord[userResource.columns.find((col) => col.primaryKey).name]
@@ -519,6 +574,14 @@ class AdminForth implements AdminForthClass {
       },
     });
 
+    server.endpoint({
+      method: 'POST',
+      path: '/check_auth',
+      handler: async ({ adminUser }) => {
+        return { ok: true };
+      },
+    });
+
     server.endpoint({
         noAuth: true,
         method: 'POST',
@@ -556,27 +619,14 @@ class AdminForth implements AdminForthClass {
       method: 'GET',
       path: '/get_base_config',
       handler: async ({input, adminUser, cookies}) => {
-        const cookieParsed = this.auth.verify(cookies['adminforth_jwt']);
         let username = ''
         let userFullName = ''
-        if (cookieParsed['pk'] == null) {
+        if (adminUser.isRoot) {
             username = this.config.rootUser.username;
         } else {
-            const userResource = this.config.resources.find((res) => res.resourceId === this.config.auth.resourceId);
-            const user = await this.connectors[userResource.dataSource].getData({
-              resource: userResource,
-              filters: [
-                { field: userResource.columns.find((col) => col.primaryKey).name, operator: AdminForthFilterOperators.EQ, value: cookieParsed['pk'] },
-              ],
-              limit: 1,
-              offset: 0,
-              sort: [],
-            });
-            if (!user.data.length) {
-              return { error: 'Unauthorized' };
-            }
-            username = user.data[0][this.config.auth.usernameField]; 
-            userFullName = user.data[0][this.config.auth.userFullNameField];
+            const dbUser = adminUser.dbUser;
+            username = dbUser[this.config.auth.usernameField]; 
+            userFullName =dbUser[this.config.auth.userFullNameField];
         }
 
         const userData = {
@@ -606,6 +656,8 @@ class AdminForth implements AdminForthClass {
       },
     });
 
+   
+
     server.endpoint({
       method: 'POST',
       path: '/get_resource',
@@ -644,7 +696,7 @@ class AdminForth implements AdminForthClass {
           return { error: `Resource ${resourceId} not found` };
         }
 
-        for (const hook of getFunctionList(resource.hooks?.[source]?.beforeDatasourceRequest)) {
+        for (const hook of listify(resource.hooks?.[source]?.beforeDatasourceRequest)) {
           const resp = await hook({ resource, query: body, adminUser });
           if (!resp || (!resp.ok && !resp.error)) {
             throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
@@ -675,7 +727,7 @@ class AdminForth implements AdminForthClass {
               // nonsense
               return { data: [], total: 0 };
           }
-      }
+        }
 
         const data = await this.connectors[resource.dataSource].getData({
           resource,
@@ -720,7 +772,7 @@ class AdminForth implements AdminForthClass {
           })
         );
 
-        for (const hook of getFunctionList(resource.hooks?.[source]?.afterDatasourceResponse)) {
+        for (const hook of listify(resource.hooks?.[source]?.afterDatasourceResponse)) {
           const resp = await hook({ resource, response: data.data, adminUser });
           if (!resp || (!resp.ok && !resp.error)) {
             throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
@@ -775,8 +827,8 @@ class AdminForth implements AdminForthClass {
         const targetResourceId = columnConfig.foreignResource.resourceId;
         const targetResource = this.config.resources.find((res) => res.resourceId == targetResourceId);
 
-        for (const hook of getFunctionList(columnConfig.foreignResource.hooks?.dropdownList?.beforeDatasourceRequest)) {
-          const resp = await hook({ query: body, adminUser });
+        for (const hook of listify(columnConfig.foreignResource.hooks?.dropdownList?.beforeDatasourceRequest as BeforeDataSourceRequestFunction[])) {
+          const resp = await hook({ query: body, adminUser, resource: targetResource });
           if (!resp || (!resp.ok && !resp.error)) {
             throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
           }
@@ -806,8 +858,8 @@ class AdminForth implements AdminForthClass {
           items
         };
 
-        for (const hook of getFunctionList(columnConfig.foreignResource.hooks?.dropdownList?.afterDatasourceResponse)) {
-          const resp = await hook({ response, adminUser });
+        for (const hook of listify(columnConfig.foreignResource.hooks?.dropdownList?.afterDatasourceResponse as AfterDataSourceResponseFunction[])) {
+          const resp = await hook({ response, adminUser, resource: targetResource });
           if (!resp || (!resp.ok && !resp.error)) {
             throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
           }
@@ -863,7 +915,7 @@ class AdminForth implements AdminForthClass {
             
             const record = body['record'];
             // execute hook if needed
-            for (const hook of getFunctionList(resource.hooks?.create?.beforeSave)) {
+            for (const hook of listify(resource.hooks?.create?.beforeSave as BeforeSaveFunction[])) {
               const resp = await hook({ resource, record, adminUser });
               if (!resp || (!resp.ok && !resp.error)) {
                 throw new Error(`Hook beforeSave must return object with {ok: true} or { error: 'Error' } `);
@@ -909,7 +961,7 @@ class AdminForth implements AdminForthClass {
             const connector = this.connectors[resource.dataSource];
             await connector.createRecord({ resource, record });
             // execute hook if needed
-            for (const hook of getFunctionList(resource.hooks?.create?.afterSave)) {
+            for (const hook of listify(resource.hooks?.create?.afterSave as AfterSaveFunction[])) {
               const resp = await hook({ resource, record, adminUser });
               if (!resp || (!resp.ok && !resp.error)) {
                 throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
@@ -944,7 +996,7 @@ class AdminForth implements AdminForthClass {
             const record = body['record'];
 
             // execute hook if needed
-            for (const hook of getFunctionList(resource.hooks?.edit?.beforeSave)) {
+            for (const hook of listify(resource.hooks?.edit?.beforeSave as BeforeSaveFunction[])) {
               const resp = await hook({ resource, record, adminUser });
               if (!resp || (!resp.ok && !resp.error)) {
                 throw new Error(`Hook beforeSave must return object with {ok: true} or { error: 'Error' } `);
@@ -975,7 +1027,7 @@ class AdminForth implements AdminForthClass {
             }
             
             // execute hook if needed
-            for (const hook of getFunctionList(resource.hooks?.edit?.afterSave)) {
+            for (const hook of listify(resource.hooks?.edit?.afterSave as AfterSaveFunction[])) {
               const resp = await hook({ resource, record, adminUser });
               if (!resp || (!resp.ok && !resp.error)) {
                 throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
@@ -1008,7 +1060,7 @@ class AdminForth implements AdminForthClass {
             }
 
             // execute hook if needed
-            for (const hook of getFunctionList(resource.hooks?.delete?.beforeSave)) {
+            for (const hook of listify(resource.hooks?.delete?.beforeSave as BeforeSaveFunction[])) {
               const resp = await hook({ resource, record, adminUser });
               if (!resp || (!resp.ok && !resp.error)) {
                 throw new Error(`Hook beforeSave must return object with {ok: true} or { error: 'Error' } `);
@@ -1023,7 +1075,7 @@ class AdminForth implements AdminForthClass {
             await connector.deleteRecord({ resource, recordId: body['primaryKey']});
 
             // execute hook if needed
-            for (const hook of getFunctionList(resource.hooks?.delete?.afterSave)) {
+            for (const hook of listify(resource.hooks?.delete?.afterSave as BeforeSaveFunction[])) {
               const resp = await hook({ resource, record, adminUser });
               if (!resp || (!resp.ok && !resp.error)) {
                 throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);

package/modules/codeInjector.ts

@@ -254,10 +254,13 @@ class CodeInjector implements CodeInjectorType {
     // for each custom component generate import statement
     const customResourceComponents = [];
     this.adminforth.config.resources.forEach((resource) => {
-      resource.columns.forEach((field) => {
-        if (field.components) {
-          Object.values(field.components).forEach(({ file }: {file: string}) => {
+      resource.columns.forEach((column) => {
+        if (column.components) {
+          Object.values(column.components).forEach(({ file }: {file: string}) => {
             if (!customResourceComponents.includes(file)) {
+              if (file === undefined) {
+                throw new Error('file is undefined from field.components, field:' + JSON.stringify(column));
+              }
               customResourceComponents.push(file);
             }
           });
@@ -267,6 +270,9 @@ class CodeInjector implements CodeInjectorType {
         Object.values(injection).forEach((filePathes: {file: string}[]) => {
           filePathes.forEach(({ file }) => {
             if (!customResourceComponents.includes(file)) {
+              if (file === undefined) {
+                throw new Error('file is undefined');
+              }
               customResourceComponents.push(file);
             }
           });

package/modules/utils.ts

@@ -34,14 +34,6 @@ export function getComponentNameFromPath(filePath) {
   return filePath.replace(/@/g, '').replace(/\./g, '').replace(/\//g, '');
 }
 
-export function getFunctionList(param?: Function | Array<Function>) {
-  if (param) {
-    if (Array.isArray(param)) {
-      return param;
-    } else {
-      return [param];
-    }
-  } else {
-    return [];
-  }
+export function listify(param?: Array<Function>) {
+  return param || [];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adminforth",
-  "version": "1.1.12",
+  "version": "1.1.14",
   "description": "OpenSource Vue3 powered forth-generation admin panel",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/plugins/AccessControl/index.ts

@@ -0,0 +1,83 @@
+import { 
+  AdminForthResource, AdminForthClass, BeforeDataSourceRequestFunction,
+  AllowedActionsEnum,
+  BeforeSaveFunction
+} from "../../types/AdminForthConfig.js";
+import AdminForthPlugin from "../base.js";
+import { PluginOptions } from "./types.js";
+
+
+
+export default class AccessControlPlugin extends AdminForthPlugin {
+ 
+  options: PluginOptions;
+  adminforth: AdminForthClass;
+
+  constructor(options: PluginOptions) {
+    super(options, import.meta.url);
+    this.options = options;
+  }
+
+  static defaultError = 'Sorry, you do not have access to this resource.'
+
+
+  modifyResourceConfig(adminforth: AdminForthClass, resourceConfig: AdminForthResource) {
+    super.modifyResourceConfig(adminforth, resourceConfig);
+    this.adminforth = adminforth;
+
+    if (!resourceConfig.hooks) {
+      resourceConfig.hooks = {};
+    }
+
+    const checkAccess = async (adminUser: any, action: AllowedActionsEnum, meta: any) => {
+      const hasAccessOrError = await this.options.hasAccess(adminUser, action, meta);
+      if (hasAccessOrError === true) {
+        return { ok: true };
+      } else {
+        return { ok: false, error: hasAccessOrError || AccessControlPlugin.defaultError };
+      }
+    }
+
+    const bindHookCheck = (action: AllowedActionsEnum, hookName: string) => {
+      if (!resourceConfig.hooks[action]) {
+        resourceConfig.hooks[action] = {};
+      }
+      if (!resourceConfig.hooks[action][hookName]) {
+        resourceConfig.hooks[action][hookName] = [];
+      }
+      if (hookName === 'beforeDatasourceRequest') {
+        (resourceConfig.hooks[action][hookName] as Array<BeforeDataSourceRequestFunction>).unshift(
+          async ({adminUser, query}: {resource: AdminForthResource, adminUser: any, query: any}) => {
+            return checkAccess(adminUser, action, { query });
+          }
+        );
+      } else {
+        (resourceConfig.hooks[action][hookName] as Array<BeforeSaveFunction>).unshift(
+          async ({adminUser, record}: {resource: AdminForthResource, adminUser: any, record: any}) => {
+            return checkAccess(adminUser, action, { record });
+          }
+        );
+      }
+    }
+
+    // List check
+    bindHookCheck(AllowedActionsEnum.list, 'beforeDatasourceRequest');
+
+    // Show check
+    bindHookCheck(AllowedActionsEnum.show, 'beforeDatasourceRequest');
+
+    // Edit check
+    bindHookCheck(AllowedActionsEnum.edit, 'beforeDatasourceRequest');    
+
+    // create check
+    bindHookCheck(AllowedActionsEnum.create, 'beforeSave');
+
+    // edit check
+    bindHookCheck(AllowedActionsEnum.edit, 'beforeSave');
+
+    // delete check
+    bindHookCheck(AllowedActionsEnum.delete, 'beforeSave');
+
+    console.log('resourceConfig', resourceConfig);
+  }
+}

package/plugins/AccessControl/types.ts

@@ -0,0 +1,14 @@
+
+import { AllowedActionsEnum, AdminUser } from '../../types/AdminForthConfig.js';
+
+
+export type PluginOptions = {
+  /**
+   * Called to check if user has access to a page
+   * @param user - The user object
+   * @param page - The page to check access for
+   * @param meta - The meta object containing query for list/show or record for save/edit
+   * @returns true if user has access, false or a string with an error message
+   */
+  hasAccess: (user: AdminUser, page: AllowedActionsEnum, meta: any) => Promise<boolean | string>;
+}

package/plugins/ForeignInlineListPlugin/custom/InlineList.vue

@@ -90,6 +90,7 @@
       :totalRows="totalRows"
       :checkboxes="checkboxes"
     />
+
   </td>
 </template>
 
@@ -114,7 +115,7 @@ const loading = ref(true);
 const page = ref(1);
 const sort = ref([]);
 const checkboxes = ref([]);
-const pageSize = computed(() => listResource.value?.options?.pageSize || 10);
+const pageSize = computed(() => listResource.value?.options?.listPageSize || 10);
 
 const rows = ref(null);
 const totalRows = ref(0);
@@ -207,6 +208,17 @@ async function getList() {
     }
   });
 
+  if (data.error) {
+    window.adminforth.alert({
+      message: data.error,
+      variant: 'danger',
+      timeout: 'unlimited',
+    });
+    rows.value = [];
+    totalRows.value = 0;
+    return;
+  }
+
   rows.value = data.data?.map(row => {
     row._primaryKeyValue = row[listResource.value.columns.find(c => c.primaryKey).name];
     return row;

package/plugins/ForeignInlineListPlugin/index.ts

@@ -23,7 +23,8 @@ export default class ForeignInlineListPlugin extends AdminForthPlugin {
           return { error: `Resource ${this.options.foreignResourceId} not found` };
         }
         // exclude "plugins" key
-        const resourceCopy = { ...resource, plugins: undefined };
+        const resourceCopy = JSON.parse(JSON.stringify({ ...resource, plugins: undefined }));
+        
         if (this.options.modifyTableResourceConfig) {
           this.options.modifyTableResourceConfig(resourceCopy);
         }

package/servers/express.ts

@@ -157,7 +157,7 @@ class ExpressServer implements ExpressHttpServer {
         res.status(401).send('Unauthorized by AdminForth');
         return
       }
-      const adminforthUser = this.adminforth.auth.verify(jwt);
+      const adminforthUser = await this.adminforth.auth.verify(jwt);
       if (!adminforthUser) {
         res.status(401).send('Unauthorized by AdminForth');
       } else {
@@ -201,7 +201,7 @@ class ExpressServer implements ExpressHttpServer {
           this.message = message;
         }
       };
-      const input = { body, query, headers, cookies, response, _raw_express_req: req, _raw_express_res: res};
+      const input = { body, query, headers, cookies, adminUser, response, _raw_express_req: req, _raw_express_res: res};
 
       let output;
       try {

package/spa/src/App.vue

@@ -64,7 +64,6 @@
     aria-label="Sidebar"
   >
     <div class="h-full px-3 pb-4 overflow-y-auto bg-nav-menu-bg dark:bg-gray-800 border-r">
-
       <div class="flex ms-2 md:me-24  m-4  ">
         <img :src="loadFile(coreStore.config?.brandLogo || '@/assets/logo.svg')" :alt="`${ coreStore.config?.brandName } Logo`" class="h-8 me-3"  />
         <span class="self-center text-header-text-size font-semibold sm:text-header-text-size whitespace-nowrap dark:text-header-text text-header-logo-color">
@@ -168,6 +167,7 @@ import { RouterLink, RouterView } from 'vue-router';
 import { initFlowbite } from 'flowbite'
 import './index.scss'
 import { useCoreStore } from '@/stores/core';
+import { useUserStore } from '@/stores/user';
 import {useModalStore} from '@/stores/modal';
 import { IconMoonSolid, IconSunSolid } from '@iconify-prerendered/vue-flowbite';
 import AcceptModal from './components/AcceptModal.vue';
@@ -184,6 +184,7 @@ import { FrontendAPI } from '@/composables/useStores'
 const coreStore = useCoreStore();
 const modalStore = useModalStore();
 const toastStore = useToastStore();
+const userStore = useUserStore();
 const frontendApi = new FrontendAPI();
 frontendApi.init();
 const splitAtLast = (str: string, separator: string) => {
@@ -221,8 +222,9 @@ if (opened.value.includes(label)) {
 }
 
 async function logout() {
-  await coreStore.logout();
-  router.push({ name: 'login' });
+  userStore.unauthorize();
+  await userStore.logout();
+  router.push({ name: 'login' })
 }
 
 
@@ -244,6 +246,8 @@ async function loadMenu() {
   });
 }
 
+
+
 watch(route, () => {
   title.value = `${coreStore.config?.title || coreStore.config?.brandName || 'Adminforth'} | ${ Object.values(route.params)[0] || route.meta.title || ' '}`;
   useHead({

package/spa/src/components/Toast.vue

@@ -46,16 +46,17 @@ const props = defineProps<{
     toast:{message: string;
     variant: string;
     id: string;
-    duration?: number;}
+    timeout?: number|'unlimited';}
 }>();
 function closeToast() {
     emit('close');
 }
 
 onMounted(() => {
-    setTimeout(() => {
-     emit('close');   
-    }, props.toast.duration  || 5000 );
+    if (props.toast.timeout === 'unlimited') return;
+    else { 
+      setTimeout(() => {emit('close');}, props.toast.timeout  || 10000 );
+    }
 });
 
 </script>

package/spa/src/components/ValueRenderer.vue

@@ -41,7 +41,7 @@ import { useRoute, useRouter } from 'vue-router';
 import { useCoreStore } from '@/stores/core';
 
 const coreStore = useCoreStore();
-const  route = useRoute();
+const route = useRoute();
 
 
 dayjs.extend(utc);

package/spa/src/composables/useStores.ts

@@ -56,7 +56,8 @@ export class FrontendAPI implements FrontendAPIInterface {
   alert(params: AlertParams): void {
     this.toastStore.addToast({
       message: params.message,
-      variant: params.variant
+      variant: params.variant,
+      timeout: params.timeout  
     })
   }
 

package/spa/src/router/index.ts

@@ -1,5 +1,6 @@
 import { createRouter, createWebHistory } from 'vue-router'
 import ResourceParent from '@/views/ResourceParent.vue'
+import { useUserStore } from '@/stores/user'
 /* IMPORTANT:ADMINFORTH ROUTES IMPORTS */
 
 const router = createRouter({
@@ -9,7 +10,15 @@ const router = createRouter({
       path: '/login',
       name: 'login',
       component: () => import('@/views/LoginView.vue'),
-      meta: { title: 'login' }
+      meta: { title: 'login' },
+      beforeEnter: async (to, from, next) => {
+        const userStore = useUserStore()
+        if (await userStore.checkAuth(true)) {
+          next({ name: 'home' })
+        } else {
+          next()
+        }
+      }
     },
     {
       path: '/resource/:resourceId',
@@ -49,4 +58,7 @@ const router = createRouter({
 })
 
 
+
+
+
 export default router