@sidekick-coder/zenith-kit 0.3.6 → 0.3.8

package/src/shared/mixins/HooksMixin.ts

@@ -0,0 +1,102 @@
+import type { Constructor } from '#shared/utils/compose.ts'
+
+export interface Listener {
+    event: string
+    listener: (...args: any[]) => void
+}
+
+export async function emitHook(constructor: any, event: string, ...args: any[]) {                
+    const listeners = constructor.listeners || []
+
+    for await (const l of listeners.filter((l: any) => l.event === event)) {
+        await l.listener(...args)
+    }
+}
+
+export function onHook(constructor: any, event: string, listener: (...args: any[]) => void) {
+    const listeners = constructor.listeners || []
+
+    const exists = listeners.find((l: any) => l.event === event && l.listener === listener)
+
+    if (exists) {
+        return
+    }
+
+    listeners.push({ 
+        event,
+        listener 
+    })
+
+    constructor.listeners = listeners
+}
+
+export function HooksStatic<TBase extends Constructor>(Base: TBase) {
+    return class extends Base {
+        constructor(...args: any[]) {
+            super(...args)
+                
+            if (typeof (this.constructor as any).boot === 'function') {
+                (this.constructor as any).boot.apply(this.constructor)
+            }
+        }
+
+        public static listeners = [] as Array<(...args: any[]) => void>
+
+        public static on(event: string, listener: (...args: any[]) => void) {
+            return onHook(this, event, listener)
+        }
+
+        public static async emit(event: string, ...args: any[]) {
+            return emitHook(this, event, ...args)
+        }
+    }
+}
+
+export default function Hooks<TBase extends Constructor>(Base: TBase) {
+    return class extends Base {
+        public listeners: Listener[]
+
+        constructor(...args: any[]) {
+            super(...args)
+            this.listeners = []
+        }
+
+        public on(event: string, listener: (...args: any[]) => void) {
+            this.listeners.push({ 
+                event,
+                listener 
+            })
+        }
+
+        public off(event: string, listener: (...args: any[]) => void) {
+            const index = this.listeners.findIndex((l) => l.event === event && l.listener === listener)
+
+            
+            if (index === -1) {
+                return
+            }
+            
+            this.listeners.splice(index, 1)
+        }
+
+        public emit(event: string, ...args: any[]) {
+            const listeners = this.listeners.filter((l) => l.event === event)
+
+
+            for (const l of listeners) {
+                l.listener(...args)
+            }
+        }
+        
+        public async emitAsync(event: string, ...args: any[]) {
+            const listeners = this.listeners.filter((l) => l.event === event)
+
+            for await (const l of listeners) {
+                await l.listener(...args)
+            }
+        }
+    }
+}
+
+HooksStatic.emit = emitHook
+HooksStatic.on = onHook

package/src/shared/mixins/SoftDeleteMixin.ts

@@ -0,0 +1,7 @@
+import type { Constructor } from '#shared/utils/compose.ts'
+
+export default function SoftDeleteMixin<T extends Constructor>(base: T) {
+    return class extends base {
+        public deleted_at: Date | string | null = null
+    }
+}

package/src/shared/mixins/TimestampMixin.ts

@@ -0,0 +1,8 @@
+import type { Constructor } from '#shared/utils/compose.ts'
+
+export default function TimestampMixin<T extends Constructor>(base: T) {
+    return class extends base {
+        public created_at: Date | string
+        public updated_at: Date | string
+    }
+}

package/src/shared/schemas/dashboardMetaSchema.ts

@@ -0,0 +1,18 @@
+import type { ValidatorResult } from '#shared/services/ValidatorService.ts'
+import validator from '#shared/facades/validator.ts'
+
+
+export type DashboardMetaSchema = ValidatorResult<ReturnType<typeof dashboardMetaSchema>>
+
+export function dashboardMetaSchema() {
+    return validator.create(v => v.object({
+        id: v.number(),
+        dashboard_id: v.number(),
+        name: v.string(),
+        value: v.nullable(v.string()),
+    }))
+}
+
+dashboardMetaSchema.create = validator.create(v => v.pick(dashboardMetaSchema(), ['dashboard_id', 'name', 'value']))
+
+dashboardMetaSchema.update = validator.create(v => v.partial(dashboardMetaSchema.create))

