@bram-dc/fastify-type-provider-zod 3.1.1 → 4.0.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 turkerdev
-
-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) 2022-2024 turkerdev
+
+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,145 +1,280 @@
-# Fastify Type Provider Zod
-
-[![NPM Version](https://img.shields.io/npm/v/@bram-dc/fastify-type-provider-zod.svg)](https://www.npmjs.com/package/@bram-dc/fastify-type-provider-zod)
-[![NPM Downloads](https://img.shields.io/npm/dm/@bram-dc/fastify-type-provider-zod.svg)](https://www.npmjs.com/package/@bram-dc/fastify-type-provider-zod)
-[![Build Status](https://github.com//bram-dc/fastify-type-provider-zod/workflows/CI/badge.svg)](https://github.com/bram-dc/fastify-type-provider-zod/actions)
-
-## How to use?
-
-```js
-import Fastify from "fastify";
-import { ZodSerializerCompiler, ZodValidatorCompiler, ZodTypeProvider } from "@bram-dc/fastify-type-provider-zod";
-import z from "zod";
-
-const app = Fastify()
-
-// Add schema validator and serializer
-app.setValidatorCompiler(ZodValidatorCompiler);
-app.setSerializerCompiler(ZodSerializerCompiler);
-
-app.withTypeProvider<ZodTypeProvider>().route({
-  method: "GET",
-  url: "/",
-  // Define your schema
-  schema: {
-    querystring: z.object({
-      name: z.string().min(4),
-    }),
-    response: {
-      200: z.string(),
-    },
-  },
-  handler: (req, res) => {
-    res.send(req.query.name);
-  },
-});
-
-app.listen({ port: 4949 });
-```
-
-## How to use together with @fastify/swagger
-
-```ts
-import fastify from "fastify";
-import fastifySwagger from "@fastify/swagger";
-import fastifySwaggerUI from "@fastify/swagger-ui";
-import { z } from "zod";
-
-import {
-  jsonSchemaTransform,
-  createJsonSchemaTransform,
-  ZodSerializerCompiler,
-  ZodValidatorCompiler,
-  ZodTypeProvider,
-} from "@bram-dc/fastify-type-provider-zod";
-
-const app = fastify();
-app.setValidatorCompiler(ZodValidatorCompiler);
-app.setSerializerCompiler(ZodSerializerCompiler);
-
-app.register(fastifySwagger, {
-  openapi: {
-    info: {
-      title: "SampleApi",
-      description: "Sample backend service",
-      version: "1.0.0",
-    },
-    servers: [],
-  },
-  transform: jsonSchemaTransform,
-  // You can also create transform with custom skiplist of endpoints that should not be included in the specification:
-  //
-  // transform: createJsonSchemaTransform({
-  //   skipList: [ "/documentation/static/*" ]
-  // })
-  
-  // In order to create refs to the schemas, you need to provide the schemas to the transformObject using createJsonSchemaTransformObject
-  //
-  // transformObject: createJsonSchemaTransformObject({
-  //    schemas: {
-  //      User: z.object({
-  //        id: z.string(),
-  //        name: z.string(),
-  //      }),
-  //    }
-  // }),
-});
-
-app.register(fastifySwaggerUI, {
-  routePrefix: "/documentation",
-});
-
-const LOGIN_SCHEMA = z.object({
-  username: z.string().max(32).describe("Some description for username"),
-  password: z.string().max(32),
-});
-
-app.after(() => {
-  app.withTypeProvider<ZodTypeProvider>().route({
-    method: "POST",
-    url: "/login",
-    schema: { body: LOGIN_SCHEMA },
-    handler: (req, res) => {
-      res.send("ok");
-    },
-  });
-});
-
-async function run() {
-  await app.ready();
-
-  await app.listen({
-    port: 4949,
-  });
-
-  console.log(`Documentation running at http://localhost:4949/documentation`);
-}
-
-run();
-```
-
-## How to create a plugin?
-
-```ts
-import { z } from "zod";
-import { FastifyPluginAsyncZod } from "@bram-dc/fastify-type-provider-zod";
-
-const plugin: FastifyPluginAsyncZod = async function (fastify, _opts) {
-  fastify.route({
-    method: "GET",
-    url: "/",
-    // Define your schema
-    schema: {
-      querystring: z.object({
-        name: z.string().min(4),
-      }),
-      response: {
-        200: z.string(),
-      },
-    },
-    handler: (req, res) => {
-      res.send(req.query.name);
-    },
-  });
-};
-```
+# Fastify Type Provider Zod
+
+[![NPM Version](https://img.shields.io/npm/v/fastify-type-provider-zod.svg)](https://npmjs.org/package/fastify-type-provider-zod)
+[![NPM Downloads](https://img.shields.io/npm/dm/fastify-type-provider-zod.svg)](https://npmjs.org/package/fastify-type-provider-zod)
+[![Build Status](https://github.com//turkerdev/fastify-type-provider-zod/workflows/CI/badge.svg)](https://github.com//turkerdev/fastify-type-provider-zod/actions)
+
+## How to use?
+
+```js
+import Fastify from "fastify";
+import { serializerCompiler, validatorCompiler, ZodTypeProvider } from "fastify-type-provider-zod";
+import z from "zod";
+
+const app = Fastify()
+
+// Add schema validator and serializer
+app.setValidatorCompiler(validatorCompiler);
+app.setSerializerCompiler(serializerCompiler);
+
+app.withTypeProvider<ZodTypeProvider>().route({
+  method: "GET",
+  url: "/",
+  // Define your schema
+  schema: {
+    querystring: z.object({
+      name: z.string().min(4),
+    }),
+    response: {
+      200: z.string(),
+    },
+  },
+  handler: (req, res) => {
+    res.send(req.query.name);
+  },
+});
+
+app.listen({ port: 4949 });
+```
+
+You can also pass options to the `serializerCompiler` function:
+
+```ts
+type ZodSerializerCompilerOptions = {
+  replacer?: ReplacerFunction;
+};
+```
+
+```js
+import Fastify from 'fastify';
+import { createSerializerCompiler, validatorCompiler } from 'fastify-type-provider-zod';
+import z from 'zod';
+
+const app = Fastify();
+
+const replacer = function (key, value) {
+  if (this[key] instanceof Date) {
+    return { _date: value.toISOString() };
+  }
+  return value;
+};
+
+// Create a custom serializer compiler
+const customSerializerCompiler = createSerializerCompiler({ replacer });
+
+// Add schema validator and serializer
+app.setValidatorCompiler(validatorCompiler);
+app.setSerializerCompiler(customSerializerCompiler);
+
+// ...
+
+app.listen({ port: 4949 });
+```
+
+## How to use together with @fastify/swagger
+
+```ts
+import fastify from 'fastify';
+import fastifySwagger from '@fastify/swagger';
+import fastifySwaggerUI from '@fastify/swagger-ui';
+import { z } from 'zod';
+
+import {
+  jsonSchemaTransform,
+  createJsonSchemaTransform,
+  serializerCompiler,
+  validatorCompiler,
+  ZodTypeProvider,
+} from 'fastify-type-provider-zod';
+
+const app = fastify();
+app.setValidatorCompiler(validatorCompiler);
+app.setSerializerCompiler(serializerCompiler);
+
+app.register(fastifySwagger, {
+  openapi: {
+    info: {
+      title: 'SampleApi',
+      description: 'Sample backend service',
+      version: '1.0.0',
+    },
+    servers: [],
+  },
+  transform: jsonSchemaTransform,
+
+  // You can also create transform with custom skiplist of endpoints that should not be included in the specification:
+  //
+  // transform: createJsonSchemaTransform({
+  //   skipList: [ '/documentation/static/*' ]
+  // })
+});
+
+app.register(fastifySwaggerUI, {
+  routePrefix: '/documentation',
+});
+
+const LOGIN_SCHEMA = z.object({
+  username: z.string().max(32).describe('Some description for username'),
+  password: z.string().max(32),
+});
+
+app.after(() => {
+  app.withTypeProvider<ZodTypeProvider>().route({
+    method: 'POST',
+    url: '/login',
+    schema: { body: LOGIN_SCHEMA },
+    handler: (req, res) => {
+      res.send('ok');
+    },
+  });
+});
+
+async function run() {
+  await app.ready();
+
+  await app.listen({
+    port: 4949,
+  });
+
+  console.log(`Documentation running at http://localhost:4949/documentation`);
+}
+
+run();
+```
+
+## Customizing error responses
+
+You can add custom handling of request and response validation errors to your fastify error handler like this:
+
+```ts
+import { hasZodFastifySchemaValidationErrors } from 'fastify-type-provider-zod'
+
+fastifyApp.setErrorHandler((err, req, reply) => {
+    if (hasZodFastifySchemaValidationErrors(err)) {
+        return reply.code(400).send({
+            error: 'Response Validation Error',
+            message: "Request doesn't match the schema",
+            statusCode: 400,
+            details: {
+                issues: err.validation,
+                method: req.method,
+                url: req.url,
+            },
+        })
+    }
+
+    if (isResponseSerializationError(err)) {
+        return reply.code(500).send({
+            error: 'Internal Server Error',
+            message: "Response doesn't match the schema",
+            statusCode: 500,
+            details: {
+                issues: err.cause.issues,
+                method: err.method,
+                url: err.url,
+            },
+        })
+    }
+    
+    // the rest of the error handler
+})
+```
+
+## How to create refs to the schemas?
+
+When provided, this package will automatically create refs using the `jsonSchemaTransformObject` function. You register the schemas to the global zod registry and give it an `id` and fastifySwagger will create a OpenAPI document in which the schemas are referenced. The following example creates a ref to the `User` schema and will include the `User` schema in the OpenAPI document.
+
+```ts
+import fastifySwagger from '@fastify/swagger';
+import fastifySwaggerUI from '@fastify/swagger-ui';
+import fastify from 'fastify';
+import { z } from 'zod';
+import type { ZodTypeProvider } from 'fastify-type-provider-zod';
+import {
+  jsonSchemaTransformObject,
+  jsonSchemaTransform,
+  serializerCompiler,
+  validatorCompiler,
+} from 'fastify-type-provider-zod';
+
+const USER_SCHEMA = z.object({
+  id: z.number().int().positive(),
+  name: z.string().describe('The name of the user'),
+});
+
+z.globalRegistry.add(USER_SCHEMA, { id: 'User' })
+
+const app = fastify();
+app.setValidatorCompiler(validatorCompiler);
+app.setSerializerCompiler(serializerCompiler);
+
+app.register(fastifySwagger, {
+  openapi: {
+    info: {
+      title: 'SampleApi',
+      description: 'Sample backend service',
+      version: '1.0.0',
+    },
+    servers: [],
+  },
+  transform: jsonSchemaTransform,
+  transformObject: jsonSchemaTransformObject,
+});
+
+app.register(fastifySwaggerUI, {
+  routePrefix: '/documentation',
+});
+
+app.after(() => {
+  app.withTypeProvider<ZodTypeProvider>().route({
+    method: 'GET',
+    url: '/users',
+    schema: {
+      response: {
+        200: USER_SCHEMA.array(),
+      },
+    },
+    handler: (req, res) => {
+      res.send([]);
+    },
+  });
+});
+
+async function run() {
+  await app.ready();
+
+  await app.listen({
+    port: 4949,
+  });
+
+  console.log(`Documentation running at http://localhost:4949/documentation`);
+}
+
+run();
+```
+
+## How to create a plugin?
+
+```ts
+import { z } from 'zod';
+import { FastifyPluginAsyncZod } from 'fastify-type-provider-zod';
+
+const plugin: FastifyPluginAsyncZod = async function (fastify, _opts) {
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    // Define your schema
+    schema: {
+      querystring: z.object({
+        name: z.string().min(4),
+      }),
+      response: {
+        200: z.string(),
+      },
+    },
+    handler: (req, res) => {
+      res.send(req.query.name);
+    },
+  });
+};
+```

package/dist/index.d.ts

@@ -1,86 +1,2 @@
-import type { FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, FastifySchema, FastifySchemaCompiler, FastifyTypeProvider, RawServerBase, RawServerDefault } from "fastify";
-import type { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
-import type { FastifySerializerCompiler } from "fastify/types/schema";
-import type { z } from "zod";
-type FreeformRecord = Record<string, any>;
-export declare const ResponseValidationError: import("@fastify/error").FastifyErrorConstructor<{
-    code: string;
-}, [{
-    cause: Error;
-}]>;
-export declare const InvalidSchemaError: import("@fastify/error").FastifyErrorConstructor<{
-    code: string;
-}, [string]>;
-export interface ZodTypeProvider extends FastifyTypeProvider {
-    validator: this["schema"] extends z.ZodTypeAny ? z.output<this["schema"]> : unknown;
-    serializer: this["schema"] extends z.ZodTypeAny ? z.input<this["schema"]> : unknown;
-}
-interface Schema extends FastifySchema {
-    hide?: boolean;
-}
-export declare const createJsonSchemaTransform: ({ skipList }: {
-    skipList: readonly string[];
-}) => ({ schema, url }: {
-    schema: Schema;
-    url: string;
-}) => {
-    schema: Schema;
-    url: string;
-} | {
-    schema: FreeformRecord;
-    url: string;
-};
-export declare const jsonSchemaTransform: ({ schema, url }: {
-    schema: Schema;
-    url: string;
-}) => {
-    schema: Schema;
-    url: string;
-} | {
-    schema: FreeformRecord;
-    url: string;
-};
-export declare const ZodValidatorCompiler: FastifySchemaCompiler<z.ZodAny>;
-type ReplacerFunction = (this: any, key: string, value: any) => any;
-type ZodSerializerCompilerOptions = {
-    replacer?: ReplacerFunction;
-};
-export declare const createZodSerializerCompiler: (options: ZodSerializerCompilerOptions) => FastifySerializerCompiler<z.ZodAny | {
-    properties: z.ZodAny;
-}>;
-export declare const ZodSerializerCompiler: FastifySerializerCompiler<z.ZodAny | {
-    properties: z.ZodAny;
-}>;
-export declare const createJsonSchemaTransformObject: ({ schemas: zodSchemas }: {
-    schemas: Record<string, z.ZodTypeAny>;
-}) => (input: {
-    swaggerObject: Partial<OpenAPIV2.Document>;
-} | {
-    openapiObject: Partial<OpenAPIV3.Document | OpenAPIV3_1.Document>;
-}) => any;
-/**
- * FastifyPluginCallbackZod with Zod automatic type inference
- *
- * @example
- * ```typescript
- * import { FastifyPluginCallbackZod } from "fastify-type-provider-zod"
- *
- * const plugin: FastifyPluginCallbackZod = (fastify, options, done) => {
- *   done()
- * }
- * ```
- */
-export type FastifyPluginCallbackZod<Options extends FastifyPluginOptions = Record<never, never>, Server extends RawServerBase = RawServerDefault> = FastifyPluginCallback<Options, Server, ZodTypeProvider>;
-/**
- * FastifyPluginAsyncZod with Zod automatic type inference
- *
- * @example
- * ```typescript
- * import { FastifyPluginAsyncZod } from "fastify-type-provider-zod"
- *
- * const plugin: FastifyPluginAsyncZod = async (fastify, options) => {
- * }
- * ```
- */
-export type FastifyPluginAsyncZod<Options extends FastifyPluginOptions = Record<never, never>, Server extends RawServerBase = RawServerDefault> = FastifyPluginAsync<Options, Server, ZodTypeProvider>;
-export {};
+export { type ZodTypeProvider, type FastifyPluginAsyncZod, type FastifyPluginCallbackZod, type ZodSerializerCompilerOptions, jsonSchemaTransform, createJsonSchemaTransform, jsonSchemaTransformObject, serializerCompiler, validatorCompiler, createSerializerCompiler, } from './src/core';
+export { type ZodFastifySchemaValidationError, ResponseSerializationError, InvalidSchemaError, hasZodFastifySchemaValidationErrors, isResponseSerializationError, } from './src/errors';

package/dist/index.js

@@ -1,161 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createJsonSchemaTransformObject = exports.ZodSerializerCompiler = exports.createZodSerializerCompiler = exports.ZodValidatorCompiler = exports.jsonSchemaTransform = exports.createJsonSchemaTransform = exports.InvalidSchemaError = exports.ResponseValidationError = void 0;
-const error_1 = __importDefault(require("@fastify/error"));
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const defaultSkipList = [
-    "/documentation/",
-    "/documentation/initOAuth",
-    "/documentation/json",
-    "/documentation/uiConfig",
-    "/documentation/yaml",
-    "/documentation/*",
-    "/documentation/static/*",
-];
-exports.ResponseValidationError = (0, error_1.default)("FST_ERR_RESPONSE_VALIDATION", "Response doesn't match the schema", 500);
-exports.InvalidSchemaError = (0, error_1.default)("FST_ERR_INVALID_SCHEMA", "Invalid schema passed: %s", 500);
-const zodToJsonSchemaOptions = {
-    target: "openApi3",
-    $refStrategy: "none",
-};
-const createJsonSchemaTransform = ({ skipList }) => {
-    return ({ schema, url }) => {
-        if (!schema) {
-            return {
-                schema,
-                url,
-            };
-        }
-        const { response, headers, querystring, body, params, hide, ...rest } = schema;
-        const transformed = {};
-        if (skipList.includes(url) || hide) {
-            transformed.hide = true;
-            return { schema: transformed, url };
-        }
-        const zodSchemas = { headers, querystring, body, params };
-        for (const prop in zodSchemas) {
-            const zodSchema = zodSchemas[prop];
-            if (zodSchema) {
-                transformed[prop] = (0, zod_to_json_schema_1.zodToJsonSchema)(zodSchema, zodToJsonSchemaOptions);
-            }
-        }
-        if (response) {
-            transformed.response = {};
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            for (const prop in response) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const schema = resolveSchema(response[prop]);
-                const transformedResponse = (0, zod_to_json_schema_1.zodToJsonSchema)(
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                schema, zodToJsonSchemaOptions);
-                transformed.response[prop] = transformedResponse;
-            }
-        }
-        for (const prop in rest) {
-            const meta = rest[prop];
-            if (meta) {
-                transformed[prop] = meta;
-            }
-        }
-        return { schema: transformed, url };
-    };
-};
-exports.createJsonSchemaTransform = createJsonSchemaTransform;
-exports.jsonSchemaTransform = (0, exports.createJsonSchemaTransform)({
-    skipList: defaultSkipList,
-});
-const ZodValidatorCompiler = ({ schema }) => (data) => {
-    const result = schema.safeParse(data);
-    if (result.success) {
-        return { value: result.data };
-    }
-    else {
-        return {
-            error: result.error.errors.map(error => ({
-                keyword: error.code,
-                instancePath: `/${error.path.join("/")}`,
-                schemaPath: `#/${error.path.join("/")}/${error.code}`,
-                params: {
-                    code: error.code,
-                    zodError: result.error,
-                },
-                message: error.message,
-            })),
-        };
-    }
-};
-exports.ZodValidatorCompiler = ZodValidatorCompiler;
-const resolveSchema = (maybeSchema) => {
-    if ("safeParse" in maybeSchema) {
-        return maybeSchema;
-    }
-    if ("properties" in maybeSchema) {
-        return maybeSchema.properties;
-    }
-    throw new exports.InvalidSchemaError(JSON.stringify(maybeSchema));
-};
-const createZodSerializerCompiler = (options) => ({ schema: maybeSchema }) => (data) => {
-    const schema = resolveSchema(maybeSchema);
-    const result = schema.safeParse(data);
-    if (result.success) {
-        return JSON.stringify(result.data, options.replacer);
-    }
-    throw new exports.ResponseValidationError({ cause: result.error });
-};
-exports.createZodSerializerCompiler = createZodSerializerCompiler;
-exports.ZodSerializerCompiler = (0, exports.createZodSerializerCompiler)({});
-const createJsonSchemaTransformObject = ({ schemas: zodSchemas }) => (input) => {
-    if ("swaggerObject" in input) {
-        console.warn("This package currently does not support component references for Swagger 2.0");
-        return input.swaggerObject;
-    }
-    const schemas = {};
-    for (const key in zodSchemas) {
-        schemas[key] = (0, zod_to_json_schema_1.zodToJsonSchema)(zodSchemas[key], zodToJsonSchemaOptions);
-    }
-    const document = {
-        ...input.openapiObject,
-        components: {
-            ...input.openapiObject.components,
-            schemas: {
-                ...input.openapiObject.components?.schemas,
-                ...schemas,
-            },
-        },
-    };
-    const componentMapVK = new Map();
-    Object.entries(schemas).forEach(([key, value]) => componentMapVK.set(JSON.stringify(value), key));
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    function componentReplacer(key, value) {
-        if (typeof value !== "object") {
-            return value;
-        }
-        // Check if the parent is the schemas object, if so, return the value as is
-        if (this === document.components.schemas) {
-            return value;
-        }
-        const stringifiedValue = JSON.stringify(value);
-        if (componentMapVK.has(stringifiedValue)) {
-            return { $ref: `#/components/schemas/${componentMapVK.get(stringifiedValue)}` };
-        }
-        if (value.nullable === true) {
-            const nonNullableValue = { ...value };
-            delete nonNullableValue.nullable;
-            const stringifiedNonNullableValue = JSON.stringify(nonNullableValue);
-            if (componentMapVK.has(stringifiedNonNullableValue)) {
-                return {
-                    anyOf: [
-                        { $ref: `#/components/schemas/${componentMapVK.get(stringifiedNonNullableValue)}` },
-                    ],
-                    nullable: true,
-                };
-            }
-        }
-        return value;
-    }
-    return JSON.parse(JSON.stringify(document, componentReplacer));
-};
-exports.createJsonSchemaTransformObject = createJsonSchemaTransformObject;
+exports.isResponseSerializationError = exports.hasZodFastifySchemaValidationErrors = exports.InvalidSchemaError = exports.ResponseSerializationError = exports.createSerializerCompiler = exports.validatorCompiler = exports.serializerCompiler = exports.jsonSchemaTransformObject = exports.createJsonSchemaTransform = exports.jsonSchemaTransform = void 0;
+var core_1 = require("./src/core");
+Object.defineProperty(exports, "jsonSchemaTransform", { enumerable: true, get: function () { return core_1.jsonSchemaTransform; } });
+Object.defineProperty(exports, "createJsonSchemaTransform", { enumerable: true, get: function () { return core_1.createJsonSchemaTransform; } });
+Object.defineProperty(exports, "jsonSchemaTransformObject", { enumerable: true, get: function () { return core_1.jsonSchemaTransformObject; } });
+Object.defineProperty(exports, "serializerCompiler", { enumerable: true, get: function () { return core_1.serializerCompiler; } });
+Object.defineProperty(exports, "validatorCompiler", { enumerable: true, get: function () { return core_1.validatorCompiler; } });
+Object.defineProperty(exports, "createSerializerCompiler", { enumerable: true, get: function () { return core_1.createSerializerCompiler; } });
+var errors_1 = require("./src/errors");
+Object.defineProperty(exports, "ResponseSerializationError", { enumerable: true, get: function () { return errors_1.ResponseSerializationError; } });
+Object.defineProperty(exports, "InvalidSchemaError", { enumerable: true, get: function () { return errors_1.InvalidSchemaError; } });
+Object.defineProperty(exports, "hasZodFastifySchemaValidationErrors", { enumerable: true, get: function () { return errors_1.hasZodFastifySchemaValidationErrors; } });
+Object.defineProperty(exports, "isResponseSerializationError", { enumerable: true, get: function () { return errors_1.isResponseSerializationError; } });

