@sidekick-coder/zenith-kit 0.3.7 → 0.3.9

package/src/server/entities/MigrationEntity.ts

@@ -0,0 +1,44 @@
+import { BaseException } from "#shared/index.ts";
+import type { Kysely } from "kysely";
+
+export interface MigrationEntiyData {
+    name: string;
+    source: string | null;
+    filename: string;
+    executedAt: Date | null;
+}
+
+export default class MigrationEntity {
+    public name: string
+    public source: string | null
+    public filename: string
+    public executedAt: Date | null
+
+    constructor(data: MigrationEntiyData) {
+        this.name = data.name
+        this.source = data.source
+        this.filename = data.filename
+        this.executedAt = data.executedAt
+    }
+
+    public async up(db: Kysely<any>): Promise<void> {
+        const mod = await import(this.filename)
+
+        if (typeof mod.up !== 'function') {
+            throw new BaseException(`Migration ${this.name} does not export an up function`)
+        }
+
+        await mod.up(db)
+    }
+
+    public async down(db: Kysely<any>): Promise<void> {
+        const mod = await import(this.filename)
+
+        if (typeof mod.down !== 'function') {
+            throw new BaseException(`Migration ${this.name} does not export a down function`)
+        }
+
+        await mod.down(db)
+    }
+}
+

package/src/server/entities/ModuleEntity.ts

@@ -0,0 +1,89 @@
+import fs from 'fs'
+import { join } from 'path'
+import { GitGateway } from '#server/gateways/GitGateway.ts'
+import { tmpPath } from '#server/utils/basePath.ts'
+import Base from '#shared/entities/ModuleEntity.ts'
+import { composeWith } from '#shared/utils/compose.ts'
+import shell from '#server/facades/shell.ts'
+import config from '#server/facades/config.ts'
+import logger from '#server/facades/logger.ts'
+
+export default class Module extends composeWith(Base) {
+    public get git(){
+        return new GitGateway({
+            cwd: this.directory,
+            sshKey: config.get(`modules.${this.id}.ssh_key`),
+            sshKeyTmpFileName: tmpPath(`ssh_key_${this.id}.pem`),
+            logger: logger.child({ label: 'git' }),
+            debug: config.get('git.debug', false),
+        })
+    }
+
+    public makePath(...parts: string[]) {
+        return join(this.directory, ...parts)
+    }
+
+    public staticPath(...parts: string[]) {
+        return join('/static', 'modules', this.id, ...parts)
+    }
+
+    public command: typeof shell.command = (bin, args, options) => {
+        return shell.command(bin, args, {
+            cwd: this.directory,
+            ...options,
+        })
+    }
+
+    public load(){
+        const manifestPath = this.makePath('module.json')
+
+        if (!fs.existsSync(manifestPath)) {
+            return
+        }
+
+        const content = fs.readFileSync(manifestPath, 'utf-8')
+        const json = JSON.parse(content)
+
+        this.dependencies = json.dependencies || {}
+        this.build = json.build || {}      
+    }
+
+    public findClientEntrypointFilename(context: 'dev' | 'node' | 'browser' = 'dev'): string | null {
+        const candidates = [] as string[]
+
+        if (context === 'dev') {
+            candidates.push(
+                this.makePath('client', 'module.client.ts'),
+                this.makePath('client', 'module.client.js'),
+                this.makePath('client', 'client.ts'),
+                this.makePath('client', 'client.js'),
+            )
+        }
+
+        if (context === 'node') {
+            candidates.push(
+                this.makePath('client-dist/node', 'index.js'),
+                this.makePath('client-dist/node', 'index.mjs'),
+                this.makePath('client-dist/node', 'module.client.js'),
+                this.makePath('client-dist/node', 'module.client.mjs'),
+            )
+        }
+
+        if (context === 'browser') {
+            candidates.push(
+                this.makePath('client-dist/browser', 'index.js'),
+                this.makePath('client-dist/browser', 'index.mjs'),
+                this.makePath('client-dist/browser', 'module.client.js'),
+                this.makePath('client-dist/browser', 'module.client.mjs'),
+            )
+        }
+        
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate
+            }
+        }
+
+        return null
+    }
+}

