hapi-terminator 0.3.0 → 0.4.0

package/README.md

@@ -36,7 +36,6 @@ const server = Hapi.server({ port: 3000, host: '127.0.0.1' });
 
 const requestTerminateOptions: TerminatorOptions = {
   unregisteredLimit: 500 * 1024, // 500KB for unregistered routes
-  registeredLimit: 500 * 1024, // 500KB for registered routes
 };
 
 await server.register({
@@ -48,6 +47,11 @@ server.route({
   method: ['GET', 'POST'],
   path: '/',
   handler: () => 'Hello World!',
+  options: {
+    payload: {
+      maxBytes: 500 * 1024, // 500KB limit for this route
+    },
+  },
 });
 
 await server.start();
@@ -56,29 +60,31 @@ console.log('Server running on %s', server.info.uri);
 
 ### Per-Route Limits
 
-You can override the global limits for specific routes by setting the limit in the route options:
-
-```typescript
-import Hapi, { type PluginSpecificConfiguration } from '@hapi/hapi';
-import terminatorPlugin, { type TerminatorOptions, type TerminatorRouteOptions } from 'hapi-terminator';
+You can set limits for specific routes using Hapi's native `payload.maxBytes` configuration:
 
-type RoutePluginOptions = PluginSpecificConfiguration & TerminatorRouteOptions;
+````typescript
+import Hapi from '@hapi/hapi';
+import terminatorPlugin, { type TerminatorOptions } from 'hapi-terminator';
 
 const server = Hapi.server({ port: 3000, host: '127.0.0.1' });
 
 await server.register({
   plugin: terminatorPlugin,
   options: {
-    registeredLimit: 500 * 1024, // 500KB default for registered routes
     unregisteredLimit: 100 * 1024, // 100KB for unregistered routes
   },
 });
 
-// Standard route with default limit (500KB)
+// Standard route with 500KB limit
 server.route({
   method: ['GET', 'POST'],
   path: '/',
   handler: () => 'Hello World!',
+  options: {
+    payload: {
+      maxBytes: 500 * 1024, // 500KB
+    },
+  },
 });
 
 // Upload route with higher limit (10MB)
@@ -87,26 +93,13 @@ server.route({
   path: '/upload',
   handler: () => ({ success: true }),
   options: {
-    plugins: {
-      'hapi-terminator': { limit: 10 * 1024 * 1024 }, // 10MB
-    } as RoutePluginOptions,
+    payload: {
+      maxBytes: 10 * 1024 * 1024, // 10MB
+    },
   },
 });
 
-// Unlimited route (disable limit for this specific route)
-server.route({
-  method: ['POST'],
-  path: '/stream',
-  handler: () => ({ success: true }),
-  options: {
-    plugins: {
-      'hapi-terminator': { limit: null }, // No limit
-    } as RoutePluginOptions,
-  },
-});
-
-await server.start();
-```
+});\n\nawait server.start();\n```
 
 ### Boolean Limits for Unregistered Routes
 
@@ -122,7 +115,6 @@ const server = Hapi.server({ port: 3000, host: '127.0.0.1' });
 await server.register({
   plugin: terminatorPlugin,
   options: {
-    registeredLimit: 1024 * 1024, // 1MB for registered routes
     unregisteredLimit: true, // Immediately reject all unregistered routes
   },
 });
@@ -132,11 +124,16 @@ server.route({
   method: ['POST'],
   path: '/api/data',
   handler: () => ({ success: true }),
+  options: {
+    payload: {
+      maxBytes: 1024 * 1024, // 1MB
+    },
+  },
 });
 
 // Any request to unregistered routes (e.g., /unknown) will be rejected immediately
 await server.start();
-```
+````
 
 You can also set `unregisteredLimit` to `false` to bypass payload size checks for unregistered routes:
 
@@ -144,7 +141,6 @@ You can also set `unregisteredLimit` to `false` to bypass payload size checks fo
 await server.register({
   plugin: terminatorPlugin,
   options: {
-    registeredLimit: 500 * 1024, // 500KB for registered routes
     unregisteredLimit: false, // Bypass payload size checks for unregistered routes
   },
 });
