@sidekick-coder/zenith-kit 0.3.7 → 0.3.8

package/src/server/services/RouterService.ts

@@ -0,0 +1,239 @@
+import { join } from 'lodash-es'
+import Route from '#server/entities/RouteEntity.ts'
+import type { Handler, Middleware, MiddlewareHandleResult } from '#server/contracts/RouterContract.ts'
+import { compose } from '#shared/utils/compose.ts'
+import Hooks from '#shared/mixins/HooksMixin.ts'
+import { LoggerService } from '#shared/index.ts'
+import { matchPath } from '#shared/utils/matchPaths.ts'
+
+type RouteContext = 'global' | 'group' | 'route'
+
+interface MiddlewareRegister {
+    middleware: Middleware
+    context: RouteContext
+}
+
+interface LoadOptions {
+    debug?: boolean;
+}
+
+export interface RouterEvents {
+    'router:registered': {
+        router: RouterService
+    }
+    'router:loaded': {
+        router: RouterService
+    }
+}
+
+
+export default class RouterService<C = {}> extends compose(Hooks) {
+    public static __container_entry_key = 'RouterService'
+
+    public routes: Route[] = []
+
+    public middlewares: MiddlewareRegister[] = []
+    public prefixes: string[] = []
+
+    public groups: RouterService<any>[] = []
+    public groupPrefixes: string[] = []
+
+    public debug = false
+    public logger = new LoggerService()
+    public metadata: Record<string, any> = {}
+
+    constructor(data: Partial<RouterService<C>> = {}) {
+        super()
+        this.routes = data.routes || []
+        this.middlewares = data.middlewares || []
+        this.prefixes = data.prefixes || []
+        this.groups = data.groups || []
+        this.groupPrefixes = data.groupPrefixes || []
+        this.debug = data.debug || false
+        this.metadata = data.metadata || {}
+        this.listeners = data.listeners || []
+        this.logger = data.logger || new LoggerService()
+    }
+
+    public use<T extends Middleware>(middleware: T, context: RouteContext = 'route') {
+        this.middlewares.push({
+            middleware,
+            context,
+        })
+
+        return this as RouterService<C & MiddlewareHandleResult<[typeof middleware]>>
+    }
+
+    public prefix(prefix: string) {
+        this.prefixes.push(prefix)
+
+        return this
+    }
+
+    public makePath(args: string): string {
+        let result = join([...this.groupPrefixes, ...this.prefixes, args], '/')
+
+        // remove duplicate slashes
+        result = result.replace(/\/+/g, '/')
+
+        return result
+    }
+
+    public add(payload: Pick<Route, 'path' | 'method' | 'handler'>) {
+        const route = new Route({
+            method: payload.method,
+            path: this.makePath(payload.path),
+            handler: payload.handler,
+            middlewares: this.middlewares.map(m => m.middleware),
+        })
+
+        this.middlewares = this.middlewares.filter(m => m.context !== 'route')
+
+        this.prefixes = [] // Reset prefixes after use
+
+        this.routes.push(route)
+
+        if (this.debug) {
+            this.logger.debug('added route', route)
+        }
+
+        this.emit('added', route)
+    }
+
+    public get(path: string, handler: Handler<C>) {
+        this.add({
+            path,
+            method: 'GET',
+            handler,
+        })
+    }
+
+    public post(path: string, handler: Handler<C>) {
+        this.add({
+            path,
+            method: 'POST',
+            handler,
+        })
+    }
+
+    public put(path: string, handler: Handler<C>) {
+        this.add({
+            path,
+            method: 'PUT',
+            handler,
+        })
+    }
+
+    public patch(path: string, handler: Handler<C>) {
+        this.add({
+            path,
+            method: 'PATCH',
+            handler,
+        })
+    }
+
+    public many(methods: Route['method'][], path: string, handler: Handler<C>) {
+        methods.forEach(method => {
+            this.add({
+                path,
+                method,
+                handler,
+            })
+        })
+    }
+
+    public delete(path: string, handler: Handler<C>) {
+        this.add({
+            path,
+            method: 'DELETE',
+            handler,
+        })
+    }
+
+
+    public group() {
+        const group = new RouterService<C>({
+            listeners: this.listeners, // Inherit listeners from parent
+            debug: this.debug,
+        })
+
+        group.groupPrefixes = this.prefixes // Inherit prefixes from parent
+        group.middlewares = this.middlewares.map(r => ({
+            middleware: r.middleware,
+            context: 'group'
+        }))
+
+        this.groups.push(group)
+
+        this.middlewares = this.middlewares.filter(m => m.context !== 'route')
+        this.prefixes = [] // Reset prefixes after use
+
+        return group
+    }
+
+    public resolve(method: string, path: string) {
+        const route = this.list()
+            .find(r => {
+                if (r.method.toUpperCase() !== method.toUpperCase()) {
+                    return false
+                }
+
+                return matchPath(r.path, path)
+            })
+
+        if (!route) {
+            return null
+        }
+
+        return route
+    }
+
+    public async execute(route: Route, initialCtx: any) {
+        if (!route.handler) {
+            throw new Error(`Route handler not found for ${route.method} ${route.path}`)
+        }
+
+        const ctx = { ...initialCtx }
+
+        for await (const middleware of route.middlewares) {
+            const result = await middleware.handle(ctx)
+
+            if (result && 'redirect' in result) {
+                return result
+            }
+
+            Object.assign(ctx, result)
+        }
+
+        return route.handler(ctx)
+    }
+
+    public clear() {
+        if (this.debug) {
+            this.logger.debug('clear', { count: this.routes.length })
+        }
+
+        this.routes = []
+        this.groups = []
+    }
+
+    public list() {
+        return this.routes.concat(...this.groups.map(g => g.routes))
+    }
+
+    public async load(options: LoadOptions = {}) {
+        this.debug = options.debug ?? this.debug
+
+        if (this.debug) {
+            this.logger.debug('service loaded in debug mode')
+        }
+    }
+
+    public loadSync(options: LoadOptions = {}) {
+        this.debug = options.debug ?? this.debug
+
+        if (this.debug) {
+            this.logger.debug('service loaded in debug mode')
+        }
+    }
+}

