@kaito-http/core 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/kaito-http-core.js

@@ -1,534 +0,0 @@
-import { TLSSocket } from 'node:tls';
-import { parse } from 'content-type';
-import { Readable } from 'node:stream';
-import { json } from 'node:stream/consumers';
-import getRawBody from 'raw-body';
-import fmw from 'find-my-way';
-import { serialize } from 'cookie';
-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 {
-    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 ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    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 = 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 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);
-    this.raw.setHeader('Content-Type', 'application/json');
-    this.raw.setHeader('Content-Length', Buffer.byteLength(json));
-    this.raw.end(json);
-    return this;
-  }
-}
-
-var _Router;
-var getSend = res => (status, response) => {
-  if (res.raw.headersSent) {
-    return;
-  }
-  res.status(status).json(response);
-};
-class Router {
-  static parseQuery(schema, url) {
-    if (!schema) {
-      return {};
-    }
-    var result = {};
-    for (var [key, value] of url.searchParams.entries()) {
-      var parsable = schema[key];
-      if (!parsable) {
-        continue;
-      }
-      var parsed = parsable.parse(value);
-      result[key] = parsed;
-    }
-    return result;
-  }
-  static handle(
-  // Allow for any server to be passed
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  server, route, options) {
-    return _asyncToGenerator(function* () {
-      var send = getSend(options.res);
-      try {
-        var _yield$route$body$par, _route$body;
-        var rootCtx = yield server.getContext(options.req, options.res);
-        var ctx = yield route.through(rootCtx);
-        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 = Router.parseQuery(route.query, options.req.url);
-        var result = yield route.run({
-          ctx,
-          body,
-          query,
-          params: options.params
-        });
-        if (options.res.raw.headersSent) {
-          return {
-            success: true,
-            data: result
-          };
-        }
-        send(200, {
-          success: true,
-          data: result,
-          message: 'OK'
-        });
-        return {
-          success: true,
-          data: result
-        };
-      } catch (e) {
-        var error = WrappedError.maybe(e);
-        if (error instanceof KaitoError) {
-          send(error.status, {
-            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'
-        }));
-        send(status, {
-          success: false,
-          data: null,
-          message
-        });
-        return {
-          success: false,
-          data: {
-            status,
-            message
-          }
-        };
-      }
-    })();
-  }
-  constructor(routes, options) {
-    var _this = this;
-    /**
-     * Adds a new route to the router
-     * @deprecated Use the method-specific methods instead
-     */
-    _defineProperty(this, "add", (method, path, route) => {
-      var merged = _objectSpread2(_objectSpread2({}, typeof route === 'object' ? route : {
-        run: route
-      }), {}, {
-        method,
-        path,
-        through: this.routerOptions.through
-      });
-      return new Router([...this.routes, merged], this.routerOptions);
-    });
-    _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], this.routerOptions);
-    });
-    // Allow for any server context to be passed
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    _defineProperty(this, "freeze", 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 : '/');
-            getSend(res)(404, {
-              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 1; // continue
-        }
-        instance.on(_route.method, _route.path, handler);
-      };
-      for (var _route2 of this.routes) {
-        if (_loop(_route2)) continue;
-      }
-      return instance;
-    });
-    _defineProperty(this, "method", method => (path, route) => {
-      return this.add(method, path, route);
-    });
-    _defineProperty(this, "get", this.method('GET'));
-    _defineProperty(this, "post", this.method('POST'));
-    _defineProperty(this, "put", this.method('PUT'));
-    _defineProperty(this, "patch", this.method('PATCH'));
-    _defineProperty(this, "delete", this.method('DELETE'));
-    _defineProperty(this, "head", this.method('HEAD'));
-    _defineProperty(this, "options", this.method('OPTIONS'));
-    _defineProperty(this, "through", transform => new Router(this.routes, {
-      through: function () {
-        var _through = _asyncToGenerator(function* (context) {
-          var fromCurrentRouter = yield _this.routerOptions.through(context);
-          return transform(fromCurrentRouter);
-        });
-        function through(_x4) {
-          return _through.apply(this, arguments);
-        }
-        return through;
-      }()
-    }));
-    this.routerOptions = options;
-    this.routes = new Set(routes);
-  }
-}
-_Router = Router;
-_defineProperty(Router, "create", () => new _Router([], {
-  through: function () {
-    var _through2 = _asyncToGenerator(function* (context) {
-      return context;
-    });
-    function through(_x5) {
-      return _through2.apply(this, arguments);
-    }
-    return through;
-  }()
-}));
-
-/**
- * @deprecated use `createUtilities` instead
- */
-function createGetContext(callback) {
-  return callback;
-}
-
-/**
- * A helper function to create typed necessary functions
- *
- * @example
- * ```ts
- * const {router, getContext} = createUtilities(async (req, res) => {
- *   // Return context here
- * })
- *
- * const app = router().get('/', async () => "hello");
- *
- * const server = createServer({
- *   router: app,
- *   getContext,
- *   // ...
- * });
- * ```
- */
-function createUtilities(getContext) {
-  return {
-    getContext,
-    router: () => Router.create()
-  };
-}
-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();
-}
-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(req.raw);
-    var {
-      type
-    } = parse(req.headers['content-type']);
-    switch (type) {
-      case 'application/json':
-        {
-          return json(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 _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 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 : []);
-  }
-}
-
-function createFMWServer(config) {
-  var _config$rawRoutes;
-  var router = config.router.freeze(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 === '*') {
-        router.all(route.path, route.handler);
-        continue;
-      }
-      router[method.toLowerCase()](route.path, route.handler);
-    }
-  }
-  var server = http.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 (res.headersSent) {
-        return;
-      }
-      var result = yield router.lookup(req, res);
-      if ('after' in config && config.after) {
-        yield config.after(before, result);
-      }
-    });
-    return function (_x, _x2) {
-      return _ref.apply(this, arguments);
-    };
-  }());
-  return {
-    server,
-    fmw: router
-  };
-}
-function createServer(config) {
-  return createFMWServer(config).server;
-}
-
-export { KaitoError, KaitoRequest, KaitoResponse, Router, WrappedError, createFMWServer, createGetContext, createServer, createUtilities, getBody, getLastEntryInMultiHeaderValue };