@sidekick-coder/zenith-kit 0.3.7 → 0.3.9

package/src/shared/services/ContainerService.ts

@@ -0,0 +1,123 @@
+import BaseException from "#shared/exceptions/BaseException.ts"
+
+type Constructor<T = object> = new (...args: any[]) => T
+
+type EntryKey = string | symbol | Constructor
+
+export default class ContainerService {
+    private entries = new Map<EntryKey, any>()
+
+    public loadFromRecord(record: Record<string, any>): void {
+        Object.entries(record).forEach(([key, value]) => {
+            this.set(key, value)
+        })
+    }
+
+    public toRecord(): Record<string, any> {
+        const record: Record<string, any> = {}
+
+        for (const [key, value] of this.entries.entries()) {
+            record[String(key)] = value
+        }
+
+        return record
+    }
+
+    private getKey(payload: EntryKey): EntryKey {
+        let key = payload
+
+        if (typeof payload === 'function' || typeof payload === 'object') {
+            key = payload.name
+        }
+
+        const isConstructor = typeof payload !== 'string' && typeof payload !== 'symbol'
+
+        if (isConstructor && !(payload as any).__container_entry_key) {
+            console.warn(`Warning: The constructor ${payload.name} does not have a unique identifier. Consider adding a static property __container_entry_key to avoid potential conflicts.`)
+        }
+
+        if (isConstructor && (payload as any).__container_entry_key) {
+            key = (payload as any).__container_entry_key
+        }
+
+        return key
+
+    }
+
+    public set(payload: EntryKey, value: any) {
+        const key = this.getKey(payload)
+
+        this.entries.set(key, value)
+
+        return this
+    }
+
+    public has(payload: EntryKey): boolean {
+        const key = this.getKey(payload)
+
+        return this.entries.has(key)
+    }
+
+    public get<T>(payload: EntryKey): T {
+        const key = this.getKey(payload)
+
+        if (!this.entries.has(key)) {
+            throw new BaseException(`Entry with key "${String(key)}" not found in container.`)
+        }
+
+        const entry = this.entries.get(key)
+
+        return entry
+    }
+
+    public unset(payload: EntryKey): void {
+        const key = this.getKey(payload)
+
+        this.entries.delete(key)
+    }
+
+    public singleton<T>(classConstructor: Constructor<T>): T {
+        const key = classConstructor.name
+        const existingInstance = this.entries.get(key)
+
+        if (existingInstance) {
+            return existingInstance
+        }
+
+        const newInstance = new classConstructor()
+        this.entries.set(key, newInstance)
+        return newInstance
+    }
+
+    public load(entries: Record<any, any>): void {
+        Object.entries(entries).forEach(([key, value]) => {
+            this.set(key, value)
+        })
+    }
+
+    public proxy<T = unknown>(key: EntryKey): T {
+        return new Proxy({}, {
+            get: (_target, prop) => {
+                const entry = this.get<T>(key) as any
+                const value = entry[prop]
+
+                if (typeof value === 'function') {
+                    return value.bind(entry)
+                }
+
+                return entry[prop]
+            },
+            set: (_target, prop, value) => {
+                const entry = this.get<T>(key) as any
+
+                entry[prop] = value
+
+                return true
+            }
+        }) as T
+    }
+
+    public keys(): EntryKey[] {
+        return Array.from(this.entries.keys())
+    }
+}

package/src/shared/services/EmmitterService.ts

