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

package/dist/esm/zod-to-json.js

@@ -0,0 +1,93 @@
+import { $ZodRegistry, toJSONSchema, $ZodType } from "zod/v4/core";
+import { getReferenceUri } from "./utils.js";
+const SCHEMA_REGISTRY_ID_PLACEHOLDER = "__SCHEMA__ID__PLACEHOLDER__";
+const SCHEMA_URI_PLACEHOLDER = "__SCHEMA__PLACEHOLDER__";
+function isZodDate(entity) {
+  return entity instanceof $ZodType && entity._zod.def.type === "date";
+}
+function isZodUnion(entity) {
+  return entity instanceof $ZodType && entity._zod.def.type === "union";
+}
+function isZodUndefined(entity) {
+  return entity instanceof $ZodType && entity._zod.def.type === "undefined";
+}
+const getOverride = (ctx, io) => {
+  if (isZodUnion(ctx.zodSchema)) {
+    ctx.jsonSchema.anyOf = ctx.jsonSchema.anyOf?.filter((schema) => Object.keys(schema).length > 0);
+  }
+  if (isZodDate(ctx.zodSchema)) {
+    if (io === "output") {
+      ctx.jsonSchema.type = "string";
+      ctx.jsonSchema.format = "date-time";
+    }
+  }
+  if (isZodUndefined(ctx.zodSchema)) {
+    if (io === "output") {
+      ctx.jsonSchema.type = "null";
+    }
+  }
+};
+const deleteInvalidProperties = (schema) => {
+  const object = { ...schema };
+  delete object.id;
+  delete object.$schema;
+  delete object.$id;
+  return object;
+};
+const zodSchemaToJson = (zodSchema, registry, io, config) => {
+  const schemaRegistryEntry = registry.get(zodSchema);
+  if (schemaRegistryEntry?.id) {
+    return { $ref: getReferenceUri(schemaRegistryEntry.id) };
+  }
+  const tempRegistry = new $ZodRegistry();
+  tempRegistry.add(zodSchema, { id: SCHEMA_REGISTRY_ID_PLACEHOLDER });
+  const {
+    schemas: { [SCHEMA_REGISTRY_ID_PLACEHOLDER]: result }
+  } = toJSONSchema(tempRegistry, {
+    ...config,
+    io,
+    target: config.target,
+    metadata: registry,
+    unrepresentable: config.unrepresentable ?? "any",
+    cycles: "ref",
+    reused: "inline",
+    /**
+     * The uri option only allows customizing the base path of the `$ref`, and it automatically appends a path to it.
+     * As a workaround, we set a placeholder that looks something like this.
+     * @see jsonSchemaReplaceRef
+     * @see https://github.com/colinhacks/zod/issues/4750
+     */
+    uri: () => SCHEMA_URI_PLACEHOLDER,
+    override: config.override ?? ((ctx) => getOverride(ctx, io))
+  });
+  const jsonSchema = deleteInvalidProperties(result);
+  return JSON.parse(JSON.stringify(jsonSchema), (__key, value) => {
+    if (typeof value === "string" && value.startsWith(SCHEMA_URI_PLACEHOLDER)) {
+      return getReferenceUri(value.slice(SCHEMA_URI_PLACEHOLDER.length));
+    }
+    return value;
+  });
+};
+const zodRegistryToJson = (registry, io, config) => {
+  const result = toJSONSchema(registry, {
+    ...config,
+    io,
+    target: config.target,
+    metadata: registry,
+    unrepresentable: config.unrepresentable ?? "any",
+    cycles: "ref",
+    reused: "inline",
+    uri: (id) => getReferenceUri(id),
+    override: config.override ?? ((ctx) => getOverride(ctx, io))
+  }).schemas;
+  const jsonSchemas = {};
+  for (const id in result) {
+    jsonSchemas[id] = deleteInvalidProperties(result[id]);
+  }
+  return jsonSchemas;
+};
+export {
+  zodRegistryToJson,
+  zodSchemaToJson
+};
+//# sourceMappingURL=zod-to-json.js.map

