@kaito-http/core 2.2.7 → 2.3.2

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

@@ -4,3 +4,7 @@ export declare class WrappedError<T> extends Error {
     static from<T>(data: T): WrappedError<T>;
     private constructor();
 }
+export declare class KaitoError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}

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

@@ -1 +1,7 @@
 export * from './server';
+export * from './router';
+export * from './route';
+export * from './util';
+export * from './req';
+export * from './res';
+export * from './error';

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

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

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

@@ -0,0 +1,13 @@
+import { HTTPMethod } from 'find-my-way';
+import { z } from 'zod';
+import { ExtractRouteParams } from './util';
+export declare type RouteArgument<Path extends string, Context, Input extends z.ZodSchema> = {
+    ctx: Context;
+    input: z.infer<Input>;
+    params: ExtractRouteParams<Path>;
+};
+export interface Route<Result, Path extends string, Method extends HTTPMethod, Context, Input extends z.ZodSchema = never> {
+    input?: Input;
+    method: Method;
+    run(arg: RouteArgument<Path, Context, Input>): Promise<Result>;
+}

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

@@ -0,0 +1,26 @@
+import fmw, { HTTPMethod, Instance } from 'find-my-way';
+import { z } from 'zod';
+import { Route } from './route';
+import { ServerConfig } from './server';
+import { NormalizePath } from './util';
+export declare type RoutesInit<Context, Paths extends string = string> = {
+    [Path in Paths]: Route<unknown, Path, HTTPMethod, Context, z.ZodSchema>;
+};
+export declare class Router<Context, Routes extends RoutesInit<Context>> {
+    static create<Context>(): Router<Context, {}>;
+    private static handle;
+    readonly routes: Routes;
+    readonly get: <Result, Path extends string, Input extends z.ZodType<any, z.ZodTypeDef, any> = never>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, route: Omit<Route<Result, (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "GET", Context, Input>, "method">) => Router<Context, Routes & { [P in Path as (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`]: Route<Result, (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`, "GET", Context, Input>; }>;
+    readonly post: <Result, Path extends string, Input extends z.ZodType<any, z.ZodTypeDef, any> = never>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, route: Omit<Route<Result, (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "POST", Context, Input>, "method">) => Router<Context, Routes & { [P in Path as (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`]: Route<Result, (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`, "POST", Context, Input>; }>;
+    readonly head: <Result, Path extends string, Input extends z.ZodType<any, z.ZodTypeDef, any> = never>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, route: Omit<Route<Result, (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "HEAD", Context, Input>, "method">) => Router<Context, Routes & { [P in Path as (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`]: Route<Result, (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`, "HEAD", Context, Input>; }>;
+    readonly put: <Result, Path extends string, Input extends z.ZodType<any, z.ZodTypeDef, any> = never>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, route: Omit<Route<Result, (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "PUT", Context, Input>, "method">) => Router<Context, Routes & { [P in Path as (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`]: Route<Result, (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`, "PUT", Context, Input>; }>;
+    readonly patch: <Result, Path extends string, Input extends z.ZodType<any, z.ZodTypeDef, any> = never>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, route: Omit<Route<Result, (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "PATCH", Context, Input>, "method">) => Router<Context, Routes & { [P in Path as (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`]: Route<Result, (P extends `${infer U}/` ? U : P) extends `/${infer U_1}` ? `/${U_1}` : `/${P extends `${infer U}/` ? U : P}`, "PATCH", Context, Input>; }>;
+    private constructor();
+    merge<Prefix extends string, NewRoutes extends RoutesInit<Context>>(prefix: NormalizePath<Prefix>, router: Router<Context, NewRoutes>): Router<Context, Routes & { [Path in Extract<keyof NewRoutes, string> as `/${Prefix}${Path}`]: Route<Context, `/${Prefix}${Path}`, fmw.HTTPMethod, Context, z.ZodType<any, z.ZodTypeDef, any>>; }>;
+    toFindMyWay(server: ServerConfig<Context>): Instance<fmw.HTTPVersion.V1>;
+    private make;
+}
+/**
+ * @deprecated Please use Router#create instead
+ */
+export declare const createRouter: typeof Router.create;

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

@@ -1,80 +1,24 @@
 /// <reference types="node" />
-import http from 'http';
-import { z, ZodTypeAny } from 'zod';
+import { Router, RoutesInit } from './router';
+import * as http from 'http';
 import { KaitoRequest } from './req';
 import { KaitoResponse } from './res';
-import { Method, NormalizePath } from './util';
-declare type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
-    [k in Param | keyof ExtractRouteParams<Rest>]: string;
-} : T extends `${string}:${infer Param}` ? {
-    [k in Param]: string;
-} : {};
-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;
-export declare type ContextWithInput<Ctx, Params extends Record<string, string>, Input> = {
-    ctx: Ctx;
-    params: Params;
-    input: Input;
-};
-declare type Values<T> = T[keyof T];
-export declare type Proc<Ctx, Result, Params extends Record<string, string> = Record<never, string>, Input extends z.ZodTypeAny | Never = Never> = {
-    input?: Input;
-    run(arg: ContextWithInput<Ctx, Params, Input extends ZodTypeAny ? z.infer<Input> : undefined>): Promise<Result>;
-};
-export interface RouterProc<Path extends string, M extends Method> {
-    method: M;
-    path: Path;
-    pattern: RegExp;
-}
-export declare type AnyProcs<Ctx> = {
-    [Path in string]: Proc<Ctx, unknown, Record<string, string>, z.ZodTypeAny> & RouterProc<Path, Method>;
-};
-export declare type AnyRouter<Ctx> = Router<Ctx, AnyProcs<Ctx>>;
-export declare class Router<Ctx, Procs extends AnyProcs<Ctx>> {
-    private readonly procs;
-    private readonly _procsArray;
-    private static patternize;
-    constructor(procs: Procs);
-    getProcs(): Procs;
-    find(method: Method, url: string): (Proc<Ctx, unknown, Record<string, string>, z.ZodTypeAny> & RouterProc<string, Method>) | null;
-    private readonly create;
-    readonly merge: <Prefix extends string, NewCtx, NewProcs extends AnyProcs<NewCtx>>(prefix: (Prefix extends `${infer U}/` ? U : Prefix) extends `/${infer U_1}` ? `/${U_1}` : `/${Prefix extends `${infer U}/` ? U : Prefix}`, router: Router<NewCtx, NewProcs>) => Router<NewCtx & Ctx, Procs & { [P in Extract<keyof NewProcs, string> as `/${Prefix}${P}`]: Omit<NewProcs[P], "path"> & {
-        path: P;
-    }; }>;
-    readonly get: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "GET">>>;
-    readonly post: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "POST">>>;
-    readonly put: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "PUT">>>;
-    readonly patch: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "PATCH">>>;
-    readonly delete: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "DELETE">>>;
-    readonly head: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "HEAD">>>;
-    readonly options: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "OPTIONS">>>;
-    readonly connect: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "CONNECT">>>;
-    readonly trace: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "TRACE">>>;
-    readonly acl: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "ACL">>>;
-    readonly bind: <Path extends string, Result, Input extends z.ZodTypeAny>(path: (Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, proc: Proc<Ctx, Result, ExtractRouteParams<Path>, Input>) => Router<Ctx, Procs & Record<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, Proc<Ctx, Result, ExtractRouteParams<Path>, Input> & RouterProc<(Path extends `${infer U}/` ? U : Path) extends `/${infer U_1}` ? `/${U_1}` : `/${Path extends `${infer U}/` ? U : Path}`, "BIND">>>;
-}
-export declare class KaitoError extends Error {
-    readonly status: number;
-    readonly 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']>>, {
-    method: M;
-}>['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: {
+import { KaitoError } from './error';
+import { GetContext } from './util';
+export interface ServerConfig<Context> {
+    router: Router<Context, RoutesInit<Context>>;
+    getContext: GetContext<Context>;
+    onError(arg: {
         error: Error;
         req: KaitoRequest;
         res: KaitoResponse;
-    }): Promise<{
+    }): Promise<KaitoError | {
         status: number;
         message: string;
     }>;
-    log?: ((message: string) => unknown) | false;
-}): http.Server;
-export {};
+}
+export declare function createFMWServer<Context>(config: ServerConfig<Context>): {
+    server: http.Server;
+    fmw: import("find-my-way").Instance<import("find-my-way").HTTPVersion.V1>;
+};
+export declare function createServer<Context>(config: ServerConfig<Context>): http.Server;

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

@@ -1,9 +1,17 @@
 import { KaitoRequest } from './req';
+import { KaitoResponse } from './res';
+export declare type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
+    [k in Param | keyof ExtractRouteParams<Rest>]: string;
+} : T extends `${string}:${infer Param}` ? {
+    [k in Param]: string;
+} : {};
+export declare type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
+export declare function createGetContext<Context>(callback: GetContext<Context>): GetContext<Context>;
+export declare type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
 export declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
 declare type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
 declare type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
 export declare type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
 export declare function normalizePath<T extends string>(path: T): NormalizePath<T>;
-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>;
 export {};

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

@@ -3,49 +3,47 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var http = require('http');
+var fmw = require('find-my-way');
 var tls = require('tls');
 var getRawBody = require('raw-body');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
-var http__default = /*#__PURE__*/_interopDefault(http);
-var getRawBody__default = /*#__PURE__*/_interopDefault(getRawBody);
-
-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 _interopNamespace(e) {
+	if (e && e.__esModule) return e;
+	var n = Object.create(null);
+	if (e) {
+		Object.keys(e).forEach(function (k) {
+			if (k !== 'default') {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	}
+	n["default"] = e;
+	return Object.freeze(n);
 }
 
-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);
-      }
+var http__namespace = /*#__PURE__*/_interopNamespace(http);
+var fmw__default = /*#__PURE__*/_interopDefault(fmw);
+var getRawBody__default = /*#__PURE__*/_interopDefault(getRawBody);
 
-      _next(undefined);
-    });
+function createFMWServer(config) {
+  var fmw = config.router.toFindMyWay(config);
+  var server = http__namespace.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) {
@@ -100,6 +98,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) {
@@ -118,8 +152,18 @@ class WrappedError extends Error {
     this.data = data;
   }
 
+}
+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(',');
@@ -137,8 +181,7 @@ function normalizePath(path) {
   }
 
   return result;
-} // Type for import('http').METHODS
-
+}
 function getInput(_x) {
   return _getInput.apply(this, arguments);
 }
@@ -247,142 +290,34 @@ class KaitoResponse {
 
 }
 
-function createGetContext(getContext) {
-  return getContext;
-}
 class Router {
-  static patternize(path) {
-    var normalized = normalizePath(path);
-    return new RegExp("^".concat(normalized, "/?$"), 'i');
+  static create() {
+    return new Router({});
   }
 
-  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);
-  }
-
-  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__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);
-
+  static handle(server, options) {
+    return _asyncToGenerator(function* () {
       try {
-        var _handler$input, _yield$getInput;
-
-        var handler = config.router.find(req.method, req.raw.url);
+        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,
-          params: {}
+          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
@@ -391,35 +326,121 @@ 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__default["default"]({
+      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;
 
 exports.KaitoError = KaitoError;
+exports.KaitoRequest = KaitoRequest;
+exports.KaitoResponse = KaitoResponse;
 exports.Router = Router;
+exports.WrappedError = WrappedError;
+exports.createFMWServer = createFMWServer;
 exports.createGetContext = createGetContext;
 exports.createRouter = createRouter;
 exports.createServer = createServer;
+exports.getInput = getInput;
+exports.getLastEntryInMultiHeaderValue = getLastEntryInMultiHeaderValue;
+exports.normalizePath = normalizePath;