@sidekick-coder/zenith-kit 0.4.2 → 0.4.4

package/src/server/services/ConfigManagerService.ts

@@ -1,11 +1,11 @@
-import ConfigFSService from '#server/services/ConfigFSService.ts'
-import ConfigS3Service from '#server/services/ConfigS3Service.ts'
-import { BaseException, type LoggerService } from '#shared/index.ts'
+import BaseException from '#shared/exceptions/BaseException.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
 import ConfigService from '#shared/services/ConfigService.ts'
 import { flatten } from '#shared/utils/flatten.ts'
 import type EnvService from './EnvService.ts'
-import fs from 'fs'
-import yaml from 'js-yaml'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url) 
 
 export interface ConfigManagerOptions {
     env: EnvService
@@ -31,6 +31,8 @@ export default class ConfigManagerService {
     }
 
     private async loadS3Config() {
+        const ConfigS3Service = await import('#server/services/ConfigS3Service.ts').then(m => m.default)
+
         const service = new ConfigS3Service({
             bucket: this.env.get('ZENITH_CONFIG_S3_BUCKET')!,
             region: this.env.get('ZENITH_CONFIG_S3_REGION')!,
@@ -58,6 +60,8 @@ export default class ConfigManagerService {
     }
 
     private async loadFSConfig() {
+        const ConfigFSService = await import('#server/services/ConfigFSService.ts').then(m => m.default)
+
         const service = new ConfigFSService({
             directory: this.env.get('ZENITH_CONFIG_FS_PATH'),
             debug: this.env.get('ZENITH_CONFIG_DEBUG'),
@@ -86,6 +90,8 @@ export default class ConfigManagerService {
     }
 
     public loadConfigFromFile(service: ConfigService, file: string) {
+        const fs = require('fs') 
+
         if (!fs.existsSync(file)) {
             this.logger.warn(`configuration file not found: ${file}`)
             return
@@ -95,6 +101,8 @@ export default class ConfigManagerService {
         let data: Record<string, any> | null = null
 
         if (file.endsWith('.yml') || file.endsWith('.yaml')) {
+            const yaml = require('js-yaml')
+
             data = yaml.load(text) as Record<string, any>
         }
 

package/src/server/services/EncryptService.ts

@@ -3,7 +3,7 @@ import ms from 'ms'
 import { format } from 'date-fns'
 import EnvService from './EnvService';
 import LoggerService from '#shared/services/LoggerService.ts';
-import { BaseException } from '#shared/index.ts';
+import BaseException from '#shared/exceptions/BaseException.ts';
 
 interface URLOptions {
     data?: any;

package/src/server/services/EnvService.ts

@@ -1,8 +1,12 @@
-import dotenv from 'dotenv'
-import * as v from 'valibot'
+// import dotenv from 'dotenv'
+// import * as v from 'valibot'
+import type { DotenvConfigOptions } from 'dotenv'
 import BaseException from '#shared/exceptions/BaseException.ts'
-import { envSchema } from '#server/schemas/envSchema.ts'
+// import { envSchema } from '#server/schemas/envSchema.ts'
 import type { EnvSchema } from '#server/schemas/envSchema.ts'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
 
 export default class EnvService {
     public static __container_entry_key = 'EnvService'
@@ -13,7 +17,9 @@ export default class EnvService {
         return new EnvService()
     }
 
-    public static dotEnvConfig(options?: dotenv.DotenvConfigOptions) {
+    public static dotEnvConfig(options?: DotenvConfigOptions) {
+        const dotenv = require('dotenv')
+
         return dotenv.config(options)
     }
 
@@ -34,6 +40,9 @@ export default class EnvService {
             quiet: true,
         })
 
+        const v = require('valibot')
+        const envSchema = require('#server/schemas/envSchema.ts').envSchema
+
         this.env = v.parse(envSchema, process.env)
 
         return this

package/src/server/services/ExceptionService.ts

@@ -1,5 +1,5 @@
 import type { Response } from 'express'
-import { BaseException, LoggerService } from '#shared/index.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
 import EnvService from './EnvService'
 
 export interface ExceptionServiceOptions {
@@ -37,6 +37,7 @@ export default class ExceptionService {
             error: errorName,
             message: errorMessage,
             status: errorStatus,
+            stack: this.env.development ? error.stack : undefined,
         })
     }
 }

package/src/server/services/HasherService.ts

@@ -1,13 +1,17 @@
-import bcrypt from 'bcrypt'
+// import bcrypt from 'bcrypt'
 
 export default class HasherService {
     public static __container_entry_key = 'HasherService'
 
-    public hash(value: string): Promise<string> {
+    public async hash(value: string): Promise<string> {
+        const bcrypt = await import('bcrypt')
+
         return bcrypt.hash(value, 12)
     }
 
     async compare(a: string, b: string): Promise<boolean> {
+        const bcrypt = await import('bcrypt')
+
         return bcrypt.compare(a, b)
     }
 }

package/src/server/services/HttpService.ts

@@ -1,15 +1,21 @@
 import type { Server } from 'http'
-import express from 'express'
-import cors from 'cors'
-import cookieParser from 'cookie-parser'
+// import express from 'express'
+// import cors from 'cors'
+// import cookieParser from 'cookie-parser'
+import type { Request, Response, Application, NextFunction } from 'express'
+import type { CorsOptions } from 'cors'
 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 EmmitterService from '#shared/services/EmmitterService.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
 import type { HttpContext } from '#server/contracts/HttpContextContract.ts'
 import CookieMapEntity from '#server/entities/CookieMapEntity.ts'
 import EnvService from './EnvService.ts'
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
 
 export interface HttpServiceOptions {
     debug?: boolean;
@@ -24,7 +30,7 @@ export interface HttpServiceOptions {
 export default class HttpService {
     public static __container_entry_key = 'HttpService'
 
-    public app: express.Application
+    public app: Application
     public server: Server | null = null
     public router: Router
     public exception: ExceptionService
@@ -32,7 +38,7 @@ export default class HttpService {
     public emmitter: EmmitterService
     public env: EnvService
     public debug = false
-    public onUnhandlerRouted: ((req: express.Request, res: express.Response) => void) | null = null
+    public onUnhandlerRouted: ((req: Request, res: Response) => void) | null = null
 
     constructor(options: HttpServiceOptions) {
         this.debug = options.debug || false
@@ -42,20 +48,25 @@ export default class HttpService {
         this.env = options.env || new EnvService()
         this.exception = options.exception || new ExceptionService({ logger: this.logger, env: this.env })
 
+        const express = require('express')
+        const cookieParser = require('cookie-parser')
+
         this.app = express()
         this.app.use(cookieParser())
         this.app.use(this.parser)
     }
 
-    public getExpressApp(): express.Application {
+    public getExpressApp(): Application {
         return this.app
     }
 
-    public cors(options: cors.CorsOptions) {
+    public cors(options: CorsOptions) {
+        const cors = require('cors')
+
         this.app.use(cors(options))
     }
 
-    public use: express.Application['use'] = (...args: any[]) => {
+    public use: Application['use'] = (...args: any[]) => {
         this.app.use(...args)
 
         return this.app
@@ -90,7 +101,8 @@ export default class HttpService {
         })
     }
 
-    public parser(req: express.Request, res: express.Response, next: express.NextFunction) {
+    public parser(req: Request, res: Response, next: NextFunction) {
+        const express = require('express')
         const contentType = req.headers['content-type'] || ''
 
         if (contentType.startsWith('multipart/form-data')) {
@@ -99,14 +111,14 @@ export default class HttpService {
         }
 
         // For other content types, parse JSON and URL-encoded body
-        express.json()(req, res, (err) => {
+        express.json()(req, res, (err: any) => {
             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) {
+    public async execute(url: URL, request: Request, response: Response, route: Route) {
         const ctx: Omit<HttpContext, 'acl'> = {
             response,
             request,

package/src/server/services/MigratorService.ts

@@ -7,7 +7,7 @@ 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'
+import BaseException from '#shared/exceptions/BaseException.ts'
 
 export interface MigrationSource {
     id: string;

package/src/server/services/RouterService.ts

@@ -3,7 +3,7 @@ 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 LoggerService from '#shared/services/LoggerService.ts'
 import { matchPath } from '#shared/utils/matchPaths.ts'
 
 type RouteContext = 'global' | 'group' | 'route'

package/src/server/services/SchedulerService.ts

@@ -1,11 +1,12 @@
 import fs from 'fs'
 import path from 'path'
-import nodeSchedule from 'node-schedule'
+// 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'
+import BaseException from '#shared/exceptions/BaseException.ts'
+import LoggerService from '#shared/services/LoggerService.ts'
 
 export interface AddOptions {
     id?: string
@@ -167,6 +168,8 @@ export default class SchedulerService {
             logger.info(`${routine.id} routine executed`)
         }
 
+        const nodeSchedule = await import('node-schedule')
+
         routine.job = nodeSchedule.scheduleJob(routine.cron, cb)
 
         logger.info(`${routine.id} routine started`)

package/src/server/services/SeederService.ts

@@ -4,7 +4,7 @@ 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'
+import { tryCatch } from '#shared/utils/tryCatch.ts'
 
 
 export interface SeederSource {

package/src/server/utils/addSoftDeleteColumn.ts

@@ -0,0 +1,17 @@
+import { CreateTableBuilder, type ColumnType } from 'kysely'
+
+export interface SoftDeleteTable {
+  deleted_at: ColumnType<Date | null, never | null | string | null>
+}
+
+declare module 'kysely' {
+    interface CreateTableBuilder<TB extends string, C extends string = never> {
+        addSoftDeleteColumn(): CreateTableBuilder<TB, C | 'deleted_at'>
+    }
+}
+
+CreateTableBuilder.prototype.addSoftDeleteColumn = function(
+    this: CreateTableBuilder<any, any>,
+) {
+    return this.addColumn('deleted_at', 'timestamp')
+}

package/src/server/utils/addTimestampColumns.ts

@@ -0,0 +1,39 @@
+import { CreateTableBuilder, sql } from 'kysely'
+import type { ColumnType } from 'kysely'
+
+export interface TimestampTable {
+    created_at: ColumnType<Date, string | undefined, never>
+    updated_at: ColumnType<Date, string | undefined, Date | string | ReturnType<typeof now>>
+}
+
+declare module 'kysely' {
+    interface CreateTableBuilder<TB extends string, C extends string = never> {
+        addTimestampColumns(): CreateTableBuilder<TB, C | 'created_at' | 'updated_at'>
+        addCreatedColumn(): CreateTableBuilder<TB, C | 'created_at'>
+        addUpdatedColumn(): CreateTableBuilder<TB, C | 'updated_at'>
+    }
+}
+
+const now = () => sql<string>`CURRENT_TIMESTAMP`
+
+CreateTableBuilder.prototype.addTimestampColumns = function(
+    this: CreateTableBuilder<any, any>,
+) {
+    return this
+        .addColumn('created_at', 'timestamp', (col) => col.defaultTo(now()).notNull())
+        .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(now()).notNull())
+}
+
+CreateTableBuilder.prototype.addCreatedColumn = function(
+    this: CreateTableBuilder<any, any>,
+) {
+    return this
+        .addColumn('created_at', 'timestamp', (col) => col.defaultTo(now()).notNull())
+}
+
+CreateTableBuilder.prototype.addUpdatedColumn = function(
+    this: CreateTableBuilder<any, any>,
+) {
+    return this
+        .addColumn('updated_at', 'timestamp', (col) => col.defaultTo(now()).notNull())
+}

package/src/server/utils/basePath.ts

@@ -1,6 +1,5 @@
 import path from 'path'
 
-
 export function basePath(...args: string[]): string {
     const BASE_PATH = process.env.ZENITH_BASE_PATH!
 
@@ -11,6 +10,22 @@ export function basePath(...args: string[]): string {
     return path.resolve(BASE_PATH, ...args)
 }
 
+export function serverPath(...args: string[]): string {
+    if (process.env.NODE_ENV === 'production') {
+        return basePath('dist', 'server', ...args)
+    }
+
+    return basePath('src', 'server', ...args)
+}
+
+export function clientPath(...args: string[]): string {
+    if (process.env.NODE_ENV === 'production') {
+        return basePath('dist', 'client-browser', ...args)
+    }
+
+    return basePath('src', 'client', ...args)
+}
+
 export function storagePath(...args: string[]): string {
     const BASE_PATH = process.env.ZENITH_BASE_PATH!
     const STORAGE_PATH = process.env.ZENITH_STORAGE_PATH || path.join(BASE_PATH || '', 'storage')

package/src/server/utils/config.ts

@@ -0,0 +1,19 @@
+import cosmicconfig from 'cosmiconfig'
+
+export function getPluginConfig(dir?: string) {
+    const explorer = cosmicconfig.cosmiconfigSync('zenith', {
+        searchPlaces: [
+            'zenith.config.js',
+            'zenith.config.yml',
+            'zenith.config.yaml',
+        ]
+    })
+
+
+    const result = explorer.search(dir)
+
+    const config = result?.config || {}
+
+    return config
+}
+

package/src/server/utils/createLoaderFactory.ts

@@ -1,4 +1,4 @@
-import { BaseException } from '#shared/index.ts'
+import BaseException from '#shared/exceptions/BaseException.ts'
 import type { Loader, LoaderRecord } from './defineLoader.ts'
 
 export function createLoaderFactory<E extends Record<string, any> = Record<string, any>, R extends LoaderRecord<E> = LoaderRecord<E>>(loaders: R) {

package/src/server/utils/importAll.ts

@@ -38,7 +38,7 @@ export async function importFiles(files: string[], options: Options = {}): Promi
 
         const cleanFilename = ctx.filename.split('?')[0]
 
-        if (/\.(mts|ts|js)$/.test(cleanFilename)) {
+        if (/\.(mts|mjs|ts|js)$/.test(cleanFilename)) {
             const abs = path.resolve(ctx.filename)
             const fileUrl = pathToFileURL(abs)
 

package/src/server/utils/printTable.ts

@@ -1,4 +1,6 @@
-import Table from 'cli-table3'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
 
 export interface TableColumn {
     label: string
@@ -12,6 +14,8 @@ export interface ObjectOptions {
 }
 
 export function printObject(output: any = {}, options: ObjectOptions = {}) {
+    const Table = require('cli-table3') as typeof import('cli-table3')
+
     const screenWidth = process.stdout.columns || 80
     const keyWidth = options.keyWidth || Math.floor(screenWidth * 0.2)
     const valueWidth = Math.floor(screenWidth * 0.7)
@@ -30,6 +34,8 @@ export function printObject(output: any = {}, options: ObjectOptions = {}) {
 }
 
 export function printTable(items: any[], columns?: TableColumn[]) {
+    const Table = require('cli-table3') as typeof import('cli-table3')
+
     const screenWidth = (process.stdout.columns || 80) - 6
     const rows = [] as string[][]
     const head: TableColumn[] = []

package/src/shared/services/ConfigService.ts

@@ -1,5 +1,8 @@
-import { get, set, has, unset } from 'lodash-es'
-import { flatten } from '../utils'
+import { flatten } from '#shared/utils/flatten.ts'
+import get from 'lodash-es/get.js'
+import set from 'lodash-es/set.js'
+import has from 'lodash-es/has.js'
+import unset from 'lodash-es/unset.js'
 
 interface Entry {
     key: string

package/src/shared/services/EmmitterService.ts

@@ -1,5 +1,6 @@
-import { debounce } from 'lodash-es'
-import { createId, tryCatch } from '../utils/index.ts'
+import debounce from 'lodash-es/debounce.js'
+import { createId } from '#shared/utils/createId.ts'
+import { tryCatch } from '#shared/utils/tryCatch.ts'
 import LoggerService from './LoggerService.ts'
 
 export interface EmmitterListenerOptions {

package/src/shared/utils/flatten.ts

@@ -1,4 +1,4 @@
-import { set } from 'lodash-es'
+import set from 'lodash-es/set.js'
 
 export function flatten(obj: any, prefix = '', res: any = {}): Record<string, any> {
     for (const [key, value] of Object.entries(obj)) {

package/src/shared/validators/array.ts

@@ -0,0 +1,13 @@
+
+import * as v from 'valibot'
+
+export function array<T extends v.BaseSchema<any, any, any>>(schema: T = v.any() as any as T) {
+    return v.pipe(
+        v.union([schema, v.array(schema)]),
+        v.transform(value => Array.isArray(value) ? value : [value]),
+        v.array(schema),
+    )
+}
+
+array.number = () => array(v.number())
+

package/src/shared/validators/index.ts

@@ -1,3 +1,4 @@
+export * from './array.ts'
 export * from './urlValidator.ts'
 export * from './keyValueValidator.ts'
 export * from './paginationValidator.ts'

package/src/shared/validators/paginationValidator.ts

@@ -1,4 +1,4 @@
-import { number, array } from './urlValidator.ts'
+import { url } from './urlValidator.ts'
 import * as v from 'valibot'
 
 export interface PaginationParams {
@@ -8,10 +8,10 @@ export interface PaginationParams {
 
 
 export const base = (options: PaginationParams = {}) => v.object({
-    page: v.optional(number(), 1),
-    limit: v.optional(number(), options.maxLimit || 100),
-    orderBy: v.nullish(options.orderFields ? array(v.picklist(options.orderFields)) : array(v.string()), []),
-    orderDirection: v.nullish(array(v.union([v.literal('asc'), v.literal('desc')])), []),
+    page: v.optional(url.number(), 1),
+    limit: v.optional(url.number(), options.maxLimit || 100),
+    orderBy: v.nullish(options.orderFields ? url.array(v.picklist(options.orderFields)) : url.array(v.string()), []),
+    orderDirection: v.nullish(url.array(v.union([v.literal('asc'), v.literal('desc')])), []),
 })
 
 export function pagination(options: PaginationParams = {}) {

package/src/shared/validators/urlValidator.ts

@@ -35,7 +35,7 @@ export const datetime = () => v.pipe(
     }),
 )
 
-export const array = <T extends v.BaseSchema<any, any, any>>(schema: T = v.any() as any as T) => v.pipe(
+const array = <T extends v.BaseSchema<any, any, any>>(schema: T = v.any() as any as T) => v.pipe(
     v.union([v.string(), v.array(v.string())]),
     v.transform(value => Array.isArray(value) ? value : value.split(',')),
     v.array(schema),

package/src/tests/services/HttpTesterService.ts

@@ -0,0 +1,63 @@
+import tokenRepository from "#server/facades/tokenRepository.ts"
+import userRepository from "#server/facades/userRepository.ts"
+import BaseException from "#shared/exceptions/BaseException.ts"
+import UserEntity from "#shared/entities/UserEntity.ts"
+import type HttpService from "#server/services/HttpService.ts"
+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()) as any
+    }
+
+
+    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)
+    }
+}