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

package/src/json-to-oas.ts

@@ -0,0 +1,109 @@
+import type { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'
+import type { JSONSchema } from 'zod/v4/core'
+
+type OASVersion = '3.0' | '3.1'
+
+export const getOASVersion = (documentObject: {
+  openapiObject: Partial<OpenAPIV3.Document | OpenAPIV3_1.Document>
+}): OASVersion => {
+  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')
+}
+
+export const jsonSchemaToOAS_3_0 = (jsonSchema: JSONSchema.BaseSchema): OpenAPIV3.SchemaObject => {
+  const clone: any = { ...jsonSchema }
+
+  if (clone.type === 'null') {
+    clone.nullable = true
+    delete clone.type
+    clone.enum = [null]
+  }
+
+  if (Array.isArray(clone.prefixItems)) {
+    const tuple = clone.prefixItems as JSONSchema.BaseSchema[]
+
+    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 !== undefined) {
+    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: any): any =>
+    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 as any)
+    }
+  }
+
+  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 as OpenAPIV3.SchemaObject
+}
+
+const jsonSchemaToOAS_3_1 = (jsonSchema: JSONSchema.BaseSchema): OpenAPIV3_1.SchemaObject => {
+  return jsonSchema as OpenAPIV3_1.SchemaObject
+}
+
+export const jsonSchemaToOAS = (
+  jsonSchema: JSONSchema.BaseSchema,
+  oasVersion: OASVersion,
+): OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject => {
+  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}`)
+  }
+}

package/src/zod-to-json.ts

@@ -0,0 +1,150 @@
+import type { $ZodDate, $ZodUndefined, $ZodUnion, JSONSchema } from 'zod/v4/core'
+import { $ZodRegistry, $ZodType, toJSONSchema } from 'zod/v4/core'
+
+const getSchemaId = (id: string, io: 'input' | 'output') => {
+  return io === 'input' ? `${id}Input` : id
+}
+
+const getReferenceUri = (id: string, io: 'input' | 'output') => {
+  return `#/components/schemas/${getSchemaId(id, io)}`
+}
+
+function isZodDate(entity: unknown): entity is $ZodDate {
+  return entity instanceof $ZodType && entity._zod.def.type === 'date'
+}
+
+function isZodUnion(entity: unknown): entity is $ZodUnion {
+  return entity instanceof $ZodType && entity._zod.def.type === 'union'
+}
+
+function isZodUndefined(entity: unknown): entity is $ZodUndefined {
+  return entity instanceof $ZodType && entity._zod.def.type === 'undefined'
+}
+
+const getOverride = (
+  ctx: {
+    zodSchema: $ZodType
+    jsonSchema: JSONSchema.BaseSchema
+  },
+  io: 'input' | 'output',
+) => {
+  if (isZodUnion(ctx.zodSchema)) {
+    // Filter unrepresentable types in unions
+    // TODO: Should be fixed upstream and not merged in this plugin.
+    // Remove when passed: https://github.com/colinhacks/zod/pull/5013
+    ctx.jsonSchema.anyOf = ctx.jsonSchema.anyOf?.filter((schema) => Object.keys(schema).length > 0)
+  }
+
+  if (isZodDate(ctx.zodSchema)) {
+    // Allow dates to be represented as strings in output schemas
+    if (io === 'output') {
+      ctx.jsonSchema.type = 'string'
+      ctx.jsonSchema.format = 'date-time'
+    }
+  }
+
+  if (isZodUndefined(ctx.zodSchema)) {
+    // Allow undefined to be represented as null in output schemas
+    if (io === 'output') {
+      ctx.jsonSchema.type = 'null'
+    }
+  }
+}
+
+export const zodSchemaToJson: (
+  zodSchema: $ZodType,
+  registry: $ZodRegistry<{ id?: string }>,
+  io: 'input' | 'output',
+) => JSONSchema.BaseSchema = (zodSchema, registry, io) => {
+  const schemaRegistryEntry = registry.get(zodSchema)
+
+  /**
+   * Checks whether the provided schema is registered in the given registry.
+   * If it is present and has an `id`, it can be referenced as component.
+   *
+   * @see https://github.com/turkerdev/fastify-type-provider-zod/issues/173
+   */
+  if (schemaRegistryEntry?.id) {
+    return {
+      $ref: getReferenceUri(schemaRegistryEntry.id, io),
+    }
+  }
+
+  /**
+   * Unfortunately, at the time of writing, there is no way to generate a schema with `$ref`
+   * using `toJSONSchema` and a zod schema.
+   *
+   * As a workaround, we create a zod registry containing only the specific schema we want to convert.
+   *
+   * @see https://github.com/colinhacks/zod/issues/4281
+   */
+  const tempID = 'GEN'
+  const tempRegistry = new $ZodRegistry<{ id?: string }>()
+  tempRegistry.add(zodSchema, { id: tempID })
+
+  const {
+    schemas: { [tempID]: result },
+  } = toJSONSchema(tempRegistry, {
+    target: 'draft-2020-12',
+    metadata: registry,
+    io,
+    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:
+     *
+     * |       marker          | always added by zod | meta.id |
+     * |__SCHEMA__PLACEHOLDER__|      #/$defs/       | User    |
+     *
+     * @example `__SCHEMA__PLACEHOLDER__#/$defs/User"`
+     * @example `__SCHEMA__PLACEHOLDER__#/$defs/Group"`
+     *
+     * @see jsonSchemaReplaceRef
+     * @see https://github.com/colinhacks/zod/issues/4750
+     */
+    uri: () => `__SCHEMA__PLACEHOLDER__`,
+    override: (ctx) => getOverride(ctx, io),
+  })
+
+  const jsonSchema = { ...result }
+  delete jsonSchema.id
+
+  /**
+   * Replace the previous generated placeholders with the final `$ref` value
+   */
+  const jsonSchemaReplaceRef = JSON.stringify(jsonSchema).replaceAll(
+    /"__SCHEMA__PLACEHOLDER__#\/\$defs\/(.+?)"/g,
+    (_, id) => `"${getReferenceUri(id, io)}"`,
+  )
+
+  return JSON.parse(jsonSchemaReplaceRef) as typeof result
+}
+
+export const zodRegistryToJson: (
+  registry: $ZodRegistry<{ id?: string }>,
+  io: 'input' | 'output',
+) => Record<string, JSONSchema.BaseSchema> = (registry, io) => {
+  const result = toJSONSchema(registry, {
+    target: 'draft-2020-12',
+    io,
+    unrepresentable: 'any',
+    cycles: 'ref',
+    reused: 'inline',
+    uri: (id) => getReferenceUri(id, io),
+    override: (ctx) => getOverride(ctx, io),
+  }).schemas
+
+  const jsonSchemas: Record<string, JSONSchema.BaseSchema> = {}
+  for (const id in result) {
+    const jsonSchema = { ...result[id] }
+
+    delete jsonSchema.id
+
+    jsonSchemas[getSchemaId(id, io)] = jsonSchema
+  }
+
+  return jsonSchemas
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isResponseSerializationError = exports.hasZodFastifySchemaValidationErrors = exports.InvalidSchemaError = exports.ResponseSerializationError = exports.createSerializerCompiler = exports.validatorCompiler = exports.serializerCompiler = exports.createJsonSchemaTransformObject = 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, "createJsonSchemaTransformObject", { enumerable: true, get: function () { return core_1.createJsonSchemaTransformObject; } });
-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

