@kaito-http/core 3.0.0-beta.1 → 3.0.0-beta.3

package/dist/index.js

@@ -0,0 +1,389 @@
+// src/error.ts
+var WrappedError = class _WrappedError extends Error {
+  constructor(data) {
+    super("Something was thrown, but it was not an instance of Error, so a WrappedError was created.");
+    this.data = data;
+  }
+  static maybe(maybeError) {
+    if (maybeError instanceof Error) {
+      return maybeError;
+    }
+    return _WrappedError.from(maybeError);
+  }
+  static from(data) {
+    return new _WrappedError(data);
+  }
+};
+var KaitoError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+
+// src/req.ts
+import { TLSSocket } from "node:tls";
+
+// src/util.ts
+import { parse as parseContentType } from "content-type";
+import { Readable } from "node:stream";
+import { json } from "node:stream/consumers";
+import getRawBody from "raw-body";
+
+// src/router.ts
+import fmw from "find-my-way";
+
+// src/res.ts
+import { serialize } from "cookie";
+var KaitoResponse = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  /**
+   * Send a response
+   * @param key The key of the header
+   * @param value The value of the header
+   * @returns The response object
+   */
+  header(key, value) {
+    this.raw.setHeader(key, value);
+    return this;
+  }
+  /**
+   * Set the status code of the response
+   * @param code The status code
+   * @returns The response object
+   */
+  status(code) {
+    this.raw.statusCode = code;
+    return this;
+  }
+  /**
+   * Set a cookie
+   * @param name The name of the cookie
+   * @param value The value of the cookie
+   * @param options The options for the cookie
+   * @returns The response object
+   */
+  cookie(name, value, options) {
+    this.raw.setHeader("Set-Cookie", serialize(name, value, options));
+    return this;
+  }
+  /**
+   * Send a JSON APIResponse body
+   * @param data The data to send
+   * @returns The response object
+   */
+  json(data) {
+    const json2 = JSON.stringify(data);
+    this.raw.setHeader("Content-Type", "application/json");
+    this.raw.setHeader("Content-Length", Buffer.byteLength(json2));
+    this.raw.end(json2);
+    return this;
+  }
+};
+
+// src/router.ts
+var getSend = (res) => (status, response) => {
+  if (res.raw.headersSent) {
+    return;
+  }
+  res.status(status).json(response);
+};
+var Router = class _Router {
+  routerOptions;
+  routes;
+  static create = () => new _Router([], {
+    through: async (context) => context
+  });
+  static parseQuery(schema, url) {
+    if (!schema) {
+      return {};
+    }
+    const result = {};
+    for (const [key, value] of url.searchParams.entries()) {
+      const parsable = schema[key];
+      if (!parsable) {
+        continue;
+      }
+      const parsed = parsable.parse(value);
+      result[key] = parsed;
+    }
+    return result;
+  }
+  static async handle(server, route, options) {
+    const send = getSend(options.res);
+    try {
+      const rootCtx = await server.getContext(options.req, options.res);
+      const ctx = await route.through(rootCtx);
+      const body = await route.body?.parse(await getBody(options.req)) ?? void 0;
+      const query = _Router.parseQuery(route.query, options.req.url);
+      const result = await route.run({
+        ctx,
+        body,
+        query,
+        params: options.params
+      });
+      if (options.res.raw.headersSent) {
+        return {
+          success: true,
+          data: result
+        };
+      }
+      send(200, {
+        success: true,
+        data: result,
+        message: "OK"
+      });
+      return {
+        success: true,
+        data: result
+      };
+    } catch (e) {
+      const error = WrappedError.maybe(e);
+      if (error instanceof KaitoError) {
+        send(error.status, {
+          success: false,
+          data: null,
+          message: error.message
+        });
+        return;
+      }
+      const { status, message } = await server.onError({ error, req: options.req, res: options.res }).catch(() => ({ status: 500, message: "Internal Server Error" }));
+      send(status, {
+        success: false,
+        data: null,
+        message
+      });
+      return {
+        success: false,
+        data: { status, message }
+      };
+    }
+  }
+  constructor(routes, options) {
+    this.routerOptions = options;
+    this.routes = new Set(routes);
+  }
+  /**
+   * Adds a new route to the router
+   * @deprecated Use the method-specific methods instead
+   */
+  add = (method, path, route) => {
+    const merged = {
+      ...typeof route === "object" ? route : { run: route },
+      method,
+      path,
+      through: this.routerOptions.through
+    };
+    return new _Router([...this.routes, merged], this.routerOptions);
+  };
+  merge = (pathPrefix, other) => {
+    const newRoutes = [...other.routes].map((route) => ({
+      ...route,
+      path: `${pathPrefix}${route.path}`
+    }));
+    return new _Router(
+      [...this.routes, ...newRoutes],
+      this.routerOptions
+    );
+  };
+  // Allow for any server context to be passed
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  freeze = (server) => {
+    const instance = fmw({
+      ignoreTrailingSlash: true,
+      async defaultRoute(req, serverResponse) {
+        const res = new KaitoResponse(serverResponse);
+        const message = `Cannot ${req.method} ${req.url ?? "/"}`;
+        getSend(res)(404, {
+          success: false,
+          data: null,
+          message
+        });
+        return {
+          success: false,
+          data: { status: 404, message }
+        };
+      }
+    });
+    for (const route of this.routes) {
+      const handler = async (incomingMessage, serverResponse, params) => {
+        const req = new KaitoRequest(incomingMessage);
+        const res = new KaitoResponse(serverResponse);
+        return _Router.handle(server, route, {
+          params,
+          req,
+          res
+        });
+      };
+      if (route.method === "*") {
+        instance.all(route.path, handler);
+        continue;
+      }
+      instance.on(route.method, route.path, handler);
+    }
+    return instance;
+  };
+  method = (method) => (path, route) => {
+    return this.add(method, path, route);
+  };
+  get = this.method("GET");
+  post = this.method("POST");
+  put = this.method("PUT");
+  patch = this.method("PATCH");
+  delete = this.method("DELETE");
+  head = this.method("HEAD");
+  options = this.method("OPTIONS");
+  through = (transform) => new _Router(this.routes, {
+    through: async (context) => {
+      const fromCurrentRouter = await this.routerOptions.through(context);
+      return transform(fromCurrentRouter);
+    }
+  });
+};
+
+// src/util.ts
+function createGetContext(callback) {
+  return callback;
+}
+function createUtilities(getContext) {
+  return {
+    getContext,
+    router: () => Router.create()
+  };
+}
+function getLastEntryInMultiHeaderValue(headerValue) {
+  const normalized = Array.isArray(headerValue) ? headerValue.join(",") : headerValue;
+  const lastIndex = normalized.lastIndexOf(",");
+  return lastIndex === -1 ? normalized.trim() : normalized.slice(lastIndex + 1).trim();
+}
+async function getBody(req) {
+  if (!req.headers["content-type"]) {
+    return null;
+  }
+  const buffer = await getRawBody(req.raw);
+  const { type } = parseContentType(req.headers["content-type"]);
+  switch (type) {
+    case "application/json": {
+      return json(Readable.from(buffer));
+    }
+    default: {
+      if (process.env.NODE_ENV === "development") {
+        console.warn("[kaito] Unsupported content type:", type);
+        console.warn("[kaito] This message is only shown in development mode.");
+      }
+      return null;
+    }
+  }
+}
+
+// src/req.ts
+var KaitoRequest = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  _url = null;
+  /**
+   * The full URL of the request, including the protocol, hostname, and path.
+   * Note: does not include the query string or hash
+   */
+  get fullURL() {
+    return `${this.protocol}://${this.hostname}${this.raw.url ?? ""}`;
+  }
+  /**
+   * A new URL instance for the full URL of the request.
+   */
+  get url() {
+    if (this._url) {
+      return this._url;
+    }
+    this._url = new URL(this.fullURL);
+    return this._url;
+  }
+  /**
+   * The HTTP method of the request.
+   */
+  get method() {
+    if (!this.raw.method) {
+      throw new Error("Request method is not defined, somehow...");
+    }
+    return this.raw.method;
+  }
+  /**
+   * The protocol of the request, either `http` or `https`.
+   */
+  get protocol() {
+    if (this.raw.socket instanceof TLSSocket) {
+      return this.raw.socket.encrypted ? "https" : "http";
+    }
+    return "http";
+  }
+  /**
+   * The request headers
+   */
+  get headers() {
+    return this.raw.headers;
+  }
+  /**
+   * The hostname of the request.
+   */
+  get hostname() {
+    return this.raw.headers.host ?? getLastEntryInMultiHeaderValue(this.raw.headers[":authority"] ?? []);
+  }
+};
+
+// src/server.ts
+import * as http from "node:http";
+function createFMWServer(config) {
+  const router = config.router.freeze(config);
+  const rawRoutes = config.rawRoutes ?? {};
+  for (const method in rawRoutes) {
+    if (!Object.prototype.hasOwnProperty.call(rawRoutes, method)) {
+      continue;
+    }
+    const routes = rawRoutes[method];
+    if (!routes || routes.length === 0) {
+      continue;
+    }
+    for (const route of routes) {
+      if (method === "*") {
+        router.all(route.path, route.handler);
+        continue;
+      }
+      router[method.toLowerCase()](route.path, route.handler);
+    }
+  }
+  const server = http.createServer(async (req, res) => {
+    let before;
+    if (config.before) {
+      before = await config.before(req, res);
+    } else {
+      before = void 0;
+    }
+    if (res.headersSent) {
+      return;
+    }
+    const result = await router.lookup(req, res);
+    if ("after" in config && config.after) {
+      await config.after(before, result);
+    }
+  });
+  return { server, fmw: router };
+}
+function createServer2(config) {
+  return createFMWServer(config).server;
+}
+export {
+  KaitoError,
+  KaitoRequest,
+  KaitoResponse,
+  Router,
+  WrappedError,
+  createFMWServer,
+  createGetContext,
+  createServer2 as createServer,
+  createUtilities,
+  getBody,
+  getLastEntryInMultiHeaderValue
+};