package/src/server/entities/PageRequestContextEntity.ts

@@ -0,0 +1,95 @@
+import CookieMapEntity from "#server/entities/CookieMapEntity.ts"
+import ContainerService from "#shared/services/ContainerService.ts"
+import type { Request, Response } from 'express'
+import type { ResolvableHead } from '@unhead/vue'
+import ConfigService from "#shared/services/ConfigService.ts"
+
+export interface PageRequestContextEntityOptions {
+    url: string;
+    request: Request;
+    response: Response;
+
+    state?: Map<string, any>
+
+    nodeContainer?: ContainerService
+    nodeConfig?: ConfigService
+    nodeState?: Map<string, any>
+
+    browserContainer?: ContainerService
+    browserConfig?: ConfigService
+    browserState?: Map<string, any>
+}
+
+export default class PageRequestContextEntity {
+    public url: string;
+    public request: Request;
+    public response: Response;
+    public cookies: CookieMapEntity
+    public head: ResolvableHead[]
+
+    public nodeContainer: ContainerService
+    public nodeConfig: ConfigService
+    public nodeState: Map<string, any>
+
+    public browserContainer: ContainerService
+    public browserConfig: ConfigService
+    public browserState: Map<string, any>
+
+
+    constructor(data: PageRequestContextEntityOptions) {
+        this.url = data.url
+        this.request = data.request
+        this.response = data.response
+        this.cookies = new CookieMapEntity(this.request, this.response)
+
+        this.head = []
+
+        this.nodeContainer = data.nodeContainer || new ContainerService()
+        this.nodeConfig = data.nodeConfig || new ConfigService()
+        this.nodeState = data.nodeState || new Map<string, any>()
+
+        this.browserConfig = data.browserConfig || new ConfigService()
+        this.browserContainer = data.browserContainer || new ContainerService()
+        this.browserState = data.browserState || new Map<string, any>()
+    }
+
+    public setBrowserState(key: string, value: any) {
+        this.browserState.set(key, value)
+    }
+
+    public setNodeState(key: string, value: any) {
+        this.nodeState.set(key, value)
+    }
+
+    public setState(key: string, value: any) {
+        this.setNodeState(key, value)
+        this.setBrowserState(key, value)
+    }
+
+    public setBrowserContainerValue(key: string, value: any) {
+        this.browserContainer.set(key, value)
+    }
+
+    public setNodeContainerValue(key: string, value: any) {
+        this.nodeContainer.set(key, value)
+    }
+
+    public setContainerValue(key: string, value: any) {
+        this.setNodeContainerValue(key, value)
+        this.setBrowserContainerValue(key, value)
+    }
+
+    public setBrowserConfigValue(key: string, value: any) {
+        this.browserConfig.set(key, value)
+    }
+
+    public setNodeConfigValue(key: string, value: any) {
+        this.nodeConfig.set(key, value)
+    }
+
+    public setConfigValue(key: string, value: any) {
+        this.setNodeConfigValue(key, value)
+        this.setBrowserConfigValue(key, value)
+    }
+
+}

package/src/server/entities/PluginEntity.ts