@@ -1,59 +0,0 @@
-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[];
-    schemaRegistry?: z.core.$ZodJSONSchemaRegistry;
-};
-export declare const createJsonSchemaTransform: ({ skipList, schemaRegistry, }: 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

@@ -1,121 +0,0 @@
-"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 createJsonSchemaTransform = ({ skipList = defaultSkipList, schemaRegistry = zod_1.z.globalRegistry, }) => {
-    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, {
-                    external: {
-                        registry: schemaRegistry,
-                        uri: (id) => `#/components/schemas/${id}`,
-                        defs: {},
-                    },
-                });
-            }
-        }
-        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, {
-                    external: {
-                        registry: schemaRegistry,
-                        uri: (id) => `#/components/schemas/${id}`,
-                        defs: {},
-                    },
-                });
-                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)({});
-const createJsonSchemaTransformObject = ({ schemaRegistry = zod_1.z.globalRegistry, }) => (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, {
-        uri: (id) => `#/components/schemas/${id}`,
-        external: {
-            registry: schemaRegistry,
-            uri: (id) => `#/components/schemas/${id}`,
-            defs: {},
-        },
-    });
-    return {
-        ...input.openapiObject,
-        components: {
-            ...input.openapiObject.components,
-            schemas: {
-                ...input.openapiObject.components?.schemas,
-                ...schemas,
-            },
-        },
-    };
-};
-exports.createJsonSchemaTransformObject = createJsonSchemaTransformObject;
-exports.jsonSchemaTransformObject = (0, exports.createJsonSchemaTransformObject)({});
-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

@@ -1,35 +0,0 @@
-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

@@ -1,43 +0,0 @@
-"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;