package/src/shared/schemas/dashboardSchema.ts

@@ -0,0 +1,21 @@
+import type { ValidatorResult } from '#shared/services/ValidatorService.ts'
+import validator from '#shared/facades/validator.ts'
+
+export type DashboardSchema = ValidatorResult<ReturnType<typeof dashboardSchema>>
+
+export function dashboardSchema() {
+    return validator.create(v => v.object({
+        id: v.number(),
+        name: v.string(),
+        description: v.nullable(v.string()),
+        created_at: v.string(),
+        updated_at: v.string(),
+        deleted_at: v.nullable(v.string()),
+
+        metas: v.optional(v.record(v.string(), v.any())),
+    }))
+}
+
+dashboardSchema.create = validator.create(v => v.pick(dashboardSchema(), ['name', 'description']))
+
+dashboardSchema.update = validator.create(v => v.partial(dashboardSchema.create))

package/src/shared/schemas/permissionAssignmentSchema.ts

@@ -0,0 +1,12 @@
+import * as v from 'valibot'
+
+export type PermissionAssignment = v.InferOutput<typeof permissionAssignmentSchema>
+
+export const permissionAssignmentSchema = v.object({
+    id: v.number(),
+    permission_id: v.number(),
+    assignable_type: v.string(),
+    assignable_id: v.string(),
+    created_at: v.string(),
+    updated_at: v.string(),
+})

package/src/shared/schemas/permissionSchema.ts

@@ -0,0 +1,15 @@
+import * as v from 'valibot'
+
+export type Permission = v.InferOutput<typeof permissionSchema>
+
+export const permissionSchema = v.object({
+    id: v.number(),
+    name: v.nullable(v.string()),
+    description: v.nullable(v.string()),
+    action: v.string(),
+    subject: v.string(),
+    conditions: v.nullable(v.string()),
+    created_at: v.string(),
+    updated_at: v.string(),
+    expires_at: v.string(),
+})

package/src/shared/schemas/tokenSchema.ts

@@ -0,0 +1,14 @@
+import * as v from 'valibot'
+
+export type Token = v.InferOutput<typeof tokenSchema>
+
+export const tokenSchema = v.object({
+    id: v.number(),
+    name: v.nullable(v.string()),
+    type: v.string(),
+    user_id: v.number(),
+    token: v.string(),
+    created_at: v.string(),
+    updated_at: v.string(),
+    expires_at: v.string(),
+})

package/src/shared/schemas/userSchema.ts

@@ -0,0 +1,20 @@
+import * as v from 'valibot'
+
+function userSchema() {
+    return v.object({
+        id: v.number(),
+        name: v.optional(v.string()),
+        email: v.pipe(v.string(), v.email()),
+        password: v.pipe(v.string(), v.minLength(6)),
+        username: v.pipe(v.string(), v.regex(/^[a-zA-Z0-9_-]+$/)),
+        verified_at: v.nullable(v.string()),
+        created_at: v.string(),
+        updated_at: v.string(),
+        deleted_at: v.nullable(v.string())
+    })
+}
+
+userSchema.create = () => v.omit(userSchema(), ['id', 'verified_at', 'created_at', 'updated_at', 'deleted_at'])
+userSchema.update = () => v.partial(userSchema.create())
+
+export default userSchema

package/src/shared/services/ConfigService.ts

