@sidekick-coder/zenith-kit 0.3.7 → 0.3.8

package/src/server/services/HttpService.ts

@@ -0,0 +1,186 @@
+import type { Server } from 'http'
+import express from 'express'
+import cors from 'cors'
+import cookieParser from 'cookie-parser'
+import Router from './RouterService.ts'
+import ExceptionService from './ExceptionService.ts'
+import Route from '#server/entities/RouteEntity.ts'
+import { tryCatch } from '#shared/utils/tryCatch.ts'
+import { EmmitterService, LoggerService } from '#shared/index.ts'
+import type { HttpContext } from '#server/contracts/HttpContextContract.ts'
+import CookieMapEntity from '#server/entities/CookieMapEntity.ts'
+import EnvService from './EnvService.ts'
+
+export interface HttpServiceOptions {
+    debug?: boolean;
+    router?: Router;
+    logger?: LoggerService;
+    exception?: ExceptionService;
+    emmitter?: EmmitterService;
+    env?: EnvService;
+    origins?: string[];
+}
+
+export default class HttpService {
+    public static __container_entry_key = 'HttpService'
+
+    public app: express.Application
+    public server: Server | null = null
+    public router: Router
+    public exception: ExceptionService
+    public logger: LoggerService
+    public emmitter: EmmitterService
+    public env: EnvService
+    public debug = false
+    public onUnhandlerRouted: ((req: express.Request, res: express.Response) => void) | null = null
+
+    constructor(options: HttpServiceOptions) {
+        this.debug = options.debug || false
+        this.logger = options.logger || new LoggerService()
+        this.router = options.router || new Router()
+        this.emmitter = options.emmitter || new EmmitterService()
+        this.env = options.env || new EnvService()
+        this.exception = options.exception || new ExceptionService({ logger: this.logger, env: this.env })
+
+        this.app = express()
+        this.app.use(cookieParser())
+        this.app.use(this.parser)
+    }
+
+    public getExpressApp(): express.Application {
+        return this.app
+    }
+
+    public cors(options: cors.CorsOptions) {
+        this.app.use(cors(options))
+    }
+
+    public use: express.Application['use'] = (...args: any[]) => {
+        this.app.use(...args)
+
+        return this.app
+    }
+
+    public routes() {
+        this.app.use('*all', (req, res) => {
+            const url = new URL(req.originalUrl, `http://${req.headers.host}`)
+            const method = req.method.toLowerCase()
+
+            const route = this.router.resolve(method, url.pathname)
+
+            if (this.router.debug) {
+                this.router.logger.debug(`${method.toUpperCase()} ${url.pathname}`)
+            }
+
+            if (route) {
+
+                return this.execute(url, req, res, route)
+            }
+
+            if (url.pathname.startsWith('/api/')) {
+                return res.status(404).json({
+                    error: 'Not Found',
+                    message: `No API route found for ${method.toUpperCase()} ${url}`,
+                })
+            }
+
+            if (this.onUnhandlerRouted) {
+                return this.onUnhandlerRouted(req, res)
+            }
+        })
+    }
+
+    public parser(req: express.Request, res: express.Response, next: express.NextFunction) {
+        const contentType = req.headers['content-type'] || ''
+
+        if (contentType.startsWith('multipart/form-data')) {
+            // Skip JSON and URL-encoded parsers for multipart requests
+            return next()
+        }
+
+        // For other content types, parse JSON and URL-encoded body
+        express.json()(req, res, (err) => {
+            if (err) return next(err)
+
+            express.urlencoded({ extended: true })(req, res, next)
+        })
+    }
+
+    public async execute(url: URL, request: express.Request, response: express.Response, route: Route) {
+        const ctx: Omit<HttpContext, 'acl'> = {
+            response,
+            request,
+
+            url: url.pathname,
+            method: request.method.toLowerCase(),
+            params: Route.params(route.path, url.pathname),
+            query: Route.query(url.href),
+            body: request.body || {},
+
+            cookie: new CookieMapEntity(request, response)
+        }
+
+        const [error, result] = await tryCatch(() => this.router.execute(route, ctx))
+
+        if (error) {
+            this.exception.handle(error, response)
+            return
+        }
+
+        if (response.headersSent) {
+            return // if headers are already sent, do not modify the response
+        }
+
+        if (result && result.redirect) {
+            response.redirect(result.redirect)
+            return
+        }
+
+        // headers not set 
+        response.status(200)
+
+        if (typeof result === 'object' || Array.isArray(result)) {
+            response.setHeader('Content-Type', 'application/json')
+        }
+
+        response.send(result)
+    }
+
+    public start() {
+        const port = this.env.get('ZENITH_PORT')
+        const host = this.env.get('ZENITH_HOST')
+
+        const url = `http://${host}:${port}`
+
+        this.server = this.app.listen(port, host, () => {
+            this.logger.info('server started', {
+                url,
+                env: this.env.get('NODE_ENV'),
+            })
+
+            this.emmitter.emit('http:started')
+        })
+    }
+
+    public stop() {
+        return new Promise<void>((resolve) => {
+            if (!this.server) {
+                this.logger.warn('server is not running')
+                return resolve()
+            }
+
+            this.server.on('close', () => {
+                resolve()
+
+                this.logger.info('server stopped', {
+                    pid: process.pid,
+                    env: this.env.get('NODE_ENV'),
+                })
+            })
+
+            this.server.close()
+
+        })
+    }
+}
+

