@openaddresses/batch-schema 10.26.0 → 10.27.0

package/.github/workflows/test.yml

@@ -1,29 +1,29 @@
 name: Test
 
 on:
-    pull_request:
-        types:
-            - opened
-            - synchronize
-            - reopened
-            - ready_for_review
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - ready_for_review
 
 jobs:
-    build:
-        runs-on: ubuntu-latest
-        if: github.event.pull_request.draft == false
-        steps:
-            - uses: actions/checkout@v2
-              with:
-                  ref: ${{ github.event.pull_request.head.sha }}
+  build:
+    runs-on: ubuntu-latest
+    if: github.event.pull_request.draft == false
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
 
-            - uses: actions/setup-node@v2
-              with:
-                node-version: '18'
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '18'
 
-            - run: npm install
+      - run: npm install
 
-            - run: npm run lint
+      - run: npm run lint
 
-            - run: npm test
+      - run: npm test
 

package/CHANGELOG.md

@@ -10,6 +10,17 @@
 
 ## Version History
 
+### v10.27.0 - 2026-07-06
+
+- :rocket: Only wrap `res.json` when a route has a response schema that requires validation — routes without one no longer pay any response-path overhead
+- :rocket: Replace the `JSON.parse(JSON.stringify())` response clone with a single-pass JSON-semantics clone (~1.3-1.6x faster, no intermediate string allocation)
+- :rocket: Skip the response clone entirely for non-200 responses (validation was already skipped)
+- :bug: `Type.Any`/`Type.Unknown` response schemas were still compiled and validated on every request due to a broken `instanceof` check; now detected via the TypeBox `Kind` symbol and skipped
+- :rocket: Precompute the body content-type matcher and supported-types error string at route registration instead of rebuilding them per request
+- :rocket: Consolidate the five per-method route registration paths into a single shared implementation
+- :rocket: Truncate response-validation error logging to 4KB
+- :white_check_mark: Add response validation test suite
+
 ### v10.26.0
 
 - :rocket: Allow non-json content-type

package/dist/lib/schema.d.ts

@@ -5,16 +5,25 @@ import type { Static, TSchema } from '@sinclair/typebox';
 import { OpenAPIV3 as Doc } from 'openapi-types';
 import { Router } from 'express';
 import type { RequestHandler } from 'express';
-import { Ajv } from 'ajv';
-import type { ErrorObject } from 'ajv';
-import type { RequestValidation } from './types.js';
+import type { ErrorObject, ValidateFunction } from 'ajv';
+import type { RequestValidation, NormalizedBody } from './types.js';
 import type { OpenAPIDocumentInput } from './openapi.js';
 import Docs from './openapi.js';
-declare const ajv: Ajv;
 export type ErrorListItem = {
     type: 'Body' | 'Query' | 'Params';
     errors: ErrorObject[];
 };
+/**
+ * Per-route body validation state, compiled once at route registration:
+ * ajv validators keyed by content-type, the normalized map used for
+ * content-type matching, and the precomputed supported-types string
+ * used in error messages.
+ */
+export type CompiledBodyValidation = {
+    validators: Map<string, true | ValidateFunction>;
+    matcher: NormalizedBody;
+    supported: string;
+};
 /**
  * @class
  *
@@ -37,19 +46,21 @@ export default class Schemas {
     validationError(method: Doc.HttpMethods, path: string): Err;
     /**
      * Compile body validators keyed by content-type. Returns null when no
-     * body validation is configured. Each entry is either `true` (any body
-     * accepted for this content-type) or a compiled ajv validator function.
+     * body validation is configured. Each validator entry is either `true`
+     * (any body accepted for this content-type) or a compiled ajv validator.
+     * The content-type matcher and supported-types error string are
+     * precomputed here so no per-request allocation is needed.
      */
-    compileBodyValidators(body: RequestValidation<TSchema, TSchema, TSchema, TSchema>['body']): Map<string, true | ReturnType<typeof ajv.compile>> | null;
+    compileBodyValidators(body: RequestValidation<TSchema, TSchema, TSchema, TSchema>['body']): CompiledBodyValidation | null;
     /**
-     * Validate the incoming request body against the compiled validator
-     * map for the route. Pushes a Body error onto `errors` if validation
+     * Validate the incoming request body against the compiled validation
+     * state for the route. Pushes a Body error onto `errors` if validation
      * fails; returns an Err to respond with for an unsupported content-type.
      *
-     * If `bodyRequired` is false and the request has no body / no
+     * If `opts.required` is false and the request has no body / no
      * content-type, validation is skipped.
      */
