@kaito-http/core 2.2.6 → 2.3.1

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

@@ -1,42 +1,21 @@
-import http from 'http';
+import * as http from 'http';
+import fmw from 'find-my-way';
 import { TLSSocket } from 'tls';
 import getRawBody from 'raw-body';
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    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;
-    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);
-    });
+function createFMWServer(config) {
+  var fmw = config.router.toFindMyWay(config);
+  var server = http.createServer((req, res) => {
+    fmw.lookup(req, res);
+  });
+  return {
+    server,
+    fmw
   };
 }
+function createServer(config) {
+  return createFMWServer(config).server;
+}
 
 function _defineProperty(obj, key, value) {
   if (key in obj) {
@@ -91,6 +70,42 @@ function _objectSpread2(target) {
   return target;
 }
 
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    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;
+    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);
+    });
+  };
+}
+
 class WrappedError extends Error {
   static maybe(maybeError) {
     if (maybeError instanceof Error) {
@@ -110,7 +125,17 @@ class WrappedError extends Error {
   }
 
 }
+class KaitoError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
 
+}
+
+function createGetContext(callback) {
+  return callback;
+}
 function getLastEntryInMultiHeaderValue(headerValue) {
   var normalized = Array.isArray(headerValue) ? headerValue.join(',') : headerValue;
   var lastIndex = normalized.lastIndexOf(',');
@@ -128,8 +153,7 @@ function normalizePath(path) {
   }
 
   return result;
-} // Type for import('http').METHODS
-
+}
 function getInput(_x) {
   return _getInput.apply(this, arguments);
 }
