@kaito-http/core 3.0.1 → 3.0.2

package/dist/cors/cors.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cors/cors.ts
+var cors_exports = {};
+__export(cors_exports, {
+  experimental_createCORSTransform: () => experimental_createCORSTransform,
+  experimental_createOriginMatcher: () => experimental_createOriginMatcher
+});
+module.exports = __toCommonJS(cors_exports);
+function experimental_createOriginMatcher(origins) {
+  if (origins.length === 0) {
+    return () => false;
+  }
+  const source = origins.map((origin) => {
+    if (origin.startsWith("*.")) {
+      const escapedDomain = origin.slice(2).replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      return `^(?:https?://)[^.]+\\.${escapedDomain}$`;
+    } else {
+      const escapedOrigin = origin.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      return `^${escapedOrigin}$`;
+    }
+  }).join("|");
+  const regex = new RegExp(source);
+  return (origin) => regex.test(origin);
+}
+function experimental_createCORSTransform(origins) {
+  const matcher = experimental_createOriginMatcher(origins);
+  return (request, response) => {
+    const origin = request.headers.get("Origin");
+    if (origin && matcher(origin)) {
+      response.headers.set("Access-Control-Allow-Origin", origin);
+      response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+      response.headers.set("Access-Control-Max-Age", "86400");
+      response.headers.set("Access-Control-Allow-Credentials", "true");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  experimental_createCORSTransform,
+  experimental_createOriginMatcher
+});

package/dist/cors/cors.d.cts

@@ -0,0 +1,55 @@
+/**
+ * Creates a function that matches origins against a predefined set of patterns, supporting wildcards.
+ * The matcher handles both exact matches and wildcard subdomain patterns (e.g., '*.example.com').
+ *
+ * **⚠️ This API is experimental and may change or even be removed in the future. ⚠️**
+ *
+ * @param origins Array of origin patterns to match against.
+ * Patterns can be exact origins (e.g., 'https://example.com') or wildcard patterns (e.g., '*.example.com') that match subdomains.
+ * @returns A function that tests if an origin matches any of the patterns
+ *
+ * @example
+ * ```typescript
+ * const allowedOrigins = [
+ *   'https://example.com',
+ *   '*.trusted-domain.com' // Won't match https://evil-domain.com, only subdomains
+ * ];
+ *
+ * const matcher = createOriginMatcher(allowedOrigins);
+ *
+ * // Exact match
+ * console.log(matcher('https://example.com')); // true
+ * console.log(matcher('http://example.com')); // false
+ *
+ * // Wildcard subdomain matches
+ * console.log(matcher('https://app.trusted-domain.com')); // true
+ * console.log(matcher('https://staging.trusted-domain.com')); // true
+ * console.log(matcher('https://trusted-domain.com')); // false, because it's not a subdomain
+ * console.log(matcher('https://evil-domain.com')); // false
+ * ```
+ */
+declare function experimental_createOriginMatcher(origins: string[]): (origin: string) => boolean;
+/**
+ * Create a function to apply CORS headers with sane defaults for most apps.
+ *
+ * **⚠️ This API is experimental and may change or even be removed in the future. ⚠️**
+ *
+ * @param options Options object
+ * @returns A function that will mutate the Response object by applying the CORS headers
+ * @example
+ * ```ts
+ * const cors = createCORSHandler({
+ *   origins: ['https://example.com', "*.allows-subdomains.com", "http://localhost:3000"],
+ * });
+ *
+ * const handler = createKaitoHandler({
+ *  // ...
+ *  transform: async (request, response) => {
+ *    cors(request, response);
+ *  }
+ * });
+ * ```
+ */
+declare function experimental_createCORSTransform(origins: string[]): (request: Request, response: Response) => void;
+
+export { experimental_createCORSTransform, experimental_createOriginMatcher };

package/dist/cors/cors.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Creates a function that matches origins against a predefined set of patterns, supporting wildcards.
+ * The matcher handles both exact matches and wildcard subdomain patterns (e.g., '*.example.com').
+ *
+ * **⚠️ This API is experimental and may change or even be removed in the future. ⚠️**
+ *
+ * @param origins Array of origin patterns to match against.
+ * Patterns can be exact origins (e.g., 'https://example.com') or wildcard patterns (e.g., '*.example.com') that match subdomains.
+ * @returns A function that tests if an origin matches any of the patterns
+ *
+ * @example
+ * ```typescript
+ * const allowedOrigins = [
+ *   'https://example.com',
+ *   '*.trusted-domain.com' // Won't match https://evil-domain.com, only subdomains
+ * ];
+ *
+ * const matcher = createOriginMatcher(allowedOrigins);
+ *
+ * // Exact match
+ * console.log(matcher('https://example.com')); // true
+ * console.log(matcher('http://example.com')); // false
+ *
+ * // Wildcard subdomain matches
+ * console.log(matcher('https://app.trusted-domain.com')); // true
+ * console.log(matcher('https://staging.trusted-domain.com')); // true
+ * console.log(matcher('https://trusted-domain.com')); // false, because it's not a subdomain
+ * console.log(matcher('https://evil-domain.com')); // false
+ * ```
+ */
+declare function experimental_createOriginMatcher(origins: string[]): (origin: string) => boolean;
+/**
+ * Create a function to apply CORS headers with sane defaults for most apps.
+ *
+ * **⚠️ This API is experimental and may change or even be removed in the future. ⚠️**
+ *
+ * @param options Options object
+ * @returns A function that will mutate the Response object by applying the CORS headers
+ * @example
+ * ```ts
+ * const cors = createCORSHandler({
+ *   origins: ['https://example.com', "*.allows-subdomains.com", "http://localhost:3000"],
+ * });
+ *
+ * const handler = createKaitoHandler({
+ *  // ...
+ *  transform: async (request, response) => {
+ *    cors(request, response);
+ *  }
+ * });
+ * ```
+ */
+declare function experimental_createCORSTransform(origins: string[]): (request: Request, response: Response) => void;
+
+export { experimental_createCORSTransform, experimental_createOriginMatcher };

package/dist/cors/cors.js

@@ -0,0 +1,34 @@
+// src/cors/cors.ts
+function experimental_createOriginMatcher(origins) {
+  if (origins.length === 0) {
+    return () => false;
+  }
+  const source = origins.map((origin) => {
+    if (origin.startsWith("*.")) {
+      const escapedDomain = origin.slice(2).replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      return `^(?:https?://)[^.]+\\.${escapedDomain}$`;
+    } else {
+      const escapedOrigin = origin.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      return `^${escapedOrigin}$`;
+    }
+  }).join("|");
+  const regex = new RegExp(source);
+  return (origin) => regex.test(origin);
+}
+function experimental_createCORSTransform(origins) {
+  const matcher = experimental_createOriginMatcher(origins);
+  return (request, response) => {
+    const origin = request.headers.get("Origin");
+    if (origin && matcher(origin)) {
+      response.headers.set("Access-Control-Allow-Origin", origin);
+      response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+      response.headers.set("Access-Control-Max-Age", "86400");
+      response.headers.set("Access-Control-Allow-Credentials", "true");
+    }
+  };
+}
+export {
+  experimental_createCORSTransform,
+  experimental_createOriginMatcher
+};

package/dist/index.d.cts

@@ -154,7 +154,7 @@ type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends K
     method: Method;
     run(arg: RouteArgument<Path, ContextTo, {
         [Key in keyof Query]: InferParsable<Query[Key]>['output'];
-    }, InferParsable<Body>['output']>): Promise<Result>;
+    }, InferParsable<Body>['output']>): Promise<Result> | Result;
 };
 type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
 
