@kaito-http/core 2.0.1 → 2.2.0

package/dist/declarations/src/error.d.ts

@@ -0,0 +1,6 @@
+export declare class WrappedError<T> extends Error {
+    readonly data: T;
+    static maybe<T>(maybeError: T): (T & Error) | WrappedError<T>;
+    static from<T>(data: T): WrappedError<T>;
+    private constructor();
+}

package/dist/declarations/src/req.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Method } from './util';
+export declare class KaitoRequest {
+    readonly raw: IncomingMessage;
+    constructor(raw: IncomingMessage);
+    get fullURL(): string;
+    get url(): URL;
+    get method(): Method;
+    get protocol(): 'http' | 'https';
+    get headers(): import("http").IncomingHttpHeaders;
+    get hostname(): string;
+}

package/dist/declarations/src/res.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { ServerResponse } from 'http';
+export declare type ErroredAPIResponse = {
+    success: false;
+    data: null;
+    message: string;
+};
+export declare type SuccessfulAPIResponse<T> = {
+    success: true;
+    data: T;
+    message: 'OK';
+};
+export declare type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
+export declare type AnyResponse = APIResponse<unknown>;
+export declare class KaitoResponse<T = unknown> {
+    readonly raw: ServerResponse;
+    constructor(raw: ServerResponse);
+    header(key: string, value: string | readonly string[]): this;
+    status(code: number): this;
+    json(data: APIResponse<T>): this;
+}

package/dist/declarations/src/server.d.ts

@@ -1,13 +1,10 @@
 /// <reference types="node" />
-import { FastifyReply, FastifyRequest } from 'fastify';
+import http from 'http';
 import { z, ZodTypeAny } from 'zod';
-export declare enum Method {
-    GET = "GET",
-    POST = "POST",
-    PATCH = "PATCH",
-    DELETE = "DELETE"
-}
-export declare type GetContext<T> = (req: FastifyRequest, res: FastifyReply) => Promise<T>;
+import { KaitoRequest } from './req';
+import { KaitoResponse } from './res';
+import { Method } from './util';
+export declare type GetContext<T> = (req: KaitoRequest, res: KaitoResponse) => Promise<T>;
 declare type Never = [never];
 export declare function createGetContext<T>(getContext: GetContext<T>): GetContext<T>;
 export declare type InferContext<T> = T extends GetContext<infer Value> ? Value : never;
@@ -16,86 +13,136 @@ export declare type ContextWithInput<Ctx, Input> = {
     input: Input;
 };
 declare type Values<T> = T[keyof T];