package/dist/src/core.d.ts

@@ -0,0 +1,58 @@
+import type { SwaggerTransform, SwaggerTransformObject } from '@fastify/swagger';
+import type { FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, FastifySchema, FastifySchemaCompiler, FastifyTypeProvider, RawServerBase, RawServerDefault } from 'fastify';
+import type { FastifySerializerCompiler } from 'fastify/types/schema';
+import { z } from 'zod';
+export interface ZodTypeProvider extends FastifyTypeProvider {
+    validator: this['schema'] extends z.ZodTypeAny ? z.output<this['schema']> : unknown;
+    serializer: this['schema'] extends z.ZodTypeAny ? z.input<this['schema']> : unknown;
+}
+interface Schema extends FastifySchema {
+    hide?: boolean;
+}
+type CreateJsonSchemaTransformOptions = {
+    skipList: readonly string[];
+};
+export declare const createJsonSchemaTransform: ({ skipList, }: CreateJsonSchemaTransformOptions) => SwaggerTransform<Schema>;
+export declare const jsonSchemaTransform: SwaggerTransform<Schema>;
+type CreateJsonSchemaTransformObjectOptions = {
+    schemaRegistry: z.core.$ZodJSONSchemaRegistry;
+};
+export declare const createJsonSchemaTransformObject: ({ schemaRegistry }: CreateJsonSchemaTransformObjectOptions) => SwaggerTransformObject;
+export declare const jsonSchemaTransformObject: SwaggerTransformObject;
+export declare const validatorCompiler: FastifySchemaCompiler<z.ZodTypeAny>;
+type ReplacerFunction = (this: any, key: string, value: any) => any;
+export type ZodSerializerCompilerOptions = {
+    replacer?: ReplacerFunction;
+};
+export declare const createSerializerCompiler: (options?: ZodSerializerCompilerOptions) => FastifySerializerCompiler<z.ZodTypeAny | {
+    properties: z.ZodTypeAny;
+}>;
+export declare const serializerCompiler: FastifySerializerCompiler<z.ZodType<unknown, unknown> | {
+    properties: z.ZodTypeAny;
+}>;
+/**
+ * FastifyPluginCallbackZod with Zod automatic type inference
+ *
+ * @example
+ * ```typescript
+ * import { FastifyPluginCallbackZod } from "fastify-type-provider-zod"
+ *
+ * const plugin: FastifyPluginCallbackZod = (fastify, options, done) => {
+ *   done()
+ * }
+ * ```
+ */
+export type FastifyPluginCallbackZod<Options extends FastifyPluginOptions = Record<never, never>, Server extends RawServerBase = RawServerDefault> = FastifyPluginCallback<Options, Server, ZodTypeProvider>;
+/**
+ * FastifyPluginAsyncZod with Zod automatic type inference
+ *
+ * @example
+ * ```typescript
+ * import { FastifyPluginAsyncZod } from "fastify-type-provider-zod"
+ *
+ * const plugin: FastifyPluginAsyncZod = async (fastify, options) => {
+ * }
+ * ```
+ */
+export type FastifyPluginAsyncZod<Options extends FastifyPluginOptions = Record<never, never>, Server extends RawServerBase = RawServerDefault> = FastifyPluginAsync<Options, Server, ZodTypeProvider>;
+export {};