package/src/server/services/HttpTesterService.ts

@@ -0,0 +1,62 @@
+import tokenRepository from "#server/facades/tokenRepository.ts"
+import userRepository from "#server/facades/userRepository.ts"
+import { BaseException, UserEntity } from "#shared/index.ts"
+import type HttpService from "./HttpService"
+import supertest, { type Test } from 'supertest'
+
+export interface HttpTesterServiceOptions {
+    http: HttpService
+}
+
+export default class HttpTesterService {
+    public static __container_entry_key = 'HttpTesterService'
+    public http: HttpService
+    public request: supertest.SuperTest<supertest.Test>
+    public headers: Record<string, string> = {}
+    public cookies: Record<string, string> = {}
+
+    constructor(options: HttpTesterServiceOptions) {
+        this.http = options.http
+        this.request = supertest(this.http.getExpressApp())
+    }
+
+
+    public create(request: Test) {
+        for (const [key, value] of Object.entries(this.headers)) {
+            request.set(key, value)
+        }
+
+        for (const [key, value] of Object.entries(this.cookies)) {
+            request.set('Cookie', `${key}=${value}`)
+        }
+
+        return request
+
+    }
+
+    public get(url: string): Test {
+        return this.create(this.request.get(url))
+    }
+
+    public post(url: string, body?: any): Test {
+        return this.create(this.request.post(url).send(body))
+    }
+
+    public async loginByUser(user: UserEntity) {
+        const token = await tokenRepository.generate({
+            user_id: user.id,
+        })
+
+        this.cookies['Authorization'] = token.token
+    }
+
+    public async loginByUsername(username: string) {
+        const user = await userRepository.findOne({ username })
+
+        if (!user) {
+            throw new BaseException('User not found')
+        }
+
+        return this.loginByUser(user)
+    }
+}

package/src/server/services/LifecycleService.ts

@@ -0,0 +1,21 @@
+import { importAll } from '#server/utils/importAll.ts';
+import LifecycleHook from '#shared/entities/LifecycleHook.ts';
+import BaseLifecycleService from '#shared/services/LifecycleService.ts';
+
+export default class LifecycleService extends BaseLifecycleService {
+    public async addDirectory(dirname: string) {
+        const mods = await importAll(dirname)
+        const hooks: LifecycleHook[] = []
+
+        for (const [name, mod] of Object.entries(mods)) {
+            const HookClass = mod.default || mod
+            const instance = new HookClass() as LifecycleHook
+
+            instance.hook_id = instance.hook_id || name
+
+            hooks.push(instance)
+        }
+
+        hooks.forEach(hook => this.add(hook))
+    }
+}

package/src/server/services/MetadataQueryService.ts

