@sidekick-coder/zenith-kit 0.3.7 → 0.3.8

package/src/server/services/MigratorService.ts

@@ -0,0 +1,412 @@
+import fs from 'fs'
+import path from 'path'
+import { format } from 'date-fns'
+import { tryCatch } from '#shared/utils/tryCatch.ts'
+import EmmitterService from '#shared/services/EmmitterService.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
+import type { Kysely } from 'kysely'
+import MigrationEntity from '#server/entities/MigrationEntity.ts'
+import { orderBy } from 'lodash-es'
+import { BaseException } from '#shared/index.ts'
+
+export interface MigrationSource {
+    id: string;
+    directory: string;
+}
+
+export interface Migration {
+    name: string;
+    source: string | null;
+    filename: string;
+    executedAt: Date | null;
+}
+
+export interface ListFilters {
+    source?: string;
+    name?: string | string[];
+}
+
+interface MigrationResult {
+    name: string;
+    filename: string;
+    source: string | null;
+    result: 'success' | 'failed';
+    error?: any;
+}
+
+export interface MigratorServiceOptions {
+    sources: MigrationSource[];
+    db: Kysely<any>;
+    debug?: boolean;
+    emmitter?: EmmitterService;
+    logger?: LoggerService
+}
+
+export interface MigratorServiceEvents {
+    'migrator:before-migrate': {
+        migrations: MigrationEntity[]
+    }
+    'migrator:after-migrate': {
+        migrations: MigrationEntity[]
+    }
+    'migrator:before-rollback': {
+        migrations: MigrationEntity[]
+    }
+    'migrator:after-rollback': {
+        migrations: MigrationEntity[]
+    }
+
+}
+
+export default class MigratorService {
+    public static __container_entry_key = 'MigratorService'
+
+    public debug = false
+    public emmitter: EmmitterService
+    public logger: LoggerService
+    public db: Kysely<any>
+    public sources: MigrationSource[]
+
+    constructor(options: MigratorServiceOptions) {
+        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: MigrationSource) {
+        this.sources.push(source)
+    }
+
+    private async ensureMigrationsTable() {
+        await this.db.schema
+            .createTable('migrations')
+            .ifNotExists()
+            .addColumn('name', 'varchar(255)', (col) => col.primaryKey())
+            .addColumn('module', 'varchar(255)') // module will be renamed to source in future versions
+            .addColumn('executed_at', 'timestamp', (col) => col.notNull())
+            .execute()
+    }
+
+    public async listSource(source: MigrationSource) {
+
+        if (!fs.existsSync(source.directory)) {
+            this.logger.warn(`Migration source directory does not exist: ${source.directory}`)
+
+            return []
+        }
+
+        const entries = await fs.promises.readdir(source.directory)
+        const extensions = ['.js', '.ts', '.mjs', '.mts']
+
+        const items: MigrationEntity[] = []
+
+        for (const entry of entries) {
+            if (!extensions.some(ext => entry.endsWith(ext))) continue
+
+            const fullPath = path.join(source.directory, entry)
+            const name = path.basename(entry, path.extname(entry))
+
+            const entity = new MigrationEntity({
+                name,
+                source: source.id,
+                filename: fullPath,
+                executedAt: null,
+            })
+
+            items.push(entity)
+        }
+
+        return items
+    }
+
+    public async list(filters?: ListFilters) {
+        await this.ensureMigrationsTable()
+
+        let items = [] as MigrationEntity[]
+
+        for await (const source of this.sources) {
+            const migrations = await this.listSource(source)
+
+            items.push(...migrations)
+        }
+
+        // Get executed migrations from database
+        const executed = await this.db
+            .selectFrom('migrations')
+            .selectAll()
+            .execute()
+
+        for (const e of executed) {
+            if (!e.source) {
+                e.source = 'root'
+            }
+
+            const m = items.find(m => m.name === e.name)
+
+            if (!m) continue
+
+            m.executedAt = new Date(e.executed_at)
+        }
+
+        if (filters?.source) {
+            items = items.filter(m => m.source === filters.source)
+        }
+
+        if (filters?.name) {
+            const names = Array.isArray(filters.name) ? filters.name : [filters.name]
+
+            items = items.filter(m => names.includes(m.name))
+        }
+
+        items = orderBy(items, ['source', 'name'], ['asc', 'asc'])
+
+        return items
+    }
+
+    private async migrateUp(migration: MigrationEntity): Promise<void> {
+        await migration.up(this.db)
+
+        await this.db
+            .insertInto('migrations')
+            .values({
+                name: migration.name,
+                module: migration.source,
+                executed_at: format(new Date(), 'yyyy-MM-dd HH:mm:ss'),
+            })
+            .execute()
+
+        this.logger.info(`${migration.name} migrated successfully`)
+
+    }
+
+    private async migrateDown(migration: MigrationEntity): Promise<void> {
+        await migration.down(this.db)
+
+        await this.db
+            .deleteFrom('migrations')
+            .where('name', '=', migration.name)
+            .where('module', '=', migration.source)
+            .execute()
+
+        this.logger.info(`${migration.name} rolled back successfully`)
+    }
+
+    private async migrateFile(filename: string): Promise<MigrationResult> {
+        await this.ensureMigrationsTable()
+
+        const migrations = await this.list()
+        const migration = migrations.find(m => m.filename === filename)
+
+        if (!migration) {
+            return {
+                name: path.basename(filename, path.extname(filename)),
+                filename: filename,
+                source: null,
+                result: 'failed',
+                error: new Error(`Migration ${filename} not found`)
+            }
+        }
+
+        if (migration.executedAt) {
+            return {
+                name: migration.name,
+                filename: migration.filename,
+                source: migration.source,
+                result: 'success',
+            }
+        }
+
+        const [error] = await tryCatch(() => this.migrateUp(migration))
+
+        if (error) {
+            return {
+                name: migration.name,
+                filename: migration.filename,
+                source: migration.source,
+                result: 'failed',
+                error
+            }
+        }
+
+        return {
+            name: migration.name,
+            filename: migration.filename,
+            source: migration.source,
+            result: 'success'
+        }
+    }
+
+    private async rollbackFile(filename: string): Promise<MigrationResult> {
+        await this.ensureMigrationsTable()
+
+        const migrations = await this.list()
+        const migration = migrations.find(m => m.filename === filename)
+
+        if (!migration) {
+            return {
+                name: path.basename(filename, path.extname(filename)),
+                filename: filename,
+                source: null,
+                result: 'failed',
+                error: `Migration ${filename} not found`
+            }
+        }
+
+        if (!migration.executedAt) {
+            return {
+                name: migration.name,
+                filename: migration.filename,
+                source: migration.source,
+                result: 'success',
+            }
+        }
+
+        const [error] = await tryCatch(() => this.migrateDown(migration))
+
+        if (error) {
+            return {
+                name: migration.name,
+                filename: migration.filename,
+                source: migration.source,
+                result: 'failed',
+                error
+            }
+        }
+
+        return {
+            name: migration.name,
+            filename: migration.filename,
+            source: migration.source,
+            result: 'success'
+        }
+    }
+
+    public async migrate(filters: ListFilters & { steps?: number } = {}): Promise<MigrationResult[]> {
+        await this.ensureMigrationsTable()
+
+        let migrations = await this.list(filters)
+
+        migrations = migrations.filter(m => !m.executedAt)
+
+        migrations.sort((a, b) => a.name.localeCompare(b.name))
+
+        if (filters.steps !== undefined) {
+            migrations = migrations.slice(0, filters.steps)
+        }
+
+        if (migrations.length === 0) {
+            return []
+        }
+
+        await this.emmitter.emitAndWait('migrator:before-migrate', {
+            migrations: migrations.map(m => m.name)
+        })
+
+        const results: MigrationResult[] = []
+
+        for (const migration of migrations) {
+            const result = await this.migrateFile(migration.filename)
+
+            results.push(result)
+
+            // Stop on first failure
+            if (result.result === 'failed') {
+                break
+            }
+        }
+
+        await this.emmitter.emitAndWait('migrator:after-migrate', {
+            migrations: migrations,
+            results
+        })
+
+        return results
+    }
+
+    public async rollback(filters: ListFilters & { steps?: number } = {}): Promise<MigrationResult[]> {
+        await this.ensureMigrationsTable()
+
+        let migrations = await this.list(filters)
+
+        migrations = migrations.filter(m => m.executedAt)
+
+        migrations.sort((a, b) => b.name.localeCompare(a.name))
+
+        if (filters.steps !== undefined) {
+            migrations = migrations.slice(0, filters.steps)
+        }
+
+        if (migrations.length === 0) {
+            return []
+        }
+
+        await this.emmitter.emitAndWait('migrator:before-rollback', {
+            migrations: migrations.map(m => m.name)
+        })
+
+        const results: MigrationResult[] = []
+
+        for (const migration of migrations) {
+            const result = await this.rollbackFile(migration.filename)
+
+            results.push(result)
+
+            // Stop on first failure
+            if (result.result === 'failed') {
+                break
+            }
+        }
+
+        await this.emmitter.emitAndWait('migrator:after-rollback', {
+            migrations: migrations.map(m => m.name)
+        })
+
+        return results
+    }
+
+    public async up(steps: number = 1, filters: ListFilters = {}): Promise<MigrationResult[]> {
+        return this.migrate({
+            ...filters,
+            steps
+        })
+    }
+
+    public async down(steps: number = 1, filters: ListFilters = {}): Promise<MigrationResult[]> {
+        return this.rollback({
+            ...filters,
+            steps
+        })
+    }
+
+    public async latest(filters: ListFilters = {}): Promise<MigrationResult[]> {
+        return this.migrate(filters)
+    }
+
+    public async latestOrFail(filters: ListFilters = {}): Promise<MigrationResult[]> {
+        const results = await this.latest(filters)
+
+        const failed = results.find(r => r.result === 'failed')
+
+        if (failed) {
+            throw failed.error || new BaseException(`Migration failed: ${failed.name}`)
+        }
+
+        return results
+    }
+
+    public async fresh(filters: ListFilters & { steps?: number } = {}): Promise<MigrationResult[]> {
+        const downResults = await this.rollback(filters)
+
+        if (downResults.some(r => r.result === 'failed')) {
+            return downResults
+        }
+
+        const upResults = await this.migrate(filters)
+
+        return upResults
+    }
+
+}
+

