adminforth 1.6.2-next.2 → 1.6.2-next.3

package/dist/spa/src/renderers/RelativeTime.vue

@@ -1,42 +0,0 @@
-<template>
-  <Tooltip>
-    {{ relativeTime }}
-    <template #tooltip v-if="relativeTime">
-        {{ fullTime }}
-    </template>
-  </Tooltip>
-</template>
-
-<script setup>
-import { computed, ref, onMounted } from 'vue';
-import Tooltip from '@/afcl/Tooltip.vue';
-import en from 'javascript-time-ago/locale/en';
-import TimeAgo from 'javascript-time-ago';
-import dayjs from 'dayjs';
-
-
-const id = ref();
-
-TimeAgo.addLocale(en);
-
-const props = defineProps(['column', 'record', 'meta', 'resource', 'adminUser']);
-
-const userLocale = ref(navigator.language || 'en-US');
-const timeAgoFormatter = new TimeAgo(userLocale.value);
-const relativeTime = computed(() => {
-  const value = props.record[props.column.name];
-  const date = new Date(value);
-  return timeAgoFormatter.format(date);
-});
-
-const fullTime = computed(() => {
-  const value = props.record[props.column.name];  
-  const date = dayjs(new Date(value));
-  return date.format('DD MMM HH:mm');
-});
-
-onMounted(async () => {
-  id.value = Math.random().toString(36).substring(7);
-});
-
-</script>

package/dist/spa/src/renderers/URL.vue

@@ -1,18 +0,0 @@
-<template>
-  <a v-if='record[column.name]' :href="record[column.name]"
-    class="text-blue-500 hover:underline overflow-ellipsis overflow-hidden whitespace-nowrap inline-block max-w-full"
-  >{{ record[column.name] }}</a>
-</template>
-
-<script setup>
-
-defineProps({
-  record: Object,
-  resource: Object,
-  adminUser: Object,
-  meta: Object,
-  column: Object
-});
-
-
-</script>

package/dist/spa/src/router/index.ts

@@ -1,70 +0,0 @@
-import { createRouter, createWebHistory } from 'vue-router';
-import ResourceParent from '@/views/ResourceParent.vue';
-import PageNotFound from '@/views/PageNotFound.vue';
-
-/* IMPORTANT:ADMINFORTH ROUTES IMPORTS */
-
-const router = createRouter({
-  history: createWebHistory(import.meta.env.BASE_URL),
-  routes: [
-    {
-      path: '/login',
-      name: 'login',
-      component: () => import('@/views/LoginView.vue'),
-      meta: { 
-        title: 'Login', 
-        customLayout: true 
-      },
-      // beforeEnter: async (to, from, next) => {
-      //   if(localStorage.getItem('isAuthorized') === 'true') {
-      //     // check if url has next=... and redirect to it
-      //     console.log('to.query', to.query)
-      //     if (to.query.next) {
-      //       next(to.query.next.toString())
-      //     } else {
-      //       next({name: 'home'});
-      //     }
-      //   } else {
-      //     next()
-      //   }
-      // }
-    },
-    {
-      path: '/resource/:resourceId',
-      component: ResourceParent,
-      name: 'resource',
-      children: [
-        {
-          path: '',
-          component: () => import('@/views/ListView.vue'),
-          name: 'resource-list',
-          meta: { title: 'list',type: 'list' }
-        },
-        {
-          path: 'show/:primaryKey',
-          component: () => import('@/views/ShowView.vue'),
-          name: 'resource-show',
-          meta: { title: 'show', type: 'show'}
-
-        },
-        {
-          path: 'edit/:primaryKey',
-          component: () => import('@/views/EditView.vue'),
-          name: 'resource-edit',
-          meta: { title: 'edit', type: 'edit'}
-        },
-        {
-          path: 'create',
-          component: () => import('@/views/CreateView.vue'),
-          name: 'resource-create',
-          meta: { title: 'create', type: 'create'}
-
-        },
-      ]
-    },
-    /* IMPORTANT:ADMINFORTH ROUTES */
-    { path: "/:pathMatch(.*)*", component: PageNotFound },
-  ]
-})
-
-export default router

package/dist/spa/src/spa_types/core.ts

