@visulima/connect 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## @visulima/connect [1.0.1](https://github.com/visulima/visulima/compare/@visulima/connect@1.0.0...@visulima/connect@1.0.1) (2022-10-27)
+
+
+### Bug Fixes
+
+* fixed package.json files paths ([0d21e94](https://github.com/visulima/visulima/commit/0d21e94a75e9518f7b87293706615d8fb280095c))
+
 ## @visulima/connect 1.0.0 (2022-10-25)
 
 

package/README.md

@@ -15,14 +15,22 @@
 
 <div align="center">
 
-[![typescript-image]][typescript-url] [![npm-image]][npm-url] [![license-image]][license-url] [![synk-image]][synk-url]
+[![typescript-image]][typescript-url] [![npm-image]][npm-url] [![license-image]][license-url]
 
 </div>
 
+---
+
 <div align="center">
-  <sub>Built with ❤︎ by <a href="https://twitter.com/_prisis_">Daniel Bannert</a></sub>
+    <p>
+        <sup>
+            Daniel Bannert's open source work is supported by the community on <a href="https://github.com/sponsors/prisis">GitHub Sponsors</a>
+        </sup>
+    </p>
 </div>
 
+---
+
 ## Features
 
 - Async middleware
@@ -44,6 +52,7 @@ yarn add @visulima/connect
 ```sh
 pnpm add @visulima/connect
 ```
+
 ## Usage
 
 > **Note**
@@ -198,7 +207,7 @@ router
     res.json({ user });
     return new Response(JSON.stringify({ user }), {
       status: 200,
-      headers: {
+      headerList: {
         "content-type": "application/json",
       },
     });
@@ -207,7 +216,7 @@ router
     const user = await updateUser(req.body.user);
     return new Response(JSON.stringify({ user }), {
       status: 200,
-      headers: {
+      headerList: {
         "content-type": "application/json",
       },
     });
@@ -589,19 +598,31 @@ router.use(expressWrapper(someExpressMiddleware));
 
 </details>
 
+## Supported Node.js Versions
+
+Libraries in this ecosystem make the best effort to track
+[Node.js' release schedule](https://nodejs.org/en/about/releases/). Here's [a
+post on why we think this is important](https://medium.com/the-node-js-collection/maintainers-should-consider-following-node-js-release-schedule-ab08ed4de71a).
+
 ## Contributing
 
-Please see my [contributing.md](https://github.com/visulima/visulima/blob/main/.github/CONTRIBUTING.md).
+If you would like to help take a look at the [list of issues](https://github.com/visulima/visulima/issues) and check our [Contributing](.github/CONTRIBUTING.md) guild.
+
+> **Note:** please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.
+
+## Credits
+
+-   [next-connect](https://github.com/hoangvvo/next-connect)
+-   [Daniel Bannert](https://github.com/prisis)
+-   [All Contributors](https://github.com/visulima/visulima/graphs/contributors)
 
 ## License
 
-[MIT][license-url]
+The visulima connect is open-sourced software licensed under the [MIT][license-url]
 
 [typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript
 [typescript-url]: "typescript"
 [license-image]: https://img.shields.io/npm/l/@visulima/connect?color=blueviolet&style=for-the-badge
 [license-url]: LICENSE.md "license"
-[npm-image]: https://img.shields.io/npm/v/@visulima/connect/alpha.svg?style=for-the-badge&logo=npm
-[npm-url]: https://www.npmjs.com/package/@visulima/connect/v/alpha "npm"
-[synk-image]: https://img.shields.io/snyk/vulnerabilities/github/visulima/connect?label=Synk%20Vulnerabilities&style=for-the-badge
-[synk-url]: https://snyk.io/test/github/visulima/connect?targetFile=package.json "synk"
+[npm-image]: https://img.shields.io/npm/v/@visulima/connect/latest.svg?style=for-the-badge&logo=npm
+[npm-url]: https://www.npmjs.com/package/@visulima/connect/v/latest "npm"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@visulima/connect",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "The minimal router and middleware layer for Next.js, Micro, Vercel, or Node.js http/http2 with support for zod validation.",
     "keywords": [
         "javascript",
@@ -52,7 +52,8 @@
     "source": "src/index.ts",
     "types": "dist/index.d.ts",
     "files": [
-        "dist/**",
+        "src",
+        "dist",
         "README.md",
         "CHANGELOG.md",
         "LICENSE.md"
@@ -87,6 +88,7 @@
         "eslint-plugin-eslint-comments": "^3.2.0",
         "eslint-plugin-import": "^2.26.0",
         "eslint-plugin-json": "^3.1.0",
+        "eslint-plugin-jsonc": "^2.5.0",
         "eslint-plugin-jsx-a11y": "^6.6.1",
         "eslint-plugin-markdown": "^3.0.0",
         "eslint-plugin-material-ui": "^1.0.1",

package/src/adapter/express.ts

@@ -0,0 +1,18 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import type { RequestHandler } from "../node";
+import type { Nextable } from "../types";
+
+type NextFunction = (error?: any) => void;
+
+const expressWrapper = <Request extends IncomingMessage, Response extends ServerResponse>(
+    function_: ExpressRequestHandler<Request, Response>,
+    // eslint-disable-next-line compat/compat
+): Nextable<RequestHandler<Request, Response>> => (request, response, next) => new Promise<void>((resolve, reject) => {
+        function_(request, response, (error) => (error ? reject(error) : resolve()));
+        // eslint-disable-next-line promise/no-callback-in-promise
+    }).then(next);
+
+export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
+
+export default expressWrapper;

package/src/adapter/with-zod.ts

@@ -0,0 +1,35 @@
+import createHttpError from "http-errors";
+import type { AnyZodObject } from "zod";
+import { ZodError, ZodObject } from "zod";
+
+import type { Nextable, NextHandler } from "../types";
+
+const withZod = <
+        Request extends object,
+        Response extends unknown,
+        Handler extends Nextable<any>,
+        Schema extends ZodObject<{ body?: AnyZodObject; headers?: AnyZodObject; query?: AnyZodObject }>,
+    >(
+        schema: Schema,
+        handler: Handler,
+    ): ((request: Request, response: Response, next: NextHandler) => Promise<Response>) => async (request: Request, response: Response, next) => {
+        let transformedRequest: Request = request;
+
+        try {
+            transformedRequest = (await schema.parseAsync(request)) as Request;
+        } catch (error: any) {
+            let { message } = error;
+
+            // eslint-disable-next-line unicorn/consistent-destructuring
+            if (error instanceof ZodError && typeof error.format === "function") {
+                // eslint-disable-next-line unicorn/consistent-destructuring
+                message = error.issues.map((issue) => `${issue.path.join("/")} - ${issue.message}`).join("/n");
+            }
+
+            throw createHttpError(422, message);
+        }
+
+        return handler(transformedRequest, response, next);
+    };
+
+export default withZod;

package/src/edge.ts

@@ -0,0 +1,165 @@
+import type { AnyZodObject } from "zod";
+import { ZodObject } from "zod";
+
+import withZod from "./adapter/with-zod";
+import { Route, Router } from "./router";
+import type {
+    FindResult,
+    FunctionLike,
+    HandlerOptions,
+    HttpMethod,
+    Nextable,
+    RouteMatch,
+    RoutesExtendedRequestHandler,
+    RouteShortcutMethod,
+    ValueOrPromise,
+} from "./types";
+
+// eslint-disable-next-line max-len
+const onNoMatch = async (request: Request) => new Response(request.method !== "HEAD" ? `Route ${request.method} ${request.url} not found` : null, { status: 404 });
+
+const onError = async (error: unknown) => {
+    // eslint-disable-next-line no-console
+    console.error(error);
+    return new Response("Internal Server Error", { status: 500 });
+};
+
+export function getPathname(request: Request & { nextUrl?: URL }) {
+    // eslint-disable-next-line compat/compat
+    return (request.nextUrl || new URL(request.url)).pathname;
+}
+
+// eslint-disable-next-line max-len
+export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
+
+export class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends AnyZodObject = ZodObject<any>> {
+    private router = new Router<RequestHandler<R, Context>>();
+
+    private readonly onNoMatch: RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>;
+
+    private readonly onError: (
+        error: unknown,
+        ...arguments_: Parameters<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>
+    ) => ReturnType<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>;
+
+    constructor(options: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>> = {}) {
+        this.onNoMatch = options.onNoMatch || onNoMatch as unknown as RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>;
+        this.onError = options.onError
+            || (onError as unknown as (
+                error: unknown,
+                ...arguments_: Parameters<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>
+            ) => ReturnType<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
+    }
+
+    private add(
+        method: HttpMethod | "",
+        routeOrFunction: RouteMatch | Nextable<RequestHandler<R, Context>>,
+        zodOrRouteOrFunction?: RouteMatch | Schema | Nextable<RequestHandler<R, Context>>,
+        ...fns: Nextable<RequestHandler<R, Context>>[]
+    ) {
+        if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
+            // eslint-disable-next-line no-param-reassign
+            fns = [zodOrRouteOrFunction];
+        } else if (typeof zodOrRouteOrFunction === "object") {
+            // eslint-disable-next-line unicorn/prefer-ternary
+            if (typeof routeOrFunction === "function") {
+                // eslint-disable-next-line no-param-reassign
+                fns = [withZod<R, Context, Nextable<RequestHandler<R, Context>>, Schema>(zodOrRouteOrFunction as Schema, routeOrFunction)];
+            } else {
+                // eslint-disable-next-line no-param-reassign,max-len
+                fns = fns.map((function_) => withZod<R, Context, Nextable<RequestHandler<R, Context>>, Schema>(zodOrRouteOrFunction as Schema, function_));
+            }
+        } else if (typeof zodOrRouteOrFunction === "function") {
+            // eslint-disable-next-line no-param-reassign
+            fns = [zodOrRouteOrFunction];
+        }
+
+        this.router.add(method, routeOrFunction, ...fns);
+
+        return this;
+    }
+
+    public all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>> = this.add.bind(this, "");
+
+    public get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>> = this.add.bind(this, "GET");
+
+    public head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>> = this.add.bind(this, "HEAD");
+
+    public post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>> = this.add.bind(this, "POST");
+
+    public put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>> = this.add.bind(this, "PUT");
+
+    public patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>> = this.add.bind(this, "PATCH");
+
+    public delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>> = this.add.bind(this, "DELETE");
+
+    public use(
+        base: RouteMatch | Nextable<RequestHandler<R, Context>> | EdgeRouter<R, Context>,
+        ...fns: (Nextable<RequestHandler<R, Context>> | EdgeRouter<R, Context>)[]
+    ) {
+        if (typeof base === "function" || base instanceof EdgeRouter) {
+            fns.unshift(base);
+            // eslint-disable-next-line no-param-reassign
+            base = "/";
+        }
+
+        this.router.use(base, ...fns.map((function_) => (function_ instanceof EdgeRouter ? function_.router : function_)));
+
+        return this;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    private prepareRequest(request: R & { params?: Record<string, unknown> }, findResult: FindResult<RequestHandler<R, Context>>) {
+        request.params = {
+            ...findResult.params,
+            ...request.params, // original params will take precedence
+        };
+    }
+
+    public clone() {
+        const r = new EdgeRouter<R, Context, RResponse, Schema>({ onNoMatch: this.onNoMatch, onError: this.onError });
+
+        r.router = this.router.clone();
+
+        return r;
+    }
+
+    async run(request: R, context_: Context) {
+        // eslint-disable-next-line unicorn/no-array-callback-reference,unicorn/no-array-method-this-argument
+        const result = this.router.find(request.method as HttpMethod, getPathname(request));
+
+        if (result.fns.length === 0) {
+            return;
+        }
+
+        this.prepareRequest(request, result);
+
+        // eslint-disable-next-line consistent-return
+        return Router.exec(result.fns, request, context_);
+    }
+
+    handler() {
+        const { routes } = this.router as Router<FunctionLike>;
+
+        return async (request: R, context_: Context): Promise<any> => {
+            // eslint-disable-next-line unicorn/no-array-callback-reference,unicorn/no-array-method-this-argument
+            const result = this.router.find(request.method as HttpMethod, getPathname(request));
+
+            this.prepareRequest(request, result);
+
+            try {
+                return await (result.fns.length === 0 || result.middleOnly
+                    ? this.onNoMatch(request, context_, routes)
+                    : Router.exec(result.fns, request, context_));
+            } catch (error) {
+                return this.onError(error, request, context_, routes);
+            }
+        };
+    }
+}
+
+export function createEdgeRouter<R extends Request, Context>(
+    options: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>> = {},
+) {
+    return new EdgeRouter<R, Context, Response>(options);
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+export type { RequestHandler as EdgeRequestHandler } from "./edge";
+export { createEdgeRouter, EdgeRouter } from "./edge";
+export type { ExpressRequestHandler } from "./adapter/express";
+export { default as expressWrapper } from "./adapter/express";
+
+export type { RequestHandler } from "./node";
+export { createRouter, NodeRouter } from "./node";
+
+export type { Route } from "./router";
+export { Router } from "./router";
+
+export { default as withZod } from "./adapter/with-zod";
+
+export type {
+    HandlerOptions, NextHandler, FunctionLike, Nextable, ValueOrPromise, FindResult, RouteShortcutMethod, HttpMethod,
+} from "./types";
+
+export { default as sendJson } from "./utils/send-json";

package/src/node.ts

@@ -0,0 +1,173 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { AnyZodObject } from "zod";
+import { ZodObject } from "zod";
+
+import withZod from "./adapter/with-zod";
+import type { Route } from "./router";
+import { Router } from "./router";
+import type {
+    FindResult,
+    FunctionLike,
+    HandlerOptions,
+    HttpMethod,
+    Nextable,
+    RouteMatch,
+    RoutesExtendedRequestHandler,
+    RouteShortcutMethod,
+    ValueOrPromise,
+} from "./types";
+
+const onNoMatch = async (request: IncomingMessage, response: ServerResponse) => {
+    response.statusCode = 404;
+    response.end(request.method !== "HEAD" ? `Route ${request.method} ${request.url} not found` : undefined);
+};
+
+const onError = async (error: unknown, _request: IncomingMessage, response: ServerResponse) => {
+    response.statusCode = 500;
+    // eslint-disable-next-line no-console
+    console.error(error);
+
+    response.end("Internal Server Error");
+};
+
+export function getPathname(url: string) {
+    const queryIndex = url.indexOf("?");
+
+    return queryIndex !== -1 ? url.slice(0, Math.max(0, queryIndex)) : url;
+}
+
+export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
+
+export class NodeRouter<
+    Request extends IncomingMessage = IncomingMessage,
+    Response extends ServerResponse = ServerResponse,
+    Schema extends AnyZodObject = ZodObject<any>,
+> {
+    private router = new Router<RequestHandler<Request, Response>>();
+
+    private readonly onNoMatch: RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>;
+
+    private readonly onError: (
+        error: unknown,
+        ...arguments_: Parameters<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>
+    ) => ReturnType<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>;
+
+    constructor(options: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>> = {}) {
+        this.onNoMatch = options.onNoMatch || onNoMatch;
+        this.onError = options.onError || onError;
+    }
+
+    private add(
+        method: HttpMethod | "",
+        routeOrFunction: RouteMatch | Nextable<RequestHandler<Request, Response>>,
+        zodOrRouteOrFunction?: RouteMatch | Schema | Nextable<RequestHandler<Request, Response>>,
+        ...fns: Nextable<RequestHandler<Request, Response>>[]
+    ) {
+        if (typeof routeOrFunction === "string" && typeof zodOrRouteOrFunction === "function") {
+            // eslint-disable-next-line no-param-reassign
+            fns = [zodOrRouteOrFunction];
+        } else if (typeof zodOrRouteOrFunction === "object") {
+            // eslint-disable-next-line unicorn/prefer-ternary
+            if (typeof routeOrFunction === "function") {
+                // eslint-disable-next-line no-param-reassign
+                fns = [withZod<Request, Response, Nextable<RequestHandler<Request, Response>>, Schema>(
+                    zodOrRouteOrFunction as Schema,
+                    routeOrFunction,
+                )];
+            } else {
+                // eslint-disable-next-line no-param-reassign,max-len
+                fns = fns.map((function_) => withZod<Request, Response, Nextable<RequestHandler<Request, Response>>, Schema>(zodOrRouteOrFunction as Schema, function_));
+            }
+        } else if (typeof zodOrRouteOrFunction === "function") {
+            // eslint-disable-next-line no-param-reassign
+            fns = [zodOrRouteOrFunction];
+        }
+
+        this.router.add(method, routeOrFunction, ...fns);
+
+        return this;
+    }
+
+    public all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>> = this.add.bind(this, "");
+
+    public get: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>> = this.add.bind(this, "GET");
+
+    public head: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>> = this.add.bind(this, "HEAD");
+
+    public post: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>> = this.add.bind(this, "POST");
+
+    public put: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>> = this.add.bind(this, "PUT");
+
+    public patch: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>> = this.add.bind(this, "PATCH");
+
+    public delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>> = this.add.bind(this, "DELETE");
+
+    public use(
+        base: RouteMatch | Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>,
+        ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]
+    ) {
+        if (typeof base === "function" || base instanceof NodeRouter) {
+            fns.unshift(base);
+            // eslint-disable-next-line no-param-reassign
+            base = "/";
+        }
+        this.router.use(base, ...fns.map((function_) => (function_ instanceof NodeRouter ? function_.router : function_)));
+
+        return this;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    private prepareRequest(request: Request & { params?: Record<string, unknown> }, findResult: FindResult<RequestHandler<Request, Response>>) {
+        request.params = {
+            ...findResult.params,
+            ...request.params, // original params will take precedence
+        };
+    }
+
+    public clone() {
+        const r = new NodeRouter<Request, Response, Schema>({ onNoMatch: this.onNoMatch, onError: this.onError });
+
+        r.router = this.router.clone();
+
+        return r;
+    }
+
+    async run(request: Request, response: Response): Promise<unknown> {
+        // eslint-disable-next-line unicorn/no-array-callback-reference,unicorn/no-array-method-this-argument
+        const result = this.router.find(request.method as HttpMethod, getPathname(request.url as string));
+
+        if (result.fns.length === 0) {
+            return;
+        }
+
+        this.prepareRequest(request, result);
+
+        // eslint-disable-next-line consistent-return
+        return Router.exec(result.fns, request, response);
+    }
+
+    handler() {
+        const { routes } = this.router as Router<FunctionLike>;
+
+        return async (request: Request, response: Response) => {
+            // eslint-disable-next-line unicorn/no-array-callback-reference,unicorn/no-array-method-this-argument
+            const result = this.router.find(request.method as HttpMethod, getPathname(request.url as string));
+
+            this.prepareRequest(request, result);
+
+            try {
+                await (result.fns.length === 0 || result.middleOnly ? this.onNoMatch(request, response, routes) : Router.exec(result.fns, request, response));
+            } catch (error) {
+                await this.onError(error, request, response, routes);
+            }
+        };
+    }
+}
+
+export const createRouter = <
+    Request extends IncomingMessage,
+    Response extends ServerResponse,
+    Schema extends AnyZodObject = ZodObject<{ body?: AnyZodObject; headers?: AnyZodObject; query?: AnyZodObject }>,
+>(
+        options: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>> = {},
+    ) => new NodeRouter<Request, Response, Schema>(options);

package/src/regexparam.d.ts

@@ -0,0 +1,10 @@
+declare module "regexparam" {
+// eslint-disable-next-line import/prefer-default-export
+    export function parse(
+        route: string | RegExp,
+        loose?: boolean,
+    ): {
+        keys: string[] | false;
+        pattern: RegExp;
+    };
+}

package/src/router.ts

@@ -0,0 +1,195 @@
+/**
+ * Agnostic router class
+ * Adapted from lukeed/trouter library:
+ * https://github.com/lukeed/trouter/blob/master/index.mjs
+ */
+import { parse } from "regexparam";
+
+import type {
+    FindResult, FunctionLike, HttpMethod, Nextable, RouteMatch,
+} from "./types";
+
+export type Route<H> = {
+    method: HttpMethod | "";
+    fns: (H | Router<H extends FunctionLike ? H : never>)[];
+    isMiddleware: boolean;
+} & (
+    | {
+        keys: string[] | false;
+        pattern: RegExp;
+    }
+    | { matchAll: true }
+);
+
+export class Router<H extends FunctionLike> {
+    constructor(public base: string = "/", public routes: Route<Nextable<H>>[] = []) {}
+
+    public add(method: HttpMethod | "", route: RouteMatch | Nextable<H>, ...fns: Nextable<H>[]): this {
+        if (typeof route === "function") {
+            fns.unshift(route);
+            // eslint-disable-next-line no-param-reassign
+            route = "";
+        }
+
+        if (route === "") {
+            this.routes.push({
+                matchAll: true,
+                method,
+                fns,
+                isMiddleware: false,
+            });
+        } else {
+            const { keys, pattern } = parse(route);
+
+            this.routes.push({
+                keys,
+                pattern,
+                method,
+                fns,
+                isMiddleware: false,
+            });
+        }
+
+        return this;
+    }
+
+    public use(base: RouteMatch | Nextable<H> | Router<H>, ...fns: (Nextable<H> | Router<H>)[]) {
+        if (typeof base === "function" || base instanceof Router) {
+            fns.unshift(base);
+            // eslint-disable-next-line no-param-reassign
+            base = "/";
+        }
+        // mount subrouter
+        // eslint-disable-next-line no-param-reassign
+        fns = fns.map((function_) => {
+            if (function_ instanceof Router) {
+                if (typeof base === "string") return function_.clone(base);
+                throw new Error("Mounting a router to RegExp base is not supported");
+            }
+            return function_;
+        });
+
+        const { keys, pattern } = parse(base, true);
+
+        this.routes.push({
+            keys,
+            pattern,
+            method: "",
+            fns,
+            isMiddleware: true,
+        });
+
+        return this;
+    }
+
+    public clone(base?: string) {
+        return new Router<H>(base, [...this.routes]);
+    }
+
+    static async exec<H extends FunctionLike>(fns: Nextable<H>[], ...arguments_: Parameters<H>): Promise<unknown> {
+        let index = 0;
+
+        // eslint-disable-next-line no-plusplus
+        const next = () => (fns[++index] as FunctionLike)(...arguments_, next);
+
+        return (fns[index] as FunctionLike)(...arguments_, next);
+    }
+
+    // eslint-disable-next-line radar/cognitive-complexity
+    find(method: HttpMethod, pathname: string): FindResult<H> {
+        let middleOnly = true;
+
+        const fns: Nextable<H>[] = [];
+        const parameters: Record<string, string> = {};
+        const isHead = method === "HEAD";
+
+        // eslint-disable-next-line radar/cognitive-complexity
+        Object.values(this.routes).forEach((route) => {
+            if (
+                route.method !== method
+                // matches any method
+                && route.method !== ""
+                // The HEAD method requests that the target resource transfer a representation of its state, as for a GET request...
+                && !(isHead && route.method === "GET")
+            ) {
+                return;
+            }
+
+            let matched = false;
+
+            if ("matchAll" in route) {
+                matched = true;
+            } else if (route.keys === false) {
+                // routes.key is RegExp: https://github.com/lukeed/regexparam/blob/master/src/index.js#L2
+                const matches = route.pattern.exec(pathname);
+
+                if (matches === null) {
+                    return;
+                }
+
+                // eslint-disable-next-line no-void
+                if (matches.groups !== void 0) {
+                    Object.keys(matches.groups).forEach((key) => {
+                        // @ts-ignore @TODO: fix this
+                        parameters[key] = matches.groups[key] as string;
+                    });
+                }
+
+                matched = true;
+            } else if (route.keys.length > 0) {
+                const matches = route.pattern.exec(pathname);
+
+                if (matches === null) {
+                    return;
+                }
+
+                for (let index = 0; index < route.keys.length;) {
+                    const parameterKey = route.keys[index];
+
+                    // @ts-ignore @TODO: fix this
+                    // eslint-disable-next-line no-plusplus
+                    parameters[parameterKey] = matches[++index];
+                }
+
+                matched = true;
+            } else if (route.pattern.test(pathname)) {
+                matched = true;
+            } // else not a match
+
+            if (matched) {
+                fns.push(
+                    ...route.fns.flatMap((function_) => {
+                        if (function_ instanceof Router) {
+                            const base = function_.base as string;
+
+                            let stripPathname = pathname.slice(base.length);
+
+                            // fix stripped pathname, not sure why this happens
+                            // eslint-disable-next-line eqeqeq
+                            if (stripPathname[0] != "/") {
+                                stripPathname = `/${stripPathname}`;
+                            }
+
+                            // eslint-disable-next-line unicorn/no-array-callback-reference, unicorn/no-array-method-this-argument
+                            const result = function_.find(method, stripPathname);
+
+                            if (!result.middleOnly) {
+                                middleOnly = false;
+                            }
+
+                            // merge params
+                            Object.assign(parameters, result.params);
+
+                            return result.fns;
+                        }
+
+                        return function_;
+                    }),
+                );
+                if (!route.isMiddleware) middleOnly = false;
+            }
+        });
+
+        return { fns, params: parameters, middleOnly };
+    }
+}

package/src/types.d.ts

@@ -0,0 +1,36 @@
+import { AnyZodObject } from "zod";
+
+export type HttpMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+export type FunctionLike = (...arguments_: any[]) => unknown;
+
+export type RouteMatch = string | RegExp;
+
+export type NextHandler = () => ValueOrPromise<any>;
+
+export type Nextable<H extends FunctionLike> = (...arguments_: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
+
+export type FindResult<H extends FunctionLike> = {
+    fns: Nextable<H>[];
+    params: Record<string, string>;
+    middleOnly: boolean;
+};
+
+export type RoutesExtendedRequestHandler<Request extends object, Context extends unknown, RResponse extends unknown, Routes> = (
+    request: Request,
+    response: Context,
+    routes: Routes,
+) => ValueOrPromise<RResponse | void>;
+
+export interface HandlerOptions<Handler extends FunctionLike> {
+    onNoMatch?: Handler;
+    onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
+}
+
+export type ValueOrPromise<T> = T | Promise<T>;
+
+export type RouteShortcutMethod<This, Schema extends AnyZodObject, H extends FunctionLike> = (
+    route: RouteMatch | Nextable<H>,
+    zodSchemaOrRouteOrFns?: Schema | RouteMatch | Nextable<H> | string,
+    ...fns: Nextable<H>[]
+) => This;

package/src/utils/send-json.ts

@@ -0,0 +1,17 @@
+import type { ServerResponse } from "node:http";
+
+/**
+ * Send `JSON` object
+ * @param {ServerResponse} response response object
+ * @param {number} statusCode
+ * @param {any} jsonBody of data
+ */
+const sendJson = (response: ServerResponse, statusCode: number, jsonBody: any): void => {
+    // Set header to application/json
+    response.setHeader("content-type", "application/json; charset=utf-8");
+
+    response.statusCode = statusCode;
+    response.end(JSON.stringify(jsonBody, null, 2));
+};
+
+export default sendJson;