express-fast-json-stringify 1.3.0 → 2.0.0

package/build/main/lib/openapi.d.ts

@@ -1,6 +1,5 @@
-import type { NextFunction, Request, Response } from 'express';
-import { type Options } from 'fast-json-stringify';
-import { type OverrideErrorHandler } from './override';
+import { type Options, type Schema } from 'fast-json-stringify';
+import { type Application, type FastJsonOptions } from './install';
 /**
  * The parts of an OpenAPI 3.x or Swagger 2.0 document this package reads.
  *
@@ -16,35 +15,9 @@ export type OpenApiDocument = {
     readonly components?: Readonly<Record<string, unknown>>;
     readonly definitions?: Readonly<Record<string, unknown>>;
 };
-export type OpenApiOptions = Omit<Options, 'mode'> & {
+export type OpenApiOptions = Omit<Options, 'mode'> & FastJsonOptions & {
     /** Media type to read the schema from. Defaults to `application/json`. */
     readonly contentType?: string;
-    /** Pin the OpenAPI path instead of deriving it from the matched route. */
-    readonly path?: string;
-    /** Pin the OpenAPI method instead of using the request method. */
-    readonly method?: string;
-    /**
-     * Throw when the document describes no schema for a response, instead of
-     * quietly falling back to `res.json()`. Only applies to explicit
-     * `res.fastJson()` calls — an overridden `res.json()` always falls back.
-     */
-    readonly strict?: boolean;
-    /**
-     * Also route `res.json()` — and therefore `res.send(object)`, which Express
-     * implements on top of it — through the compiled serializer whenever the
-     * document describes the response.
-     *
-     * Off by default. Turning it on lets an existing codebase benefit without
-     * rewriting a single call site: responses the document covers are serialized
-     * from the schema, everything else keeps the stock behavior.
-     */
-    readonly overrideJson?: boolean;
-    /**
-     * Called when an overridden `res.json()` could not use the fast path because
-     * the serializer threw. The response falls back to the stock `res.json()`
-     * either way; this is only so the mismatch is visible.
-     */
-    readonly onError?: OverrideErrorHandler;
 };
 /**
  * Translate an Express route pattern into the OpenAPI equivalent:
@@ -53,14 +26,35 @@ export type OpenApiOptions = Omit<Options, 'mode'> & {
  */
 export declare const toOpenApiPath: (path: string) => string;
 /**
- * Build a stringify middleware that takes its schemas from an OpenAPI or Swagger
- * document, so the contract you already publish is the one used to serialize.
+ * The schema the document declares for one operation and status, with the
+ * shared schemas attached so `$ref` resolves, ready for `fastJsonSchema`. For
+ * a route whose Express path does not match the document.
  *
- * The operation is resolved per request from the matched Express route, and the
- * schema from the response status code, which means `res.status(201).fastJson()`
+ * @param {OpenApiDocument} document The OpenAPI 3.x or Swagger 2.0 document
+ * @param {string} path The OpenAPI path, `/users/{id}`
+ * @param {string} method The operation, `get`
+ * @param {number} status The response status, `200` when omitted
+ * @param {string} contentType The media type, `application/json` when omitted
+ * @returns {Schema | undefined} undefined when the document describes no such response
+ *
+ * Examples:
+ * ```ts
+ * app.get('/v2/people/:id', fastJsonSchema(openApiSchema(document, '/users/{id}', 'get')!), handler);
+ * ```
+ */
+export declare const openApiSchema: (document: OpenApiDocument, path: string, method: string, status?: number, contentType?: string) => Schema | undefined;
+/**
+ * Serialize every documented response of an application from its OpenAPI or
+ * Swagger document, so the contract you already publish is the one used to
+ * serialize. Once per app, at setup: it calls `installFastJson(app)` itself, and no
+ * middleware runs per request.
+ *
+ * The operation is resolved from the matched Express route, and the schema
+ * from the response status code, which means `res.status(201).fastJson()`
  * serializes with the `201` schema. Routes the document does not describe fall
  * back to `res.json()` unless `strict` is set.
  *
+ * @param {Application} app The application
  * @param {OpenApiDocument} document The OpenAPI 3.x or Swagger 2.0 document
  * @param {OpenApiOptions} options The options to use (optional)
  *
@@ -73,7 +67,7 @@ export declare const toOpenApiPath: (path: string) => string;
  * const app = express();
  * const document = swaggerJsdoc({ definition: { openapi: '3.1.0', info: { title: 'API', version: '1.0.0' } }, apis: ['./routes/*.ts'] });
  *
- * app.use(fastJsonOpenApi(document));
+ * fastJsonOpenApi(app, document);
  *
  * app.get('/users/:id', (req, res, next) => {
  *   try {
@@ -84,4 +78,4 @@ export declare const toOpenApiPath: (path: string) => string;
  * });
  * ```
  */