package/src/server/services/RouterService.unit.test.ts

@@ -0,0 +1,75 @@
+import {
+    describe,
+    it,
+    expect,
+    vi
+} from 'vitest'
+import Router from './RouterService.ts'
+
+describe('Router', () => {
+    it('should add GET route and resolve it', () => {
+        const router = new Router()
+        const handler = vi.fn()
+        router.get('/test', handler)
+        const route = router.resolve('GET', '/test')
+        expect(route).toBeTruthy()
+        expect(route?.handler).toBe(handler)
+    })
+
+    it('should add POST route and resolve it', () => {
+        const router = new Router()
+        const handler = vi.fn()
+        router.post('/submit', handler)
+        const route = router.resolve('POST', '/submit')
+        expect(route).toBeTruthy()
+        expect(route?.handler).toBe(handler)
+    })
+
+    it('should return null for non-existent route', () => {
+        const router = new Router()
+        const route = router.resolve('GET', '/notfound')
+        expect(route).toBeNull()
+    })
+
+
+    it('should match path with params', () => {
+        const router = new Router()
+        const match = router.matchPath('/user/:id', '/user/123')
+        expect(match).toBe(true)
+    })
+
+    it('should not match path with different segments', () => {
+        const router = new Router()
+        const match = router.matchPath('/user/:id', '/profile/123')
+        expect(match).toBe(false)
+    })
+
+    it('should match path with wildcard spread parameter', () => {
+        const router = new Router()
+        const match = router.matchPath('/files/*', '/files/documents/folder/file.txt')
+        expect(match).toBe(true)
+    })
+
+
+    it('should match wildcard at root level', () => {
+        const router = new Router()
+        const match = router.matchPath('*', '/any/path/here')
+        expect(match).toBe(true)
+    })
+
+
+    it('should match empty path with wildcard', () => {
+        const router = new Router()
+        const match = router.matchPath('*', '/')
+        expect(match).toBe(true)
+    })
+
+    it('should add and resolve wildcard route', () => {
+        const router = new Router()
+        const handler = vi.fn()
+        router.get('/files/*', handler)
+        const route = router.resolve('GET', '/files/documents/test.pdf')
+        expect(route).toBeTruthy()
+        expect(route?.handler).toBe(handler)
+    })
+})

package/src/server/services/SchedulerService.ts

