@kaito-http/core 2.4.0 → 2.5.0

package/dist/kaito-http-core.esm.js

@@ -1,8 +1,51 @@
-import * as http from 'http';
-import fmw from 'find-my-way';
-import { TLSSocket } from 'tls';
+import { TLSSocket } from 'node:tls';
 import { parse } from 'content-type';
 import getRawBody from 'raw-body';
+import { serialize } from 'cookie';
+import fmw from 'find-my-way';
+import * as http from 'node:http';
+
+class WrappedError extends Error {
+  static maybe(maybeError) {
+    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) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -40,118 +83,6 @@ function _asyncToGenerator(fn) {
   };
 }
 
-function createFMWServer(config) {
-  var fmw = config.router.toFindMyWay(config);
-  var server = http.createServer( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (req, res) {
-      for (var fn of (_config$before = config.before) !== null && _config$before !== void 0 ? _config$before : []) {
-        var _config$before;
-
-        // Disabled because we need these to run in order!
-        // eslint-disable-next-line no-await-in-loop
-        yield fn(req, res);
-      }
-
-      if (req.method === 'OPTIONS') {
-        return;
-      }
-
-      fmw.lookup(req, res);
-    });
-
-    return function (_x, _x2) {
-      return _ref.apply(this, arguments);
-    };
-  }());
-  return {
-    server,
-    fmw
-  };
-}
-function createServer(config) {
-  return createFMWServer(config).server;
-}
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
-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);
-  }
-
-  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));
-      });
-    }
-  }
-
-  return target;
-}
-
-class WrappedError extends Error {
-  static maybe(maybeError) {
-    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 createGetContext(callback) {
   return callback;
 }
@@ -194,6 +125,11 @@ function _getInput() {
 
       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;
         }
     }
@@ -207,12 +143,21 @@ class KaitoRequest {
 
     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) {
@@ -222,6 +167,10 @@ class KaitoRequest {
     this._url = new URL(this.fullURL);
     return this._url;
   }
+  /**
+   * The HTTP method of the request.
+   */
+
 
   get method() {
     if (!this.raw.method) {
@@ -230,6 +179,10 @@ class KaitoRequest {
 
     return this.raw.method;
   }
+  /**
+   * The protocol of the request, either `http` or `https`.
+   */
+
 
   get protocol() {
     if (this.raw.socket instanceof TLSSocket) {
@@ -238,10 +191,18 @@ class KaitoRequest {
 
     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;
@@ -255,16 +216,48 @@ 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
+   * @param value The value of the cookie
+   * @param options The options for the cookie
+   * @returns The response object
+   */
+
+
+  cookie(name, value, options) {
+    this.raw.setHeader('Set-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);
@@ -276,9 +269,117 @@ class KaitoResponse {
 
 }
 
+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);
+  }
+
+  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));
+      });
+    }
+  }
+
+  return target;
+}
+
 class Router {
-  static create() {
-    return new Router([]);
+  constructor(routes) {
+    _defineProperty(this, "add", route => new Router([...this.routes, route]));
+
+    _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({
+        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({
+              success: false,
+              data: null,
+              message
+            });
+            return {
+              success: false,
+              data: {
+                status: 404,
+                message
+              }
+            };
+          })();
+        }
+
+      });
+
+      var _loop = function _loop(route) {
+        var handler = /*#__PURE__*/function () {
+          var _ref = _asyncToGenerator(function* (incomingMessage, serverResponse, params) {
+            var req = new KaitoRequest(incomingMessage);
+            var res = new KaitoResponse(serverResponse);
+            return Router.handle(server, route, {
+              params,
+              req,
+              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) {
@@ -286,11 +387,11 @@ class Router {
       try {
         var _route$input$parse, _route$input;
 
-        var context = yield server.getContext(options.req, options.res);
+        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: context,
+          ctx,
           input,
           params: options.params
         });
@@ -299,6 +400,10 @@ class Router {
           data: result,
           message: 'OK'
         });
+        return {
+          success: true,
+          data: result
+        };
       } catch (e) {
         var error = WrappedError.maybe(e);
 
@@ -327,100 +432,81 @@ class Router {
           data: null,
           message
         });
+        return {
+          success: false,
+          data: {
+            status,
+            message
+          }
+        };
       }
     })();
   }
 
-  constructor(routes) {
-    this.routes = routes;
-  }
+}
 