@@ -156,23 +152,33 @@ await server.register({
 
 | Option              | Type                | Description                                                                                                                                                                                                   |
 | ------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `registeredLimit`   | `number`            | Maximum payload size in bytes for registered routes. Must be >= 0. Set to `null` or `undefined` to disable.                                                                                                   |
 | `unregisteredLimit` | `number \| boolean` | Maximum payload size in bytes for unregistered routes. Must be >= 0. Set to `null` or `undefined` to disable. Set to `true` to reject all requests immediately. Set to `false` to bypass payload size checks. |
 
-### TerminatorRouteOptions
+### Route Payload Configuration
+
+Use Hapi's native `payload.maxBytes` option in your route configuration to set per-route limits:
 
-You can configure per-route limits using the route options:
+Use Hapi's native `payload.maxBytes` option in your route configuration to set per-route limits:
 
-| Option  | Type     | Description                                                                                                                            |
-| ------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| `limit` | `number` | Maximum payload size in bytes for this specific route. Must be >= 0. Overrides the global `registeredLimit`. Set to `null` to disable. |
+```typescript
+server.route({
+  method: 'POST',
+  path: '/upload',
+  handler: () => ({ success: true }),
+  options: {
+    payload: {
+      maxBytes: 10 * 1024 * 1024, // 10MB
+    },
+  },
+});
+```
 
 ### Behavior
 
-- **Registered Routes**: When a payload exceeds the limit on a registered route, the socket is gracefully ended and a `413 Payload Too Large` error is returned.
-- **Unregistered Routes**: When a payload exceeds the limit on an unregistered route, the socket is gracefully ended and a `404 Not Found` error is returned.
-- **Per-Route Limits**: Route-specific limits take precedence over global limits, allowing you to customize limits for individual routes.
-- **Disabled**: Set to `null` or `undefined` to disable termination for that category or route.
+- **Registered Routes**: Routes use Hapi's native `payload.maxBytes` setting. When a payload exceeds this limit, the socket is gracefully ended and a `413 Payload Too Large` error is returned.
+- **Unregistered Routes**: When a payload exceeds the `unregisteredLimit`, the socket is gracefully ended and a `404 Not Found` error is returned.
+- **Per-Route Limits**: Use Hapi's `payload.maxBytes` to customize limits for individual routes.
+- **Disabled**: Omit `payload.maxBytes` to allow unlimited payload size for a route.
 - **Boolean Values for Unregistered Routes**:
   - Set `unregisteredLimit` to `true` to immediately reject all unregistered route requests regardless of Content-Length (even 0 bytes).
   - Set `unregisteredLimit` to `false` to bypass payload size checks for unregistered route requests (they will still receive 404 responses).

package/{dist/index.d.ts → index.d.ts}

@@ -1,6 +1,5 @@
 import type { Server } from '@hapi/hapi';
 import { z } from 'zod/mini';
-export type TerminatorRouteOptions = z.infer<typeof TerminatorRouteOptionsSchema>;
 export type TerminatorOptions = z.infer<typeof TerminatorOptionsSchema>;
 export declare const plugin: {
     pkg: {
@@ -53,13 +52,7 @@ export declare const plugin: {
     };
     register: typeof register;
 };
-declare const TerminatorRouteOptionsSchema: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniObject<{
-    "hapi-terminator": z.ZodMiniObject<{
-        limit: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniNumber<number>>>;
-    }, z.core.$strip>;
-}, z.core.$strip>>>;
 declare const TerminatorOptionsSchema: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniObject<{
-    registeredLimit: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniNumber<number>>>;
     unregisteredLimit: z.ZodMiniUnion<readonly [z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniNumber<number>>>, z.ZodMiniBoolean<boolean>]>;
 }, z.core.$strip>>>;
 declare function register(server: Server, rawOptions: TerminatorOptions): Promise<void>;

package/index.js

@@ -0,0 +1,71 @@
+import { z } from 'zod/mini';
+import pkg from './package.json';
+export const plugin = { pkg, register };
+const TerminatorOptionsSchema = z.nullish(z.object({
+    unregisteredLimit: z.union([z.nullish(z.number().check(z.minimum(0))), z.boolean()]),
+}));
+async function register(server, rawOptions) {
+    const options = TerminatorOptionsSchema.parse(rawOptions);
+    server.ext('onRequest', validateHookHandler(options));
+}
+function validateHookHandler(pluginOptions) {
+    return (request, h) => {
+        const handler = validateRoute(request, h);
+        const hasTransferEncoding = Boolean(request.headers['transfer-encoding']);
+        const rawContentLength = request.headers['content-length'];
+        const willProcessPayload = hasTransferEncoding || Boolean(rawContentLength);
+        if (!willProcessPayload) {
+            return h.continue;
+        }
+        const contentLength = Number.parseInt(rawContentLength || '0', 10);
+        const route = request.server.match(request.method, request.path, request.info.host);
+        if (route != null) {
+            const maxBytes = route.settings.payload?.maxBytes;
+            return handler(contentLength, maxBytes, option => {
+                return h
+                    .response({
+                    error: 'Request Entity Too Large',
+                    message: `Payload content length greater than maximum allowed: ${option}`,
+                    statusCode: 413,
+                })
+                    .code(413);
+            });
+        }
+        return handler(contentLength, (hasTransferEncoding ? 0 : null) ?? pluginOptions?.unregisteredLimit, () => {
+            return h.response({ error: 'Not Found', message: 'Not Found', statusCode: 404 }).code(404);
+        });
+    };
+}
+function validateRoute(request, h) {
+    return (contentLength, limit, response) => {
+        if (limit == null) {
+            return h.continue;
+        }
+        if (limit === false) {
+            return h.continue;
+        }
+        if (limit === true) {
+            const result = response(0).takeover();
+            closeSocketsOnFinish(request);
+            return result;
+        }
+        if (limit === 0 || contentLength > limit) {
+            const result = response(limit).takeover();
+            closeSocketsOnFinish(request);
+            return result;
+        }
+        return h.continue;
+    };
+}
+function closeSocketsOnFinish(request) {
+    request.raw.res.once('finish', () => {
+        const socket = request.raw.req.socket;
+        if (socket.destroy) {
+            socket.destroy();
+        }
+        else {
+            socket.end();
+        }
+    });
+}
+export default { plugin };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "hapi-terminator",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "index.js",
+  "typings": "index.d.ts",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "MIT",
   "author": {
     "name": "Kamaal Farah"
@@ -47,6 +47,7 @@
     "access": "public"
   },
   "files": [
-    "dist"
+    "index.js",
+    "index.d.ts"
   ]
 }

package/dist/index.js

@@ -1,94 +0,0 @@
-import assert from 'node:assert';
-import { z } from 'zod/mini';
-import pkg from './package.json';
-const LIMIT_OPTION_NAMES = {
-    REGISTERED: 'registeredLimit',
-    UNREGISTERED: 'unregisteredLimit',
-};
-const PACKAGE_NAME = 'hapi-terminator';
-assert(PACKAGE_NAME === pkg.name);
-export const plugin = { pkg, register };
-const TerminatorRouteOptionsSchema = z.nullish(z.object({ [PACKAGE_NAME]: z.object({ limit: z.nullish(z.number().check(z.minimum(0))) }) }));
-const TerminatorOptionsSchema = z.nullish(z.object({
-    registeredLimit: z.nullish(z.number().check(z.minimum(0))),
-    unregisteredLimit: z.union([z.nullish(z.number().check(z.minimum(0))), z.boolean()]),
-}));
-async function register(server, rawOptions) {
-    const options = TerminatorOptionsSchema.parse(rawOptions);
-    const routeOptionsCache = new Map();
-    server.ext('onRequest', validateHookHandler(options, routeOptionsCache));
-}
-function validateHookHandler(pluginOptions, routeOptionsCache) {
-    return (request, h) => {
-        const handler = validateRoute(request, h, pluginOptions);
-        const rawContentLength = request.headers['content-length'];
-        if (!rawContentLength) {
-            return h.continue;
-        }
-        const contentLength = Number.parseInt(rawContentLength, 10);
-        if (Number.isNaN(contentLength)) {
-            return h.continue;
-        }
-        const { route, options } = getRouteAndOptions(request, routeOptionsCache) ?? {};
-        if (route != null) {
-            return handler(contentLength, LIMIT_OPTION_NAMES.REGISTERED, options, option => {
-                return h
-                    .response({
-                    error: 'Request Entity Too Large',
-                    message: `Payload content length greater than maximum allowed: ${option}`,
-                    statusCode: 413,
-                })
-                    .code(413);
-            });
-        }
-        assert(options == null, "Unregistered routes can't have route options");
-        return handler(contentLength, LIMIT_OPTION_NAMES.UNREGISTERED, null, () => {
-            return h.response({ error: 'Not Found', message: 'Not Found', statusCode: 404 }).code(404);
-        });
-    };
-}
-function getRouteAndOptions(request, routeOptionsCache) {
-    const matchedRoute = request.server.match(request.method, request.path, request.info.host);
-    if (matchedRoute == null) {
-        return null;
-    }
-    const cacheKey = `${matchedRoute.method}-${matchedRoute.path}`;
-    const cachedResult = routeOptionsCache.get(cacheKey);
-    if (cachedResult != null) {
-        return { options: cachedResult, route: matchedRoute };
-    }
-    const options = getRoutePluginSettings(matchedRoute);
-    routeOptionsCache.set(cacheKey, options);
-    return { options, route: matchedRoute };
-}
-function validateRoute(request, h, options) {
-    return (contentLength, optionName, routeOptions, response) => {
-        const option = options?.[optionName];
-        const limit = routeOptions?.[PACKAGE_NAME]?.limit ?? option;
-        if (limit == null) {
-            return h.continue;
-        }
-        if (limit === false) {
-            return h.continue;
-        }
-        if (limit === true) {
-            const result = response(0).takeover();
-            request.raw.res.once('finish', () => {
-                request.raw.req.socket.end();
-            });
-            return result;
-        }
-        if (contentLength <= limit) {
-            return h.continue;
-        }
-        const result = response(limit).takeover();
-        request.raw.res.once('finish', () => {
-            request.raw.req.socket.end();
-        });
-        return result;
-    };
-}
-function getRoutePluginSettings(matchedRoute) {
-    return TerminatorRouteOptionsSchema.safeParse(matchedRoute?.settings.plugins).data;
-}
-export default { plugin };

package/dist/package.json

@@ -1,52 +0,0 @@
-{
-    "name": "hapi-terminator",
-    "main": "dist/index.js",
-    "typings": "dist/index.d.ts",
-    "type": "module",
-    "version": "0.3.0",
-    "license": "MIT",
-    "author": {
-        "name": "Kamaal Farah"
-    },
-    "devDependencies": {
-        "@eslint/js": "^9.39.2",
-        "@hapi/hapi": "^21.4.4",
-        "@kamaalio/prettier-config": "^0.1.2",
-        "@types/bun": "latest",
-        "eslint": "^9.39.2",
-        "globals": "^17.0.0",
-        "husky": "^9.1.7",
-        "jiti": "^2.6.1",
-        "lint-staged": "^16.2.7",
-        "prettier": "^3.7.4",
-        "typescript": "^5.9.3",
-        "typescript-eslint": "^8.52.0"
-    },
-    "dependencies": {
-        "zod": "^4.3.5"
-    },
-    "prettier": "@kamaalio/prettier-config",
-    "lint-staged": {
-        "**/*.{js,ts,tsx}": [
-            "eslint --fix"
-        ],
-        "**/*": "prettier --write --ignore-unknown"
-    },
-    "scripts": {
-        "compile": "tsc --project tsconfig.build.json",
-        "format": "prettier --write .",
-        "format:check": "prettier --check .",
-        "lint": "eslint .",
-        "prepare": "bunx husky",
-        "prepack": "rm -rf dist && bun run compile",
-        "quality": "bun run format:check && bun run lint && bun run typecheck",
-        "test": "bun test",
-        "typecheck": "tsc --noEmit"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "files": [
-        "dist"
-    ]
-}