@sidekick-coder/zenith-kit 0.3.6 → 0.3.8

package/src/server/services/ShellService.ts

@@ -0,0 +1,150 @@
+import { spawn } from 'child_process'
+import LoggerService from '#shared/services/LoggerService.ts'
+import ShellExecption from '#shared/exceptions/ShellException.ts'
+
+interface CommandOptions {
+    cwd?: string
+    env?: NodeJS.ProcessEnv
+    shell?: boolean
+}
+
+export interface ShellServiceOptions {
+    debug?: boolean
+    logger?: LoggerService
+}
+
+export default class ShellService {
+    public static __container_entry_key = 'ShellService'
+
+    public debug: boolean
+    public logger: LoggerService
+
+    constructor(options: ShellServiceOptions = {}) {
+        this.debug = options.debug ?? false
+        this.logger = options.logger || new LoggerService()
+
+        if (this.debug) {
+            this.logger.debug('initialized in debug mode')
+        }
+    }
+
+    /**
+     * Execute a shell command and return a promise
+     */
+    public async command(bin: string, args: string[], options: CommandOptions = {}): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const child = spawn(bin, args, {
+                cwd: options.cwd || process.cwd(),
+                stdio: 'pipe',
+                shell: options.shell ?? true,
+                env: options.env || process.env
+            })
+
+            let data = ''
+
+            child.stdout?.on('data', (d) => {
+                data += d.toString()
+            })
+
+            child.stderr?.on('data', (d) => {
+                data += d.toString()
+            })
+
+            child.on('close', (code) => {
+                if (this.debug) {
+                    this.logger.debug('command executed', {
+                        bin,
+                        args,
+                        fullCommand: `${bin} ${args.join(' ')}`,
+                        output: data
+                    })
+                }
+
+                if (code === 0) {
+                    return resolve()
+                }
+
+                const errorMessage = `Command failed with exit code ${code}`
+
+                this.logger.error(errorMessage, {
+                    bin,
+                    args,
+                    code,
+                    output: data
+                })
+
+                reject(new ShellExecption(errorMessage, data, bin, args))
+
+            })
+
+            child.on('error', (error) => {
+                this.logger.error('Command execution error', {
+                    bin,
+                    args,
+                    fullCommand: `${bin} ${args.join(' ')}`,
+                    error: error?.message || error
+                })
+
+                reject(error)
+            })
+        })
+    }
+
+    /**
+     * Execute a shell command and return the output as a string
+     */
+    public async executeCommandWithOutput(bin: string, args: string[], options: CommandOptions = {}): Promise<string> {
+        if (this.debug) {
+            this.logger.debug('executing command', {
+                bin,
+                args,
+                fullCommand: `${bin} ${args.join(' ')}`,
+            })
+        }
+        return new Promise((resolve, reject) => {
+            const child = spawn(bin, args, {
+                cwd: options.cwd || process.cwd(),
+                stdio: 'pipe',
+                shell: options.shell !== undefined ? options.shell : true,
+                env: options.env || process.env
+            })
+
+            let output = ''
+            let errorOutput = ''
+
+            child.stdout?.on('data', (data) => {
+                output += data.toString()
+            })
+
+            child.stderr?.on('data', (data) => {
+                errorOutput += data.toString()
+            })
+
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(output.trim())
+                } else {
+                    const errorMessage = `Command failed with exit code ${code}: ${errorOutput}`
+                    this.logger.error(errorMessage, {
+                        bin,
+                        args,
+                        code,
+                        fullCommand: `${bin} ${args.join(' ')}`,
+                        errorOutput
+                    })
+
+                    reject(new ShellExecption(errorMessage, output, bin, args))
+                }
+            })
+
+            child.on('error', (error) => {
+                this.logger.error('Command execution error', {
+                    bin,
+                    args,
+                    error: error.message
+                })
+                reject(error)
+            })
+        })
+    }
+}

