@sidekick-coder/zenith-kit 0.3.7 → 0.3.8

package/src/client/services/FetchBrowserService.ts

@@ -0,0 +1,22 @@
+import type { FetchOptions } from './FetchService.ts'
+import FetchService from './FetchService.ts'
+
+export default class FetchBrowserService extends FetchService {
+    public async fetch<T>(url: string, options: FetchOptions = {}): Promise<T> {
+        const fullUrl = this.buildUrl(url, options.query)
+        const fetchOptions = this.buildRequestInit(options)
+
+        const response = await fetch(fullUrl, fetchOptions)
+
+
+        if (!response.ok) {
+            const result = await this.handleError(response)
+
+            throw result
+        }
+
+        const parsed = await this.parseResponse<T>(response)
+
+        return parsed
+    }
+}

package/src/client/services/FetchNodeService.ts

@@ -0,0 +1,60 @@
+import type { FetchOptions } from './FetchService.ts'
+import FetchService from './FetchService.ts'
+import CokkieMapEntity from '#shared/entities/CookieMapEntity.ts'
+import config from '#client/facades/config.ts'
+import container from '#client/facades/container.ts'
+import { parseUrlParams, parseUrlQuery } from '#shared/utils/parseRouteUrl.ts'
+
+export default class FetchNodeService extends FetchService {
+    public async fetch<T>(url: string, options: FetchOptions = {}): Promise<T> {
+        const isInternal = !url.startsWith('http://') && !url.startsWith('https://')
+
+        if (!isInternal) {
+            return this.fetchExternal<T>(url, options)
+        }
+
+        return this.fetchInternal<T>(url, options)
+    }
+
+    protected async fetchExternal<T>(url: string, options: FetchOptions = {}): Promise<T> {
+        const fullUrl = this.buildUrl(url, options.query)
+        const fetchOptions = this.buildRequestInit(options)
+
+        const response = await fetch(fullUrl, fetchOptions)
+
+        if (!response.ok) {
+            await this.handleError(response)
+            throw new Error(`HTTP error! status: ${response.status}`)
+        }
+
+        return this.parseResponse<T>(response)
+    }
+
+    protected async fetchInternal<T>(url: string, options: FetchOptions = {}): Promise<T> {
+        const router =  container.get<any>('RouterService')
+        const method = options.method || 'GET'
+        const route = router.resolve(method, url)
+        const cookie = new CokkieMapEntity({
+            prefix: config.get('cookie.prefix', '')
+        })
+        
+        if (container.has('cookies')) {
+            cookie.load(container.get<Record<string, string>>('cookies'))
+        }
+
+        if (!route || !route.handler) {
+            throw new Error(`Route not found for ${method} ${url}`)
+        }
+
+        const result = await router.execute(route, {
+            url: url,
+            params: parseUrlParams(route.path, url),
+            query: options.query || parseUrlQuery(url),
+            body: options.data || options.body,
+            method: method.toLowerCase(),
+            cookie: cookie
+        })
+
+        return result as Promise<T>
+    }
+}

package/src/client/services/FetchService.ts

