@kunk/server 3.0.4 → 3.0.6

package/package.json

@@ -1,15 +1,25 @@
 {
   "name": "@kunk/server",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "private": false,
   "type": "module",
   "main": "./src/index.ts",
   "module": "./src/index.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsdown",
     "version:patch": "bun pm version patch",
     "deploy": "bun publish"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
   "dependencies": {
     "@kunk/api": "3.0.0",
     "@kunk/tsconfig": "3.0.0",

package/.turbo/turbo-build.log

@@ -1,16 +0,0 @@
-
-$ tsdown
-ℹ tsdown v0.20.3 powered by rolldown v1.0.0-rc.3
-ℹ config file: /Users/ag/auxo/kunk/packages/server/tsdown.config.ts 
-ℹ entry: src/index.ts
-ℹ tsconfig: tsconfig.json
-ℹ Build start
-
- WARN  Consider adding inlineOnly option to avoid unintended bundling of dependencies, or set inlineOnly: false to disable this warning.
-Detected dependencies in bundle:
-- zod
-
-ℹ dist/index.mjs      7.66 kB │ gzip:  2.96 kB
-ℹ dist/index.d.mts  116.22 kB │ gzip: 23.02 kB
-ℹ 2 files, total: 123.88 kB
-✔ Build complete in 2381ms

package/.turbo/turbo-version$colon$patch.log

@@ -1,4 +0,0 @@
-
-$ bun pm version patch
-[0.03ms] ".env"
-v3.0.4

package/CHANGELOG.md

@@ -1,13 +0,0 @@
-# @kunk/server
-
-## 3.0.0
-
-### Major Changes
-
-- version 2
-
-### Patch Changes
-
-- Updated dependencies
-  - @kunk/tsconfig@3.0.0
-  - @kunk/api@3.0.0

package/src/command.ts

@@ -1,56 +0,0 @@
-import type { I, ICommand, ICommandHandler, IContextCommand, IMiddleware, StandardSchemaV1 } from "@/interfaces/+"
-import { SERVER_ERROR } from "@/utils/+"
-import { middleware } from "./middleware"
-
-export class Command<IN extends StandardSchemaV1, OUT extends StandardSchemaV1> implements ICommand<IN, OUT> {
-
-  public readonly "~type": "kunk:command" = "kunk:command"
-
-  private constructor(
-    public readonly name: string,
-    public readonly visibility: "PUBLIC" | "PROTECTED" | "PRIVATE",
-    public input: IN,
-    public output: OUT,
-    public middlewares: IMiddleware[],
-    public handler: ICommandHandler<IN, OUT>,
-  ) {}
-
-  private static create = (visibility: "PUBLIC" | "PROTECTED" | "PRIVATE") => <IN extends StandardSchemaV1 = StandardSchemaV1, OUT extends StandardSchemaV1 = StandardSchemaV1>(
-    setup: {
-      name: string,
-      input: IN
-      output: OUT
-      middlewares?: IMiddleware[]
-    }, 
-    handler: ICommandHandler<IN, OUT>,
-  ) => {
-    return new Command<IN, OUT>(
-      setup.name,
-      visibility,
-      setup.input,
-      setup.output,
-      setup.middlewares || [],
-      handler
-    )
-  }
-
-  public static PUBLIC = this.create("PUBLIC")
-  public static PROTECTED = this.create("PROTECTED")
-  public static PRIVATE = this.create("PRIVATE")
-
-
-  async internalCall(context: IContextCommand<IN, OUT>): Promise<I.Output<OUT>> {
-    if (!this.handler) {
-      throw SERVER_ERROR.UNEXPECTED("HANDLER_NOT_SET", { 
-        command: this.name 
-      })
-    }
-    return this.handler(context)
-  }
-
-  async call(context: IContextCommand<IN, OUT>): Promise<I.Output<OUT>> {
-    const caller = () => this.internalCall(context)
-    const handler: any = middleware(caller, this.middlewares)
-    return handler(context)
-  }
-}

package/src/configs/+.ts

@@ -1 +0,0 @@
-export * from "./DatabaseConfig"

package/src/configs/DatabaseConfig.ts

@@ -1,12 +0,0 @@
-import { Config } from "@/utils/config"
-import { T } from "@kunk/model"
-
-export const DatabaseConfig = await Config.create({
-  name: "database", 
-  schema: T.object({
-    uri: T.string().default("${DATABASE_URI}"),
-    idleTimeout: T.number().default(5),
-    connectionTimeout: T.number().default(30),
-    maxPoolSize: T.number().default(30),
-  })
-})

package/src/context.ts

@@ -1,97 +0,0 @@
-import type { IService, IError, IContext, IContainer, IContextCommand } from "@/interfaces/+";
-import { ContextData, Database, Generator, Logger } from "@/contracts/+";
-import { DrizzleQuery } from "@/services/+";
-import { SERVER_ERROR } from "@/utils/+";
-import { Command } from "./command";
-import { registry } from "./registry";
-import { Container } from "inversify";
-
-// export const registry = new FinalizationRegistry<Context>(async (context) => {
-//   console.log(`Finalizing context`);
-//   await context.db.commit()
-// });
-
-export class Context implements IContext {
-
-  public readonly gen: Generator;
-  public readonly logger: Logger;
-
-  constructor(
-    private readonly container: IContainer,
-    public readonly db: Database
-  ) {
-    this.gen = container.get(Generator)
-    this.logger = container.get(Logger)
-  }
-
-  static async create(contextData: ContextData = {}): Promise<Context> {
-    const container = new Container({ defaultScope: 'Singleton', parent: registry })
-    container.bind(ContextData).toConstantValue(contextData)
-    const db = await container.getAsync(Database)
-    return new Context(container, db)
-  }
-
-  public readonly Q = DrizzleQuery
-
-  execute: IContext["execute"] = async (command: any, input: any) => {
-    let _command: Command<any, any> = command
-    if (_command instanceof Function) {
-      _command = command()
-    }
-    if (_command instanceof Promise) {
-      _command = await _command.then(cmd => cmd.default)
-    }
-
-    let newInput: any = input
-    if (_command.input) {
-      const validated = await _command.input["~standard"].validate(input)
-      if (validated.issues) {
-        throw SERVER_ERROR.SCHEMA_VALIDATION(validated.issues)
-      }
-      newInput = validated.value
-    }
-
-    const context: IContextCommand = {
-      ...this,
-      command: _command,
-      input: newInput
-    }
-    
-    let error: IError | null = null
-    // context.logger.info(`started`)
-    try {
-      const caller = () => _command.call(context as any)
-      const handler: any = caller
-      return await handler(context, this)
-    } catch (err: any) {
-      error = SERVER_ERROR.FORWARD(err)
-      throw error
-    } finally {
-      if (error) {
-        // context.logger.error(error)
-      } else {
-        // context.logger.info(`finished`)
-      }
-    }
-  }
-  
-  prepare: IContext["prepare"] = (command: any, input: any) => {
-    return {
-      input,
-      execute: () => this.execute(command, input)
-    }
-  }
-
-  get = <T>(service: IService<T>): T => {
-    return this.container.get(service)
-  }
-
-  getAsync = async <T>(service: IService<T>): Promise<T> => {
-    return await this.container.getAsync(service)
-  }
-
-  [Symbol.dispose] = async (): Promise<void> => {
-    await this.db.commit()
-  }
-
-}

package/src/contracts/+.ts

@@ -1,5 +0,0 @@
-export { Logger, Generator, Validator, ContextData } from "@kunk/api"
-
-export * from "./Auth"
-export * from "./Database"
-export * from "./Query"

package/src/contracts/Auth.ts

@@ -1,73 +0,0 @@
-
-export abstract class Auth {
-
-  abstract getSession(): Promise<Auth.Session>
-
-  abstract signInEmail(data: Auth.SignInEmail.Input): Promise<Auth.SignInEmail.Output>
-
-  abstract signOut(): Promise<void>
-
-  abstract signUpEmail(data: Auth.SignUpEmail.Input): Promise<Auth.SignUpEmail.Output>
-
-}
-
-export namespace Auth {
-
-  export type User = {
-    id: string;
-    email: string;
-    name: string;
-    image: string | null | undefined;
-    emailVerified: boolean;
-    createdAt: Date;
-    updatedAt: Date;
-}
-
-  export type Session = {
-    redirect: boolean;
-    token: string;
-    url: string | undefined;
-    user: User
-  }
-
-  export type SignUpEmailResponse = {
-    redirect: boolean;
-    token: string;
-    url: string | undefined;
-    user: User
-  }
-
-  export namespace SignUpEmail {
-
-    export type Input = {
-      email: string;
-      password: string;
-      name: string;
-      rememberMe?: boolean;
-      callbackURL?: string;
-      image?: string;
-    }
-
-    export type Output = {
-      token: string | null;
-      user: User;
-    }
-
-  }
-
-  export namespace SignInEmail {
-
-    export type Input = {
-      email: string;
-      password: string;
-    }
-
-    export type Output = {
-      redirect: boolean;
-      token: string;
-      url: string | undefined;
-      user: User;
-    } 
-  }
-}
-

package/src/contracts/Database.ts

@@ -1,40 +0,0 @@
-import type { InferInsertModel, InferSelectModel, SQL, Table } from "drizzle-orm"
-import type { IndexColumn, PgColumn } from "drizzle-orm/pg-core"
-
-export abstract class Database {
-  abstract commit(): Promise<void>
-
-  abstract create<T extends Table, V extends InferInsertModel<T> | InferInsertModel<T>[]>(
-    entity: T,
-    values: V
-  ): Promise<
-    V extends InferInsertModel<T>[]
-      ? { [K in keyof V]: NonNullable<InferSelectModel<T>> }
-      : NonNullable<InferSelectModel<T>>
-  >
-
-  abstract update<T extends Table>(entity: T, 
-    id: string, 
-    values: Partial<InferInsertModel<T>>
-  ): Promise<InferSelectModel<T>>
-
-  abstract upsert<T extends Table>(entity: T, options: {
-    target: IndexColumn | IndexColumn[],  
-    values: InferInsertModel<T>
-  }): Promise<InferSelectModel<T>>
-
-  abstract delete<T extends Table>(entity: T, id: string): Promise<void>
-  
-  abstract findMany<T extends Table>(entity: T, options?: {
-    where?: SQL,
-    limit?: number,
-    offset?: number,
-    orderBy?: (PgColumn | SQL | SQL.Aliased)[],
-  }): Promise<InferSelectModel<T>[]>
-
-  abstract findOne<T extends Table>(entity: T, options?: {
-    where?: SQL,
-  }): Promise<InferSelectModel<T> | null>
-
-  abstract get<T extends Table>(entity: T, id: string): Promise<InferSelectModel<T>>
-}

package/src/contracts/Query.ts

@@ -1,3 +0,0 @@
-import * as DrizzleQuery from "drizzle-orm/sql/expressions";
-
-export type Query = typeof DrizzleQuery;

package/src/index.ts

@@ -1,11 +0,0 @@
-export * from "./configs/+"
-export * from "./contracts/+"
-export * from "./interfaces/+"
-export * from "./services/+"
-export * from "./utils/+"
-export * from "./context"
-export * from "./command"
-export * from "./middleware"
-export * from "./server"
-export * from "./registry"
-export * from "./setup"

package/src/interfaces/+.ts

@@ -1,9 +0,0 @@
-export type { I, ICommand, StandardSchemaV1, IError } from "@kunk/api"
-
-export * from "./IApplication"
-export * from "./IContext"
-export * from "./IContextCommand"
-export * from "./IContextHandler"
-export * from "./IMiddleware"
-export * from "./IService"
-export * from "./IContainer"

package/src/interfaces/IApplication.ts

@@ -1,6 +0,0 @@
-import type { BindToFluentSyntax } from "inversify";
-import type { IService } from "./IService";
-
-export interface IApplication {
-  bind<T>(serviceIdentifier: IService<T>): BindToFluentSyntax<T>
-}

package/src/interfaces/IContainer.ts

@@ -1 +0,0 @@
-export type { Container as IContainer } from "inversify";

package/src/interfaces/IContext.ts

@@ -1,31 +0,0 @@
-import type { I, ICommand, StandardSchemaV1 } from "@kunk/api";
-import type { Generator, Logger, Database, Query } from "@/contracts/+";
-import type { IService } from "./IService";
-
-
-type Executor = {
-  <T extends Promise<{ default: ICommand<any, any> }>>(command: () => T, input: I.Input<Awaited<T>['default']>): Promise<I.Output<Awaited<T>['default']>>
-  <IN extends StandardSchemaV1, OUT extends StandardSchemaV1>(command: ICommand<IN, OUT>, input: I.Input<IN>): Promise<I.Output<OUT>>
-}
-
-type Prepare = {
-  <T extends Promise<{ default: ICommand<any, any> }>>(command: () => T, input: I.Input<Awaited<T>['default']>): {
-    input: I.Input<Awaited<T>['default']>
-    execute: () => Promise<I.Output<Awaited<T>['default']>>
-  }
-  <IN extends StandardSchemaV1, OUT extends StandardSchemaV1>(command: ICommand<IN, OUT>, input: I.Input<IN>): {
-    input: I.Input<IN>
-    execute: () => Promise<I.Output<OUT>>
-  }
-}
-
-export interface IContext {
-  db: Database
-  Q: Query
-  gen: Generator
-  logger: Logger
-  prepare: Prepare
-  execute: Executor
-  get: <T>(serviceIdentifier: IService<T>) => T
-  getAsync: <T>(serviceIdentifier: IService<T>) => Promise<T>  
-}

package/src/interfaces/IContextCommand.ts

@@ -1,7 +0,0 @@
-import type { I, ICommand, StandardSchemaV1 } from "@kunk/api"
-import type { IContext } from "./IContext"
-
-export interface IContextCommand<IN extends StandardSchemaV1 = StandardSchemaV1, OUT extends StandardSchemaV1 = StandardSchemaV1> extends IContext {
-  readonly command: ICommand<IN, OUT>
-  readonly input: I.Output<IN>
-}

package/src/interfaces/IContextHandler.ts

@@ -1,6 +0,0 @@
-import type { I, StandardSchemaV1 } from "@kunk/api"
-import type { IContextCommand } from "./IContextCommand"
-
-export interface ICommandHandler<IN extends StandardSchemaV1, OUT extends StandardSchemaV1> {
-  (context: IContextCommand<IN, OUT>): Promise<I.Output<OUT>>
-}

package/src/interfaces/IMiddleware.ts

@@ -1,6 +0,0 @@
-import type { Container } from "inversify";
-
-export type IMiddleware = (ctx: {
-  next: any,
-  container: Container,
-}) => any;

package/src/interfaces/IService.ts

@@ -1 +0,0 @@
-export type { ServiceIdentifier as IService } from "inversify";

package/src/middleware.ts

@@ -1,13 +0,0 @@
-import type { IMiddleware } from "@/interfaces/+"
-
-export function middleware<T extends (...args: any[]) => any>(
-  fn: T,
-  middlewares: IMiddleware[]
-): T {
-  return middlewares.reduceRight((next: T, mw: IMiddleware) => {
-    return ((ctx: any) => mw({
-      ...ctx,
-      next,
-    })) as any
-  }, fn);
-}

package/src/registry.ts

@@ -1,11 +0,0 @@
-import { Generator } from "@kunk/api";
-import { Container } from "inversify";
-import { DrizzleQuery } from "./services/DrizzleQuery";
-
-export const registry = new Container({ defaultScope: "Singleton" })
-
-export function gen() {
-  return registry.get(Generator)
-}
-
-export const Q = DrizzleQuery

package/src/server.ts

@@ -1,87 +0,0 @@
-import "./setup"
-import type { ICommand } from "@/interfaces/+"
-import openapi, { fromTypes } from "@elysiajs/openapi"
-import Elysia, { ValidationError } from "elysia"
-import { Throwable } from "@kunk/api"
-import { Context } from "./context"
-import { T } from "@kunk/model"
-
-export const Server = new Elysia()
-  .use(openapi({
-    references: fromTypes(),
-    mapJsonSchema: {
-      zod: T.toJSONSchema
-    },
-    documentation: {
-      servers: [
-        {
-          url: "/",
-          description: "The base URL of the API",
-          variables: {
-            tenant_id: {
-              default: "test"
-            }
-          }
-        }
-      ]
-    }
-  }))
-  .onError(({ error }) => {
-    if (Throwable.is(error)) {
-      return Response.json(error)
-    }
-    if (error instanceof T.ModelError) {
-      return Response.json(
-        Throwable.forward(error)
-      )
-    }
-    if (error instanceof ValidationError) {
-      return Response.json(error)
-    }
-    if (error instanceof Error) {
-      return Response.json(
-        error
-      )
-    }
-    return Response.json(
-      Throwable.forward(error)
-    )
-  })
-
-
-
-export async function route<K extends string, CMD extends ICommand<any, any>>(path: K, commandImport: Promise<{ default: CMD }>) {
-  const splited = path.split("/")
-  const tag = splited.slice(0, -1).join(".");
-  const summary = splited.pop()!;
-
-
-  const command = (await commandImport).default
-
-
-  let input: CMD["input"] = command.input?.type === 'void' ? null : command.input
-  let output: CMD["output"] = command.output?.type === 'void' ? null : command.output
-
-  console.info("command loaded:", path);
-
-  const elysia = new Elysia()
-
-  return elysia.post(path, async ({ headers, body }) => {
-    const tenantId = headers["x-tenant-id"];
-    using ctx = await Context.create({
-      tenantId: tenantId!
-    });
-    const result = await ctx.execute(command, body);
-    return Response.json(result);
-  }, {
-    body: input,
-    response: output,
-    headers: T.object({
-      "x-tenant-id": T.string().default("{{tenant_id}}").optional(),
-    }),
-    detail: {
-      summary,
-    },
-    tags: [tag]
-  });
-}

package/src/services/+.ts

@@ -1,4 +0,0 @@
-export * from "./BunGenerator"
-export * from "./PinoLogger"
-export * from "./DizzleDatabase"
-export * from "./DrizzleQuery"

package/src/services/BunGenerator.ts

@@ -1,13 +0,0 @@
-import { Generator } from "@kunk/api"
-
-export class BunGenerator extends Generator {
-
-  override get id() {
-    return Bun.randomUUIDv7()
-  }
-
-  override code(length: number) {
-    return Bun.randomUUIDv7().replace(/-/g, '').slice(0, length)
-  }
-
-}

package/src/services/DizzleDatabase.ts

@@ -1,142 +0,0 @@
-import { eq, type InferInsertModel, type InferSelectModel, type SQL, type Table } from "drizzle-orm";
-import { drizzle } from "drizzle-orm/bun-sql";
-import type { BunSQLDatabase } from "drizzle-orm/bun-sql/postgres/driver";
-import { SERVER_ERROR } from "@/utils/+";
-import { Database } from "@/contracts/+";
-import type { ContextData } from "@kunk/api";
-import type { IndexColumn, PgColumn } from "drizzle-orm/pg-core";
-
-export class DizzleDatabase extends Database {
-
-  private released: boolean = false
-
-  private constructor(
-    private readonly sql: BunSQLDatabase,
-    private readonly session: Bun.ReservedSQL
-  ) {
-    super()
-  }
-
-  static async create(sql: Bun.SQL, contextData: ContextData): Promise<DizzleDatabase> {
-    const session = await sql.reserve()
-    if (contextData.tenantId) {
-      await session`SELECT set_config('app.tenant_id', ${contextData.tenantId}, false);`
-    }
-    return new DizzleDatabase(drizzle({ client: session }), session)
-  }
-
-  override async create<T extends Table, V extends InferInsertModel<T> | InferInsertModel<T>[]>(
-    entity: T,
-    values: V
-  ): Promise<
-    V extends InferInsertModel<T>[]
-      ? { [K in keyof V]: NonNullable<InferSelectModel<T>> }
-      : NonNullable<InferSelectModel<T>>
-  > {
-    const table = entity as any
-    const result = await this.sql.insert(table).values(values).returning()
-
-    const length = Array.isArray(values) ? values.length : 1
-    if (result.length !== length) {
-      throw SERVER_ERROR.UNEXPECTED("FAILED_TO_INSERT_ENTITY", {})
-    }
-
-    if (Array.isArray(values)) {
-      return result as any
-    }
-
-    return result[0] as any
-  }
-
-  async update<T extends Table>(
-    entity: T, 
-    id: string,
-    values: Partial<InferInsertModel<T>>
-  ): Promise<InferSelectModel<T>> {
-    const table = entity as any
-    const [result] = await this.sql.update(table)
-    .set(values)
-    .where(eq(table.id, id))
-    .returning()
-
-    if (!result) {
-      throw SERVER_ERROR.UNEXPECTED("FAILED_TO_UPDATE_ENTITY", { })
-    }
-
-    return result as InferSelectModel<T>
-  }
-
-  async upsert<T extends Table>(entity: T, options: {
-    target: IndexColumn | IndexColumn[],
-    values: InferInsertModel<T>
-  }): Promise<InferSelectModel<T>> {
-    const table = entity as any
-    const [result] = await this.sql.insert(table).values(options.values).onConflictDoUpdate({
-      target: options.target,
-      set: options.values,
-    }).returning()
-
-    if (!result) {
-      throw SERVER_ERROR.UNEXPECTED("FAILED_TO_UPSERT_ENTITY", {})
-    }
-
-    return result as InferSelectModel<T>
-  }
-
-  async findMany<T extends Table>(entity: T, options?: {
-    where?: SQL,
-    limit?: number,
-    offset?: number,
-    orderBy?: (PgColumn | SQL | SQL.Aliased)[],
-  }): Promise<InferSelectModel<T>[]> {
-    const table = entity as any
-    const result = await this.sql.select().from(table)
-    .where(options?.where)
-    .limit(options?.limit ?? 1000)
-    .offset(options?.offset ?? 0)
-    .orderBy(...(options?.orderBy ?? []))
-    .execute()
-
-    if (!result) {
-      throw SERVER_ERROR.UNEXPECTED("FAILED_TO_GET_MANY_ENTITIES", {})
-    }
-
-    return result as InferSelectModel<T>[]
-  }
-
-  async findOne<T extends Table>(entity: T, options?: {
-    where?: SQL,
-  }): Promise<InferSelectModel<T> | null> {
-    const table = entity as any
-    const [result] = await this.sql.select().from(table).where(options?.where).limit(1).execute()
-
-    if (!result) {
-      return null
-    }
-
-    return result as InferSelectModel<T>
-  }
-
-  async get<T extends Table>(entity: T, id: string): Promise<InferSelectModel<T>> {
-    const table = entity as any
-    const [result] = await this.sql.select().from(table).where(eq(table.id, id)).limit(1).execute()
-
-    if (!result) {
-      throw SERVER_ERROR.GET_ENTITY_NOT_FOUND(table, id)
-    }
-
-    return result as InferSelectModel<T>
-  }
-
-  async delete<T extends Table>(entity: T, id: string): Promise<void> {
-    const table = entity as any
-    await this.sql.delete(table).where(eq(table.id, id))
-  }
-
-  async commit(): Promise<void> {
-    if (!this.released) {
-      this.released = true
-      this.session.release()
-    }
-  }
-}

package/src/services/DrizzleQuery.ts

@@ -1 +0,0 @@
-export * as DrizzleQuery from "drizzle-orm/sql/expressions";

package/src/services/PinoLogger.ts

@@ -1,36 +0,0 @@
-import { Logger } from "@kunk/api"
-import pino from "pino"
-
-const rootLogger = pino({
-  name: 'app',
-  transport: {
-    target: 'pino-pretty',
-    options: {
-      colorize: true,
-      translateTime: 'SYS:standard',
-      ignore: 'pid,hostname'
-    }
-  }
-})
-
-export class PinoLogger implements Logger {
-
-  constructor(private logger: pino.Logger = rootLogger) {}
-
-  info(message: string): void {
-    this.logger.info(message)
-  }
-
-  warn(message: string): void {
-    this.logger.warn(message)
-  }
-
-  error(error: any): void {
-    this.logger.error(error)
-  }
-
-  fork(name: string): Logger {
-    return new PinoLogger(this.logger.child({ name }))
-  }
-
-}

package/src/setup.ts

@@ -1,26 +0,0 @@
-import * as Contracts from "@/contracts/+";
-import * as Services from "@/services/+";
-import { registry } from "@/registry";
-import { DizzleDatabase } from "@/services/+";
-import { DatabaseConfig } from "@/configs/+";
-
-
-registry.bind(Contracts.Logger).to(Services.PinoLogger)
-registry.bind(Contracts.Generator).to(Services.BunGenerator)
-
-registry.bind(Bun.SQL).toDynamicValue(() => {
-  const config = DatabaseConfig.get()
-  return new Bun.SQL({
-    url: config.uri,
-    max: config.maxPoolSize,
-    idleTimeout: config.idleTimeout,
-    connectionTimeout: config.connectionTimeout
-  })
-}).inSingletonScope()
-
-registry.bind(Contracts.Database).toDynamicValue(async (container) => {
-  return await DizzleDatabase.create(
-    container.get(Bun.SQL), 
-    container.get(Contracts.ContextData)
-  )
-}).inRequestScope()

package/src/utils/+.ts

@@ -1,2 +0,0 @@
-export * from "./SERVER_ERROR"
-export * from "./config"

package/src/utils/SERVER_ERROR.ts

@@ -1,41 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { Throwable, type IThrowable } from "@kunk/api"
-import { getTableUniqueName, Table } from "drizzle-orm"
-
-export namespace SERVER_ERROR {
-
-  export function RESOURCE_ID_NOT_FOUND(resource: string, id: string) {
-    return Throwable.create("RESOURCE_ID_NOT_FOUND", 404, { resource, id })
-  }
-
-  export function RESOURCE_NOT_FOUND(resource: string) {
-    return Throwable.create("RESOURCE_NOT_FOUND", 404, { resource })
-  }
-
-  export function BAD_REQUEST(type: string, args: Record<string, any>) {
-    return Throwable.create(type, 400, args)
-  }
-
-  export function RESOURCE_ID_ALREADY_EXISTS(resource: string, id: string) {
-    return Throwable.create("RESOURCE_ID_ALREADY_EXISTS", 400, { resource, id })
-  }
-
-  export function VALIDATION(...issues: IThrowable[]) {
-    return Throwable.create("VALIDATION_ERROR", 422, { issues })
-  }
-
-  export function SCHEMA_VALIDATION(issues: readonly StandardSchemaV1.Issue[]) {
-    return Throwable.create("SCHEMA_VALIDATION_ERROR", 422, { issues })
-  }
-
-  export function UNEXPECTED(type: string, args: Record<string, any>) {
-    return Throwable.create(type, 500, args)
-  }
-
-  export const FORWARD = Throwable.forward
-
-  export function GET_ENTITY_NOT_FOUND<T extends Table>(entity: T, id: string) {
-    return SERVER_ERROR.RESOURCE_ID_NOT_FOUND(getTableUniqueName(entity), id)
-  }
-
-}

package/src/utils/config.ts

@@ -1,70 +0,0 @@
-import { SERVER_ERROR } from "./SERVER_ERROR";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { I } from "@kunk/api";
-import * as path from "path";
-
-function interpolateEnvVars<T>(obj: T): T {
-  if (typeof obj === 'string') {
-    return obj.replace(
-      /\${([^:-]+)(?:-([^}]+))?}/g,
-      (_, key, defaultValue) => Bun.env[key] || defaultValue || ''
-    ) as T;
-  }
-  
-  if (typeof obj === 'object' && obj !== null) {
-    const result = (Array.isArray(obj) ? [] : {}) as T;
-    for (const key in obj) {
-      result[key] = interpolateEnvVars(obj[key]);
-    }
-    return result;
-  }
-  
-  return obj;
-}
-
-async function loadFromFile<T extends StandardSchemaV1>(name: string, schema: T): Promise<I.Output<T>> {
-  let rawConfig = {}
-  const filePath = path.resolve(process.cwd(), `./config/${name}.yaml`)
-
-  if (await Bun.file(filePath).exists()) {
-    rawConfig = await import(filePath).then(module => module.default?.[Bun.env.NODE_ENV || "local"]);
-  }
-
-  const validated = await schema["~standard"].validate(rawConfig);
-  if (validated.issues) {
-    throw SERVER_ERROR.SCHEMA_VALIDATION(validated.issues)
-  }
-  return interpolateEnvVars(validated.value) as I.Output<T>;
-}
-
-
-export class Config<T extends StandardSchemaV1> {
-
-  private constructor(
-    private readonly schema: T,
-    private values: I.Output<T>
-  ) {}
-  
-
-  public get() {
-    return this.values;
-  }
-
-  public async set(values: I.Input<T>): Promise<void> {
-    const validated = await this.schema["~standard"].validate(values);
-    if (validated.issues) {
-      throw SERVER_ERROR.SCHEMA_VALIDATION(validated.issues)
-    }
-    this.values = validated.value as I.Output<T>;
-  }
-
-  static async create<T extends StandardSchemaV1>(options: { name: string, schema: T }) {
-    const values = await loadFromFile(options.name, options.schema);
-    return new Config(options.schema, values as I.Output<T>);
-  }
-
-  public static set<T extends StandardSchemaV1>(config: Config<T>, values: I.Input<T>) {
-    config.set(values);
-  }
-
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "rootDir": ".",
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./src/*"]
-    },
-    "strict": true,
-    "module": "Preserve",
-    "target": "ESNext"
-  },
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}

package/tsdown.config.ts

@@ -1,15 +0,0 @@
-import { defineConfig } from 'tsdown'
-
-export default defineConfig({
-  entry: [
-    './src/index.ts'
-  ],
-  external: [
-    "drizzle-orm",
-    "drizzle-sdk",
-  ],
-  dts: true,
-  minify: {
-    mangle: true,
-  }
-})