-declare type Proc<Ctx, Result, Input extends z.ZodTypeAny | Never = Never> = Readonly<{
+export declare type Proc<Ctx, Result, Input extends z.ZodTypeAny | Never = Never> = Readonly<{
     input?: Input;
     run(arg: ContextWithInput<Ctx, Input extends ZodTypeAny ? z.infer<Input> : undefined>): Promise<Result>;
 }>;
-declare type ProcsInit<Ctx> = {
-    [Key in string]: Proc<Ctx, unknown, z.ZodTypeAny> & {
-        method: Method;
-        name: Key;
-    };
+export interface RouterProc<Path extends string = string, M extends Method = Method> {
+    method: M;
+    path: Path;
+    pattern: RegExp;
+}
+export declare type AnyProcs<Ctx> = {
+    [Path in string]: Proc<Ctx, unknown, z.ZodTypeAny> & RouterProc<Path>;
 };
-declare type AnyRouter<Ctx> = Router<Ctx, ProcsInit<Ctx>>;
-export declare class Router<Ctx, Procs extends ProcsInit<Ctx>> {
+export declare type AnyRouter<Ctx> = Router<Ctx, AnyProcs<Ctx>>;
+export declare class Router<Ctx, Procs extends AnyProcs<Ctx>> {
     private readonly procs;
+    private readonly _procsArray;
+    /**
+     * Ensures that the path does not start or end with a slash.
+     * @param path
+     * @private
+     */
+    private static stripSlashes;
     constructor(procs: Procs);
     getProcs(): Procs;
+    find(method: Method, url: string): (Readonly<{
+        input?: z.ZodTypeAny | undefined;
+        run(arg: ContextWithInput<Ctx, any>): Promise<unknown>;
+    }> & RouterProc<string, Method>) | null;
     private readonly create;
-    readonly merge: <Prefix extends string, NewCtx, NewProcs extends ProcsInit<NewCtx>>(prefix: Prefix, router: Router<NewCtx, NewProcs>) => Router<NewCtx & Ctx, Procs & { [Key in `${Prefix}${Extract<keyof NewProcs, string>}`]: Omit<NewProcs[Key extends `${Prefix}${infer Rest}` ? Rest : never], "name"> & {
-        name: Key;
+    readonly merge: <Prefix extends string, NewCtx, NewProcs extends AnyProcs<NewCtx>>(prefix: Prefix, router: Router<NewCtx, NewProcs>) => Router<NewCtx & Ctx, Procs & { [P in `${Prefix}${Extract<keyof NewProcs, string>}`]: Omit<NewProcs[P extends `${Prefix}${infer Rest}` ? Rest : never], "path"> & {
+        path: P;
     }; }>;
-    readonly get: <Name extends string, Result, Input extends z.ZodTypeAny>(name: Name, proc: Readonly<{
+    readonly get: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & RouterProc<Path, "GET">>>;
+    readonly post: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & RouterProc<Path, "POST">>>;
+    readonly put: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & RouterProc<Path, "PUT">>>;
+    readonly patch: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & RouterProc<Path, "PATCH">>>;
+    readonly delete: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & RouterProc<Path, "DELETE">>>;
+    readonly head: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & RouterProc<Path, "HEAD">>>;
+    readonly options: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & RouterProc<Path, "OPTIONS">>>;
+    readonly connect: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
         input?: Input | undefined;
         run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
-    }>) => Router<Ctx, Procs & Record<Name, Readonly<{
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
         input?: Input | undefined;
         run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
-    }> & {
-        method: Method.GET;
-        name: Name;
-    }>>;
-    readonly post: <Name extends string, Result, Input extends z.ZodTypeAny>(name: Name, proc: Readonly<{
+    }> & RouterProc<Path, "CONNECT">>>;
+    readonly trace: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
         input?: Input | undefined;
         run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
-    }>) => Router<Ctx, Procs & Record<Name, Readonly<{
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
         input?: Input | undefined;
         run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
-    }> & {
-        method: Method.POST;
-        name: Name;
-    }>>;
-    readonly patch: <Name extends string, Result, Input extends z.ZodTypeAny>(name: Name, proc: Readonly<{
+    }> & RouterProc<Path, "TRACE">>>;
+    readonly acl: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
         input?: Input | undefined;
         run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
-    }>) => Router<Ctx, Procs & Record<Name, Readonly<{
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
         input?: Input | undefined;
         run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
-    }> & {
-        method: Method.PATCH;
-        name: Name;
-    }>>;
-    readonly delete: <Name extends string, Result, Input extends z.ZodTypeAny>(name: Name, proc: Readonly<{
+    }> & RouterProc<Path, "ACL">>>;
+    readonly bind: <Path extends string, Result, Input extends z.ZodTypeAny>(path: Path, proc: Readonly<{
         input?: Input | undefined;
         run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
-    }>) => Router<Ctx, Procs & Record<Name, Readonly<{
+    }>) => Router<Ctx, Procs & Record<Path, Readonly<{
         input?: Input | undefined;
         run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
-    }> & {
-        method: Method.DELETE;
-        name: Name;
-    }>>;
+    }> & RouterProc<Path, "BIND">>>;
 }
 export declare class KaitoError extends Error {
-    readonly code: number;
+    readonly status: number;
     readonly cause?: Error | undefined;
-    constructor(code: number, message: string, cause?: Error | undefined);
+    constructor(status: number, message: string, cause?: Error | undefined);
 }
 export declare function createRouter<Ctx>(): Router<Ctx, {}>;
-export declare type InferApiResponseType<R extends AnyRouter<unknown>, M extends Method, Path extends Extract<Values<ReturnType<R['getProcs']>>, {
+export declare type InferAPIResponseType<R extends AnyRouter<unknown>, M extends Method, Path extends Extract<Values<ReturnType<R['getProcs']>>, {
     method: M;
-}>['name']> = ReturnType<ReturnType<R['getProcs']>[Path]['run']> extends Promise<infer V> ? V : never;
-export declare function createServer<Ctx, R extends Router<Ctx, ProcsInit<Ctx>>>(config: {
+}>['path']> = ReturnType<ReturnType<R['getProcs']>[Path]['run']> extends Promise<infer V> ? V : never;
+export declare function createServer<Ctx, R extends Router<Ctx, AnyProcs<Ctx>>>(config: {
     getContext: GetContext<Ctx>;
     router: R;
     onError(error: {
         error: Error;
-        req: FastifyRequest;
-        res: FastifyReply;
+        req: KaitoRequest;
+        res: KaitoResponse;
     }): Promise<{
-        code: number;
+        status: number;
         message: string;
     }>;
-    log?: (message: string) => unknown | false;
-}): import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance> & PromiseLike<import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance>>;
+    log?: ((message: string) => unknown) | false;
+}): http.Server;
 export {};

package/dist/declarations/src/util.d.ts

@@ -0,0 +1,4 @@
+import { KaitoRequest } from './req';
+export declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
+export declare type Method = 'ACL' | 'BIND' | 'CHECKOUT' | 'CONNECT' | 'COPY' | 'DELETE' | 'GET' | 'HEAD' | 'LINK' | 'LOCK' | 'M-SEARCH' | 'MERGE' | 'MKACTIVITY' | 'MKCALENDAR' | 'MKCOL' | 'MOVE' | 'NOTIFY' | 'OPTIONS' | 'PATCH' | 'POST' | 'PRI' | 'PROPFIND' | 'PROPPATCH' | 'PURGE' | 'PUT' | 'REBIND' | 'REPORT' | 'SEARCH' | 'SOURCE' | 'SUBSCRIBE' | 'TRACE' | 'UNBIND' | 'UNLINK' | 'UNLOCK' | 'UNSUBSCRIBE';
+export declare function getInput(req: KaitoRequest): Promise<unknown>;

package/dist/kaito-http-core.cjs.dev.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;