@@ -0,0 +1,192 @@
+import type { ExpressionBuilder } from 'kysely'
+import type { DatabaseContract as Database } from '#server/contracts/DatabaseContract.ts'
+
+export interface Metadafilter {
+    eq?: string,
+    neq?: string,
+    
+    like?: string,
+    nlike?: string,
+
+    in?: string[],
+    nin?: string[],
+
+    gt?: string,
+    gte?: string,
+    lt?: string,
+    lte?: string,
+
+    is_null?: boolean
+    exists?: boolean
+}
+
+export interface MetadataQueryPayload {
+    [key: string]: string | Metadafilter
+}
+
+export default class MetadataQueryService<T extends keyof Database> {
+    private payload: MetadataQueryPayload
+    private table: T
+    private foreignKey: keyof Database[T]
+    private parentKey = 'id'
+
+    constructor(payload: MetadataQueryPayload, table: T, foreignKey: keyof Database[T], parentKey?: string) {
+        this.payload = payload
+        this.table = table
+        this.foreignKey = foreignKey
+
+        if (parentKey) {
+            this.parentKey = parentKey
+        }
+    }
+
+    public get needWhereIn(){
+        for (const condition of Object.values(this.payload)) {
+            if (typeof condition === 'string') {
+                return true
+            }
+
+            if (
+                condition.eq !== undefined
+                || condition.neq !== undefined
+                || condition.like !== undefined
+                || condition.nlike !== undefined
+                || condition.in !== undefined
+                || condition.nin !== undefined
+                || condition.gt !== undefined
+                || condition.gte !== undefined
+                || condition.lt !== undefined
+                || condition.lte !== undefined
+                || condition.is_null !== undefined
+                || condition.exists === true
+            ) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    public get needWhereNotIn(){
+        for (const condition of Object.values(this.payload)) {
+            if (typeof condition === 'string') continue
+
+            if (condition.exists === false) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    public apply(dbQuery: any) {
+        let query = dbQuery
+
+        if (this.needWhereIn) {
+            query = query
+                .where(this.parentKey, 'in', (eb: any) => 
+                    eb.selectFrom(this.table)
+                        .select(this.foreignKey)
+                        .where(this.whereIn(eb))
+                )
+        }
+
+        if (this.needWhereNotIn) {
+            query = query
+                .where(this.parentKey, 'not in', (eb: any) => 
+                    eb.selectFrom(this.table)
+                        .select(this.foreignKey)
+                        .where(this.whereNotIn(eb))
+                )
+        }
+
+        return query
+    }
+
+    private buildRowConditions(eb: ExpressionBuilder<any, any>, name: string, condition: string | Metadafilter) {
+        if (typeof condition === 'string') {
+            return [
+                eb.eb('name', '=', name),
+                eb.eb('value', '=', condition)
+            ]
+        }
+
+        const clauses = [
+            eb.eb('name', '=', name)
+        ]
+
+        if (condition.eq !== undefined) {
+            clauses.push(eb.eb('value', '=', condition.eq))
+        }
+
+        if (condition.neq !== undefined) {
+            clauses.push(eb.eb('value', '!=', condition.neq))
+        }
+
+        if (condition.like !== undefined) {
+            clauses.push(eb.eb('value', 'like', condition.like))
+        }
+
+        if (condition.nlike !== undefined) {
+            clauses.push(eb.eb('value', 'not like', condition.nlike))
+        }
+
+        if (condition.in) {
+            clauses.push(eb.eb('value', 'in', condition.in))
+        }
+
+        if (condition.nin) {
+            clauses.push(eb.eb('value', 'not in', condition.nin))
+        }
+
+        if (condition.gt !== undefined) {
+            clauses.push(eb.eb('value', '>', condition.gt))
+        }
+
+        if (condition.gte !== undefined) {
+            clauses.push(eb.eb('value', '>=', condition.gte))
+        }
+
+        if (condition.lt !== undefined) {
+            clauses.push(eb.eb('value', '<', condition.lt))
+        }
+
+        if (condition.lte !== undefined) {
+            clauses.push(eb.eb('value', '<=', condition.lte))
+        }
+
+        if (condition.is_null !== undefined) {
+            clauses.push(eb.eb('value', condition.is_null ? 'is' : 'is not', null))
+        }
+
+        return clauses
+    }
+
+    public whereIn = <DBQuery>(eb:  ExpressionBuilder<any, any>) => {
+        let query = eb as any
+
+        for (const [name, condition] of Object.entries(this.payload)) {
+            if (typeof condition !== 'string' && condition.exists === false) {
+                continue
+            }
+
+            query = query.and(this.buildRowConditions(eb, name, condition))
+        }
+
+        return query as DBQuery
+    }
+
+    public whereNotIn = <DBQuery>(eb:  ExpressionBuilder<any, any>) => {
+        let query = eb as any
+
+        for (const [name, condition] of Object.entries(this.payload)) {
+            if (typeof condition === 'string') continue
+
+            if (condition.exists === false) {
+                query = query('name', '=', name)
+            }
+        }
+
+        return query as DBQuery
+    }
+}

package/src/server/services/MetadataService.ts

@@ -0,0 +1,128 @@
+import db from '#server/facades/database.ts'
+
+export default class MetadataService {
+    public id: number
+    public table: string
+    public foreignKey: string
+
+    constructor(payload: Pick<MetadataService, 'table' | 'foreignKey' | 'id'>) {
+        this.id = payload.id
+        this.table = payload.table
+        this.foreignKey = payload.foreignKey
+    }
+
+    public static parse(value: any): any {
+        if (typeof value === 'string' && value.startsWith('json:')) {
+            return JSON.parse(value.slice(5))
+        }
+
+        if (typeof value === 'string' && value.startsWith('bool:')) {
+            return value.slice(5) === 'true'
+        }
+
+        if (typeof value === 'string' && value.startsWith('number:')) {
+            return Number(value.slice(7))
+        }
+        
+        if (typeof value === 'string' && value.startsWith('string:')) {
+            return value.slice(7)
+        }
+
+        return value
+    }
+
+    public static flatten(items: Array<{ name: string; value: any }>): Record<string, any> {
+        const result: Record<string, any> = {}
+
+        for (const item of items) {
+            result[item.name] = MetadataService.parse(item.value)
+        }
+
+        return result
+    }
+    
+
+    public async get<T = any>(name: string): Promise<T | undefined>
+    public async get<T = any>(name: string, defaultValue: T): Promise<T>
+    public async get<T = any>(name: string, defaultValue?: T): Promise<T | undefined> {
+        let query = db.selectFrom(this.table as any) as any
+
+        query = query
+            .selectAll()
+            .where((this.foreignKey as string), '=', this.id)
+            .where('name', '=', name)
+            .limit(1)
+
+        const row = await query.executeTakeFirst() 
+
+        if (!row || !row.value) {
+            return defaultValue
+        }
+
+        const value = MetadataService.parse(row.value)
+
+        return value as T
+    }
+
+    public async set(name: string, value: any): Promise<void> {
+        const foreignKey = this.foreignKey
+        const table = this.table
+
+        const values = {
+            [foreignKey]: this.id,
+            name,
+            value
+        }
+
+        if (typeof value === 'object') {
+            values.value = `json:${JSON.stringify(value)}`
+        }
+
+        const row = await db.selectFrom(table as any).where((foreignKey as string), '=', this.id).where('name', '=', name).executeTakeFirst()
+
+        if (row) {
+            await db.updateTable(table as any)
+                .set(values)
+                .where((foreignKey as string), '=', this.id)
+                .where('name', '=', name)
+                .execute()
+
+            return
+        }
+
+        await db.insertInto(table as any)
+            .values(values)
+            .execute()
+
+    }
+
+    public async list(): Promise<Array<{ name: string; value: any }>> {
+        const foreignKey = this.foreignKey
+        const table = this.table
+
+        let query = db.selectFrom(table as any) as any
+
+        query = query
+            .selectAll()
+            .where((foreignKey as string), '=', this.id)
+
+        const rows = await query.execute()
+
+        return rows.map((row: any) => ({
+            name: row.name,
+            value: MetadataService.parse(row.value)
+        }))
+    }
+
+    public async all(): Promise<Record<string, any>> {
+        const rows = await this.list()
+        const result: Record<string, any> = {}
+
+        for (const row of rows) {
+            result[row.name] = row.value
+        }
+
+        return result
+    }
+
+}