@@ -0,0 +1,85 @@
+import { join } from 'path'
+import RouterFileBaseRoutingService from '#server/services/RouterFileBaseRoutingService.ts'
+import PluginEntryEntity from './PluginEntryEntity.ts'
+import emmitter from '#server/facades/emmitter.ts'
+import type { RouterEvents } from '#server/services/RouterService.ts'
+import type RouterRegister from '#server/services/RouterRegisterService.ts'
+
+interface AddApiFolderOptions {
+    prefix?: string
+}
+
+export default class PluginEntity extends PluginEntryEntity {
+    public apiFolders = new Map<string, AddApiFolderOptions>()
+    public apiDirectories = new Set<string>()
+
+    constructor() {
+        super()
+
+        emmitter.on('router:registered', this.onRouterRegistered.bind(this))
+    }
+
+    public staticPath(...parts: string[]) {
+        return join('/static', 'modules', this.id, ...parts)
+    }
+
+    public async load() {
+        // This method can be used to load additional data from the plugin's directory if needed
+    }
+
+    public async onRouterRegistered(ctx: RouterEvents['router:registered']) {
+        const router = ctx.router as RouterRegister
+
+        for (const [directory, options] of this.apiFolders) {
+            const prefix = options.prefix || `/api/`
+
+            await RouterFileBaseRoutingService
+                .create(directory)
+                .setPrefix(prefix)
+                .setRouter(router)
+                .setModule(this.id)
+                .load()
+        }
+
+        for (const apiDir of this.apiDirectories) {
+            router.addDir(apiDir, {
+                module: this.id,
+            })
+        }
+    }
+
+    public addApiFolder(directory: string, options: AddApiFolderOptions = {}) {
+        this.apiFolders.set(directory, options)
+    }
+
+    public addRouterFolder(directory: string) {
+        this.apiDirectories.add(directory)
+    }
+
+    public static fromPluginDiscoverEntity<T>(this: new () => T, entity: PluginEntryEntity): T {
+        const contructor = (typeof this === 'function' ? this : PluginEntity) as any
+
+        const instance = new contructor() as any
+
+        let payload = {
+            id: entity.id,
+            name: entity.name,
+            version: entity.version,
+            directory: entity.directory,
+        }
+
+        if (typeof contructor?.parse === 'function') {
+            payload = (contructor as any).parse(entity)
+        }
+
+        if (typeof (this as any)?.parse === 'function') {
+            payload = (this as any).parse(entity)
+        }
+
+        Object.assign(instance as any, payload)
+
+        return instance
+    }
+
+
+}

package/src/server/entities/PluginEntryEntity.ts

@@ -0,0 +1,48 @@
+import config from '#server/facades/config.ts'
+import container from '#server/facades/container.ts'
+import { GitGateway } from '#server/gateways/GitGateway.ts'
+import GitBranchRepository from '#server/repositories/GitBranchRepository.ts'
+import GitCommitRepository from '#server/repositories/GitCommitRepository.ts'
+import ShellService from '#server/services/ShellService.ts'
+import Base from '#shared/entities/PluginEntity.ts'
+import { composeWith } from '#shared/utils/compose.ts'
+import { join } from 'node:path'
+
+export default class PluginEntryEntity extends composeWith(Base) {
+    public directory: string
+
+    public makePath(...parts: string[]) {
+        return join(this.directory, ...parts)
+    }
+
+    public set: typeof config.set = (key, value, source) => {
+        config.set(`plugins.registry.${this.id}.${key}`, value, source)
+    }
+
+    public get: typeof config.get = (key, defaultValue) => {
+        return config.get(`plugins.registry.${this.id}.${key}`, defaultValue)
+    }
+
+    public get git(){
+        return new GitGateway({
+            cwd: this.directory,
+            shell: container.has(ShellService) ? container.get(ShellService) : undefined,
+            sshKey: config.get(`plugins.registry.${this.id}.ssh_key`),
+            sshKeyFile: config.get(`plugins.registry.${this.id}.ssh_key_file`)
+        })
+    }
+
+    public get commits() {
+        return new GitCommitRepository({
+            cwd: this.directory,
+            shell: container.has(ShellService) ? container.get(ShellService) : undefined
+        })
+    }
+
+    public get branches() {
+        return new GitBranchRepository({
+            cwd: this.directory,
+            shell: container.has(ShellService) ? container.get(ShellService) : undefined
+        })
+    }
+}

package/src/server/entities/RouteEntity.ts