@@ -0,0 +1,188 @@
+import { get, set, has, unset } from 'lodash-es'
+import { flatten } from '../utils'
+
+interface Entry {
+    key: string
+    value: any
+    source: string
+}
+
+export default class ConfigService {
+    public static __container_entry_key = 'ConfigService'
+
+    public entries: Map<string, Entry>
+
+    constructor() {
+        this.entries = new Map()
+    }
+
+    public list() {
+        return Array.from(this.entries.values())
+    }
+
+    public parseValue(value: any): any {
+        if (typeof value === 'string' && value.endsWith(':boolean')) {
+            return value.replace(':boolean', '').trim() === 'true'
+        }
+
+        return value
+    }
+
+    public loadFromRecord(record: Record<string, any>, source = 'unknow'): void {
+        for (const [key, value] of Object.entries(record)) {
+            this.entries.set(key, {
+                key,
+                value: this.parseValue(value),
+                source
+            })
+        }
+    }
+
+    public loadFromEntries(entries: [string, any][], source = 'unknow'): void {
+        for (const [key, value] of entries) {
+            this.entries.set(key, {
+                key,
+                value: this.parseValue(value),
+                source
+            })
+        }
+    }
+
+    public toRecord(): Record<string, any> {
+        const record: Record<string, any> = {}
+
+        for (const [key, entry] of this.entries.entries()) {
+            record[key] = entry.value
+        }
+
+        return record
+    }
+
+    public has(key: string): boolean {
+        const entry = this.entries.get(key)
+
+        if (entry) {
+            return true
+        }
+
+        if (!key.includes('.')) {
+            return false
+        }
+
+        const primary = key.split('.')[0]
+        const primaryEntry = this.entries.get(primary)
+
+        if (!primaryEntry) {
+            const entry = this.entries.get(key)
+
+            return entry ? true : false
+        }
+
+        const value = primaryEntry.value
+
+        if (typeof value !== 'object' || Array.isArray(value)) {
+            return false
+        }
+
+        return has(value, key.substring(primary.length + 1))
+    }
+
+    public get<T = any | undefined>(key: string, defaultValue?: any): T {
+        const entry = this.entries.get(key)
+
+        if (entry) {
+            return entry.value as T
+        }
+
+        if (!key.includes('.')) {
+            return defaultValue
+        }
+
+        const primary = key.split('.')[0]
+        const primaryEntry = this.entries.get(primary)
+
+        if (!primaryEntry) {
+            const entry = this.entries.get(key)
+
+            return entry ? entry.value : defaultValue
+        }
+
+        const value = primaryEntry.value
+
+        if (typeof value !== 'object' || Array.isArray(value)) {
+            return defaultValue
+        }
+
+        const result = get(value, key.substring(primary.length + 1), defaultValue)
+
+        return result
+    }
+
+    public getOne<T = any | undefined>(keys: string[], defaultValue?: any): T {
+        for (const key of keys) {
+            if (this.has(key)) {
+                return this.get<T>(key)
+            }
+        }
+
+        return defaultValue
+    }
+
+    public set(key: string, value: any, source = 'runtime'): void {
+        if (!key.includes('.')) {
+            this.entries.set(key, {
+                key: key,
+                source: source,
+                value
+            })
+            return
+        }
+
+        const primary = key.split('.')[0]
+        let primaryValue = this.get(primary, {})
+
+        if (typeof primaryValue !== 'object' || Array.isArray(primaryValue)) {
+            primaryValue = {}
+        }
+
+        set(primaryValue, key.substring(primary.length + 1), value)
+
+        this.entries.set(primary, {
+            key: primary,
+            source: source,
+            value: primaryValue
+        })
+    }
+
+    public unset(key: string): void {
+        if (!key.includes('.')) {
+            this.entries.delete(key)
+            return
+        }
+
+        const primary = key.split('.')[0]
+        const primaryValue = this.get(primary, {})
+
+        if (!primaryValue) return
+
+        if (typeof primaryValue !== 'object' || Array.isArray(primaryValue)) {
+            return
+        }
+
+        unset(primaryValue, key.substring(primary.length + 1))
+
+        this.entries.set(primary, {
+            key: primary,
+            source: 'runtime',
+            value: primaryValue
+        })
+    }
+
+    public clear(): void {
+        this.entries.clear()
+    }
+
+    public dump(): Record<string, any> {
+        return flatten(this.toRecord())
+    }
+}