@@ -1,51 +0,0 @@
-import type { AdminForthResource, AdminForthResourceColumn } from '../types/AdminForthConfig';
-
-export type resourceById = {
-    [key: string]: AdminForthResource;
-}
-
-export type Menu = {
-    label: string,
-    icon: string,
-    resourceId: string,
-    children?: Array<Menu>,
-}
-
-export type Record = {
-    [key: string]: any;
-}
-
-export type ResourceColumns = {
-    [key: string]: Array<AdminForthResourceColumn>;
-}
-
-export type CoreConfig = {
-    brandName: string,
-    brandLogo: string,
-    title: string,
-    datesFormat: string,
-    timeFormat: string,
-    usernameField: string,
-    usernameFieldName?: string,
-    auth?: {
-        resourceId: string,
-        usernameField: string,
-        passwordHashField: string,
-        loginBackgroundImage: string,
-        loginBackgroundPosition: string,
-        userFullnameField: string,
-    },
-    emptyFieldPlaceholder?: {
-        show?: string,
-        list?: string,
-    } | string,
-}
-
-
-export type AllowedActions = {
-    show: boolean,
-    create: boolean,
-    edit: boolean,
-    delete: boolean,
-}
-

package/dist/spa/src/stores/core.ts

@@ -1,228 +0,0 @@
-import { ref, computed } from 'vue'
-import { defineStore } from 'pinia'
-import { callAdminForthApi } from '@/utils';
-import websocket from '@/websocket';
-import adminforth from '@/adminforth';
-
-import type { AdminForthResourceCommon, AdminForthResourceColumnCommon, GetBaseConfigResponse, ResourceVeryShort, AdminUser, UserData, AdminForthConfigMenuItem, AdminForthConfigForFrontend } from '@/types/Common';
-import type { Ref } from 'vue'
-
-export const useCoreStore = defineStore('core', () => {
-  const resourceById: Ref<Record<string, ResourceVeryShort>> = ref({});
-  const theme: Ref<'light'| 'dark'> = ref(window.localStorage.getItem('af__theme') as ('light'|'dark') || 'light');
-
-  const menu: Ref<AdminForthConfigMenuItem[]> = ref([]);
-  const config: Ref<AdminForthConfigForFrontend | null> = ref(null);
-  const record: Ref<any | null> = ref({});
-  const resource: Ref<AdminForthResourceCommon | null> = ref(null);
-  const userData: Ref<UserData | null> = ref(null);
-
-  const resourceColumnsWithFilters = computed(() => {
-    if (!resource.value) {
-      return [];
-    }
-    return resource.value.columns.filter((col: AdminForthResourceColumnCommon) => col.showIn?.includes('filter'));
-  })
-
-  const resourceOptions: Ref<AdminForthResourceCommon['options'] | null> = ref(null);
-  const resourceColumnsError: Ref<string> = ref('');
-  const resourceColumnsId: Ref<string | null> = ref(null);
-  const adminUser: Ref<null | AdminUser> = ref(null);
-
-  
-  async function resetAdminUser() {
-    adminUser.value = null;
-  }
-
-  async function toggleTheme() {
-    theme.value = theme.value === 'light' ? 'dark' : 'light';
-    if (theme.value === 'light') {
-      document.documentElement.classList.remove('dark');
-    } else {
-      document.documentElement.classList.add('dark');
-    }
-
-    document.documentElement.setAttribute('data-theme', theme.value);
-    theme.value = theme.value;
-    window.localStorage.setItem('af__theme', theme.value);
-  }
-
-  async function fetchMenuAndResource() {
-    const resp: GetBaseConfigResponse = await callAdminForthApi({
-      path: '/get_base_config',
-      method: 'GET',
-    });
-
-    if(!resp){
-      return
-    }
-    menu.value = resp.menu;
-    resourceById.value = resp.resources.reduce((acc: Record<string, ResourceVeryShort>, resource: ResourceVeryShort) => {
-      acc[resource.resourceId] = resource;
-      return acc;
-    }, {});
-    config.value = resp.config;
-    adminUser.value = resp.adminUser;
-    userData.value = resp.user;
-    console.log('🌍 AdminForth v', resp.version);
-  }
-
-  function findItemWithId(items: AdminForthConfigMenuItem[], itemId: string): AdminForthConfigMenuItem | undefined {
-    for (const item of items) {
-      if (item.itemId === itemId) {
-        return item;
-      }
-      if (item.children) {
-        const found = findItemWithId(item.children, itemId);
-        if (found) {
-          return found;
-        }
-      }
-    }
-  }
-  async function subscribeToMenuBadges() {
-    const processItem = (mi: AdminForthConfigMenuItem) => {
-      if (mi.badge) {
-        websocket.subscribe(`/opentopic/update-menu-badge/${mi.itemId}`, ({ badge }) => {
-          mi.badge = badge;
-        });
-      }
-    }
-  
-    menu.value.forEach((mi) => {
-      processItem(mi);
-      if (mi.children) {
-        mi.children.forEach((child) => {
-          processItem(child);
-        })
-      }
-    })
-  }
-  async function fetchMenuBadges() {
-    const resp: Record<string, string> = await callAdminForthApi({
-      path: '/get_menu_badges',
-      method: 'GET',
-    });
-    if (!resp) {
-      return;
-    }
-    Object.entries(resp).forEach(([itemId, badge]: [string, string]) => {
-      const item: AdminForthConfigMenuItem | undefined = findItemWithId(menu.value, itemId);
-      if (item) {
-        item.badge = badge;
-      }
-    });
-
-    subscribeToMenuBadges();
-
-  }
-
-
-  async function fetchRecord({ resourceId, primaryKey, source }: { resourceId: string, primaryKey: string, source: string }) {
-    record.value = null;
-    
-    if (!resource.value) {
-      throw new Error('Columns not fetched yet');
-    }
-    const col = resource.value.columns.find((col: AdminForthResourceColumnCommon) => col.primaryKey);
-    if (!col) {
-      throw new Error(`Primary key not found in resource ${resourceId}`);
-    }
-
-    const respData = await callAdminForthApi({
-      path: '/get_resource_data',
-      method: 'POST',
-      body: {
-        source: source,
-        resourceId: resourceId,
-        filters: [
-          {
-            field: col.name,
-            operator: 'eq',
-            value: primaryKey
-          }
-        ],
-        sort: [],
-        limit: 1,
-        offset: 0
-      }
-    });
-
-    if (respData.error) {
-      adminforth.alert({
-        message: respData.error,
-        variant: 'danger',
-        timeout: 30,
-      });
-      record.value = {};
-    } else {
-      record.value = respData.data[0];
-    }
-
-  }
-
-  async function fetchResourceFull({ resourceId }: { resourceId: string }) {
-    if (resourceColumnsId.value === resourceId && resource.value) {
-      // already fetched
-      return;
-    }
-    resourceColumnsId.value = resourceId;
-    resourceColumnsError.value = '';
-    const res = await callAdminForthApi({
-      path: '/get_resource',
-      method: 'POST',
-      body: {
-        resourceId,
-      }
-    });
-    if (res.error) {
-      resourceColumnsError.value = res.error;
-    } else {
-      resourceById.value[resourceId] = res.resource;
-      resource.value = res.resource;
-      resourceOptions.value = res.resource.options;
-    }
-  }
-
-  async function getPublicConfig() {
-    const res = await callAdminForthApi({
-      path: '/get_public_config',
-      method: 'GET',
-    });
-    config.value = {...config.value, ...res};
-  }
-
-
-  const username = computed(() => {
-    const usernameField = config.value?.usernameField;
-    return userData.value && usernameField && userData.value[usernameField];
-  });
-
-  const userFullname = computed(() => {
-    const userFullnameField = config.value?.userFullnameField;
-    return userData.value && userFullnameField && userData.value[userFullnameField];
-  })
-
-
-  return { 
-    config,
-    resourceById, 
-    menu, 
-    username,
-    userFullname,
-    getPublicConfig,
-    fetchMenuAndResource, 
-    fetchRecord, 
-    record, 
-    fetchResourceFull, 
-    resourceColumnsError,
-    resourceOptions,
-    resource,
-    adminUser,
-    resourceColumnsWithFilters,
-    toggleTheme,
-    theme,
-    fetchMenuBadges,
-    resetAdminUser,
-  }
-})