package/dist/src/core.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializerCompiler = exports.createSerializerCompiler = exports.validatorCompiler = exports.jsonSchemaTransformObject = exports.createJsonSchemaTransformObject = exports.jsonSchemaTransform = exports.createJsonSchemaTransform = void 0;
+const zod_1 = require("zod");
+const errors_1 = require("./errors");
+const defaultSkipList = [
+    '/documentation/',
+    '/documentation/initOAuth',
+    '/documentation/json',
+    '/documentation/uiConfig',
+    '/documentation/yaml',
+    '/documentation/*',
+    '/documentation/static/*',
+];
+const zodtoJSONSchemaOptions = {
+    uri: (id) => `#/components/schemas/${id}`,
+    external: {
+        registry: zod_1.z.globalRegistry,
+        uri: (id) => `#/components/schemas/${id}`,
+        defs: {},
+    },
+};
+const createJsonSchemaTransform = ({ skipList, }) => {
+    return ({ schema, url }) => {
+        if (!schema) {
+            return {
+                schema,
+                url,
+            };
+        }
+        const { response, headers, querystring, body, params, hide, ...rest } = schema;
+        const transformed = {};
+        if (skipList.includes(url) || hide) {
+            transformed.hide = true;
+            return { schema: transformed, url };
+        }
+        const zodSchemas = { headers, querystring, body, params };
+        for (const prop in zodSchemas) {
+            const zodSchema = zodSchemas[prop];
+            if (zodSchema) {
+                transformed[prop] = zod_1.z.toJSONSchema(zodSchema, zodtoJSONSchemaOptions);
+            }
+        }
+        if (response) {
+            transformed.response = {};
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            for (const prop in response) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const zodSchema = resolveSchema(response[prop]);
+                const transformedResponse = zod_1.z.toJSONSchema(zodSchema, zodtoJSONSchemaOptions);
+                transformed.response[prop] = transformedResponse;
+            }
+        }
+        for (const prop in rest) {
+            const meta = rest[prop];
+            if (meta) {
+                transformed[prop] = meta;
+            }
+        }
+        return { schema: transformed, url };
+    };
+};
+exports.createJsonSchemaTransform = createJsonSchemaTransform;
+exports.jsonSchemaTransform = (0, exports.createJsonSchemaTransform)({
+    skipList: defaultSkipList,
+});
+const createJsonSchemaTransformObject = ({ schemaRegistry }) => (input) => {
+    if ('swaggerObject' in input) {
+        console.warn('This package currently does not support component references for Swagger 2.0');
+        return input.swaggerObject;
+    }
+    const { schemas } = zod_1.z.toJSONSchema(schemaRegistry, zodtoJSONSchemaOptions);
+    return {
+        ...input.openapiObject,
+        components: {
+            ...input.openapiObject.components,
+            schemas: {
+                ...input.openapiObject.components?.schemas,
+                ...schemas,
+            },
+        },
+    };
+};
+exports.createJsonSchemaTransformObject = createJsonSchemaTransformObject;
+exports.jsonSchemaTransformObject = (0, exports.createJsonSchemaTransformObject)({
+    schemaRegistry: zod_1.z.globalRegistry,
+});
+const validatorCompiler = ({ schema }) => (data) => {
+    const result = schema.safeParse(data);
+    if (result.error) {
+        return { error: (0, errors_1.createValidationError)(result.error) };
+    }
+    return { value: result.data };
+};
+exports.validatorCompiler = validatorCompiler;
+function resolveSchema(maybeSchema) {
+    if ('safeParse' in maybeSchema) {
+        return maybeSchema;
+    }
+    if ('properties' in maybeSchema) {
+        return maybeSchema.properties;
+    }
+    throw new errors_1.InvalidSchemaError(JSON.stringify(maybeSchema));
+}
+const createSerializerCompiler = (options) => ({ schema: maybeSchema, method, url }) => (data) => {
+    const schema = resolveSchema(maybeSchema);
+    const result = schema.safeParse(data);
+    if (result.error) {
+        throw new errors_1.ResponseSerializationError(method, url, { cause: result.error });
+    }
+    return JSON.stringify(result.data, options?.replacer);
+};
+exports.createSerializerCompiler = createSerializerCompiler;
+exports.serializerCompiler = (0, exports.createSerializerCompiler)({});