@@ -0,0 +1,75 @@
+import qs from 'qs'
+import type { Handler,  Middleware } from '#server/contracts/RouterContract.ts'
+
+type RouteMethod = 'get' 
+    | 'GET' 
+    | 'post' 
+    | 'POST' 
+    | 'put' 
+    | 'PUT' 
+    | 'patch' 
+    | 'PATCH' 
+    | 'delete' 
+    | 'DELETE'
+
+export default class Route {
+    public path: string = ''
+    public method: RouteMethod = 'get'
+    public handler: Handler<any> | null = null
+    public middlewares: Middleware[] = []
+    public metadata: Record<string, any> | null = {}
+
+    constructor(data: Partial<Route> = {}) {
+        this.path = data.path || ''
+        this.method = data.method || 'get'
+        this.handler = data.handler || null
+        this.middlewares = data.middlewares || []
+        this.metadata = data.metadata || {}
+    }
+
+    public static params(routePath: string, requestPath: string): Record<string, string> {
+        const params: Record<string, string> = {}
+
+        const routeSegments = routePath.split('/').filter(Boolean)
+        const requestSegments = requestPath.split('/').filter(Boolean)
+
+        for (let i = 0; i < routeSegments.length; i++) {
+            const routeSegment = routeSegments[i]
+            const requestSegment = requestSegments[i]
+
+            if (routeSegment.startsWith(':')) {
+                const paramName = routeSegment.slice(1) // Remove the ':' prefix
+                params[paramName] = requestSegment
+            }
+            
+            if (routeSegment === '*') {
+                // Capture all remaining segments as a single path
+                const remainingSegments = requestSegments.slice(i)
+                params['*'] = remainingSegments.join('/')
+                break
+            }
+        }
+
+        return params
+    }
+
+    public static query(requestPath: string): Record<string, string> {
+        const query: Record<string, string> = {}
+        const queryString = requestPath.split('?')[1]
+
+        if (!queryString) {
+            return query
+        }
+
+        return qs.parse(queryString)
+    }
+
+    public toJSON() {
+        return {
+            path: this.path,
+            method: this.method,
+            middlewares: this.middlewares.map(mw => mw.constructor.name),
+            metadata: this.metadata
+        }
+    }
+}

package/src/server/entities/RoutineEntity.ts

@@ -0,0 +1,43 @@
+import { Job } from 'node-schedule'
+
+export interface RoutineHandler {
+    (): void | Promise<void>
+}
+
+export interface RoutineEntityOptions {
+    id: string
+    cron: string
+    handler?: RoutineHandler
+}
+
+export default class RoutineEntity {
+    public id: string
+    public cron: string
+    public job?: Job
+
+    public static create(){
+        return new RoutineEntity()
+    }
+
+    public handle: RoutineHandler = () => {
+        throw new Error('RoutineEntity handler not implemented')
+    }
+
+    public setId(id: string) {
+        this.id = id
+
+        return this
+    }
+
+    public setCron(cron: string) {
+        this.cron = cron
+
+        return this
+    }
+
+    public setHandler(handler: RoutineHandler) {
+        this.handle = handler
+
+        return this
+    }
+}

package/src/server/entities/SeederEntity.ts

@@ -0,0 +1,32 @@
+import { BaseException } from "#shared/index.ts";
+import type { Kysely } from "kysely";
+
+export interface SeederEntiyData {
+    name: string;
+    source: string | null;
+    filename: string;
+}
+
+export default class SeederEntity {
+    public name: string
+    public source: string | null
+    public filename: string
+
+    constructor(data: SeederEntiyData) {
+        this.name = data.name
+        this.source = data.source
+        this.filename = data.filename
+    }
+
+    public async run(db: Kysely<any>): Promise<void> {
+        const mod = await import(this.filename)
+
+        if (typeof mod.default !== 'function') {
+            throw new BaseException(`Seeder ${this.name} does not export a function`)
+        }
+
+        await mod.default(db)
+    }
+
+}
+

package/src/server/facades/config.ts

@@ -0,0 +1,6 @@
+import ConfigService from '#shared/services/ConfigService.ts'
+import container from './container'
+
+const config = container.proxy<ConfigService>(ConfigService)
+
+export default config

package/src/server/facades/container.ts

@@ -0,0 +1,7 @@
+import ContainerService from "#shared/services/ContainerService.ts";
+
+const container = (globalThis as any).serverContainer || new ContainerService()
+
+globalThis.serverContainer = container
+
+export default container as ContainerService

package/src/server/facades/database.ts

@@ -0,0 +1,8 @@
+import container from './container'
+import type { DatabaseContract } from '#server/contracts/DatabaseContract.ts'
+import DatabaseGateway from '#server/gateways/DatabaseGateway.ts'
+
+const database = container.proxy<DatabaseGateway<DatabaseContract>>(DatabaseGateway)
+
+export default database
+

package/src/server/facades/download.ts

@@ -0,0 +1,6 @@
+import DownloadService from '#server/services/DownloadService.ts'
+
+const download = new DownloadService()
+
+export default download
+