-    validateBody(req: Request, validators: Map<string, true | ReturnType<typeof ajv.compile>>, errors: Array<ErrorListItem>, opts?: {
+    validateBody(req: Request, compiled: CompiledBodyValidation, errors: Array<ErrorListItem>, opts?: {
         required?: boolean;
     }): Err | null;
     constructor(router: Router, opts?: {
@@ -84,6 +95,19 @@ export default class Schemas {
     blueprint<T>(bp_fn: (schema: Schemas, config?: T) => Promise<void>, config?: T, opts?: {
         silent: boolean;
     }): Promise<void>;
+    /**
+     * Compile the response validator for a route. Type.Any and Type.Unknown
+     * impose no constraints, so they are skipped entirely — routes with an
+     * open response schema (or none) bypass response validation and its
+     * clone at request time.
+     */
+    private compileResponseValidation;
+    /**
+     * Shared route registration: compiles all validators once, then installs
+     * a request handler that validates params/query/body and — only when a
+     * response schema requires it — wraps res.json with response validation.
+     */
+    private route;
     get<TParams extends TSchema, TQuery extends TSchema, TBody extends TSchema, TResponse extends TSchema>(path: string, opts: RequestValidation<TParams, TQuery, TBody, TResponse> | undefined, handler: RequestHandler<Static<TParams>, Static<TResponse>, Static<TBody>, Static<TQuery>>): Promise<void>;
     delete<TParams extends TSchema, TQuery extends TSchema, TBody extends TSchema, TResponse extends TSchema>(path: string, opts: RequestValidation<TParams, TQuery, TBody, TResponse> | undefined, handler: RequestHandler<Static<TParams>, Static<TResponse>, Static<TBody>, Static<TQuery>>): Promise<void>;
     post<TParams extends TSchema, TQuery extends TSchema, TBody extends TSchema, TResponse extends TSchema>(path: string, opts: RequestValidation<TParams, TQuery, TBody, TResponse> | undefined, handler: RequestHandler<Static<TParams>, Static<TResponse>, Static<TBody>, Static<TQuery>>): Promise<void>;
@@ -104,4 +128,3 @@ export default class Schemas {
         };
     };
 }
-export {};

package/dist/lib/schema.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import morgan from 'morgan';
 import bodyparser from 'body-parser';
 import Err from '@openaddresses/batch-error';
-import { Type } from '@sinclair/typebox';
+import { Kind } from '@sinclair/typebox';
 import { OpenAPIV3 as Doc } from 'openapi-types';
 import { Router } from 'express';
 import { Ajv } from 'ajv';
@@ -19,6 +19,61 @@ const ajv = new Ajv({
     coerceTypes: true
 });
 addFormatsModule.default(ajv);
+const MAX_LOGGED_RESPONSE = 4096;
+/**
+ * Deep-clone a value following JSON.stringify semantics: toJSON() support
+ * (Date => ISO string), undefined/function/symbol omission, NaN/Infinity
+ * => null, and circular reference detection. Response validation needs the
+ * serialized shape of the payload (Dates must already be strings), and ajv's
+ * removeAdditional/useDefaults mutate the object they validate, so the
+ * caller's object must be protected. A single-pass clone does both without
+ * the cost of JSON.parse(JSON.stringify()) building an intermediate string.
+ */
+function jsonClone(value, seen) {
+    if (value !== null && typeof value === 'object' && typeof value.toJSON === 'function') {
+        value = value.toJSON();
+    }
+    if (value === null)
+        return null;
+    switch (typeof value) {
+        case 'string':
+        case 'boolean':
+            return value;
+        case 'number':
+            return Number.isFinite(value) ? value : null;
+        case 'bigint':
+            throw new TypeError('Do not know how to serialize a BigInt');
+        case 'object':
+            break;
+        default:
+            return undefined; // undefined | function | symbol are omitted, as in JSON.stringify
+    }
+    if (!seen)
+        seen = new Set();
+    if (seen.has(value))
+        throw new TypeError('Converting circular structure to JSON');
+    seen.add(value);
+    let out;
+    if (Array.isArray(value)) {
+        const arr = new Array(value.length);
+        for (let i = 0; i < value.length; i++) {
+            const v = jsonClone(value[i], seen);
+            arr[i] = v === undefined ? null : v;
+        }
+        out = arr;
+    }
+    else {
+        const obj = {};
+        for (const key of Object.keys(value)) {
+            const v = jsonClone(value[key], seen);
+            if (v !== undefined)
+                obj[key] = v;
+        }
+        out = obj;
+    }
+    seen.delete(value);
+    return out;
+}
 /**
  * @class
  *
@@ -43,46 +98,48 @@ export default class Schemas {
     }
     /**
      * Compile body validators keyed by content-type. Returns null when no
-     * body validation is configured. Each entry is either `true` (any body
-     * accepted for this content-type) or a compiled ajv validator function.
+     * body validation is configured. Each validator entry is either `true`
+     * (any body accepted for this content-type) or a compiled ajv validator.
+     * The content-type matcher and supported-types error string are
+     * precomputed here so no per-request allocation is needed.
      */
     compileBodyValidators(body) {
         const normalized = normalizeBody(body);
         if (!normalized)
             return null;
-        const map = new Map();
+        const validators = new Map();
         for (const ct of Object.keys(normalized)) {
             const schema = normalized[ct].schema;
             if (schema === true || schema === undefined) {
-                map.set(ct, true);
+                validators.set(ct, true);
             }
             else {
-                map.set(ct, ajv.compile(schema));
+                validators.set(ct, ajv.compile(schema));
             }
         }
-        return map;
+        return {
+            validators,
+            matcher: normalized,
+            supported: Object.keys(normalized).join(', ')
+        };
     }
     /**
-     * Validate the incoming request body against the compiled validator
-     * map for the route. Pushes a Body error onto `errors` if validation
+     * Validate the incoming request body against the compiled validation
+     * state for the route. Pushes a Body error onto `errors` if validation
      * fails; returns an Err to respond with for an unsupported content-type.
      *
-     * If `bodyRequired` is false and the request has no body / no
+     * If `opts.required` is false and the request has no body / no
      * content-type, validation is skipped.
      */
-    validateBody(req, validators, errors, opts = {}) {
+    validateBody(req, compiled, errors, opts = {}) {
         const raw = (req.headers['content-type'] || '').split(';')[0].trim().toLowerCase();
         const required = opts.required !== false;
         if (!raw && !required)
             return null;
-        const normalizedMap = {};
-        for (const key of validators.keys())
-            normalizedMap[key] = { schema: true };
-        const matched = matchContentType(raw, normalizedMap);
-        const validator = matched ? validators.get(matched) : undefined;
+        const matched = matchContentType(raw, compiled.matcher);
+        const validator = matched ? compiled.validators.get(matched) : undefined;
         if (!validator) {
-            const supported = Array.from(validators.keys()).join(', ');
-            return new Err(400, null, `Content-Type ${raw || '(none)'} not supported. Supported: ${supported}`);
+            return new Err(400, null, `Content-Type ${raw || '(none)'} not supported. Supported: ${compiled.supported}`);
         }
         if (validator !== true) {
             if (!validator(req.body)) {
@@ -172,60 +229,40 @@ export default class Schemas {
             console.log(`ok - loaded blueprint`);
         await bp_fn(this, config);
     }
-    async get(path, opts = {}, handler) {
-        try {
-            const validation = this.normalizeValidation(opts);
-            this.docs.push({ method: Doc.HttpMethods.GET, path: path }, validation);
-            this.schemas.set(`GET ${path}`, validation);
-            const resValidation = validation.res && !(validation.res instanceof Type.Any) && !(validation.res instanceof Type.Unknown) && ajv.compile(validation.res);
-            const paramsValidation = validation.params && ajv.compile(validation.params);
-            const queryValidation = validation.query && ajv.compile(validation.query);
-            if (validation.body)
-                throw new Error(`Body not allowed`);
-            const _handler = (req, res, next) => {
-                if (req.query) { // Ref: https://github.com/cdimascio/express-openapi-validator/issues/969
-                    Object.defineProperty(req, 'query', {
-                        writable: true,
-                        value: { ...req.query },
-                    });
-                }
-                const errors = [];
-                if (paramsValidation && !paramsValidation(req.params))
-                    errors.push({ type: 'Params', errors: paramsValidation.errors });
-                if (queryValidation && !queryValidation(req.query))
-                    errors.push({ type: 'Query', errors: queryValidation.errors });
-                if (errors.length)
-                    return Err.respond(this.validationError(Doc.HttpMethods.GET, path), res, errors);
-                const json = res.json;
-                res.json = function (obj) {
-                    obj = JSON.parse(JSON.stringify(obj)); // Here as Date => String needs to happen
-                    if ((res.statusCode === null || res.statusCode === 200) && resValidation && !resValidation(obj)) {
-                        res.status(400);
-                        console.error(`Response Validation Error: ${JSON.stringify(obj)}`);
-                        return json.call(this, { type: 'Response', errors: resValidation.errors });
-                    }
-                    else {
-                        return json.call(this, obj);
-                    }
-                };
-                return handler(req, res, next);
-            };
-            this.router.get(path, _handler);
-        }
-        catch (err) {
-            throw new Error(`Get: ${path}: ` + err, { cause: err });
-        }
+    /**
+     * Compile the response validator for a route. Type.Any and Type.Unknown
+     * impose no constraints, so they are skipped entirely — routes with an
+     * open response schema (or none) bypass response validation and its
+     * clone at request time.
+     */
+    compileResponseValidation(res) {
+        if (!res)
+            return null;
+        if (res[Kind] === 'Any' || res[Kind] === 'Unknown')
+            return null;
+        return ajv.compile(res);
     }
-    async delete(path, opts = {}, handler) {
+    /**
+     * Shared route registration: compiles all validators once, then installs
+     * a request handler that validates params/query/body and — only when a
+     * response schema requires it — wraps res.json with response validation.
+     */
+    route(method, path, opts, handler, allowBody) {
+        const methodUpper = String(method).toUpperCase();
         try {
             const validation = this.normalizeValidation(opts);
-            this.docs.push({ method: Doc.HttpMethods.DELETE, path: path }, validation);
-            this.schemas.set(`DELETE ${path}`, validation);
-            const resValidation = validation.res && !(validation.res instanceof Type.Any) && !(validation.res instanceof Type.Unknown) && ajv.compile(validation.res);
+            this.docs.push({ method, path }, validation);
+            this.schemas.set(`${methodUpper} ${path}`, validation);
+            const resValidation = this.compileResponseValidation(validation.res);
             const paramsValidation = validation.params && ajv.compile(validation.params);
             const queryValidation = validation.query && ajv.compile(validation.query);
-            if (validation.body)
+            let bodyValidation = null;
+            if (allowBody) {
+                bodyValidation = this.compileBodyValidators(validation.body);
+            }
+            else if (validation.body) {
                 throw new Error(`Body not allowed`);
+            }
             const _handler = (req, res, next) => {
                 if (req.query) { // Ref: https://github.com/cdimascio/express-openapi-validator/issues/969
                     Object.defineProperty(req, 'query', {
@@ -238,171 +275,51 @@ export default class Schemas {
                     errors.push({ type: 'Params', errors: paramsValidation.errors });
                 if (queryValidation && !queryValidation(req.query))
                     errors.push({ type: 'Query', errors: queryValidation.errors });
-                if (errors.length)
-                    return Err.respond(this.validationError(Doc.HttpMethods.DELETE, path), res, errors);
-                const json = res.json;
-                res.json = function (obj) {
-                    obj = JSON.parse(JSON.stringify(obj)); // Here as Date => String needs to happen
-                    if ((res.statusCode === null || res.statusCode === 200) && resValidation && !resValidation(obj)) {
-                        res.status(400);
-                        console.error(`Response Validation Error: ${JSON.stringify(obj)}`);
-                        return json.call(this, { type: 'Response', errors: resValidation.errors });
-                    }
-                    else {
-                        return json.call(this, obj);
-                    }
-                };
-                return handler(req, res, next);
-            };
-            this.router.delete(path, _handler);
-        }
-        catch (err) {
-            throw new Error(`Delete: ${path}: ` + String(err), { cause: err });
-        }
-    }
-    async post(path, opts = {}, handler) {
-        try {
-            const validation = this.normalizeValidation(opts);
-            this.docs.push({ method: Doc.HttpMethods.POST, path: path }, validation);
-            this.schemas.set(`POST ${path}`, validation);
-            const resValidation = validation.res && !(validation.res instanceof Type.Any) && !(validation.res instanceof Type.Unknown) && ajv.compile(validation.res);
-            const paramsValidation = validation.params && ajv.compile(validation.params);
-            const queryValidation = validation.query && ajv.compile(validation.query);
-            const bodyValidators = this.compileBodyValidators(validation.body);
-            const _handler = (req, res, next) => {
-                if (req.query) { // Ref: https://github.com/cdimascio/express-openapi-validator/issues/969
-                    Object.defineProperty(req, 'query', {
-                        writable: true,
-                        value: { ...req.query },
-                    });
-                }
-                const errors = [];
-                if (paramsValidation && !paramsValidation(req.params))
-                    errors.push({ type: 'Params', errors: paramsValidation.errors });
-                if (queryValidation && !queryValidation(req.query))
-                    errors.push({ type: 'Query', errors: queryValidation.errors });
-                if (bodyValidators) {
-                    const ctErr = this.validateBody(req, bodyValidators, errors, { required: validation.bodyRequired });
+                if (bodyValidation) {
+                    const ctErr = this.validateBody(req, bodyValidation, errors, { required: validation.bodyRequired });
                     if (ctErr)
                         return Err.respond(ctErr, res);
                 }
                 if (errors.length)
-                    return Err.respond(this.validationError(Doc.HttpMethods.POST, path), res, errors);
-                const json = res.json;
-                res.json = function (obj) {
-                    obj = JSON.parse(JSON.stringify(obj)); // Here as Date => String needs to happen
-                    if ((res.statusCode === null || res.statusCode === 200) && resValidation && !resValidation(obj)) {
-                        res.status(400);
-                        console.error(`Response Validation Error: ${JSON.stringify(obj)}`);
-                        return json.call(this, { type: 'Response', errors: resValidation.errors });
-                    }
-                    else {
+                    return Err.respond(this.validationError(method, path), res, errors);
+                if (resValidation) {
+                    const json = res.json;
+                    res.json = function (obj) {
+                        if (res.statusCode === null || res.statusCode === 200) {
+                            obj = jsonClone(obj); // Date => String needs to happen before validation
+                            if (!resValidation(obj)) {
+                                res.status(400);
+                                const logged = JSON.stringify(obj);
+                                console.error(`Response Validation Error: ${methodUpper} ${path}: ${logged && logged.length > MAX_LOGGED_RESPONSE ? logged.slice(0, MAX_LOGGED_RESPONSE) + '... (truncated)' : logged}`);
+                                return json.call(this, { type: 'Response', errors: resValidation.errors });
+                            }
+                        }
                         return json.call(this, obj);
-                    }
-                };
+                    };
+                }
                 return handler(req, res, next);
             };
-            this.router.post(path, _handler);
+            this.router[method](path, _handler);
         }
         catch (err) {
-            throw new Error(`Post: ${path}: ` + String(err), { cause: err });
+            const label = methodUpper.charAt(0) + methodUpper.slice(1).toLowerCase();
+            throw new Error(`${label}: ${path}: ` + String(err), { cause: err });
         }
     }
+    async get(path, opts = {}, handler) {
+        this.route(Doc.HttpMethods.GET, path, opts, handler, false);
+    }
+    async delete(path, opts = {}, handler) {
+        this.route(Doc.HttpMethods.DELETE, path, opts, handler, false);
+    }
+    async post(path, opts = {}, handler) {
+        this.route(Doc.HttpMethods.POST, path, opts, handler, true);
+    }
     async patch(path, opts = {}, handler) {
-        try {
-            const validation = this.normalizeValidation(opts);
-            this.docs.push({ method: Doc.HttpMethods.PATCH, path: path }, validation);
-            this.schemas.set(`PATCH ${path}`, validation);
-            const resValidation = validation.res && !(validation.res instanceof Type.Any) && !(validation.res instanceof Type.Unknown) && ajv.compile(validation.res);
-            const paramsValidation = validation.params && ajv.compile(validation.params);
-            const queryValidation = validation.query && ajv.compile(validation.query);
-            const bodyValidators = this.compileBodyValidators(validation.body);
-            const _handler = (req, res, next) => {
-                if (req.query) { // Ref: https://github.com/cdimascio/express-openapi-validator/issues/969
-                    Object.defineProperty(req, 'query', {
-                        writable: true,
-                        value: { ...req.query },
-                    });
-                }
-                const errors = [];
-                if (paramsValidation && !paramsValidation(req.params))
-                    errors.push({ type: 'Params', errors: paramsValidation.errors });
-                if (queryValidation && !queryValidation(req.query))
-                    errors.push({ type: 'Query', errors: queryValidation.errors });
-                if (bodyValidators) {
-                    const ctErr = this.validateBody(req, bodyValidators, errors, { required: validation.bodyRequired });
-                    if (ctErr)
-                        return Err.respond(ctErr, res);
-                }
-                if (errors.length)
-                    return Err.respond(this.validationError(Doc.HttpMethods.PATCH, path), res, errors);
-                const json = res.json;
-                res.json = function (obj) {
-                    obj = JSON.parse(JSON.stringify(obj)); // Here as Date => String needs to happen
-                    if ((res.statusCode === null || res.statusCode === 200) && resValidation && !resValidation(obj)) {
-                        res.status(400);
-                        console.error(`Response Validation Error: ${JSON.stringify(obj)}`);
-                        return json.call(this, { type: 'Response', errors: resValidation.errors });
-                    }
-                    else {
-                        return json.call(this, obj);
-                    }
-                };
-                return handler(req, res, next);
-            };
-            this.router.patch(path, _handler);
-        }
-        catch (err) {
-            throw new Error(`Patch: ${path}: ` + String(err), { cause: err });
-        }
+        this.route(Doc.HttpMethods.PATCH, path, opts, handler, true);
     }
     async put(path, opts = {}, handler) {
-        try {
-            const validation = this.normalizeValidation(opts);
-            this.docs.push({ method: Doc.HttpMethods.PUT, path: path }, validation);
-            this.schemas.set(`PUT ${path}`, validation);
-            const resValidation = validation.res && !(validation.res instanceof Type.Any) && !(validation.res instanceof Type.Unknown) && ajv.compile(validation.res);
-            const paramsValidation = validation.params && ajv.compile(validation.params);
-            const queryValidation = validation.query && ajv.compile(validation.query);
-            const bodyValidators = this.compileBodyValidators(validation.body);
-            const _handler = (req, res, next) => {
-                if (req.query) { // Ref: https://github.com/cdimascio/express-openapi-validator/issues/969
-                    Object.defineProperty(req, 'query', {
-                        writable: true,
-                        value: { ...req.query },
-                    });
-                }
-                const errors = [];
-                if (paramsValidation && !paramsValidation(req.params))
-                    errors.push({ type: 'Params', errors: paramsValidation.errors });
-                if (queryValidation && !queryValidation(req.query))
-                    errors.push({ type: 'Query', errors: queryValidation.errors });
-                if (bodyValidators) {
-                    const ctErr = this.validateBody(req, bodyValidators, errors, { required: validation.bodyRequired });
-                    if (ctErr)
-                        return Err.respond(ctErr, res);
-                }
-                if (errors.length)
-                    return Err.respond(this.validationError(Doc.HttpMethods.PUT, path), res, errors);
-                const json = res.json;
-                res.json = function (obj) {
-                    obj = JSON.parse(JSON.stringify(obj)); // Here as Date => String needs to happen
-                    if ((res.statusCode === null || res.statusCode === 200) && resValidation && !resValidation(obj)) {
-                        res.status(400);
-                        console.error(`Response Validation Error: ${JSON.stringify(obj)}`);
-                        return json.call(this, { type: 'Response', errors: resValidation.errors });
-                    }
-                    else {
-                        return json.call(this, obj);
-                    }
-                };
-                return handler(req, res, next);
-            };
-            this.router.put(path, _handler);
-        }
-        catch (err) {
-            throw new Error(`Put: ${path}: ` + String(err), { cause: err });
-        }
+        this.route(Doc.HttpMethods.PUT, path, opts, handler, true);
     }
     not_found() {
         this.router.all('*path', (req, res) => {