@kaito-http/core 3.0.0-beta.6 → 3.0.0-beta.8

package/dist/index.cjs

@@ -0,0 +1,439 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  KaitoError: () => KaitoError,
+  KaitoRequest: () => KaitoRequest,
+  KaitoResponse: () => KaitoResponse,
+  Router: () => Router,
+  WrappedError: () => WrappedError,
+  createFMWServer: () => createFMWServer,
+  createGetContext: () => createGetContext,
+  createServer: () => createServer2,
+  createUtilities: () => createUtilities,
+  getBody: () => getBody,
+  getLastEntryInMultiHeaderValue: () => getLastEntryInMultiHeaderValue,
+  parsable: () => parsable
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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
+var import_node_tls = require("tls");
+
+// src/util.ts
+var import_content_type = require("content-type");
+var import_node_stream = require("stream");
+var import_consumers = require("stream/consumers");
+var import_raw_body = __toESM(require("raw-body"), 1);
+
+// src/router.ts
+var import_find_my_way = __toESM(require("find-my-way"), 1);
+
+// src/res.ts
+var import_cookie = require("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", (0, import_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, parsable2] of Object.entries(schema)) {
+      const value = url.searchParams.get(key);
+      result[key] = parsable2.parse(value);
+    }
+    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 = (0, import_find_my_way.default)({
+      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();
+}
+function parsable(parse) {
+  return {
+    parse
+  };
+}
+async function getBody(req) {
+  if (!req.headers["content-type"]) {
+    return null;
+  }
+  const buffer = await (0, import_raw_body.default)(req.raw);
+  const { type } = (0, import_content_type.parse)(req.headers["content-type"]);
+  switch (type) {
+    case "application/json": {
+      return (0, import_consumers.json)(import_node_stream.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 import_node_tls.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
+var http = __toESM(require("http"), 1);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KaitoError,
+  KaitoRequest,
+  KaitoResponse,
+  Router,
+  WrappedError,
+  createFMWServer,
+  createGetContext,
+  createServer,
+  createUtilities,
+  getBody,
+  getLastEntryInMultiHeaderValue,
+  parsable
+});

package/dist/index.d.cts

@@ -0,0 +1,237 @@
+import * as find_my_way from 'find-my-way';
+import find_my_way__default, { HTTPMethod } from 'find-my-way';
+export { HTTPMethod } from 'find-my-way';
+import * as http from 'http';
+import * as http$1 from 'node:http';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { CookieSerializeOptions } from 'cookie';
+
+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();
+}
+declare class KaitoError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+
+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(): http.IncomingHttpHeaders;
+    /**
+     * The hostname of the request.
+     */
+    get hostname(): string;
+}
+
+type ErroredAPIResponse = {
+    success: false;
+    data: null;
+    message: string;
+};
+type SuccessfulAPIResponse<T> = {
+    success: true;
+    data: T;
+    message: 'OK';
+};
+type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
+type AnyResponse = APIResponse<unknown>;
+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;
+}
+
+type Before<BeforeAfterContext> = (req: http$1.IncomingMessage, res: http$1.ServerResponse) => Promise<BeforeAfterContext>;
+type HandlerResult = {
+    success: true;
+    data: unknown;
+} | {
+    success: false;
+    data: {
+        status: number;
+        message: string;
+    };
+};
+type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
+type ServerConfigWithBefore<BeforeAfterContext> = {
+    before: Before<BeforeAfterContext>;
+    after?: After<BeforeAfterContext>;
+} | {
+    before?: undefined;
+};
+type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
+    router: Router<ContextFrom, unknown, any>;
+    getContext: GetContext<ContextFrom>;
+    rawRoutes?: Partial<Record<KaitoMethod, Array<{
+        path: string;
+        handler: (request: http$1.IncomingMessage, response: http$1.ServerResponse) => unknown;
+    }>>>;
+    onError(arg: {
+        error: Error;
+        req: KaitoRequest;
+        res: KaitoResponse;
+    }): Promise<KaitoError | {
+        status: number;
+        message: string;
+    }>;
+};
+declare function createFMWServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): {
+    readonly server: http$1.Server<typeof http$1.IncomingMessage, typeof http$1.ServerResponse>;
+    readonly fmw: find_my_way.Instance<find_my_way.HTTPVersion.V1>;
+};
+declare function createServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): http$1.Server<typeof http$1.IncomingMessage, typeof http$1.ServerResponse>;
+
+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;
+type RouterOptions<ContextFrom, ContextTo> = {
+    through: (context: ContextFrom) => Promise<ContextTo>;
+};
+type InferRoutes<R extends Router<any, any, any>> = R extends Router<any, any, infer R> ? R : never;
+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 = {}, Body extends Parsable = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>>;
+    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>) => find_my_way__default.Instance<find_my_way__default.HTTPVersion.V1>;
+    private readonly method;
+    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>, "body" | "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>>;
+    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>>;
+    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>>;
+    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>>;
+    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>>;
+    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>>;
+    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>>;
+    through: <NextContext>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
+}
+
+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;
+} : {};
+type KaitoMethod = HTTPMethod | '*';
+type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
+/**
+ * @deprecated use `createUtilities` instead
+ */
+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,
+ *   // ...
+ * });
+ * ```
+ */
+declare function createUtilities<Context>(getContext: GetContext<Context>): {
+    getContext: GetContext<Context>;
+    router: () => Router<Context, Context, never>;
+};
+type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
+declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
+interface Parsable<Output = any, Input = Output> {
+    _input: Input;
+    parse: (value: unknown) => Output;
+}
+type InferParsable<T> = T extends Parsable<infer Output, infer Input> ? {
+    input: Input;
+    output: Output;
+} : never;
+declare function parsable<T>(parse: (value: unknown) => T): Parsable<T, T>;
+type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
+type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
+type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
+type Values<T> = T[keyof T];
+type NoEmpty<T> = [keyof T] extends [never] ? never : T;
+declare function getBody(req: KaitoRequest): Promise<unknown>;
+
+type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
+    ctx: Context;
+    body: BodyOutput;
+    query: QueryOutput;
+    params: ExtractRouteParams<Path>;
+};
+type AnyQueryDefinition = Record<string, Parsable<any, string | undefined>>;
+type RouteRunner<Result, Path extends string, Context, QueryOutput, BodyOutput> = (args: RouteArgument<Path, Context, QueryOutput, BodyOutput>) => Promise<Result>;
+type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, Body extends Parsable> = {
+    through: (context: ContextFrom) => Promise<ContextTo>;
+    body?: Body;
+    query?: Query;
+    path: Path;
+    method: Method;
+    run(arg: RouteArgument<Path, ContextTo, {
+        [Key in keyof Query]: InferParsable<Query[Key]>['output'];
+    }, InferParsable<Body>['output']>): Promise<Result>;
+};
+type AnyRoute<FromContext = any, ToContext = any> = Route<FromContext, ToContext, any, any, any, AnyQueryDefinition, any>;
+
+export { type APIResponse, type AddStartSlashes, type After, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type HandlerResult, type InferContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, KaitoResponse, type NoEmpty, type NormalizePath, type Parsable, type RemoveEndSlashes, type Route, type RouteArgument, type RouteRunner, Router, type RouterOptions, type ServerConfig, type ServerConfigWithBefore, type SuccessfulAPIResponse, type Values, WrappedError, createFMWServer, createGetContext, createServer, createUtilities, getBody, getLastEntryInMultiHeaderValue, parsable };

package/dist/index.js

@@ -101,13 +101,9 @@ var Router = class _Router {
       return {};
     }
     const result = {};
-    for (const [key, value] of url.searchParams.entries()) {
-      const parsable2 = schema[key];
-      if (!parsable2) {
-        continue;
-      }
-      const parsed = parsable2.parse(value);
-      result[key] = parsed;
+    for (const [key, parsable2] of Object.entries(schema)) {
+      const value = url.searchParams.get(key);
+      result[key] = parsable2.parse(value);
     }
     return result;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaito-http/core",
-  "version": "3.0.0-beta.6",
+  "version": "3.0.0-beta.8",
   "type": "module",
   "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
@@ -9,7 +9,10 @@
   },
   "exports": {
     "./package.json": "./package.json",
-    ".": "./dist/index.js"
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
   },
   "homepage": "https://github.com/kaito-http/kaito",
   "repository": "https://github.com/kaito-http/kaito",