@aghlimi/next-middleware-chain 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aghlimi
+
+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,138 @@
+# Next Middleware Chain
+
+A lightweight middleware chain for Next.js with route-based middleware and a `next()` API inspired by NestJS/Express.
+
+## Installation
+
+```bash
+pnpm add @aghlimi/next-middleware-chain
+```
+
+or:
+
+```bash
+npm install @aghlimi/next-middleware-chain
+```
+
+## Usage
+
+Register middleware in your Next.js `proxy.ts`:
+
+```ts
+import { NextRequest, NextResponse } from "next/server";
+import setMiddleware, {
+  executeMiddlewares,
+} from "@aghlimi/next-middleware-chain";
+
+setMiddleware("/api/*", async (request, next) => {
+  console.log(`Request to ${request.nextUrl.pathname}`);
+
+  const allowed = true;
+
+  if (!allowed) {
+    return NextResponse.json(
+      { message: "Forbidden" },
+      { status: 403 }
+    );
+  }
+
+  next();
+});
+
+setMiddleware("/api/*", async (request, next) => {
+  console.log("Second middleware");
+  next();
+});
+
+export async function proxy(request: NextRequest) {
+  return executeMiddlewares(request);
+}
+```
+
+Call `next()` to continue to the next matching middleware.
+
+Return a `NextResponse` without calling `next()` to stop the middleware chain.
+
+## Route Matching
+
+Paths passed to `setMiddleware()` are JavaScript regular expressions:
+
+```ts
+setMiddleware("/api/*", middleware);
+```
+
+The expression is evaluated using:
+
+```ts
+new RegExp(pathExpression).test(request.nextUrl.pathname);
+```
+
+For stricter matching, you can use any valid regex:
+
+```ts
+setMiddleware("^/api(?:/|$)", middleware);
+setMiddleware("^/api/admin(?:/|$)", adminMiddleware);
+```
+
+Multiple middleware functions can match the same request and are executed in registration order.
+
+## Separate Middleware Files
+
+You can define reusable middleware using `MiddlewareFunction`:
+
+```ts
+import type {
+  MiddlewareFunction,
+} from "@aghlimi/next-middleware-chain";
+
+const logger: MiddlewareFunction = async (request, next) => {
+  console.log(`${request.method} ${request.nextUrl.pathname}`);
+  next();
+};
+
+export default logger;
+```
+
+Then register it:
+
+```ts
+import setMiddleware from "@aghlimi/next-middleware-chain";
+import logger from "./middlewares/logger";
+
+setMiddleware("/api/*", logger);
+```
+
+## API
+
+### `setMiddleware(pathExpression, middleware)`
+
+Registers middleware for a path expression.
+
+```ts
+setMiddleware("/api/*", middleware);
+```
+
+### `executeMiddlewares(request)`
+
+Executes middleware matching the current request.
+
+```ts
+export async function proxy(request: NextRequest) {
+  return executeMiddlewares(request);
+}
+```
+
+### `MiddlewareFunction`
+
+Type for reusable middleware:
+
+```ts
+type MiddlewareFunction = (
+  request: NextRequest,
+  next: () => Promise<NextResponse | void>
+) => Promise<NextResponse | void>;
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { NextRequest, NextResponse } from "next/server";
+export type MiddlewareFunction = (request: NextRequest, next: () => Promise<NextResponse | void>) => Promise<NextResponse | void>;
+declare function setMiddleware(pathExpression: string, middlewareFunction: MiddlewareFunction): void;
+export declare function getMiddlewares(path: string): MiddlewareFunction[];
+export declare function executeMiddlewares(request: NextRequest): Promise<NextResponse>;
+export default setMiddleware;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,kBAAkB,GAAG,CAC/B,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,MAAM,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,KACrC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;AAIlC,iBAAS,aAAa,CACpB,cAAc,EAAE,MAAM,EACtB,kBAAkB,EAAE,kBAAkB,GACrC,IAAI,CAKN;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAIjE;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,YAAY,CAAC,CAmBvB;AAED,eAAe,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,28 @@
+import { NextResponse } from "next/server";
+const config = new Map();
+function setMiddleware(pathExpression, middlewareFunction) {
+    config.set(pathExpression, [
+        ...(config.get(pathExpression) || []),
+        middlewareFunction,
+    ]);
+}
+export function getMiddlewares(path) {
+    return Array.from(config.entries())
+        .filter(([key]) => new RegExp(key).test(path))
+        .flatMap(([, value]) => value);
+}
+export async function executeMiddlewares(request) {
+    const path = request.nextUrl.pathname;
+    const middlewares = getMiddlewares(path);
+    async function dispatch(index) {
+        const middleware = middlewares[index];
+        if (!middleware) {
+            return NextResponse.next();
+        }
+        const next = () => dispatch(index + 1);
+        return middleware(request, next);
+    }
+    const response = await dispatch(0);
+    return response instanceof NextResponse ? response : NextResponse.next();
+}
+export default setMiddleware;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@aghlimi/next-middleware-chain",
+  "version": "1.0.0",
+  "description": "A tiny middleware-chain utility for Next.js request proxies.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "nextjs",
+    "middleware",
+    "typescript",
+    "proxy"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Aghlimi/nextjs-middleware.git"
+  },
+  "peerDependencies": {
+    "next": ">=16"
+  },
+  "devDependencies": {
+    "next": "^16.3.4",
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}