@kaito-http/core 2.0.1 → 2.2.0

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

@@ -2,11 +2,14 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var fastify = require('fastify');
+var http = require('http');
+var tls = require('tls');
+var getRawBody = require('raw-body');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
-var fastify__default = /*#__PURE__*/_interopDefault(fastify);
+var http__default = /*#__PURE__*/_interopDefault(http);
+var getRawBody__default = /*#__PURE__*/_interopDefault(getRawBody);
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -97,35 +100,176 @@ function _objectSpread2(target) {
   return target;
 }
 
-exports.Method = void 0;
+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;
+  }
+
+}
+
+function getLastEntryInMultiHeaderValue(headerValue) {
+  var normalized = Array.isArray(headerValue) ? headerValue.join(',') : headerValue;
+  var lastIndex = normalized.lastIndexOf(',');
+  return lastIndex === -1 ? normalized.trim() : normalized.slice(lastIndex + 1).trim();
+} // Type for import('http').METHODS
+
+function getInput(_x) {
+  return _getInput.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);
+
+    switch (req.headers['content-type']) {
+      case 'application/json':
+        {
+          return JSON.parse(buffer.toString());
+        }
+
+      default:
+        {
+          return null;
+        }
+    }
+  });
+  return _getInput.apply(this, arguments);
+}
+
+class KaitoRequest {
+  constructor(raw) {
+    this.raw = raw;
+  }
+
+  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 : '');
+  }
+
+  get url() {
+    return new URL(this.fullURL);
+  }
+
+  get method() {
+    if (!this.raw.method) {
+      throw new Error('Request method is not defined, somehow...');
+    }
+
+    return this.raw.method;
+  }
+
+  get protocol() {
+    if (this.raw.socket instanceof tls.TLSSocket) {
+      return this.raw.socket.encrypted ? 'https' : 'http';
+    }
+
+    return 'http';
+  }
+
+  get headers() {
+    return this.raw.headers;
+  }
+
+  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;
+  }
+
+  header(key, value) {
+    this.raw.setHeader(key, value);
+    return this;
+  }
+
+  status(code) {
+    this.raw.statusCode = code;
+    return this;
+  }
 