@@ -0,0 +1,219 @@
+import fs from 'fs'
+import path from 'path'
+import nodeSchedule from 'node-schedule'
+import logger from '../facades/logger.ts'
+import { tryCatch } from '#shared/utils/tryCatch.ts'
+import { createId } from '#client/utils/createId.ts'
+import RoutineEntity from '#server/entities/RoutineEntity.ts'
+import { BaseException, LoggerService } from '#shared/index.ts'
+
+export interface AddOptions {
+    id?: string
+}
+
+export interface SchedulerServiceOptions {
+    logger?: LoggerService
+    debug?: boolean
+}
+
+export interface SchedulerEvents {
+    'scheduler:registered': {
+        scheduler: SchedulerService
+    }
+    'scheduler:loaded': {
+        scheduler: SchedulerService
+    }
+    'scheduler:booted': {
+        scheduler: SchedulerService
+    },
+    'scheduler:shutdowned': {
+        scheduler: SchedulerService
+    }
+}
+
+export default class SchedulerService {
+    public static __container_entry_key = 'SchedulerService'
+    public routines: RoutineEntity[]
+    public logger: LoggerService
+    public debug: boolean
+    public dirs: string[] = []
+
+    constructor(options?: SchedulerServiceOptions) {
+        this.routines = []
+        this.logger = options?.logger || new LoggerService()
+        this.debug = options?.debug || false
+    }
+
+    public static create(options?: SchedulerServiceOptions) {
+        return new SchedulerService(options)
+    }
+
+    public setLogger(logger: LoggerService) {
+        this.logger = logger
+    }
+
+    public setDebug(debug: boolean) {
+        this.debug = debug
+    }
+
+    public addDir(dir: string) {
+        this.dirs.push(dir)
+    }
+
+    public add(routine: Omit<RoutineEntity, 'job'>) {
+        const id = routine?.id || createId()
+
+        this.routines.push(routine)
+
+        if (this.debug) {
+            this.logger.debug(`${id} routine added`, {
+                id: id,
+                cron: routine.cron,
+            })
+        }
+    }
+
+    public remove(id: RoutineEntity['id'] | RoutineEntity['id'][]) {
+        const ids = Array.isArray(id) ? id : [id]
+
+        this.routines = this.routines.filter(r => !ids.includes(r.id))
+
+        if (this.debug) {
+            this.logger.info('routines removed', {
+                ids: ids
+            })
+        }
+    }
+
+
+    public async loadFile(filename: string) {
+        if (!fs.existsSync(filename)) {
+            this.logger.warn(`File not found: ${filename}`)
+            return
+        }
+
+        const [error, mod] = await tryCatch(() => import(filename))
+
+        if (error) {
+            this.logger.error(`failed to load routines from ${filename}`, error)
+            return
+        }
+
+        const ctr = mod?.default || mod
+
+        if (!ctr?.is_routine) {
+            this.logger.warn(`file does not export a routine: ${filename}`)
+            return
+        }
+
+        const instance = new ctr()
+
+        instance.id = instance.id || filename
+
+        this.add(instance)
+
+        if (this.debug) {
+            this.logger.debug('file loaded', { filename })
+        }
+    }
+
+    public async loadDirectory(directory: string) {
+        if (!fs.existsSync(directory)) {
+            logger.warn('directory not found', { directory })
+            return
+        }
+
+        const files = fs.readdirSync(directory).filter(file => file.endsWith('.ts'))
+
+        for (const file of files) {
+            await this.loadFile(path.join(directory, file))
+        }
+    }
+
+    public async load() {
+        for (const dir of this.dirs) {
+            await this.loadDirectory(dir)
+        }
+    }
+
+    public has(id: RoutineEntity['id']): boolean {
+        return this.routines.some(routine => routine.id === id)
+    }
+
+    public async startRoutine(id: RoutineEntity['id']) {
+        const routine = this.routines.find(r => r.id === id)
+
+        if (!routine) {
+            throw new BaseException(`RoutineEntity not found: ${id}`)
+        }
+
+        if (routine.job) {
+            routine.job.cancel()
+        }
+
+        const logger = this.logger.child({
+            routineId: routine.id,
+            routineCron: routine.cron
+        })
+
+        const cb = async () => {
+            const [error] = await tryCatch(() => routine.handle())
+
+            if (error) {
+                logger.error(error.message, error)
+                return
+            }
+
+            logger.info(`${routine.id} routine executed`)
+        }
+
+        routine.job = nodeSchedule.scheduleJob(routine.cron, cb)
+
+        logger.info(`${routine.id} routine started`)
+    }
+
+    public async addAndStart(routine: Omit<RoutineEntity, 'job'>) {
+        this.add(routine)
+
+        await this.startRoutine(routine.id)
+    }
+
+    public async stopRoutine(id: RoutineEntity['id']) {
+        const routine = this.routines.find(r => r.id === id)
+
+        if (!routine) {
+            throw new BaseException('RoutineEntity not found', 404)
+        }
+
+        if (!routine.job) {
+            return
+        }
+
+        routine.job.cancel()
+
+        this.logger.info(`${routine.id} routine stopped`)
+    }
+
+    public async stopAndRemove(id: RoutineEntity['id']) {
+        await this.stopRoutine(id)
+
+        this.remove(id)
+    }
+
+
+    public async boot() {
+        for (const routine of this.routines) {
+            await this.startRoutine(routine.id)
+        }
+    }
+
+    public async shutdown() {
+        for (const routine of this.routines) {
+            await this.stopRoutine(routine.id)
+        }
+    }
+
+    public list() {
+        return this.routines
+    }
+}

