@kaito-http/core 3.0.3 → 4.0.0-beta.10

package/dist/index.js

@@ -1,9 +1,12 @@
+// src/router/router.ts
+import { z } from "zod";
+import {
+  createDocument
+} from "zod-openapi";
+import "zod-openapi/extend";
+
 // 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;
@@ -13,56 +16,39 @@ var WrappedError = class _WrappedError extends Error {
   static from(data) {
     return new _WrappedError(data);
   }
+  data;
+  constructor(data) {
+    super("Something was thrown, but it was not an instance of Error, so a WrappedError was created.");
+    this.data = data;
+  }
 };
 var KaitoError = class extends Error {
+  status;
   constructor(status, message) {
     super(message);
     this.status = status;
   }
 };
 
-// src/handler.ts
-function createKaitoHandler(config) {
-  const handle = config.router.freeze(config);
-  return async (request) => {
-    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;
-  };
-}
-
 // src/head.ts
 var KaitoHead = class {
-  _headers;
-  _status;
+  #headers;
+  #status;
   constructor() {
-    this._headers = null;
-    this._status = 200;
+    this.#headers = null;
+    this.#status = 200;
   }
   get headers() {
-    if (this._headers === null) {
-      this._headers = new Headers();
+    if (this.#headers === null) {
+      this.#headers = new Headers();
     }
-    return this._headers;
+    return this.#headers;
   }
   status(status) {
     if (status === void 0) {
-      return this._status;
+      return this.#status;
     }
-    this._status = status;
+    this.#status = status;
     return this;
   }
   /**
@@ -72,10 +58,10 @@ var KaitoHead = class {
    */
   toResponse(body) {
     const init = {
-      status: this._status
+      status: this.#status
     };
-    if (this._headers) {
-      init.headers = this._headers;
+    if (this.#headers) {
+      init.headers = this.#headers;
     }
     return Response.json(body, init);
   }
@@ -83,7 +69,7 @@ var KaitoHead = class {
    * Whether this KaitoHead instance has been touched/modified
    */
   get touched() {
-    return this._status !== 200 || this._headers !== null;
+    return this.#status !== 200 || this.#headers !== null;
   }
 };
 
@@ -127,102 +113,102 @@ var KaitoRequest = class {
 
 // src/util.ts
 var isNodeLikeDev = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.NODE_ENV === "development";
-function createUtilities(getContext) {
-  return {
-    getContext,
-    router: () => Router.create()
-  };
-}
-function parsable(parse) {
-  return {
-    parse
-  };
-}
 
 // src/router/router.ts
 var Router = class _Router {
   state;
-  static create = () => new _Router({
+  static create = (config) => new _Router({
     through: async (context) => context,
-    routes: /* @__PURE__ */ new Set()
+    routes: /* @__PURE__ */ new Set(),
+    config,
+    paramsSchema: null
   });
-  static parseQuery(schema, url) {
-    if (!schema) {
-      return {};
-    }
-    const result = {};
-    for (const key in schema) {
-      if (!schema.hasOwnProperty(key)) continue;
-      const value = url.searchParams.get(key);
-      result[key] = schema[key].parse(value);
-    }
-    return result;
-  }
-  constructor(options) {
-    this.state = options;
+  constructor(state) {
+    this.state = state;
   }
   get routes() {
     return this.state.routes;
   }
   add = (method, path, route) => {
     const merged = {
-      // TODO: Ideally fix the typing here, but this will be replaced in Kaito v4 where all routes must return a Response (which we can type)
       ...typeof route === "object" ? route : { run: route },
       method,
       path,
-      through: this.state.through
+      router: this
     };
     return new _Router({
       ...this.state,
       routes: /* @__PURE__ */ new Set([...this.state.routes, merged])
     });
   };
+  params = (spec) => new _Router({
+    ...this.state,
+    paramsSchema: z.object(spec)
+  });
   merge = (pathPrefix, other) => {
     const newRoutes = [...other.state.routes].map((route) => ({
       ...route,
-      path: `${pathPrefix}${route.path}`
+      // handle pathPrefix = / & route.path = / case causing //
+      // we intentionally are replacing on the joining path and not the pathPrefix, in case of
+      // /named -> merged to -> / causing /named/ not /named
+      path: `${pathPrefix}${route.path === "/" ? "" : route.path}`
     }));
     return new _Router({
       ...this.state,
       routes: /* @__PURE__ */ new Set([...this.state.routes, ...newRoutes])
     });
   };
-  freeze = (server) => {
-    const routes = /* @__PURE__ */ new Map();
-    for (const route of this.state.routes) {
-      if (!routes.has(route.path)) {
-        routes.set(route.path, /* @__PURE__ */ new Map());
+  static getFindRoute = (routes) => (method, path) => {
+    const params = {};
+    const pathParts = path.split("/").filter(Boolean);
+    const methodRoutes = routes.get(method);
+    if (!methodRoutes) return {};
+    for (const [routePath, route] of methodRoutes) {
+      const routeParts = routePath.split("/").filter(Boolean);
+      if (routeParts.length !== pathParts.length) {
+        continue;
       }
-      routes.get(route.path).set(route.method, route);
-    }
-    const findRoute = (method, path) => {
-      const params = {};
-      const pathParts = path.split("/").filter(Boolean);
-      for (const [routePath, methodHandlers] of routes) {
-        const routeParts = routePath.split("/").filter(Boolean);
-        if (routeParts.length !== pathParts.length) continue;
-        let matches = true;
-        for (let i = 0; i < routeParts.length; i++) {
-          const routePart = routeParts[i];
-          const pathPart = pathParts[i];
-          if (routePart && pathPart && routePart.startsWith(":")) {
-            params[routePart.slice(1)] = pathPart;
-          } else if (routePart !== pathPart) {
-            matches = false;
-            break;
-          }
-        }
-        if (matches) {
-          const route = methodHandlers.get(method);
-          if (route) return { route, params };
+      let matches = true;
+      for (let i = 0; i < routeParts.length; i++) {
+        const routePart = routeParts[i];
+        const pathPart = pathParts[i];
+        if (routePart && pathPart && routePart.startsWith(":")) {
+          params[routePart.slice(1)] = pathPart;
+        } else if (routePart !== pathPart) {
+          matches = false;
+          break;
         }
       }
-      return { params };
-    };
-    return async (req) => {
+      if (matches) return { route, params };
+    }
+    return {};
+  };
+  static buildQuerySchema = (schema) => {
+    const keys = Object.keys(schema);
+    return z.instanceof(URLSearchParams).transform((params) => {
+      const result = {};
+      for (const key of keys) {
+        result[key] = params.get(key);
+      }
+      return result;
+    }).pipe(z.object(schema));
+  };
+  serve = () => {
+    const methodToRoutesMap = /* @__PURE__ */ new Map();
+    for (const route of this.state.routes) {
+      if (!methodToRoutesMap.has(route.method)) {
+        methodToRoutesMap.set(route.method, /* @__PURE__ */ new Map());
+      }
+      methodToRoutesMap.get(route.method).set(route.path, {
+        ...route,
+        fastQuerySchema: route.query ? _Router.buildQuerySchema(route.query) : void 0
+      });
+    }
+    const findRoute = _Router.getFindRoute(methodToRoutesMap);
+    const handle = async (req) => {
       const url = new URL(req.url);
       const method = req.method;
-      const { route, params } = findRoute(method, url.pathname);
+      const { route, params: rawParams } = findRoute(method, url.pathname);
       if (!route) {
         const body = {
           success: false,
@@ -234,10 +220,13 @@ var Router = class _Router {
       const request = new KaitoRequest(url, req);
       const head = new KaitoHead();
       try {
-        const body = route.body ? await route.body.parse(await req.json()) : void 0;
-        const query = _Router.parseQuery(route.query, url);
-        const rootCtx = await server.getContext(request, head);
-        const ctx = await route.through(rootCtx);
+        const body = route.body ? await route.body.parseAsync(await req.json()) : void 0;
+        const query = route.fastQuerySchema ? await route.fastQuerySchema.parseAsync(url.searchParams) : {};
+        const params = route.router.state.paramsSchema ? route.router.state.paramsSchema.parse(rawParams) : rawParams;
+        const ctx = await route.router.state.through(
+          await this.state.config.getContext?.(request, head) ?? null,
+          params
+        );
         const result = await route.run({
           ctx,
           body,
@@ -260,8 +249,7 @@ var Router = class _Router {
         }
         return head.toResponse({
           success: true,
-          data: result,
-          message: "OK"
+          data: result
         });
       } catch (e) {
         const error = WrappedError.maybe(e);
@@ -272,17 +260,129 @@ var Router = class _Router {
             message: error.message
           });
         }
-        const { status, message } = await server.onError({ error, req: request }).catch(() => ({ status: 500, message: "Internal Server Error" }));
-        return head.status(status).toResponse({
-          success: false,
-          data: null,
-          message
-        });
+        if (!this.state.config.onError) {
+          return head.status(500).toResponse({
+            success: false,
+            data: null,
+            message: "Internal Server Error"
+          });
+        }
+        try {
+          const { status, message } = await this.state.config.onError(error, request);
+          return head.status(status).toResponse({
+            success: false,
+            data: null,
+            message
+          });
+        } catch (e2) {
+          console.error("KAITO - Failed to handle error inside `.onError()`, returning 500 and Internal Server Error");
+          console.error(e2);
+          return head.status(500).toResponse({
+            success: false,
+            data: null,
+            message: "Internal Server Error"
+          });
+        }
+      }
+    };
+    return async (request) => {
+      if (this.state.config.before) {
+        const result = await this.state.config.before(request);
+        if (result instanceof Response) {
+          if (this.state.config.transform) {
+            const transformed = await this.state.config.transform(request, result);
+            if (transformed instanceof Response) {
+              return result;
+            }
+          }
+          return result;
+        }
+      }
+      const response = await handle(request);
+      if (this.state.config.transform) {
+        const transformed = await this.state.config.transform(request, response);
+        if (transformed instanceof Response) {
+          return transformed;
+        }
       }
+      return response;
     };
   };
-  method = (method) => (path, route) => {
-    return this.add(method, path, route);
+  openapi = (highLevelSpec) => {
+    const OPENAPI_VERSION = "3.0.0";
+    const paths = {};
+    for (const route of this.state.routes) {
+      const path = route.path;
+      if (!route.openapi) {
+        continue;
+      }
+      const pathWithColonParamsReplaceWithCurlyBraces = path.replace(/:(\w+)/g, "{$1}");
+      if (!paths[pathWithColonParamsReplaceWithCurlyBraces]) {
+        paths[pathWithColonParamsReplaceWithCurlyBraces] = {};
+      }
+      const content = route.openapi.body.type === "json" ? {
+        "application/json": {
+          schema: z.object({
+            success: z.literal(true).openapi({
+              type: "boolean",
+              enum: [true]
+              // Need this as zod-openapi doesn't properly work with literals
+            }),
+            data: route.openapi.body.schema
+          })
+        }
+      } : {
+        "text/event-stream": {
+          schema: route.openapi.body.schema
+        }
+      };
+      const item = {
+        description: route.openapi?.description ?? "Successful response",
+        responses: {
+          200: {
+            description: route.openapi?.description ?? "Successful response",
+            content
+          }
+        }
+      };
+      if (route.body) {
+        item.requestBody = {
+          content: {
+            "application/json": { schema: route.body }
+          }
+        };
+      }
+      const params = {};
+      if (route.query) {
+        params.query = z.object(route.query);
+      }
+      const urlParams = path.match(/:(\w+)/g);
+      if (urlParams) {
+        const pathParams = {};
+        for (const param of urlParams) {
+          pathParams[param.slice(1)] = z.string();
+        }
+        params.path = z.object(pathParams);
+      }
+      item.requestParams = params;
+      paths[pathWithColonParamsReplaceWithCurlyBraces][route.method.toLowerCase()] = item;
+    }
+    const doc = createDocument({
+      openapi: OPENAPI_VERSION,
+      paths,
+      ...highLevelSpec,
+      servers: Object.entries(highLevelSpec.servers ?? {}).map((entry) => {
+        const [url, description] = entry;
+        return {
+          url,
+          description
+        };
+      })
+    });
+    return this.get("/openapi.json", () => Response.json(doc));
+  };
+  method = (method) => {
+    return (path, route) => this.add(method, path, route);
   };
   get = this.method("GET");
   post = this.method("POST");
@@ -294,18 +394,21 @@ var Router = class _Router {
   through = (through) => {
     return new _Router({
       ...this.state,
-      through: async (context) => through(await this.state.through(context))
+      through: async (context, params) => await through(await this.state.through(context, params), params)
     });
   };
 };
+
+// src/create.ts
+function create(config = {}) {
+  return Router.create(config);
+}
 export {
   KaitoError,
   KaitoHead,
   KaitoRequest,
   Router,
   WrappedError,
-  createKaitoHandler,
-  createUtilities,
-  isNodeLikeDev,
-  parsable
+  create,
+  isNodeLikeDev
 };

package/dist/stream/stream.cjs

@@ -38,10 +38,8 @@ var KaitoSSEResponse = class extends Response {
       headers
     });
   }
-  async *[Symbol.asyncIterator]() {
-    for await (const chunk of this.body) {
-      yield chunk;
-    }
+  get [Symbol.toStringTag]() {
+    return "KaitoSSEResponse";
   }
 };
 function sseEventToString(event) {

package/dist/stream/stream.d.cts

@@ -1,6 +1,6 @@
 declare class KaitoSSEResponse<_T> extends Response {
     constructor(body: ReadableStream<string>, init?: ResponseInit);
-    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+    get [Symbol.toStringTag](): string;
 }
 type SSEEvent<T, E extends string> = ({
     data: T;

package/dist/stream/stream.d.ts

@@ -1,6 +1,6 @@
 declare class KaitoSSEResponse<_T> extends Response {
     constructor(body: ReadableStream<string>, init?: ResponseInit);
-    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+    get [Symbol.toStringTag](): string;
 }
 type SSEEvent<T, E extends string> = ({
     data: T;

package/dist/stream/stream.js

@@ -10,10 +10,8 @@ var KaitoSSEResponse = class extends Response {
       headers
     });
   }
-  async *[Symbol.asyncIterator]() {
-    for await (const chunk of this.body) {
-      yield chunk;
-    }
+  get [Symbol.toStringTag]() {
+    return "KaitoSSEResponse";
   }
 };
 function sseEventToString(event) {

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@kaito-http/core",
-  "version": "3.0.3",
-  "type": "module",
+  "version": "4.0.0-beta.10",
   "author": "Alistair Smith <hi@alistair.sh>",
-  "description": "Functional HTTP Framework for TypeScript",
-  "scripts": {
-    "build": "tsup",
-    "attw": "attw --profile node16 --pack .",
-    "test": "node --test --import=tsx ./src/**/*.test.ts"
+  "repository": "https://github.com/kaito-http/kaito",
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3"
   },
   "exports": {
     "./package.json": "./package.json",
@@ -24,26 +23,32 @@
       "require": "./dist/cors/cors.cjs"
     }
   },
+  "bugs": {
+    "url": "https://github.com/kaito-http/kaito/issues"
+  },
+  "description": "Functional HTTP Framework for TypeScript",
+  "files": [
+    "package.json",
+    "README.md",
+    "dist"
+  ],
   "homepage": "https://github.com/kaito-http/kaito",
-  "repository": "https://github.com/kaito-http/kaito",
   "keywords": [
     "typescript",
     "http",
     "framework"
   ],
   "license": "MIT",
-  "devDependencies": {
-    "@arethetypeswrong/cli": "^0.17.2",
-    "@types/node": "^22.10.2",
-    "tsup": "^8.3.5",
-    "typescript": "^5.7.2"
+  "scripts": {
+    "build": "tsup",
+    "attw": "attw --profile node16 --pack .",
+    "test": "node --test --import=tsx ./src/**/*.test.ts"
   },
-  "files": [
-    "package.json",
-    "README.md",
-    "dist"
-  ],
-  "bugs": {
-    "url": "https://github.com/kaito-http/kaito/issues"
+  "type": "module",
+  "peerDependencies": {
+    "zod": "^3.24.1"
+  },
+  "dependencies": {
+    "zod-openapi": "^4.2.3"
   }
 }