express-fast-json-stringify 1.2.8 → 1.3.0

package/CHANGELOG.md

@@ -1,7 +1,20 @@
 # Changelog
 
+## [1.3.0](https://github.com/nigrosimone/express-fast-json-stringify/compare/v1.2.9...v1.3.0) (2026-07-26)
+
+### Features
+
+* derive the schema from an OpenAPI or Swagger document ([5ce6622](https://github.com/nigrosimone/express-fast-json-stringify/commit/5ce6622fd216df1074e844c254bef0c7731205cd))
+* opt in override of res.json, so adoption needs no call site changes ([bcfda45](https://github.com/nigrosimone/express-fast-json-stringify/commit/bcfda4579ac8380f53c525b5cadcbc177e835b9c))
+
+### Bug Fixes
+
+* align res.fastJson with res.json HTTP semantics; add CI and vitest ([f2c8558](https://github.com/nigrosimone/express-fast-json-stringify/commit/f2c85584c105ce24c6c7327382b6b80022aade10))
+
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.2.9](https://github.com/nigrosimone/express-fast-json-stringify/compare/v1.2.8...v1.2.9) (2026-01-18)
+
 ### [1.2.8](https://github.com/nigrosimone/express-fast-json-stringify/compare/v1.2.6...v1.2.8) (2024-09-29)
 
 

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2019 Nigro Simone
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2019 Nigro Simone
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,113 +1,274 @@
-JSON serialization is a critical task in web development, particularly for applications built with Node.js and Express.js. While the native JSON serialization in Node.js (`JSON.stringify()`) is straightforward and convenient, it can become a performance bottleneck, especially under heavy load. This article introduces [express-fast-json-stringify](https://www.npmjs.com/package/express-fast-json-stringify), a custom middleware package that leverages [fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify) to significantly boost JSON serialization performance in Express applications.
-
-## What is fast-json-stringify?
-
-`fast-json-stringify` is a JSON serialization library developed by the Fastify team. It enhances JSON conversion speed by analyzing JSON schema definitions and compiling them into highly optimized serialization functions. This makes it much faster than the native `JSON.stringify()`, particularly beneficial for high-performance applications.
-
-## Introducing express-fast-json-stringify
-
-`express-fast-json-stringify` is an npm package that brings the performance benefits of `fast-json-stringify` to Express.js applications. By integrating this package, you can achieve faster JSON serialization, thus improving the overall performance of your application.
-
-## Installation
-
-First, install the `express-fast-json-stringify` package:
-
-```
-npm install express-fast-json-stringify
-```
-
-## Creating a JSON Schema
-
-Define a schema object that specifies the structure of your JSON responses. This schema will be used by `fast-json-stringify` to optimize the serialization process.
-
-```ts
-import { Schema } from 'express-fast-json-stringify';
-
-const schema: Schema = {
-  title: 'Example Schema',
-  type: 'object',
-  properties: {
-    firstName: { type: 'string' },
-    lastName: { type: 'string' },
-    age: {
-      description: 'Age in years',
-      type: 'integer',
-    },
-  },
-};
-```
-
-## Applying the Middleware
-
-Use the `fastJsonSchema` middleware in your Express routes, passing the schema object as an argument. This will set up the optimized JSON serialization for that route.
-
-```ts
-import express, { Request, Response, NextFunction } from 'express';
-import { fastJsonSchema, Schema } from 'express-fast-json-stringify';
-
-const app = express();
-
-const exampleSchema: Schema = {
-  title: 'Example Schema',
-  type: 'object',
-  properties: {
-    firstName: { type: 'string' },
-    lastName: { type: 'string' },
-    age: { type: 'integer' },
-  },
-};
-
-app.get(
-  '/',
-  fastJsonSchema(exampleSchema),
-  (req: Request, res: Response, next: NextFunction) => {},
-);
-```
-
-## Sending JSON Responses
-
-Instead of using the default `res.json()` method, use the `res.fastJson()` method provided by the middleware to send JSON responses. This leverages the speed benefits of fast-json-stringify.
-
-```ts
-import { fastJsonSchema, Schema } from 'express-fast-json-stringify';
-
-const schema: Schema = {
-  title: 'Example Schema',
-  type: 'object',
-  properties: {
-    firstName: { type: 'string' },
-    lastName: { type: 'string' },
-    age: {
-      description: 'Age in years',
-      type: 'integer',
-    },
-  },
-};
-
-app.get('/', fastJsonSchema(schema), (req, res, next) => {
-  try {
-    const data = {
-      firstName: 'Simone',
-      lastName: 'Nigro',
-      age: 40,
-    };
-    res.fastJson(data);
-  } catch (error) {
-    next(error);
-  }
-});
-```
-
-## Performance Benefits
-
-Using `express-fast-json-stringify` offers several performance benefits:
-
-1. **Increased Speed**: `fast-json-stringify` can serialize JSON data much faster than JSON.stringify(), especially for complex JSON objects.
-2. **Reduced CPU Usage**: Faster serialization means less CPU time spent on processing, allowing your server to handle more concurrent requests.
-3. **Consistency and Validation**: By defining JSON schemas, you ensure that the serialized data adheres to a predefined structure, improving data consistency and reducing the likelihood of errors.
-
-## Conclusion
-
-Integrating `express-fast-json-stringify` into your Express.js application can provide substantial performance improvements, especially in scenarios where JSON serialization is a bottleneck. By leveraging the power of `fast-json-stringify`, you can achieve faster response times and handle higher loads, making your application more efficient and scalable.
-
-To start using `express-fast-json-stringify`, follow the steps outlined in this article, and enjoy the benefits of faster JSON serialization in your Express applications. For a live demo, you can check out the [StackBlitz demo](https://stackblitz.com/edit/express-fast-json-stringify).
+JSON serialization is a critical task in web development, particularly for applications built with Node.js and Express.js. While the native JSON serialization in Node.js (`JSON.stringify()`) is straightforward and convenient, it can become a performance bottleneck, especially under heavy load. This documentation introduces [express-fast-json-stringify](https://www.npmjs.com/package/express-fast-json-stringify), a custom middleware package that leverages [fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify) to significantly boost JSON serialization performance in Express applications.
+
+## What is fast-json-stringify?
+
+`fast-json-stringify` is a JSON serialization library developed by the Fastify team. It analyzes JSON schema definitions and compiles them into serialization functions specialized for the exact shape of your payload, so it can skip everything the schema does not describe instead of walking the object generically like `JSON.stringify()` has to.
+
+## Introducing express-fast-json-stringify
+
+`express-fast-json-stringify` is an npm package that brings the performance benefits of `fast-json-stringify` to Express.js applications. By integrating this package, you can achieve faster JSON serialization, thus improving the overall performance of your application.
+
+## Installation
+
+First, install the `express-fast-json-stringify` package:
+
+```
+npm install express-fast-json-stringify
+```
+
+It requires Express 4.16 or newer (Express 5 included) and Node.js 20 or newer.
+
+## Creating a JSON Schema
+
+Define a schema object that specifies the structure of your JSON responses. This schema will be used by `fast-json-stringify` to optimize the serialization process.
+
+```ts
+import { Schema } from 'express-fast-json-stringify';
+
+const schema: Schema = {
+  title: 'Example Schema',
+  type: 'object',
+  properties: {
+    firstName: { type: 'string' },
+    lastName: { type: 'string' },
+    age: {
+      description: 'Age in years',
+      type: 'integer',
+    },
+  },
+};
+```
+
+## Applying the Middleware
+
+Use the `fastJsonSchema` middleware in your Express routes, passing the schema object as an argument. This will set up the optimized JSON serialization for that route.
+
+```ts
+import express from 'express';
+import { fastJsonSchema, Schema } from 'express-fast-json-stringify';
+
+const app = express();
+
+const exampleSchema: Schema = {
+  title: 'Example Schema',
+  type: 'object',
+  properties: {
+    firstName: { type: 'string' },
+    lastName: { type: 'string' },
+    age: { type: 'integer' },
+  },
+};
+
+app.get('/', fastJsonSchema(exampleSchema), (req, res, next) => {});
+```
+
+## Sending JSON Responses
+
+Instead of using the default `res.json()` method, use the `res.fastJson()` method provided by the middleware to send JSON responses. This leverages the speed benefits of fast-json-stringify.
+
+```ts
+import express from 'express';
+import { fastJsonSchema, Schema } from 'express-fast-json-stringify';
+
+const app = express();
+
+const schema: Schema = {
+  title: 'Example Schema',
+  type: 'object',
+  properties: {
+    firstName: { type: 'string' },
+    lastName: { type: 'string' },
+    age: {
+      description: 'Age in years',
+      type: 'integer',
+    },
+  },
+};
+
+app.get('/', fastJsonSchema(schema), (req, res, next) => {
+  try {
+    const data = {
+      firstName: 'Simone',
+      lastName: 'Nigro',
+      age: 40,
+    };
+    res.fastJson(data);
+  } catch (error) {
+    next(error);
+  }
+});
+```
+
+## Response semantics
+
+`res.fastJson()` is a drop-in replacement for `res.json()`: only the
+serialization changes, every HTTP detail stays the same.
+
+| Behavior             | What `res.fastJson()` does                                                                          |
+| -------------------- | --------------------------------------------------------------------------------------------------- |
+| `Content-Type`       | `application/json; charset=utf-8`, unless the route already set one with `res.type()`.              |
+| `Content-Length`     | Always set, from the byte length of the payload, so the response is never chunked.                  |
+| `ETag`               | Follows the app `etag` setting, exactly like `res.send()`. Set `app.set('etag', false)` to skip it. |
+| Conditional requests | A matching `If-None-Match` answers `304` with no body.                                              |
+| `204` and `304`      | No body and no `Content-Type`/`Content-Length`/`Transfer-Encoding`.                                 |
+| `HEAD`               | Headers only, `Content-Length` included.                                                            |
+
+The payload is serialized before the status code is inspected, so a body that
+does not match the schema still throws on a `204` — just like `res.json()`.
+
+## Taking the schema from your OpenAPI document
+
+If you already publish an OpenAPI (or Swagger) document, the response schemas
+are written there — no need to repeat them in the routes. `fastJsonOpenApi`
+takes that document and resolves the schema per route and per status code:
+
+```ts
+import express from 'express';
+import { fastJsonOpenApi } from 'express-fast-json-stringify';
+
+import document from './openapi.json' with { type: 'json' };
+
+const app = express();
+
+// One middleware for the whole app.
+app.use(fastJsonOpenApi(document));
+
+app.get('/users/:id', (req, res, next) => {
+  try {
+    // Serialized with the schema of `get /users/{id}` -> `200`.
+    res.fastJson(user);
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/users', (req, res, next) => {
+  try {
+    // ...and this one with the schema of `post /users` -> `201`.
+    res.status(201).fastJson(user);
+  } catch (error) {
+    next(error);
+  }
+});
+```
+
+The document is a plain object, so this works with whatever produces yours:
+
+| Tool                        | How to pass it                                                         |
+| --------------------------- | ---------------------------------------------------------------------- |
+| `swagger-jsdoc`             | `fastJsonOpenApi(swaggerJsdoc(options))`                               |
+| `swagger-ui-express`        | the same object you hand to `swaggerUi.setup(document)`                |
+| `express-openapi-validator` | the same document you pass as `apiSpec` (or the parsed YAML/JSON file) |
+| `tsoa`                      | the generated `swagger.json`                                           |
+| hand written                | `import document from './openapi.json' with { type: 'json' }`          |
+
+There is no dependency on any of them: the middleware only reads `paths`,
+`components.schemas` (OpenAPI 3.x) and `definitions` (Swagger 2.0).
+
+### What it resolves
+
+- **The operation** comes from the matched Express route, so `/users/:id`
+  under a router mounted at `/api` looks up `/api/users/{id}`. Parameter
+  modifiers (`:id?`, `:id(\d+)`) are ignored, as OpenAPI has no equivalent.
+  A `HEAD` request falls back to the `get` operation, the way Express does.
+- **The response** is matched most specific first: the exact status code, then
+  the wildcard range (`2XX`), then `default`. `res.status(404).fastJson(...)`
+  therefore serializes with the `404` schema.
+- **`$ref`** is resolved against the document, including recursive references,
+  so `#/components/schemas/User` and `#/definitions/User` both just work.
+- **OpenAPI 3.0 and 3.1** are both supported; `nullable: true` is honoured and
+  annotation keywords (`example`, `discriminator`, `xml`, ...) are ignored.
+
+Routes the document does not describe fall back to `res.json()`, so adding the
+middleware app-wide cannot break an undocumented endpoint. Pass
+`{ strict: true }` to get an error instead of a silent fallback.
+
+```ts
+// Read a different media type, pin an operation, forward fast-json-stringify options
+app.use(fastJsonOpenApi(document, { contentType: 'application/vnd.api+json' }));
+app.get('/v2/people/:id', fastJsonOpenApi(document, { path: '/users/{id}', method: 'get' }), handler);
+```
+
+Because the schema decides what gets written, a property that is not in the
+document can never reach a client — `npm run example:openapi` shows a
+`passwordHash` being dropped from an otherwise ordinary response object.
+
+### Adopting it without touching your routes
+
+Everything above needs you to call `res.fastJson()`. In an existing codebase
+that means editing every `res.json()` call site, which is a lot of churn for a
+serialization change. `overrideJson` removes that step:
+
+```ts
+app.use(fastJsonOpenApi(document, { overrideJson: true }));
+
+// Unchanged route. It is now serialized from the `get /users/{id}` -> `200`
+// schema, with no edit at the call site.
+app.get('/users/:id', (req, res) => res.json(user));
+```
+
+Only `res.json` is replaced. Express implements `res.send(object)` by calling
+`res.json(object)`, so both entry points are covered by the one hook, while
+`res.send` of a string or a Buffer is left alone.
+
+**The override cannot break a route.** It steps aside, and the stock
+`res.json()` runs, whenever:
+
+- the document describes no schema for that route and status code;
+- the app sets `json replacer`, `json spaces` or `json escape` — those change
+  the bytes `res.json()` writes and a compiled serializer cannot reproduce them;
+- the serializer rejects the body, for instance because a required property is
+  missing. Pass `onError` to be told when that happens:
+
+```ts
+app.use(
+  fastJsonOpenApi(document, {
+    overrideJson: true,
+    onError: (error, req) => logger.warn({ error, url: req.originalUrl }, 'schema mismatch'),
+  }),
+);
+```
+
+`strict` does not apply here: it governs explicit `res.fastJson()` calls, while
+an overridden `res.json()` always falls back rather than throw.
+
+`fastJsonSchema` accepts `overrideJson` too, with one difference: a single
+schema describes the _successful_ payload, so only `2xx` responses take the fast
+path. An error body would otherwise be rewritten into the shape of the success
+schema.
+
+```ts
+app.get('/users/:id', fastJsonSchema(userSchema, { overrideJson: true }), (req, res) => {
+  res.json(user); // serialized through the schema
+  res.status(500).json({ error: 'boom' }); // untouched, stock res.json()
+});
+```
+
+## Performance Benefits
+
+Using `express-fast-json-stringify` offers several benefits:
+
+1. **Increased Speed**: a compiled serializer only writes the properties the schema describes, so the more your objects carry that the response does not need, the more time it saves.
+2. **Reduced CPU Usage**: faster serialization means less CPU time spent on processing, allowing your server to handle more concurrent requests.
+3. **Consistency and Validation**: by defining JSON schemas, you ensure that the serialized data adheres to a predefined structure, improving data consistency and reducing the likelihood of errors — and properties missing from the schema never leak into a response.
+
+How much you gain depends on the payload, and on a current V8 it is not a win across the board. Measured on Node.js 26 by `npm run example`:
+
+| Case                                       | `fast-json-stringify` vs `JSON.stringify`   |
+| ------------------------------------------ | ------------------------------------------- |
+| objects carrying fields outside the schema | much faster (≈9x when 17 of 20 are dropped) |
+| a single small object                      | comparable                                  |
+| every field serialized                     | comparable                                  |
+| long strings                               | slower                                      |
+
+Run `npm run example` to get the numbers for your own Node.js version and payload shape before adopting it in a hot path.
+
+## Conclusion
+
+Integrating `express-fast-json-stringify` into your Express.js application can provide substantial performance improvements when JSON serialization is a bottleneck and your schemas let the serializer skip work. It also guarantees that responses carry exactly the properties the schema describes, which is worth having on its own.
+
+To start using `express-fast-json-stringify`, follow the steps outlined in this documentation, and enjoy the benefits of faster JSON serialization in your Express applications. For a runnable demo, see [example/](./example): `npm install && npm run example`.
+
+## Support
+
+This is an open-source project. Star this [repository](https://github.com/nigrosimone/express-fast-json-stringify), if you like it, or even [donate](https://www.paypal.com/paypalme/snwp). Thank you so much!

package/build/main/index.d.ts

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

package/build/main/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lib/middleware"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFpQyJ9
+__exportStar(require("./lib/openapi"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFpQztBQUNqQyxnREFBOEIifQ==

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

@@ -1,8 +1,26 @@
 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;
+};
 /**
- * Set the schema
+ * Build a stringify function using a schema of the documents that should be stringified
  * @param {Schema} schema The schema used to stringify values
  * @param {Options} options The options to use (optional)
  * @see https://www.npmjs.com/package/fast-json-stringify
@@ -10,7 +28,7 @@ export type { Schema, Options } from 'fast-json-stringify';
  * Examples:
  * ```ts
  * import express from 'express';
- * import { fastJsonSchemas, Schema } from 'express-fast-json-stringify';
+ * import { fastJsonSchema, Schema } from 'express-fast-json-stringify';
  *
  * const app = express();
  *
@@ -44,7 +62,7 @@ export type { Schema, Options } from 'fast-json-stringify';
  * });
  * ```
  */
-export declare const fastJsonSchema: (schema: Schema, options?: Options) => (_req: Request, res: Response, next: NextFunction) => void;
+export declare const fastJsonSchema: (schema: Schema, options?: FastJsonSchemaOptions) => (req: Request, res: Response, next: NextFunction) => void;
 declare global {
     namespace Express {
         interface Response {
@@ -53,11 +71,11 @@ declare global {
              *
              * Examples:
              * ```ts
-             * res.fastJson({ user: 'tj' });
-             * res.status(200).fastJson({ user: 'tj' });
+             * res.fastJson({ user: 'Simone Nigro' });
+             * res.status(200).fastJson({ user: 'Simone Nigro' });
              * ```
              */
-            fastJson: (data: any) => Response;
+            fastJson: (body: any) => Response;
         }
     }
 }

package/build/main/lib/middleware.js

@@ -1,12 +1,25 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fastJsonSchema = void 0;
 const fast_json_stringify_1 = __importDefault(require("fast-json-stringify"));
+const override_1 = require("./override");
+const send_1 = require("./send");
 /**
- * Set the schema
+ * Build a stringify function using a schema of the documents that should be stringified
  * @param {Schema} schema The schema used to stringify values
  * @param {Options} options The options to use (optional)
  * @see https://www.npmjs.com/package/fast-json-stringify
@@ -14,7 +27,7 @@ const fast_json_stringify_1 = __importDefault(require("fast-json-stringify"));
  * Examples:
  * ```ts
  * import express from 'express';
- * import { fastJsonSchemas, Schema } from 'express-fast-json-stringify';
+ * import { fastJsonSchema, Schema } from 'express-fast-json-stringify';
  *
  * const app = express();
  *
@@ -49,28 +62,30 @@ const fast_json_stringify_1 = __importDefault(require("fast-json-stringify"));
  * ```
  */
 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 = (0, fast_json_stringify_1.default)(schema, options);
-    return (_req, res, next) => {
+    const _a = options !== null && options !== void 0 ? options : {}, { overrideJson = false, onError } = _a, fastJsonOptions = __rest(_a, ["overrideJson", "onError"]);
+    const fjs = (0, fast_json_stringify_1.default)(schema, fastJsonOptions);
+    return (req, res, next) => {
         /**
          * Send JSON response.
          *
          * Examples:
          * ```ts
-         * res.fastJson({ user: 'tj' });
-         * res.status(200).fastJson({ user: 'tj' });
+         * res.fastJson({ user: 'Simone Nigro' });
+         * res.status(200).fastJson({ user: 'Simone Nigro' });
          * ```
          */
-        res.fastJson = (data) => {
-            if (!res.getHeader('Content-Type')) {
-                res.setHeader('Content-Type', 'application/json');
-            }
-            return res.send(fjs(data));
-        };
+        res.fastJson = (body) => (0, send_1.sendJson)(req, res, fjs(body));
+        if (overrideJson) {
+            // A single schema describes the successful payload, so applying it to an
+            // error body would rewrite it into the wrong shape. Only 2xx responses
+            // take the fast path; everything else keeps the stock res.json().
+            (0, override_1.overrideResJson)(req, res, (status) => (status >= 200 && status < 300 ? fjs : null), onError);
+        }
         next();
     };
 };
 exports.fastJsonSchema = fastJsonSchema;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFDQSw4RUFBMEU7QUFJMUU7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTBDRztBQUNJLE1BQU0sY0FBYyxHQUFHLENBQUMsTUFBYyxFQUFFLE9BQWlCLEVBQUUsRUFBRTtJQUNsRSxJQUFJLENBQUMsTUFBTSxFQUFFO1FBQ1gsTUFBTSxJQUFJLFNBQVMsQ0FBQyw2Q0FBNkMsQ0FBQyxDQUFDO0tBQ3BFO0lBQ0QsTUFBTSxHQUFHLEdBQUcsSUFBQSw2QkFBUSxFQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztJQUN0QyxPQUFPLENBQUMsSUFBYSxFQUFFLEdBQWEsRUFBRSxJQUFrQixFQUFFLEVBQUU7UUFDMUQ7Ozs7Ozs7O1dBUUc7UUFDSCxHQUFHLENBQUMsUUFBUSxHQUFHLENBQUMsSUFBUyxFQUFZLEVBQUU7WUFDckMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsY0FBYyxDQUFDLEVBQUU7Z0JBQ2xDLEdBQUcsQ0FBQyxTQUFTLENBQUMsY0FBYyxFQUFFLGtCQUFrQixDQUFDLENBQUM7YUFDbkQ7WUFDRCxPQUFPLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7UUFDN0IsQ0FBQyxDQUFDO1FBQ0YsSUFBSSxFQUFFLENBQUM7SUFDVCxDQUFDLENBQUM7QUFDSixDQUFDLENBQUM7QUF2QlcsUUFBQSxjQUFjLGtCQXVCekIifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUNBLDhFQUEwRTtBQUUxRSx5Q0FBd0U7QUFDeEUsaUNBQWtDO0FBc0JsQzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMENHO0FBQ0ksTUFBTSxjQUFjLEdBQUcsQ0FBQyxNQUFjLEVBQUUsT0FBK0IsRUFBRSxFQUFFO0lBQ2hGLElBQUksQ0FBQyxNQUFNLElBQUksQ0FBQyxPQUFPLE1BQU0sS0FBSyxRQUFRLElBQUksT0FBTyxNQUFNLEtBQUssU0FBUyxDQUFDLEVBQUUsQ0FBQztRQUMzRSxNQUFNLElBQUksU0FBUyxDQUFDLDZDQUE2QyxDQUFDLENBQUM7SUFDckUsQ0FBQztJQUNELE1BQU0sS0FBd0QsT0FBTyxhQUFQLE9BQU8sY0FBUCxPQUFPLEdBQUksRUFBRSxFQUFyRSxFQUFFLFlBQVksR0FBRyxLQUFLLEVBQUUsT0FBTyxPQUFzQyxFQUFqQyxlQUFlLGNBQW5ELDJCQUFxRCxDQUFnQixDQUFDO0lBQzVFLE1BQU0sR0FBRyxHQUFHLElBQUEsNkJBQVEsRUFBQyxNQUFNLEVBQUUsZUFBZSxDQUFDLENBQUM7SUFDOUMsT0FBTyxDQUFDLEdBQVksRUFBRSxHQUFhLEVBQUUsSUFBa0IsRUFBRSxFQUFFO1FBQ3pEOzs7Ozs7OztXQVFHO1FBQ0gsR0FBRyxDQUFDLFFBQVEsR0FBRyxDQUFDLElBQVMsRUFBWSxFQUFFLENBQUMsSUFBQSxlQUFRLEVBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUV0RSxJQUFJLFlBQVksRUFBRSxDQUFDO1lBQ2pCLHlFQUF5RTtZQUN6RSx1RUFBdUU7WUFDdkUsa0VBQWtFO1lBQ2xFLElBQUEsMEJBQWUsRUFBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxDQUFDLE1BQU0sSUFBSSxHQUFHLElBQUksTUFBTSxHQUFHLEdBQUcsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUMvRixDQUFDO1FBRUQsSUFBSSxFQUFFLENBQUM7SUFDVCxDQUFDLENBQUM7QUFDSixDQUFDLENBQUM7QUEzQlcsUUFBQSxjQUFjLGtCQTJCekIifQ==