package/dist/esm/zod-to-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-to-json.js","sources":["../../src/zod-to-json.ts"],"sourcesContent":["import type {\n  $ZodDate,\n  $ZodUndefined,\n  $ZodUnion,\n  JSONSchema,\n  RegistryToJSONSchemaParams,\n} from 'zod/v4/core'\nimport { $ZodRegistry, $ZodType, toJSONSchema } from 'zod/v4/core'\nimport type { SchemaRegistryMeta } from './registry'\nimport { getReferenceUri } from './utils'\n\nconst SCHEMA_REGISTRY_ID_PLACEHOLDER = '__SCHEMA__ID__PLACEHOLDER__'\nconst SCHEMA_URI_PLACEHOLDER = '__SCHEMA__PLACEHOLDER__'\n\nfunction isZodDate(entity: unknown): entity is $ZodDate {\n  return entity instanceof $ZodType && entity._zod.def.type === 'date'\n}\n\nfunction isZodUnion(entity: unknown): entity is $ZodUnion {\n  return entity instanceof $ZodType && entity._zod.def.type === 'union'\n}\n\nfunction isZodUndefined(entity: unknown): entity is $ZodUndefined {\n  return entity instanceof $ZodType && entity._zod.def.type === 'undefined'\n}\n\nconst getOverride = (\n  ctx: {\n    zodSchema: $ZodType\n    jsonSchema: JSONSchema.BaseSchema\n  },\n  io: 'input' | 'output',\n) => {\n  if (isZodUnion(ctx.zodSchema)) {\n    // Filter unrepresentable types in unions\n    // TODO: Should be fixed upstream and not merged in this plugin.\n    // Remove when passed: https://github.com/colinhacks/zod/pull/5013\n    ctx.jsonSchema.anyOf = ctx.jsonSchema.anyOf?.filter((schema) => Object.keys(schema).length > 0)\n  }\n\n  if (isZodDate(ctx.zodSchema)) {\n    // Allow dates to be represented as strings in output schemas\n    if (io === 'output') {\n      ctx.jsonSchema.type = 'string'\n      ctx.jsonSchema.format = 'date-time'\n    }\n  }\n\n  if (isZodUndefined(ctx.zodSchema)) {\n    // Allow undefined to be represented as null in output schemas\n    if (io === 'output') {\n      ctx.jsonSchema.type = 'null'\n    }\n  }\n}\n\nexport type ZodToJsonConfig = {} & Omit<\n  RegistryToJSONSchemaParams,\n  'io' | 'metadata' | 'cycles' | 'reused' | 'uri'\n>\n\nconst deleteInvalidProperties: (\n  schema: JSONSchema.BaseSchema,\n) => Omit<JSONSchema.BaseSchema, 'id' | '$schema'> = (schema) => {\n  const object = { ...schema }\n\n  delete object.id\n  delete object.$schema\n\n  // ToDo added in newer zod\n  delete object.$id\n\n  return object\n}\n\nexport const zodSchemaToJson: (\n  zodSchema: $ZodType,\n  registry: $ZodRegistry<SchemaRegistryMeta>,\n  io: 'input' | 'output',\n  config: ZodToJsonConfig,\n) => ReturnType<typeof deleteInvalidProperties> = (zodSchema, registry, io, config) => {\n  /**\n   * Checks whether the provided schema is registered in the given registry.\n   * If it is present and has an `id`, it can be referenced as component.\n   *\n   * @see https://github.com/turkerdev/fastify-type-provider-zod/issues/173\n   */\n  const schemaRegistryEntry = registry.get(zodSchema)\n  if (schemaRegistryEntry?.id) {\n    return { $ref: getReferenceUri(schemaRegistryEntry.id) }\n  }\n\n  /**\n   * Unfortunately, at the time of writing, there is no way to generate a schema with `$ref`\n   * using `toJSONSchema` and a zod schema.\n   *\n   * As a workaround, we create a zod registry containing only the specific schema we want to convert.\n   *\n   * @see https://github.com/colinhacks/zod/issues/4281\n   */\n  const tempRegistry = new $ZodRegistry<SchemaRegistryMeta>()\n  tempRegistry.add(zodSchema, { id: SCHEMA_REGISTRY_ID_PLACEHOLDER })\n\n  const {\n    schemas: { [SCHEMA_REGISTRY_ID_PLACEHOLDER]: result },\n  } = toJSONSchema(tempRegistry, {\n    ...config,\n    io,\n    target: config.target,\n    metadata: registry,\n    unrepresentable: config.unrepresentable ?? 'any',\n    cycles: 'ref',\n    reused: 'inline',\n    /**\n     * The uri option only allows customizing the base path of the `$ref`, and it automatically appends a path to it.\n     * As a workaround, we set a placeholder that looks something like this.\n     * @see jsonSchemaReplaceRef\n     * @see https://github.com/colinhacks/zod/issues/4750\n     */\n    uri: () => SCHEMA_URI_PLACEHOLDER,\n    override: config.override ?? ((ctx) => getOverride(ctx, io)),\n  })\n\n  const jsonSchema = deleteInvalidProperties(result)\n\n  /**\n   * Replace the previous generated placeholders with the final `$ref` value\n   */\n  return JSON.parse(JSON.stringify(jsonSchema), (__key, value) => {\n    if (typeof value === 'string' && value.startsWith(SCHEMA_URI_PLACEHOLDER)) {\n      return getReferenceUri(value.slice(SCHEMA_URI_PLACEHOLDER.length))\n    }\n    return value\n  }) as typeof result\n}\n\nexport const zodRegistryToJson: (\n  registry: $ZodRegistry<SchemaRegistryMeta>,\n  io: 'input' | 'output',\n  config: ZodToJsonConfig,\n) => Record<string, JSONSchema.BaseSchema> = (registry, io, config) => {\n  const result = toJSONSchema(registry, {\n    ...config,\n    io,\n    target: config.target,\n    metadata: registry,\n    unrepresentable: config.unrepresentable ?? 'any',\n    cycles: 'ref',\n    reused: 'inline',\n    uri: (id) => getReferenceUri(id),\n    override: config.override ?? ((ctx) => getOverride(ctx, io)),\n  }).schemas\n\n  const jsonSchemas: Record<string, JSONSchema.BaseSchema> = {}\n  for (const id in result) {\n    jsonSchemas[id] = deleteInvalidProperties(result[id])\n  }\n\n  return jsonSchemas\n}\n"],"names":[],"mappings":";;AAWA,MAAM,iCAAiC;AACvC,MAAM,yBAAyB;AAE/B,SAAS,UAAU,QAAqC;AACtD,SAAO,kBAAkB,YAAY,OAAO,KAAK,IAAI,SAAS;AAChE;AAEA,SAAS,WAAW,QAAsC;AACxD,SAAO,kBAAkB,YAAY,OAAO,KAAK,IAAI,SAAS;AAChE;AAEA,SAAS,eAAe,QAA0C;AAChE,SAAO,kBAAkB,YAAY,OAAO,KAAK,IAAI,SAAS;AAChE;AAEA,MAAM,cAAc,CAClB,KAIA,OACG;AACH,MAAI,WAAW,IAAI,SAAS,GAAG;AAI7B,QAAI,WAAW,QAAQ,IAAI,WAAW,OAAO,OAAO,CAAC,WAAW,OAAO,KAAK,MAAM,EAAE,SAAS,CAAC;AAAA,EAChG;AAEA,MAAI,UAAU,IAAI,SAAS,GAAG;AAE5B,QAAI,OAAO,UAAU;AACnB,UAAI,WAAW,OAAO;AACtB,UAAI,WAAW,SAAS;AAAA,IAC1B;AAAA,EACF;AAEA,MAAI,eAAe,IAAI,SAAS,GAAG;AAEjC,QAAI,OAAO,UAAU;AACnB,UAAI,WAAW,OAAO;AAAA,IACxB;AAAA,EACF;AACF;AAOA,MAAM,0BAE+C,CAAC,WAAW;AAC/D,QAAM,SAAS,EAAE,GAAG,OAAA;AAEpB,SAAO,OAAO;AACd,SAAO,OAAO;AAGd,SAAO,OAAO;AAEd,SAAO;AACT;AAEO,MAAM,kBAKqC,CAAC,WAAW,UAAU,IAAI,WAAW;AAOrF,QAAM,sBAAsB,SAAS,IAAI,SAAS;AAClD,MAAI,qBAAqB,IAAI;AAC3B,WAAO,EAAE,MAAM,gBAAgB,oBAAoB,EAAE,EAAA;AAAA,EACvD;AAUA,QAAM,eAAe,IAAI,aAAA;AACzB,eAAa,IAAI,WAAW,EAAE,IAAI,gCAAgC;AAElE,QAAM;AAAA,IACJ,SAAS,EAAE,CAAC,8BAA8B,GAAG,OAAA;AAAA,EAAO,IAClD,aAAa,cAAc;AAAA,IAC7B,GAAG;AAAA,IACH;AAAA,IACA,QAAQ,OAAO;AAAA,IACf,UAAU;AAAA,IACV,iBAAiB,OAAO,mBAAmB;AAAA,IAC3C,QAAQ;AAAA,IACR,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOR,KAAK,MAAM;AAAA,IACX,UAAU,OAAO,aAAa,CAAC,QAAQ,YAAY,KAAK,EAAE;AAAA,EAAA,CAC3D;AAED,QAAM,aAAa,wBAAwB,MAAM;AAKjD,SAAO,KAAK,MAAM,KAAK,UAAU,UAAU,GAAG,CAAC,OAAO,UAAU;AAC9D,QAAI,OAAO,UAAU,YAAY,MAAM,WAAW,sBAAsB,GAAG;AACzE,aAAO,gBAAgB,MAAM,MAAM,uBAAuB,MAAM,CAAC;AAAA,IACnE;AACA,WAAO;AAAA,EACT,CAAC;AACH;AAEO,MAAM,oBAIgC,CAAC,UAAU,IAAI,WAAW;AACrE,QAAM,SAAS,aAAa,UAAU;AAAA,IACpC,GAAG;AAAA,IACH;AAAA,IACA,QAAQ,OAAO;AAAA,IACf,UAAU;AAAA,IACV,iBAAiB,OAAO,mBAAmB;AAAA,IAC3C,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,KAAK,CAAC,OAAO,gBAAgB,EAAE;AAAA,IAC/B,UAAU,OAAO,aAAa,CAAC,QAAQ,YAAY,KAAK,EAAE;AAAA,EAAA,CAC3D,EAAE;AAEH,QAAM,cAAqD,CAAA;AAC3D,aAAW,MAAM,QAAQ;AACvB,gBAAY,EAAE,IAAI,wBAAwB,OAAO,EAAE,CAAC;AAAA,EACtD;AAEA,SAAO;AACT;"}

package/package.json

@@ -1,61 +1,78 @@
 {
-    "name": "@bram-dc/fastify-type-provider-zod",
-    "version": "5.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"
+  "name": "@bram-dc/fastify-type-provider-zod",
+  "version": "7.0.0",
+  "description": "Zod Type Provider for Fastify@5",
+  "type": "module",
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/cjs/index.d.cts",
+  "exports": {
+    "require": {
+      "types": "./dist/cjs/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
     },
-    "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"
+    "default": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/index.js"
     }
-}
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "prepare": "npm run build",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage",
+    "test:ci": "npm run build && npm run typescript && npm run test:coverage",
+    "lint": "biome check . && tsc --noEmit",
+    "lint:fix": "biome check --write .",
+    "typescript": "tsd",
+    "prepublishOnly": "npm run build"
+  },
+  "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.2.0"
+  },
+  "peerDependencies": {
+    "@fastify/swagger": ">=9.5.1",
+    "fastify": "^5.5.0",
+    "openapi-types": "^12.1.3",
+    "zod": ">=4.1.5"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.0",
+    "@fastify/swagger": "^9.5.2",
+    "@fastify/swagger-ui": "^5.2.3",
+    "@kibertoad/biome-config": "^2.0.0",
+    "@readme/openapi-parser": "^5.0.2",
+    "@types/node": "^24.9.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "fastify": "^5.6.1",
+    "fastify-plugin": "^5.0.1",
+    "oas-validator": "^5.0.8",
+    "tsd": "^0.33.0",
+    "typescript": "^5.9.3",
+    "unplugin-isolated-decl": "^0.15.2",
+    "vitest": "^3.2.4",
+    "zod": "^4.2.0"
+  },
+  "tsd": {
+    "directory": "types"
+  }
+}