@@ -0,0 +1,99 @@
+import { toast } from 'vue-sonner'
+import qs from 'qs'
+import { tryCatch } from '#shared/utils/tryCatch.ts'
+
+export interface FetchOptions extends RequestInit {
+    query?: Record<string, any>
+    data?: Record<string, any>
+}
+
+export default class FetchService {
+    public static __container_entry_key = 'FetchService'
+
+    protected async handleError(response: Response) {
+        if (response.headers.get('Content-Type')?.includes('json')) {
+            const data = await response.json()
+                .catch(() => ({ message: $t('Internal Server Error') }))
+
+            if (data.message) {
+                toast.error(data.message)
+            }
+
+            return data
+        }
+
+        toast.error($t('Internal Server Error'))
+
+        return {
+            message: $t('Internal Server Error'),
+        }
+    }
+
+    protected buildUrl(url: string, query?: Record<string, any>): string {
+        if (!query) {
+            return url
+        }
+
+        const queryString = qs.stringify(query, { arrayFormat: 'brackets' })
+
+        return url + '?' + queryString
+    }
+
+    protected buildRequestInit(options: FetchOptions): RequestInit {
+        const fetchOptions: RequestInit = { ...options }
+
+        if (options.data) {
+            fetchOptions.body = JSON.stringify(options.data)
+            fetchOptions.headers = {
+                ...fetchOptions.headers,
+                'Content-Type': 'application/json',
+            }
+        }
+
+        return fetchOptions
+    }
+
+    protected async parseResponse<T>(response: Response): Promise<T> {
+        if (response.headers.get('Content-Type')?.includes('json')) {
+            return response.json() as Promise<T>
+        }
+
+        return response.text() as Promise<T>
+    }
+
+    public async fetch<T>(_url: string, _options: FetchOptions = {}): Promise<T> {
+        throw new Error('Method not implemented')
+    }
+
+    public async try<T = any>(url: string, options: FetchOptions = {}) {
+        return tryCatch(() => this.fetch<T>(url, options))
+    }
+
+    public async get<T = any>(url: string, options: FetchOptions = {}) {
+        return this.fetch<T>(url, {
+            ...options,
+            method: 'GET',
+        })
+    }
+
+    public async post<T = any>(url: string, options: FetchOptions = {}) {
+        return this.fetch<T>(url, {
+            ...options,
+            method: 'POST',
+        })
+    }
+
+    public async put<T = any>(url: string, options: FetchOptions = {}) {
+        return this.fetch<T>(url, {
+            ...options,
+            method: 'PUT',
+        })
+    }
+
+    public async delete<T = any>(url: string, options: FetchOptions = {}) {
+        return this.fetch<T>(url, {
+            ...options,
+            method: 'DELETE',
+        })
+    }
+}

package/src/client/services/LayoutService.ts

@@ -0,0 +1,53 @@
+import { BaseException } from "#shared/index.ts"
+import type { DefineComponent } from "vue"
+import emmitter from '../facades/emmitter.ts'
+
+export default class LayoutService {
+    public static __container_entry_key = 'LayoutService'
+    public components: Map<string, DefineComponent> = new Map()
+    public options: Record<string, any> = {}
+    public currendId: string | null = null
+
+    public setCurrent(id: string) {
+        this.currendId = id
+
+        emmitter.emit('layout:change', id)
+    }
+
+    public add(name: string, component: DefineComponent, options?: any) {
+        this.components.set(name, component)
+        this.options = options || {}
+    }
+
+    public has(name: string) {
+        return this.components.has(name)
+    }
+
+    public get(name: string) {
+        const entry = this.components.get(name)
+
+        if (!entry) {
+            throw new BaseException(`Layout ${name} not found`)
+        }
+
+        return entry
+    }
+
+    public getOptions() {
+        return this.options
+    }
+
+    public getCurrent() {
+        if (!this.currendId) {
+            return null
+        }
+
+        return this.get(this.currendId)
+    }
+
+    public setOptions(options: any = {}) {
+        this.options = options
+
+        emmitter.emit('layout:set-options', options)
+    }
+}

package/src/client/services/LifecycleService.ts

@@ -0,0 +1,19 @@
+import LifecycleHook from '#shared/entities/LifecycleHook.ts';
+import BaseLifecycleService from '#shared/services/LifecycleService.ts';
+
+export default class LifecycleService extends BaseLifecycleService {
+    public addImports(imports: Record<string, any>){
+        const hooks: LifecycleHook[] = []
+
+        for (const [name, mod] of Object.entries(imports)) {
+            const HookClass = mod.default || mod
+            const instance = new HookClass() as LifecycleHook
+
+            instance.hook_id = instance.hook_id || name
+
+            hooks.push(instance)
+        }
+
+        hooks.forEach(hook => this.add(hook))
+    }
+}

package/src/client/services/MenuService.ts