package/src/server/services/PluginIpcClient.ts

@@ -0,0 +1,49 @@
+import { createId } from '../../shared/utils/createId.ts'
+
+export type IpcMessage<T = any> = {
+    id: string
+    event: string
+    data: T
+}
+
+type IpcListener<T = any> = (data: T) => void
+
+export class PluginIpcClient {
+    private listeners = new Map<string, Set<IpcListener>>()
+    constructor() {
+        process.on('message', (message: IpcMessage) => {
+            const handlers = this.listeners.get(message.event)
+            if (!handlers) return
+
+            for (const handler of handlers) {
+                handler(message.data)
+            }
+        })
+    }
+
+    public on<T = any>(event: string, callback: IpcListener<T>): void {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set())
+        }
+
+        this.listeners.get(event)!.add(callback as IpcListener)
+    }
+
+    public off<T = any>(event: string, callback: IpcListener<T>): void {
+        this.listeners.get(event)?.delete(callback as IpcListener)
+    }
+
+    public emit<T = any>(event: string, data?: T): string {
+        if (!process.send) {
+            throw new Error('PluginIpcClient.emit: process.send is not available — process was not spawned with IPC channel')
+        }
+
+        const id = createId()
+        const message: IpcMessage<T> = { id, event, data: data as T }
+        process.send(message)
+
+        return id
+    }
+
+}
+

