@kaito-http/core 2.6.0 → 2.7.0

package/dist/declarations/src/res.d.ts

@@ -1,18 +1,18 @@
 /// <reference types="node" />
 import type { ServerResponse } from 'node:http';
 import type { CookieSerializeOptions } from 'cookie';
-export declare type ErroredAPIResponse = {
+export type ErroredAPIResponse = {
     success: false;
     data: null;
     message: string;
 };
-export declare type SuccessfulAPIResponse<T> = {
+export type SuccessfulAPIResponse<T> = {
     success: true;
     data: T;
     message: 'OK';
 };
-export declare type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
-export declare type AnyResponse = APIResponse<unknown>;
+export type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
+export type AnyResponse = APIResponse<unknown>;
 export declare class KaitoResponse<T = unknown> {
     readonly raw: ServerResponse;
     constructor(raw: ServerResponse);

package/dist/declarations/src/route.d.ts

@@ -1,17 +1,17 @@
 import type { z } from 'zod';
 import type { ExtractRouteParams, KaitoMethod } from './util';
-export declare type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
+export type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
     ctx: Context;
     body: BodyOutput;
     query: QueryOutput;
     params: ExtractRouteParams<Path>;
 };
-export declare type AnyQueryDefinition = Record<string, z.ZodTypeAny>;
-export declare type Route<Context, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, BodyOutput, BodyDef extends z.ZodTypeDef, BodyInput> = {
+export type AnyQueryDefinition = Record<string, z.ZodTypeAny>;
+export type Route<Context, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, BodyOutput, BodyDef extends z.ZodTypeDef, BodyInput> = {
     body?: z.ZodType<BodyOutput, BodyDef, BodyInput>;
     query?: Query;
     path: Path;
     method: Method;
-    run(args: RouteArgument<Path, Context, z.infer<z.ZodObject<Query>>, BodyOutput>): Promise<Result>;
+    run(args: RouteArgument<Path, Context, z.infer<z.ZodObject<Query>>, BodyOutput>): Promise<Result> | Result;
 };
-export declare type AnyRoute<Context = any> = Route<Context, any, any, any, AnyQueryDefinition, any, any, any>;
+export type AnyRoute<Context = any> = Route<Context, any, any, any, AnyQueryDefinition, any, any, any>;

package/dist/declarations/src/router.d.ts

@@ -3,9 +3,9 @@ import { z } from 'zod';
 import type { AnyQueryDefinition, AnyRoute, Route } from './route';
 import type { ServerConfig } from './server';
 import type { KaitoMethod } from './util';
-declare type Routes = readonly AnyRoute[];
-declare type RemapRoutePrefix<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer Context, infer Result, infer Path, infer Method, infer Query, infer BodyOutput, infer BodyDef, infer BodyInput> ? Route<Context, Result, `${Prefix}${Path}`, Method, Query, BodyOutput, BodyDef, BodyInput> : never;
-declare type PrefixRoutesPath<Prefix extends `/${string}`, R extends Routes> = R extends [infer First, ...infer Rest] ? [
+type Routes = readonly AnyRoute[];
+type RemapRoutePrefix<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer Context, infer Result, infer Path, infer Method, infer Query, infer BodyOutput, infer BodyDef, infer BodyInput> ? Route<Context, Result, `${Prefix}${Path}`, Method, Query, BodyOutput, BodyDef, BodyInput> : never;
+type PrefixRoutesPath<Prefix extends `/${string}`, R extends Routes> = R extends [infer First, ...infer Rest] ? [
     RemapRoutePrefix<Extract<First, AnyRoute>, Prefix>,
     ...PrefixRoutesPath<Prefix, Extract<Rest, readonly AnyRoute[]>>
 ] : [];
@@ -14,7 +14,21 @@ export declare class Router<Context, R extends Routes> {
     static create: <Context_1>() => Router<Context_1, []>;
     private static handle;
     constructor(routes: R);
-    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(route: Method extends "GET" ? Omit<Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "body"> : Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>) => Router<Context, [...R, Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>]>;
+    /**
+     * Adds a new route to the router
+     * @param route The route specification to add to this router
+     * @returns A new router with this route added
+     * @deprecated Use `Router#add` instead
+     */
+    old_add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(route: Method extends "GET" ? Omit<Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "body"> : Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>) => Router<Context, [...R, Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>]>;
+    /**
+     * Adds a new route to the router
+     * @param method The HTTP method to add a route for
+     * @param path The path to add a route for
+     * @param route The route specification to add to this router
+     * @returns A new router with this route added
+     */
+    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(method: Method, path: Path, route: ((args: import("./route").RouteArgument<Path, Context, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Result | Promise<Result>) | (Method extends "GET" ? Omit<Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "body" | "method"> : Omit<Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "method">)) => Router<Context, [...R, Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>]>;
     merge: <PathPrefix extends `/${string}`, OtherRoutes extends Routes>(pathPrefix: PathPrefix, other: Router<Context, OtherRoutes>) => Router<Context, [...R, ...PrefixRoutesPath<PathPrefix, OtherRoutes>]>;
     toFindMyWay: (server: ServerConfig<Context, any>) => fmw.Instance<fmw.HTTPVersion.V1>;
 }

package/dist/declarations/src/server.d.ts

@@ -5,8 +5,8 @@ import type { KaitoRequest } from './req';
 import type { KaitoResponse } from './res';
 import type { Router } from './router';
 import type { GetContext, KaitoMethod } from './util';
-export declare type Before<BeforeAfterContext> = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<BeforeAfterContext>;
-export declare type HandlerResult = {
+export type Before<BeforeAfterContext> = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<BeforeAfterContext>;
+export type HandlerResult = {
     success: true;
     data: unknown;
 } | {
@@ -16,14 +16,14 @@ export declare type HandlerResult = {
         message: string;
     };
 };
-export declare type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
-export declare type ServerConfigWithBefore<BeforeAfterContext> = {
+export type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
+export type ServerConfigWithBefore<BeforeAfterContext> = {
     before: Before<BeforeAfterContext>;
     after?: After<BeforeAfterContext>;
 } | {
     before?: undefined;
 };
-export declare type ServerConfig<Context, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
+export type ServerConfig<Context, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
     router: Router<Context, any>;
     getContext: GetContext<Context>;
     rawRoutes?: Partial<Record<KaitoMethod, Array<{

package/dist/declarations/src/util.d.ts

@@ -1,20 +1,20 @@
 import type { HTTPMethod } from 'find-my-way';
 import type { KaitoRequest } from './req';
 import type { KaitoResponse } from './res';
-export declare type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
+export type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
     [k in Param | keyof ExtractRouteParams<Rest>]: string;
 } : T extends `${string}:${infer Param}` ? {
     [k in Param]: string;
 } : {};
-export declare type KaitoMethod = HTTPMethod | '*';
-export declare type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
+export type KaitoMethod = HTTPMethod | '*';
+export type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
 export declare function createGetContext<Context>(callback: GetContext<Context>): GetContext<Context>;
-export declare type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
+export type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
 export declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
-declare type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
-declare type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
-export declare type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
-export declare type Values<T> = T[keyof T];
-export declare type NoEmpty<T> = [keyof T] extends [never] ? never : T;
+type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
+type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
+export type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
+export type Values<T> = T[keyof T];
+export type NoEmpty<T> = [keyof T] extends [never] ? never : T;
 export declare function getBody(req: KaitoRequest): Promise<unknown>;
 export {};

package/dist/kaito-http-core.cjs.dev.js

@@ -41,26 +41,21 @@ class WrappedError extends Error {
     if (maybeError instanceof Error) {
       return maybeError;
     }
-
     return WrappedError.from(maybeError);
   }
-
   static from(data) {
     return new WrappedError(data);
   }
-
   constructor(data) {
     super('Something was thrown, but it was not an instance of Error, so a WrappedError was created.');
     this.data = data;
   }
-
 }
 class KaitoError extends Error {
   constructor(status, message) {
     super(message);
     this.status = status;
   }
-
 }
 
 function _defineProperty(obj, key, value) {
@@ -74,7 +69,6 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
 
@@ -86,29 +80,24 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     reject(error);
     return;
   }
-
   if (info.done) {
     resolve(value);
   } else {
     Promise.resolve(value).then(_next, _throw);
   }
 }
-
 function _asyncToGenerator(fn) {
   return function () {
     var self = this,
-        args = arguments;
+      args = arguments;
     return new Promise(function (resolve, reject) {
       var gen = fn.apply(self, args);
-
       function _next(value) {
         asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
       }
-
       function _throw(err) {
         asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
       }
-
       _next(undefined);
     });
   };
@@ -125,31 +114,26 @@ function getLastEntryInMultiHeaderValue(headerValue) {
 function getBody(_x) {
   return _getBody.apply(this, arguments);
 }
-
 function _getBody() {
   _getBody = _asyncToGenerator(function* (req) {
     if (!req.headers['content-type']) {
       return null;
     }
-
     var buffer = yield getRawBody__default["default"](req.raw);
     var {
       type
     } = contentType.parse(req.headers['content-type']);
-
     switch (type) {
       case 'application/json':
         {
           return consumers.json(node_stream.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;
         }
     }
@@ -160,105 +144,91 @@ function _getBody() {
 class KaitoRequest {
   constructor(raw) {
     _defineProperty(this, "_url", null);
-
     this.raw = raw;
   }
+
   /**
    * The full URL of the request, including the protocol, hostname, and path.
    * Note: does not include the query string or hash
    */
-
-
   get fullURL() {
     var _this$raw$url;
-
     return "".concat(this.protocol, "://").concat(this.hostname).concat((_this$raw$url = this.raw.url) !== null && _this$raw$url !== void 0 ? _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 node_tls.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() {
     var _this$raw$headers$hos, _this$raw$headers$Au;
-
     return (_this$raw$headers$hos = this.raw.headers.host) !== null && _this$raw$headers$hos !== void 0 ? _this$raw$headers$hos : getLastEntryInMultiHeaderValue((_this$raw$headers$Au = this.raw.headers[':authority']) !== null && _this$raw$headers$Au !== void 0 ? _this$raw$headers$Au : []);
   }
-
 }
 
 class KaitoResponse {
   constructor(raw) {
     this.raw = raw;
   }
+
   /**
    * 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;
   }
+
   /**
    * Set the status code of the response
    * @param code The status code
    * @returns The response object
    */
-
-
   status(code) {
     this.raw.statusCode = code;
     return this;
   }
+
   /**
    * Set a cookie
    * @param name The name of the cookie
@@ -266,19 +236,16 @@ class KaitoResponse {
    * @param options The options for the cookie
    * @returns The response object
    */
-
-
   cookie(name, value, options) {
     this.raw.setHeader('Set-Cookie', cookie.serialize(name, value, options));
     return this;
   }
+
   /**
    * Send a JSON APIResponse body
    * @param data The data to send
    * @returns The response object
    */
-
-
   json(data) {
     var json = JSON.stringify(data);
     this.raw.setHeader('Content-Type', 'application/json');
@@ -286,44 +253,27 @@ class KaitoResponse {
     this.raw.end(json);
     return this;
   }
-
 }
 
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
-
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
-
-    if (enumerableOnly) {
-      symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      });
-    }
-
-    keys.push.apply(keys, symbols);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
   }
-
   return keys;
 }
-
 function _objectSpread2(target) {
   for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-
-    if (i % 2) {
-      ownKeys(Object(source), true).forEach(function (key) {
-        _defineProperty(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      ownKeys(Object(source)).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
   }
-
   return target;
 }
 
@@ -332,7 +282,6 @@ class Router {
     return _asyncToGenerator(function* () {
       try {
         var _yield$route$body$par, _route$body;
-
         var ctx = yield server.getContext(options.req, options.res);
         var body = (_yield$route$body$par = yield (_route$body = route.body) === null || _route$body === void 0 ? void 0 : _route$body.parse(yield getBody(options.req))) !== null && _yield$route$body$par !== void 0 ? _yield$route$body$par : undefined;
         var query = route.query ? zod.z.object(route.query).parse(Object.fromEntries(options.req.url.searchParams.entries())) : {};
@@ -353,7 +302,6 @@ class Router {
         };
       } catch (e) {
         var error = WrappedError.maybe(e);
-
         if (error instanceof KaitoError) {
           options.res.status(error.status).json({
             success: false,
@@ -362,7 +310,6 @@ class Router {
           });
           return;
         }
-
         var {
           status,
           message
@@ -389,25 +336,29 @@ class Router {
       }
     })();
   }
-
   constructor(routes) {
-    _defineProperty(this, "add", route => new Router([...this.routes, route]));
-
+    _defineProperty(this, "old_add", route => new Router([...this.routes, route]));
+    _defineProperty(this, "add", (method, path, route) => {
+      var merged = _objectSpread2(_objectSpread2({}, typeof route === 'object' ? route : {
+        run: route
+      }), {}, {
+        method,
+        path
+      });
+      return new Router([...this.routes, merged]);
+    });
     _defineProperty(this, "merge", (pathPrefix, other) => {
       var newRoutes = other.routes.map(route => _objectSpread2(_objectSpread2({}, route), {}, {
         path: "".concat(pathPrefix).concat(route.path)
       }));
       return new Router([...this.routes, ...newRoutes]);
     });
-
     _defineProperty(this, "toFindMyWay", server => {
       var instance = fmw__default["default"]({
         ignoreTrailingSlash: true,
-
         defaultRoute(req, serverResponse) {
           return _asyncToGenerator(function* () {
             var _req$url;
-
             var res = new KaitoResponse(serverResponse);
             var message = "Cannot ".concat(req.method, " ").concat((_req$url = req.url) !== null && _req$url !== void 0 ? _req$url : '/');
             res.status(404).json({
@@ -424,9 +375,7 @@ class Router {
             };
           })();
         }
-
       });
-
       var _loop = function _loop(route) {
         var handler = /*#__PURE__*/function () {
           var _ref = _asyncToGenerator(function* (incomingMessage, serverResponse, params) {
@@ -438,85 +387,72 @@ class Router {
               res
             });
           });
-
           return function handler(_x, _x2, _x3) {
             return _ref.apply(this, arguments);
           };
         }();
-
         if (route.method === '*') {
           instance.all(route.path, handler);
           return "continue";
         }
-
         instance.on(route.method, route.path, handler);
       };
-
       for (var route of this.routes) {
         var _ret = _loop(route);
-
         if (_ret === "continue") continue;
       }
-
       return instance;
     });
-
     this.routes = routes;
   }
 
+  /**
+   * Adds a new route to the router
+   * @param route The route specification to add to this router
+   * @returns A new router with this route added
+   * @deprecated Use `Router#add` instead
+   */
 }
-
 _defineProperty(Router, "create", () => new Router([]));
 
 function createFMWServer(config) {
   var _config$rawRoutes;
-
   var fmw = config.router.toFindMyWay(config);
   var rawRoutes = (_config$rawRoutes = config.rawRoutes) !== null && _config$rawRoutes !== void 0 ? _config$rawRoutes : {};
-
   for (var method in rawRoutes) {
     if (!Object.prototype.hasOwnProperty.call(rawRoutes, method)) {
       continue;
     }
-
     var routes = rawRoutes[method];
-
     if (!routes || routes.length === 0) {
       continue;
     }
-
     for (var route of routes) {
       if (method === '*') {
         fmw.all(route.path, route.handler);
         continue;
       }
-
       fmw[method.toLowerCase()](route.path, route.handler);
     }
   }
-
   var server = http__namespace.createServer( /*#__PURE__*/function () {
     var _ref = _asyncToGenerator(function* (req, res) {
       var before;
-
       if (config.before) {
         before = yield config.before(req, res);
       } else {
         before = undefined;
-      } // If the user has sent a response (e.g. replying to CORS), we don't want to do anything else.
-
+      }
 
+      // If the user has sent a response (e.g. replying to CORS), we don't want to do anything else.
       if (res.headersSent) {
         return;
       }
-
       var result = yield fmw.lookup(req, res);
-
       if ('after' in config && config.after) {
         yield config.after(before, result);
       }
     });
-
     return function (_x, _x2) {
       return _ref.apply(this, arguments);
     };