@orval/mock 8.34.0 → 8.35.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { EnumGeneration, OutputMockType, OutputMode, PropertySortOrder, camelPathParamName, compareNatural, compareVersions, escapeRegExp, generalJSTypesWithArray, generateDependencyImports, getKey, getOperationTagKey, getRefInfo, getRequiredKeys, getStringLiteralType, isBoolean, isFunction, isMswMock, isNumber, isObject, isReference, isString, jsStringLiteralEscape, mergeDeep, pascal, resolveRef, safeNumericConstraint, stringify, toColonRoutePath } from "@orval/core";
+import { EnumGeneration, OutputMockType, OutputMode, PropertySortOrder, camelPathParamName, compareNatural, compareVersions, escapeRegExp, generalJSTypesWithArray, generateDependencyImports, getKey, getOperationTagKey, getRefInfo, getRequiredKeys, getStringLiteralType, isBoolean, isFunction, isMswMock, isNumber, isObject, isReference, isSchemaNullable, isString, jsStringLiteralEscape, mergeDeep, pascal, resolveRef, safeNumericConstraint, stringify, toColonRoutePath } from "@orval/core";
 import { prop } from "remeda";
 //#region src/mock-types.ts
 function isStrictMock(mockOptions) {
@@ -436,11 +436,12 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 			return {
 				value: "faker.helpers.arrayElement([{}, null])",
 				imports: [],
-				name: schemaItem.name
+				name: schemaItem.name,
+				nullWrapped: true
 			};
 		}
 		const baseItem = schemaItem;