-(function (Method) {
-  Method["GET"] = "GET";
-  Method["POST"] = "POST";
-  Method["PATCH"] = "PATCH";
-  Method["DELETE"] = "DELETE";
-})(exports.Method || (exports.Method = {}));
+  json(data) {
+    var json = JSON.stringify(data);
+    this.raw.setHeader('Content-Type', 'application/json');
+    this.raw.setHeader('Content-Length', Buffer.byteLength(json));
+    this.raw.end(json);
+    return this;
+  }
+
+}
 
 function createGetContext(getContext) {
   return getContext;
 }
 class Router {
+  /**
+   * Ensures that the path does not start or end with a slash.
+   * @param path
+   * @private
+   */
+  static stripSlashes(path) {
+    if (path.startsWith('/')) {
+      path = path.slice(1);
+    }
+
+    if (path.endsWith('/')) {
+      path = path.slice(-1);
+    }
+
+    return path;
+  }
+
   constructor(procs) {
-    _defineProperty(this, "create", method => (name, proc) => {
-      return new Router(_objectSpread2(_objectSpread2({}, this.procs), {}, {
-        [name]: _objectSpread2(_objectSpread2({}, proc), {}, {
+    _defineProperty(this, "create", method => (path, proc) => {
+      var stripped = Router.stripSlashes(path);
+      var pattern = new RegExp("^/".concat(stripped, "/?$"), 'i');
+
+      var merged = _objectSpread2(_objectSpread2({}, this.procs), {}, {
+        [path]: _objectSpread2(_objectSpread2({}, proc), {}, {
           method,
-          name
+          path,
+          pattern
         })
-      }));
+      });
+
+      return new Router(merged);
     });
 
     _defineProperty(this, "merge", (prefix, router) => {
       var newProcs = Object.entries(router.getProcs()).reduce((all, entry) => {
-        var [name, proc] = entry;
+        var [path, proc] = entry;
         return _objectSpread2(_objectSpread2({}, all), {}, {
-          ["".concat(prefix).concat(name)]: _objectSpread2(_objectSpread2({}, proc), {}, {
-            name: "".concat(prefix).concat(name)
+          ["".concat(prefix).concat(path)]: _objectSpread2(_objectSpread2({}, proc), {}, {
+            path: "".concat(prefix).concat(path)
           })
         });
       }, {});
@@ -135,26 +279,55 @@ class Router {
       return new Router(mergedProcs);
     });
 
-    _defineProperty(this, "get", this.create(exports.Method.GET));
+    _defineProperty(this, "get", this.create('GET'));
+
+    _defineProperty(this, "post", this.create('POST'));
 
-    _defineProperty(this, "post", this.create(exports.Method.POST));
+    _defineProperty(this, "put", this.create('PUT'));
 
-    _defineProperty(this, "patch", this.create(exports.Method.PATCH));
+    _defineProperty(this, "patch", this.create('PATCH'));
 
-    _defineProperty(this, "delete", this.create(exports.Method.DELETE));
+    _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);
   }
 
   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(code, message, cause) {
+  constructor(status, message, cause) {
     super(message);
-    this.code = code;
+    this.status = status;
     this.cause = cause;
   }
 
@@ -163,79 +336,76 @@ function createRouter() {
   return new Router({});
 }
 function createServer(config) {
-  var tree = config.router.getProcs();
-  var app = fastify__default["default"]();
-  app.setErrorHandler( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(function* (error, req, res) {
-      if (error instanceof KaitoError) {
-        yield res.status(error.code).send({
-          success: false,
-          data: null,
-          message: error.message
-        });
-        return;
-      }
-
-      var {
-        code,
-        message
-      } = yield config.onError({
-        error,
-        req,
-        res
-      }).catch(() => ({
-        code: 500,
-        message: 'Something went wrong'
-      }));
-      yield res.status(code).send({
-        success: false,
-        data: null,
-        message
-      });
-    });
-
-    return function (_x, _x2, _x3) {
-      return _ref.apply(this, arguments);
-    };
-  }());
-  app.all('*', /*#__PURE__*/function () {
-    var _ref2 = _asyncToGenerator(function* (req, res) {
-      var _handler$input$parse, _handler$input;
-
-      var logMessage = "".concat(req.hostname, " ").concat(req.method, " ").concat(req.routerPath);
+  var log = message => {
+    if (config.log === undefined) {
+      console.log(message);
+    } else if (config.log) {
+      config.log(message);
+    }
+  };
 
-      if (config.log === undefined) {
-        console.log(logMessage);
-      } else if (config.log) {
-        config.log(logMessage);
-      }
+  return http__default["default"].createServer( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (incomingMessage, serverResponse) {
+      var start = Date.now();
+      var req = new KaitoRequest(incomingMessage);
+      var res = new KaitoResponse(serverResponse);
 
-      var url = new URL("".concat(req.protocol, "://").concat(req.hostname).concat(req.url));
-      var handler = tree[url.pathname];
+      try {
+        var _handler$input, _yield$getInput;
 
-      if (!handler) {
-        throw new KaitoError(404, "Cannot ".concat(req.method, " this route."));
-      }
+        var handler = config.router.find(req.method, req.url.pathname);
 
-      var context = yield config.getContext(req, res); // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        if (!handler) {
+          throw new KaitoError(404, "Cannot ".concat(req.method, " this route."));
+        }
 
-      var input = (_handler$input$parse = (_handler$input = handler.input) === null || _handler$input === void 0 ? void 0 : _handler$input.parse(req.method === 'GET' ? req.query : req.body)) !== null && _handler$input$parse !== void 0 ? _handler$input$parse : null;
-      yield res.send({
-        success: true,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        data: yield handler.run({
+        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({
           ctx: context,
           input
-        }),
-        message: 'OK'
-      });
+        });
+        res.json({
+          success: true,
+          data,
+          message: 'OK'
+        });
+      } catch (error) {
+        if (error instanceof KaitoError) {
+          res.status(error.status).json({
+            success: false,
+            data: null,
+            message: error.message
+          });
+          return;
+        }
+
+        var {
+          status: _status,
+          message: _message
+        } = yield config.onError({
+          error: WrappedError.maybe(error),
+          req,
+          res
+        }).catch(() => ({
+          status: 500,
+          message: 'Something went wrong'
+        }));
+        res.status(_status).json({
+          success: false,
+          data: null,
+          message: _message
+        });
+      } finally {
+        var finish = Date.now();
+        log("".concat(req.method, " ").concat(req.fullURL, " ").concat(res.raw.statusCode, " ").concat(finish - start, "ms"));
+      }
     });
 
-    return function (_x4, _x5) {
-      return _ref2.apply(this, arguments);
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
     };
   }());
-  return app;
 }
 
 exports.KaitoError = KaitoError;