@@ -0,0 +1,64 @@
+import MenuItem from '#client/entities/MenuItemEntity.ts'
+import acl from '#client/facades/acl.ts'
+
+export interface ListFilter {
+    layout?: string
+    group?: string
+    parent?: string
+    allowed?: boolean
+}
+
+export default class MenuService {
+    public static __container_entry_key = 'MenuService'
+
+    public items: Map<string, MenuItem> = new Map()
+
+    public add(...item: Omit<Partial<MenuItem>, 'merge' | 'from'>[]) {
+        for (const i of item) {
+
+            if (!i.id) {
+                i.id = JSON.stringify(i)
+            }
+
+            this.items.set(i.id, MenuItem.from(i))
+        }
+    }
+
+    public remove(id: MenuItem['id']) {
+        this.items.delete(id)
+    }
+
+    public list(filter: ListFilter = {}) {
+        let items = JSON.parse(JSON.stringify(Array.from(this.items.values()))) as MenuItem[]
+
+
+        if (filter.layout) {
+            items = items.filter(i => i.layout === filter.layout)
+        }
+
+        if (filter.group) {
+            items = items.filter(i => i.group === filter.group || i.parent === filter.group)
+        }
+
+        if (filter.parent) {
+            items = items.filter(i => i.parent === filter.parent)
+        }
+
+        if (filter.allowed !== undefined && filter.allowed === true) {
+            items = items.filter(i => acl.can('view', i))
+        }
+
+        items.sort((a, b) => {
+            const orderA = a.order ? a.order : 98
+            const orderB = b.order ? b.order : 98
+
+            return orderA - orderB
+        })
+
+        return items
+    }
+
+    public clear() {
+        this.items.clear()
+    }
+}

package/src/client/services/RouterService.ts

@@ -0,0 +1,127 @@
+import {
+    createRouter as createVueRouter,
+    createMemoryHistory,
+    createWebHistory
+} from 'vue-router'
+import type { NavigationGuard, Router as VueRouter } from 'vue-router'
+import type { RouteRecordRaw } from 'vue-router'
+import type { DefineComponent } from 'vue'
+import setupGuard from '#client/guards/setupGuard.ts'
+
+export interface Router extends VueRouter {
+    auto: typeof auto;
+}
+
+export interface AutoOptions {
+    guards?: NavigationGuard[] | ((record: RouteRecordRaw) => NavigationGuard[]);
+    strip?: (string | RegExp)[];
+    exclude?: (string | RegExp)[];
+    prefix?: string;
+    refine?: (records: RouteRecordRaw[]) => RouteRecordRaw[];
+}
+
+export function auto(imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options: AutoOptions = {}): RouteRecordRaw[] {
+    let routes: RouteRecordRaw[] = []
+
+    for (const [filename, component] of Object.entries(imports)) {
+
+        if (options.exclude?.some(rule =>
+            typeof rule === 'string'
+                ? filename.includes(rule)
+                : rule.test(filename)
+        )) {
+            continue
+        }
+
+        let parts = filename
+            .replace(/\.vue$/, '')
+            .split('/')
+            .filter(p => p && !p.startsWith('.'))
+            .map(part => {
+                let p = part
+
+                if (p.startsWith('[') && p.endsWith(']')) {
+                    p = ':' + p.slice(1, -1)
+                }
+
+                return p
+            })
+
+
+        // Strip specific segments
+        if (options.strip?.length) {
+            parts = parts.filter(p =>
+                !options.strip!.some(rule =>
+                    typeof rule === 'string'
+                        ? p === rule
+                        : rule.test(p)
+                )
+            )
+        }
+
+        let path = parts.join('/').replace(/index$/, '')
+
+        if (options.prefix) {
+            path = options.prefix + '/' + path
+        }
+
+        if (!path.startsWith('/')) {
+            path = '/' + path
+        }
+
+        if (path.endsWith('/')) {
+            path = path.slice(0, -1)
+        }
+
+        const record = {
+            path: path,
+            component: component as DefineComponent,
+            beforeEnter: [] as NavigationGuard[],
+        }
+        
+        if (options.guards && Array.isArray(options.guards)) {
+            record.beforeEnter = options.guards
+        }
+
+        if (options.guards && typeof options.guards === 'function') {
+            record.beforeEnter = options.guards(record)
+        }
+
+        routes.push(record)
+    }
+
+    if (options.refine) {
+        routes = options.refine(routes)
+    }
+
+    return routes
+}
+
+export function createRouter() {
+    const ssr = import.meta.env.SSR
+
+    const router = createVueRouter({
+        history: ssr ? createMemoryHistory() : createWebHistory(),
+        routes: [],
+        scrollBehavior(_to, _from, savedPosition) {
+            if (savedPosition) {
+                return savedPosition
+            } else {
+                return { top: 0 }
+            }
+        },
+    }) as any as Router
+
+    router.beforeEach(setupGuard)
+
+    router.auto = (imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>, options: AutoOptions = {}) => {
+        const autoRoutes = auto(imports, options)
+        
+        autoRoutes.forEach(route => router.addRoute(route))
+
+        return autoRoutes
+    }
+
+    return router
+}
+