-export declare const fastJsonOpenApi: (document: OpenApiDocument, options?: OpenApiOptions) => (req: Request, res: Response, next: NextFunction) => void;
+export declare const fastJsonOpenApi: (app: Application, document: OpenApiDocument, options?: OpenApiOptions) => void;

package/build/main/lib/openapi.js

@@ -14,10 +14,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fastJsonOpenApi = exports.toOpenApiPath = void 0;
+exports.fastJsonOpenApi = exports.openApiSchema = exports.toOpenApiPath = void 0;
 const fast_json_stringify_1 = __importDefault(require("fast-json-stringify"));
-const override_1 = require("./override");
-const send_1 = require("./send");
+const install_1 = require("./install");
 /**
  * Translate an Express route pattern into the OpenAPI equivalent:
  * `/users/:id` becomes `/users/{id}`. Express parameter modifiers — a trailing
@@ -81,15 +80,46 @@ const withSharedSchemas = (document, schema) => {
     }
     return result;
 };
+const validateDocument = (document) => {
+    if (!document || typeof document !== 'object' || typeof document.paths !== 'object' || document.paths === null) {
+        throw new TypeError(`express-fast-json-stringify: invalid OpenAPI document`);
+    }
+};
 /**
- * Build a stringify middleware that takes its schemas from an OpenAPI or Swagger
- * document, so the contract you already publish is the one used to serialize.
+ * The schema the document declares for one operation and status, with the
+ * shared schemas attached so `$ref` resolves, ready for `fastJsonSchema`. For
+ * a route whose Express path does not match the document.
+ *
+ * @param {OpenApiDocument} document The OpenAPI 3.x or Swagger 2.0 document
+ * @param {string} path The OpenAPI path, `/users/{id}`
+ * @param {string} method The operation, `get`
+ * @param {number} status The response status, `200` when omitted
+ * @param {string} contentType The media type, `application/json` when omitted
+ * @returns {Schema | undefined} undefined when the document describes no such response
  *
- * The operation is resolved per request from the matched Express route, and the
- * schema from the response status code, which means `res.status(201).fastJson()`
+ * Examples:
+ * ```ts
+ * app.get('/v2/people/:id', fastJsonSchema(openApiSchema(document, '/users/{id}', 'get')!), handler);
+ * ```
+ */
+const openApiSchema = (document, path, method, status = 200, contentType = 'application/json') => {
+    validateDocument(document);
+    const schema = findResponseSchema(document, path, method.toLowerCase(), status, contentType);
+    return schema ? withSharedSchemas(document, schema) : undefined;
+};
+exports.openApiSchema = openApiSchema;
+/**
+ * Serialize every documented response of an application from its OpenAPI or
+ * Swagger document, so the contract you already publish is the one used to
+ * serialize. Once per app, at setup: it calls `installFastJson(app)` itself, and no
+ * middleware runs per request.
+ *
+ * The operation is resolved from the matched Express route, and the schema
+ * from the response status code, which means `res.status(201).fastJson()`
  * serializes with the `201` schema. Routes the document does not describe fall
  * back to `res.json()` unless `strict` is set.
  *
+ * @param {Application} app The application
  * @param {OpenApiDocument} document The OpenAPI 3.x or Swagger 2.0 document
  * @param {OpenApiOptions} options The options to use (optional)
  *
@@ -102,7 +132,7 @@ const withSharedSchemas = (document, schema) => {
  * const app = express();
  * const document = swaggerJsdoc({ definition: { openapi: '3.1.0', info: { title: 'API', version: '1.0.0' } }, apis: ['./routes/*.ts'] });
  *
- * app.use(fastJsonOpenApi(document));
+ * fastJsonOpenApi(app, document);
  *
  * app.get('/users/:id', (req, res, next) => {
  *   try {
@@ -113,54 +143,53 @@ const withSharedSchemas = (document, schema) => {
  * });
  * ```
  */