package/dist/spa/src/stores/filters.ts

@@ -1,27 +0,0 @@
-import { ref, type Ref } from 'vue';
-import { defineStore } from 'pinia';
-
-export const useFiltersStore = defineStore('filters', () => {
-    const filters: Ref<any[]> = ref([]);
-    const sort: Ref<any> = ref({});
-
-    const setSort = (s: any) => {
-        sort.value = s;
-    }
-    const getSort = () => {
-        return sort.value;
-    }
-    const setFilter = (filter: any) => {
-        filters.value.push(filter);
-    }
-    const setFilters = (f: any) => {
-        filters.value = f;
-    }
-    const getFilters = () => {
-        return filters.value;
-    }
-    const clearFilters = () => {
-        filters.value = [];
-    }
-    return {setFilter, getFilters, clearFilters, filters, setFilters, setSort, getSort}
-})

package/dist/spa/src/stores/modal.ts

@@ -1,48 +0,0 @@
-import { ref } from 'vue'
-import { defineStore } from 'pinia'
-
- type ModalContentType = {
-  title?: string;
-  content?: string;
-  acceptText?: string;
-  cancelText?: string;
- }
-
-
-export const useModalStore = defineStore('modal', () => {
-  const modalContent = ref({
-    title: 'title',
-    content: 'content',
-    acceptText: 'acceptText',
-    cancelText: 'cancelText',
-  });  
-  const isOpened = ref(false);
-  const onAcceptFunction: any = ref(()=>{});
-  const onCancelFunction: any = ref(()=>{});
-  function togleModal() {
-    isOpened.value = !isOpened.value;
-  }
-  function setOnAcceptFunction(func: Function) {
-    onAcceptFunction.value = func;
-  }
-  function setOnCancelFunction(func: Function) {
-    onCancelFunction.value = func;
-  }
-  function setModalContent(content: ModalContentType) {
-    modalContent.value = content;
-  }
-  function resetmodalState() {
-    isOpened.value = false;
-    modalContent.value = {
-      title: 'title',
-      content: 'content',
-      acceptText: 'acceptText',
-      cancelText: 'cancelText',
-    };
-    setOnAcceptFunction(()=>{});
-
-  }
-    
-  return {isOpened, setModalContent,onCancelFunction, togleModal,modalContent, setOnAcceptFunction, onAcceptFunction,resetmodalState,setOnCancelFunction} 
-   
-})