package/src/core.ts

@@ -0,0 +1,228 @@
+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, output } from 'zod/v4/core'
+import { $ZodType, globalRegistry, safeDecode, safeEncode } from 'zod/v4/core'
+import { createValidationError, InvalidSchemaError, ResponseSerializationError } from './errors'
+import { generateIORegistries, type SchemaRegistryMeta } from './registry'
+import { assertIsOpenAPIObject, getJSONSchemaTarget } from './utils'
+import { type ZodToJsonConfig, zodRegistryToJson, zodSchemaToJson } from './zod-to-json'
+
+type FreeformRecord = Record<string, any>
+
+const defaultSkipList = [
+  '/documentation/',
+  '/documentation/initOAuth',
+  '/documentation/json',
+  '/documentation/uiConfig',
+  '/documentation/yaml',
+  '/documentation/*',
+  '/documentation/static/*',
+]
+
+export interface ZodTypeProvider extends FastifyTypeProvider {
+  validator: this['schema'] extends $ZodType ? output<this['schema']> : unknown
+  serializer: this['schema'] extends $ZodType ? output<this['schema']> : unknown
+}
+
+interface Schema extends FastifySchema {
+  hide?: boolean
+}
+
+type CreateJsonSchemaTransformOptions = {
+  skipList?: readonly string[]
+  schemaRegistry?: $ZodRegistry<SchemaRegistryMeta>
+  zodToJsonConfig?: ZodToJsonConfig
+}
+
+export const createJsonSchemaTransform = ({
+  skipList = defaultSkipList,
+  schemaRegistry = globalRegistry,
+  zodToJsonConfig = {},
+}: CreateJsonSchemaTransformOptions): SwaggerTransform<Schema> => {
+  return (document) => {
+    assertIsOpenAPIObject(document)
+
+    const { schema, url } = document
+
+    if (!schema) {
+      return {
+        schema,
+        url,
+      }
+    }
+
+    const target = getJSONSchemaTarget(document.openapiObject.openapi)
+    const config = {
+      target,
+      ...zodToJsonConfig,
+    }
+
+    const { inputRegistry, outputRegistry } = generateIORegistries(schemaRegistry)
+
+    const { response, headers, querystring, body, params, hide, ...rest } = schema
+
+    const transformed: FreeformRecord = {}
+
+    if (skipList.includes(url) || hide) {
+      transformed.hide = true
+      return { schema: transformed, url }
+    }
+
+    const zodSchemas: FreeformRecord = { headers, querystring, body, params }
+
+    for (const prop in zodSchemas) {
+      const zodSchema = zodSchemas[prop]
+      if (zodSchema) {
+        transformed[prop] = zodSchemaToJson(zodSchema, inputRegistry, 'input', config)
+      }
+    }
+
+    if (response) {
+      transformed.response = {}
+
+      for (const prop in response as any) {
+        const zodSchema = resolveSchema((response as any)[prop])
+
+        transformed.response[prop] = zodSchemaToJson(zodSchema, outputRegistry, 'output', config)
+      }
+    }
+
+    for (const prop in rest) {
+      const meta = rest[prop as keyof typeof rest]
+      if (meta) {
+        transformed[prop] = meta
+      }
+    }
+
+    return { schema: transformed, url }
+  }
+}
+
+export const jsonSchemaTransform: SwaggerTransform<Schema> = createJsonSchemaTransform({})
+
+type CreateJsonSchemaTransformObjectOptions = {
+  schemaRegistry?: $ZodRegistry<SchemaRegistryMeta>
+  zodToJsonConfig?: ZodToJsonConfig
+}
+
+export const createJsonSchemaTransformObject =
+  ({
+    schemaRegistry = globalRegistry,
+    zodToJsonConfig = {},
+  }: CreateJsonSchemaTransformObjectOptions): SwaggerTransformObject =>
+  (document) => {
+    assertIsOpenAPIObject(document)
+
+    const target = getJSONSchemaTarget(document.openapiObject.openapi)
+    const config = {
+      target,
+      ...zodToJsonConfig,
+    }
+
+    const { inputRegistry, outputRegistry } = generateIORegistries(schemaRegistry)
+    const inputSchemas = zodRegistryToJson(inputRegistry, 'input', config)
+    const outputSchemas = zodRegistryToJson(outputRegistry, 'output', config)
+
+    return {
+      ...document.openapiObject,
+      components: {
+        ...document.openapiObject.components,
+        schemas: {
+          ...document.openapiObject.components?.schemas,
+          ...inputSchemas,
+          ...outputSchemas,
+        },
+      },
+    } as ReturnType<SwaggerTransformObject>
+  }
+
+export const jsonSchemaTransformObject: SwaggerTransformObject = createJsonSchemaTransformObject({})
+
+export const validatorCompiler: FastifySchemaCompiler<$ZodType> =
+  ({ schema }) =>
+  (data) => {
+    const result = safeDecode(schema, data)
+    if (result.error) {
+      return { error: createValidationError(result.error) as unknown as Error }
+    }
+
+    return { value: result.data }
+  }
+
+function resolveSchema(maybeSchema: $ZodType | { properties: $ZodType }): $ZodType {
+  if (maybeSchema instanceof $ZodType) {
+    return maybeSchema as $ZodType
+  }
+  if ('properties' in maybeSchema && maybeSchema.properties instanceof $ZodType) {
+    return maybeSchema.properties as $ZodType
+  }
+  throw new InvalidSchemaError(JSON.stringify(maybeSchema))
+}
+
+type ReplacerFunction = (this: any, key: string, value: any) => any
+
+export type ZodSerializerCompilerOptions = {
+  replacer?: ReplacerFunction
+}
+
+export const createSerializerCompiler =
+  (
+    options?: ZodSerializerCompilerOptions,
+  ): FastifySerializerCompiler<$ZodType | { properties: $ZodType }> =>
+  ({ schema: maybeSchema, method, url }) =>
+  (data) => {
+    const schema = resolveSchema(maybeSchema)
+
+    const result = safeEncode(schema, data)
+    if (result.error) {
+      throw new ResponseSerializationError(method, url, { cause: result.error })
+    }
+
+    return JSON.stringify(result.data, options?.replacer)
+  }
+
+export const serializerCompiler: ReturnType<typeof createSerializerCompiler> =
+  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>

