@orval/mock 8.23.0 → 8.24.0

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, compareVersions, escapeRegExp, generalJSTypesWithArray, generateDependencyImports, getKey, getOperationTagKey, getRefInfo, 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: {
@@ -421,9 +472,16 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 			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";
@@ -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,8 +1265,9 @@ 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,
@@ -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 = [...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) : "";
@@ -1724,6 +1808,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 +1833,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 = `