package/src/server/services/SeederService.ts

@@ -0,0 +1,172 @@
+import fs from 'fs'
+import path from 'path'
+import EmmitterService from '#shared/services/EmmitterService.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
+import type { Kysely } from 'kysely'
+import SeederEntity from '#server/entities/SeederEntity.ts'
+import { tryCatch } from '#shared/index.ts'
+
+
+export interface SeederSource {
+    id: string;
+    directory: string;
+}
+
+export interface ListFilters {
+    source?: string | string[];
+    name?: string | string[];
+}
+
+export interface SeederResult {
+    name: string;
+    filename: string;
+    source: string | null;
+    result: 'success' | 'failed';
+    error?: any;
+}
+
+export interface SeederEvents {
+    'seeder:before-run': {
+        seeders: string[];
+    };
+    'seeder:after-run': {
+        seeders: string[];
+    };
+}
+
+export interface SeederServiceOptions {
+    db: Kysely<any>;
+    sources?: SeederSource[];
+    debug?: boolean;
+    emmitter?: EmmitterService;
+    logger?: LoggerService
+}
+
+export default class SeeederService {
+    public static __container_entry_key = 'SeederService'
+
+    public debug = false
+    public emmitter: EmmitterService
+    public logger: LoggerService
+    public db: Kysely<any>
+    public sources: SeederSource[]
+
+    constructor(options: SeederServiceOptions) {
+        this.debug = options.debug ?? this.debug
+        this.emmitter = options.emmitter || new EmmitterService()
+        this.logger = options.logger || new LoggerService()
+        this.db = options.db
+        this.sources = options.sources || []
+    }
+
+    public addSource(source: SeederSource) {
+        this.sources.push(source)
+    }
+
+    public async listSource(source: SeederSource) {
+        const entries = await fs.promises.readdir(source.directory)
+                const extensions = ['.js', '.ts', '.mjs', '.mts']
+
+
+        const items: SeederEntity[] = []
+
+        for (const entry of entries) {
+            if (!extensions.includes(path.extname(entry))) {
+                continue
+            }
+
+            const fullPath = path.join(source.directory, entry)
+            const name = path.basename(entry, path.extname(entry))
+
+            const entity = new SeederEntity({
+                name,
+                source: source.id,
+                filename: fullPath,
+            })
+
+            items.push(entity)
+        }
+
+        return items
+    }
+
+    public async list(filters?: ListFilters) {
+        let items = [] as SeederEntity[]
+
+        for await (const source of this.sources) {
+            const sourceSeeders = await this.listSource(source)
+
+            items.push(...sourceSeeders)
+        }
+
+        if (filters?.source) {
+            const sources = Array.isArray(filters.source) ? filters.source : [filters.source]
+
+            items = items.filter(i => i.source && sources.includes(i.source))
+        }
+
+        if (filters?.name) {
+            const names = Array.isArray(filters.name) ? filters.name : [filters.name]
+
+            items = items.filter(i => names.includes(i.name))
+        }
+
+        // Sort by name
+        items.sort((a, b) => a.name.localeCompare(b.name))
+
+        return items
+    }
+
+    public async runSeeder(seeder: SeederEntity): Promise<SeederResult> {
+        const [error] = await tryCatch(() => seeder.run(this.db))
+
+        if (error) {
+            this.logger.error(`failed to run seeder ${seeder.name}`, error)
+            return {
+                name: seeder.name,
+                filename: seeder.filename,
+                source: seeder.source,
+                result: 'failed',
+                error,
+            }
+        }
+
+        this.logger.info(`seeder ${seeder.name} ran successfully`)
+
+        return {
+            name: seeder.name,
+            filename: seeder.filename,
+            source: seeder.source,
+            result: 'success',
+        }
+    }
+
+
+    public async run(filters: ListFilters & { steps?: number } = {}): Promise<SeederResult[]> {
+        const items = await this.list(filters)
+
+        await this.emmitter.emitAndWait('seeder:before-run', {
+            seeders: items.map(m => m.name)
+        })
+
+        const results: SeederResult[] = []
+
+        for (const s of items) {
+            const result = await this.runSeeder(s)
+
+            results.push(result)
+
+            // Stop on first failure
+            if (result.result === 'failed') {
+                break
+            }
+        }
+
+        await this.emmitter.emitAndWait('seeder:after-run', {
+            seeders: results.map(m => m.name),
+        })
+
+        return results
+    }
+}
+