package/src/server/utils/basePath.ts

@@ -0,0 +1,33 @@
+import path from 'path'
+
+
+export function basePath(...args: string[]): string {
+    const BASE_PATH = process.env.ZENITH_BASE_PATH!
+
+    if (!BASE_PATH) {
+        throw new Error('ZENITH_BASE_PATH environment variable is not set')
+    }
+
+    return path.resolve(BASE_PATH, ...args)
+}
+
+export function storagePath(...args: string[]): string {
+    const BASE_PATH = process.env.ZENITH_BASE_PATH!
+    const STORAGE_PATH = process.env.ZENITH_STORAGE_PATH || path.join(BASE_PATH || '', 'storage')
+
+    return path.resolve(STORAGE_PATH, ...args)
+}
+
+export function relativeToBasePath(...args: string[]): string {
+    const BASE_PATH = process.env.ZENITH_BASE_PATH!
+
+    if (!BASE_PATH) {
+        throw new Error('ZENITH_BASE_PATH environment variable is not set')
+    }
+
+    return path.relative(process.cwd(), path.resolve(BASE_PATH, ...args))
+}
+
+export function tmpPath(...args: string[]): string {
+    return basePath('tmp', ...args)
+}

package/src/server/utils/createLoaderFactory.ts

@@ -0,0 +1,27 @@
+import { BaseException } from '#shared/index.ts'
+import type { Loader, LoaderRecord } from './defineLoader.ts'
+
+export function createLoaderFactory<E extends Record<string, any> = Record<string, any>, R extends LoaderRecord<E> = LoaderRecord<E>>(loaders: R) {
+    async function load(entities: E | E[], names: keyof R | (keyof R)[]) {
+        const items = Array.isArray(entities) ? entities : [entities]
+        const relationNames = Array.isArray(names) ? names : [names]
+
+        for (const name of relationNames) {
+            const loader = loaders?.[name as string] as Loader
+
+            if (!loader) {
+                throw new BaseException(`Loader ${String(name)} not declared`)
+            }
+
+            await loader.load(items)
+        }
+
+    }
+
+    return {
+        keys: Object.keys(loaders) as (keyof R)[],
+        loaders,
+        load 
+    }
+}
+

package/src/server/utils/cuid.ts

@@ -0,0 +1,14 @@
+import crypto from 'crypto'
+
+export function cuid(){
+    const randomBytes = new Uint8Array(8)
+    
+    crypto.getRandomValues(randomBytes)
+    
+    const random = Array.from(randomBytes, b => b.toString(36).padStart(2, '0')).join('')
+  
+    const timestamp = Date.now().toString(36)
+
+    return `c${timestamp}${random.slice(0, 12)}`
+}
+

package/src/server/utils/defineHandler.ts

@@ -0,0 +1,9 @@
+import type { HttpContext } from "#server/contracts/HttpContextContract.ts";
+
+export interface Handler {
+    (ctx: HttpContext): Promise<any> | (() => any)
+}
+
+export function defineHandler(handler: Handler): Handler {
+    return handler
+}

package/src/server/utils/defineLoader.ts

@@ -0,0 +1,11 @@
+export interface Loader<T = Record<string, any>> {
+    load(entities: T[]): Promise<void>
+}
+
+export interface LoaderRecord<T = Record<string, any>> {
+    [key: string]: Loader<T>
+}
+
+export function defineLoader<T = Record<string, any>>(loader: Loader<T>): Loader<T> {
+    return loader
+}

package/src/server/utils/generateIndexFile.ts

