@kaito-http/core 4.0.0-beta.2 → 4.0.0-beta.21

package/dist/index.js

@@ -1,6 +1,25 @@
+import {
+  BaseSchema,
+  KArray,
+  KBoolean,
+  KLiteral,
+  KNull,
+  KNumber,
+  KObject,
+  KObjectFromURLSearchParams,
+  KRef,
+  KScalar,
+  KString,
+  KUnion,
+  ParseContext,
+  STRING_FORMAT_REGEXES,
+  SchemaError,
+  isPrimitiveJSONValue,
+  k
+} from "./chunk-TL3E52YN.js";
+
 // src/router/router.ts
-import { z } from "zod";
-import { createDocument } from "zod-openapi";
+import "openapi3-ts/oas31";
 
 // src/error.ts
 var WrappedError = class _WrappedError extends Error {
@@ -113,38 +132,44 @@ var isNodeLikeDev = typeof process !== "undefined" && typeof process.env !== "un
 
 // src/router/router.ts
 var Router = class _Router {
-  state;
-  static create = (config) => new _Router({
-    through: async (context) => context,
-    routes: /* @__PURE__ */ new Set(),
-    config
-  });
+  #state;
+  static create = (config = {}) => {
+    return new _Router({
+      through: (context) => context,
+      routes: /* @__PURE__ */ new Set(),
+      config
+    });
+  };
   constructor(state) {
-    this.state = state;
+    this.#state = state;
   }
   get routes() {
-    return this.state.routes;
+    return this.#state.routes;
   }
   add = (method, path, route) => {
     const merged = {
       ...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])
+      ...this.#state,
+      routes: /* @__PURE__ */ new Set([...this.#state.routes, merged])
     });
   };
+  params = () => this;
   merge = (pathPrefix, other) => {
-    const newRoutes = [...other.state.routes].map((route) => ({
+    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])
+      ...this.#state,
+      routes: /* @__PURE__ */ new Set([...this.#state.routes, ...newRoutes])
     });
   };
   static getFindRoute = (routes) => (method, path) => {
@@ -172,32 +197,22 @@ var Router = class _Router {
     }
     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) {
+    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
+        fastQuerySchema: route.query ? k.objectFromURLSearchParams(route.query) : void 0
       });
     }
     const findRoute = _Router.getFindRoute(methodToRoutesMap);