package/dist/src/errors.d.ts

@@ -0,0 +1,35 @@
+import type { FastifyError } from 'fastify';
+import type { z } from 'zod';
+declare const ResponseSerializationError_base: import("@fastify/error").FastifyErrorConstructor<{
+    code: string;
+}, [{
+    cause: z.core.$ZodError;
+}]>;
+export declare class ResponseSerializationError extends ResponseSerializationError_base {
+    method: string;
+    url: string;
+    cause: z.core.$ZodError;
+    constructor(method: string, url: string, options: {
+        cause: z.core.$ZodError;
+    });
+}
+export declare function isResponseSerializationError(value: unknown): value is ResponseSerializationError;
+export declare const InvalidSchemaError: import("@fastify/error").FastifyErrorConstructor<{
+    code: string;
+}, [string]>;
+declare const ZodFastifySchemaValidationErrorSymbol: unique symbol;
+export type ZodFastifySchemaValidationError = {
+    [ZodFastifySchemaValidationErrorSymbol]: true;
+    keyword: string;
+    instancePath: string;
+    schemaPath: string;
+    params: {
+        issue: z.core.$ZodIssue;
+    };
+    message: string;
+};
+export declare const hasZodFastifySchemaValidationErrors: (error: unknown) => error is Omit<FastifyError, "validation"> & {
+    validation: ZodFastifySchemaValidationError[];
+};
+export declare const createValidationError: (error: z.core.$ZodError) => ZodFastifySchemaValidationError[];
+export {};