@@ -0,0 +1,55 @@
+import fg from 'fast-glob'
+import fs from 'fs'
+import path from 'path'
+
+// generate indexes for folders 
+export function generateIndexFile(options: any) {
+    const folders = options.folders
+    const filename = options.filename
+    const patterns = options.patterns || []
+    const defaultIgnore = [
+        "**/node_modules",
+        "**/*.spec.ts",
+        "**/*.spec-d.ts",
+        "**/*.test.ts",
+        "**/*.test-d.ts",
+    ]
+
+    if (options.folders) {
+        for (const folder of folders) {
+            patterns.push(`${folder}/**/*.ts`, `${folder}/**/*.js`)
+        }
+    }
+
+    const ignore = options.ignore || []
+
+    let content = ''
+
+    const files = fg.sync(patterns, {
+        ignore: [...defaultIgnore, ...ignore],
+    })
+
+    for (const file of files) {
+        const filePath = path.relative(path.dirname(filename), file)
+        const extension = path.extname(file)
+
+        const fileContent = fs.readFileSync(file, 'utf-8')
+
+        let shouldExportDefault = fileContent.includes('export default') && !filePath.includes('generateIndexFile.ts')
+
+        if (file.endsWith('.vue')) {
+            shouldExportDefault = true
+        }
+
+        content += `export * from './${filePath}'\n`
+
+        // default export 
+        if (shouldExportDefault) {
+            content += `export { default as ${path.basename(file, extension)} } from './${filePath}'\n`
+        }
+    }
+
+    content = content.trim()
+
+    fs.writeFileSync(filename, content)
+}

package/src/server/utils/importAll.ts

@@ -0,0 +1,112 @@
+import path from 'path'
+import fs from 'fs'
+import { pathToFileURL } from 'url'
+import fg from 'fast-glob'
+import { tryCatch } from '#shared/utils/tryCatch.ts'
+import logger from '#server/facades/logger.ts'
+
+interface Options {
+    cache?: boolean;
+    onBeforeImport?: (ctx: { filename: string }) => void | Promise<void>;
+    onAfterImport?: (ctx: { filename: string, module: any }) => void | Promise<void>;
+    onError?: (ctx: { filename: string, error: Error }) => void | Promise<void>;
+    exclude?: string[];
+}
+
+export async function importFiles(files: string[], options: Options = {}): Promise<Record<string, any>> {
+    const modules: Record<string, any> = {}
+    let onError: Required<Options>['onError'] = ctx => {
+        Object.assign(ctx.error, { filename: ctx.filename }) 
+
+        logger.error(`Failed to import ${ctx.filename}`, ctx.error)
+    }
+
+    if (options.onError) {
+        onError = options.onError
+    }
+
+    for (const filename of files) {
+        if (options.exclude && options.exclude.some(pattern => filename.includes(pattern))) {
+            continue
+        }
+
+        const ctx = { filename }
+
+        if (options.onBeforeImport) {
+            await options.onBeforeImport(ctx)
+        }
+
+        const cleanFilename = ctx.filename.split('?')[0]
+
+        if (/\.(mts|ts|js)$/.test(cleanFilename)) {
+            const abs = path.resolve(ctx.filename)
+            const fileUrl = pathToFileURL(abs)
+
+            if (options.cache === false) {
+                fileUrl.searchParams.set('t', Date.now().toString())
+            }
+
+            const [error, mod] = await tryCatch(() => import(fileUrl.toString()))
+            
+            if (error) {
+                Object.assign(error, {
+                    filename: ctx.filename,
+                    url: fileUrl,
+                })
+                onError({
+                    filename: ctx.filename,
+                    error 
+                })
+                continue
+            }
+
+            modules[filename] = mod
+        }
+        
+        if (/\.json$/.test(cleanFilename)) {
+            const [error, json] = await tryCatch(async () => {
+                const text = await fs.promises.readFile(ctx.filename, 'utf8')
+
+                return JSON.parse(text)
+            })
+
+            if (error) {
+                onError({
+                    filename: ctx.filename,
+                    error 
+                })
+                continue
+            }
+
+            modules[filename] = json
+        }
+
+        if (options.onAfterImport) {
+            await options.onAfterImport({
+                ...ctx,
+                module: modules[filename]
+            })
+        }
+    }
+
+    return modules
+}
+
+export async function importGlob(pattern: string, options: Options = {}): Promise<Record<string, any>> {
+    const files = await fg(pattern)
+
+    return importFiles(files as string[], options)
+}
+
+export async function importAll(directory: string, options: Options = {}): Promise<Record<string, any>> {
+    const dirents = await fs.promises.readdir(directory, { withFileTypes: true })
+
+    const files = dirents
+        .filter(dirent => dirent.isFile())
+        .map(dirent => path.join(directory, dirent.name))
+
+    return importFiles(files, options)
+}
+
+
+

