@opensourceframework/next-connect 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Hoang Vo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,565 @@
+# @opensourceframework/next-connect
+
+[![npm](https://badgen.net/npm/v/@opensourceframework/next-connect)](https://www.npmjs.com/package/@opensourceframework/next-connect)
+[![CircleCI](https://circleci.com/gh/hoangvvo/@opensourceframework/next-connect.svg?style=svg)](https://circleci.com/gh/hoangvvo/@opensourceframework/next-connect)
+[![codecov](https://codecov.io/gh/hoangvvo/@opensourceframework/next-connect/branch/main/graph/badge.svg?token=LGIyl3Ti4H)](https://codecov.io/gh/hoangvvo/@opensourceframework/next-connect)
+[![minified size](https://badgen.net/bundlephobia/min/@opensourceframework/next-connect)](https://bundlephobia.com/result?p=@opensourceframework/next-connect)
+[![download/year](https://badgen.net/npm/dy/@opensourceframework/next-connect)](https://www.npmjs.com/package/@opensourceframework/next-connect)
+
+The promise-based method routing and middleware layer for [Next.js](https://nextjs.org/) [API Routes](#nextjs-api-routes), [Edge API Routes](#nextjs-edge-api-routes), [Middleware](#nextjs-middleware), [Next.js App Router](#nextjs-app-router), and [getServerSideProps](#nextjs-getserversideprops).
+
+### Attribution
+
+- **Original Author**: Unknown
+- **Original Repository**: https://github.com/hoangvvo/next-connect
+- **Original License**: MIT
+
+
+
+- Async middleware
+- [Lightweight](https://bundlephobia.com/scan-results?packages=express,@opensourceframework/next-connect,koa,micro) => Suitable for serverless environment
+- [way faster](https://github.com/hoangvvo/@opensourceframework/next-connect/tree/main/bench) than Express.js. Compatible with Express.js via [a wrapper](#expressjs-compatibility).
+- Works with async handlers (with error catching)
+- TypeScript support
+
+## Installation
+
+```sh
+npm install @opensourceframework/next-connect@next
+```
+
+## Usage
+
+Also check out the [examples](./examples/) folder.
+
+### Next.js API Routes
+
+`@opensourceframework/next-connect` can be used in [API Routes](https://nextjs.org/docs/api-routes/introduction).
+
+```typescript
+// pages/api/user/[id].ts
+import type { NextApiRequest, NextApiResponse } from "next";
+import { createRouter, expressWrapper } from "@opensourceframework/next-connect";
+import cors from "cors";
+
+const router = createRouter<NextApiRequest, NextApiResponse>();
+
+router
+  // Use express middleware in @opensourceframework/next-connect with expressWrapper function
+  .use(expressWrapper(passport.session()))
+  // A middleware example
+  .use(async (req, res, next) => {
+    const start = Date.now();
+    await next(); // call next in chain
+    const end = Date.now();
+    console.log(`Request took ${end - start}ms`);
+  })
+  .get((req, res) => {
+    const user = getUser(req.query.id);
+    res.json({ user });
+  })
+  .put((req, res) => {
+    if (req.user.id !== req.query.id) {
+      throw new ForbiddenError("You can't update other user's profile");
+    }
+    const user = await updateUser(req.body.user);
+    res.json({ user });
+  });
+
+export const config = {
+  runtime: "edge",
+};
+
+export default router.handler({
+  onError: (err, req, res) => {
+    console.error(err.stack);
+    res.status(err.statusCode || 500).end(err.message);
+  },
+});
+```
+
+### Next.js Edge API Routes
+
+`@opensourceframework/next-connect` can be used in [Edge API Routes](https://nextjs.org/docs/api-routes/edge-api-routes)
+
+```typescript
+// pages/api/user/[id].ts
+import type { NextFetchEvent, NextRequest } from "next/server";
+import { createEdgeRouter } from "@opensourceframework/next-connect";
+import cors from "cors";
+
+const router = createEdgeRouter<NextRequest, NextFetchEvent>();
+
+router
+  // A middleware example
+  .use(async (req, event, next) => {
+    const start = Date.now();
+    await next(); // call next in chain
+    const end = Date.now();
+    console.log(`Request took ${end - start}ms`);
+  })
+  .get((req) => {
+    const id = req.nextUrl.searchParams.get("id");
+    const user = getUser(id);
+    return NextResponse.json({ user });
+  })
+  .put((req) => {
+    const id = req.nextUrl.searchParams.get("id");
+    if (req.user.id !== id) {
+      throw new ForbiddenError("You can't update other user's profile");
+    }
+    const user = await updateUser(req.body.user);
+    return NextResponse.json({ user });
+  });
+
+export default router.handler({
+  onError: (err, req, event) => {
+    console.error(err.stack);
+    return new NextResponse("Something broke!", {
+      status: err.statusCode || 500,
+    });
+  },
+});
+```
+
+### Next.js App Router
+
+`@opensourceframework/next-connect` can be used in [Next.js 13 Route Handler](https://beta.nextjs.org/docs/routing/route-handlers). The way handlers are written is almost the same to [Next.js Edge API Routes](#nextjs-edge-api-routes) by using `createEdgeRouter`.
+
+```typescript
+// app/api/user/[id]/route.ts
+
+import type { NextFetchEvent, NextRequest } from "next/server";
+import { createEdgeRouter } from "@opensourceframework/next-connect";
+import cors from "cors";
+
+interface RequestContext {
+  params: {
+    id: string;
+  };
+}
+
+const router = createEdgeRouter<NextRequest, RequestContext>();
+
+router
+  // A middleware example
+  .use(async (req, event, next) => {
+    const start = Date.now();
+    await next(); // call next in chain
+    const end = Date.now();
+    console.log(`Request took ${end - start}ms`);
+  })
+  .get((req) => {
+    const id = req.params.id;
+    const user = getUser(id);
+    return NextResponse.json({ user });
+  })
+  .put((req) => {
+    const id = req.params.id;
+    if (req.user.id !== id) {
+      throw new ForbiddenError("You can't update other user's profile");
+    }
+    const user = await updateUser(req.body.user);
+    return NextResponse.json({ user });
+  });
+
+export async function GET(request: NextRequest, ctx: RequestContext) {
+  return router.run(request, ctx);
+}
+
+export async function PUT(request: NextRequest, ctx: RequestContext) {
+  return router.run(request, ctx);
+}
+```
+
+### Next.js Middleware
+
+`@opensourceframework/next-connect` can be used in [Next.js Middleware](https://nextjs.org/docs/advanced-features/middleware)
+
+```typescript
+// middleware.ts
+import { NextResponse } from "next/server";
+import type { NextRequest, NextFetchEvent } from "next/server";
+import { createEdgeRouter } from "@opensourceframework/next-connect";
+
+const router = createEdgeRouter<NextRequest, NextFetchEvent>();
+
+router.use(async (request, event, next) => {
+  // logging request example
+  console.log(`${request.method} ${request.url}`);
+  return next();
+});
+
+router.get("/about", (request) => {
+  return NextResponse.redirect(new URL("/about-2", request.url));
+});
+
+router.use("/dashboard", (request) => {
+  if (!isAuthenticated(request)) {
+    return NextResponse.redirect(new URL("/login", request.url));
+  }
+  return NextResponse.next();
+});
+
+router.all(() => {
+  // default if none of the above matches
+  return NextResponse.next();
+});
+
+export function middleware(request: NextRequest, event: NextFetchEvent) {
+  return router.run(request, event);
+}
+
+export const config = {
+  matcher: [
+    /*
+     * Match all request paths except for the ones starting with:
+     * - api (API routes)
+     * - _next/static (static files)
+     * - _next/image (image optimization files)
+     * - favicon.ico (favicon file)
+     */
+    "/((?!api|_next/static|_next/image|favicon.ico).*)",
+  ],
+};
+```
+
+### Next.js getServerSideProps
+
+`@opensourceframework/next-connect` can be used in [getServerSideProps](https://nextjs.org/docs/basic-features/data-fetching/get-server-side-props).
+
+```jsx
+// pages/users/[id].js
+import { createRouter } from "@opensourceframework/next-connect";
+
+export default function Page({ user, updated }) {
+  return (
+    <div>
+      {updated && <p>User has been updated</p>}
+      <div>{JSON.stringify(user)}</div>
+      <form method="POST">{/* User update form */}</form>
+    </div>
+  );
+}
+
+const router = createRouter()
+  .use(async (req, res, next) => {
+    // this serve as the error handling middleware
+    try {
+      return await next();
+    } catch (e) {
+      return {
+        props: { error: e.message },
+      };
+    }
+  })
+  .get(async (req, res) => {
+    const user = await getUser(req.params.id);
+    if (!user) {
+      // https://nextjs.org/docs/api-reference/data-fetching/get-server-side-props#notfound
+      return { props: { notFound: true } };
+    }
+    return { props: { user } };
+  })
+  .put(async (req, res) => {
+    const user = await updateUser(req);
+    return { props: { user, updated: true } };
+  });
+
+export async function getServerSideProps({ req, res }) {
+  return router.run(req, res);
+}
+```
+
+## API
+
+The following APIs are rewritten in term of `NodeRouter` (`createRouter`), but they apply to `EdgeRouter` (`createEdgeRouter`) as well.
+
+### router = createRouter()
+
+Create an instance Node.js router.
+
+### router.use(base, ...fn)
+
+`base` (optional) - match all routes to the right of `base` or match all if omitted. (Note: If used in Next.js, this is often omitted)
+
+`fn`(s) can either be:
+
+- functions of `(req, res[, next])`
+- **or** a router instance
+
+```javascript
+// Mount a middleware function
+router1.use(async (req, res, next) => {
+  req.hello = "world";
+  await next(); // call to proceed to the next in chain
+  console.log("request is done"); // call after all downstream handler has run
+});
+
+// Or include a base
+router2.use("/foo", fn); // Only run in /foo/**
+
+// mount an instance of router
+const sub1 = createRouter().use(fn1, fn2);
+const sub2 = createRouter().use("/dashboard", auth);
+const sub3 = createRouter()
+  .use("/waldo", subby)
+  .get(getty)
+  .post("/baz", posty)
+  .put("/", putty);
+router3
+  // - fn1 and fn2 always run
+  // - auth runs only on /dashboard
+  .use(sub1, sub2)
+  // `subby` runs on ANY /foo/waldo?/*
+  // `getty` runs on GET /foo/*
+  // `posty` runs on POST /foo/baz
+  // `putty` runs on PUT /foo
+  .use("/foo", sub3);
+```
+
+### router.METHOD(pattern, ...fns)
+
+`METHOD` is an HTTP method (`GET`, `HEAD`, `POST`, `PUT`, `PATCH`, `DELETE`, `OPTIONS`, `TRACE`) in lowercase.
+
+`pattern` (optional) - match routes based on [supported pattern](https://github.com/lukeed/regexparam#regexparam-) or match any if omitted.
+
+`fn`(s) are functions of `(req, res[, next])`.
+
+```javascript
+router.get("/api/user", (req, res, next) => {
+  res.json(req.user);
+});
+router.post("/api/users", (req, res, next) => {
+  res.end("User created");
+});
+router.put("/api/user/:id", (req, res, next) => {
+  // https://nextjs.org/docs/routing/dynamic-routes
+  res.end(`User ${req.params.id} updated`);
+});
+
+// Next.js already handles routing (including dynamic routes), we often
+// omit `pattern` in `.METHOD`
+router.get((req, res, next) => {
+  res.end("This matches whatever route");
+});
+```
+
+> **Note**
+> You should understand Next.js [file-system based routing](https://nextjs.org/docs/routing/introduction). For example, having a `router.put("/api/foo", handler)` inside `page/api/index.js` _does not_ serve that handler at `/api/foo`.
+
+### router.all(pattern, ...fns)
+
+Same as [.METHOD](#methodpattern-fns) but accepts _any_ methods.
+
+### router.handler(options)
+
+Create a handler to handle incoming requests.
+
+**options.onError**
+
+Accepts a function as a catch-all error handler; executed whenever a handler throws an error.
+By default, it responds with a generic `500 Internal Server Error` while logging the error to `console`.
+
+```javascript
+function onError(err, req, res) {
+  logger.log(err);
+  // OR: console.error(err);
+
+  res.status(500).end("Internal server error");
+}
+
+export default router.handler({ onError });
+```
+
+**options.onNoMatch**
+
+Accepts a function of `(req, res)` as a handler when no route is matched.
+By default, it responds with a `404` status and a `Route [Method] [Url] not found` body.
+
+```javascript
+function onNoMatch(req, res) {
+  res.status(404).end("page is not found... or is it!?");
+}
+
+export default router.handler({ onNoMatch });
+```
+
+### router.run(req, res)
+
+Runs `req` and `res` through the middleware chain and returns a **promise**. It resolves with the value returned from handlers.
+
+```js
+router
+  .use(async (req, res, next) => {
+    return (await next()) + 1;
+  })
+  .use(async () => {
+    return (await next()) + 2;
+  })
+  .use(async () => {
+    return 3;
+  });
+
+console.log(await router.run(req, res));
+// The above will print "6"
+```
+
+If an error in thrown within the chain, `router.run` will reject. You can also add a try-catch in the first middleware to catch the error before it rejects the `.run()` call:
+
+```js
+router
+  .use(async (req, res, next) => {
+    return next().catch(errorHandler);
+  })
+  .use(thisMiddlewareMightThrow);
+
+await router.run(req, res);
+```
+
+## Common errors
+
+There are some pitfalls in using `@opensourceframework/next-connect`. Below are things to keep in mind to use it correctly.
+
+1. **Always** `await next()`
+
+If `next()` is not awaited, errors will not be caught if they are thrown in async handlers, leading to `UnhandledPromiseRejection`.
+
+```javascript
+// OK: we don't use async so no need to await
+router
+  .use((req, res, next) => {
+    next();
+  })
+  .use((req, res, next) => {
+    next();
+  })
+  .use(() => {
+    throw new Error("💥");
+  });
+
+// BAD: This will lead to UnhandledPromiseRejection
+router
+  .use(async (req, res, next) => {
+    next();
+  })
+  .use(async (req, res, next) => {
+    next();
+  })
+  .use(async () => {
+    throw new Error("💥");
+  });
+
+// GOOD
+router
+  .use(async (req, res, next) => {
+    await next(); // next() is awaited, so errors are caught properly
+  })
+  .use((req, res, next) => {
+    return next(); // this works as well since we forward the rejected promise
+  })
+  .use(async () => {
+    throw new Error("💥");
+    // return new Promise.reject("💥");
+  });
+```
+
+Another issue is that the handler would resolve before all the code in each layer runs.
+
+```javascript
+const handler = router
+  .use(async (req, res, next) => {
+    next(); // this is not returned or await
+  })
+  .get(async () => {
+    // simulate a long task
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    res.send("ok");
+    console.log("request is completed");
+  })
+  .handler();
+
+await handler(req, res);
+console.log("finally"); // this will run before the get layer gets to finish
+
+// This will result in:
+// 1) "finally"
+// 2) "request is completed"
+```
+
+2. **DO NOT** reuse the same instance of `router` like the below pattern:
+
+```javascript
+// api-libs/base.js
+export default createRouter().use(a).use(b);
+
+// api/foo.js
+import router from "api-libs/base";
+export default router.get(x).handler();
+
+// api/bar.js
+import router from "api-libs/base";
+export default router.get(y).handler();
+```
+
+This is because, in each API Route, the same router instance is mutated, leading to undefined behaviors.
+If you want to achieve something like that, you can use `router.clone` to return different instances with the same routes populated.
+
+```javascript
+// api-libs/base.js
+export default createRouter().use(a).use(b);
+
+// api/foo.js
+import router from "api-libs/base";
+export default router.clone().get(x).handler();
+
+// api/bar.js
+import router from "api-libs/base";
+export default router.clone().get(y).handler();
+```
+
+3. **DO NOT** use response function like `res.(s)end` or `res.redirect` inside `getServerSideProps`.
+
+```javascript
+// page/index.js
+const handler = createRouter()
+  .use((req, res) => {
+    // BAD: res.redirect is not a function (not defined in `getServerSideProps`)
+    // See https://github.com/hoangvvo/@opensourceframework/next-connect/issues/194#issuecomment-1172961741 for a solution
+    res.redirect("foo");
+  })
+  .use((req, res) => {
+    // BAD: `getServerSideProps` gives undefined behavior if we try to send a response
+    res.end("bar");
+  });
+
+export async function getServerSideProps({ req, res }) {
+  await router.run(req, res);
+  return {
+    props: {},
+  };
+}
+```
+
+3. **DO NOT** use `handler()` directly in `getServerSideProps`.
+
+```javascript
+// page/index.js
+const router = createRouter().use(foo).use(bar);
+const handler = router.handler();
+
+export async function getServerSideProps({ req, res }) {
+  await handler(req, res); // BAD: You should call router.run(req, res);
+  return {
+    props: {},
+  };
+}
+```
+
+## Contributing
+
+Please see my [contributing.md](CONTRIBUTING.md).
+
+## License
+
+[MIT](LICENSE)

package/dist/edge.d.cts

@@ -0,0 +1,25 @@
+import { R as RouteShortcutMethod, V as ValueOrPromise, a as RouteMatch, b as Nextable, H as HandlerOptions } from './types-C6rPiWOS.cjs';
+
+type RequestHandler<Req extends Request, Ctx> = (req: Req, ctx: Ctx) => ValueOrPromise<Response | void>;
+declare class EdgeRouter<Req extends Request = Request, Ctx = unknown> {
+    private router;
+    private add;
+    all: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    get: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    head: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    post: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    put: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    patch: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    delete: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    use(base: RouteMatch | Nextable<RequestHandler<Req, Ctx>> | EdgeRouter<Req, Ctx>, ...fns: (Nextable<RequestHandler<Req, Ctx>> | EdgeRouter<Req, Ctx>)[]): this;
+    private prepareRequest;
+    clone(): EdgeRouter<Req, Ctx>;
+    run(req: Req, ctx: Ctx): Promise<unknown>;
+    handler(options?: HandlerOptions<RequestHandler<Req, Ctx>>): (req: Req, ctx: Ctx) => Promise<any>;
+}
+declare function getPathname(req: Request & {
+    nextUrl?: URL;
+}): string;
+declare function createEdgeRouter<Req extends Request, Ctx>(): EdgeRouter<Req, Ctx>;
+
+export { EdgeRouter, type RequestHandler, createEdgeRouter, getPathname };

package/dist/edge.d.ts

@@ -0,0 +1,25 @@
+import { R as RouteShortcutMethod, V as ValueOrPromise, a as RouteMatch, b as Nextable, H as HandlerOptions } from './types-C6rPiWOS.js';
+
+type RequestHandler<Req extends Request, Ctx> = (req: Req, ctx: Ctx) => ValueOrPromise<Response | void>;
+declare class EdgeRouter<Req extends Request = Request, Ctx = unknown> {
+    private router;
+    private add;
+    all: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    get: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    head: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    post: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    put: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    patch: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    delete: RouteShortcutMethod<this, RequestHandler<Req, Ctx>>;
+    use(base: RouteMatch | Nextable<RequestHandler<Req, Ctx>> | EdgeRouter<Req, Ctx>, ...fns: (Nextable<RequestHandler<Req, Ctx>> | EdgeRouter<Req, Ctx>)[]): this;
+    private prepareRequest;
+    clone(): EdgeRouter<Req, Ctx>;
+    run(req: Req, ctx: Ctx): Promise<unknown>;
+    handler(options?: HandlerOptions<RequestHandler<Req, Ctx>>): (req: Req, ctx: Ctx) => Promise<any>;
+}
+declare function getPathname(req: Request & {
+    nextUrl?: URL;
+}): string;
+declare function createEdgeRouter<Req extends Request, Ctx>(): EdgeRouter<Req, Ctx>;
+
+export { EdgeRouter, type RequestHandler, createEdgeRouter, getPathname };

package/dist/express.d.cts

@@ -0,0 +1,9 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { RequestHandler } from './node.cjs';
+import { b as Nextable } from './types-C6rPiWOS.cjs';
+
+type NextFunction = (err?: any) => void;
+type ExpressRequestHandler<Req, Res> = (req: Req, res: Res, next: NextFunction) => void;
+declare function expressWrapper<Req extends IncomingMessage, Res extends ServerResponse>(fn: ExpressRequestHandler<Req, Res>): Nextable<RequestHandler<Req, Res>>;
+
+export { expressWrapper };

package/dist/express.d.ts

@@ -0,0 +1,9 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { RequestHandler } from './node.js';
+import { b as Nextable } from './types-C6rPiWOS.js';
+
+type NextFunction = (err?: any) => void;
+type ExpressRequestHandler<Req, Res> = (req: Req, res: Res, next: NextFunction) => void;
+declare function expressWrapper<Req extends IncomingMessage, Res extends ServerResponse>(fn: ExpressRequestHandler<Req, Res>): Nextable<RequestHandler<Req, Res>>;
+
+export { expressWrapper };

package/dist/index.d.cts

@@ -0,0 +1,5 @@
+export { createEdgeRouter } from './edge.cjs';
+export { expressWrapper } from './express.cjs';
+export { createRouter } from './node.cjs';
+export { H as HandlerOptions, N as NextHandler } from './types-C6rPiWOS.cjs';
+import 'http';

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { createEdgeRouter } from './edge.js';
+export { expressWrapper } from './express.js';
+export { createRouter } from './node.js';
+export { H as HandlerOptions, N as NextHandler } from './types-C6rPiWOS.js';
+import 'http';

package/dist/node.d.cts

@@ -0,0 +1,24 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { V as ValueOrPromise, R as RouteShortcutMethod, a as RouteMatch, b as Nextable, H as HandlerOptions } from './types-C6rPiWOS.cjs';
+
+type RequestHandler<Req extends IncomingMessage, Res extends ServerResponse> = (req: Req, res: Res) => ValueOrPromise<void>;
+declare class NodeRouter<Req extends IncomingMessage = IncomingMessage, Res extends ServerResponse = ServerResponse> {
+    private router;
+    private add;
+    all: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    get: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    head: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    post: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    put: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    patch: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    delete: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    use(base: RouteMatch | Nextable<RequestHandler<Req, Res>> | NodeRouter<Req, Res>, ...fns: (Nextable<RequestHandler<Req, Res>> | NodeRouter<Req, Res>)[]): this;
+    private prepareRequest;
+    clone(): NodeRouter<Req, Res>;
+    run(req: Req, res: Res): Promise<unknown>;
+    handler(options?: HandlerOptions<RequestHandler<Req, Res>>): (req: Req, res: Res) => Promise<void>;
+}
+declare function getPathname(url: string): string;
+declare function createRouter<Req extends IncomingMessage, Res extends ServerResponse>(): NodeRouter<Req, Res>;
+
+export { NodeRouter, type RequestHandler, createRouter, getPathname };

package/dist/node.d.ts

@@ -0,0 +1,24 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { V as ValueOrPromise, R as RouteShortcutMethod, a as RouteMatch, b as Nextable, H as HandlerOptions } from './types-C6rPiWOS.js';
+
+type RequestHandler<Req extends IncomingMessage, Res extends ServerResponse> = (req: Req, res: Res) => ValueOrPromise<void>;
+declare class NodeRouter<Req extends IncomingMessage = IncomingMessage, Res extends ServerResponse = ServerResponse> {
+    private router;
+    private add;
+    all: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    get: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    head: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    post: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    put: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    patch: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    delete: RouteShortcutMethod<this, RequestHandler<Req, Res>>;
+    use(base: RouteMatch | Nextable<RequestHandler<Req, Res>> | NodeRouter<Req, Res>, ...fns: (Nextable<RequestHandler<Req, Res>> | NodeRouter<Req, Res>)[]): this;
+    private prepareRequest;
+    clone(): NodeRouter<Req, Res>;
+    run(req: Req, res: Res): Promise<unknown>;
+    handler(options?: HandlerOptions<RequestHandler<Req, Res>>): (req: Req, res: Res) => Promise<void>;
+}
+declare function getPathname(url: string): string;
+declare function createRouter<Req extends IncomingMessage, Res extends ServerResponse>(): NodeRouter<Req, Res>;
+
+export { NodeRouter, type RequestHandler, createRouter, getPathname };

package/dist/types-C6rPiWOS.d.cts

@@ -0,0 +1,12 @@
+type FunctionLike = (...args: any[]) => unknown;
+type RouteMatch = string | RegExp;
+type NextHandler = () => ValueOrPromise<any>;
+type Nextable<H extends FunctionLike> = (...args: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
+interface HandlerOptions<Handler extends FunctionLike> {
+    onNoMatch?: Handler;
+    onError?: (err: unknown, ...args: Parameters<Handler>) => ReturnType<Handler>;
+}
+type ValueOrPromise<T> = T | Promise<T>;
+type RouteShortcutMethod<This, H extends FunctionLike> = (route: RouteMatch | Nextable<H>, ...fns: Nextable<H>[]) => This;
+
+export type { HandlerOptions as H, NextHandler as N, RouteShortcutMethod as R, ValueOrPromise as V, RouteMatch as a, Nextable as b };

package/dist/types-C6rPiWOS.d.ts

@@ -0,0 +1,12 @@
+type FunctionLike = (...args: any[]) => unknown;
+type RouteMatch = string | RegExp;
+type NextHandler = () => ValueOrPromise<any>;
+type Nextable<H extends FunctionLike> = (...args: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
+interface HandlerOptions<Handler extends FunctionLike> {
+    onNoMatch?: Handler;
+    onError?: (err: unknown, ...args: Parameters<Handler>) => ReturnType<Handler>;
+}
+type ValueOrPromise<T> = T | Promise<T>;
+type RouteShortcutMethod<This, H extends FunctionLike> = (route: RouteMatch | Nextable<H>, ...fns: Nextable<H>[]) => This;
+
+export type { HandlerOptions as H, NextHandler as N, RouteShortcutMethod as R, ValueOrPromise as V, RouteMatch as a, Nextable as b };

package/package.json

@@ -0,0 +1,83 @@
+{
+  "type": "module",
+  "name": "@opensourceframework/next-connect",
+  "version": "1.0.0",
+  "description": "The method routing and middleware layer for Next.js (and many others)",
+  "keywords": [
+    "javascript",
+    "nextjs",
+    "middleware",
+    "router",
+    "connect"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./node": {
+      "import": "./dist/node.js",
+      "require": "./dist/node.cjs"
+    },
+    "./edge": {
+      "import": "./dist/edge.js",
+      "require": "./dist/edge.cjs"
+    },
+    "./express": {
+      "import": "./dist/express.js",
+      "require": "./dist/express.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src --ext ts --ignore-path .gitignore",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/riceharvest/opensourceframework.git",
+    "directory": "packages/next-connect"
+  },
+  "author": "OpenSource Framework Contributors (fork), Original: Hoang Vo",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/riceharvest/opensourceframework/issues?q=is%3Aissue+is%3Aopen+next-connect"
+  },
+  "homepage": "https://github.com/riceharvest/opensourceframework/tree/main/packages/next-connect#readme",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  },
+  "dependencies": {
+    "regexparam": "^2.0.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "contributors": [
+    {
+      "name": "Hoang Vo",
+      "url": "https://github.com/hoangvvo/next-connect"
+    }
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "GitHub",
+    "url": "https://github.com/sponsors/riceharvest"
+  }
+}