package/dist/src/errors.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidationError = exports.hasZodFastifySchemaValidationErrors = exports.InvalidSchemaError = exports.ResponseSerializationError = void 0;
+exports.isResponseSerializationError = isResponseSerializationError;
+const error_1 = __importDefault(require("@fastify/error"));
+class ResponseSerializationError extends (0, error_1.default)('FST_ERR_RESPONSE_SERIALIZATION', "Response doesn't match the schema", 500) {
+    constructor(method, url, options) {
+        super({ cause: options.cause });
+        this.method = method;
+        this.url = url;
+    }
+}
+exports.ResponseSerializationError = ResponseSerializationError;
+function isResponseSerializationError(value) {
+    return 'method' in value;
+}
+exports.InvalidSchemaError = (0, error_1.default)('FST_ERR_INVALID_SCHEMA', 'Invalid schema passed: %s', 500);
+const ZodFastifySchemaValidationErrorSymbol = Symbol.for('ZodFastifySchemaValidationError');
+const isZodFastifySchemaValidationError = (error) => typeof error === 'object' &&
+    error !== null &&
+    ZodFastifySchemaValidationErrorSymbol in error &&
+    error[ZodFastifySchemaValidationErrorSymbol] === true;
+const hasZodFastifySchemaValidationErrors = (error) => typeof error === 'object' &&
+    error !== null &&
+    'validation' in error &&
+    Array.isArray(error.validation) &&
+    error.validation.length > 0 &&
+    isZodFastifySchemaValidationError(error.validation[0]);
+exports.hasZodFastifySchemaValidationErrors = hasZodFastifySchemaValidationErrors;
+const createValidationError = (error) => error.issues.map((issue) => ({
+    [ZodFastifySchemaValidationErrorSymbol]: true,
+    keyword: issue.code ?? 'custom',
+    instancePath: `/${issue.path.join('/')}`,
+    schemaPath: `#/${issue.path.join('/')}/${issue.code}`,
+    params: {
+        issue,
+    },
+    message: issue.message,
+}));
+exports.createValidationError = createValidationError;

