@orval/mock 8.23.0 → 8.25.0

package/dist/index.d.mts

@@ -1,5 +1,4 @@
 import { ClientMockGeneratorBuilder, ContextSpec, FakerMockOptions, FinalizeMockImplementationOptions, GenerateMockImports, GeneratorImport, GeneratorOptions, GeneratorSchema, GeneratorVerbOptions, GlobalMockOptions, MswMockOptions, StrictMockSchemaKind, StrictMockSchemaKind as StrictMockSchemaKind$1 } from "@orval/core";
-
 //#region src/faker/index.d.ts
 /**
  * Emits the import header for a faker-only mock file. Faker output never

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { EnumGeneration, OutputMockType, OutputMode, PropertySortOrder, camelPathParamName, compareVersions, escapeRegExp, generalJSTypesWithArray, generateDependencyImports, getKey, getOperationTagKey, getRefInfo, isBoolean, isFunction, isMswMock, isNumber, isObject, isReference, isSchema, isString, jsStringLiteralEscape, mergeDeep, pascal, resolveRef, stringify, toColonRoutePath } from "@orval/core";
+import { EnumGeneration, OutputMockType, OutputMode, PropertySortOrder, camelPathParamName, compareNatural, compareVersions, escapeRegExp, generalJSTypesWithArray, generateDependencyImports, getKey, getOperationTagKey, getRefInfo, getRequiredKeys, isBoolean, isFunction, isMswMock, isNumber, isObject, isReference, isString, jsStringLiteralEscape, mergeDeep, pascal, resolveRef, stringify, toColonRoutePath } from "@orval/core";
 import { prop } from "remeda";
 //#region src/mock-types.ts
 function isStrictMock(mockOptions) {
@@ -265,6 +265,43 @@ const getDelay = (override, options) => {
 	return false;
 };
 //#endregion
+//#region src/faker/getters/all-of-required.ts
+function derefAllOfMember(member, context, seen) {
+	let current = member;
+	while (current && typeof current === "object" && isReference(current)) {
+		const ref = current.$ref;
+		if (typeof ref !== "string" || seen.has(ref)) return;
+		seen.add(ref);
+		const { refPaths } = getRefInfo(ref, context);
+		current = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
+	}
+	return current && typeof current === "object" ? current : void 0;
+}
+function collectAllOfRequiredWithDeclared(schemas, context, seen) {
+	const required = [];
+	const declared = /* @__PURE__ */ new Set();
+	for (const val of schemas) {
+		const memberSeen = new Set(seen);
+		const schema = derefAllOfMember(val, context, memberSeen);
+		if (!schema) continue;
+		const properties = schema.properties;
+		if (properties && typeof properties === "object") for (const key of Object.keys(properties)) declared.add(key);
+		if (Array.isArray(schema.required)) required.push(...schema.required);
+		if (Array.isArray(schema.allOf)) {
+			const inner = collectAllOfRequiredWithDeclared(schema.allOf, context, memberSeen);
+			required.push(...inner.required.filter((name) => inner.declared.has(name) || properties && name in properties));
+			for (const key of inner.declared) declared.add(key);
+		}
+	}
+	return {
+		required,
+		declared
+	};
+}
+function collectAllOfRequired(schemas, context) {
+	return collectAllOfRequiredWithDeclared(schemas, context, /* @__PURE__ */ new Set()).required;
+}
+//#endregion
 //#region src/faker/compatible-v9.ts
 const getFakerPackageVersion = (packageJson) => {
 	return packageJson.resolvedVersions?.["@faker-js/faker"] ?? packageJson.dependencies?.["@faker-js/faker"] ?? packageJson.devDependencies?.["@faker-js/faker"] ?? packageJson.peerDependencies?.["@faker-js/faker"];
@@ -316,6 +353,20 @@ function getReferenceName$1(ref, context) {
 	if (!ref) return "";
 	return getRefInfo(ref, context).name;
 }
+function isNullableRefTarget(ref, context) {
+	return isNullableSchema(resolveRefTarget(ref, context));
+}
+function reExpansionWouldCollapse(ref, context, existingReferencedProperties, nonNullable) {
+	const target = resolveRefTarget(ref, context);
+	const targetProperties = target?.properties;
+	const targetRequired = target?.required;
+	if (!targetProperties || !Array.isArray(targetRequired)) return false;
+	return Object.entries(targetProperties).some(([key, property]) => {
+		if (!targetRequired.includes(key) || !isReference(property)) return false;
+		if (!existingReferencedProperties.includes(getReferenceName$1(property.$ref, context))) return false;
+		return nonNullable || !isNullableRefTarget(property.$ref, context);
+	});
+}
 function getMockObject({ item, mockOptions, operationId, tags, combine, context, imports, existingReferencedProperties, existingReferencedAllOfRefs = [], splitMockImplementations, allowOverride = false }) {
 	if (isReference(item)) return resolveMockValue({
 		schema: {
@@ -415,15 +466,22 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 		const includedProperties = [];
 		const entries = Object.entries(itemProperties);
 		if (context.output.propertySortOrder === PropertySortOrder.ALPHABETICAL) entries.sort((a, b) => {
-			return a[0].localeCompare(b[0], "en", { numeric: true });
+			return compareNatural(a[0], b[0]);
 		});
 		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;
-			if (isReference(prop) && existingReferencedProperties.includes(getReferenceName$1(prop.$ref, context))) {
-				if (isRequired) return `${getKey(key)}: null`;
-				return;
+			const refName = isReference(prop) ? getReferenceName$1(prop.$ref, context) : "";
+			const isRecursiveRef = !!refName && existingReferencedProperties.includes(refName);
+			if (isRecursiveRef) {
+				if (!isRequired) return;
+				const keyDefinition = getKey(key);
+				if (!mockOptions?.nonNullable && (hasNullable || isReference(prop) && isNullableRefTarget(prop.$ref, context))) return `${keyDefinition}: null`;
+				if (new Set(existingReferencedProperties).size !== existingReferencedProperties.length || isReference(prop) && reExpansionWouldCollapse(prop.$ref, context, existingReferencedProperties, mockOptions?.nonNullable)) {
+					imports.push({ name: refName });
+					return `${keyDefinition}: {} as unknown as ${refName}`;
+				}
 			}
 			const importsBefore = imports.length;
 			const resolvedValue = resolveMockValue({
@@ -445,6 +503,14 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 			mergeReturnedMockImports(imports, importsBefore, resolvedValue.imports);
 			includedProperties.push(key);
 			const keyDefinition = getKey(key);
+			if (isRequired && refName && resolvedValue.value === "undefined") {
+				imports.push({ name: refName });
+				return `${keyDefinition}: undefined as unknown as ${refName}`;
+			}
+			if (isRequired && isRecursiveRef && resolvedValue.value.includes(" as unknown as ")) {
+				imports.push({ name: refName });
+				return `${keyDefinition}: {} as unknown as ${refName}`;
+			}
 			const hasDefault = "default" in prop && prop.default !== void 0;
 			if (!isRequired && !resolvedValue.overrided && !hasDefault) {
 				const omitValue = mockOptions?.nonNullable || !hasNullable ? "undefined" : "null";
@@ -675,7 +741,7 @@ function extractArrayItemMock({ items, propertyName, parentName, operationId, ta
 }
 //#endregion
 //#region src/faker/format-example-value.ts
-const DATE_FORMATS = new Set(["date", "date-time"]);
+const DATE_FORMATS = /* @__PURE__ */ new Set(["date", "date-time"]);
 function isDateFormat(format) {
 	return format !== void 0 && DATE_FORMATS.has(format);
 }
@@ -791,7 +857,7 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 	const operationProperty = resolveMockOverride(safeMockOptions.operations?.[operationId]?.properties, item, nonNullableOption);
 	if (operationProperty) return operationProperty;
 	let overrideTag = { properties: {} };
-	const sortedTags = Object.entries(safeMockOptions.tags ?? {}).toSorted((a, b) => a[0].localeCompare(b[0], "en", { numeric: true }));
+	const sortedTags = Object.entries(safeMockOptions.tags ?? {}).toSorted((a, b) => compareNatural(a[0], b[0]));
 	for (const [tag, options] of sortedTags) {
 		if (!tags.includes(tag)) continue;
 		overrideTag = mergeDeep(overrideTag, options);
@@ -1073,17 +1139,19 @@ function getItemType(item) {
 function getEnum(item, imports, context, existingReferencedProperties, type) {
 	if (!item.enum) return "";
 	let enumValue = `[${item.enum.filter((e) => e !== null).map((e) => type === "string" || type === void 0 && isString(e) ? `'${jsStringLiteralEscape(e)}'` : e).join(",")}]`;
-	if (context.output.override.enumGenerationType === EnumGeneration.ENUM) if (item.isRef || existingReferencedProperties.length === 0) {
-		enumValue += ` as ${item.name}${item.name.endsWith("[]") ? "" : "[]"}`;
-		imports.push({ name: item.name });
-	} else {
-		const parentReference = existingReferencedProperties.at(-1);
-		if (!parentReference) return "";
-		enumValue += ` as ${parentReference}['${item.name}']`;
-		if (!item.path?.endsWith("[]")) enumValue += "[]";
-		imports.push({ name: parentReference });
-	}
-	else enumValue += " as const";
+	if (context.output.override.enumGenerationType === EnumGeneration.ENUM) {
+		const isRootSchema = !item.parentName && existingReferencedProperties.at(-1) === item.name;
+		if (item.isRef || existingReferencedProperties.length === 0 || isRootSchema) {
+			enumValue += ` as ${item.name}${item.name.endsWith("[]") ? "" : "[]"}`;
+			imports.push({ name: item.name });
+		} else {
+			const parentReference = existingReferencedProperties.at(-1);
+			if (!parentReference) return "";
+			enumValue += ` as ${parentReference}['${item.name}']`;
+			if (!item.path?.endsWith("[]")) enumValue += "[]";
+			imports.push({ name: parentReference });
+		}
+	} else enumValue += " as const";
 	if (item.isRef && type === "string" && context.output.override.enumGenerationType !== EnumGeneration.UNION) {
 		enumValue = `Object.values(${item.name})`;
 		imports.push({
@@ -1122,6 +1190,15 @@ function resolveMockOverride(properties = {}, item, nonNullableOption) {
 		overrided: true
 	};
 }
+/** Resolves a `$ref` string to its schema in the loaded spec, if any. */
+function resolveRefTarget(ref, context) {
+	if (typeof ref !== "string") return void 0;
+	const [, fragment] = ref.split("#");
+	if (!fragment) return void 0;
+	const { refPaths } = getRefInfo(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`. */
 function isNullableSchema(schema) {
 	if (!schema || typeof schema !== "object") return false;
@@ -1188,14 +1265,15 @@ function hasOverrideTouchingSchema(schemaProperties, mockOptions, operationId, t
 function resolveMockValue({ schema, mockOptions, operationId, tags, combine, context, imports, existingReferencedProperties, existingReferencedAllOfRefs = [], splitMockImplementations, allowOverride }) {
 	if (isReference(schema)) {
 		const schemaReference = schema;
-		const { name, refPaths } = getRefInfo(typeof schema.$ref === "string" ? schema.$ref : "", context);
-		const schemaRef = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
+		const schemaRefPath = typeof schema.$ref === "string" ? schema.$ref : "";
+		const { name, refPaths } = getRefInfo(schemaRefPath, context);
+		const schemaRef = resolveRefTarget(schemaRefPath, context);
 		const newSchema = {
 			...schemaRef,
 			name,
 			path: schemaReference.path,
 			isRef: true,
-			required: [...schemaRef?.required ?? [], ...schemaReference.required ?? []],
+			required: [...schemaRef?.required ?? [], ...getRequiredKeys(schemaReference, name)],
 			...schemaReference.nullable === void 0 ? {} : { nullable: schemaReference.nullable }
 		};
 		if (combine?.separator === "allOf" && newSchema.discriminator && newSchema.oneOf) {
@@ -1219,7 +1297,9 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 			}
 		}
 		const newSeparator = newSchema.allOf ? "allOf" : newSchema.oneOf ? "oneOf" : "anyOf";
-		if (shouldDelegateToSchemaFactories(context) && isComponentsSchemaRef(refPaths) && !hasOverrideTouchingSchema(schemaRef?.properties, mockOptions, operationId, tags, schemaReference.path)) {
+		const targetEffective = schemaRef ? collectAllOfRequiredWithDeclared([schemaRef], context, /* @__PURE__ */ new Set()) : void 0;
+		const delegationDropsRequired = (schemaReference.required ?? []).some((requiredName) => targetEffective?.declared.has(requiredName) && !targetEffective.required.includes(requiredName));
+		if (shouldDelegateToSchemaFactories(context) && isComponentsSchemaRef(refPaths) && !existingReferencedProperties.includes(name) && !delegationDropsRequired && !hasOverrideTouchingSchema(schemaRef?.properties, mockOptions, operationId, tags, schemaReference.path)) {
 			const factoryName = `get${pascal(name)}Mock`;
 			const factoryImport = {
 				name: factoryName,
@@ -1315,8 +1395,7 @@ function resolvesToObjectLike(schema, context, seen = /* @__PURE__ */ new Set())
 	if (isReference(schema)) {
 		if (typeof schema.$ref !== "string" || seen.has(schema.$ref)) return false;
 		seen = new Set(seen).add(schema.$ref);
-		const { refPaths } = getRefInfo(schema.$ref, context);
-		resolved = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
+		resolved = resolveRefTarget(schema.$ref, context);
 	} else resolved = schema;
 	if (!resolved) return false;
 	if (resolved.type === "object" || resolved.properties || resolved.additionalProperties || resolved.allOf) return true;
@@ -1355,8 +1434,18 @@ function combineSchemasMock({ item, separator, mockOptions, operationId, tags, c
 		}
 	}
 	const hasResolvableProperties = itemEntriesForResolve.some(([key]) => key === "properties");
+	const allRequiredFields = [];
+	if (separator === "allOf") {
+		if (itemRequired) allRequiredFields.push(...itemRequired);
+		allRequiredFields.push(...collectAllOfRequired(separatorItems, context));
+	}
+	const itemSchemaForResolve = Object.fromEntries(itemEntriesForResolve);
+	if (separator === "allOf" && allRequiredFields.length > 0) {
+		const itemResolveRequired = itemSchemaForResolve.required;
+		itemSchemaForResolve.required = [.../* @__PURE__ */ new Set([...allRequiredFields, ...itemResolveRequired ?? []])];
+	}
 	const itemResolvedValue = isRefAndNotExisting || hasResolvableProperties ? resolveMockValue({
-		schema: Object.fromEntries(itemEntriesForResolve),
+		schema: itemSchemaForResolve,
 		combine: {
 			separator: "allOf",
 			includedProperties: []
@@ -1373,11 +1462,6 @@ function combineSchemasMock({ item, separator, mockOptions, operationId, tags, c
 	includedProperties.push(...itemResolvedValue?.includedProperties ?? []);
 	combineImports.push(...itemResolvedValue?.imports ?? []);
 	let containsOnlyPrimitiveValues = true;
-	const allRequiredFields = [];
-	if (separator === "allOf") {
-		if (itemRequired) allRequiredFields.push(...itemRequired);
-		for (const val of separatorItems) if (isSchema(val) && val.required) allRequiredFields.push(...val.required);
-	}
 	let value = separator === "allOf" ? "" : "faker.helpers.arrayElement([";
 	for (const val of separatorItems) {
 		const refName = isReference(val) ? getReferenceName(val.$ref, context) : "";
@@ -1701,19 +1785,20 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
 	let mockFactoryParam = "";
 	let mockFactoryReturnType = nonVoidMockReturnType;
 	let mockFactoryReturnCast = "";
-	if (isResponseOverridable) if (strictMock && simpleSchemaReturnType) {
-		const signature = getMockFactorySignatureParts(simpleSchemaReturnType, mockOptionsFromOverride, {
-			isOverridable: true,
-			overrideType: overrideResponseType
-		});
-		mockFactoryParam = signature.param;
-		mockFactoryReturnType = signature.returnType;
-		mockFactoryReturnCast = signature.returnCast;
-	} else {
-		mockFactoryParam = `overrideResponse: ${overrideResponseType} = {}`;
-		mockFactoryReturnType = strictMock ? strictMockReturnType : nonVoidMockReturnType;
-	}
-	else if (strictMock) mockFactoryReturnType = strictMockReturnType;
+	if (isResponseOverridable) {
+		if (strictMock && simpleSchemaReturnType) {
+			const signature = getMockFactorySignatureParts(simpleSchemaReturnType, mockOptionsFromOverride, {
+				isOverridable: true,
+				overrideType: overrideResponseType
+			});
+			mockFactoryParam = signature.param;
+			mockFactoryReturnType = signature.returnType;
+			mockFactoryReturnCast = signature.returnCast;
+		} else {
+			mockFactoryParam = `overrideResponse: ${overrideResponseType} = {}`;
+			mockFactoryReturnType = strictMock ? strictMockReturnType : nonVoidMockReturnType;
+		}
+	} else if (strictMock) mockFactoryReturnType = strictMockReturnType;
 	const mockImplementation = isReturnHttpResponse ? `${mockImplementations}${formatMockFactoryDeclaration(getResponseMockFunctionName, mockFactoryParam, mockFactoryReturnType, value, mockFactoryReturnCast, { omitReturnType: Boolean(mockData) })}\n\n` : mockImplementations;
 	const delay = getDelay(override, isFunction(mock) ? void 0 : mock);
 	const infoParam = "info";
@@ -1724,6 +1809,10 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
 	const binaryContentType = (preferredContentTypeMatch && isBinaryLikeContentType(preferredContentTypeMatch) ? preferredContentTypeMatch : contentTypes.find((ct) => isBinaryLikeContentType(ct))) ?? "application/octet-stream";
 	const firstTextCt = isExactlyStringReturnType && !!preferredContentTypeMatch && !isTextLikeContentType(preferredContentTypeMatch) && hasTextLikeContentType ? contentTypes.find((ct) => isTextLikeContentType(ct)) : contentTypesByPreference.find((ct) => isTextLikeContentType(ct));
 	const textHelper = firstTextCt === "application/xml" || firstTextCt?.endsWith("+xml") ? "xml" : firstTextCt === "text/html" ? "html" : "text";
+	const firstJsonCt = contentTypesByPreference.find((ct) => ct.includes("json"));
+	const textHelperDefaultContentType = textHelper === "xml" ? "text/xml" : textHelper === "html" ? "text/html" : "text/plain";
+	const jsonCtHeaderSuffix = firstJsonCt && firstJsonCt !== "application/json" ? `, headers: { 'Content-Type': '${firstJsonCt}' }` : "";
+	const textCtHeaderSuffix = firstTextCt && firstTextCt !== textHelperDefaultContentType ? `, headers: { 'Content-Type': '${firstTextCt}' }` : "";
 	let responseBody;
 	let responsePrelude = "";
 	if (isReturnHttpResponse) {
@@ -1745,23 +1834,23 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
 	else if (isVoidUnionType) {
 		let nonVoidBody;
 		if (needsRuntimeContentTypeSwitch) nonVoidBody = `typeof resolvedBody === 'string'
-        ? HttpResponse.${textHelper}(resolvedBody, { status: ${statusCode} })
-        : HttpResponse.json(resolvedBody, { status: ${statusCode} })`;
+        ? HttpResponse.${textHelper}(resolvedBody, { status: ${statusCode}${textCtHeaderSuffix} })
+        : HttpResponse.json(resolvedBody, { status: ${statusCode}${jsonCtHeaderSuffix} })`;
 		else if (isTextResponse && !shouldPreferJsonResponse) nonVoidBody = `HttpResponse.${textHelper}(
         typeof resolvedBody === 'string' ? resolvedBody : JSON.stringify(resolvedBody ?? null),
-        { status: ${statusCode} })`;
-		else nonVoidBody = `HttpResponse.json(resolvedBody, { status: ${statusCode} })`;
+        { status: ${statusCode}${textCtHeaderSuffix} })`;
+		else nonVoidBody = `HttpResponse.json(resolvedBody, { status: ${statusCode}${jsonCtHeaderSuffix} })`;
 		responseBody = `resolvedBody === undefined
       ? new HttpResponse(null, { status: ${noContentStatusCode} })
       : ${nonVoidBody}`;
 	} else if (needsRuntimeContentTypeSwitch) responseBody = `typeof resolvedBody === 'string'
-      ? HttpResponse.${textHelper}(resolvedBody, { status: ${statusCode} })
-      : HttpResponse.json(resolvedBody, { status: ${statusCode} })`;
+      ? HttpResponse.${textHelper}(resolvedBody, { status: ${statusCode}${textCtHeaderSuffix} })
+      : HttpResponse.json(resolvedBody, { status: ${statusCode}${jsonCtHeaderSuffix} })`;
 	else if (isTextResponse && !shouldPreferJsonResponse) responseBody = `HttpResponse.${textHelper}(textBody,
-      { status: ${statusCode}
+      { status: ${statusCode}${textCtHeaderSuffix}
       })`;
 	else responseBody = `HttpResponse.json(${resolvedResponseExpr},
-      { status: ${statusCode}
+      { status: ${statusCode}${jsonCtHeaderSuffix}
       })`;
 	const infoType = `Parameters<Parameters<typeof http.${verb}>[1]>[0]`;
 	const handlerImplementation = `