package/src/client/services/ToastService.ts

@@ -0,0 +1,11 @@
+export default class ToastService {
+    public static __container_entry_key = 'ToastService'
+
+    public success(message: string, options?: Record<string, any>) {
+        console.log('Success:', message, options)
+    }
+
+    public error(message: string, options?: Record<string, any>) {
+        console.error('Error:', message, options)
+    }
+}

package/src/client/utils/autoPages.ts

@@ -0,0 +1,12 @@
+import { auto } from '#client/services/RouterService.ts'
+import type { AutoOptions } from '#client/services/RouterService.ts'
+import type { DefineComponent } from 'vue'
+import type { RouteRecordRaw } from 'vue-router'
+
+/** @deprecated Use auto from RouterService instead */
+export function autoRoutes(
+    imports: Record<string, DefineComponent | (() => Promise<DefineComponent>)>,
+    options: AutoOptions = {}
+): RouteRecordRaw[] {
+    return auto(imports, options)
+}

package/src/client/utils/createId.ts

@@ -0,0 +1 @@
+export { createId } from '#shared/utils/createId.ts'

package/src/client/utils/defineColumns.ts

@@ -0,0 +1,11 @@
+export interface DataTableColumn<T extends Record<string, any> = Record<string, any>> {
+    id?: string
+    label?: string
+    field?: keyof T | ((row: T) => any) | (string & {})
+    sortable?: boolean
+    width?: string | number
+}
+
+export function defineColumns<T extends Record<string, any>>(columns: DataTableColumn<T>[]) {
+    return columns
+}

package/src/client/utils/defineFormFields.ts

@@ -0,0 +1,21 @@
+export interface DefineFormField {
+    component:
+    'text-field'
+    | 'textarea'
+    | 'select'
+    | 'autocomplete'
+    | 'switch'
+    | 'file-upload'
+    | 'image-upload'
+    | 'color-picker'
+    | 'string-list-input'
+    | 'json-input'
+    | 'date-picker'
+    | 'hidden'
+    [key: string]: any
+}
+
+export function defineFormFields(field: Record<string, DefineFormField>) {
+    return field
+}
+

package/src/client/utils/fetcher.ts

@@ -0,0 +1,4 @@
+import $original from "#client/facades/fetcher.ts";
+
+/** @deprecated Use fetcher facade */
+export const $fetch = $original;

package/src/client/utils/file.ts