package/src/errors.ts

@@ -0,0 +1,99 @@
+import createError, { 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 const InvalidSchemaError: FastifyErrorConstructor<
+  {
+    code: string
+  },
+  [string]
+> = createError<[string]>('FST_ERR_INVALID_SCHEMA', 'Invalid schema passed: %s', 500)
+
+const ZodFastifySchemaValidationErrorSymbol: symbol = Symbol.for('ZodFastifySchemaValidationError')
+
+export type ZodFastifySchemaValidationError = FastifySchemaValidationError & {
+  [ZodFastifySchemaValidationErrorSymbol]: true
+}
+
+const ResponseSerializationBase: FastifyErrorConstructor<
+  {
+    code: string
+  },
+  [
+    {
+      cause: $ZodError
+    },
+  ]
+> = createError<[{ cause: $ZodError }]>(
+  'FST_ERR_RESPONSE_SERIALIZATION',
+  "Response doesn't match the schema",
+  500,
+)
+
+export class ResponseSerializationError extends ResponseSerializationBase {
+  cause!: $ZodError
+
+  constructor(
+    public method: string,
+    public url: string,
+    options: { cause: $ZodError },
+  ) {
+    super({ cause: options.cause })
+
+    this.cause = options.cause
+  }
+}
+
+export function isResponseSerializationError(value: unknown): value is ResponseSerializationError {
+  return 'method' in (value as ResponseSerializationError)
+}
+
+function isZodFastifySchemaValidationError(
+  error: unknown,
+): error is ZodFastifySchemaValidationError {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    (error as ZodFastifySchemaValidationError)[ZodFastifySchemaValidationErrorSymbol] === true
+  )
+}
+
+export function hasZodFastifySchemaValidationErrors(
+  error: unknown,
+): error is Omit<FastifyError, 'validation'> & { validation: ZodFastifySchemaValidationError[] } {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'validation' in error &&
+    Array.isArray(error.validation) &&
+    error.validation.length > 0 &&
+    isZodFastifySchemaValidationError(error.validation[0])
+  )
+}
+
+function omit<T extends object, K extends keyof T>(obj: T, keys: readonly K[]): Omit<T, K> {
+  const result = {} as Omit<T, K>
+  for (const key of Object.keys(obj) as Array<keyof T>) {
+    if (!keys.includes(key as K)) {
+      // @ts-expect-error
+      result[key] = obj[key]
+    }
+  }
+  return result
+}
+
+export function createValidationError(error: $ZodError): ZodFastifySchemaValidationError[] {
+  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']),
+      },
+    }
+  })
+}

