@kaito-http/core 2.5.0 → 2.7.0

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

@@ -4,9 +4,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var node_tls = require('node:tls');
 var contentType = require('content-type');
+var node_stream = require('node:stream');
+var consumers = require('node:stream/consumers');
 var getRawBody = require('raw-body');
 var cookie = require('cookie');
 var fmw = require('find-my-way');
+var zod = require('zod');
 var http = require('node:http');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
@@ -38,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) {
@@ -71,7 +69,6 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
 
@@ -83,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);
     });
   };
@@ -119,154 +111,124 @@ function getLastEntryInMultiHeaderValue(headerValue) {
   var lastIndex = normalized.lastIndexOf(',');
   return lastIndex === -1 ? normalized.trim() : normalized.slice(lastIndex + 1).trim();
 }
-function getInput(_x) {
-  return _getInput.apply(this, arguments);
+function getBody(_x) {
+  return _getBody.apply(this, arguments);
 }
-
-function _getInput() {
-  _getInput = _asyncToGenerator(function* (req) {
-    if (req.method === 'GET') {
-      var input = req.url.searchParams.get('input');
-
-      if (!input) {
-        return null;
-      }
-
-      return JSON.parse(input);
-    }
-
-    var buffer = yield getRawBody__default["default"](req.raw);
-
+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 JSON.parse(buffer.toString());
+          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;
         }
     }
   });
-  return _getInput.apply(this, arguments);
+  return _getBody.apply(this, arguments);
 }
 
 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
@@ -274,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');
@@ -294,66 +253,112 @@ 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;
 }
 
 class Router {
+  static handle(server, route, options) {
+    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())) : {};
+        var result = yield route.run({
+          ctx,
+          body,
+          query,
+          params: options.params
+        });
+        options.res.status(200).json({
+          success: true,
+          data: result,
+          message: 'OK'
+        });
+        return {
+          success: true,
+          data: result
+        };
+      } catch (e) {
+        var error = WrappedError.maybe(e);
+        if (error instanceof KaitoError) {
+          options.res.status(error.status).json({
+            success: false,
+            data: null,
+            message: error.message
+          });
+          return;
+        }
+        var {
+          status,
+          message
+        } = yield server.onError({
+          error,
+          req: options.req,
+          res: options.res
+        }).catch(() => ({
+          status: 500,
+          message: 'Internal Server Error'
+        }));
+        options.res.status(status).json({
+          success: false,
+          data: null,
+          message
+        });
+        return {
+          success: false,
+          data: {
+            status,
+            message
+          }
+        };
+      }
+    })();
+  }
   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({
@@ -370,9 +375,7 @@ class Router {
             };
           })();
         }
-
       });
-
       var _loop = function _loop(route) {
         var handler = /*#__PURE__*/function () {
           var _ref = _asyncToGenerator(function* (incomingMessage, serverResponse, params) {
@@ -384,146 +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;
   }
 
-  static handle(server, route, options) {
-    return _asyncToGenerator(function* () {
-      try {
-        var _route$input$parse, _route$input;
-
-        var ctx = yield server.getContext(options.req, options.res);
-        var body = yield getInput(options.req);
-        var input = (_route$input$parse = (_route$input = route.input) === null || _route$input === void 0 ? void 0 : _route$input.parse(body)) !== null && _route$input$parse !== void 0 ? _route$input$parse : undefined;
-        var result = yield route.run({
-          ctx,
-          input,
-          params: options.params
-        });
-        options.res.status(200).json({
-          success: true,
-          data: result,
-          message: 'OK'
-        });
-        return {
-          success: true,
-          data: result
-        };
-      } catch (e) {
-        var error = WrappedError.maybe(e);
-
-        if (error instanceof KaitoError) {
-          options.res.status(error.status).json({
-            success: false,
-            data: null,
-            message: error.message
-          });
-          return;
-        }
-
-        var {
-          status,
-          message
-        } = yield server.onError({
-          error,
-          req: options.req,
-          res: options.res
-        }).catch(() => ({
-          status: 500,
-          message: 'Internal Server Error'
-        }));
-        options.res.status(status).json({
-          success: false,
-          data: null,
-          message
-        });
-        return {
-          success: false,
-          data: {
-            status,
-            message
-          }
-        };
-      }
-    })();
-  }
-
+  /**
+   * 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 = null;
-      } // If the user has sent a response (e.g. replying to CORS), we don't want to do anything else.
-
+        before = undefined;
+      }
 
+      // 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);
     };
@@ -545,5 +474,5 @@ exports.WrappedError = WrappedError;
 exports.createFMWServer = createFMWServer;
 exports.createGetContext = createGetContext;
 exports.createServer = createServer;
-exports.getInput = getInput;
+exports.getBody = getBody;
 exports.getLastEntryInMultiHeaderValue = getLastEntryInMultiHeaderValue;