package/src/shared/services/ConfigService.unit.test.ts

@@ -0,0 +1,227 @@
+import {
+    beforeEach,
+    describe,
+    expect,
+    it
+} from 'vitest'
+import ConfigService from './ConfigService.ts'
+
+describe('ConfigService', () => {
+    let config: ConfigService
+
+    beforeEach(() => {
+        config = new ConfigService()
+    })
+
+    describe('parseValue', () => {
+        it('should convert ":boolean" suffix strings to boolean true', () => {
+            expect(config.parseValue('true:boolean')).toBe(true)
+        })
+
+        it('should convert ":boolean" suffix strings to boolean false', () => {
+            expect(config.parseValue('false:boolean')).toBe(false)
+        })
+
+        it('should return non-boolean strings as-is', () => {
+            expect(config.parseValue('hello')).toBe('hello')
+        })
+
+        it('should return non-string values as-is', () => {
+            expect(config.parseValue(42)).toBe(42)
+            expect(config.parseValue(null)).toBe(null)
+            expect(config.parseValue({ a: 1 })).toEqual({ a: 1 })
+        })
+    })
+
+    describe('loadFromRecord', () => {
+        it('should load entries from a record', () => {
+            config.loadFromRecord({ key1: 'value1', key2: 'value2' })
+            expect(config.get('key1')).toBe('value1')
+            expect(config.get('key2')).toBe('value2')
+        })
+
+        it('should store the provided source', () => {
+            config.loadFromRecord({ key1: 'value1' }, 'test-source')
+            expect(config.list()[0].source).toBe('test-source')
+        })
+
+        it('should default source to "unknow"', () => {
+            config.loadFromRecord({ key1: 'value1' })
+            expect(config.list()[0].source).toBe('unknow')
+        })
+
+        it('should parse values when loading', () => {
+            config.loadFromRecord({ flag: 'true:boolean' })
+            expect(config.get('flag')).toBe(true)
+        })
+    })
+
+    describe('loadFromEntries', () => {
+        it('should load entries from an array of tuples', () => {
+            config.loadFromEntries([['key1', 'value1'], ['key2', 42]])
+            expect(config.get('key1')).toBe('value1')
+            expect(config.get('key2')).toBe(42)
+        })
+
+        it('should store the provided source', () => {
+            config.loadFromEntries([['key1', 'value1']], 'env')
+            expect(config.list()[0].source).toBe('env')
+        })
+    })
+
+    describe('list', () => {
+        it('should return all entries as an array', () => {
+            config.loadFromRecord({ a: 1, b: 2 })
+            expect(config.list()).toHaveLength(2)
+        })
+
+        it('should return empty array when no entries', () => {
+            expect(config.list()).toEqual([])
+        })
+    })
+
+    describe('toRecord', () => {
+        it('should convert entries to a plain record', () => {
+            config.loadFromRecord({ a: 1, b: 'two' })
+            expect(config.toRecord()).toEqual({ a: 1, b: 'two' })
+        })
+    })
+
+    describe('has', () => {
+        it('should return true for existing flat keys', () => {
+            config.set('foo', 'bar')
+            expect(config.has('foo')).toBe(true)
+        })
+
+        it('should return false for missing flat keys', () => {
+            expect(config.has('missing')).toBe(false)
+        })
+
+        it('should return true for nested keys inside object values', () => {
+            config.set('db', { host: 'localhost' })
+            expect(config.has('db.host')).toBe(true)
+        })
+
+        it('should return false for missing nested keys', () => {
+            config.set('db', { host: 'localhost' })
+            expect(config.has('db.port')).toBe(false)
+        })
+
+        it('should return false for dot-notation key when primary value is not an object', () => {
+            config.set('db', 'not-an-object')
+            expect(config.has('db.host')).toBe(false)
+        })
+    })
+
+    describe('get', () => {
+        it('should return the value for an existing key', () => {
+            config.set('name', 'zenith')
+            expect(config.get('name')).toBe('zenith')
+        })
+
+        it('should return defaultValue for a missing key', () => {
+            expect(config.get('missing', 'default')).toBe('default')
+        })
+
+        it('should return undefined when no defaultValue given for missing key', () => {
+            expect(config.get('missing')).toBeUndefined()
+        })
+
+        it('should support dot-notation to access nested object properties', () => {
+            config.set('db', { host: 'localhost', port: 5432 })
+            expect(config.get('db.host')).toBe('localhost')
+            expect(config.get('db.port')).toBe(5432)
+        })
+
+        it('should return defaultValue for missing nested key', () => {
+            config.set('db', { host: 'localhost' })
+            expect(config.get('db.port', 3306)).toBe(3306)
+        })
+
+        it('should return defaultValue when primary key value is not an object', () => {
+            config.set('db', 'flat')
+            expect(config.get('db.host', 'fallback')).toBe('fallback')
+        })
+    })
+
+    describe('getOne', () => {
+        it('should return the first found value from a list of keys', () => {
+            config.set('b', 'found')
+            expect(config.getOne(['a', 'b', 'c'])).toBe('found')
+        })
+
+        it('should return defaultValue when none of the keys exist', () => {
+            expect(config.getOne(['x', 'y'], 'fallback')).toBe('fallback')
+        })
+
+        it('should return undefined when no keys exist and no default provided', () => {
+            expect(config.getOne(['x', 'y'])).toBeUndefined()
+        })
+    })
+
+    describe('set', () => {
+        it('should set a flat key', () => {
+            config.set('env', 'production')
+            expect(config.get('env')).toBe('production')
+        })
+
+        it('should set a nested key using dot-notation', () => {
+            config.set('db.host', 'localhost')
+            expect(config.get('db.host')).toBe('localhost')
+        })
+
+        it('should merge nested keys under the same primary key', () => {
+            config.set('db.host', 'localhost')
+            config.set('db.port', 5432)
+            expect(config.get('db.host')).toBe('localhost')
+            expect(config.get('db.port')).toBe(5432)
+        })
+
+        it('should overwrite an existing flat key', () => {
+            config.set('env', 'dev')
+            config.set('env', 'prod')
+            expect(config.get('env')).toBe('prod')
+        })
+    })
+
+    describe('unset', () => {
+        it('should remove a flat key', () => {
+            config.set('temp', 'value')
+            config.unset('temp')
+            expect(config.has('temp')).toBe(false)
+        })
+
+        it('should remove a nested key using dot-notation', () => {
+            config.set('db', { host: 'localhost', port: 5432 })
+            config.unset('db.port')
+            expect(config.has('db.port')).toBe(false)
+            expect(config.get('db.host')).toBe('localhost')
+        })
+
+        it('should do nothing when unsetting a non-existent key', () => {
+            expect(() => config.unset('nonexistent')).not.toThrow()
+        })
+    })
+
+    describe('clear', () => {
+        it('should remove all entries', () => {
+            config.loadFromRecord({ a: 1, b: 2 })
+            config.clear()
+            expect(config.list()).toHaveLength(0)
+        })
+    })
+
+    describe('dump', () => {
+        it('should return a flattened record of all entries', () => {
+            config.set('db', { host: 'localhost', port: 5432 })
+            const dumped = config.dump()
+            expect(dumped['db.host']).toBe('localhost')
+            expect(dumped['db.port']).toBe(5432)
+        })
+
+        it('should include flat keys in the dump', () => {
+            config.set('env', 'test')
+            expect(config.dump()).toMatchObject({ env: 'test' })
+        })
+    })
+})