package/package.json

@@ -1,62 +1,61 @@
-{
-  "name": "@bram-dc/fastify-type-provider-zod",
-  "version": "3.1.1",
-  "description": "Zod Type Provider for Fastify@5",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "README.md",
-    "LICENSE",
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "npm run build && npm run typescript && vitest",
-    "lint": "eslint .",
-    "lint:fix": "eslint --fix .",
-    "typescript": "tsd",
-    "prepublishOnly": "npm run build"
-  },
-  "peerDependencies": {
-    "fastify": "^5.0.0",
-    "zod": "^3.23.8"
-  },
-  "repository": {
-    "url": "https://github.com/bram-dc/fastify-type-provider-zod"
-  },
-  "keywords": [
-    "fastify",
-    "zod",
-    "type",
-    "provider"
-  ],
-  "author": "turkerd",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/bram-dc/fastify-type-provider-zod/issues"
-  },
-  "homepage": "https://github.com/bram-dc/fastify-type-provider-zod",
-  "dependencies": {
-    "@fastify/error": "^4.0.0",
-    "zod-to-json-schema": "^3.23.3"
-  },
-  "devDependencies": {
-    "@fastify/swagger": "^9.0.0",
-    "@fastify/swagger-ui": "^5.0.1",
-    "@stylistic/eslint-plugin": "^2.8.0",
-    "@types/node": "^22.5.5",
-    "eslint": "^9.10.0",
-    "fastify": "^5.0.0",
-    "fastify-plugin": "^5.0.0",
-    "oas-validator": "^5.0.8",
-    "openapi-types": "^12.1.3",
-    "tsd": "^0.31.2",
-    "typescript": "^5.6.2",
-    "typescript-eslint": "^8.6.0",
-    "vitest": "^2.1.1",
-    "zod": "^3.23.8"
-  },
-  "tsd": {
-    "directory": "types"
-  }
-}
+{
+    "name": "@bram-dc/fastify-type-provider-zod",
+    "version": "4.0.2",
+    "description": "Zod Type Provider for Fastify@5",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "README.md",
+        "LICENSE",
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "test": "npm run build && npm run typescript && vitest",
+        "test:coverage": "vitest --coverage",
+        "lint": "biome check . && tsc --project tsconfig.lint.json --noEmit",
+        "lint:fix": "biome check --write .",
+        "typescript": "tsd",
+        "prepublishOnly": "npm run build"
+    },
+    "peerDependencies": {
+        "fastify": "^5.0.0",
+        "zod": "^4.0.0-beta.20250412T085909"
+    },
+    "repository": {
+        "url": "https://github.com/turkerdev/fastify-type-provider-zod"
+    },
+    "keywords": [
+        "fastify",
+        "zod",
+        "type",
+        "provider"
+    ],
+    "author": "turkerd",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/turkerdev/fastify-type-provider-zod/issues"
+    },
+    "homepage": "https://github.com/turkerdev/fastify-type-provider-zod",
+    "dependencies": {
+        "@fastify/error": "^4.0.0"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "^1.9.3",
+        "@fastify/swagger": "^9.1.0",
+        "@fastify/swagger-ui": "^5.0.1",
+        "@kibertoad/biome-config": "^1.2.1",
+        "@types/node": "^20.16.10",
+        "@vitest/coverage-v8": "^2.1.2",
+        "fastify": "^5.0.0",
+        "fastify-plugin": "^5.0.1",
+        "oas-validator": "^5.0.8",
+        "tsd": "^0.31.2",
+        "typescript": "^5.6.2",
+        "vitest": "^2.1.2",
+        "zod": "^4.0.0-beta.20250412T085909"
+    },
+    "tsd": {
+        "directory": "types"
+    }
+}