-const fastJsonOpenApi = (document, options = {}) => {
-    if (!document || typeof document !== 'object' || typeof document.paths !== 'object' || document.paths === null) {
-        throw new TypeError(`express-fast-json-stringify: invalid OpenAPI document`);
-    }
-    const { contentType = 'application/json', path: pinnedPath, method: pinnedMethod, strict = false, overrideJson = false, onError } = options, fastJsonOptions = __rest(options, ["contentType", "path", "method", "strict", "overrideJson", "onError"]);
-    // One compiled serializer per operation and status code. Misses are cached as
-    // `null` so an undocumented route costs a single lookup.
-    const serializers = new Map();
-    const routePath = (req) => { var _a, _b; return pinnedPath !== null && pinnedPath !== void 0 ? pinnedPath : (0, exports.toOpenApiPath)(`${req.baseUrl}${(_b = (_a = req.route) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : req.path}`); };
-    const serializerFor = (req, status) => {
-        const path = routePath(req);
-        const method = (pinnedMethod !== null && pinnedMethod !== void 0 ? pinnedMethod : req.method).toLowerCase();
-        const key = `${method} ${path} ${status}`;
-        const cached = serializers.get(key);
-        if (cached !== undefined) {
-            return cached;
-        }
+const fastJsonOpenApi = (app, document, options = {}) => {
+    validateDocument(document);
+    const { contentType = 'application/json', overrideJson, onError, strict } = options, fastJsonOptions = __rest(options, ["contentType", "overrideJson", "onError", "strict"]);
+    (0, install_1.installFastJson)(app, { overrideJson, onError, strict });
+    const compile = (path, method, status) => {
         const schema = findResponseSchema(document, path, method, status, contentType);
-        const serializer = schema ? (0, fast_json_stringify_1.default)(withSharedSchemas(document, schema), fastJsonOptions) : null;
-        serializers.set(key, serializer);
-        return serializer;
+        return schema ? (0, fast_json_stringify_1.default)(withSharedSchemas(document, schema), fastJsonOptions) : null;
     };
-    return (req, res, next) => {
-        /**
-         * Send JSON response, serialized with the schema the document declares for
-         * this route and status code.
-         *
-         * Examples:
-         * ```ts
-         * res.fastJson({ user: 'Simone Nigro' });
-         * res.status(201).fastJson({ user: 'Simone Nigro' });
-         * ```
-         */
-        res.fastJson = (body) => {
-            const serializer = serializerFor(req, res.statusCode);
-            if (!serializer) {
-                if (strict) {
-                    throw new Error(`express-fast-json-stringify: no ${contentType} schema for ${req.method} ${routePath(req)} with status ${res.statusCode}`);
-                }
-                return res.json(body);
+    // One compiled serializer per route, mount and status, found from the route object the
+    // framework already matched: no path is rebuilt per request. Misses are cached as `null`.
+    // A router mounted twice answers under two mounts, so the mount is a key of its own.
+    const byRoute = new WeakMap();
+    // Answered from plain middleware, before any route matched: the request path is what names
+    // the operation, and a string key is all there is.
+    const byPath = new Map();
+    (0, install_1.setResolver)(app, (res) => {
+        const req = res.req;
+        const status = res.statusCode;
+        const method = req.method.toLowerCase();
+        const route = req.route;
+        if (route === undefined) {
+            const key = `${method} ${req.baseUrl}${req.path} ${status}`;
+            let serialize = byPath.get(key);
+            if (serialize === undefined) {
+                serialize = compile((0, exports.toOpenApiPath)(`${req.baseUrl}${req.path}`), method, status);
+                byPath.set(key, serialize);
             }
-            return (0, send_1.sendJson)(req, res, serializer(body));
-        };
-        if (overrideJson) {
-            (0, override_1.overrideResJson)(req, res, (status) => serializerFor(req, status), onError);
+            return serialize;
         }
-        next();
-    };
+        let byMount = byRoute.get(route);
+        if (byMount === undefined) {
+            byMount = new Map();
+            byRoute.set(route, byMount);
+        }
+        const baseUrl = req.baseUrl;
+        let byStatus = byMount.get(baseUrl);
+        if (byStatus === undefined) {
+            byStatus = new Map();
+            byMount.set(baseUrl, byStatus);
+        }
+        let serialize = byStatus.get(status);
+        if (serialize === undefined) {
+            serialize = compile((0, exports.toOpenApiPath)(`${baseUrl}${route.path}`), method, status);
+            byStatus.set(status, serialize);
+        }
+        return serialize;
+    });
 };
 exports.fastJsonOpenApi = fastJsonOpenApi;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/send.d.ts

@@ -1,10 +1,9 @@
-import type { Request, Response } from 'express';
+import type { Response } from 'express';
 /**
- * Write an already serialized JSON payload with the same HTTP semantics as
- * `res.json()`: charset, `Content-Length`, `ETag`, conditional requests and the
- * empty body rules for `204`/`304`.
- *
- * Every middleware in this package goes through here, so they cannot drift
- * apart from each other or from Express.
+ * Write an already serialized JSON payload the way `res.json()` does once the
+ * body is a string: the type when the route set none, then `res.send()`, which
+ * owns `Content-Length`, the `ETag`, conditional requests, `204`/`304` and
+ * `HEAD` in Express and in the frameworks that stand in for it. Nothing is
+ * reimplemented here, so nothing can drift.
  */
-export declare const sendJson: (req: Request, res: Response, serialized: string) => Response;
+export declare const sendSerialized: (res: Response, json: string) => Response;

package/build/main/lib/send.js

@@ -1,46 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendJson = void 0;
+exports.sendSerialized = void 0;
 /**
- * Write an already serialized JSON payload with the same HTTP semantics as
- * `res.json()`: charset, `Content-Length`, `ETag`, conditional requests and the
- * empty body rules for `204`/`304`.
- *
- * Every middleware in this package goes through here, so they cannot drift
- * apart from each other or from Express.
+ * Write an already serialized JSON payload the way `res.json()` does once the
+ * body is a string: the type when the route set none, then `res.send()`, which
+ * owns `Content-Length`, the `ETag`, conditional requests, `204`/`304` and
+ * `HEAD` in Express and in the frameworks that stand in for it. Nothing is
+ * reimplemented here, so nothing can drift.
  */
-const sendJson = (req, res, serialized) => {
-    var _a;
-    let payload = serialized;
-    // Do not clobber a content type the route set on purpose (eg. res.type('application/vnd.api+json')).
-    if (!res.getHeader('Content-Type')) {
-        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+const sendSerialized = (res, json) => {
+    if (!res.get('Content-Type')) {
+        res.set('Content-Type', 'application/json; charset=utf-8');
     }
-    // Mirror res.send(): honour the app `etag` setting so that swapping
-    // res.json() for res.fastJson() keeps conditional requests working.
-    const etagFn = (_a = res.app) === null || _a === void 0 ? void 0 : _a.get('etag fn');
-    if (typeof etagFn === 'function' && !res.getHeader('ETag')) {
-        const etag = etagFn(payload, 'utf-8');
-        if (etag) {
-            res.setHeader('ETag', etag);
-        }
-    }
-    if (req.fresh) {
-        res.statusCode = 304;
-    }
-    // 204 No Content and 304 Not Modified must not carry a body, nor describe one.
-    if (res.statusCode === 204 || res.statusCode === 304) {
-        res.removeHeader('Content-Type');
-        res.removeHeader('Content-Length');
-        res.removeHeader('Transfer-Encoding');
-        payload = '';
-    }
-    else {
-        // Without this the response falls back to chunked encoding, and HEAD
-        // requests answer with no length at all.
-        res.setHeader('Content-Length', Buffer.byteLength(payload));
-    }
-    return res.end(payload);
+    return res.send(json);
 };
-exports.sendJson = sendJson;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvc2VuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQTs7Ozs7OztHQU9HO0FBQ0ksTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFZLEVBQUUsR0FBYSxFQUFFLFVBQWtCLEVBQVksRUFBRTs7SUFDcEYsSUFBSSxPQUFPLEdBQUcsVUFBVSxDQUFDO0lBRXpCLHFHQUFxRztJQUNyRyxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxjQUFjLENBQUMsRUFBRSxDQUFDO1FBQ25DLEdBQUcsQ0FBQyxTQUFTLENBQUMsY0FBYyxFQUFFLGlDQUFpQyxDQUFDLENBQUM7SUFDbkUsQ0FBQztJQUVELG9FQUFvRTtJQUNwRSxvRUFBb0U7SUFDcEUsTUFBTSxNQUFNLEdBQUcsTUFBQSxHQUFHLENBQUMsR0FBRywwQ0FBRSxHQUFHLENBQUMsU0FBUyxDQUE0RSxDQUFDO0lBQ2xILElBQUksT0FBTyxNQUFNLEtBQUssVUFBVSxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1FBQzNELE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDdEMsSUFBSSxJQUFJLEVBQUUsQ0FBQztZQUNULEdBQUcsQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQzlCLENBQUM7SUFDSCxDQUFDO0lBRUQsSUFBSSxHQUFHLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDZCxHQUFHLENBQUMsVUFBVSxHQUFHLEdBQUcsQ0FBQztJQUN2QixDQUFDO0lBRUQsK0VBQStFO0lBQy9FLElBQUksR0FBRyxDQUFDLFVBQVUsS0FBSyxHQUFHLElBQUksR0FBRyxDQUFDLFVBQVUsS0FBSyxHQUFHLEVBQUUsQ0FBQztRQUNyRCxHQUFHLENBQUMsWUFBWSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQ2pDLEdBQUcsQ0FBQyxZQUFZLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUNuQyxHQUFHLENBQUMsWUFBWSxDQUFDLG1CQUFtQixDQUFDLENBQUM7UUFDdEMsT0FBTyxHQUFHLEVBQUUsQ0FBQztJQUNmLENBQUM7U0FBTSxDQUFDO1FBQ04scUVBQXFFO1FBQ3JFLHlDQUF5QztRQUN6QyxHQUFHLENBQUMsU0FBUyxDQUFDLGdCQUFnQixFQUFFLE1BQU0sQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRUQsT0FBTyxHQUFHLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0FBQzFCLENBQUMsQ0FBQztBQW5DVyxRQUFBLFFBQVEsWUFtQ25CIn0=
+exports.sendSerialized = sendSerialized;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvc2VuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQTs7Ozs7O0dBTUc7QUFDSSxNQUFNLGNBQWMsR0FBRyxDQUFDLEdBQWEsRUFBRSxJQUFZLEVBQVksRUFBRTtJQUN0RSxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxjQUFjLENBQUMsRUFBRSxDQUFDO1FBQzdCLEdBQUcsQ0FBQyxHQUFHLENBQUMsY0FBYyxFQUFFLGlDQUFpQyxDQUFDLENBQUM7SUFDN0QsQ0FBQztJQUNELE9BQU8sR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUN4QixDQUFDLENBQUM7QUFMVyxRQUFBLGNBQWMsa0JBS3pCIn0=

package/build/module/index.d.ts

@@ -1,3 +1,3 @@
+export { type Application, installFastJson, type FastJsonOptions, type OverrideErrorHandler } from './lib/install';
 export * from './lib/middleware';
 export * from './lib/openapi';
-export type { OverrideErrorHandler } from './lib/override';

package/build/module/index.js

@@ -1,3 +1,4 @@
+export { installFastJson } from './lib/install';
 export * from './lib/middleware';
 export * from './lib/openapi';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGVBQWUsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFvQixlQUFlLEVBQW1ELE1BQU0sZUFBZSxDQUFDO0FBQ25ILGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxlQUFlLENBQUMifQ==

package/build/module/lib/install.d.ts

@@ -0,0 +1,77 @@
+import type { Express, Request, Response } from 'express';
+/** What the install needs of an application: the prototype its responses share. Fulmine has one too. */
+export type Application = Pick<Express, 'response'>;
+/** A compiled serializer, as fast-json-stringify builds it. */
+export type Serializer = (body: any) => string;
+/** Finds the serializer for a response from something other than the route, an OpenAPI document. */
+export type SerializerResolver = (res: Response) => Serializer | null;
+/** Notified when an overridden `res.json()` could not use the fast path. */
+export type OverrideErrorHandler = (error: unknown, req: Request) => void;
+export type FastJsonOptions = {
+    /**
+     * Also route `res.json()`, and `res.send(object)` which Express implements on
+     * top of it, through the serializer in force.
+     *
+     * Off by default. A route's own schema describes the successful payload, so
+     * under it only `2xx` responses take the fast path: an error body would
+     * otherwise be rewritten into the wrong shape.
+     */
+    readonly overrideJson?: boolean;
+    /**
+     * Called when an overridden `res.json()` could not use the fast path because
+     * the serializer threw. The response falls back to the stock `res.json()`
+     * either way; this is only so the mismatch is visible.
+     */
+    readonly onError?: OverrideErrorHandler;
+    /**
+     * Make `res.fastJson()` throw when no schema is known for the response,
+     * instead of quietly falling back to `res.json()`. An overridden `res.json()`
+     * always falls back.
+     */
+    readonly strict?: boolean;
+};
+/** Where `fastJsonSchema` leaves the serializer of the route, on `res.locals`. */
+export declare const kSerializer: unique symbol;
+/**
+ * Give an application `res.fastJson()`, and with `overrideJson` a `res.json()`
+ * that serializes through the schema in force. Once per app, at setup: the
+ * methods go on `app.response`, so a request pays nothing to have them.
+ *
+ * `fastJsonSchema` chooses the schema per route, `fastJsonOpenApi` per
+ * operation from a document and calls this itself.
+ *
+ * @param {Application} app The application to extend
+ * @param {FastJsonOptions} options The options to use (optional)
+ *
+ * Examples:
+ * ```ts
+ * import express from 'express';
+ * import { installFastJson, fastJsonSchema } from 'express-fast-json-stringify';
+ *
+ * const app = express();
+ * installFastJson(app);
+ *
+ * app.get('/', fastJsonSchema(schema), (req, res) => {
+ *   res.fastJson({ firstName: 'Simone', lastName: 'Nigro', age: 40 });
+ * });
+ * ```
+ */
+export declare const installFastJson: (app: Application, options?: FastJsonOptions) => void;
+/** Registers where the document based serializers come from, see fastJsonOpenApi. */
+export declare const setResolver: (app: Application, resolver: SerializerResolver) => void;
+declare global {
+    namespace Express {
+        interface Response {
+            /**
+             * Send JSON response, serialized with the schema in force for the route.
+             *
+             * Examples:
+             * ```ts
+             * res.fastJson({ user: 'Simone Nigro' });
+             * res.status(200).fastJson({ user: 'Simone Nigro' });
+             * ```
+             */
+            fastJson: (body: any) => Response;
+        }
+    }
+}

package/build/module/lib/install.js

@@ -0,0 +1,92 @@
+import { sendSerialized } from './send';
+/** Where `fastJsonSchema` leaves the serializer of the route, on `res.locals`. */
+export const kSerializer = Symbol('express-fast-json-stringify');
+// one state per response prototype, which is one per app
+const states = new WeakMap();
+const routeOf = (req) => `${req.baseUrl}${req.route?.path ?? req.path}`;
+// the route's own serializer first, then what the document says
+const pick = (state, res, successOnly) => {
+    const own = res.locals[kSerializer];
+    if (own !== undefined && (!successOnly || (res.statusCode >= 200 && res.statusCode < 300))) {
+        return own;
+    }
+    return state.resolver === null ? null : state.resolver(res);
+};
+const fastJsonMethod = (state) => function installFastJson(body) {
+    const serialize = pick(state, this, false);
+    if (serialize === null) {
+        if (state.strict) {
+            throw new Error(`express-fast-json-stringify: no schema for ${this.req.method} ${routeOf(this.req)}`);
+        }
+        return state.stockJson.call(this, body);
+    }
+    return sendSerialized(this, serialize(body));
+};
+// The stock res.json() runs whenever the fast path does not apply: a setting that changes the
+// bytes (json replacer, spaces, escape), no schema for this response, or a body the schema refuses
+const jsonMethod = (state) => function json(body) {
+    const app = this.app;
+    if (!app.get('json replacer') && !app.get('json spaces') && !app.get('json escape')) {
+        const serialize = pick(state, this, true);
+        if (serialize !== null) {
+            let out;
+            try {
+                out = serialize(body);
+            }
+            catch (error) {
+                state.onError?.(error, this.req);
+            }
+            if (out !== undefined) {
+                return sendSerialized(this, out);
+            }
+        }
+    }
+    return state.stockJson.call(this, body);
+};
+/**
+ * Give an application `res.fastJson()`, and with `overrideJson` a `res.json()`
+ * that serializes through the schema in force. Once per app, at setup: the
+ * methods go on `app.response`, so a request pays nothing to have them.
+ *
+ * `fastJsonSchema` chooses the schema per route, `fastJsonOpenApi` per
+ * operation from a document and calls this itself.
+ *
+ * @param {Application} app The application to extend
+ * @param {FastJsonOptions} options The options to use (optional)
+ *
+ * Examples:
+ * ```ts
+ * import express from 'express';
+ * import { installFastJson, fastJsonSchema } from 'express-fast-json-stringify';
+ *
+ * const app = express();
+ * installFastJson(app);
+ *
+ * app.get('/', fastJsonSchema(schema), (req, res) => {
+ *   res.fastJson({ firstName: 'Simone', lastName: 'Nigro', age: 40 });
+ * });
+ * ```
+ */
+export const installFastJson = (app, options = {}) => {
+    const proto = app?.response;
+    if (!proto || typeof proto.json !== 'function') {
+        throw new TypeError('express-fast-json-stringify: an Express application is required');
+    }
+    let state = states.get(proto);
+    if (state === undefined) {
+        state = { stockJson: proto.json, resolver: null, overrideJson: false, onError: undefined, strict: false };
+        states.set(proto, state);
+        proto.fastJson = fastJsonMethod(state);
+    }
+    state.overrideJson = options.overrideJson === true;
+    state.onError = options.onError;
+    state.strict = options.strict === true;
+    // the stock method is put back when the override is off, so nothing runs on res.json() that
+    // was not there before, and a framework reading the prototype sees the method it knows
+    proto.json = state.overrideJson ? jsonMethod(state) : state.stockJson;
+};
+/** Registers where the document based serializers come from, see fastJsonOpenApi. */
+export const setResolver = (app, resolver) => {
+    states.get(app.response).resolver = resolver;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/middleware.d.ts

@@ -1,36 +1,22 @@
 import type { NextFunction, Request, Response } from 'express';
 import { type Options, type Schema } from 'fast-json-stringify';
-import { type OverrideErrorHandler } from './override';
 export type { Schema, Options } from 'fast-json-stringify';
-export type FastJsonSchemaOptions = Omit<Options, 'mode'> & {
-    /**
-     * Also route `res.json()` — and therefore `res.send(object)`, which Express
-     * implements on top of it — through the compiled serializer.
-     *
-     * Off by default. Because a single schema describes the successful payload,
-     * only `2xx` responses take the fast path: an error body would otherwise be
-     * rewritten into the shape of the success schema.
-     */
-    readonly overrideJson?: boolean;
-    /**
-     * Called when an overridden `res.json()` could not use the fast path because
-     * the serializer threw. The response falls back to the stock `res.json()`
-     * either way; this is only so the mismatch is visible.
-     */
-    readonly onError?: OverrideErrorHandler;
-};
+export type FastJsonSchemaOptions = Omit<Options, 'mode'>;
 /**
- * Build a stringify function using a schema of the documents that should be stringified
+ * Build a middleware that gives its route a serializer compiled from the schema.
+ * The application needs `installFastJson(app)` once for `res.fastJson()` to exist.
+ *
  * @param {Schema} schema The schema used to stringify values
- * @param {Options} options The options to use (optional)
+ * @param {FastJsonSchemaOptions} options The fast-json-stringify options (optional)
  * @see https://www.npmjs.com/package/fast-json-stringify
  *
  * Examples:
  * ```ts
  * import express from 'express';
- * import { fastJsonSchema, Schema } from 'express-fast-json-stringify';
+ * import { installFastJson, fastJsonSchema, Schema } from 'express-fast-json-stringify';
  *
  * const app = express();
+ * installFastJson(app);
  *
  * const schema: Schema = {
  *   title: 'Example Schema',
@@ -62,20 +48,4 @@ export type FastJsonSchemaOptions = Omit<Options, 'mode'> & {
  * });
  * ```
  */
-export declare const fastJsonSchema: (schema: Schema, options?: FastJsonSchemaOptions) => (req: Request, res: Response, next: NextFunction) => void;
-declare global {
-    namespace Express {
-        interface Response {
-            /**
-             * Send JSON response.
-             *
-             * Examples:
-             * ```ts
-             * res.fastJson({ user: 'Simone Nigro' });
-             * res.status(200).fastJson({ user: 'Simone Nigro' });
-             * ```
-             */
-            fastJson: (body: any) => Response;
-        }
-    }
-}
+export declare const fastJsonSchema: (schema: Schema, options?: FastJsonSchemaOptions) => (_req: Request, res: Response, next: NextFunction) => void;