package/dist/spa/src/stores/toast.ts

@@ -1,30 +0,0 @@
-import { ref, watch, type Ref } from 'vue'
-import { defineStore } from 'pinia'
-import { v1 as uuid } from 'uuid';
-import { useRoute } from 'vue-router';
-
-
-
-export const useToastStore = defineStore('toast', () => {
-    const toasts: Ref<any[]> = ref([]);
-    const route = useRoute();
-
-    watch(route, () => {
-        // on route change clear all toasts older then 5 seconds
-        const now = +new Date();
-        toasts.value = toasts.value.filter((t) => now - t.createdAt < 5000);
-    });
-
-    const addToast = (toast: { message: string; variant: string }) => {
-        const toastId = uuid();
-        toasts.value.push({
-            ...toast,
-            id: toastId,
-            createdAt: +new Date(),
-        });
-    };
-    const removeToast = (toast: { id: string }) => {
-        toasts.value = toasts.value.filter((t) => t.id !== toast.id);
-    };
-    return { toasts, addToast, removeToast };
-});

package/dist/spa/src/stores/user.ts

@@ -1,79 +0,0 @@
-import { ref } from 'vue';
-import { defineStore } from 'pinia';
-import { callAdminForthApi } from '@/utils';
-import { useCoreStore } from './core';
-import router from '@/router';
-import { reconnect } from '@/websocket';
-
-
-export const useUserStore = defineStore('user', () => {
-    const isAuthorized = ref(false);
-
-    function authorize() {
-        // syncing isAuthorized allows us to use navigation guards without waiting for user api response
-        isAuthorized.value = true;
-        localStorage.setItem('isAuthorized', 'true');
-    }
-
-    function unauthorize() {
-        isAuthorized.value = false;
-        localStorage.setItem('isAuthorized', 'false');
-    }
-
-    async function finishLogin() {
-        const coreStore = useCoreStore();
-        authorize();
-        reconnect();
-        // if next param in route, redirect to it
-        if (router.currentRoute.value.query.next) {
-            await router.push(router.currentRoute.value.query.next.toString());
-        } else {
-            await router.push('/');
-        }
-        await router.isReady();
-        await coreStore.fetchMenuAndResource();
-    }
-
-    async function logout() {
-        const coreStore = useCoreStore();
-
-        await callAdminForthApi({
-          path: '/logout',
-          method: 'POST',
-        });
-        reconnect();
-        coreStore.resetAdminUser();
-        unauthorize();
-        
-      }
-
-    // async function checkAuth( skipApiCall = false){
-    //      console.log('checkAuth', isAuthorized.value, skipApiCall)
-    //     if(isAuthorized.value) {
-    //         return true}
-    //     else {
-    //         if(skipApiCall) return false;
-    //         const resp = await callAdminForthApi({
-    //             path: '/check_auth',
-    //             method: 'POST',
-    //         });
-    //         if (resp.status !== 401) {
-    //             authorize();
-    //             return true;
-    //         }
-    //         else {
-    //             unauthorize();
-    //             return false;}
-    //     }
-        
-    // }
-
-    return {
-        isAuthorized,
-        authorize,
-        unauthorize,
-        logout,
-        finishLogin
-    }
-
-});        

package/dist/spa/src/types/Adapters.ts

@@ -1,26 +0,0 @@
-export interface EmailAdapter {
-  validate(): Promise<void>;
-
-  sendEmail(
-    from: string,
-    to: string,
-    text: string,
-    html: string,
-    subject: string
-  ): Promise<void>;
-}
-
-export interface CompletionAdapter {
-
-  validate(): void;
-
-  complete(
-    content: string,
-    stop: string[],
-    maxTokens: number,
-  ): Promise<{
-    content?: string;
-    finishReason?: string;
-    error?: string;
-  }>;
-}