-		return combineSchemasMock({
+		const combined = combineSchemasMock({
 			item: {
 				anyOf: nonNullTypes.map((type) => ({
 					...baseItem,
@@ -459,6 +460,10 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 			existingReferencedAllOfRefs,
 			splitMockImplementations
 		});
+		return nonNullTypes.includes("null") ? {
+			...combined,
+			nullWrapped: true
+		} : combined;
 	}
 	if (itemProperties) {
 		let value = !combine || combine.separator === "oneOf" || combine.separator === "anyOf" ? "{" : "";
@@ -471,7 +476,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 		const propertyScalars = entries.map(([key, prop]) => {
 			if (combine?.includedProperties.includes(key)) return;
 			const isRequired = mockOptions?.required ?? (Array.isArray(itemRequired) ? itemRequired : []).includes(key);
-			const hasNullable = "nullable" in prop && prop.nullable === true;
+			const hasNullable = !isReference(prop) && isSchemaNullable(prop);
 			const refName = isReference(prop) ? getReferenceName$1(prop.$ref, context) : "";
 			const isRecursiveRef = !!refName && existingReferencedProperties.includes(refName);
 			if (isRecursiveRef) {
@@ -513,6 +518,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 			}
 			const hasDefault = "default" in prop && prop.default !== void 0;
 			if (!isRequired && !resolvedValue.overrided && !hasDefault) {
+				if (resolvedValue.nullWrapped) return `${keyDefinition}: ${resolvedValue.value}`;
 				const omitValue = mockOptions?.nonNullable || !hasNullable ? "undefined" : "null";
 				return `${keyDefinition}: faker.helpers.arrayElement([${resolvedValue.value}, ${omitValue}])`;
 			}
@@ -639,7 +645,6 @@ function isAmbiguousInlineItemContext(operationId, parentName) {
 	return !parentName.toLowerCase().includes(operationId.toLowerCase());
 }
 function isNullableArrayItem(schema) {
-	if (schema.nullable === true) return true;
 	return Array.isArray(schema.type) && schema.type.includes("null");
 }
 function isResolvedSchemaObjectLike(schema) {
@@ -1085,7 +1090,8 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 		case "null": return {
 			value: "null",
 			imports: [],
-			name: item.name
+			name: item.name,
+			nullWrapped: true
 		};
 		default:
 			if (item.enum) {
@@ -1243,11 +1249,21 @@ function resolveRefTarget(ref, context) {
 	if (!Array.isArray(refPaths)) return void 0;
 	return prop(context.spec, ...refPaths);
 }
-/** OpenAPI 3.0 `nullable: true` or 3.1 `type` unions that include `null`. */
+/**
+* Whether a schema accepts `null`, in any of the spellings orval sees.
+*
+* Delegates to core's {@link isSchemaNullable} rather than keeping a second,
+* narrower copy: this one knew only the 3.0 `nullable` keyword and a 3.1 `type`
+* union, so a schema nullable through a bare `type: 'null'`, a `null` member of
+* an `enum`, or a `{ type: 'null' }` branch of a `oneOf`/`anyOf` read as
+* non-nullable here while the type generator emitted `| null` (#4141).
+*
+* Kept as a thin wrapper because callers pass `unknown` — resolved `$ref`
+* targets and mock schemas that are not typed as Schema Objects.
+*/
 function isNullableSchema(schema) {
 	if (!schema || typeof schema !== "object") return false;
-	const { type, nullable } = schema;
-	return nullable === true || Array.isArray(type) && type.includes("null");
+	return isSchemaNullable(schema);
 }
 /** When `nonNullableOption` is true (`override.mock.nonNullable`), omit the null branch. */
 function getNullable(value, nullable, nonNullableOption) {
@@ -1318,7 +1334,7 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 			path: schemaReference.path,
 			isRef: true,
 			required: [...schemaRef?.required ?? [], ...getRequiredKeys(schemaReference, name)],
-			...schemaReference.nullable === void 0 ? {} : { nullable: schemaReference.nullable }
+			...Array.isArray(schemaReference.type) ? { type: schemaReference.type } : {}
 		};
 		if (combine?.separator === "allOf" && newSchema.discriminator && newSchema.oneOf) {
 			const parentDiscriminator = newSchema.discriminator;
@@ -1350,7 +1366,9 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 				values: true,
 				schemaFactory: true
 			};
-			const isObjectLike = newSchema.type === "object" || !!newSchema.allOf || resolvesToObjectLike(newSchema, context);
+			const targetNullable = !!schemaRef && isNullableSchema(schemaRef);
+			const siteNullable = isNullableSchema(schemaReference);
+			const isObjectLike = !targetNullable && (newSchema.type === "object" || !!newSchema.allOf || resolvesToObjectLike(newSchema, context));
 			const mockTypeName = getStrictMockTypeName(pascal(name));
 			const strictMockTypeImport = isStrictMock(mockOptions) && isObjectLike ? {
 				name: mockTypeName,
@@ -1358,12 +1376,14 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 				schemaFactory: true
 			} : void 0;
 			const strictObjectCast = isStrictMock(mockOptions) && isObjectLike ? ` as ${mockTypeName}` : "";
+			const callValue = isObjectLike ? `{ ...${factoryName}()${strictObjectCast} }` : `${factoryName}()`;
+			const delegatesNullable = targetNullable || siteNullable;
 			return {
-				value: getNullable(isObjectLike ? `{ ...${factoryName}()${strictObjectCast} }` : `${factoryName}()`, Boolean(newSchema.nullable), mockOptions?.nonNullable),
+				value: getNullable(callValue, siteNullable && !targetNullable, mockOptions?.nonNullable),
 				imports: strictMockTypeImport ? [factoryImport, strictMockTypeImport] : [factoryImport],
 				name: newSchema.name,
 				type: getType(newSchema),
-				nullWrapped: Boolean(newSchema.nullable) && !mockOptions?.nonNullable
+				nullWrapped: delegatesNullable && !mockOptions?.nonNullable
 			};
 		}
 		const importsBefore = imports.length;
@@ -1396,7 +1416,7 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 				const func = formatMockFactoryDeclaration(funcName, param, returnType, `{${scalar.value.startsWith("...") ? "" : "..."}${scalar.value}, ...${overrideVarName}}`, returnCast, { terminateStatement: true });
 				splitMockImplementations.push(func);
 			}
-			scalar.value = newSchema.nullable ? `${funcName}()` : `{...${funcName}()}`;
+			scalar.value = isNullableSchema(newSchema) ? `${funcName}()` : `{...${funcName}()}`;
 			const typeImport = {
 				name: newSchema.name,
 				values: false
@@ -1569,7 +1589,8 @@ function combineSchemasMock({ item, separator, mockOptions, operationId, tags, c
 		value: finalValue,
 		imports: combineImports,
 		name: item.name,
-		includedProperties
+		includedProperties,
+		nullWrapped: isSchemaNullable(item) && !mockOptions?.nonNullable
 	};
 }
 //#endregion