@@ -175,13 +175,13 @@ declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
     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: Omit<HandlerConfig<ContextFrom>, "router">) => (req: Request) => Promise<Response>;
     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>>;
+    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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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>(through: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
 }
 
@@ -228,7 +228,7 @@ type HandlerConfig<ContextFrom> = {
      * }
      * ```
      */
-    before?: (req: Request) => Promise<Response | void | undefined>;
+    before?: (req: Request) => Promise<Response | void | undefined> | Response | void | undefined;
     /**
      * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
      *
@@ -248,7 +248,7 @@ type HandlerConfig<ContextFrom> = {
      * }
      * ```
      */
-    transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
+    transform?: (req: Request, res: Response) => Promise<Response | void | undefined> | Response | void | undefined;
 };
 declare function createKaitoHandler<Context>(config: HandlerConfig<Context>): (request: Request) => Promise<Response>;
 

package/dist/index.d.ts

@@ -154,7 +154,7 @@ type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends K
     method: Method;
     run(arg: RouteArgument<Path, ContextTo, {
         [Key in keyof Query]: InferParsable<Query[Key]>['output'];
-    }, InferParsable<Body>['output']>): Promise<Result>;
+    }, InferParsable<Body>['output']>): Promise<Result> | Result;
 };
 type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
 
