@kaito-http/core 3.0.0-beta.7 → 3.0.1

package/dist/index.js

@@ -21,205 +21,265 @@ var KaitoError = class extends Error {
   }
 };
 
-// src/req.ts
-import { TLSSocket } from "node:tls";
-
-// src/util.ts
-import { parse as parseContentType } from "content-type";
-import { Readable } from "node:stream";
-import { json } from "node:stream/consumers";
-import getRawBody from "raw-body";
+// 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/router.ts
-import fmw from "find-my-way";
+// src/request.ts
+var KaitoRequest = class {
+  url;
+  _request;
+  constructor(url, request) {
+    this._request = request;
+    this.url = url;
+  }
+  get headers() {
+    return this._request.headers;
+  }
+  get method() {
+    return this._request.method;
+  }
+  async arrayBuffer() {
+    return this._request.arrayBuffer();
+  }
+  async blob() {
+    return this._request.blob();
+  }
+  async formData() {
+    return this._request.formData();
+  }
+  async bytes() {
+    const buffer = await this.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  async json() {
+    return this._request.json();
+  }
+  async text() {
+    return this._request.text();
+  }
+  get request() {
+    return this._request;
+  }
+};
 
-// src/res.ts
-import { serialize } from "cookie";
-var KaitoResponse = class {
-  constructor(raw) {
-    this.raw = raw;
+// src/head.ts
+var KaitoHead = class {
+  _headers;
+  _status;
+  constructor() {
+    this._headers = null;
+    this._status = 200;
   }
-  /**
-   * 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;
+  get headers() {
+    if (this._headers === null) {
+      this._headers = new Headers();
+    }
+    return this._headers;
   }
-  /**
-   * Set the status code of the response
-   * @param code The status code
-   * @returns The response object
-   */
-  status(code) {
-    this.raw.statusCode = code;
+  status(status) {
+    if (status === void 0) {
+      return this._status;
+    }
+    this._status = status;
     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
+   * 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
    */
-  cookie(name, value, options) {
-    this.raw.setHeader("Set-Cookie", serialize(name, value, options));
-    return this;
+  toResponse(body) {
+    const init = {
+      status: this._status
+    };
+    if (this._headers) {
+      init.headers = this._headers;
+    }
+    return Response.json(body, init);
   }
   /**
-   * Send a JSON APIResponse body
-   * @param data The data to send
-   * @returns The response object
+   * Whether this KaitoHead instance has been touched/modified
    */
-  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;
+  get touched() {
+    return this._status !== 200 || this._headers !== null;
   }
 };
 
-// src/router.ts
-var getSend = (res) => (status, response) => {
-  if (res.raw.headersSent) {
-    return;
-  }
-  res.status(status).json(response);
-};
+// 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 {
-  routerOptions;
-  routes;
-  static create = () => new _Router([], {
-    through: async (context) => context
+  state;
+  static create = () => new _Router({
+    through: async (context) => context,
+    routes: /* @__PURE__ */ new Set()
   });
   static parseQuery(schema, url) {
     if (!schema) {
       return {};
     }
     const result = {};
-    for (const [key, parsable2] of Object.entries(schema)) {
+    for (const key in schema) {
+      if (!schema.hasOwnProperty(key)) continue;
       const value = url.searchParams.get(key);
-      result[key] = parsable2.parse(value);
+      result[key] = schema[key].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(options) {
+    this.state = options;
   }
-  constructor(routes, options) {
-    this.routerOptions = options;
-    this.routes = new Set(routes);
+  get routes() {
+    return this.state.routes;
   }
-  /**
-   * Adds a new route to the router
-   * @deprecated Use the method-specific methods instead
-   */
   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.routerOptions.through
+      through: this.state.through
     };
-    return new _Router([...this.routes, merged], this.routerOptions);
+    return new _Router({
+      ...this.state,
+      routes: /* @__PURE__ */ new Set([...this.state.routes, merged])
+    });
   };
   merge = (pathPrefix, other) => {
-    const newRoutes = [...other.routes].map((route) => ({
+    const newRoutes = [...other.state.routes].map((route) => ({
       ...route,
       path: `${pathPrefix}${route.path}`
     }));
-    return new _Router(
-      [...this.routes, ...newRoutes],
-      this.routerOptions
-    );
+    return new _Router({
+      ...this.state,
+      routes: /* @__PURE__ */ new Set([...this.state.routes, ...newRoutes])
+    });
   };
-  // Allow for any server context to be passed
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   freeze = (server) => {
-    const instance = fmw({
-      ignoreTrailingSlash: true,
-      async defaultRoute(req, serverResponse) {
-        const res = new KaitoResponse(serverResponse);
-        const message = `Cannot ${req.method} ${req.url ?? "/"}`;
-        getSend(res)(404, {
+    const routes = /* @__PURE__ */ new Map();
+    for (const route of this.state.routes) {
+      if (!routes.has(route.path)) {
+        routes.set(route.path, /* @__PURE__ */ new Map());
+      }
+      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 };
+        }
+      }
+      return { params };
+    };
+    return async (req) => {
+      const url = new URL(req.url);
+      const method = req.method;
+      const { route, params } = findRoute(method, url.pathname);
+      if (!route) {
+        const body = {
           success: false,
           data: null,
-          message
-        });
-        return {
-          success: false,
-          data: { status: 404, message }
+          message: `Cannot ${method} ${url.pathname}`
         };
+        return Response.json(body, { status: 404 });
       }
-    });
-    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
+      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 result = await route.run({
+          ctx,
+          body,
+          query,
+          params
+        });
+        if (result instanceof Response) {
+          if (isNodeLikeDev) {
+            if (head.touched) {
+              const msg = [
+                "Kaito detected that you used the KaitoHead object to modify the headers or status, but then returned a Response in the route",
+                "This is usually a mistake, as your Response object will override any changes you made to the headers or status code.",
+                "",
+                "This warning was shown because `process.env.NODE_ENV=development`"
+              ].join("\n");
+              console.warn(msg);
+            }
+          }
+          return result;
+        }
+        return head.toResponse({
+          success: true,
+          data: result,
+          message: "OK"
+        });
+      } catch (e) {
+        const error = WrappedError.maybe(e);
+        if (error instanceof KaitoError) {
+          return head.status(error.status).toResponse({
+            success: false,
+            data: null,
+            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 (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);
@@ -231,161 +291,20 @@ var Router = class _Router {
   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
+  through = (through) => {
+    return new _Router({
+      ...this.state,
+      through: async (context) => through(await this.state.through(context))
+    });
   };
-}
-async function getBody(req) {
-  if (!req.headers["content-type"]) {
-    return null;
-  }
-  const buffer = await getRawBody(req.raw);
-  const { type } = parseContentType(req.headers["content-type"]);
-  switch (type) {
-    case "application/json": {
-      return json(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 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
-import * as http from "node:http";
-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;
-}
 export {
   KaitoError,
   KaitoRequest,
-  KaitoResponse,
   Router,
   WrappedError,
-  createFMWServer,
-  createGetContext,
-  createServer2 as createServer,
+  createKaitoHandler,
   createUtilities,
-  getBody,
-  getLastEntryInMultiHeaderValue,
+  isNodeLikeDev,
   parsable
 };