package/src/server/services/PluginIpcHost.ts

@@ -0,0 +1,44 @@
+import type { ChildProcess } from 'node:child_process'
+import { createId } from '../../shared/utils/createId.ts'
+import type { IpcMessage } from './PluginIpcClient.ts'
+
+type IpcListener<T = any> = (data: T) => void
+
+export class PluginIpcHost {
+    private listeners = new Map<string, Set<IpcListener>>()
+    constructor(private readonly child: ChildProcess) {
+        this.child.on('message', (message: IpcMessage) => {
+            const handlers = this.listeners.get(message.event)
+            if (!handlers) return
+
+            for (const handler of handlers) {
+                handler(message.data)
+            }
+        })
+    }
+
+    public on<T = any>(event: string, callback: IpcListener<T>): void {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set())
+        }
+
+        this.listeners.get(event)!.add(callback as IpcListener)
+    }
+
+    public off<T = any>(event: string, callback: IpcListener<T>): void {
+        this.listeners.get(event)?.delete(callback as IpcListener)
+    }
+
+    public emit<T = any>(event: string, data?: T): string {
+        if (!this.child.send) {
+            throw new Error('PluginIpcHost.emit: child process was not spawned with an IPC channel')
+        }
+
+        const id = createId()
+        const message: IpcMessage<T> = { id, event, data: data as T }
+        this.child.send(message)
+
+        return id
+    }
+
+}

