@kunk/server 3.0.4 → 3.0.5

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,
-  }
-})