@@ -165,6 +189,8 @@ function _getInput() {
 
 class KaitoRequest {
   constructor(raw) {
+    _defineProperty(this, "_url", null);
+
     this.raw = raw;
   }
 
@@ -175,7 +201,12 @@ class KaitoRequest {
   }
 
   get url() {
-    return new URL(this.fullURL);
+    if (this._url) {
+      return this._url;
+    }
+
+    this._url = new URL(this.fullURL);
+    return this._url;
   }
 
   get method() {
@@ -231,141 +262,34 @@ class KaitoResponse {
 
 }
 
-function createGetContext(getContext) {
-  return getContext;
-}
 class Router {
-  static patternize(path) {
-    var normalized = normalizePath(path);
-    return new RegExp("^".concat(normalized, "/?$"), 'i');
-  }
-
-  constructor(procs) {
-    _defineProperty(this, "create", method => (path, proc) => {
-      var pattern = Router.patternize(path);
-
-      var merged = _objectSpread2(_objectSpread2({}, this.procs), {}, {
-        [path]: _objectSpread2(_objectSpread2({}, proc), {}, {
-          method,
-          path,
-          pattern
-        })
-      });
-
-      return new Router(merged);
-    });
-
-    _defineProperty(this, "merge", (prefix, router) => {
-      var newProcs = Object.entries(router.getProcs()).reduce((all, entry) => {
-        var [path, proc] = entry;
-        var newPath = "".concat(prefix).concat(path);
-        return _objectSpread2(_objectSpread2({}, all), {}, {
-          ["".concat(prefix).concat(path)]: _objectSpread2(_objectSpread2({}, proc), {}, {
-            path: newPath,
-            pattern: Router.patternize(newPath)
-          })
-        });
-      }, {});
-
-      var mergedProcs = _objectSpread2(_objectSpread2({}, this.procs), newProcs);
-
-      return new Router(mergedProcs);
-    });
-
-    _defineProperty(this, "get", this.create('GET'));
-
-    _defineProperty(this, "post", this.create('POST'));
-
-    _defineProperty(this, "put", this.create('PUT'));
-
-    _defineProperty(this, "patch", this.create('PATCH'));
-
-    _defineProperty(this, "delete", this.create('DELETE'));
-
-    _defineProperty(this, "head", this.create('HEAD'));
-
-    _defineProperty(this, "options", this.create('OPTIONS'));
-
-    _defineProperty(this, "connect", this.create('CONNECT'));
-
-    _defineProperty(this, "trace", this.create('TRACE'));
-
-    _defineProperty(this, "acl", this.create('ACL'));
-
-    _defineProperty(this, "bind", this.create('BIND'));
-
-    this.procs = procs;
-    this._procsArray = Object.values(procs);
+  static create() {
+    return new Router({});
   }
 
-  getProcs() {
-    return this.procs;
-  }
-
-  find(method, url) {
-    for (var proc of this._procsArray) {
-      if (proc.method !== method) {
-        continue;
-      }
-
-      if (proc.pattern.test(url)) {
-        return proc;
-      }
-    }
-
-    return null;
-  }
-
-}
-class KaitoError extends Error {
-  constructor(status, message, cause) {
-    super(message);
-    this.status = status;
-    this.cause = cause;
-  }
-
-}
-function createRouter() {
-  return new Router({});
-}
-function createServer(config) {
-  var log = message => {
-    if (config.log === undefined) {
-      console.log(message);
-    } else if (config.log) {
-      config.log(message);
-    }
-  };
-
-  return http.createServer( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (incomingMessage, serverResponse) {
-      var start = Date.now();
-      var req = new KaitoRequest(incomingMessage);
-      var res = new KaitoResponse(serverResponse);
-
+  static handle(server, options) {
+    return _asyncToGenerator(function* () {
       try {
-        var _handler$input, _yield$getInput;
-
-        var handler = config.router.find(req.method, req.url.pathname);
+        var _options$route$input$, _options$route$input;
 
-        if (!handler) {
-          throw new KaitoError(404, "Cannot ".concat(req.method, " this route."));
-        }
-
-        var input = (_handler$input = handler.input) === null || _handler$input === void 0 ? void 0 : _handler$input.parse((_yield$getInput = yield getInput(req)) !== null && _yield$getInput !== void 0 ? _yield$getInput : undefined);
-        var context = yield config.getContext(req, res);
-        var data = yield handler.run({
+        var context = yield server.getContext(options.req, options.res);
+        var body = yield getInput(options.req);
+        var input = (_options$route$input$ = (_options$route$input = options.route.input) === null || _options$route$input === void 0 ? void 0 : _options$route$input.parse(body)) !== null && _options$route$input$ !== void 0 ? _options$route$input$ : undefined;
+        var result = yield options.route.run({
           ctx: context,
-          input
+          input,
+          params: options.params
         });
-        res.json({
+        options.res.status(200).json({
           success: true,
-          data,
+          data: result,
           message: 'OK'
         });
-      } catch (error) {
+      } catch (e) {
+        var error = WrappedError.maybe(e);
+
         if (error instanceof KaitoError) {
-          res.status(error.status).json({
+          options.res.status(error.status).json({
             success: false,
             data: null,
             message: error.message
@@ -374,31 +298,110 @@ function createServer(config) {
         }
 
         var {
-          status: _status,
-          message: _message
-        } = yield config.onError({
-          error: WrappedError.maybe(error),
-          req,
-          res
+          status,
+          message
+        } = yield server.onError({
+          error,
+          req: options.req,
+          res: options.res
         }).catch(() => ({
           status: 500,
-          message: 'Something went wrong'
+          message: 'Internal Server Error'
         }));
-        res.status(_status).json({
+        options.res.status(status).json({
           success: false,
           data: null,
-          message: _message
+          message
         });
-      } finally {
-        var finish = Date.now();
-        log("".concat(req.method, " ").concat(req.fullURL, " ").concat(res.raw.statusCode, " ").concat(finish - start, "ms"));
       }
-    });
+    })();
+  }
+
+  constructor(routes) {
+    _defineProperty(this, "get", this.make('GET'));
+
+    _defineProperty(this, "post", this.make('POST'));
+
+    _defineProperty(this, "head", this.make('HEAD'));
+
+    _defineProperty(this, "put", this.make('PUT'));
+
+    _defineProperty(this, "patch", this.make('PATCH'));
+
+    this.routes = routes;
+  }
+
+  merge(prefix, router) {
+    var newRoutes = Object.fromEntries(Object.entries(router.routes).map(_ref => {
+      var [k, v] = _ref;
+      return ["".concat(prefix).concat(k), v];
+    }));
+    return new Router(_objectSpread2(_objectSpread2({}, this.routes), newRoutes));
+  }
+
+  toFindMyWay(server) {
+    var _this = this;
+
+    var instance = fmw({
+      ignoreTrailingSlash: true,
 
-    return function (_x, _x2) {
-      return _ref.apply(this, arguments);
+      defaultRoute(req, serverResponse) {
+        var _req$url;
+
+        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 : '/')
+        });
+      }
+
+    }); // eslint-disable-next-line guard-for-in
+
+    var _loop = function _loop(path) {
+      var route = _this.routes[path];
+      instance.on(route.method, path, /*#__PURE__*/function () {
+        var _ref2 = _asyncToGenerator(function* (incomingMessage, serverResponse, params) {
+          var req = new KaitoRequest(incomingMessage);
+          var res = new KaitoResponse(serverResponse);
+          yield Router.handle(server, {
+            route,
+            params,
+            req,
+            res
+          });
+        });
+
+        return function (_x, _x2, _x3) {
+          return _ref2.apply(this, arguments);
+        };
+      }());
+    };
+
+    for (var path in this.routes) {
+      _loop(path);
+    }
+
+    return instance;
+  }
+
+  make(method) {
+    return (path, route) => {
+      var mergedRoute = _objectSpread2(_objectSpread2({}, route), {}, {
+        method
+      });
+
+      return new Router(_objectSpread2(_objectSpread2({}, this.routes), {}, {
+        [path]: mergedRoute
+      }));
     };
-  }());
+  }
+
 }
+/**
+ * @deprecated Please use Router#create instead
+ */
+
+var createRouter = Router.create;
 
-export { KaitoError, Router, createGetContext, createRouter, createServer };
+export { KaitoError, KaitoRequest, KaitoResponse, Router, WrappedError, createFMWServer, createGetContext, createRouter, createServer, getInput, getLastEntryInMultiHeaderValue, normalizePath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaito-http/core",
-  "version": "2.2.6",
+  "version": "2.3.1",
   "description": "Functional HTTP Framework for TypeScript",
   "repository": "https://github.com/kaito-http/kaito",
   "author": "Alistair Smith <hi@alistair.sh>",
@@ -32,6 +32,7 @@
     "framework"
   ],
   "dependencies": {
+    "find-my-way": "^5.5.0",
     "raw-body": "^2.5.1"
   }
 }