package/package.json

@@ -1,35 +1,38 @@
 {
   "name": "@kaito-http/core",
-  "version": "3.0.0-beta.1",
+  "version": "3.0.0-beta.3",
+  "type": "module",
+  "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
+  "scripts": {
+    "build": "tsup"
+  },
   "exports": {
-    ".": "./dist/kaito-http-core.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    ".": "./dist/index.js"
   },
+  "homepage": "https://github.com/kaito-http/kaito",
   "repository": "https://github.com/kaito-http/kaito",
-  "author": "Alistair Smith <hi@alistair.sh>",
+  "keywords": [
+    "typescript",
+    "http",
+    "framework"
+  ],
   "license": "MIT",
-  "type": "module",
   "devDependencies": {
-    "@types/content-type": "^1.1.5",
-    "@types/cookie": "^0.5.1",
-    "@types/node": "^18.11.9",
+    "@types/content-type": "^1.1.8",
+    "@types/cookie": "^0.6.0",
+    "@types/node": "^22.7.4",
     "typescript": "^5.6.2"
   },
   "files": [
     "package.json",
-    "readme.md",
+    "README.md",
     "dist"
   ],
   "bugs": {
     "url": "https://github.com/kaito-http/kaito/issues"
   },
-  "homepage": "https://github.com/kaito-http/kaito",
-  "keywords": [
-    "typescript",
-    "http",
-    "framework"
-  ],
   "dependencies": {
     "content-type": "^1.0.5",
     "cookie": "^0.6.0",

package/dist/declarations/src/error.d.ts

@@ -1,10 +0,0 @@
-export declare class WrappedError<T> extends Error {
-    readonly data: T;
-    static maybe<T>(maybeError: T): (T & Error) | WrappedError<T>;
-    static from<T>(data: T): WrappedError<T>;
-    private constructor();
-}
-export declare class KaitoError extends Error {
-    readonly status: number;
-    constructor(status: number, message: string);
-}

package/dist/declarations/src/index.d.ts

@@ -1,8 +0,0 @@
-export type { HTTPMethod } from 'find-my-way';
-export * from "./error.js";
-export * from "./req.js";
-export * from "./res.js";
-export * from "./route.js";
-export * from "./router.js";
-export * from "./server.js";
-export * from "./util.js";

package/dist/declarations/src/req.d.ts

@@ -1,32 +0,0 @@
-import type { HTTPMethod } from 'find-my-way';
-import type { IncomingMessage } from 'node:http';
-export declare class KaitoRequest {
-    readonly raw: IncomingMessage;
-    private _url;
-    constructor(raw: IncomingMessage);
-    /**
-     * The full URL of the request, including the protocol, hostname, and path.
-     * Note: does not include the query string or hash
-     */
-    get fullURL(): string;
-    /**
-     * A new URL instance for the full URL of the request.
-     */
-    get url(): URL;
-    /**
-     * The HTTP method of the request.
-     */
-    get method(): HTTPMethod;
-    /**
-     * The protocol of the request, either `http` or `https`.
-     */
-    get protocol(): 'http' | 'https';
-    /**
-     * The request headers
-     */
-    get headers(): import("http").IncomingHttpHeaders;
-    /**
-     * The hostname of the request.
-     */
-    get hostname(): string;
-}

package/dist/declarations/src/res.d.ts

@@ -1,45 +0,0 @@
-import type { ServerResponse } from 'node:http';
-import type { CookieSerializeOptions } from 'cookie';
-export type ErroredAPIResponse = {
-    success: false;
-    data: null;
-    message: string;
-};
-export type SuccessfulAPIResponse<T> = {
-    success: true;
-    data: T;
-    message: 'OK';
-};
-export type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
-export type AnyResponse = APIResponse<unknown>;
-export declare class KaitoResponse<T = unknown> {
-    readonly raw: ServerResponse;
-    constructor(raw: ServerResponse);
-    /**
-     * Send a response
-     * @param key The key of the header
-     * @param value The value of the header
-     * @returns The response object
-     */
-    header(key: string, value: string | readonly string[]): this;
-    /**
-     * Set the status code of the response
-     * @param code The status code
-     * @returns The response object
-     */
-    status(code: number): this;
-    /**
-     * Set a cookie
-     * @param name The name of the cookie
-     * @param value The value of the cookie
-     * @param options The options for the cookie
-     * @returns The response object
-     */
-    cookie(name: string, value: string, options: CookieSerializeOptions): this;
-    /**
-     * Send a JSON APIResponse body
-     * @param data The data to send
-     * @returns The response object
-     */
-    json(data: APIResponse<T>): this;
-}

package/dist/declarations/src/route.d.ts

@@ -1,22 +0,0 @@
-import type { ExtractRouteParams, KaitoMethod, Parsable } from "./util.js";
-export type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
-    ctx: Context;
-    body: BodyOutput;
-    query: QueryOutput;
-    params: ExtractRouteParams<Path>;
-};
-export type AnyQueryDefinition = Record<string, Parsable<any>>;
-export type InferQuery<T extends AnyQueryDefinition> = {
-    [Key in keyof T]: InferParsable<T[Key]>;
-};
-export type InferParsable<T> = T extends Parsable<infer U> ? U : never;
-export type RouteRunner<Result, Path extends string, Context, QueryOutput, BodyOutput> = (args: RouteArgument<Path, Context, QueryOutput, BodyOutput>) => Promise<Result>;
-export type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, BodyOutput> = {
-    through: (context: ContextFrom) => Promise<ContextTo>;
-    body?: Parsable<BodyOutput>;
-    query?: Query;
-    path: Path;
-    method: Method;
-    run(arg: RouteArgument<Path, ContextTo, InferQuery<Query>, BodyOutput>): Promise<Result>;
-};
-export type AnyRoute<FromContext = any, ToContext = any> = Route<FromContext, ToContext, any, any, any, AnyQueryDefinition, any>;

package/dist/declarations/src/router.d.ts

@@ -1,34 +0,0 @@
-import fmw from 'find-my-way';
-import type { AnyQueryDefinition, AnyRoute, Route } from "./route.js";
-import type { ServerConfig } from "./server.js";
-import type { KaitoMethod } from "./util.js";
-type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput> ? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput> : never;
-type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
-export type RouterOptions<ContextFrom, ContextTo> = {
-    through: (context: ContextFrom) => Promise<ContextTo>;
-};
-export declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
-    private readonly routerOptions;
-    readonly routes: Set<R>;
-    static create: <Context>() => Router<Context, Context, never>;
-    private static parseQuery;
-    private static handle;
-    constructor(routes: Iterable<R>, options: RouterOptions<ContextFrom, ContextTo>);
-    /**
-     * Adds a new route to the router
-     * @deprecated Use the method-specific methods instead
-     */
-    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, BodyOutput = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput>>;
-    readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends AnyRoute>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, OtherRoutes>, AnyRoute>>;
-    freeze: (server: ServerConfig<ContextFrom, any>) => fmw.Instance<fmw.HTTPVersion.V1>;
-    private readonly method;
-    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, 'GET', Query, BodyOutput>, 'body' | 'path' | 'method' | 'through'>) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, 'GET', Query, BodyOutput>>;
-    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput>>;
-    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput>>;
-    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput>>;
-    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput>>;
-    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput>>;
-    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput>>;
-    through: <NextContext>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
-}
-export {};

