@orval/zod 8.33.0 → 8.35.0

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { ClientBuilder, ClientDependenciesBuilder, ClientGeneratorsBuilder, ContextSpec, GeneratorMutator, OpenApiParameterObject, OpenApiReferenceObject, OpenApiSchemaObject, PackageJson, ZodCoerceType, ZodVariantOption, ZodVersionOption } from "@orval/core";
+import { ClientBuilder, ClientDependenciesBuilder, ClientGeneratorsBuilder, ContextSpec, GeneratorMutator, GeneratorVerbOptions, OpenApiParameterObject, OpenApiReferenceObject, OpenApiSchemaObject, PackageJson, ZodCoerceType, ZodVariantOption, ZodVersionOption } from "@orval/core";
 //#region src/compatible-v4.d.ts
-declare const isZodVersionV4: (packageJson: PackageJson) => boolean;
+export declare const isZodVersionV4: (packageJson: PackageJson) => boolean;
 /**
  * Resolves whether to emit Zod 4-style output.
  *
@@ -11,13 +11,13 @@ declare const isZodVersionV4: (packageJson: PackageJson) => boolean;
  * still get the modern baseline. This keeps generation deterministic when a
  * target is pinned while preserving package-detection for `'auto'`.
  */
-declare const resolveIsZodV4: (version: ZodVersionOption | undefined, packageJson: PackageJson | undefined) => boolean;
-declare const assertZodTarget: ({ variant, isZodV4 }: {
+export declare const resolveIsZodV4: (version: ZodVersionOption | undefined, packageJson: PackageJson | undefined) => boolean;
+export declare const assertZodTarget: ({ variant, isZodV4 }: {
   variant: ZodVariantOption | undefined;
   isZodV4: boolean;
 }) => void;
-declare const getZodImportSource: (variant: ZodVariantOption | undefined) => "zod/mini" | "zod";
-declare const getZodTypeName: (variant: ZodVariantOption | undefined) => "ZodMiniType" | "ZodType";
+export declare const getZodImportSource: (variant: ZodVariantOption | undefined) => "zod/mini" | "zod";
+export declare const getZodTypeName: (variant: ZodVariantOption | undefined) => "ZodMiniType" | "ZodType";
 //#endregion
 //#region src/export-emitter.d.ts
 /**
@@ -70,12 +70,12 @@ interface ZodExportBlock {
  * or a recursive `zod.ZodType<X>` pin. See {@link ZodExportBlock} for what
  * this deliberately leaves to the caller.
  */
-declare const renderZodExport: (block: ZodExportBlock) => string;
+export declare const renderZodExport: (block: ZodExportBlock) => string;
 //#endregion
 //#region src/index.d.ts
-declare const getZodDependencies: ClientDependenciesBuilder;
-declare const predefinedZodFormats: Set<string>;
-interface ZodValidationSchemaDefinition {
+export declare const getZodDependencies: ClientDependenciesBuilder;
+export declare const predefinedZodFormats: Set<string>;
+export interface ZodValidationSchemaDefinition {
   functions: [string, unknown][];
   consts: string[];
 }
@@ -87,7 +87,7 @@ interface DateTimeOptions {
 interface TimeOptions {
   precision?: -1 | 0 | 1 | 2 | 3;
 }
-declare const generateZodValidationSchemaDefinition: (schema: OpenApiSchemaObject | OpenApiReferenceObject | undefined, context: ContextSpec, name: string, strict: boolean, isZodV4: boolean, rules?: {
+export declare const generateZodValidationSchemaDefinition: (schema: OpenApiSchemaObject | OpenApiReferenceObject | undefined, context: ContextSpec, name: string, strict: boolean, isZodV4: boolean, rules?: {
   required?: boolean;
   /**
    * Required keys inherited from sibling `allOf` members. Per JSON Schema /
@@ -138,7 +138,7 @@ declare const generateZodValidationSchemaDefinition: (schema: OpenApiSchemaObjec
  * every emitted validator. Exported so consumers can type their function with
  * `import type { ZodParamsContext } from 'orval'` instead of hand-writing it.
  */
-interface ZodParamsContext {
+export interface ZodParamsContext {
   /** The OpenAPI `operationId`, or `''` for shared component schemas. */
   operationId: string;
   /** `'schema'` is used for shared component schemas with no owning operation. */
@@ -150,16 +150,16 @@ interface ZodParamsContext {
   /** The Zod method being emitted, e.g. `'string'`, `'min'`, `'email'`. */
   validator: string;
 }
-interface ZodParamsInjection extends Pick<ZodParamsContext, 'operationId' | 'location' | 'schemaName'> {
+export interface ZodParamsInjection extends Pick<ZodParamsContext, 'operationId' | 'location' | 'schemaName'> {
   mutator: GeneratorMutator;
 }
-interface ZodMetaArgs {
+export interface ZodMetaArgs {
   id?: string;
   title?: string;
   description?: string;
   deprecated?: boolean;
 }
-declare const parseZodValidationSchemaDefinition: (input: ZodValidationSchemaDefinition, context: ContextSpec, coerceTypes: boolean | ZodCoerceType[] | undefined, strict: boolean, isZodV4: boolean, preprocess?: GeneratorMutator, paramsInjection?: ZodParamsInjection, variant?: ZodVariantOption, exactOptional?: boolean) => {
+export declare const parseZodValidationSchemaDefinition: (input: ZodValidationSchemaDefinition, context: ContextSpec, coerceTypes: boolean | ZodCoerceType[] | undefined, strict: boolean, isZodV4: boolean, preprocess?: GeneratorMutator, paramsInjection?: ZodParamsInjection, variant?: ZodVariantOption, exactOptional?: boolean) => {
   zod: string;
   consts: string;
   usedRefs: Set<string>;
@@ -178,16 +178,23 @@ declare const parseZodValidationSchemaDefinition: (input: ZodValidationSchemaDef
  *  3. If resolved to a concrete schema, inline it (same as `$ref`).
  *  4. If unresolved, external, or a generic parameter → return `{}`.
  */
-declare const dereference: (schema: OpenApiSchemaObject | OpenApiReferenceObject, context: ContextSpec) => OpenApiSchemaObject;
+export declare const dereference: (schema: OpenApiSchemaObject | OpenApiReferenceObject, context: ContextSpec) => OpenApiSchemaObject;
 /**
  * Generate zod schema for form-data request body.
  * Handles file type detection for top-level properties based on encoding.contentType
  * and contentMediaType. Mirrors type gen's resolveFormDataRootObject.
  */
-declare const generateFormDataZodSchema: (schema: OpenApiSchemaObject, context: ContextSpec, name: string, strict: boolean, isZodV4: boolean, encoding?: Record<string, {
+export declare const generateFormDataZodSchema: (schema: OpenApiSchemaObject, context: ContextSpec, name: string, strict: boolean, isZodV4: boolean, encoding?: Record<string, {
   contentType?: string;
 }>, useReusableSchemas?: boolean) => ZodValidationSchemaDefinition;
-declare const parseParameters: ({ data, context, operationName, isZodV4, strict, generate, useReusableSchemas }: {
+/** The success response is emitted as a plain `zod.object(...)`. */
+export declare const isObjectResponseSchema: (verbOptions: Pick<GeneratorVerbOptions, "verb" | "pathRoute" | "override">, context: ContextSpec) => boolean;
+/**
+ * A `<Operation>Response` schema that can be converted to JSON Schema is
+ * emitted for the success response.
+ */
+export declare const hasResponseSchema: (verbOptions: Pick<GeneratorVerbOptions, "verb" | "pathRoute" | "override">, context: ContextSpec) => boolean;
+export declare const parseParameters: ({ data, context, operationName, isZodV4, strict, generate, useReusableSchemas }: {
   data: (OpenApiParameterObject | OpenApiReferenceObject)[] | undefined;
   context: ContextSpec;
   operationName: string;
@@ -212,8 +219,8 @@ declare const parseParameters: ({ data, context, operationName, isZodV4, strict,
   queryParams: ZodValidationSchemaDefinition;
   params: ZodValidationSchemaDefinition;
 };
-declare const generateZod: ClientBuilder;
-declare const builder: () => () => ClientGeneratorsBuilder;
+export declare const generateZod: ClientBuilder;
+export declare const builder: () => () => ClientGeneratorsBuilder;
 //#endregion
-export { type ZodExportBlock, ZodMetaArgs, ZodParamsContext, ZodParamsInjection, ZodValidationSchemaDefinition, assertZodTarget, builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, getZodImportSource, getZodTypeName, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats, renderZodExport, resolveIsZodV4 };
+export { type ZodExportBlock, builder as default };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { EnumGeneration, assertSafeNumericConstraint, buildDynamicScope, buildInlineDynamicScope, camel, compareVersions, createLogger, generateMutator, getDynamicAnchorName, getEnumImplementation, getEnumMembers, getEnumValueInfo, getFormDataFieldFileType, getNumberWord, getRefInfo, getRequiredKeys, hasEnumMetadata, isBoolean, isDynamicReference, isNumber, isObject, isString, jsStringEscape, jsStringLiteralEscape, pascal, resolveDynamicRef, resolveRef, safeNumericConstraint, stringify } from "@orval/core";
+import { EnumGeneration, assertSafeNumericConstraint, buildDynamicScope, buildInlineDynamicScope, camel, compareVersions, createLogger, generateMutator, getDynamicAnchorName, getEnumImplementation, getEnumMembers, getEnumValueInfo, getFormDataFieldFileType, getNumberWord, getRefInfo, getRequiredKeys, hasEnumMetadata, isBoolean, isDynamicReference, isNumber, isObject, isSchemaNullable, isString, jsStringEscape, jsStringLiteralEscape, pascal, resolveDynamicRef, resolveRef, safeNumericConstraint, stringify } from "@orval/core";
 import jsesc from "jsesc";
 import { unique } from "remeda";
 //#region src/logger.ts
@@ -356,18 +356,12 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 		functions: [],
 		consts: []
 	};
-	const CHAINABLE_SIBLINGS = /* @__PURE__ */ new Set([
-		"nullable",
-		"default",
-		"description"
-	]);
+	const CHAINABLE_SIBLINGS = /* @__PURE__ */ new Set(["default", "description"]);
 	const isChainable = (k) => CHAINABLE_SIBLINGS.has(k);
 	const applyChainableSiblings = (functions, consts, siblingSchema) => {
 		const refRequired = rules?.required ?? false;
 		const refHasDefault = siblingSchema.default !== void 0;
-		if (!refRequired && siblingSchema.nullable) functions.push(["nullish", void 0]);
-		else if (siblingSchema.nullable) functions.push(["nullable", void 0]);
-		else if (!refRequired && !refHasDefault) functions.push(["optional", void 0]);
+		if (!refRequired && !refHasDefault) functions.push(["optional", void 0]);
 		if (refHasDefault) {
 			const registry = rules?.constNameRegistry ?? {};
 			const counter = isNumber(registry[name]) ? registry[name] + 1 : 0;
@@ -450,13 +444,11 @@ const generateZodValidationSchemaDefinition = (schema, context, name, strict, is
 	const type = resolveZodType(schema);
 	const required = rules?.required ?? false;
 	const hasDefault = schema.default !== void 0;
-	const nullable = "nullable" in schema && schema.nullable || Array.isArray(schema.type) && schema.type.includes("null");
+	const nullable = Array.isArray(schema.type) && schema.type.includes("null");
 	const min = schema.minimum ?? schema.minLength ?? schema.minItems;
 	const max = schema.maximum ?? schema.maxLength ?? schema.maxItems;
-	const exclusiveMinRaw = "exclusiveMinimum" in schema ? schema.exclusiveMinimum : void 0;
-	const exclusiveMaxRaw = "exclusiveMaximum" in schema ? schema.exclusiveMaximum : void 0;
-	const exclusiveMin = isBoolean(exclusiveMinRaw) ? exclusiveMinRaw ? min : void 0 : exclusiveMinRaw;
-	const exclusiveMax = isBoolean(exclusiveMaxRaw) ? exclusiveMaxRaw ? max : void 0 : exclusiveMaxRaw;
+	const exclusiveMin = "exclusiveMinimum" in schema ? schema.exclusiveMinimum : void 0;
+	const exclusiveMax = "exclusiveMaximum" in schema ? schema.exclusiveMaximum : void 0;
 	const multipleOf = schema.multipleOf;
 	const matches = schema.pattern ?? void 0;
 	const hasNonArrayEnum = !!schema.enum && type !== "array";
@@ -1441,8 +1433,11 @@ const generateFormDataZodSchema = (schema, context, name, strict, isZodV4, encod
 		const fileType = resolvedPropSchema ? getFormDataFieldFileType(resolvedPropSchema, encoding?.[key]?.contentType) : void 0;
 		if (fileType) {
 			const isRequired = schema.required?.includes(key);
+			const isNullable = !!resolvedPropSchema && isSchemaNullable(resolvedPropSchema);
 			const fileFunctions = [fileType === "binary" ? ["instanceof", "Blob"] : ["fileOrString", void 0]];
-			if (!isRequired) fileFunctions.push(["optional", void 0]);
+			if (!isRequired && isNullable) fileFunctions.push(["nullish", void 0]);
+			else if (isNullable) fileFunctions.push(["nullable", void 0]);
+			else if (!isRequired) fileFunctions.push(["optional", void 0]);
 			propertyOverrides[key] = {
 				functions: fileFunctions,
 				consts: []
@@ -1537,6 +1532,64 @@ const getSingleResponse = (responses) => {
 	const otherSuccess = Object.entries(responses).find(([code]) => code.startsWith("2") && code !== "204" && code !== "205")?.[1];
 	return responses["200"] ?? responses["2XX"] ?? responses["2xx"] ?? otherSuccess ?? responses["204"] ?? responses["205"];
 };
+const parseResponseSchema = ({ verb, pathRoute, override }, context) => {
+	const isZodV4 = resolveIsZodV4(context.output.override.zod.version, context.output.packageJson);
+	return {
+		isZodV4,
+		...parseBodyAndResponse({
+			data: getSingleResponse(context.spec.paths?.[pathRoute]?.[verb]?.responses),
+			context,
+			name: "response",
+			strict: override.zod.strict.response,
+			generate: override.zod.generate.response,
+			isZodV4,
+			parseType: "response"
+		})
+	};
+};
+/** The success response is emitted as a plain `zod.object(...)`. */
+const isObjectResponseSchema = (verbOptions, context) => {
+	if (context.output.override.zod.generateEachHttpStatus) return false;
+	const { input, isArray, isZodV4 } = parseResponseSchema(verbOptions, context);
+	const [root, ...modifiers] = input.functions;
+	if (isArray || root === void 0) return false;
+	if (verbOptions.override.zod.preprocess?.response || verbOptions.override.zod.useBrandedTypes && !isZodV4) return false;
+	const objectRoots = /* @__PURE__ */ new Set([
+		"object",
+		"looseObject",
+		"strictObject"
+	]);
+	const objectModifiers = /* @__PURE__ */ new Set([
+		"strict",
+		"passthrough",
+		"describe"
+	]);
+	return objectRoots.has(root[0]) && modifiers.every(([fn]) => objectModifiers.has(fn));
+};
+/**
+* A `<Operation>Response` schema that can be converted to JSON Schema is
+* emitted for the success response.
+*/
+const hasResponseSchema = (verbOptions, context) => {
+	if (context.output.override.zod.generateEachHttpStatus) return false;
+	const { input, isArray } = parseResponseSchema(verbOptions, context);
+	if (!isArray && input.functions.length === 0) return false;
+	const unsupportedTypes = /* @__PURE__ */ new Set([
+		"allOf",
+		"date",
+		"instanceof"
+	]);
+	const containsUnsupported = (value) => {
+		if (Array.isArray(value)) return value.some(containsUnsupported);
+		if (!isObject(value)) return false;
+		if (Array.isArray(value.functions)) {
+			const functions = value.functions;
+			return functions[0] !== void 0 && unsupportedTypes.has(functions[0][0]) || functions.some(([, args]) => containsUnsupported(args));
+		}
+		return Object.values(value).some(containsUnsupported);
+	};
+	return !containsUnsupported(input);
+};
 const parseParameters = ({ data, context, operationName, isZodV4, strict, generate, useReusableSchemas }) => {
 	if (!data) return {
 		headers: {
@@ -1860,6 +1913,6 @@ const zodClientBuilder = {
 };
 const builder = () => () => zodClientBuilder;
 //#endregion
-export { assertZodTarget, builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, getZodImportSource, getZodTypeName, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats, renderZodExport, resolveIsZodV4 };
+export { assertZodTarget, builder, builder as default, dereference, generateFormDataZodSchema, generateZod, generateZodValidationSchemaDefinition, getZodDependencies, getZodImportSource, getZodTypeName, hasResponseSchema, isObjectResponseSchema, isZodVersionV4, parseParameters, parseZodValidationSchemaDefinition, predefinedZodFormats, renderZodExport, resolveIsZodV4 };
 
 //# sourceMappingURL=index.mjs.map