-    const handle = async (req) => {
+    const handle = async (req, ...args) => {
       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,
@@ -209,14 +224,17 @@ var Router = class _Router {
       const request = new KaitoRequest(url, req);
       const head = new KaitoHead();
       try {
-        const body = route.body ? await route.body.parseAsync(await req.json()) : void 0;
-        const query = route.fastQuerySchema ? await route.fastQuerySchema.parseAsync(url.searchParams) : {};
-        const ctx = await route.through(await this.state.config.getContext?.(request, head) ?? null);
+        const body = route.body ? await route.body.parse(await req.json()) : void 0;
+        const query = route.fastQuerySchema ? route.fastQuerySchema.parse(url.searchParams) : {};
+        const ctx = await route.router.#state.through(
+          await this.#state.config.getContext?.(request, head, ...args) ?? null,
+          rawParams
+        );
         const result = await route.run({
           ctx,
           body,
           query,
-          params
+          params: rawParams
         });
         if (result instanceof Response) {
           if (isNodeLikeDev) {
@@ -232,6 +250,18 @@ var Router = class _Router {
           }
           return result;
         }
+        if (route.openapi?.schema) {
+          if (route.openapi.type !== "json") {
+            throw new Error(
+              `Cannot use openapi schema for ${route.method} ${route.path} because it is not a json output type`
+            );
+          }
+          const parsed = route.openapi.schema.serialize(result);
+          return head.toResponse({
+            success: true,
+            data: parsed
+          });
+        }
         return head.toResponse({
           success: true,
           data: result
@@ -245,7 +275,7 @@ var Router = class _Router {
             message: error.message
           });
         }
-        if (!this.state.config.onError) {
+        if (!this.#state.config.onError) {
           return head.status(500).toResponse({
             success: false,
             data: null,
@@ -253,14 +283,14 @@ var Router = class _Router {
           });
         }
         try {
-          const { status, message } = await this.state.config.onError(error, request);
+          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("[Kaito] Failed to handle error inside `.onError()`, returning 500 and Internal Server Error");
           console.error(e2);
           return head.status(500).toResponse({
             success: false,
@@ -270,12 +300,12 @@ var Router = class _Router {
         }
       }
     };
-    return async (request) => {
-      if (this.state.config.before) {
-        const result = await this.state.config.before(request);
+    return async (request, ...args) => {
+      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 (this.#state.config.transform) {
+            const transformed = await this.#state.config.transform(request, result);
             if (transformed instanceof Response) {
               return result;
             }
@@ -283,9 +313,9 @@ var Router = class _Router {
           return result;
         }
       }
-      const response = await handle(request);
-      if (this.state.config.transform) {
-        const transformed = await this.state.config.transform(request, response);
+      const response = await handle(request, ...args);
+      if (this.#state.config.transform) {
+        const transformed = await this.#state.config.transform(request, response);
         if (transformed instanceof Response) {
           return transformed;
         }
@@ -293,66 +323,70 @@ var Router = class _Router {
       return response;
     };
   };
-  openapi = (highLevelSpec) => {
-    const OPENAPI_VERSION = "3.0.0";
+  openapi = ({
+    info,
+    servers
+  }) => {
+    const OPENAPI_VERSION = "3.1.0";
     const paths = {};
-    for (const route of this.state.routes) {
-      const path = route.path;
-      const pathWithColonParamsReplaceWithCurlyBraces = path.replace(/:(\w+)/g, "{$1}");
+    for (const route of this.#state.routes) {
+      if (!route.openapi) {
+        continue;
+      }
+      const pathWithColonParamsReplaceWithCurlyBraces = route.path.replace(/:(\w+)/g, "{$1}");
       if (!paths[pathWithColonParamsReplaceWithCurlyBraces]) {
         paths[pathWithColonParamsReplaceWithCurlyBraces] = {};
       }
+      let contentType;
+      const type = route.openapi.type;
+      switch (type) {
+        case "json":
+          contentType = "application/json";
+          break;
+        case "sse":
+          contentType = "text/event-stream";
+          break;
+        default:
+          throw new Error(`Unknown output type in route ${route.method} ${route.path}: ${type}`);
+      }
       const item = {
         description: route.openapi?.description ?? "Successful response",
         responses: {
           200: {
             description: route.openapi?.description ?? "Successful response",
-            ...route.openapi ? {
-              content: {
-                [{
-                  json: "application/json",
-                  sse: "text/event-stream"
-                }[route.openapi.body.type]]: { schema: route.openapi?.body.schema }
+            content: {
+              [contentType]: {
+                schema: k.object({
+                  success: k.literal(true),
+                  data: route.openapi.schema
+                }).toOpenAPI()
               }
-            } : {}
+            }
           }
         }
       };
       if (route.body) {
         item.requestBody = {
           content: {
-            "application/json": { schema: route.body }
+            "application/json": { schema: route.body.toOpenAPI() }
           }
         };
       }
-      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({
+    const doc = {
       openapi: OPENAPI_VERSION,
+      info,
       paths,
-      ...highLevelSpec,
-      servers: Object.entries(highLevelSpec.servers ?? {}).map((entry) => {
+      servers: Object.entries(servers ?? {}).map((entry) => {
         const [url, description] = entry;
         return {
           url,
           description
         };
       })
-    });
-    return this.add("GET", "/openapi.json", async () => Response.json(doc));
+    };
+    return this.get("/openapi.json", () => Response.json(doc));
   };
   method = (method) => {
     return (path, route) => this.add(method, path, route);
@@ -366,21 +400,43 @@ var Router = class _Router {
   options = this.method("OPTIONS");
   through = (through) => {
     return new _Router({
-      ...this.state,
-      through: async (context) => await through(await this.state.through(context))
+      ...this.#state,
+      through: (context, params) => {
+        const next = this.#state.through(context, params);
+        if (next instanceof Promise) {
+          return next.then((next2) => through(next2, params));
+        }
+        return through(next, params);
+      }
     });
   };
 };
 
-// src/create.ts
-function create(config = {}) {
-  return () => Router.create(config);
-}
+// src/index.ts
+var create = Router.create;
 export {
+  BaseSchema,
+  KArray,
+  KBoolean,
+  KLiteral,
+  KNull,
+  KNumber,
+  KObject,
+  KObjectFromURLSearchParams,
+  KRef,
+  KScalar,
+  KString,
+  KUnion,
   KaitoError,
+  KaitoHead,
   KaitoRequest,
+  ParseContext,
   Router,
+  STRING_FORMAT_REGEXES,
+  SchemaError,
   WrappedError,
   create,
-  isNodeLikeDev
+  isNodeLikeDev,
+  isPrimitiveJSONValue,
+  k
 };