package/src/server/facades/drive.ts

@@ -0,0 +1,7 @@
+import DriveService from '#server/services/DriveService.ts'
+import container from './container.ts'
+
+const drive = container.proxy<DriveService>(DriveService)
+
+export default drive
+

package/src/server/facades/emmitter.ts

@@ -0,0 +1,7 @@
+import container from './container'
+import { EmmitterService } from '#shared/index.ts'
+
+const emmitter = container.proxy<EmmitterService>(EmmitterService)
+
+export default emmitter
+

package/src/server/facades/encrypt.ts

@@ -0,0 +1,7 @@
+import EncryptService from '#server/services/EncryptService.ts'
+import container from './container.ts'
+
+const encrypt = container.proxy<EncryptService>(EncryptService)
+
+export default encrypt
+

package/src/server/facades/env.ts

@@ -0,0 +1,7 @@
+import EnvService from "#server/services/EnvService.ts"
+import container from "./container"
+
+const env = container.proxy<EnvService>(EnvService)
+
+export default env
+

package/src/server/facades/filesRepository.ts

@@ -0,0 +1,6 @@
+import FileRepository from "#server/repositories/FileRepository.ts";
+import database from "./database.ts";
+
+const fileRepository = new FileRepository(database)
+
+export default fileRepository

package/src/server/facades/hasher.ts

@@ -0,0 +1,8 @@
+
+import HasherService from '#server/services/HasherService.ts'
+import container from './container.ts'
+
+const hasher = container.proxy<HasherService>(HasherService)
+
+export default hasher
+

package/src/server/facades/http.ts

@@ -0,0 +1,6 @@
+import HttpService from "#server/services/HttpService.ts";
+import container from "./container";
+
+const http = container.proxy<HttpService>(HttpService)
+
+export default http

package/src/server/facades/logger.ts

@@ -0,0 +1,6 @@
+import LoggerService from '#shared/services/LoggerService.ts'
+import container from './container'
+
+const logger = container.proxy<LoggerService>(LoggerService)
+
+export default logger

package/src/server/facades/migrator.ts

@@ -0,0 +1,6 @@
+import MigratorService from '#server/services/MigratorService.ts'
+import container from './container'
+
+const migrator = container.proxy<MigratorService>(MigratorService)
+
+export default migrator

package/src/server/facades/permissionAssignmentRepository.ts

@@ -0,0 +1,6 @@
+import PermissionAssignmentRepository from '#server/repositories/PermissionAssignmentRepository.ts'
+import db from '#server/facades/database.ts'
+
+const permissionAssignmentRepository = new PermissionAssignmentRepository(db as any)
+
+export default permissionAssignmentRepository

package/src/server/facades/permissionRepository.ts

@@ -0,0 +1,6 @@
+import PermissionRepository from '#server/repositories/PermissionRepository.ts'
+import db from '#server/facades/database.ts'
+
+const permissionRepository = new PermissionRepository(db as any)
+
+export default permissionRepository

package/src/server/facades/router.ts

@@ -0,0 +1,7 @@
+import type { HttpContext } from '#server/contracts/HttpContextContract.ts'
+import RouterService from '#server/services/RouterService.ts'
+import container from '#server/facades/container.ts'
+
+const router = container.proxy<RouterService<HttpContext>>(RouterService)
+
+export default router

package/src/server/facades/scheduler.ts

@@ -0,0 +1,6 @@
+import container from '#server/facades/container.ts'
+import SchedulerService from '#server/services/SchedulerService.ts'
+
+const scheduler = container.proxy<SchedulerService>(SchedulerService)
+
+export default scheduler

package/src/server/facades/shell.ts

@@ -0,0 +1,6 @@
+import ShellService from '#server/services/ShellService.ts'
+import container from './container'
+
+const shell = container.proxy<ShellService>(ShellService)
+
+export default shell

package/src/server/facades/tokenRepository.ts

@@ -0,0 +1,7 @@
+import db from '#server/facades/database.ts'
+import TokenRepository from '#server/repositories/TokenRepository.ts'
+
+const tokenRepository = new TokenRepository(db as any)
+
+export default tokenRepository
+