hapi-terminator 0.3.1 → 0.5.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({
@@ -45,9 +44,14 @@ await server.register({
 });
 
 server.route({
-  method: ['GET', 'POST'],
+  method: ['POST'],
   path: '/',
   handler: () => 'Hello World!',
+  options: {
+    payload: {
+      maxBytes: 500 * 1024, // 500KB limit for this route
+    },
+  },
 });
 
 await server.start();
@@ -56,25 +60,21 @@ 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:
+You can set limits for specific routes using Hapi's native `payload.maxBytes` configuration:
 
 ```typescript
-import Hapi, { type PluginSpecificConfiguration } from '@hapi/hapi';
-import terminatorPlugin, { type TerminatorOptions, type TerminatorRouteOptions } from 'hapi-terminator';
-
-type RoutePluginOptions = PluginSpecificConfiguration & TerminatorRouteOptions;
+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)
 server.route({
   method: ['GET', 'POST'],
   path: '/',
@@ -87,21 +87,9 @@ server.route({
   path: '/upload',
   handler: () => ({ success: true }),
   options: {
-    plugins: {
-      'hapi-terminator': { limit: 10 * 1024 * 1024 }, // 10MB
-    } as RoutePluginOptions,
-  },
-});
-
-// 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,
+    payload: {
+      maxBytes: 10 * 1024 * 1024, // 10MB
+    },
   },
 });
 
@@ -122,7 +110,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,6 +119,11 @@ 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
@@ -144,7 +136,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 +147,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
 
-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. |
+Use Hapi's native `payload.maxBytes` option in your route configuration to set per-route limits:
+
+```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/index.d.ts

@@ -1,7 +1,7 @@
 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 type TerminatorOptions = {
+    unregisteredLimit?: number | boolean | null;
+};
 export declare const plugin: {
     pkg: {
         name: string;
@@ -27,9 +27,6 @@ export declare const plugin: {
             typescript: string;
             "typescript-eslint": string;
         };
-        dependencies: {
-            zod: string;
-        };
         prettier: string;
         "lint-staged": {
             "**/*.{js,ts,tsx}": string[];
@@ -53,16 +50,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>;
+declare function register(server: Server, rawOptions: Record<string, unknown> | null | undefined): Promise<void>;
 declare const _default: {
     plugin: {
         pkg: {
@@ -89,9 +77,6 @@ declare const _default: {
                 typescript: string;
                 "typescript-eslint": string;
             };
-            dependencies: {
-                zod: string;
-            };
             prettier: string;
             "lint-staged": {
                 "**/*.{js,ts,tsx}": string[];

package/index.js

@@ -1,37 +1,23 @@
-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));
+    const options = validateOptions(rawOptions);
+    server.ext('onRequest', validateHookHandler(options));
 }
-function validateHookHandler(pluginOptions, routeOptionsCache) {
+function validateHookHandler(pluginOptions) {
     return (request, h) => {
-        const handler = validateRoute(request, h, pluginOptions);
+        const handler = validateRoute(request, h);
+        const hasTransferEncoding = Boolean(request.headers['transfer-encoding']);
         const rawContentLength = request.headers['content-length'];
-        if (!rawContentLength) {
+        const willProcessPayload = hasTransferEncoding || Boolean(rawContentLength);
+        if (!willProcessPayload) {
             return h.continue;
         }
-        const contentLength = Number.parseInt(rawContentLength, 10);
-        if (Number.isNaN(contentLength)) {
-            return h.continue;
-        }
-        const { route, options } = getRouteAndOptions(request, routeOptionsCache) ?? {};
+        const contentLength = Number.parseInt(rawContentLength || '0', 10);
+        const route = request.server.match(request.method, request.path, request.info.host);
         if (route != null) {
-            return handler(contentLength, LIMIT_OPTION_NAMES.REGISTERED, options, option => {
+            const maxBytes = route.settings.payload?.maxBytes;
+            return handler(contentLength, maxBytes, option => {
                 return h
                     .response({
                     error: 'Request Entity Too Large',
@@ -41,30 +27,13 @@ function validateHookHandler(pluginOptions, routeOptionsCache) {
                     .code(413);
             });
         }
-        assert(options == null, "Unregistered routes can't have route options");
-        return handler(contentLength, LIMIT_OPTION_NAMES.UNREGISTERED, null, () => {
+        return handler(contentLength, (hasTransferEncoding ? 0 : null) ?? pluginOptions?.unregisteredLimit, () => {
             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;
+function validateRoute(request, h) {
+    return (contentLength, limit, response) => {
         if (limit == null) {
             return h.continue;
         }
@@ -76,12 +45,12 @@ function validateRoute(request, h, options) {
             closeSocketsOnFinish(request);
             return result;
         }
-        if (contentLength <= limit) {
-            return h.continue;
+        if (limit === 0 || contentLength > limit) {
+            const result = response(limit).takeover();
+            closeSocketsOnFinish(request);
+            return result;
         }
-        const result = response(limit).takeover();
-        closeSocketsOnFinish(request);
-        return result;
+        return h.continue;
     };
 }
 function closeSocketsOnFinish(request) {
@@ -95,7 +64,20 @@ function closeSocketsOnFinish(request) {
         }
     });
 }
-function getRoutePluginSettings(matchedRoute) {
-    return TerminatorRouteOptionsSchema.safeParse(matchedRoute?.settings.plugins).data;
+function validateOptions(options) {
+    if (options == null) {
+        return { unregisteredLimit: null };
+    }
+    if (!('unregisteredLimit' in options)) {
+        return { unregisteredLimit: null };
+    }
+    const unregisteredLimit = options.unregisteredLimit;
+    if (typeof unregisteredLimit === 'number') {
+        return { unregisteredLimit: Math.max(0, unregisteredLimit) };
+    }
+    if (typeof unregisteredLimit === 'boolean') {
+        return { unregisteredLimit };
+    }
+    return { unregisteredLimit: null };
 }
 export default { plugin };

package/package.json

@@ -3,7 +3,7 @@
   "main": "index.js",
   "typings": "index.d.ts",
   "type": "module",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "license": "MIT",
   "author": {
     "name": "Kamaal Farah"
@@ -22,9 +22,6 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.52.0"
   },
-  "dependencies": {
-    "zod": "^4.3.5"
-  },
   "prettier": "@kamaalio/prettier-config",
   "lint-staged": {
     "**/*.{js,ts,tsx}": [