@bram-dc/fastify-type-provider-zod 5.0.2 → 5.0.3

package/README.md

@@ -4,22 +4,29 @@
 [![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)
 
+## Zod compatibility
+
+| fastify-type-provider-zod | zod  |
+|---------------------------|------|
+| <=4.x                     | v3   |
+| >=5.x                     | v4   |
+
 ## How to use?
 
-```js
-import Fastify from "fastify";
-import { serializerCompiler, validatorCompiler, ZodTypeProvider } from "fastify-type-provider-zod";
-import z from "zod";
+```ts
+import type { ZodTypeProvider } from 'fastify-type-provider-zod';
+import { serializerCompiler, validatorCompiler } from 'fastify-type-provider-zod';
+import { z } from 'zod/v4';
 
-const app = Fastify()
+const app = Fastify();
 
 // Add schema validator and serializer
 app.setValidatorCompiler(validatorCompiler);
 app.setSerializerCompiler(serializerCompiler);
 
 app.withTypeProvider<ZodTypeProvider>().route({
-  method: "GET",
-  url: "/",
+  method: 'GET',
+  url: '/',
   // Define your schema
   schema: {
     querystring: z.object({
@@ -45,10 +52,9 @@ type ZodSerializerCompilerOptions = {
 };
 ```
 
-```js
+```ts
 import Fastify from 'fastify';
 import { createSerializerCompiler, validatorCompiler } from 'fastify-type-provider-zod';
-import z from 'zod';
 
 const app = Fastify();
 
@@ -77,14 +83,13 @@ app.listen({ port: 4949 });
 import fastify from 'fastify';
 import fastifySwagger from '@fastify/swagger';
 import fastifySwaggerUI from '@fastify/swagger-ui';
-import { z } from 'zod';
-
+import { z } from 'zod/v4';
+import type { ZodTypeProvider } from 'fastify-type-provider-zod';
 import {
   jsonSchemaTransform,
   createJsonSchemaTransform,
   serializerCompiler,
   validatorCompiler,
-  ZodTypeProvider,
 } from 'fastify-type-provider-zod';
 
 const app = fastify();
@@ -147,48 +152,50 @@ run();
 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'
+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
-})
+  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.
+When provided, this package will automatically create refs using the `jsonSchemaTransformObject` function. You register the schemas with the global Zod registry and assign them an `id`. `fastifySwagger` will then create an OpenAPI document that references the schemas.
+
+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 { z } from 'zod/v4';
 import type { ZodTypeProvider } from 'fastify-type-provider-zod';
 import {
   jsonSchemaTransformObject,
@@ -202,7 +209,7 @@ const USER_SCHEMA = z.object({
   name: z.string().describe('The name of the user'),
 });
 
-z.globalRegistry.add(USER_SCHEMA, { id: 'User' })
+z.globalRegistry.add(USER_SCHEMA, { id: 'User' });
 
 const app = fastify();
 app.setValidatorCompiler(validatorCompiler);
@@ -256,8 +263,8 @@ run();
 ## How to create a plugin?
 
 ```ts
-import { z } from 'zod';
-import { FastifyPluginAsyncZod } from 'fastify-type-provider-zod';
+import { z } from 'zod/v4';
+import type { FastifyPluginAsyncZod } from 'fastify-type-provider-zod';
 
 const plugin: FastifyPluginAsyncZod = async function (fastify, _opts) {
   fastify.route({

package/dist/cjs/core.cjs

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("zod/v4/core");
+const errors = require("./errors.cjs");
+const jsonToOas = require("./json-to-oas.cjs");
+const zodToJson = require("./zod-to-json.cjs");
+const defaultSkipList = [
+  "/documentation/",
+  "/documentation/initOAuth",
+  "/documentation/json",
+  "/documentation/uiConfig",
+  "/documentation/yaml",
+  "/documentation/*",
+  "/documentation/static/*"
+];
+const createJsonSchemaTransform = ({
+  skipList = defaultSkipList,
+  schemaRegistry = core.globalRegistry
+}) => {
+  return (input) => {
+    if ("swaggerObject" in input) {
+      throw new Error("OpenAPI 2.0 is not supported");
+    }
+    const { schema, url } = input;
+    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 };
+    const oasVersion = jsonToOas.getOASVersion(input);
+    for (const prop in zodSchemas) {
+      const zodSchema = zodSchemas[prop];
+      if (zodSchema) {
+        const jsonSchema = zodToJson.zodSchemaToJson(zodSchema, schemaRegistry, "input");
+        const oasSchema = jsonToOas.jsonSchemaToOAS(jsonSchema, oasVersion);
+        transformed[prop] = oasSchema;
+      }
+    }
+    if (response) {
+      transformed.response = {};
+      for (const prop in response) {
+        const zodSchema = resolveSchema(response[prop]);
+        const jsonSchema = zodToJson.zodSchemaToJson(zodSchema, schemaRegistry, "output");
+        if (jsonSchema.type === "null") {
+          transformed.response[prop] = jsonSchema;
+          continue;
+        }
+        const oasSchema = jsonToOas.jsonSchemaToOAS(jsonSchema, oasVersion);
+        transformed.response[prop] = oasSchema;
+      }
+    }
+    for (const prop in rest) {
+      const meta = rest[prop];
+      if (meta) {
+        transformed[prop] = meta;
+      }
+    }
+    return { schema: transformed, url };
+  };
+};
+const jsonSchemaTransform = createJsonSchemaTransform({});
+const createJsonSchemaTransformObject = ({
+  schemaRegistry = core.globalRegistry
+}) => (input) => {
+  if ("swaggerObject" in input) {
+    throw new Error("OpenAPI 2.0 is not supported");
+  }
+  const oasVersion = jsonToOas.getOASVersion(input);
+  const inputSchemas = zodToJson.zodRegistryToJson(schemaRegistry, "input");
+  const outputSchemas = zodToJson.zodRegistryToJson(schemaRegistry, "output");
+  for (const key in outputSchemas) {
+    if (inputSchemas[key]) {
+      throw new Error(
+        `Collision detected for schema "${key}". The is already an input schema with the same name.`
+      );
+    }
+  }
+  const jsonSchemas = {
+    ...inputSchemas,
+    ...outputSchemas
+  };
+  const oasSchemas = Object.fromEntries(
+    Object.entries(jsonSchemas).map(([key, value]) => [key, jsonToOas.jsonSchemaToOAS(value, oasVersion)])
+  );
+  return {
+    ...input.openapiObject,
+    components: {
+      ...input.openapiObject.components,
+      schemas: {
+        ...input.openapiObject.components?.schemas,
+        ...oasSchemas
+      }
+    }
+  };
+};
+const jsonSchemaTransformObject = createJsonSchemaTransformObject({});
+const validatorCompiler = ({ schema }) => (data) => {
+  const result = core.safeParse(schema, data);
+  if (result.error) {
+    return { error: errors.createValidationError(result.error) };
+  }
+  return { value: result.data };
+};
+function resolveSchema(maybeSchema) {
+  if (maybeSchema instanceof core.$ZodType) {
+    return maybeSchema;
+  }
+  if ("properties" in maybeSchema && maybeSchema.properties instanceof core.$ZodType) {
+    return maybeSchema.properties;
+  }
+  throw new errors.InvalidSchemaError(JSON.stringify(maybeSchema));
+}
+const createSerializerCompiler = (options) => ({ schema: maybeSchema, method, url }) => (data) => {
+  const schema = resolveSchema(maybeSchema);
+  const result = core.safeParse(schema, data);
+  if (result.error) {
+    throw new errors.ResponseSerializationError(method, url, { cause: result.error });
+  }
+  return JSON.stringify(result.data, options?.replacer);
+};
+const serializerCompiler = createSerializerCompiler({});
+exports.createJsonSchemaTransform = createJsonSchemaTransform;
+exports.createJsonSchemaTransformObject = createJsonSchemaTransformObject;
+exports.createSerializerCompiler = createSerializerCompiler;
+exports.jsonSchemaTransform = jsonSchemaTransform;
+exports.jsonSchemaTransformObject = jsonSchemaTransformObject;
+exports.serializerCompiler = serializerCompiler;
+exports.validatorCompiler = validatorCompiler;
+//# sourceMappingURL=core.cjs.map

package/dist/cjs/core.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.cjs","sources":["../../src/core.ts"],"sourcesContent":["import type { SwaggerTransform, SwaggerTransformObject } from '@fastify/swagger'\nimport type {\n  FastifyPluginAsync,\n  FastifyPluginCallback,\n  FastifyPluginOptions,\n  FastifySchema,\n  FastifySchemaCompiler,\n  FastifyTypeProvider,\n  RawServerBase,\n  RawServerDefault,\n} from 'fastify'\nimport type { FastifySerializerCompiler } from 'fastify/types/schema'\nimport type { $ZodRegistry, input, output } from 'zod/v4/core'\nimport { $ZodType, globalRegistry, safeParse } from 'zod/v4/core'\nimport { createValidationError, InvalidSchemaError, ResponseSerializationError } from './errors'\nimport { getOASVersion, jsonSchemaToOAS } from './json-to-oas'\nimport { zodRegistryToJson, zodSchemaToJson } from './zod-to-json'\n\ntype FreeformRecord = Record<string, any>\n\nconst defaultSkipList = [\n  '/documentation/',\n  '/documentation/initOAuth',\n  '/documentation/json',\n  '/documentation/uiConfig',\n  '/documentation/yaml',\n  '/documentation/*',\n  '/documentation/static/*',\n]\n\nexport interface ZodTypeProvider extends FastifyTypeProvider {\n  validator: this['schema'] extends $ZodType ? output<this['schema']> : unknown\n  serializer: this['schema'] extends $ZodType ? input<this['schema']> : unknown\n}\n\ninterface Schema extends FastifySchema {\n  hide?: boolean\n}\n\ntype CreateJsonSchemaTransformOptions = {\n  skipList?: readonly string[]\n  schemaRegistry?: $ZodRegistry<{ id?: string | undefined }>\n}\n\nexport const createJsonSchemaTransform = ({\n  skipList = defaultSkipList,\n  schemaRegistry = globalRegistry,\n}: CreateJsonSchemaTransformOptions): SwaggerTransform<Schema> => {\n  return (input) => {\n    if ('swaggerObject' in input) {\n      throw new Error('OpenAPI 2.0 is not supported')\n    }\n\n    const { schema, url } = input\n\n    if (!schema) {\n      return {\n        schema,\n        url,\n      }\n    }\n\n    const { response, headers, querystring, body, params, hide, ...rest } = schema\n\n    const transformed: FreeformRecord = {}\n\n    if (skipList.includes(url) || hide) {\n      transformed.hide = true\n      return { schema: transformed, url }\n    }\n\n    const zodSchemas: FreeformRecord = { headers, querystring, body, params }\n\n    const oasVersion = getOASVersion(input)\n\n    for (const prop in zodSchemas) {\n      const zodSchema = zodSchemas[prop]\n      if (zodSchema) {\n        const jsonSchema = zodSchemaToJson(zodSchema, schemaRegistry, 'input')\n        const oasSchema = jsonSchemaToOAS(jsonSchema, oasVersion)\n\n        transformed[prop] = oasSchema\n      }\n    }\n\n    if (response) {\n      transformed.response = {}\n\n      for (const prop in response as any) {\n        const zodSchema = resolveSchema((response as any)[prop])\n        const jsonSchema = zodSchemaToJson(zodSchema, schemaRegistry, 'output')\n\n        // Check is the JSON schema is null then return as it is since fastify-swagger will handle it\n        if (jsonSchema.type === 'null') {\n          transformed.response[prop] = jsonSchema\n          continue\n        }\n\n        const oasSchema = jsonSchemaToOAS(jsonSchema, oasVersion)\n\n        transformed.response[prop] = oasSchema\n      }\n    }\n\n    for (const prop in rest) {\n      const meta = rest[prop as keyof typeof rest]\n      if (meta) {\n        transformed[prop] = meta\n      }\n    }\n\n    return { schema: transformed, url }\n  }\n}\n\nexport const jsonSchemaTransform: SwaggerTransform<Schema> = createJsonSchemaTransform({})\n\ntype CreateJsonSchemaTransformObjectOptions = {\n  schemaRegistry?: $ZodRegistry<{ id?: string | undefined }>\n}\n\nexport const createJsonSchemaTransformObject =\n  ({\n    schemaRegistry = globalRegistry,\n  }: CreateJsonSchemaTransformObjectOptions): SwaggerTransformObject =>\n  (input) => {\n    if ('swaggerObject' in input) {\n      throw new Error('OpenAPI 2.0 is not supported')\n    }\n\n    const oasVersion = getOASVersion(input)\n\n    const inputSchemas = zodRegistryToJson(schemaRegistry, 'input')\n    const outputSchemas = zodRegistryToJson(schemaRegistry, 'output')\n\n    for (const key in outputSchemas) {\n      if (inputSchemas[key]) {\n        throw new Error(\n          `Collision detected for schema \"${key}\". The is already an input schema with the same name.`,\n        )\n      }\n    }\n\n    const jsonSchemas = {\n      ...inputSchemas,\n      ...outputSchemas,\n    }\n\n    const oasSchemas = Object.fromEntries(\n      Object.entries(jsonSchemas).map(([key, value]) => [key, jsonSchemaToOAS(value, oasVersion)]),\n    )\n\n    return {\n      ...input.openapiObject,\n      components: {\n        ...input.openapiObject.components,\n        schemas: {\n          ...input.openapiObject.components?.schemas,\n          ...oasSchemas,\n        },\n      },\n    } as ReturnType<SwaggerTransformObject>\n  }\n\nexport const jsonSchemaTransformObject: SwaggerTransformObject = createJsonSchemaTransformObject({})\n\nexport const validatorCompiler: FastifySchemaCompiler<$ZodType> =\n  ({ schema }) =>\n  (data) => {\n    const result = safeParse(schema, data)\n    if (result.error) {\n      return { error: createValidationError(result.error) as unknown as Error }\n    }\n\n    return { value: result.data }\n  }\n\nfunction resolveSchema(maybeSchema: $ZodType | { properties: $ZodType }): $ZodType {\n  if (maybeSchema instanceof $ZodType) {\n    return maybeSchema\n  }\n  if ('properties' in maybeSchema && maybeSchema.properties instanceof $ZodType) {\n    return maybeSchema.properties\n  }\n  throw new InvalidSchemaError(JSON.stringify(maybeSchema))\n}\n\ntype ReplacerFunction = (this: any, key: string, value: any) => any\n\nexport type ZodSerializerCompilerOptions = {\n  replacer?: ReplacerFunction\n}\n\nexport const createSerializerCompiler =\n  (\n    options?: ZodSerializerCompilerOptions,\n  ): FastifySerializerCompiler<$ZodType | { properties: $ZodType }> =>\n  ({ schema: maybeSchema, method, url }) =>\n  (data) => {\n    const schema = resolveSchema(maybeSchema)\n\n    const result = safeParse(schema, data)\n    if (result.error) {\n      throw new ResponseSerializationError(method, url, { cause: result.error })\n    }\n\n    return JSON.stringify(result.data, options?.replacer)\n  }\n\nexport const serializerCompiler: ReturnType<typeof createSerializerCompiler> =\n  createSerializerCompiler({})\n\n/**\n * FastifyPluginCallbackZod with Zod automatic type inference\n *\n * @example\n * ```typescript\n * import { FastifyPluginCallbackZod } from \"fastify-type-provider-zod\"\n *\n * const plugin: FastifyPluginCallbackZod = (fastify, options, done) => {\n *   done()\n * }\n * ```\n */\nexport type FastifyPluginCallbackZod<\n  Options extends FastifyPluginOptions = Record<never, never>,\n  Server extends RawServerBase = RawServerDefault,\n> = FastifyPluginCallback<Options, Server, ZodTypeProvider>\n\n/**\n * FastifyPluginAsyncZod with Zod automatic type inference\n *\n * @example\n * ```typescript\n * import { FastifyPluginAsyncZod } from \"fastify-type-provider-zod\"\n *\n * const plugin: FastifyPluginAsyncZod = async (fastify, options) => {\n * }\n * ```\n */\nexport type FastifyPluginAsyncZod<\n  Options extends FastifyPluginOptions = Record<never, never>,\n  Server extends RawServerBase = RawServerDefault,\n> = FastifyPluginAsync<Options, Server, ZodTypeProvider>\n"],"names":["globalRegistry","getOASVersion","zodSchemaToJson","jsonSchemaToOAS","zodRegistryToJson","safeParse","createValidationError","$ZodType","InvalidSchemaError","ResponseSerializationError"],"mappings":"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"}

package/dist/cjs/core.d.cts

@@ -0,0 +1,68 @@
+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 type { $ZodRegistry, input, output } from "zod/v4/core";
+import { $ZodType } from "zod/v4/core";
+export interface ZodTypeProvider extends FastifyTypeProvider {
+	validator: this["schema"] extends $ZodType ? output<this["schema"]> : unknown;
+	serializer: this["schema"] extends $ZodType ? input<this["schema"]> : unknown;
+}
+interface Schema extends FastifySchema {
+	hide?: boolean;
+}
+type CreateJsonSchemaTransformOptions = {
+	skipList?: readonly string[];
+	schemaRegistry?: $ZodRegistry<{
+		id?: string | undefined;
+	}>;
+};
+export declare const createJsonSchemaTransform: ({ skipList, schemaRegistry }: CreateJsonSchemaTransformOptions) => SwaggerTransform<Schema>;
+export declare const jsonSchemaTransform: SwaggerTransform<Schema>;
+type CreateJsonSchemaTransformObjectOptions = {
+	schemaRegistry?: $ZodRegistry<{
+		id?: string | undefined;
+	}>;
+};
+export declare const createJsonSchemaTransformObject: ({ schemaRegistry }: CreateJsonSchemaTransformObjectOptions) => SwaggerTransformObject;
+export declare const jsonSchemaTransformObject: SwaggerTransformObject;
+export declare const validatorCompiler: FastifySchemaCompiler<$ZodType>;
+type ReplacerFunction = (this: any, key: string, value: any) => any;
+export type ZodSerializerCompilerOptions = {
+	replacer?: ReplacerFunction;
+};
+export declare const createSerializerCompiler: (options?: ZodSerializerCompilerOptions) => FastifySerializerCompiler<$ZodType | {
+	properties: $ZodType;
+}>;
+export declare const serializerCompiler: ReturnType<typeof createSerializerCompiler>;
+/**
+* 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/cjs/errors.cjs

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createError = require("@fastify/error");
+const InvalidSchemaError = createError("FST_ERR_INVALID_SCHEMA", "Invalid schema passed: %s", 500);
+const ZodFastifySchemaValidationErrorSymbol = Symbol.for("ZodFastifySchemaValidationError");
+const ResponseSerializationBase = createError(
+  "FST_ERR_RESPONSE_SERIALIZATION",
+  "Response doesn't match the schema",
+  500
+);
+class ResponseSerializationError extends ResponseSerializationBase {
+  constructor(method, url, options) {
+    super({ cause: options.cause });
+    this.method = method;
+    this.url = url;
+    this.cause = options.cause;
+  }
+  cause;
+}
+function isResponseSerializationError(value) {
+  return "method" in value;
+}
+function isZodFastifySchemaValidationError(error) {
+  return typeof error === "object" && error !== null && error[ZodFastifySchemaValidationErrorSymbol] === true;
+}
+function hasZodFastifySchemaValidationErrors(error) {
+  return typeof error === "object" && error !== null && "validation" in error && Array.isArray(error.validation) && error.validation.length > 0 && isZodFastifySchemaValidationError(error.validation[0]);
+}
+function omit(obj, keys) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (!keys.includes(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function createValidationError(error) {
+  return error.issues.map((issue) => {
+    return {
+      [ZodFastifySchemaValidationErrorSymbol]: true,
+      keyword: issue.code,
+      instancePath: `/${issue.path.join("/")}`,
+      schemaPath: `#/${issue.path.join("/")}/${issue.code}`,
+      message: issue.message,
+      params: {
+        ...omit(issue, ["path", "code", "message"])
+      }
+    };
+  });
+}
+exports.InvalidSchemaError = InvalidSchemaError;
+exports.ResponseSerializationError = ResponseSerializationError;
+exports.createValidationError = createValidationError;
+exports.hasZodFastifySchemaValidationErrors = hasZodFastifySchemaValidationErrors;
+exports.isResponseSerializationError = isResponseSerializationError;
+//# sourceMappingURL=errors.cjs.map

package/dist/cjs/errors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.cjs","sources":["../../src/errors.ts"],"sourcesContent":["import createError, { type FastifyErrorConstructor } from '@fastify/error'\nimport type { FastifyError } from 'fastify'\nimport type { FastifySchemaValidationError } from 'fastify/types/schema'\nimport type { $ZodError } from 'zod/v4/core'\n\nexport const InvalidSchemaError: FastifyErrorConstructor<\n  {\n    code: string\n  },\n  [string]\n> = createError<[string]>('FST_ERR_INVALID_SCHEMA', 'Invalid schema passed: %s', 500)\n\nconst ZodFastifySchemaValidationErrorSymbol: symbol = Symbol.for('ZodFastifySchemaValidationError')\n\nexport type ZodFastifySchemaValidationError = FastifySchemaValidationError & {\n  [ZodFastifySchemaValidationErrorSymbol]: true\n}\n\nconst ResponseSerializationBase: FastifyErrorConstructor<\n  {\n    code: string\n  },\n  [\n    {\n      cause: $ZodError\n    },\n  ]\n> = createError<[{ cause: $ZodError }]>(\n  'FST_ERR_RESPONSE_SERIALIZATION',\n  \"Response doesn't match the schema\",\n  500,\n)\n\nexport class ResponseSerializationError extends ResponseSerializationBase {\n  cause!: $ZodError\n\n  constructor(\n    public method: string,\n    public url: string,\n    options: { cause: $ZodError },\n  ) {\n    super({ cause: options.cause })\n\n    this.cause = options.cause\n  }\n}\n\nexport function isResponseSerializationError(value: unknown): value is ResponseSerializationError {\n  return 'method' in (value as ResponseSerializationError)\n}\n\nfunction isZodFastifySchemaValidationError(\n  error: unknown,\n): error is ZodFastifySchemaValidationError {\n  return (\n    typeof error === 'object' &&\n    error !== null &&\n    (error as ZodFastifySchemaValidationError)[ZodFastifySchemaValidationErrorSymbol] === true\n  )\n}\n\nexport function hasZodFastifySchemaValidationErrors(\n  error: unknown,\n): error is Omit<FastifyError, 'validation'> & { validation: ZodFastifySchemaValidationError[] } {\n  return (\n    typeof error === 'object' &&\n    error !== null &&\n    'validation' in error &&\n    Array.isArray(error.validation) &&\n    error.validation.length > 0 &&\n    isZodFastifySchemaValidationError(error.validation[0])\n  )\n}\n\nfunction omit<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K> {\n  const result = {} as Omit<T, K>\n  for (const key of Object.keys(obj) as Array<keyof T>) {\n    if (!keys.includes(key as K)) {\n      // @ts-expect-error\n      result[key] = obj[key]\n    }\n  }\n  return result\n}\n\nexport function createValidationError(error: $ZodError): ZodFastifySchemaValidationError[] {\n  return error.issues.map((issue) => {\n    return {\n      [ZodFastifySchemaValidationErrorSymbol]: true,\n      keyword: issue.code,\n      instancePath: `/${issue.path.join('/')}`,\n      schemaPath: `#/${issue.path.join('/')}/${issue.code}`,\n      message: issue.message,\n      params: {\n        ...omit(issue, ['path', 'code', 'message']),\n      },\n    }\n  })\n}\n"],"names":[],"mappings":";;;AAKO,MAAM,qBAKT,YAAsB,0BAA0B,6BAA6B,GAAG;AAEpF,MAAM,wCAAgD,OAAO,IAAI,iCAAiC;AAMlG,MAAM,4BASF;AAAA,EACF;AAAA,EACA;AAAA,EACA;AACF;AAEO,MAAM,mCAAmC,0BAA0B;AAAA,EAGxE,YACS,QACA,KACP,SACA;AACA,UAAM,EAAE,OAAO,QAAQ,MAAA,CAAO;AAJvB,SAAA,SAAA;AACA,SAAA,MAAA;AAKP,SAAK,QAAQ,QAAQ;AAAA,EACvB;AAAA,EAVA;AAWF;AAEO,SAAS,6BAA6B,OAAqD;AAChG,SAAO,YAAa;AACtB;AAEA,SAAS,kCACP,OAC0C;AAC1C,SACE,OAAO,UAAU,YACjB,UAAU,QACT,MAA0C,qCAAqC,MAAM;AAE1F;AAEO,SAAS,oCACd,OAC+F;AAC/F,SACE,OAAO,UAAU,YACjB,UAAU,QACV,gBAAgB,SAChB,MAAM,QAAQ,MAAM,UAAU,KAC9B,MAAM,WAAW,SAAS,KAC1B,kCAAkC,MAAM,WAAW,CAAC,CAAC;AAEzD;AAEA,SAAS,KAA0C,KAAQ,MAAgC;AACzF,QAAM,SAAS,CAAA;AACf,aAAW,OAAO,OAAO,KAAK,GAAG,GAAqB;AACpD,QAAI,CAAC,KAAK,SAAS,GAAQ,GAAG;AAE5B,aAAO,GAAG,IAAI,IAAI,GAAG;AAAA,IACvB;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,sBAAsB,OAAqD;AACzF,SAAO,MAAM,OAAO,IAAI,CAAC,UAAU;AACjC,WAAO;AAAA,MACL,CAAC,qCAAqC,GAAG;AAAA,MACzC,SAAS,MAAM;AAAA,MACf,cAAc,IAAI,MAAM,KAAK,KAAK,GAAG,CAAC;AAAA,MACtC,YAAY,KAAK,MAAM,KAAK,KAAK,GAAG,CAAC,IAAI,MAAM,IAAI;AAAA,MACnD,SAAS,MAAM;AAAA,MACf,QAAQ;AAAA,QACN,GAAG,KAAK,OAAO,CAAC,QAAQ,QAAQ,SAAS,CAAC;AAAA,MAAA;AAAA,IAC5C;AAAA,EAEJ,CAAC;AACH;;;;;;"}

package/dist/cjs/errors.d.cts

@@ -0,0 +1,30 @@
+import { type FastifyErrorConstructor } from "@fastify/error";
+import type { FastifyError } from "fastify";
+import type { FastifySchemaValidationError } from "fastify/types/schema";
+import type { $ZodError } from "zod/v4/core";
+export declare const InvalidSchemaError: FastifyErrorConstructor<{
+	code: string;
+}, [string]>;
+declare const ZodFastifySchemaValidationErrorSymbol: symbol;
+export type ZodFastifySchemaValidationError = FastifySchemaValidationError & {
+	[ZodFastifySchemaValidationErrorSymbol]: true;
+};
+declare const ResponseSerializationBase: FastifyErrorConstructor<{
+	code: string;
+}, [{
+	cause: $ZodError;
+}]>;
+export declare class ResponseSerializationError extends ResponseSerializationBase {
+	method: string;
+	url: string;
+	cause: $ZodError;
+	constructor(method: string, url: string, options: {
+		cause: $ZodError;
+	});
+}
+export declare function isResponseSerializationError(value: unknown): value is ResponseSerializationError;
+export declare function hasZodFastifySchemaValidationErrors(error: unknown): error is Omit<FastifyError, "validation"> & {
+	validation: ZodFastifySchemaValidationError[];
+};
+export declare function createValidationError(error: $ZodError): ZodFastifySchemaValidationError[];
+export {};

package/dist/cjs/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("./core.cjs");
+const errors = require("./errors.cjs");
+exports.createJsonSchemaTransform = core.createJsonSchemaTransform;
+exports.createJsonSchemaTransformObject = core.createJsonSchemaTransformObject;
+exports.createSerializerCompiler = core.createSerializerCompiler;
+exports.jsonSchemaTransform = core.jsonSchemaTransform;
+exports.jsonSchemaTransformObject = core.jsonSchemaTransformObject;
+exports.serializerCompiler = core.serializerCompiler;
+exports.validatorCompiler = core.validatorCompiler;
+exports.InvalidSchemaError = errors.InvalidSchemaError;
+exports.ResponseSerializationError = errors.ResponseSerializationError;
+exports.hasZodFastifySchemaValidationErrors = errors.hasZodFastifySchemaValidationErrors;
+exports.isResponseSerializationError = errors.isResponseSerializationError;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}

package/dist/cjs/index.d.cts

@@ -0,0 +1,2 @@
+export { createJsonSchemaTransform, createJsonSchemaTransformObject, createSerializerCompiler, type FastifyPluginAsyncZod, type FastifyPluginCallbackZod, jsonSchemaTransform, jsonSchemaTransformObject, serializerCompiler, validatorCompiler, type ZodSerializerCompilerOptions, type ZodTypeProvider } from "../cjs/core.cjs";
+export { hasZodFastifySchemaValidationErrors, InvalidSchemaError, isResponseSerializationError, ResponseSerializationError, type ZodFastifySchemaValidationError } from "../cjs/errors.cjs";

package/dist/cjs/json-to-oas.cjs

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getOASVersion = (documentObject) => {
+  const openapiVersion = documentObject.openapiObject.openapi || "3.0.3";
+  if (openapiVersion.startsWith("3.1")) {
+    return "3.1";
+  }
+  if (openapiVersion.startsWith("3.0")) {
+    return "3.0";
+  }
+  throw new Error("Unsupported OpenAPI document object");
+};
+const jsonSchemaToOAS_3_0 = (jsonSchema) => {
+  const clone = { ...jsonSchema };
+  if (clone.type === "null") {
+    clone.nullable = true;
+    delete clone.type;
+    clone.enum = [null];
+  }
+  if (Array.isArray(clone.prefixItems)) {
+    const tuple = clone.prefixItems;
+    clone.minItems ??= tuple.length;
+    clone.maxItems ??= tuple.length;
+    clone.items = {
+      oneOf: tuple.map(jsonSchemaToOAS_3_0)
+    };
+    delete clone.prefixItems;
+  }
+  if ("const" in clone && clone.const !== void 0) {
+    clone.enum = [clone.const];
+    delete clone.const;
+  }
+  if (typeof clone.exclusiveMinimum === "number") {
+    clone.minimum = clone.exclusiveMinimum;
+    clone.exclusiveMinimum = true;
+  }
+  if (typeof clone.exclusiveMaximum === "number") {
+    clone.maximum = clone.exclusiveMaximum;
+    clone.exclusiveMaximum = true;
+  }
+  for (const key of [
+    "$schema",
+    "$id",
+    "unevaluatedProperties",
+    "dependentSchemas",
+    "patternProperties",
+    "propertyNames",
+    "contentEncoding",
+    "contentMediaType"
+  ]) {
+    delete clone[key];
+  }
+  const recursive = (v) => Array.isArray(v) ? v.map(jsonSchemaToOAS_3_0) : jsonSchemaToOAS_3_0(v);
+  if (clone.properties) {
+    for (const [k, v] of Object.entries(clone.properties)) {
+      clone.properties[k] = jsonSchemaToOAS_3_0(v);
+    }
+  }
+  if (clone.items && !Array.isArray(clone.items)) {
+    clone.items = recursive(clone.items);
+  }
+  for (const key of ["allOf", "anyOf", "oneOf", "not", "then", "else", "if", "contains"]) {
+    if (clone[key]) {
+      clone[key] = recursive(clone[key]);
+    }
+  }
+  return clone;
+};
+const jsonSchemaToOAS_3_1 = (jsonSchema) => {
+  return jsonSchema;
+};
+const jsonSchemaToOAS = (jsonSchema, oasVersion) => {
+  switch (oasVersion) {
+    case "3.0":
+      return jsonSchemaToOAS_3_0(jsonSchema);
+    case "3.1":
+      return jsonSchemaToOAS_3_1(jsonSchema);
+    default:
+      throw new Error(`Unsupported OpenAPI version: ${oasVersion}`);
+  }
+};
+exports.getOASVersion = getOASVersion;
+exports.jsonSchemaToOAS = jsonSchemaToOAS;
+exports.jsonSchemaToOAS_3_0 = jsonSchemaToOAS_3_0;
+//# sourceMappingURL=json-to-oas.cjs.map

package/dist/cjs/json-to-oas.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-to-oas.cjs","sources":["../../src/json-to-oas.ts"],"sourcesContent":["import type { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'\nimport type { JSONSchema } from 'zod/v4/core'\n\ntype OASVersion = '3.0' | '3.1'\n\nexport const getOASVersion = (documentObject: {\n  openapiObject: Partial<OpenAPIV3.Document | OpenAPIV3_1.Document>\n}): OASVersion => {\n  const openapiVersion = documentObject.openapiObject.openapi || '3.0.3'\n\n  if (openapiVersion.startsWith('3.1')) {\n    return '3.1'\n  }\n\n  if (openapiVersion.startsWith('3.0')) {\n    return '3.0'\n  }\n\n  throw new Error('Unsupported OpenAPI document object')\n}\n\nexport const jsonSchemaToOAS_3_0 = (jsonSchema: JSONSchema.BaseSchema): OpenAPIV3.SchemaObject => {\n  const clone: any = { ...jsonSchema }\n\n  if (clone.type === 'null') {\n    clone.nullable = true\n    delete clone.type\n    clone.enum = [null]\n  }\n\n  if (Array.isArray(clone.prefixItems)) {\n    const tuple = clone.prefixItems as JSONSchema.BaseSchema[]\n\n    clone.minItems ??= tuple.length\n    clone.maxItems ??= tuple.length\n\n    clone.items = {\n      oneOf: tuple.map(jsonSchemaToOAS_3_0),\n    }\n\n    delete clone.prefixItems\n  }\n\n  if ('const' in clone && clone.const !== undefined) {\n    clone.enum = [clone.const]\n    delete clone.const\n  }\n\n  if (typeof clone.exclusiveMinimum === 'number') {\n    clone.minimum = clone.exclusiveMinimum\n    clone.exclusiveMinimum = true\n  }\n  if (typeof clone.exclusiveMaximum === 'number') {\n    clone.maximum = clone.exclusiveMaximum\n    clone.exclusiveMaximum = true\n  }\n\n  for (const key of [\n    '$schema',\n    '$id',\n    'unevaluatedProperties',\n    'dependentSchemas',\n    'patternProperties',\n    'propertyNames',\n    'contentEncoding',\n    'contentMediaType',\n  ]) {\n    delete clone[key]\n  }\n\n  const recursive = (v: any): any =>\n    Array.isArray(v) ? v.map(jsonSchemaToOAS_3_0) : jsonSchemaToOAS_3_0(v)\n\n  if (clone.properties) {\n    for (const [k, v] of Object.entries(clone.properties)) {\n      clone.properties![k] = jsonSchemaToOAS_3_0(v as any)\n    }\n  }\n\n  if (clone.items && !Array.isArray(clone.items)) {\n    clone.items = recursive(clone.items)\n  }\n\n  for (const key of ['allOf', 'anyOf', 'oneOf', 'not', 'then', 'else', 'if', 'contains']) {\n    if (clone[key]) {\n      clone[key] = recursive(clone[key])\n    }\n  }\n\n  return clone as OpenAPIV3.SchemaObject\n}\n\nconst jsonSchemaToOAS_3_1 = (jsonSchema: JSONSchema.BaseSchema): OpenAPIV3_1.SchemaObject => {\n  return jsonSchema as OpenAPIV3_1.SchemaObject\n}\n\nexport const jsonSchemaToOAS = (\n  jsonSchema: JSONSchema.BaseSchema,\n  oasVersion: OASVersion,\n): OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject => {\n  switch (oasVersion) {\n    case '3.0':\n      return jsonSchemaToOAS_3_0(jsonSchema)\n    case '3.1':\n      return jsonSchemaToOAS_3_1(jsonSchema)\n    default:\n      throw new Error(`Unsupported OpenAPI version: ${oasVersion}`)\n  }\n}\n"],"names":[],"mappings":";;AAKO,MAAM,gBAAgB,CAAC,mBAEZ;AAChB,QAAM,iBAAiB,eAAe,cAAc,WAAW;AAE/D,MAAI,eAAe,WAAW,KAAK,GAAG;AACpC,WAAO;AAAA,EACT;AAEA,MAAI,eAAe,WAAW,KAAK,GAAG;AACpC,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,qCAAqC;AACvD;AAEO,MAAM,sBAAsB,CAAC,eAA8D;AAChG,QAAM,QAAa,EAAE,GAAG,WAAA;AAExB,MAAI,MAAM,SAAS,QAAQ;AACzB,UAAM,WAAW;AACjB,WAAO,MAAM;AACb,UAAM,OAAO,CAAC,IAAI;AAAA,EACpB;AAEA,MAAI,MAAM,QAAQ,MAAM,WAAW,GAAG;AACpC,UAAM,QAAQ,MAAM;AAEpB,UAAM,aAAa,MAAM;AACzB,UAAM,aAAa,MAAM;AAEzB,UAAM,QAAQ;AAAA,MACZ,OAAO,MAAM,IAAI,mBAAmB;AAAA,IAAA;AAGtC,WAAO,MAAM;AAAA,EACf;AAEA,MAAI,WAAW,SAAS,MAAM,UAAU,QAAW;AACjD,UAAM,OAAO,CAAC,MAAM,KAAK;AACzB,WAAO,MAAM;AAAA,EACf;AAEA,MAAI,OAAO,MAAM,qBAAqB,UAAU;AAC9C,UAAM,UAAU,MAAM;AACtB,UAAM,mBAAmB;AAAA,EAC3B;AACA,MAAI,OAAO,MAAM,qBAAqB,UAAU;AAC9C,UAAM,UAAU,MAAM;AACtB,UAAM,mBAAmB;AAAA,EAC3B;AAEA,aAAW,OAAO;AAAA,IAChB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA,GACC;AACD,WAAO,MAAM,GAAG;AAAA,EAClB;AAEA,QAAM,YAAY,CAAC,MACjB,MAAM,QAAQ,CAAC,IAAI,EAAE,IAAI,mBAAmB,IAAI,oBAAoB,CAAC;AAEvE,MAAI,MAAM,YAAY;AACpB,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,MAAM,UAAU,GAAG;AACrD,YAAM,WAAY,CAAC,IAAI,oBAAoB,CAAQ;AAAA,IACrD;AAAA,EACF;AAEA,MAAI,MAAM,SAAS,CAAC,MAAM,QAAQ,MAAM,KAAK,GAAG;AAC9C,UAAM,QAAQ,UAAU,MAAM,KAAK;AAAA,EACrC;AAEA,aAAW,OAAO,CAAC,SAAS,SAAS,SAAS,OAAO,QAAQ,QAAQ,MAAM,UAAU,GAAG;AACtF,QAAI,MAAM,GAAG,GAAG;AACd,YAAM,GAAG,IAAI,UAAU,MAAM,GAAG,CAAC;AAAA,IACnC;AAAA,EACF;AAEA,SAAO;AACT;AAEA,MAAM,sBAAsB,CAAC,eAAgE;AAC3F,SAAO;AACT;AAEO,MAAM,kBAAkB,CAC7B,YACA,eACsD;AACtD,UAAQ,YAAA;AAAA,IACN,KAAK;AACH,aAAO,oBAAoB,UAAU;AAAA,IACvC,KAAK;AACH,aAAO,oBAAoB,UAAU;AAAA,IACvC;AACE,YAAM,IAAI,MAAM,gCAAgC,UAAU,EAAE;AAAA,EAAA;AAElE;;;;"}

package/dist/cjs/json-to-oas.d.cts

@@ -0,0 +1,9 @@
+import type { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
+import type { JSONSchema } from "zod/v4/core";
+type OASVersion = "3.0" | "3.1";
+export declare const getOASVersion: (documentObject: {
+	openapiObject: Partial<OpenAPIV3.Document | OpenAPIV3_1.Document>;
+}) => OASVersion;
+export declare const jsonSchemaToOAS_3_0: (jsonSchema: JSONSchema.BaseSchema) => OpenAPIV3.SchemaObject;
+export declare const jsonSchemaToOAS: (jsonSchema: JSONSchema.BaseSchema, oasVersion: OASVersion) => OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject;
+export {};