-  toFindMyWay(server) {
-    var instance = fmw({
-      ignoreTrailingSlash: true,
+_defineProperty(Router, "create", () => new Router([]));
 
-      defaultRoute(req, serverResponse) {
-        var _req$url;
+function createFMWServer(config) {
+  var _config$rawRoutes;
 
-        var res = new KaitoResponse(serverResponse);
-        res.status(404).json({
-          success: false,
-          data: null,
-          message: "Cannot ".concat(req.method, " ").concat((_req$url = req.url) !== null && _req$url !== void 0 ? _req$url : '/')
-        });
-      }
+  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 _loop = function _loop(route) {
-      var handler = /*#__PURE__*/function () {
-        var _ref = _asyncToGenerator(function* (incomingMessage, serverResponse, params) {
-          var req = new KaitoRequest(incomingMessage);
-          var res = new KaitoResponse(serverResponse);
-          yield Router.handle(server, route, {
-            params,
-            req,
-            res
-          });
-        });
+    var routes = rawRoutes[method];
 
-        return function handler(_x, _x2, _x3) {
-          return _ref.apply(this, arguments);
-        };
-      }();
+    if (!routes || routes.length === 0) {
+      continue;
+    }
 
-      if (route.method === '*') {
-        instance.all(route.path, handler);
-        return "continue";
+    for (var route of routes) {
+      if (method === '*') {
+        fmw.all(route.path, route.handler);
+        continue;
       }
 
-      instance.on(route.method, route.path, handler);
-    };
-
-    for (var route of this.routes) {
-      var _ret = _loop(route);
-
-      if (_ret === "continue") continue;
+      fmw[method.toLowerCase()](route.path, route.handler);
     }
-
-    return instance;
   }
 
-  add(route) {
-    return new Router([...this.routes, route]);
-  }
+  var server = http.createServer( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (req, res) {
+      var before;
 
-  map() {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    var result = {};
+      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.
 
-    for (var route of this.routes) {
-      var _result$method;
 
-      var method = route.method;
-      result[method] = _objectSpread2(_objectSpread2({}, (_result$method = result[method]) !== null && _result$method !== void 0 ? _result$method : {}), {}, {
-        [route.path]: route
-      });
-    }
+      if (res.headersSent) {
+        return;
+      }
 
-    return result;
-  }
+      var result = yield fmw.lookup(req, res);
 
-  merge(prefix, router) {
-    return this.copyContext([...this.routes, ...router.routes.map(route => _objectSpread2(_objectSpread2({}, route), {}, {
-      path: prefix + route.path
-    }))]);
-  }
-
-  copyContext(routes) {
-    return new Router(routes);
-  }
+      if ('after' in config && config.after) {
+        yield config.after(before, result);
+      }
+    });
 
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  return {
+    server,
+    fmw
+  };
+}
+function createServer(config) {
+  return createFMWServer(config).server;
 }
-/**
- * @deprecated Please use Router#create instead
- */
-
-var createRouter = Router.create;
 
-export { KaitoError, KaitoRequest, KaitoResponse, Router, WrappedError, createFMWServer, createGetContext, createRouter, createServer, getInput, getLastEntryInMultiHeaderValue };
+export { KaitoError, KaitoRequest, KaitoResponse, Router, WrappedError, createFMWServer, createGetContext, createServer, getInput, getLastEntryInMultiHeaderValue };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaito-http/core",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Functional HTTP Framework for TypeScript",
   "repository": "https://github.com/kaito-http/kaito",
   "author": "Alistair Smith <hi@alistair.sh>",
@@ -10,9 +10,10 @@
   "types": "dist/kaito-http-core.cjs.d.ts",
   "devDependencies": {
     "@types/content-type": "^1.1.5",
-    "@types/node": "^17.0.25",
-    "typescript": "4.6",
-    "zod": "^3.14.4"
+    "@types/cookie": "^0.5.1",
+    "@types/node": "^18.7.18",
+    "typescript": "4.8",
+    "zod": "^3.19.1"
   },
   "files": [
     "package.json",
@@ -33,7 +34,8 @@
   ],
   "dependencies": {
     "content-type": "^1.0.4",
-    "find-my-way": "^5.5.0",
+    "cookie": "^0.5.0",
+    "find-my-way": "^7.1.0",
     "raw-body": "^2.5.1"
   }
 }