package/dist/declarations/src/server.d.ts

@@ -1,45 +0,0 @@
-import * as http from 'node:http';
-import type { KaitoError } from "./error.js";
-import type { KaitoRequest } from "./req.js";
-import type { KaitoResponse } from "./res.js";
-import type { Router } from "./router.js";
-import type { GetContext, KaitoMethod } from "./util.js";
-export type Before<BeforeAfterContext> = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<BeforeAfterContext>;
-export type HandlerResult = {
-    success: true;
-    data: unknown;
-} | {
-    success: false;
-    data: {
-        status: number;
-        message: string;
-    };
-};
-export type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
-export type ServerConfigWithBefore<BeforeAfterContext> = {
-    before: Before<BeforeAfterContext>;
-    after?: After<BeforeAfterContext>;
-} | {
-    before?: undefined;
-};
-export type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
-    router: Router<ContextFrom, unknown, any>;
-    getContext: GetContext<ContextFrom>;
-    rawRoutes?: Partial<Record<KaitoMethod, Array<{
-        path: string;
-        handler: (request: http.IncomingMessage, response: http.ServerResponse) => unknown;
-    }>>>;
-    onError(arg: {
-        error: Error;
-        req: KaitoRequest;
-        res: KaitoResponse;
-    }): Promise<KaitoError | {
-        status: number;
-        message: string;
-    }>;
-};
-export declare function createFMWServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): {
-    readonly server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    readonly fmw: import("find-my-way").Instance<import("find-my-way").HTTPVersion.V1>;
-};
-export declare function createServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/dist/declarations/src/util.d.ts

