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

package/dist/index.cjs

@@ -25,19 +25,18 @@ __export(index_exports, {
   KaitoRequest: () => KaitoRequest,
   Router: () => Router,
   WrappedError: () => WrappedError,
-  createKaitoHandler: () => createKaitoHandler,
-  createUtilities: () => createUtilities,
-  isNodeLikeDev: () => isNodeLikeDev,
-  parsable: () => parsable
+  create: () => create,
+  isNodeLikeDev: () => isNodeLikeDev
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/router/router.ts
+var import_zod = require("zod");
+var import_zod_openapi = require("zod-openapi");
+var import_extend = require("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;
@@ -47,56 +46,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;
   }
   /**
@@ -106,10 +88,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);
   }
@@ -117,7 +99,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;
   }
 };
 
@@ -161,102 +143,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: import_zod.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 import_zod.z.instanceof(URLSearchParams).transform((params) => {
+      const result = {};
+      for (const key of keys) {
+        result[key] = params.get(key);
+      }
+      return result;
+    }).pipe(import_zod.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,
@@ -268,10 +250,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,
@@ -294,8 +279,7 @@ var Router = class _Router {
         }
         return head.toResponse({
           success: true,
-          data: result,
-          message: "OK"
+          data: result
         });
       } catch (e) {
         const error = WrappedError.maybe(e);
@@ -306,17 +290,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: import_zod.z.object({
+            success: import_zod.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 = import_zod.z.object(route.query);
+      }
+      const urlParams = path.match(/:(\w+)/g);
+      if (urlParams) {
+        const pathParams = {};
+        for (const param of urlParams) {
+          pathParams[param.slice(1)] = import_zod.z.string();
+        }
+        params.path = import_zod.z.object(pathParams);
+      }
+      item.requestParams = params;
+      paths[pathWithColonParamsReplaceWithCurlyBraces][route.method.toLowerCase()] = item;
+    }
+    const doc = (0, import_zod_openapi.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");
@@ -328,10 +424,15 @@ 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);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KaitoError,
@@ -339,8 +440,6 @@ var Router = class _Router {
   KaitoRequest,
   Router,
   WrappedError,
-  createKaitoHandler,
-  createUtilities,
-  isNodeLikeDev,
-  parsable
+  create,
+  isNodeLikeDev
 });