@@ -175,13 +175,13 @@ declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
     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: Omit<HandlerConfig<ContextFrom>, "router">) => (req: Request) => Promise<Response>;
     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>>;
+    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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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>(through: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
 }
 
@@ -228,7 +228,7 @@ type HandlerConfig<ContextFrom> = {
      * }
      * ```
      */
-    before?: (req: Request) => Promise<Response | void | undefined>;
+    before?: (req: Request) => Promise<Response | void | undefined> | Response | void | undefined;
     /**
      * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
      *
@@ -248,7 +248,7 @@ type HandlerConfig<ContextFrom> = {
      * }
      * ```
      */
-    transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
+    transform?: (req: Request, res: Response) => Promise<Response | void | undefined> | Response | void | undefined;
 };
 declare function createKaitoHandler<Context>(config: HandlerConfig<Context>): (request: Request) => Promise<Response>;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaito-http/core",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "type": "module",
   "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
@@ -12,18 +12,16 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": {
-        "types": "./src/index.ts",
-        "default": "./dist/index.js"
-      },
+      "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
     "./stream": {
-      "import": {
-        "types": "./src/stream/stream.ts",
-        "default": "./dist/stream/stream.js"
-      },
+      "import": "./dist/stream/stream.js",
       "require": "./dist/stream/stream.cjs"
+    },
+    "./cors": {
+      "import": "./dist/cors/cors.js",
+      "require": "./dist/cors/cors.cjs"
     }
   },
   "homepage": "https://github.com/kaito-http/kaito",
