express-fast-json-stringify 1.2.9 → 2.0.0

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,18 +1,22 @@
 import type { NextFunction, Request, Response } from 'express';
 import { type Options, type Schema } from 'fast-json-stringify';
 export type { Schema, Options } from 'fast-json-stringify';
+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',
@@ -44,20 +48,4 @@ export type { Schema, Options } from 'fast-json-stringify';
  * });
  * ```
  */
-export declare const fastJsonSchema: (schema: Schema, options?: Omit<Options, "mode">) => (_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;

package/build/module/lib/middleware.js

@@ -1,16 +1,20 @@
-import fastJson from 'fast-json-stringify';
+import fastJsonStringify from 'fast-json-stringify';
+import { kSerializer } from './install';
 /**
- * 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',
@@ -43,25 +47,15 @@ import fastJson from 'fast-json-stringify';
  * ```
  */
 export const fastJsonSchema = (schema, options) => {
-    if (!schema) {
+    if (!schema || (typeof schema !== 'object' && typeof schema !== 'boolean')) {
         throw new TypeError(`express-fast-json-stringify: invalid schema`);
     }
-    const fjs = fastJson(schema, options);
+    const serialize = fastJsonStringify(schema, options);
+    // One write on res.locals and a next(), nothing else on req or res: a framework that reads a
+    // middleware's source to skip work, fulmine does, must be able to see this touches no header
     return (_req, res, next) => {
-        /**
-         * Send JSON response.
-         *
-         * Examples:
-         * ```ts
-         * res.fastJson({ user: 'Simone Nigro' });
-         * res.status(200).fastJson({ user: 'Simone Nigro' });
-         * ```
-         */
-        res.fastJson = (body) => {
-            res.setHeader('Content-Type', 'application/json');
-            return res.end(fjs(body));
-        };
+        res.locals[kSerializer] = serialize;
         next();
     };
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLFFBQXVDLE1BQU0scUJBQXFCLENBQUM7QUFJMUU7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTBDRztBQUNILE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFDLE1BQWMsRUFBRSxPQUErQixFQUFFLEVBQUU7SUFDaEYsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osTUFBTSxJQUFJLFNBQVMsQ0FBQyw2Q0FBNkMsQ0FBQyxDQUFDO0lBQ3JFLENBQUM7SUFDRCxNQUFNLEdBQUcsR0FBRyxRQUFRLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3RDLE9BQU8sQ0FBQyxJQUFhLEVBQUUsR0FBYSxFQUFFLElBQWtCLEVBQUUsRUFBRTtRQUMxRDs7Ozs7Ozs7V0FRRztRQUNILEdBQUcsQ0FBQyxRQUFRLEdBQUcsQ0FBQyxJQUFTLEVBQVksRUFBRTtZQUNyQyxHQUFHLENBQUMsU0FBUyxDQUFDLGNBQWMsRUFBRSxrQkFBa0IsQ0FBQyxDQUFDO1lBQ2xELE9BQU8sR0FBRyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUM1QixDQUFDLENBQUM7UUFDRixJQUFJLEVBQUUsQ0FBQztJQUNULENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLGlCQUFnRCxNQUFNLHFCQUFxQixDQUFDO0FBRW5GLE9BQU8sRUFBRSxXQUFXLEVBQW1CLE1BQU0sV0FBVyxDQUFDO0FBTXpEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0E2Q0c7QUFDSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FBQyxNQUFjLEVBQUUsT0FBK0IsRUFBRSxFQUFFO0lBQ2hGLElBQUksQ0FBQyxNQUFNLElBQUksQ0FBQyxPQUFPLE1BQU0sS0FBSyxRQUFRLElBQUksT0FBTyxNQUFNLEtBQUssU0FBUyxDQUFDLEVBQUUsQ0FBQztRQUMzRSxNQUFNLElBQUksU0FBUyxDQUFDLDZDQUE2QyxDQUFDLENBQUM7SUFDckUsQ0FBQztJQUNELE1BQU0sU0FBUyxHQUFlLGlCQUFpQixDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNqRSw2RkFBNkY7SUFDN0YsNkZBQTZGO0lBQzdGLE9BQU8sQ0FBQyxJQUFhLEVBQUUsR0FBYSxFQUFFLElBQWtCLEVBQVEsRUFBRTtRQUMvRCxHQUFHLENBQUMsTUFBaUQsQ0FBQyxXQUFXLENBQUMsR0FBRyxTQUFTLENBQUM7UUFDaEYsSUFBSSxFQUFFLENBQUM7SUFDVCxDQUFDLENBQUM7QUFDSixDQUFDLENBQUMifQ==

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

@@ -0,0 +1,81 @@
+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.
+ *
+ * It is deliberately a plain document rather than an integration with a
+ * specific library: every popular Express toolchain either consumes or produces
+ * one of these, so `swagger-jsdoc`, `swagger-ui-express`, `tsoa`,
+ * `express-openapi-validator` and a hand written file all work unchanged.
+ */
+export type OpenApiDocument = {
+    readonly openapi?: string;
+    readonly swagger?: string;
+    readonly paths?: Readonly<Record<string, unknown>>;
+    readonly components?: Readonly<Record<string, unknown>>;
+    readonly definitions?: Readonly<Record<string, unknown>>;
+};
+export type OpenApiOptions = Omit<Options, 'mode'> & FastJsonOptions & {
+    /** Media type to read the schema from. Defaults to `application/json`. */
+    readonly contentType?: string;
+};
+/**
+ * Translate an Express route pattern into the OpenAPI equivalent:
+ * `/users/:id` becomes `/users/{id}`. Express parameter modifiers — a trailing
+ * `?` or an inline `(regex)` — are dropped, since OpenAPI has no notion of them.
+ */
+export declare const toOpenApiPath: (path: string) => string;
+/**
+ * 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
+ *
+ * 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)
+ *
+ * Examples:
+ * ```ts
+ * import express from 'express';
+ * import swaggerJsdoc from 'swagger-jsdoc';
+ * import { fastJsonOpenApi } from 'express-fast-json-stringify';
+ *
+ * const app = express();
+ * const document = swaggerJsdoc({ definition: { openapi: '3.1.0', info: { title: 'API', version: '1.0.0' } }, apis: ['./routes/*.ts'] });
+ *
+ * fastJsonOpenApi(app, document);
+ *
+ * app.get('/users/:id', (req, res, next) => {
+ *   try {
+ *     res.fastJson({ id: Number(req.params.id), firstName: 'Simone' });
+ *   } catch (error) {
+ *     next(error);
+ *   }
+ * });
+ * ```
+ */
+export declare const fastJsonOpenApi: (app: Application, document: OpenApiDocument, options?: OpenApiOptions) => void;

package/build/module/lib/openapi.js

@@ -0,0 +1,174 @@
+import fastJsonStringify from 'fast-json-stringify';
+import { installFastJson, setResolver } from './install';
+/**
+ * Translate an Express route pattern into the OpenAPI equivalent:
+ * `/users/:id` becomes `/users/{id}`. Express parameter modifiers — a trailing
+ * `?` or an inline `(regex)` — are dropped, since OpenAPI has no notion of them.
+ */
+export const toOpenApiPath = (path) => path.replace(/:([A-Za-z0-9_]+)(\([^)]*\))?\??/g, '{$1}');
+/**
+ * Express answers a HEAD request with the GET handler, and documents rarely
+ * describe a `head` operation, so fall back to `get`.
+ */
+const methodCandidates = (method) => (method === 'head' ? ['head', 'get'] : [method]);
+/**
+ * Response keys to try, most specific first. OpenAPI allows a wildcard range
+ * (`2XX`) and a catch all (`default`) next to explicit codes.
+ */
+const statusCandidates = (status) => {
+    const range = Math.floor(status / 100);
+    return [String(status), `${range}XX`, `${range}xx`, 'default'];
+};
+const findResponseSchema = (document, path, method, status, contentType) => {
+    const operations = document.paths?.[path];
+    if (!operations) {
+        return undefined;
+    }
+    for (const candidate of methodCandidates(method)) {
+        const operation = operations[candidate];
+        const responses = operation?.responses;
+        if (!responses) {
+            continue;
+        }
+        for (const key of statusCandidates(status)) {
+            const response = responses[key];
+            if (!response) {
+                continue;
+            }
+            // OpenAPI 3.x keys the schema by media type; Swagger 2.0 does not.
+            const schema = response.content?.[contentType]?.schema ?? response.schema;
+            if (schema) {
+                return schema;
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * fast-json-stringify resolves `$ref` as a JSON pointer against the root of the
+ * schema it is given, so the document's shared schemas only have to be reachable
+ * under the key the references already use — `components` for OpenAPI 3.x,
+ * `definitions` for Swagger 2.0. No rewriting needed, and recursive references
+ * keep working.
+ */
+const withSharedSchemas = (document, schema) => {
+    const result = { ...schema };
+    if (document.components && result.components === undefined) {
+        result.components = document.components;
+    }
+    if (document.definitions && result.definitions === undefined) {
+        result.definitions = document.definitions;
+    }
+    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`);
+    }
+};
+/**
+ * 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
+ *
+ * Examples:
+ * ```ts
+ * app.get('/v2/people/:id', fastJsonSchema(openApiSchema(document, '/users/{id}', 'get')!), handler);
+ * ```
+ */
+export 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;
+};
+/**
+ * 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)
+ *
+ * Examples:
+ * ```ts
+ * import express from 'express';
+ * import swaggerJsdoc from 'swagger-jsdoc';
+ * import { fastJsonOpenApi } from 'express-fast-json-stringify';
+ *
+ * const app = express();
+ * const document = swaggerJsdoc({ definition: { openapi: '3.1.0', info: { title: 'API', version: '1.0.0' } }, apis: ['./routes/*.ts'] });
+ *
+ * fastJsonOpenApi(app, document);
+ *
+ * app.get('/users/:id', (req, res, next) => {
+ *   try {
+ *     res.fastJson({ id: Number(req.params.id), firstName: 'Simone' });
+ *   } catch (error) {
+ *     next(error);
+ *   }
+ * });
+ * ```
+ */
+export const fastJsonOpenApi = (app, document, options = {}) => {
+    validateDocument(document);
+    const { contentType = 'application/json', overrideJson, onError, strict, ...fastJsonOptions } = options;
+    installFastJson(app, { overrideJson, onError, strict });
+    const compile = (path, method, status) => {
+        const schema = findResponseSchema(document, path, method, status, contentType);
+        return schema ? fastJsonStringify(withSharedSchemas(document, schema), fastJsonOptions) : null;
+    };
+    // 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();
+    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(toOpenApiPath(`${req.baseUrl}${req.path}`), method, status);
+                byPath.set(key, serialize);
+            }
+            return serialize;
+        }
+        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(toOpenApiPath(`${baseUrl}${route.path}`), method, status);
+            byStatus.set(status, serialize);
+        }
+        return serialize;
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,9 @@
+import type { Response } 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 sendSerialized: (res: Response, json: string) => Response;

package/build/module/lib/send.js

@@ -0,0 +1,14 @@
+/**
+ * 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 const sendSerialized = (res, json) => {
+    if (!res.get('Content-Type')) {
+        res.set('Content-Type', 'application/json; charset=utf-8');
+    }
+    return res.send(json);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvc2VuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FBQyxHQUFhLEVBQUUsSUFBWSxFQUFZLEVBQUU7SUFDdEUsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsY0FBYyxDQUFDLEVBQUUsQ0FBQztRQUM3QixHQUFHLENBQUMsR0FBRyxDQUFDLGNBQWMsRUFBRSxpQ0FBaUMsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFDRCxPQUFPLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7QUFDeEIsQ0FBQyxDQUFDIn0=