@@ -1,48 +0,0 @@
-import type { HTTPMethod } from 'find-my-way';
-import type { KaitoRequest } from "./req.js";
-import type { KaitoResponse } from "./res.js";
-import { Router } from "./router.js";
-export type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
-    [k in Param | keyof ExtractRouteParams<Rest>]: string;
-} : T extends `${string}:${infer Param}` ? {
-    [k in Param]: string;
-} : {};
-export type KaitoMethod = HTTPMethod | '*';
-export type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
-/**
- * @deprecated use `createUtilities` instead
- */
-export declare function createGetContext<Context>(callback: GetContext<Context>): GetContext<Context>;
-/**
- * A helper function to create typed necessary functions
- *
- * @example
- * ```ts
- * const {router, getContext} = createUtilities(async (req, res) => {
- *   // Return context here
- * })
- *
- * const app = router().get('/', async () => "hello");
- *
- * const server = createServer({
- *   router: app,
- *   getContext,
- *   // ...
- * });
- * ```
- */
-export declare function createUtilities<Context>(getContext: GetContext<Context>): {
-    getContext: GetContext<Context>;
-    router: () => Router<Context, Context, never>;
-};
-export type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
-export declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
-export interface Parsable<T> {
-    parse: (value: unknown) => T;
-}
-export type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
-export type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
-export type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
-export type Values<T> = T[keyof T];
-export type NoEmpty<T> = [keyof T] extends [never] ? never : T;
-export declare function getBody(req: KaitoRequest): Promise<unknown>;