@@ -0,0 +1,216 @@
+import { debounce } from 'lodash-es'
+import { createId, tryCatch } from '../utils/index.ts'
+import LoggerService from './LoggerService.ts'
+
+export interface EmmitterListenerOptions {
+    event: string
+}
+export interface EmmitterListener {
+    (data: any, options: EmmitterListenerOptions): void
+}
+
+interface EmmitterHandler {
+    id: string
+    event: string
+    listener: EmmitterListener
+    originalListener?: EmmitterListener
+}
+
+interface OnOptions {
+    id?: string
+    unique?: boolean
+}
+
+interface OnDebounceOptions extends OnOptions {
+    debounce?: number
+}
+
+export interface EmmitterServiceOptions {
+    debug?: boolean
+    logger?: LoggerService
+}
+
+export default class EmmitterService<Events extends Record<string, any> = Record<string, any>> {
+    public static __container_entry_key = 'EmmitterService'
+
+    public handlers: EmmitterHandler[] = []
+    public debug: boolean
+    public logger: LoggerService
+
+    constructor (options?: EmmitterServiceOptions) {
+        this.debug = options?.debug || false
+        this.logger = options?.logger || new LoggerService()
+
+        if (this.debug) {
+            this.logger.debug('emmitter loaded with debug mode enabled')
+        }
+    }
+
+    public static create<Events extends Record<string, any> = Record<string, any>>(options?: EmmitterServiceOptions) {
+        return new EmmitterService<Events>(options)
+    }
+
+    public setDebug(debug: boolean) {
+        this.debug = debug
+
+        if (this.debug) {
+            this.logger.debug('debug mode enabled')
+        }
+    }
+
+    public setLogger(logger: LoggerService) {
+        this.logger = logger
+    }
+
+    public on<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler
+    public on(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler
+    public on(event: string, listener: EmmitterHandler['listener'], options?: OnOptions) {
+        const id = options?.id || createId()
+
+        if (options?.unique) {
+            const exists = this.handlers.some(h => (h.event === event && h.listener === listener) || h.id === id)
+
+            if (exists) {
+                return
+            }
+        }
+
+        const handler: EmmitterHandler = {
+            id,
+            event,
+            listener
+        }
+
+        this.handlers.push(handler)
+
+        if (this.debug) {
+            this.logger.debug('handler added', handler)
+        }
+
+        return handler
+    }
+
+    public once<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler
+    public once(event: string, listener: (args: any) => void, options?: OnOptions): EmmitterHandler
+    public once(event: string, listener: EmmitterHandler['listener'], options?: OnOptions) {
+        const wrapper = (args: any, options: any) => {
+            listener(args, options)
+
+            this.off(event, wrapper)
+        }
+
+        return this.on(event, wrapper as any, options)
+    }
+
+
+    public onDebounce<K extends keyof Events>(event: K, listener: (args: Events[K]) => void, options?: OnDebounceOptions): EmmitterHandler
+    public onDebounce(event: string, listener: (args: any) => void, options?: OnDebounceOptions): EmmitterHandler
+    public onDebounce(event: string, listener: EmmitterHandler['listener'], options?: OnDebounceOptions) {
+        const debounced = debounce(listener, options?.debounce || 300)
+
+        const handler = this.on(event, debounced as any, options)
+
+        if (handler) {
+            handler.originalListener = listener
+        }
+
+        return handler
+    }
+
+    public onAnyOf<K extends keyof Events>(events: K[], listener: (args: Events[K]) => void, options?: OnOptions): EmmitterHandler[]
+    public onAnyOf(events: string[], listener: (args: any) => void, options?: OnOptions): EmmitterHandler[]
+    public onAnyOf(events: string[], listener: EmmitterHandler['listener'], options?: OnOptions) {
+        const handlers: EmmitterHandler[] = []
+
+        for (const event of events) {
+            const handler = this.on(event, listener as any, options)
+
+            if (handler) {
+                handlers.push(handler)
+            }
+        }
+
+        return handlers
+    }
+
+    public off(event: string, listener: EmmitterHandler['listener']) {
+        this.handlers = this.handlers.filter(h => {
+            if (h.event === event && (h.listener === listener || h.originalListener === listener)) {
+                return false
+            }
+
+            return true
+        })
+
+        if (this.debug) {
+            this.logger.debug('handler removed', { event })
+        }
+    }
+
+    public emit<K extends keyof Events>(event: K, args: Events[K]): void
+    public emit(event: string, args?: any): void
+    public emit(event: string, args?: any) {
+
+        if (this.debug) {
+            this.logger.debug('emitting event', {
+                event,
+                args
+            })
+        }
+
+        const handlers = this.handlers.filter(h => h.event === event)
+
+        for (const handler of handlers) {
+            tryCatch.sync(() => handler.listener(args, { event }))
+        }
+    }
+
+    public async emitAndWait<K extends keyof Events>(event: K, args: Events[K]): Promise<void>
+    public async emitAndWait(event: string, args?: any): Promise<void>
+    public async emitAndWait(event: string, args?: any) {
+        const handlers = this.handlers.filter(h => h.event === event)
+
+        if (this.debug) {
+            this.logger.debug('emitting event and wait', {
+                handlers: handlers.length,
+                event,
+                args
+            })
+        }
+
+        for await (const handler of handlers) {
+            await handler.listener(args, { event })
+        }
+    }
+
+
+    public list() {
+        return this.handlers
+    }
+
+    public listByEvent(event: string) {
+        return this.handlers.filter(h => h.event === event)
+    }
+
+    public remove(payload: string | string[]) {
+        const ids = Array.isArray(payload) ? payload : [payload]
+
+        this.handlers = this.handlers.filter(h => !ids.includes(h.id))
+
+        if (this.debug) {
+            this.logger.debug('handlers removed', { ids })
+        }
+    }
+
+    public clear() {
+        this.handlers = []
+
+        if (this.debug) {
+            this.logger.debug('all handlers cleared')
+        }
+    }
+
+    public hasHandlers() {
+        return this.handlers.length > 0
+    }
+}

package/src/shared/services/LifecycleService.ts

@@ -0,0 +1,192 @@
+import LoggerService from './LoggerService.ts'
+import LifecycleHook from '#shared/entities/LifecycleHook.ts'
+import type { Constructor } from '#shared/utils/compose.ts'
+import { tryCatch } from '../utils/tryCatch.ts'
+import { orderBy } from 'lodash-es'
+
+type LifecycleMethod = 'register' | 'load' | 'boot' | 'shutdown'
+
+interface ListOptions {
+    include?: string | string[]
+    exclude?: string | string[]
+}
+
+export interface LifecycleServiceOptions {
+    debug?: boolean
+    hooks?: Map<string, LifecycleHook>
+    logger?: LoggerService
+    onError?: (error: Error, context: { hookId: string; method: LifecycleMethod }) => void
+}
+
+export default class LifecycleService {
+    public static __container_entry_key = 'LifecycleService'
+
+    public hooks: Map<string, LifecycleHook>
+    public logger: LoggerService
+    public debug = false
+
+    constructor(data: LifecycleServiceOptions = {}) {
+        this.debug = data.debug ?? this.debug
+        this.hooks = data.hooks ?? new Map()
+        this.logger = data.logger ?? new LoggerService()
+        
+        if (data.onError) {
+            this.onError = data.onError
+        }
+    }
+
+    public setOnError(handler: Required<LifecycleServiceOptions>['onError']) {
+        this.onError = handler
+    }
+
+
+    public onError(error: Error, context: { hookId: string; method: LifecycleMethod }) {
+        Object.assign(error, { context })
+
+        this.logger.error(`Error in hook ${context.method} (${context.hookId}):`, error)
+    }
+
+    public mapAliases(args: string[]) {
+        const result: string[] = []
+        const all = Array.from(this.hooks.values())
+
+        for (const hook of all) {
+            if (args.includes(hook.hook_id)) {
+                result.push(hook.hook_id)
+                continue
+            }
+
+            if (hook.hook_aliases) {
+                const matchedAlias = hook.hook_aliases.find(alias => args.includes(alias))
+
+                if (matchedAlias) {
+                    result.push(hook.hook_id)
+                }
+            }
+        }
+
+        return result
+    }
+
+    public list(options?: ListOptions) {
+        let hooks = Array.from(this.hooks.values())
+
+        if (options?.exclude) {
+            let ids = Array.isArray(options.exclude) ? options.exclude : [options.exclude]
+
+            ids = this.mapAliases(ids)
+
+            hooks = hooks.filter(hook => !ids.includes(hook.hook_id))
+        }
+
+        if (options?.include) {
+            let ids = Array.isArray(options.include) ? options.include : [options.include]
+
+            ids = this.mapAliases(ids)
+
+            hooks = hooks.filter(hook => ids.includes(hook.hook_id))
+        }
+
+        hooks = orderBy(hooks, ['order'], ['asc'])
+
+        return hooks
+    }
+
+    public add(...payload: (LifecycleHook | Constructor<LifecycleHook>)[]): void {
+        const instances: LifecycleHook[] = []
+
+        for (const item of payload) {
+            if (typeof item === 'function') {
+                instances.push(new item())
+                continue
+            }
+
+            instances.push(item)
+        }
+
+        for (const hook of instances) {
+            if (!hook.hook_id) {
+                this.logger.warn('Skipping hook without hook_id:', hook)
+                continue
+            }
+
+            this.hooks.set(hook.hook_id, hook)
+
+            if (this.debug) {
+                this.logger.debug('add ' + hook.hook_id)
+            }
+
+            if (hook.subhooks) {
+                hook.subhooks.forEach(subhook => this.add(subhook))
+            }
+        }
+    }
+
+    public async emitMethod(method: LifecycleMethod, options?: ListOptions): Promise<void> {
+        const hooks = this.list(options) 
+
+        if (this.debug) {
+            this.logger.debug(`emitting ${method} for hooks:`, {
+                hooks: hooks.map(hook => hook.hook_id)
+            })
+        }
+
+        for (const hook of this.list(options)) {
+            const map = {
+                register: () => Promise.all([hook.register(), hook.onRegister()]),
+                load: () => Promise.all([hook.load(), hook.onLoad()]),
+                boot: () => Promise.all([hook.boot(), hook.onBoot()]),
+                shutdown: () => Promise.all([hook.shutdown(), hook.onShutdown()]),
+            }
+
+            const [error] = await tryCatch(() => map[method]())
+
+            if (error) {
+                this.onError(error, { hookId: hook.hook_id, method })
+                continue
+            }
+
+            if (this.debug) {
+                this.logger.debug(`${method} ` + hook.hook_id)
+            }
+        }
+    }
+
+    public async emit(payload: LifecycleMethod | LifecycleMethod[], options?: ListOptions): Promise<void> {
+        const methods = Array.isArray(payload) ? payload : [payload]
+
+        for (const method of methods) {
+            await this.emitMethod(method, options)
+        }
+    }
+
+    public on(method: LifecycleMethod, handler: () => Promise<void>): void {
+        const h = new LifecycleHook()
+
+        h.hook_id = `custom:${method}:${Date.now()}`
+
+        h[method] = handler
+
+        this.add(h)
+    }
+
+    public async register(options?: ListOptions): Promise<void> {
+        return this.emit('register', options)
+    }
+
+    public async load(options?: ListOptions): Promise<void> {
+        return this.emit('load', options)
+    }
+
+    public async boot(options?: ListOptions): Promise<void> {
+        return this.emit('boot', options)
+    }
+
+    public async shutdown(options?: ListOptions): Promise<void> {
+        await this.emit('shutdown', options)
+    }
+
+    public clear(): void {
+        this.hooks.clear()
+    }
+}

package/src/shared/services/LoggerService.ts

@@ -0,0 +1,28 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-nocheck
+
+export default class LoggerService {
+    public static __container_entry_key = 'LoggerService' 
+
+    public info(message: string, meta?: any): void {
+        // Implementation here
+    }
+    
+    public debug(message: string, meta?: any): void {
+        // Implementation here
+    }
+    
+    public warn(message: string, meta?: any): void {
+        // Implementation here
+    }
+    
+    public error(message: string | Error, meta?: any): void {
+        // Implementation here
+    }
+
+    public child(options: any): LoggerService {
+        // Implementation here
+        return new LoggerService()
+    }
+}

package/src/shared/services/TranslatorService.ts

@@ -0,0 +1,131 @@
+import LoggerService from './LoggerService.ts'
+
+export default class TranslatorService {
+    public static __container_entry_key = 'TranslatorService'
+
+    public entries: Map<string, string>
+    public locale: string
+    public localeLoaders: Map<string, () => Promise<Record<string, string>>>
+    public debug: boolean = false
+    public logger: LoggerService
+    public cache: Map<string, Record<string, string>>
+
+    constructor(data: Partial<TranslatorService> = {}) {
+        this.entries = data.entries || new Map<string, string>()
+        this.locale = data.locale || 'en'
+        this.debug = data.debug || false
+        this.cache = data.cache || new Map<string, Record<string, string>>()
+        this.logger = data.logger || new LoggerService()
+        this.localeLoaders = new Map<string, () => Promise<Record<string, string>>>()
+
+        if (this.debug) {
+            this.logger.debug('initialized in debug mode', { locale: this.locale })
+        }
+    }
+
+    public get locales(): string[] {
+        return Array.from(this.localeLoaders.keys())
+    }
+
+    public list(): { key: string; value: string }[] {
+        const items: { key: string; value: string }[] = []
+
+        this.entries.forEach((value, key) => {
+            items.push({
+                key,
+                value
+            })
+        })
+
+        return items
+    }
+
+
+    public async getEntries(locale: string): Promise<Record<string, string>> {
+        const cache = this.cache.get(locale)!
+
+        if (cache && this.debug) {
+            this.logger.debug(`load locale "${locale}" from cache`, {
+                locale,
+                length: Object.keys(cache).length
+            })
+        }
+
+        if (cache) {
+            return cache
+        }
+
+        const loader = this.localeLoaders.get(locale)
+
+        if (!loader) {
+            this.logger.warn(`no loader found for locale "${locale}"`)
+            return {}
+        }
+
+        const entries = await loader()
+
+        this.cache.set(locale, entries)
+
+        if (this.debug) {
+            this.logger.debug(`load locale ${locale}`, {
+                locale,
+                keys: Object.keys(entries).length
+            })
+        }
+
+        return entries
+    }
+
+    public async load(locale: string) {
+        const entries = await this.getEntries(locale)
+
+        this.entries = new Map<string, string>(Object.entries(entries))
+
+        this.locale = locale
+    }
+
+    public t(key: string, args: any = {}): string {
+        if (!this.entries.has(key) && this.debug) {
+            this.logger.debug(`missing translation for key "${key}"`, {
+                key,
+                locale: this.locale
+            })
+        }
+
+        const entry = this.entries.get(key) || key
+
+        let translation = entry
+
+        if (!Object.keys(args).length) {
+            return translation
+        }
+
+        Object.entries(args).forEach(([aKey, aValue]) => {
+            translation = translation.replace(`:${aKey}`, String(aValue))
+        })
+
+        return translation
+    }
+
+    public date(data: string | number | Date) {
+        const date = new Date(data)
+
+        return date.toLocaleDateString(this.locale, {
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit'
+        })
+    }
+
+    public datetime(data: string | number | Date) {
+        const date = new Date(data)
+
+        return date.toLocaleString(this.locale, {
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+        })
+    }
+}

package/src/shared/services/UploadService.ts

@@ -0,0 +1,19 @@
+export default class UploadService {
+    public static __container_entry_key = 'UploadService'
+
+    public single(name: string){
+        const error = new Error('Method not implemented.')
+
+        Object.assign(error, { name })
+
+        throw error
+    }
+
+    public multiple(name: string) {
+        const error = new Error('Method not implemented.')
+
+        Object.assign(error, { name })
+
+        throw error
+    }
+}