@kunk/server 3.0.2 → 3.0.5

package/dist/index.d.mts

@@ -0,0 +1,520 @@
+import { ContextData, ContextData as ContextData$1, Generator, Generator as Generator$1, I, I as I$1, ICommand, ICommand as ICommand$1, IError, IThrowable, Logger, Logger as Logger$1, StandardSchemaV1, StandardSchemaV1 as StandardSchemaV1$1, Validator } from "@kunk/api";
+import { InferInsertModel, InferSelectModel, SQL, Table } from "drizzle-orm";
+import pino from "pino";
+import * as DrizzleQuery from "drizzle-orm/sql/expressions";
+import { BindToFluentSyntax, Container, Container as IContainer, ServiceIdentifier as IService } from "inversify";
+import * as elysia from "elysia";
+import Elysia from "elysia";
+import { StandardSchemaV1 as StandardSchemaV1$2 } from "@standard-schema/spec";
+import { IndexColumn, PgColumn } from "drizzle-orm/pg-core";
+import * as elysia_types0 from "elysia/types";
+import * as elysia_universal_server0 from "elysia/universal/server";
+import * as elysia_cookies0 from "elysia/cookies";
+
+//#region src/utils/config.d.ts
+declare class Config<T extends StandardSchemaV1$2> {
+  private readonly schema;
+  private values;
+  private constructor();
+  get(): I$1.Output<T>;
+  set(values: I$1.Input<T>): Promise<void>;
+  static create<T extends StandardSchemaV1$2>(options: {
+    name: string;
+    schema: T;
+  }): Promise<Config<T>>;
+  static set<T extends StandardSchemaV1$2>(config: Config<T>, values: I$1.Input<T>): void;
+}
+//#endregion
+//#region src/configs/DatabaseConfig.d.ts
+declare const DatabaseConfig: Config<any>;
+//#endregion
+//#region src/contracts/Auth.d.ts
+declare 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>;
+}
+declare namespace Auth {
+  type User = {
+    id: string;
+    email: string;
+    name: string;
+    image: string | null | undefined;
+    emailVerified: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+  };
+  type Session = {
+    redirect: boolean;
+    token: string;
+    url: string | undefined;
+    user: User;
+  };
+  type SignUpEmailResponse = {
+    redirect: boolean;
+    token: string;
+    url: string | undefined;
+    user: User;
+  };
+  namespace SignUpEmail {
+    type Input = {
+      email: string;
+      password: string;
+      name: string;
+      rememberMe?: boolean;
+      callbackURL?: string;
+      image?: string;
+    };
+    type Output = {
+      token: string | null;
+      user: User;
+    };
+  }
+  namespace SignInEmail {
+    type Input = {
+      email: string;
+      password: string;
+    };
+    type Output = {
+      redirect: boolean;
+      token: string;
+      url: string | undefined;
+      user: User;
+    };
+  }
+}
+//#endregion
+//#region src/contracts/Database.d.ts
+declare 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>>;
+}
+//#endregion
+//#region src/contracts/Query.d.ts
+type Query = typeof DrizzleQuery;
+//#endregion
+//#region src/interfaces/IApplication.d.ts
+interface IApplication {
+  bind<T>(serviceIdentifier: IService<T>): BindToFluentSyntax<T>;
+}
+//#endregion
+//#region src/interfaces/IContext.d.ts
+type Executor = {
+  <T extends Promise<{
+    default: ICommand$1<any, any>;
+  }>>(command: () => T, input: I$1.Input<Awaited<T>['default']>): Promise<I$1.Output<Awaited<T>['default']>>;
+  <IN extends StandardSchemaV1$1, OUT extends StandardSchemaV1$1>(command: ICommand$1<IN, OUT>, input: I$1.Input<IN>): Promise<I$1.Output<OUT>>;
+};
+type Prepare = {
+  <T extends Promise<{
+    default: ICommand$1<any, any>;
+  }>>(command: () => T, input: I$1.Input<Awaited<T>['default']>): {
+    input: I$1.Input<Awaited<T>['default']>;
+    execute: () => Promise<I$1.Output<Awaited<T>['default']>>;
+  };
+  <IN extends StandardSchemaV1$1, OUT extends StandardSchemaV1$1>(command: ICommand$1<IN, OUT>, input: I$1.Input<IN>): {
+    input: I$1.Input<IN>;
+    execute: () => Promise<I$1.Output<OUT>>;
+  };
+};
+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>;
+}
+//#endregion
+//#region src/interfaces/IContextCommand.d.ts
+interface IContextCommand<IN extends StandardSchemaV1$1 = StandardSchemaV1$1, OUT extends StandardSchemaV1$1 = StandardSchemaV1$1> extends IContext {
+  readonly command: ICommand$1<IN, OUT>;
+  readonly input: I$1.Output<IN>;
+}
+//#endregion
+//#region src/interfaces/IContextHandler.d.ts
+interface ICommandHandler<IN extends StandardSchemaV1$1, OUT extends StandardSchemaV1$1> {
+  (context: IContextCommand<IN, OUT>): Promise<I$1.Output<OUT>>;
+}
+//#endregion
+//#region src/interfaces/IMiddleware.d.ts
+type IMiddleware = (ctx: {
+  next: any;
+  container: Container;
+}) => any;
+//#endregion
+//#region src/services/BunGenerator.d.ts
+declare class BunGenerator extends Generator$1 {
+  get id(): string;
+  code(length: number): string;
+}
+//#endregion
+//#region src/services/PinoLogger.d.ts
+declare class PinoLogger implements Logger$1 {
+  private logger;
+  constructor(logger?: pino.Logger);
+  info(message: string): void;
+  warn(message: string): void;
+  error(error: any): void;
+  fork(name: string): Logger$1;
+}
+//#endregion
+//#region src/services/DizzleDatabase.d.ts
+declare class DizzleDatabase extends Database {
+  private readonly sql;
+  private readonly session;
+  private released;
+  private constructor();
+  static create(sql: Bun.SQL, contextData: ContextData$1): Promise<DizzleDatabase>;
+  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>>>;
+  update<T extends Table>(entity: T, id: string, values: Partial<InferInsertModel<T>>): Promise<InferSelectModel<T>>;
+  upsert<T extends Table>(entity: T, options: {
+    target: IndexColumn | IndexColumn[];
+    values: InferInsertModel<T>;
+  }): Promise<InferSelectModel<T>>;
+  findMany<T extends Table>(entity: T, options?: {
+    where?: SQL;
+    limit?: number;
+    offset?: number;
+    orderBy?: (PgColumn | SQL | SQL.Aliased)[];
+  }): Promise<InferSelectModel<T>[]>;
+  findOne<T extends Table>(entity: T, options?: {
+    where?: SQL;
+  }): Promise<InferSelectModel<T> | null>;
+  get<T extends Table>(entity: T, id: string): Promise<InferSelectModel<T>>;
+  delete<T extends Table>(entity: T, id: string): Promise<void>;
+  commit(): Promise<void>;
+}
+//#endregion
+//#region src/utils/SERVER_ERROR.d.ts
+declare namespace SERVER_ERROR {
+  function RESOURCE_ID_NOT_FOUND(resource: string, id: string): any;
+  function RESOURCE_NOT_FOUND(resource: string): any;
+  function BAD_REQUEST(type: string, args: Record<string, any>): any;
+  function RESOURCE_ID_ALREADY_EXISTS(resource: string, id: string): any;
+  function VALIDATION(...issues: IThrowable[]): any;
+  function SCHEMA_VALIDATION(issues: readonly StandardSchemaV1$2.Issue[]): any;
+  function UNEXPECTED(type: string, args: Record<string, any>): any;
+  const FORWARD: any;
+  function GET_ENTITY_NOT_FOUND<T extends Table>(entity: T, id: string): any;
+}
+//#endregion
+//#region src/context.d.ts
+declare class Context implements IContext {
+  private readonly container;
+  readonly db: Database;
+  readonly gen: Generator;
+  readonly logger: Logger;
+  constructor(container: IContainer, db: Database);
+  static create(contextData?: ContextData): Promise<Context>;
+  readonly Q: typeof DrizzleQuery;
+  execute: IContext["execute"];
+  prepare: IContext["prepare"];
+  get: <T>(service: IService<T>) => T;
+  getAsync: <T>(service: IService<T>) => Promise<T>;
+  [Symbol.dispose]: () => Promise<void>;
+}
+//#endregion
+//#region src/command.d.ts
+declare class Command<IN extends StandardSchemaV1, OUT extends StandardSchemaV1> implements ICommand<IN, OUT> {
+  readonly name: string;
+  readonly visibility: "PUBLIC" | "PROTECTED" | "PRIVATE";
+  input: IN;
+  output: OUT;
+  middlewares: IMiddleware[];
+  handler: ICommandHandler<IN, OUT>;
+  readonly "~type": "kunk:command";
+  private constructor();
+  private static create;
+  static PUBLIC: <IN_1 extends StandardSchemaV1 = StandardSchemaV1, OUT_1 extends StandardSchemaV1 = StandardSchemaV1>(setup: {
+    name: string;
+    input: IN_1;
+    output: OUT_1;
+    middlewares?: IMiddleware[];
+  }, handler: ICommandHandler<IN_1, OUT_1>) => Command<IN_1, OUT_1>;
+  static PROTECTED: <IN_1 extends StandardSchemaV1 = StandardSchemaV1, OUT_1 extends StandardSchemaV1 = StandardSchemaV1>(setup: {
+    name: string;
+    input: IN_1;
+    output: OUT_1;
+    middlewares?: IMiddleware[];
+  }, handler: ICommandHandler<IN_1, OUT_1>) => Command<IN_1, OUT_1>;
+  static PRIVATE: <IN_1 extends StandardSchemaV1 = StandardSchemaV1, OUT_1 extends StandardSchemaV1 = StandardSchemaV1>(setup: {
+    name: string;
+    input: IN_1;
+    output: OUT_1;
+    middlewares?: IMiddleware[];
+  }, handler: ICommandHandler<IN_1, OUT_1>) => Command<IN_1, OUT_1>;
+  internalCall(context: IContextCommand<IN, OUT>): Promise<I.Output<OUT>>;
+  call(context: IContextCommand<IN, OUT>): Promise<I.Output<OUT>>;
+}
+//#endregion
+//#region src/middleware.d.ts
+declare function middleware<T extends (...args: any[]) => any>(fn: T, middlewares: IMiddleware[]): T;
+//#endregion
+//#region src/server.d.ts
+declare const Server: Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+} & {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+} & {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {
+    200: Response;
+  };
+}>;
+declare function route<K extends string, CMD extends ICommand<any, any>>(path: K, commandImport: Promise<{
+  default: CMD;
+}>): Promise<Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {} & elysia.CreateEden<elysia_types0.JoinPath<"", K>, {
+  post: {
+    body: elysia_types0.IntersectIfObject<elysia.UnwrapBodySchema<CMD["input"], {}>, unknown>;
+    params: elysia_types0.IsNever<keyof elysia_types0.IntersectIfObject<elysia.ResolvePath<elysia_types0.JoinPath<"", K>>, unknown>> extends true ? elysia.ResolvePath<K> : elysia_types0.IntersectIfObject<elysia.ResolvePath<elysia_types0.JoinPath<"", K>>, unknown>;
+    query: unknown;
+    headers: any;
+    response: elysia.ComposeElysiaResponse<elysia_types0.IntersectIfObjectSchema<elysia.UnwrapRoute<{
+      body: CMD["input"];
+      response: CMD["output"];
+      headers: any;
+      detail: {
+        summary: string;
+      };
+      tags: string[];
+    }, {}, elysia_types0.JoinPath<"", K>>, {}>, ({
+      headers,
+      body
+    }: {
+      body: elysia_types0.IntersectIfObject<elysia.UnwrapBodySchema<CMD["input"], {}>, unknown> extends infer T_1 ? T_1 extends elysia_types0.IntersectIfObject<elysia.UnwrapBodySchema<CMD["input"], {}>, unknown> ? T_1 extends object ? { [K_2 in keyof T_1]: T_1[K_2] } : T_1 : never : never;
+      query: Record<string, string>;
+      params: undefined extends elysia_types0.IntersectIfObject<elysia.ResolvePath<elysia_types0.JoinPath<"", K>>, unknown> ? Record<string, string> : elysia_types0.IntersectIfObject<elysia.ResolvePath<elysia_types0.JoinPath<"", K>>, unknown> extends infer T_2 ? T_2 extends elysia_types0.IntersectIfObject<elysia.ResolvePath<elysia_types0.JoinPath<"", K>>, unknown> ? T_2 extends object ? { [K_3 in keyof T_2]: T_2[K_3] } : T_2 : never : never;
+      headers: any;
+      cookie: Record<string, elysia.Cookie<unknown>>;
+      server: elysia_universal_server0.Server | null;
+      redirect: elysia.redirect;
+      set: {
+        headers: elysia.HTTPHeaders;
+        status?: number | keyof elysia.StatusMap;
+        redirect?: string;
+        cookie?: Record<string, elysia_cookies0.ElysiaCookie>;
+      };
+      path: string;
+      route: string;
+      request: Request;
+      store: {};
+      status: {} extends elysia_types0.IntersectIfObject<CMD["output"] extends string | elysia_types0.FastAnySchema ? {
+        200: elysia.UnwrapSchema<CMD["output"], {}> extends infer A ? A extends File ? elysia.ElysiaFile | File : A : unknown;
+      } : CMD["output"] extends {
+        [x: number]: string | elysia_types0.FastAnySchema;
+      } ? { [k in keyof CMD["output"]]: elysia.UnwrapSchema<CMD["output"][k], {}> extends infer A_1 ? A_1 extends File ? elysia.ElysiaFile | File : A_1 : unknown } : unknown, unknown> ? <const Code extends number | keyof elysia.StatusMap, const T_3 = (Code extends 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 300 | 301 | 302 | 303 | 304 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 ? {
+        readonly 100: "Continue";
+        readonly 101: "Switching Protocols";
+        readonly 102: "Processing";
+        readonly 103: "Early Hints";
+        readonly 200: "OK";
+        readonly 201: "Created";
+        readonly 202: "Accepted";
+        readonly 203: "Non-Authoritative Information";
+        readonly 204: "No Content";
+        readonly 205: "Reset Content";
+        readonly 206: "Partial Content";
+        readonly 207: "Multi-Status";
+        readonly 208: "Already Reported";
+        readonly 300: "Multiple Choices";
+        readonly 301: "Moved Permanently";
+        readonly 302: "Found";
+        readonly 303: "See Other";
+        readonly 304: "Not Modified";
+        readonly 307: "Temporary Redirect";
+        readonly 308: "Permanent Redirect";
+        readonly 400: "Bad Request";
+        readonly 401: "Unauthorized";
+        readonly 402: "Payment Required";
+        readonly 403: "Forbidden";
+        readonly 404: "Not Found";
+        readonly 405: "Method Not Allowed";
+        readonly 406: "Not Acceptable";
+        readonly 407: "Proxy Authentication Required";
+        readonly 408: "Request Timeout";
+        readonly 409: "Conflict";
+        readonly 410: "Gone";
+        readonly 411: "Length Required";
+        readonly 412: "Precondition Failed";
+        readonly 413: "Payload Too Large";
+        readonly 414: "URI Too Long";
+        readonly 415: "Unsupported Media Type";
+        readonly 416: "Range Not Satisfiable";
+        readonly 417: "Expectation Failed";
+        readonly 418: "I'm a teapot";
+        readonly 420: "Enhance Your Calm";
+        readonly 421: "Misdirected Request";
+        readonly 422: "Unprocessable Content";
+        readonly 423: "Locked";
+        readonly 424: "Failed Dependency";
+        readonly 425: "Too Early";
+        readonly 426: "Upgrade Required";
+        readonly 428: "Precondition Required";
+        readonly 429: "Too Many Requests";
+        readonly 431: "Request Header Fields Too Large";
+        readonly 451: "Unavailable For Legal Reasons";
+        readonly 500: "Internal Server Error";
+        readonly 501: "Not Implemented";
+        readonly 502: "Bad Gateway";
+        readonly 503: "Service Unavailable";
+        readonly 504: "Gateway Timeout";
+        readonly 505: "HTTP Version Not Supported";
+        readonly 506: "Variant Also Negotiates";
+        readonly 507: "Insufficient Storage";
+        readonly 508: "Loop Detected";
+        readonly 510: "Not Extended";
+        readonly 511: "Network Authentication Required";
+      }[Code] : Code)>(code: Code, response?: T_3) => elysia.ElysiaCustomStatusResponse<Code, T_3, Code extends "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required" ? {
+        readonly Continue: 100;
+        readonly "Switching Protocols": 101;
+        readonly Processing: 102;
+        readonly "Early Hints": 103;
+        readonly OK: 200;
+        readonly Created: 201;
+        readonly Accepted: 202;
+        readonly "Non-Authoritative Information": 203;
+        readonly "No Content": 204;
+        readonly "Reset Content": 205;
+        readonly "Partial Content": 206;
+        readonly "Multi-Status": 207;
+        readonly "Already Reported": 208;
+        readonly "Multiple Choices": 300;
+        readonly "Moved Permanently": 301;
+        readonly Found: 302;
+        readonly "See Other": 303;
+        readonly "Not Modified": 304;
+        readonly "Temporary Redirect": 307;
+        readonly "Permanent Redirect": 308;
+        readonly "Bad Request": 400;
+        readonly Unauthorized: 401;
+        readonly "Payment Required": 402;
+        readonly Forbidden: 403;
+        readonly "Not Found": 404;
+        readonly "Method Not Allowed": 405;
+        readonly "Not Acceptable": 406;
+        readonly "Proxy Authentication Required": 407;
+        readonly "Request Timeout": 408;
+        readonly Conflict: 409;
+        readonly Gone: 410;
+        readonly "Length Required": 411;
+        readonly "Precondition Failed": 412;
+        readonly "Payload Too Large": 413;
+        readonly "URI Too Long": 414;
+        readonly "Unsupported Media Type": 415;
+        readonly "Range Not Satisfiable": 416;
+        readonly "Expectation Failed": 417;
+        readonly "I'm a teapot": 418;
+        readonly "Enhance Your Calm": 420;
+        readonly "Misdirected Request": 421;
+        readonly "Unprocessable Content": 422;
+        readonly Locked: 423;
+        readonly "Failed Dependency": 424;
+        readonly "Too Early": 425;
+        readonly "Upgrade Required": 426;
+        readonly "Precondition Required": 428;
+        readonly "Too Many Requests": 429;
+        readonly "Request Header Fields Too Large": 431;
+        readonly "Unavailable For Legal Reasons": 451;
+        readonly "Internal Server Error": 500;
+        readonly "Not Implemented": 501;
+        readonly "Bad Gateway": 502;
+        readonly "Service Unavailable": 503;
+        readonly "Gateway Timeout": 504;
+        readonly "HTTP Version Not Supported": 505;
+        readonly "Variant Also Negotiates": 506;
+        readonly "Insufficient Storage": 507;
+        readonly "Loop Detected": 508;
+        readonly "Not Extended": 510;
+        readonly "Network Authentication Required": 511;
+      }[Code] : Code> : elysia.SelectiveStatus<elysia_types0.IntersectIfObject<CMD["output"] extends string | elysia_types0.FastAnySchema ? {
+        200: elysia.UnwrapSchema<CMD["output"], {}> extends infer A ? A extends File ? elysia.ElysiaFile | File : A : unknown;
+      } : CMD["output"] extends {
+        [x: number]: string | elysia_types0.FastAnySchema;
+      } ? { [k in keyof CMD["output"]]: elysia.UnwrapSchema<CMD["output"][k], {}> extends infer A_1 ? A_1 extends File ? elysia.ElysiaFile | File : A_1 : unknown } : unknown, unknown>>;
+    }) => Promise<Response>, {}> extends infer T ? { [K_1 in keyof T]: T[K_1] } : never;
+  };
+}>, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}>>;
+//#endregion
+//#region src/registry.d.ts
+declare const registry: Container;
+declare function gen(): unknown;
+declare const Q: typeof DrizzleQuery;
+//#endregion
+export { Auth, BunGenerator, Command, Config, Context, ContextData, Database, DatabaseConfig, DizzleDatabase, DrizzleQuery, Generator, type I, IApplication, type ICommand, ICommandHandler, type IContainer, IContext, IContextCommand, type IError, IMiddleware, type IService, Logger, PinoLogger, Q, Query, SERVER_ERROR, Server, type StandardSchemaV1, Validator, gen, middleware, registry, route };