package/src/server/utils/importOne.ts

@@ -0,0 +1,18 @@
+import { pathToFileURL } from 'node:url'
+import fs from 'node:fs'
+
+export async function importOne(filenames: string[]): Promise<any> {
+    for (const filename of filenames) {
+        const fileUrl = pathToFileURL(filename)
+
+        if (!fs.existsSync(filename)) {
+            continue
+        }
+
+        const mod = await import(fileUrl.toString())
+
+        return mod
+    }
+
+    return null
+}

package/src/server/utils/printTable.ts

@@ -0,0 +1,121 @@
+import Table from 'cli-table3'
+
+export interface TableColumn {
+    label: string
+    value: string | ((item: any) => string)
+    width?: number
+    realWidth?: number
+}
+
+export interface ObjectOptions {
+    keyWidth?: number
+}
+
+export function printObject(output: any = {}, options: ObjectOptions = {}) {
+    const screenWidth = process.stdout.columns || 80
+    const keyWidth = options.keyWidth || Math.floor(screenWidth * 0.2)
+    const valueWidth = Math.floor(screenWidth * 0.7)
+
+    const table = new Table({
+        wordWrap: true,
+        wrapOnWordBoundary: false,
+        colWidths: [keyWidth, valueWidth],
+    })
+
+    for (const key of Object.keys(output)) {
+        table.push([key, String(output[key])])
+    }
+
+    console.log(table.toString())
+}
+
+export function printTable(items: any[], columns?: TableColumn[]) {
+    const screenWidth = (process.stdout.columns || 80) - 6
+    const rows = [] as string[][]
+    const head: TableColumn[] = []
+
+    if (columns) {
+        head.push(...columns)
+    }
+
+    if (!columns) {
+        items.map((item: any) => Object.keys(item))
+            .flat()
+            .filter((value, index, self) => self.indexOf(value) === index)
+            .forEach((key) => {
+                head.push({
+                    label: key,
+                    value: key,
+                })
+            })
+    }
+
+    items.forEach((item: any) => {
+        const row = [] as string[]
+
+        head.forEach((h) => {
+            let value = ''
+
+            if (typeof h.value === 'function') {
+                value = h.value(item)
+            }
+
+            if (typeof h.value === 'string') {
+                value = item[h.value]
+            }
+
+            if (value === undefined || value === null) {
+                value = ''
+            }
+
+            if (typeof value === 'object' || Array.isArray(value)) {
+                value = JSON.stringify(value)
+            }
+            
+            row.push(value)
+        })
+
+        rows.push(row)
+    })
+
+    head.forEach((h) => {
+        if (h.width) {
+            h.width = Number(h.width)
+        }
+
+        if (!h.label) {
+            h.label = String(h.value)
+        }
+    })
+
+    const usedWidth = head.filter((h) => !!h.width).reduce((acc, h) => acc + h.width!, 0)
+    const remainingWidth = 100 - usedWidth
+    const withNoWidth = head.filter((h) => !h.width).length
+
+    head.forEach((h) => {
+        if (!h.width) {
+            h.width = Math.floor(remainingWidth / withNoWidth)
+        }
+    })
+
+    head.forEach((h) => {
+        if (h.width) {
+            h.realWidth = Math.floor(screenWidth * (h.width / 100))
+        }
+    })
+
+    const table = new Table({
+        head: head.map((h) => h.label),
+        style: {
+            head: [], //disable colors in header cells
+            border: [], //disable colors for the border
+        },
+        wordWrap: true,
+        wrapOnWordBoundary: false,
+        colWidths: head.map((h) => h.realWidth) as number[],
+    })
+
+    table.push(...rows)
+
+    console.log(table.toString())
+}

