@kunk/server 3.0.2 → 3.0.5

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"