package/dist/kaito-http-core.d.ts

@@ -1,2 +0,0 @@
-export * from "./declarations/src/index";
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2FpdG8taHR0cC1jb3JlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuL2RlY2xhcmF0aW9ucy9zcmMvaW5kZXguZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSJ9

package/dist/kaito-http-core.js

@@ -1,534 +0,0 @@
-import { TLSSocket } from 'node:tls';
-import { parse } from 'content-type';
-import { Readable } from 'node:stream';
-import { json } from 'node:stream/consumers';
-import getRawBody from 'raw-body';
-import fmw from 'find-my-way';
-import { serialize } from 'cookie';
-import * as http from 'node:http';
-
-class WrappedError extends Error {
-  static maybe(maybeError) {
-    if (maybeError instanceof Error) {
-      return maybeError;
-    }
-    return WrappedError.from(maybeError);
-  }
-  static from(data) {
-    return new WrappedError(data);
-  }
-  constructor(data) {
-    super('Something was thrown, but it was not an instance of Error, so a WrappedError was created.');
-    this.data = data;
-  }
-}
-class KaitoError extends Error {
-  constructor(status, message) {
-    super(message);
-    this.status = status;
-  }
-}
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-      args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-      _next(undefined);
-    });
-  };
-}
-
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-  return keys;
-}
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-  return target;
-}
-
-class KaitoResponse {
-  constructor(raw) {
-    this.raw = raw;
-  }
-
-  /**
-   * Send a response
-   * @param key The key of the header
-   * @param value The value of the header
-   * @returns The response object
-   */
-  header(key, value) {
-    this.raw.setHeader(key, value);
-    return this;
-  }
-
-  /**
-   * Set the status code of the response
-   * @param code The status code
-   * @returns The response object
-   */
-  status(code) {
-    this.raw.statusCode = code;
-    return this;
-  }
-
-  /**
-   * Set a cookie
-   * @param name The name of the cookie
-   * @param value The value of the cookie
-   * @param options The options for the cookie
-   * @returns The response object
-   */
-  cookie(name, value, options) {
-    this.raw.setHeader('Set-Cookie', serialize(name, value, options));
-    return this;
-  }
-
-  /**
-   * Send a JSON APIResponse body
-   * @param data The data to send
-   * @returns The response object
-   */
-  json(data) {
-    var json = JSON.stringify(data);
-    this.raw.setHeader('Content-Type', 'application/json');
-    this.raw.setHeader('Content-Length', Buffer.byteLength(json));
-    this.raw.end(json);
-    return this;
-  }
-}
-
-var _Router;
-var getSend = res => (status, response) => {
-  if (res.raw.headersSent) {
-    return;
-  }
-  res.status(status).json(response);
-};
-class Router {
-  static parseQuery(schema, url) {
-    if (!schema) {
-      return {};
-    }
-    var result = {};
-    for (var [key, value] of url.searchParams.entries()) {
-      var parsable = schema[key];
-      if (!parsable) {
-        continue;
-      }
-      var parsed = parsable.parse(value);
-      result[key] = parsed;
-    }
-    return result;
-  }
-  static handle(
-  // Allow for any server to be passed
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  server, route, options) {
-    return _asyncToGenerator(function* () {
-      var send = getSend(options.res);
-      try {
-        var _yield$route$body$par, _route$body;
-        var rootCtx = yield server.getContext(options.req, options.res);
-        var ctx = yield route.through(rootCtx);
-        var body = (_yield$route$body$par = yield (_route$body = route.body) === null || _route$body === void 0 ? void 0 : _route$body.parse(yield getBody(options.req))) !== null && _yield$route$body$par !== void 0 ? _yield$route$body$par : undefined;
-        var query = Router.parseQuery(route.query, options.req.url);
-        var result = yield route.run({
-          ctx,
-          body,
-          query,
-          params: options.params
-        });
-        if (options.res.raw.headersSent) {
-          return {
-            success: true,
-            data: result
-          };
-        }
-        send(200, {
-          success: true,
-          data: result,
-          message: 'OK'
-        });
-        return {
-          success: true,
-          data: result
-        };
-      } catch (e) {
-        var error = WrappedError.maybe(e);
-        if (error instanceof KaitoError) {
-          send(error.status, {
-            success: false,
-            data: null,
-            message: error.message
-          });
-          return;
-        }
-        var {
-          status,
-          message
-        } = yield server.onError({
-          error,
-          req: options.req,
-          res: options.res
-        }).catch(() => ({
-          status: 500,
-          message: 'Internal Server Error'
-        }));
-        send(status, {
-          success: false,
-          data: null,
-          message
-        });
-        return {
-          success: false,
-          data: {
-            status,
-            message
-          }
-        };
-      }
-    })();
-  }
-  constructor(routes, options) {
-    var _this = this;
-    /**
-     * Adds a new route to the router
-     * @deprecated Use the method-specific methods instead
-     */
-    _defineProperty(this, "add", (method, path, route) => {
-      var merged = _objectSpread2(_objectSpread2({}, typeof route === 'object' ? route : {
-        run: route
-      }), {}, {
-        method,
-        path,
-        through: this.routerOptions.through
-      });
-      return new Router([...this.routes, merged], this.routerOptions);
-    });
-    _defineProperty(this, "merge", (pathPrefix, other) => {
-      var newRoutes = [...other.routes].map(route => _objectSpread2(_objectSpread2({}, route), {}, {
-        path: "".concat(pathPrefix).concat(route.path)
-      }));
-      return new Router([...this.routes, ...newRoutes], this.routerOptions);
-    });
-    // Allow for any server context to be passed
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    _defineProperty(this, "freeze", server => {
-      var instance = fmw({
-        ignoreTrailingSlash: true,
-        defaultRoute(req, serverResponse) {
-          return _asyncToGenerator(function* () {
-            var _req$url;
-            var res = new KaitoResponse(serverResponse);
-            var message = "Cannot ".concat(req.method, " ").concat((_req$url = req.url) !== null && _req$url !== void 0 ? _req$url : '/');
-            getSend(res)(404, {
-              success: false,
-              data: null,
-              message
-            });
-            return {
-              success: false,
-              data: {
-                status: 404,
-                message
-              }
-            };
-          })();
-        }
-      });
-      var _loop = function _loop(_route) {
-        var handler = /*#__PURE__*/function () {
-          var _ref = _asyncToGenerator(function* (incomingMessage, serverResponse, params) {
-            var req = new KaitoRequest(incomingMessage);
-            var res = new KaitoResponse(serverResponse);
-            return Router.handle(server, _route, {
-              params,
-              req,
-              res
-            });
-          });
-          return function handler(_x, _x2, _x3) {
-            return _ref.apply(this, arguments);
-          };
-        }();
-        if (_route.method === '*') {
-          instance.all(_route.path, handler);
-          return 1; // continue
-        }
-        instance.on(_route.method, _route.path, handler);
-      };
-      for (var _route2 of this.routes) {
-        if (_loop(_route2)) continue;
-      }
-      return instance;
-    });
-    _defineProperty(this, "method", method => (path, route) => {
-      return this.add(method, path, route);
-    });
-    _defineProperty(this, "get", this.method('GET'));
-    _defineProperty(this, "post", this.method('POST'));
-    _defineProperty(this, "put", this.method('PUT'));
-    _defineProperty(this, "patch", this.method('PATCH'));
-    _defineProperty(this, "delete", this.method('DELETE'));
-    _defineProperty(this, "head", this.method('HEAD'));
-    _defineProperty(this, "options", this.method('OPTIONS'));
-    _defineProperty(this, "through", transform => new Router(this.routes, {
-      through: function () {
-        var _through = _asyncToGenerator(function* (context) {
-          var fromCurrentRouter = yield _this.routerOptions.through(context);
-          return transform(fromCurrentRouter);
-        });
-        function through(_x4) {
-          return _through.apply(this, arguments);
-        }
-        return through;
-      }()
-    }));
-    this.routerOptions = options;
-    this.routes = new Set(routes);
-  }
-}
-_Router = Router;
-_defineProperty(Router, "create", () => new _Router([], {
-  through: function () {
-    var _through2 = _asyncToGenerator(function* (context) {
-      return context;
-    });
-    function through(_x5) {
-      return _through2.apply(this, arguments);
-    }
-    return through;
-  }()
-}));
-
-/**
- * @deprecated use `createUtilities` instead
- */
-function createGetContext(callback) {
-  return callback;
-}
-
-/**
- * A helper function to create typed necessary functions
- *
- * @example
- * ```ts
- * const {router, getContext} = createUtilities(async (req, res) => {
- *   // Return context here
- * })
- *
- * const app = router().get('/', async () => "hello");
- *
- * const server = createServer({
- *   router: app,
- *   getContext,
- *   // ...
- * });
- * ```
- */
-function createUtilities(getContext) {
-  return {
-    getContext,
-    router: () => Router.create()
-  };
-}
-function getLastEntryInMultiHeaderValue(headerValue) {
-  var normalized = Array.isArray(headerValue) ? headerValue.join(',') : headerValue;
-  var lastIndex = normalized.lastIndexOf(',');
-  return lastIndex === -1 ? normalized.trim() : normalized.slice(lastIndex + 1).trim();
-}
-function getBody(_x) {
-  return _getBody.apply(this, arguments);
-}
-function _getBody() {
-  _getBody = _asyncToGenerator(function* (req) {
-    if (!req.headers['content-type']) {
-      return null;
-    }
-    var buffer = yield getRawBody(req.raw);
-    var {
-      type
-    } = parse(req.headers['content-type']);
-    switch (type) {
-      case 'application/json':
-        {
-          return json(Readable.from(buffer));
-        }
-      default:
-        {
-          if (process.env.NODE_ENV === 'development') {
-            console.warn('[kaito] Unsupported content type:', type);
-            console.warn('[kaito] This message is only shown in development mode.');
-          }
-          return null;
-        }
-    }
-  });
-  return _getBody.apply(this, arguments);
-}
-
-class KaitoRequest {
-  constructor(raw) {
-    _defineProperty(this, "_url", null);
-    this.raw = raw;
-  }
-
-  /**
-   * The full URL of the request, including the protocol, hostname, and path.
-   * Note: does not include the query string or hash
-   */
-  get fullURL() {
-    var _this$raw$url;
-    return "".concat(this.protocol, "://").concat(this.hostname).concat((_this$raw$url = this.raw.url) !== null && _this$raw$url !== void 0 ? _this$raw$url : '');
-  }
-
-  /**
-   * A new URL instance for the full URL of the request.
-   */
-  get url() {
-    if (this._url) {
-      return this._url;
-    }
-    this._url = new URL(this.fullURL);
-    return this._url;
-  }
-
-  /**
-   * The HTTP method of the request.
-   */
-  get method() {
-    if (!this.raw.method) {
-      throw new Error('Request method is not defined, somehow...');
-    }
-    return this.raw.method;
-  }
-
-  /**
-   * The protocol of the request, either `http` or `https`.
-   */
-  get protocol() {
-    if (this.raw.socket instanceof TLSSocket) {
-      return this.raw.socket.encrypted ? 'https' : 'http';
-    }
-    return 'http';
-  }
-
-  /**
-   * The request headers
-   */
-  get headers() {
-    return this.raw.headers;
-  }
-
-  /**
-   * The hostname of the request.
-   */
-  get hostname() {
-    var _this$raw$headers$hos, _this$raw$headers$Au;
-    return (_this$raw$headers$hos = this.raw.headers.host) !== null && _this$raw$headers$hos !== void 0 ? _this$raw$headers$hos : getLastEntryInMultiHeaderValue((_this$raw$headers$Au = this.raw.headers[':authority']) !== null && _this$raw$headers$Au !== void 0 ? _this$raw$headers$Au : []);
-  }
-}
-
-function createFMWServer(config) {
-  var _config$rawRoutes;
-  var router = config.router.freeze(config);
-  var rawRoutes = (_config$rawRoutes = config.rawRoutes) !== null && _config$rawRoutes !== void 0 ? _config$rawRoutes : {};
-  for (var method in rawRoutes) {
-    if (!Object.prototype.hasOwnProperty.call(rawRoutes, method)) {
-      continue;
-    }
-    var routes = rawRoutes[method];
-    if (!routes || routes.length === 0) {
-      continue;
-    }
-    for (var route of routes) {
-      if (method === '*') {
-        router.all(route.path, route.handler);
-        continue;
-      }
-      router[method.toLowerCase()](route.path, route.handler);
-    }
-  }
-  var server = http.createServer( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (req, res) {
-      var before;
-      if (config.before) {
-        before = yield config.before(req, res);
-      } else {
-        before = undefined;
-      }
-
-      // If the user has sent a response (e.g. replying to CORS), we don't want to do anything else.
-      if (res.headersSent) {
-        return;
-      }
-      var result = yield router.lookup(req, res);
-      if ('after' in config && config.after) {
-        yield config.after(before, result);
-      }
-    });
-    return function (_x, _x2) {
-      return _ref.apply(this, arguments);
-    };
-  }());
-  return {
-    server,
-    fmw: router
-  };
-}
-function createServer(config) {
-  return createFMWServer(config).server;
-}
-
-export { KaitoError, KaitoRequest, KaitoResponse, Router, WrappedError, createFMWServer, createGetContext, createServer, createUtilities, getBody, getLastEntryInMultiHeaderValue };