package/src/index.ts

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

package/src/registry.ts

@@ -0,0 +1,64 @@
+import { $ZodRegistry, type $ZodType } from 'zod/v4/core'
+
+export type SchemaRegistryMeta = {
+  id?: string | undefined
+  [key: string]: unknown
+}
+
+const getSchemaId = (id: string, io: 'input' | 'output'): string => {
+  return io === 'input' ? `${id}Input` : id
+}
+
+// A WeakMap that falls back to another WeakMap when a key is not found, this is to ensure nested metadata is properly resolved
+class WeakMapWithFallback extends WeakMap<$ZodType, SchemaRegistryMeta> {
+  constructor(private fallback: WeakMap<$ZodType, SchemaRegistryMeta>) {
+    super()
+  }
+
+  get(key: $ZodType): SchemaRegistryMeta | undefined {
+    return super.get(key) ?? this.fallback.get(key)
+  }
+
+  has(key: $ZodType): boolean {
+    return super.has(key) || this.fallback.has(key)
+  }
+}
+
+const copyRegistry = (
+  inputRegistry: $ZodRegistry<SchemaRegistryMeta>,
+  idReplaceFn: (id: string) => string,
+): $ZodRegistry<SchemaRegistryMeta> => {
+  const outputRegistry = new $ZodRegistry<SchemaRegistryMeta>()
+
+  outputRegistry._map = new WeakMapWithFallback(inputRegistry._map)
+
+  inputRegistry._idmap.forEach((schema, id) => {
+    outputRegistry.add(schema, {
+      ...inputRegistry._map.get(schema),
+      id: idReplaceFn(id),
+    })
+  })
+
+  return outputRegistry
+}
+
+export const generateIORegistries = (
+  baseRegistry: $ZodRegistry<SchemaRegistryMeta>,
+): {
+  inputRegistry: $ZodRegistry<SchemaRegistryMeta>
+  outputRegistry: $ZodRegistry<SchemaRegistryMeta>
+} => {
+  const inputRegistry = copyRegistry(baseRegistry, (id) => getSchemaId(id, 'input'))
+  const outputRegistry = copyRegistry(baseRegistry, (id) => getSchemaId(id, 'output'))
+
+  // Detect colliding schemas
+  inputRegistry._idmap.forEach((_, id) => {
+    if (outputRegistry._idmap.has(id)) {
+      throw new Error(
+        `Collision detected for schema "${id}". There is already an input schema with the same name.`,
+      )
+    }
+  })
+
+  return { inputRegistry, outputRegistry }
+}