@@ -0,0 +1,78 @@
+import { $fetch } from './fetcher'
+
+interface PickOptions {
+    accept?: string
+    multiple?: boolean
+}
+
+type PickResult<T extends PickOptions> = T['multiple'] extends true ? File[] : File | null
+
+function pick<T extends PickOptions>(options: T): Promise<PickResult<T>> {
+    return new Promise((resolve) => {
+        const input = document.createElement('input')
+
+        input.type = 'file'
+        input.accept = options.accept || '*/*'
+        input.multiple = options.multiple || false
+
+        input.onchange = (e) => {
+            const target = e.target as HTMLInputElement
+            const files = Array.from(target.files as FileList) as File[]
+
+            resolve((options.multiple ? Array.from(files) : files[0]) as PickResult<T>)
+        }
+
+        input.oncancel = () => {
+            resolve(options.multiple ? [] : (null as any))
+        }
+
+        input.click()
+    })
+}
+
+function toUint8Array(file: File): Promise<Uint8Array> {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader()
+
+        reader.onload = (e) => {
+            if (e.target?.result instanceof ArrayBuffer) {
+                resolve(new Uint8Array(e.target.result))
+            } else {
+                reject(new Error('Failed to read file as ArrayBuffer'))
+            }
+        }
+
+        reader.onerror = () => {
+            reject(reader.error)
+        }
+
+        reader.readAsArrayBuffer(file)
+    })
+}
+
+interface UploadOptions {
+    driveId: string
+    file: File
+    directory?: string
+}
+
+async function upload(options: UploadOptions){
+    const form = new FormData()
+    
+    form.append('file', options.file)
+
+    if (options.directory) {
+        form.append('directory', options.directory)
+    }
+
+    return $fetch.post(`/api/drives/${options.driveId}/upload`, {
+        body: form,
+        query: { directory: options.directory, }
+    })
+}
+
+export const $file = {
+    pick,
+    upload,
+    toUint8Array,
+}

package/src/client/utils/parseTo.ts

@@ -0,0 +1,15 @@
+import route from '#client/facades/route.ts' 
+
+export function parseTo(to: string) {
+    let result = to
+
+    // replace :param with route param value
+    for (const [key, value] of Object.entries(route.params)) {
+        const paramPlaceholder = `:${key}`
+
+        result = result.replace(paramPlaceholder, String(value))
+    }
+
+    return result
+}
+

package/src/client/utils/toast.ts

@@ -0,0 +1,3 @@
+import { toast } from 'vue-sonner'
+
+export const $toast = toast

package/src/client/utils/twMerge.ts

@@ -0,0 +1,16 @@
+
+import { clsx as originalClsx } from 'clsx'
+import type { ClassValue } from 'clsx'
+import { twMerge as originalTwMerge, type ClassNameValue } from 'tailwind-merge'
+
+export function twMerge(...inputs: ClassNameValue[]) {
+    return originalTwMerge(inputs)
+}
+
+export function clsx(...inputs: ClassValue[]) {
+    return originalClsx(inputs)
+}
+
+export function cn(...inputs: ClassValue[]) {
+    return originalTwMerge(originalClsx(inputs))
+}

package/src/client/zenith-env.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="vite/client" />
+import type { ContainerService, tryCatch } from '#shared/index.ts'
+import type ConfigService from '#shared/services/ConfigService.ts'
+import type TranslatorService from '#shared/services/TranslatorService.ts'
+
+export { }
+
+declare global {
+    var imports: Map<string, () => Promise<any>>
+    var importAsync: (id: string) => Promise<any>
+
+    var __CONFIG__: any | undefined
+    var __CONTAINER__: Record<string, any> | undefined
+    var __STATE__: Record<string, any> | undefined
+
+    var config: ConfigService | undefined // only on dev
+    var clientContainer: ContainerService | undefined
+    var $t: TranslatorService['t']
+    var $dt: TranslatorService['datetime']
+    var $d: TranslatorService['date']
+    var $translator: TranslatorService
+    var $try: typeof tryCatch
+}
+
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        $t(key: string, ...args: any[]): string;
+        $dt(value: any, options?: Intl.DateTimeFormatOptions): string;
+        $d(value: any, options?: Intl.DateTimeFormatOptions): string;
+        $translator: TranslatorService;
+        $try: typeof tryCatch;
+    }
+}
+