package/dist/index.mjs

@@ -0,0 +1 @@
+import{ContextData,Generator,Generator as Generator$1,Logger,Throwable,Validator}from"@kunk/api";import{eq,getTableUniqueName}from"drizzle-orm";import*as path from"path";import{T}from"@kunk/model";import pino from"pino";import{drizzle}from"drizzle-orm/bun-sql";import*as DrizzleQuery from"drizzle-orm/sql/expressions";import{Container}from"inversify";import openapi,{fromTypes}from"@elysiajs/openapi";import Elysia,{ValidationError}from"elysia";let SERVER_ERROR;(function(e){function t(e,t){return Throwable.create(`RESOURCE_ID_NOT_FOUND`,404,{resource:e,id:t})}e.RESOURCE_ID_NOT_FOUND=t;function n(e){return Throwable.create(`RESOURCE_NOT_FOUND`,404,{resource:e})}e.RESOURCE_NOT_FOUND=n;function r(e,t){return Throwable.create(e,400,t)}e.BAD_REQUEST=r;function a(e,t){return Throwable.create(`RESOURCE_ID_ALREADY_EXISTS`,400,{resource:e,id:t})}e.RESOURCE_ID_ALREADY_EXISTS=a;function o(...e){return Throwable.create(`VALIDATION_ERROR`,422,{issues:e})}e.VALIDATION=o;function c(e){return Throwable.create(`SCHEMA_VALIDATION_ERROR`,422,{issues:e})}e.SCHEMA_VALIDATION=c;function l(e,t){return Throwable.create(e,500,t)}e.UNEXPECTED=l,e.FORWARD=Throwable.forward;function u(e,t){return SERVER_ERROR.RESOURCE_ID_NOT_FOUND(getTableUniqueName(e),t)}e.GET_ENTITY_NOT_FOUND=u})(SERVER_ERROR||={});function interpolateEnvVars(e){if(typeof e==`string`)return e.replace(/\${([^:-]+)(?:-([^}]+))?}/g,(e,t,n)=>Bun.env[t]||n||``);if(typeof e==`object`&&e){let t=Array.isArray(e)?[]:{};for(let n in e)t[n]=interpolateEnvVars(e[n]);return t}return e}async function loadFromFile(e,t){let n={},r=path.resolve(process.cwd(),`./config/${e}.yaml`);await Bun.file(r).exists()&&(n=await import(r).then(e=>e.default?.[Bun.env.NODE_ENV||`local`]));let i=await t[`~standard`].validate(n);if(i.issues)throw SERVER_ERROR.SCHEMA_VALIDATION(i.issues);return interpolateEnvVars(i.value)}var Config=class e{constructor(e,t){this.schema=e,this.values=t}get(){return this.values}async set(e){let t=await this.schema[`~standard`].validate(e);if(t.issues)throw SERVER_ERROR.SCHEMA_VALIDATION(t.issues);this.values=t.value}static async create(t){let n=await loadFromFile(t.name,t.schema);return new e(t.schema,n)}static set(e,t){e.set(t)}};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)})});var Auth=class{},Database=class{},BunGenerator=class extends Generator$1{get id(){return Bun.randomUUIDv7()}code(e){return Bun.randomUUIDv7().replace(/-/g,``).slice(0,e)}};const rootLogger=pino({name:`app`,transport:{target:`pino-pretty`,options:{colorize:!0,translateTime:`SYS:standard`,ignore:`pid,hostname`}}});var PinoLogger=class e{constructor(e=rootLogger){this.logger=e}info(e){this.logger.info(e)}warn(e){this.logger.warn(e)}error(e){this.logger.error(e)}fork(t){return new e(this.logger.child({name:t}))}},DizzleDatabase=class e extends Database{released=!1;constructor(e,t){super(),this.sql=e,this.session=t}static async create(t,n){let r=await t.reserve();return n.tenantId&&await r`SELECT set_config('app.tenant_id', ${n.tenantId}, false);`,new e(drizzle({client:r}),r)}async create(e,t){let n=e,r=await this.sql.insert(n).values(t).returning(),i=Array.isArray(t)?t.length:1;if(r.length!==i)throw SERVER_ERROR.UNEXPECTED(`FAILED_TO_INSERT_ENTITY`,{});return Array.isArray(t)?r:r[0]}async update(e,t,n){let r=e,[i]=await this.sql.update(r).set(n).where(eq(r.id,t)).returning();if(!i)throw SERVER_ERROR.UNEXPECTED(`FAILED_TO_UPDATE_ENTITY`,{});return i}async upsert(e,t){let n=e,[r]=await this.sql.insert(n).values(t.values).onConflictDoUpdate({target:t.target,set:t.values}).returning();if(!r)throw SERVER_ERROR.UNEXPECTED(`FAILED_TO_UPSERT_ENTITY`,{});return r}async findMany(e,t){let n=e,r=await this.sql.select().from(n).where(t?.where).limit(t?.limit??1e3).offset(t?.offset??0).orderBy(...t?.orderBy??[]).execute();if(!r)throw SERVER_ERROR.UNEXPECTED(`FAILED_TO_GET_MANY_ENTITIES`,{});return r}async findOne(e,t){let n=e,[r]=await this.sql.select().from(n).where(t?.where).limit(1).execute();return r||null}async get(e,t){let n=e,[r]=await this.sql.select().from(n).where(eq(n.id,t)).limit(1).execute();if(!r)throw SERVER_ERROR.GET_ENTITY_NOT_FOUND(n,t);return r}async delete(e,t){let n=e;await this.sql.delete(n).where(eq(n.id,t))}async commit(){this.released||(this.released=!0,this.session.release())}};const registry=new Container({defaultScope:`Singleton`});function gen(){return registry.get(Generator$1)}const Q=DrizzleQuery;var Context=class n{gen;logger;constructor(e,n){this.container=e,this.db=n,this.gen=e.get(Generator),this.logger=e.get(Logger)}static async create(t={}){let r=new Container({defaultScope:`Singleton`,parent:registry});return r.bind(ContextData).toConstantValue(t),new n(r,await r.getAsync(Database))}Q=DrizzleQuery;execute=async(e,t)=>{let n=e;n instanceof Function&&(n=e()),n instanceof Promise&&(n=await n.then(e=>e.default));let r=t;if(n.input){let e=await n.input[`~standard`].validate(t);if(e.issues)throw SERVER_ERROR.SCHEMA_VALIDATION(e.issues);r=e.value}let i={...this,command:n,input:r},a=null;try{return await(()=>n.call(i))(i,this)}catch(e){throw a=SERVER_ERROR.FORWARD(e),a}};prepare=(e,t)=>({input:t,execute:()=>this.execute(e,t)});get=e=>this.container.get(e);getAsync=async e=>await this.container.getAsync(e);[Symbol.dispose]=async()=>{await this.db.commit()}};function middleware(e,t){return t.reduceRight((e,t)=>(n=>t({...n,next:e})),e)}var Command=class e{"~type"=`kunk:command`;constructor(e,t,n,r,i,a){this.name=e,this.visibility=t,this.input=n,this.output=r,this.middlewares=i,this.handler=a}static create=t=>(n,r)=>new e(n.name,t,n.input,n.output,n.middlewares||[],r);static PUBLIC=this.create(`PUBLIC`);static PROTECTED=this.create(`PROTECTED`);static PRIVATE=this.create(`PRIVATE`);async internalCall(e){if(!this.handler)throw SERVER_ERROR.UNEXPECTED(`HANDLER_NOT_SET`,{command:this.name});return this.handler(e)}async call(e){return middleware(()=>this.internalCall(e),this.middlewares)(e)}};registry.bind(Logger).to(PinoLogger),registry.bind(Generator).to(BunGenerator),registry.bind(Bun.SQL).toDynamicValue(()=>{let e=DatabaseConfig.get();return new Bun.SQL({url:e.uri,max:e.maxPoolSize,idleTimeout:e.idleTimeout,connectionTimeout:e.connectionTimeout})}).inSingletonScope(),registry.bind(Database).toDynamicValue(async t=>await DizzleDatabase.create(t.get(Bun.SQL),t.get(ContextData))).inRequestScope();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:e})=>Throwable.is(e)?Response.json(e):e instanceof T.ModelError?Response.json(Throwable.forward(e)):e instanceof ValidationError||e instanceof Error?Response.json(e):Response.json(Throwable.forward(e)));async function route(e,t){let n=e.split(`/`),r=n.slice(0,-1).join(`.`),i=n.pop(),a=(await t).default,o=a.input?.type===`void`?null:a.input,s=a.output?.type===`void`?null:a.output;return console.info(`command loaded:`,e),new Elysia().post(e,async({headers:e,body:t})=>{let n=e[`x-tenant-id`];using r=await Context.create({tenantId:n});let i=await r.execute(a,t);return Response.json(i)},{body:o,response:s,headers:T.object({"x-tenant-id":T.string().default(`{{tenant_id}}`).optional()}),detail:{summary:i},tags:[r]})}export{Auth,BunGenerator,Command,Config,Context,ContextData,Database,DatabaseConfig,DizzleDatabase,DrizzleQuery,Generator,Logger,PinoLogger,Q,SERVER_ERROR,Server,Validator,gen,middleware,registry,route};

package/package.json

@@ -1,15 +1,25 @@
 {
   "name": "@kunk/server",
-  "version": "3.0.2",
+  "version": "3.0.5",
   "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.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "dependencies": {
     "@kunk/api": "3.0.0",
     "@kunk/tsconfig": "3.0.0",

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

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

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,57 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import type { I, ICommand, ICommandHandler, IContextCommand, IMiddleware } 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),
-  })
-})