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

package/src/utils.ts

@@ -0,0 +1,33 @@
+import type { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'
+
+type SwaggerObject = {
+  swaggerObject: Partial<OpenAPIV2.Document>
+}
+
+type OpenAPIObject = {
+  openapiObject: Partial<OpenAPIV3.Document | OpenAPIV3_1.Document>
+}
+
+export const assertIsOpenAPIObject: (
+  obj: SwaggerObject | OpenAPIObject,
+) => asserts obj is OpenAPIObject = (obj) => {
+  if ('swaggerObject' in obj) {
+    throw new Error('This package currently does not support component references for Swagger 2.0')
+  }
+}
+
+export type JSONSchemaTarget = 'draft-2020-12' | 'openapi-3.0'
+
+export const getReferenceUri = (input: string): string => {
+  const id = input.replace(/^#\/(?:\$defs|definitions|components\/schemas)\//, '')
+
+  return `#/components/schemas/${id}`
+}
+
+export const getJSONSchemaTarget = (version = '3.0.0'): JSONSchemaTarget => {
+  if (version.startsWith('3.0')) {
+    return 'openapi-3.0'
+  }
+
+  return 'draft-2020-12'
+}

package/src/zod-to-json.ts

@@ -0,0 +1,160 @@
+import type {
+  $ZodDate,
+  $ZodUndefined,
+  $ZodUnion,
+  JSONSchema,
+  RegistryToJSONSchemaParams,
+} from 'zod/v4/core'
+import { $ZodRegistry, $ZodType, toJSONSchema } from 'zod/v4/core'
+import type { SchemaRegistryMeta } from './registry'
+import { getReferenceUri } from './utils'
+
+const SCHEMA_REGISTRY_ID_PLACEHOLDER = '__SCHEMA__ID__PLACEHOLDER__'
+const SCHEMA_URI_PLACEHOLDER = '__SCHEMA__PLACEHOLDER__'
+
+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 type ZodToJsonConfig = {} & Omit<
+  RegistryToJSONSchemaParams,
+  'io' | 'metadata' | 'cycles' | 'reused' | 'uri'
+>
+
+const deleteInvalidProperties: (
+  schema: JSONSchema.BaseSchema,
+) => Omit<JSONSchema.BaseSchema, 'id' | '$schema'> = (schema) => {
+  const object = { ...schema }
+
+  delete object.id
+  delete object.$schema
+
+  // ToDo added in newer zod
+  delete object.$id
+
+  return object
+}
+
+export const zodSchemaToJson: (
+  zodSchema: $ZodType,
+  registry: $ZodRegistry<SchemaRegistryMeta>,
+  io: 'input' | 'output',
+  config: ZodToJsonConfig,
+) => ReturnType<typeof deleteInvalidProperties> = (zodSchema, registry, io, config) => {
+  /**
+   * 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
+   */
+  const schemaRegistryEntry = registry.get(zodSchema)
+  if (schemaRegistryEntry?.id) {
+    return { $ref: getReferenceUri(schemaRegistryEntry.id) }
+  }
+
+  /**
+   * 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 tempRegistry = new $ZodRegistry<SchemaRegistryMeta>()
+  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)
+
+  /**
+   * Replace the previous generated placeholders with the final `$ref` value
+   */
+  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
+  }) as typeof result
+}
+
+export const zodRegistryToJson: (
+  registry: $ZodRegistry<SchemaRegistryMeta>,
+  io: 'input' | 'output',
+  config: ZodToJsonConfig,
+) => Record<string, JSONSchema.BaseSchema> = (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: Record<string, JSONSchema.BaseSchema> = {}
+  for (const id in result) {
+    jsonSchemas[id] = deleteInvalidProperties(result[id])
+  }
+
+  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;