package/src/server/services/PluginRouter.ts

@@ -0,0 +1,128 @@
+import { PluginIpcClient } from './PluginIpcClient.ts'
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
+
+export interface RouteDefinition {
+    method: HttpMethod
+    path: string
+}
+
+export interface RouteRequest {
+    requestId: string
+    method: HttpMethod
+    path: string
+    body?: any
+    headers?: Record<string, string>
+    query?: Record<string, string>
+    params?: Record<string, string>
+}
+
+export interface RouteResponsePayload {
+    requestId: string
+    status: number
+    body?: any
+    headers?: Record<string, string>
+}
+
+export interface RouteReply {
+    status(code: number): RouteReply
+    send(body?: any): void
+}
+
+export type RouteHandler = (req: RouteRequest, reply: RouteReply) => void | Promise<void>
+
+interface RouteEntry extends RouteDefinition {
+    handler: RouteHandler
+    pattern: RegExp
+    paramNames: string[]
+}
+
+function buildPattern(path: string): { pattern: RegExp; paramNames: string[] } {
+    const paramNames: string[] = []
+
+    const regexStr = path
+        .replace(/:[a-zA-Z_][a-zA-Z0-9_]*/g, (match) => {
+            paramNames.push(match.slice(1))
+            return '([^/]+)'
+        })
+        .replace(/\//g, '\\/')
+
+    return { pattern: new RegExp(`^${regexStr}$`), paramNames }
+}
+
+export class PluginRouter {
+    private routes: RouteEntry[] = []
+
+    constructor(private readonly client: PluginIpcClient) {
+        this.client.on<RouteRequest>('router:request', (req) => this.dispatch(req))
+    }
+
+    private async dispatch(req: RouteRequest): Promise<void> {
+        for (const route of this.routes) {
+            if (route.method !== req.method) continue
+
+            const match = route.pattern.exec(req.path)
+            if (!match) continue
+
+            const params: Record<string, string> = {}
+            route.paramNames.forEach((name, i) => {
+                params[name] = match[i + 1]
+            })
+
+            let statusCode = 200
+            const headers: Record<string, string> = {}
+
+            const reply: RouteReply = {
+                status(code) {
+                    statusCode = code
+                    return this
+                },
+                send: (body?: any) => {
+                    const response: RouteResponsePayload = {
+                        requestId: req.requestId,
+                        status: statusCode,
+                        body,
+                        headers,
+                    }
+                    this.client.emit('router:response', response)
+                },
+            }
+
+            await route.handler({ ...req, params }, reply)
+            return
+        }
+
+        this.client.emit('router:response', {
+            requestId: req.requestId,
+            status: 404,
+            body: { message: 'Not Found' },
+        } satisfies RouteResponsePayload)
+    }
+
+    private register(method: HttpMethod, path: string, handler: RouteHandler): void {
+        const { pattern, paramNames } = buildPattern(path)
+
+        this.routes.push({ method, path, handler, pattern, paramNames })
+        this.client.emit('router:register', { method, path } satisfies RouteDefinition)
+    }
+
+    public get(path: string, handler: RouteHandler): void {
+        this.register('GET', path, handler)
+    }
+
+    public post(path: string, handler: RouteHandler): void {
+        this.register('POST', path, handler)
+    }
+
+    public put(path: string, handler: RouteHandler): void {
+        this.register('PUT', path, handler)
+    }
+
+    public patch(path: string, handler: RouteHandler): void {
+        this.register('PATCH', path, handler)
+    }
+
+    public delete(path: string, handler: RouteHandler): void {
+        this.register('DELETE', path, handler)
+    }
+}