@@ -43,8 +41,7 @@
   "files": [
     "package.json",
     "README.md",
-    "dist",
-    "src"
+    "dist"
   ],
   "bugs": {
     "url": "https://github.com/kaito-http/kaito/issues"

package/src/error.ts

@@ -1,26 +0,0 @@
-export class WrappedError<T> extends Error {
-	public static maybe<T>(maybeError: T) {
-		if (maybeError instanceof Error) {
-			return maybeError;
-		}
-
-		return WrappedError.from(maybeError);
-	}
-
-	public static from<T>(data: T) {
-		return new WrappedError(data);
-	}
-
-	private constructor(public readonly data: T) {
-		super('Something was thrown, but it was not an instance of Error, so a WrappedError was created.');
-	}
-}
-
-export class KaitoError extends Error {
-	constructor(
-		public readonly status: number,
-		message: string,
-	) {
-		super(message);
-	}
-}

package/src/handler.ts

@@ -1,96 +0,0 @@
-import type {KaitoError} from './error.ts';
-import type {KaitoRequest} from './request.ts';
-import type {Router} from './router/router.ts';
-import type {GetContext} from './util.ts';
-
-export type HandlerConfig<ContextFrom> = {
-	/**
-	 * The root router to mount on this handler.
-	 */
-	router: Router<ContextFrom, unknown, any>;
-
-	/**
-	 * A function that is called to get the context for a request.
-	 *
-	 * This is useful for things like authentication, to pass in a database connection, etc.
-	 *
-	 * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
-	 */
-	getContext: GetContext<ContextFrom>;
-
-	/**
-	 * A function that is called when an error occurs inside a route handler.
-	 *
-	 * The result of this function is used to determine the response status and message, and is
-	 * always sent to the client. You could include logic to check for production vs development
-	 * environments here, and this would also be a good place to include error tracking
-	 * like Sentry or Rollbar.
-	 *
-	 * @param arg - The error thrown, and the KaitoRequest instance
-	 * @returns A KaitoError or an object with a status and message
-	 */
-	onError: (arg: {error: Error; req: KaitoRequest}) => Promise<KaitoError | {status: number; message: string}>;
-
-	/**
-	 * A function that is called before every request. Most useful for bailing out early in the case of an OPTIONS request.
-	 *
-	 * @example
-	 * ```ts
-	 * before: async req => {
-	 * 	if (req.method === 'OPTIONS') {
-	 * 		return new Response(null, {status: 204});
-	 * 	}
-	 * }
-	 * ```
-	 */
-	before?: (req: Request) => Promise<Response | void | undefined>;
-
-	/**
-	 * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
-	 *
-	 * You can also return a new response in this function, or just mutate the current one.
-	 *
-	 * This function WILL receive the result of `.before()` if you return a response from it. This means
-	 *  you only need to define headers in a single place.
-	 *
-	 * @example
-	 * ```ts
-	 * transform: async (req, res) => {
-	 * 	res.headers.set('Access-Control-Allow-Origin', 'http://localhost:3000');
-	 * 	res.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-	 * 	res.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-	 * 	res.headers.set('Access-Control-Max-Age', '86400');
-	 * 	res.headers.set('Access-Control-Allow-Credentials', 'true');
-	 * }
-	 * ```
-	 */
-	transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
-};
-
-export function createKaitoHandler<Context>(config: HandlerConfig<Context>) {
-	const handle = config.router.freeze(config);
-
-	return async (request: Request): Promise<Response> => {
-		if (config.before) {
-			const result = await config.before(request);
-
-			if (result instanceof Response) {
-				if (config.transform) {
-					const result2 = await config.transform(request, result);
-					if (result2 instanceof Response) return result;
-				}
-
-				return result;
-			}
-		}
-
-		const response = await handle(request);
-
-		if (config.transform) {
-			const result = await config.transform(request, response);
-			if (result instanceof Response) return result;
-		}
-
-		return response;
-	};
-}

package/src/head.ts

@@ -1,83 +0,0 @@
-import type {APIResponse} from './util.ts';
-
-/**
- * This class is merely a wrapper around a `Headers` object and a status code.
- * It's used while the router is executing a route to store any mutations to the status
- * code or headers that the developer may want to make.
- *
- * This exists because there's otherwise no way to indicate back to Kaito that
- * the developer wants to change the status code or headers.
- *
- * @example
- * ```ts
- * const response = new KaitoHead();
- *
- * response.status(200);
- * response.headers.set('Content-Type', 'application/json');
- *
- * console.log(response.headers); // Headers {'content-type': 'application/json'}
- * ```
- */
-export class KaitoHead {
-	private _headers: Headers | null;
-	private _status: number;
-
-	public constructor() {
-		this._headers = null;
-		this._status = 200;
-	}
-
-	public get headers() {
-		if (this._headers === null) {
-			this._headers = new Headers();
-		}
-
-		return this._headers;
-	}
-
-	/**
-	 * Gets the status code of this KaitoHead instance
-	 * @returns The status code
-	 */
-	public status(): number;
-
-	/**
-	 * Sets the status code of this KaitoHead instance
-	 * @param status The status code to set
-	 * @returns This KaitoHead instance
-	 */
-	public status(status: number): this;
-
-	public status(status?: number) {
-		if (status === undefined) {
-			return this._status;
-		}
-
-		this._status = status;
-		return this;
-	}
-
-	/**
-	 * Turn this KaitoHead instance into a Response instance
-	 * @param body The Kaito JSON format to be sent as the response body
-	 * @returns A Response instance, ready to be sent
-	 */
-	public toResponse<T>(body: APIResponse<T>): Response {
-		const init: ResponseInit = {
-			status: this._status,
-		};
-
-		if (this._headers) {
-			init.headers = this._headers;
-		}
-
-		return Response.json(body, init);
-	}
-
-	/**
-	 * Whether this KaitoHead instance has been touched/modified
-	 */
-	public get touched() {
-		return this._status !== 200 || this._headers !== null;
-	}
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-export * from './error.ts';
-export * from './handler.ts';
-export * from './request.ts';
-export * from './route.ts';
-export * from './router/router.ts';
-export type {KaitoMethod} from './router/types.ts';
-export * from './util.ts';

package/src/request.ts

@@ -1,47 +0,0 @@
-export class KaitoRequest {
-	public readonly url: URL;
-
-	private readonly _request: Request;
-
-	public constructor(url: URL, request: Request) {
-		this._request = request;
-		this.url = url;
-	}
-
-	public get headers() {
-		return this._request.headers;
-	}
-
-	public get method() {
-		return this._request.method;
-	}
-
-	public async arrayBuffer(): Promise<ArrayBuffer> {
-		return this._request.arrayBuffer();
-	}
-
-	public async blob(): Promise<Blob> {
-		return this._request.blob();
-	}
-
-	public async formData(): Promise<FormData> {
-		return this._request.formData();
-	}
-
-	public async bytes(): Promise<Uint8Array> {
-		const buffer = await this.arrayBuffer();
-		return new Uint8Array(buffer);
-	}
-
-	public async json(): Promise<unknown> {
-		return this._request.json();
-	}
-
-	public async text(): Promise<string> {
-		return this._request.text();
-	}
-
-	public get request() {
-		return this._request;
-	}
-}