package/src/shared/entities/AclEntity.ts

@@ -0,0 +1,59 @@
+import { defineAbility, subject as createSubject } from '@casl/ability'
+import Permission from './PermissionEntity.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
+
+export default class AclEntity {
+    public static __container_entry_key = 'AclEntity'
+
+    public ability: ReturnType<typeof defineAbility>
+    public permissions: Permission[]
+    public debug: boolean = false
+    public logger: LoggerService
+
+    constructor(data: Partial<AclEntity> = {}) {
+        const permissions = data.permissions || []
+        const perms = permissions.map((permission) => Permission.from(permission))
+
+        
+        this.permissions = perms
+        this.debug = data.debug || false
+        this.logger = data.logger || new LoggerService().child({ label: 'acl' })
+        
+        this.ability = defineAbility((can) => {
+            perms.forEach((permission) => {
+                can(permission.action, permission.subject, permission.parsedConditions)
+            })
+        })
+
+        if (this.debug) {
+            this.logger.debug('initialized in debug mode', {
+                permissions: this.permissions,
+            })
+        }
+    }
+
+    public can(action: string, subject: any, object?: Record<string, any>) {
+
+        if (!object) {
+            return this.ability.can(action, subject)
+        }
+
+        const subjectWithObject = createSubject(subject, object)
+
+        return this.ability.can(action, subjectWithObject)
+    }
+
+    public cannot(action: string, subject: any, object?: Record<string, any>) {
+        if (!object) {
+            return this.ability.cannot(action, subject)
+        }
+
+        const subjectWithObject = createSubject(subject, object)
+
+        return this.ability.cannot(action, subjectWithObject)
+    }
+
+    public subject(subject: string, object: Record<string, any>) {
+        return createSubject(subject, object)
+    }
+}

package/src/shared/entities/CookieMapEntity.ts

@@ -0,0 +1,58 @@
+export interface CookieMapEntityOptions {
+    cookies?: Map<string, string>
+    prefix?: string
+}
+
+export default class CookieMapEntity {
+    public static __container_entry_key = 'CookieMapEntity'
+
+    public cookies: Map<string, string>
+    public prefix: string
+
+    constructor(data?: CookieMapEntityOptions) {
+        this.cookies = data?.cookies || new Map<string, string>()
+        this.prefix = data?.prefix || ''
+    }
+
+    public load(cookies: Record<string, string> | Map<string, string>) {
+        if (cookies instanceof Map) {
+            for (const [key, value] of cookies.entries()) {
+                this.set(key, value)
+            }
+
+            return
+        }
+
+        for (const key of Object.keys(cookies)) {
+            this.set(key, cookies[key])
+        }
+    }
+
+    public get(name: string, defaultValue: string | null = null): string | null {
+        const fullName = this.prefix + name
+
+        return this.cookies.get(fullName) || defaultValue
+    }
+
+    // @ts-expect-error - We want to allow any options to be passed here, as they may be used by the underlying cookie
+    //  eslint-disable-next-line @typescript-eslint/no-unused-vars
+    public set(name: string, value: string, options?: any) {
+        const fullName = this.prefix + name
+
+        this.cookies.set(fullName, value)
+    }
+
+    public toRecord(): Record<string, string> {
+        const result: Record<string, string> = {}
+
+        for (const [key, value] of this.cookies.entries()) {
+            if (key.startsWith(this.prefix)) {
+                const unprefixedKey = key.slice(this.prefix.length)
+
+                result[unprefixedKey] = value
+            }
+        }
+
+        return result
+    }
+}