@orval/mock 8.14.0 → 8.16.0

package/dist/index.mjs

@@ -1,5 +1,103 @@
-import { EnumGeneration, OutputMockType, PropertySortOrder, camel, compareVersions, escape, escapeRegExp, generalJSTypesWithArray, generateDependencyImports, getKey, getRefInfo, isBoolean, isFunction, isMswMock, isNumber, isObject, isReference, isSchema, isString, mergeDeep, pascal, resolveRef, sanitize, stringify } from "@orval/core";
+import { DefaultTag, EnumGeneration, OutputMockType, OutputMode, PropertySortOrder, camel, compareVersions, escape, escapeRegExp, generalJSTypesWithArray, generateDependencyImports, getKey, getRefInfo, isBoolean, isFunction, isMswMock, isNumber, isObject, isReference, isSchema, isString, kebab, mergeDeep, pascal, resolveRef, sanitize, stringify } from "@orval/core";
 import { prop } from "remeda";
+//#region src/mock-types.ts
+function isStrictMock(mockOptions) {
+	return Boolean(mockOptions && mockOptions.required && mockOptions.nonNullable);
+}
+function getStrictMockTypeName(typeName) {
+	return `${typeName}Mock`;
+}
+function getStrictMockHelperTypeDeclarations() {
+	return `export type KeysWithNull<O> = {
+  [K in keyof O]-?: null extends O[K] ? K : never;
+}[keyof O];
+
+export type MockWithNullableOverrides<
+  T,
+  O extends Partial<T>,
+  M extends Record<keyof T, unknown>,
+> = Omit<M, Extract<KeysWithNull<O>, keyof T>> & {
+  [K in Extract<KeysWithNull<O>, keyof T>]: M[K] | null;
+};`;
+}
+function getStrictMockTypeDeclaration(typeName) {
+	return `export type ${getStrictMockTypeName(typeName)} = {\n  [K in keyof Required<${typeName}>]: NonNullable<Required<${typeName}>[K]>;\n};`;
+}
+function getStrictMockTypeDeclarations(typeNames) {
+	const unique = [...new Set(typeNames)];
+	if (unique.length === 0) return "";
+	return unique.map((typeName) => getStrictMockTypeDeclaration(typeName)).join("\n\n");
+}
+function getMockFactoryReturnType(typeName, mockOptions) {
+	return isStrictMock(mockOptions) ? getStrictMockTypeName(typeName) : typeName;
+}
+function getMockFactorySignatureParts(typeName, mockOptions, options = {}) {
+	const isOverridable = options.isOverridable ?? false;
+	const overrideType = options.overrideType ?? `Partial<${typeName}>`;
+	const mockTypeName = getStrictMockTypeName(typeName);
+	if (!isOverridable) return {
+		param: "",
+		returnType: getMockFactoryReturnType(typeName, mockOptions),
+		returnCast: ""
+	};
+	if (isStrictMock(mockOptions)) return {
+		param: `<O extends ${overrideType} = {}>(overrideResponse?: O)`,
+		returnType: `MockWithNullableOverrides<${typeName}, O, ${mockTypeName}>`,
+		returnCast: ` as MockWithNullableOverrides<${typeName}, O, ${mockTypeName}>`
+	};
+	return {
+		param: `overrideResponse: ${overrideType} = {}`,
+		returnType: typeName,
+		returnCast: ""
+	};
+}
+function getSimpleSchemaReturnType(returnType, schemaTypeNames) {
+	const trimmed = returnType.trim();
+	return schemaTypeNames.includes(trimmed) ? trimmed : void 0;
+}
+function formatMockFactoryDeclaration(factoryName, param, returnType, body, returnCast, options) {
+	return `${param ? param.startsWith("<") ? `export const ${factoryName} = ${param}` : `export const ${factoryName} = (${param})` : `export const ${factoryName} = ()`}${options?.omitReturnType || !returnType ? "" : `: ${returnType}`} => (${body})${returnCast}${returnCast || options?.terminateStatement ? ";" : ""}`;
+}
+function getSchemaTypeNamesFromResponses(responses) {
+	const names = /* @__PURE__ */ new Set();
+	for (const response of responses) {
+		for (const imp of response.imports) {
+			if (imp.values || imp.schemaFactory) continue;
+			const importName = imp.alias ?? imp.name;
+			if (/^[A-Z]\w*$/.test(importName)) names.add(importName);
+		}
+		const { value } = response;
+		if (!value) continue;
+		const baseType = value.endsWith("[]") ? value.slice(0, -2) : value;
+		if (/^[A-Z]\w*$/.test(baseType)) names.add(baseType);
+	}
+	return [...names];
+}
+function buildStrictMockTypeFileHeader(schemaTypeNames) {
+	const schemaBlock = getStrictMockTypeDeclarations([...new Set(schemaTypeNames)]);
+	return [getStrictMockHelperTypeDeclarations(), schemaBlock].filter(Boolean).join("\n\n");
+}
+/**
+* Prepends shared strict-mock helper types and each `{Schema}Mock` alias once at
+* the top of a mock file. Generators pass `strictSchemaTypeNames`; no scraping.
+*
+* Not idempotent — callers must invoke this exactly once per aggregated mock
+* file (writers and `writeFakerSchemaMocks`), not from import hooks.
+*/
+function dedupeStrictMockTypeDeclarations(implementation, options = {}) {
+	if (!isStrictMock(options.mockOptions)) return implementation;
+	const schemaTypeNames = options.strictSchemaTypeNames ? [...new Set(options.strictSchemaTypeNames)] : [];
+	if (schemaTypeNames.length === 0) return implementation;
+	return `${buildStrictMockTypeFileHeader(schemaTypeNames)}\n\n${implementation.trimStart()}`;
+}
+function applyStrictMockReturnType(returnType, schemaTypeNames) {
+	if (schemaTypeNames.length === 0) return returnType;
+	let result = returnType;
+	const sorted = [...schemaTypeNames].toSorted((a, b) => b.length - a.length);
+	for (const name of sorted) result = result.replaceAll(new RegExp(String.raw`\b${escapeRegExp(name)}\b`, "g"), getStrictMockTypeName(name));
+	return result;
+}
+//#endregion
 //#region src/delay.ts
 const getDelay = (override, options) => {
 	const mswOptions = options && isMswMock(options) ? options : void 0;
@@ -55,7 +153,7 @@ function getReferenceName$1(ref, context) {
 	if (!ref) return "";
 	return getRefInfo(ref, context).name;
 }
-function getMockObject({ item, mockOptions, operationId, tags, combine, context, imports, existingReferencedProperties, splitMockImplementations, allowOverride = false }) {
+function getMockObject({ item, mockOptions, operationId, tags, combine, context, imports, existingReferencedProperties, existingReferencedAllOfRefs = [], splitMockImplementations, allowOverride = false }) {
 	if (isReference(item)) return resolveMockValue({
 		schema: {
 			...item,
@@ -68,6 +166,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 		context,
 		imports,
 		existingReferencedProperties,
+		existingReferencedAllOfRefs,
 		splitMockImplementations
 	});
 	const schemaItem = item;
@@ -88,6 +187,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 		context,
 		imports,
 		existingReferencedProperties,
+		existingReferencedAllOfRefs,
 		splitMockImplementations
 	});
 	if (Array.isArray(itemType)) {
@@ -108,6 +208,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 			context,
 			imports,
 			existingReferencedProperties,
+			existingReferencedAllOfRefs,
 			splitMockImplementations
 		});
 	}
@@ -131,6 +232,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 				schema: {
 					...prop,
 					name: key,
+					parentName: schemaItem.name,
 					path: schemaItem.path ? `${schemaItem.path}.${key}` : `#.${key}`
 				},
 				mockOptions,
@@ -139,6 +241,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 				context,
 				imports,
 				existingReferencedProperties,
+				existingReferencedAllOfRefs: [],
 				splitMockImplementations
 			});
 			imports.push(...resolvedValue.imports);
@@ -149,7 +252,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 				const omitValue = mockOptions?.nonNullable || !hasNullable ? "undefined" : "null";
 				return `${keyDefinition}: faker.helpers.arrayElement([${resolvedValue.value}, ${omitValue}])`;
 			}
-			if (Array.isArray(prop.type) && prop.type.includes("null") && !resolvedValue.overrided && !mockOptions?.nonNullable) return `${keyDefinition}: faker.helpers.arrayElement([${resolvedValue.value}, null])`;
+			if (Array.isArray(prop.type) && prop.type.includes("null") && !resolvedValue.nullWrapped && !resolvedValue.overrided && !mockOptions?.nonNullable) return `${keyDefinition}: faker.helpers.arrayElement([${resolvedValue.value}, null])`;
 			return `${keyDefinition}: ${resolvedValue.value}`;
 		}).filter(Boolean);
 		if (allowOverride) propertyScalars.push(`...${overrideVarName}`);
@@ -186,6 +289,7 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 			context,
 			imports,
 			existingReferencedProperties,
+			existingReferencedAllOfRefs: [],
 			splitMockImplementations
 		});
 		return {
@@ -202,8 +306,145 @@ function getMockObject({ item, mockOptions, operationId, tags, combine, context,
 	};
 }
 //#endregion
+//#region src/faker/getters/array-item-factory.ts
+/**
+* Scope key for file-level array-item factory dedup. Must match how writers
+* group mock output: one bucket per tag file in tags modes, otherwise one
+* bucket for the whole target.
+*/
+function getArrayItemMockFileScope(context, tags) {
+	const mode = context.output.mode;
+	if (mode === OutputMode.TAGS || mode === OutputMode.TAGS_SPLIT) return `tag:${kebab(tags.length > 0 ? tags[0] : DefaultTag)}`;
+	if (mode === OutputMode.SPLIT) return "split";
+	return "single";
+}
+function getFileLevelExtractedFactories(context, scope) {
+	context.arrayItemMockFactories ??= /* @__PURE__ */ new Map();
+	const existing = context.arrayItemMockFactories.get(scope);
+	if (existing) return existing;
+	const factories = /* @__PURE__ */ new Set();
+	context.arrayItemMockFactories.set(scope, factories);
+	return factories;
+}
+/**
+* True when the active faker generator entry opts into reusable array-item
+* mock factories for object-like array item schemas in operation responses.
+*/
+function shouldExtractArrayItemFactories(context) {
+	return !!context.output.mock.generators.find((g) => !isFunction(g) && g.type === OutputMockType.FAKER && g.arrayItems === true);
+}
+/**
+* True when `schemas: true` already emits a consolidated factory for this
+* `$ref` item under `components/schemas`, so we must not re-export it from
+* the operation mock file.
+*/
+function hasConsolidatedSchemaFactory(items, context) {
+	if (!context.output.schemas) return false;
+	const itemsRef = extractItemsRef(items);
+	if (!itemsRef) return false;
+	const { refPaths } = getRefInfo(itemsRef, context);
+	if (!(Array.isArray(refPaths) && refPaths[0] === "components" && refPaths[1] === "schemas")) return false;
+	return context.output.mock.generators.some((g) => !isFunction(g) && g.type === OutputMockType.FAKER && g.schemas === true);
+}
+/**
+* True when `parentName` looks like a nested property key rather than the
+* generated response wrapper type (e.g. `outer` vs `GetTenants200`). Inlining
+* avoids factory/type-name collisions and mismatched `<Parent><Prop>Item` aliases.
+*/
+function isAmbiguousInlineItemContext(operationId, parentName) {
+	if (!parentName) return false;
+	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) {
+	if (schema.type === "object" || schema.properties) return true;
+	if (schema.allOf) return true;
+	return false;
+}
+/**
+* True when array `items` resolve to an object-like schema worth extracting.
+* Conservative: skips scalar refs, oneOf/anyOf, nullable items, and nested
+* contexts where generated item type names cannot be inferred reliably.
+*/
+function shouldExtractArrayItem(items, context, operationId, parentName) {
+	const itemsRef = extractItemsRef(items);
+	if (itemsRef) try {
+		const { schema } = resolveRef({ $ref: itemsRef }, context);
+		return isResolvedSchemaObjectLike(schema);
+	} catch {
+		return false;
+	}
+	if (isReference(items)) return false;
+	const schema = items;
+	if (isNullableArrayItem(schema)) return false;
+	if (schema.oneOf || schema.anyOf) return false;
+	if (schema.allOf) return true;
+	if (schema.type === "object" || schema.properties) return !isAmbiguousInlineItemContext(operationId, parentName);
+	return false;
+}
+/**
+* True when `mapValue` is already a bare factory call or a single spread of one.
+*/
+function isAlreadyFactoryCall(mapValue) {
+	return /^(?:\{\s*\.\.\.\s*get\w+Mock\(\)\s*\}|get\w+Mock\(\))$/.test(mapValue.trim());
+}
+/**
+* Derive the exported factory and TypeScript type names for an array item.
+*/
+function getArrayItemFactoryNames({ items, propertyName, parentName, operationId, context }) {
+	if (!shouldExtractArrayItem(items, context, operationId, parentName)) return;
+	const itemsRef = extractItemsRef(items);
+	if (itemsRef) {
+		const { name } = getRefInfo(itemsRef, context);
+		const typeName = pascal(name);
+		return {
+			factoryName: `get${typeName}Mock`,
+			typeName
+		};
+	}
+	const itemSuffix = context.output.override.components.schemas.itemSuffix;
+	const typeName = parentName ? `${pascal(parentName)}${pascal(propertyName)}${itemSuffix}` : `${pascal(operationId)}${pascal(propertyName)}${itemSuffix}`;
+	return {
+		factoryName: `get${pascal(operationId)}Response${pascal(propertyName)}ItemMock`,
+		typeName
+	};
+}
+/**
+* When `arrayItems: true`, lift an object-like array item mock body into a
+* reusable exported factory and return the call site expression for `.map()`.
+*/
+function extractArrayItemMock({ items, propertyName, parentName, operationId, tags, mapValue, context, splitMockImplementations, imports }) {
+	if (!shouldExtractArrayItemFactories(context)) return;
+	if (!mapValue || mapValue === "[]" || isAlreadyFactoryCall(mapValue) || hasConsolidatedSchemaFactory(items, context)) return;
+	const names = getArrayItemFactoryNames({
+		items,
+		propertyName,
+		parentName,
+		operationId,
+		context
+	});
+	if (!names) return;
+	const { factoryName, typeName } = names;
+	const fileLevelFactories = getFileLevelExtractedFactories(context, getArrayItemMockFileScope(context, tags));
+	if (!(fileLevelFactories.has(factoryName) || splitMockImplementations.some((f) => f.includes(`export const ${factoryName}`)))) {
+		const mockOptions = context.output.override.mock;
+		const { param, returnType, returnCast } = getMockFactorySignatureParts(typeName, mockOptions, {
+			isOverridable: true,
+			overrideType: `Partial<${typeName}>`
+		});
+		const func = formatMockFactoryDeclaration(factoryName, param, returnType, `{${mapValue.startsWith("...") ? "" : "..."}${mapValue}, ...${overrideVarName}}`, returnCast, { terminateStatement: true });
+		splitMockImplementations.push(func);
+		fileLevelFactories.add(factoryName);
+	}
+	imports.push({ name: typeName });
+	return `{...${factoryName}()}`;
+}
+//#endregion
 //#region src/faker/getters/scalar.ts
-function getMockScalar({ item, imports, mockOptions, operationId, tags, combine, context, existingReferencedProperties, splitMockImplementations, allowOverride = false }) {
+function getMockScalar({ item, imports, mockOptions, operationId, tags, combine, context, existingReferencedProperties, existingReferencedAllOfRefs = [], splitMockImplementations, allowOverride = false }) {
 	const safeMockOptions = mockOptions ?? {};
 	const nonNullableOption = safeMockOptions.nonNullable;
 	if (item.isRef) existingReferencedProperties = [...existingReferencedProperties, item.name];
@@ -234,12 +475,14 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 		...Object.fromEntries(Object.entries(formatOverrides).filter((entry) => typeof entry[1] === "string"))
 	};
 	const isNullable = Array.isArray(item.type) && item.type.includes("null");
+	const nullWrapped = isNullable && !nonNullableOption;
 	const schemaContentMediaType = item.contentMediaType;
 	if (!item.format && schemaContentMediaType === "application/octet-stream" && ALL_FORMAT.binary) return {
 		value: getNullable(ALL_FORMAT.binary, isNullable, nonNullableOption),
 		imports: [],
 		name: item.name,
-		overrided: false
+		overrided: false,
+		nullWrapped
 	};
 	if (item.format && ALL_FORMAT[item.format]) {
 		let value = ALL_FORMAT[item.format];
@@ -248,7 +491,8 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 			value: getNullable(value, isNullable, nonNullableOption),
 			imports: [],
 			name: item.name,
-			overrided: false
+			overrided: false,
+			nullWrapped
 		};
 	}
 	const type = getItemType(item);
@@ -279,7 +523,8 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 				value,
 				enums: item.enum,
 				imports: numberImports,
-				name: item.name
+				name: item.name,
+				nullWrapped: nullWrapped && !item.enum && !("const" in item)
 			};
 		}
 		case "boolean": {
@@ -306,10 +551,12 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 				imports: [],
 				name: item.name
 			};
+			const resolvedItems = itemsRef && !("$ref" in item.items) ? { $ref: itemsRef } : item.items;
 			const { value, enums, imports: resolvedImports } = resolveMockValue({
 				schema: {
-					...itemsRef && !("$ref" in item.items) ? { $ref: itemsRef } : item.items,
+					...resolvedItems,
 					name: item.name,
+					parentName: item.parentName,
 					path: item.path ? `${item.path}.[]` : "#.[]"
 				},
 				combine,
@@ -319,6 +566,7 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 				context,
 				imports,
 				existingReferencedProperties,
+				existingReferencedAllOfRefs,
 				splitMockImplementations
 			});
 			if (enums) return {
@@ -327,6 +575,18 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 				name: item.name
 			};
 			let mapValue = value;
+			const extractedItemCall = extractArrayItemMock({
+				items: resolvedItems,
+				propertyName: item.name,
+				parentName: item.parentName,
+				operationId,
+				tags,
+				mapValue,
+				context,
+				splitMockImplementations,
+				imports: resolvedImports
+			});
+			if (extractedItemCall) mapValue = extractedItemCall;
 			if (combine && !value.startsWith("faker") && !value.startsWith("{") && !value.startsWith("Array.from")) mapValue = `{${value}}`;
 			const arrSchemaMin = item.minItems;
 			const arrSchemaMax = item.maxItems;
@@ -377,7 +637,8 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 				value: getNullable(value, isNullable, nonNullableOption),
 				enums: item.enum,
 				name: item.name,
-				imports: stringImports
+				imports: stringImports,
+				nullWrapped
 			};
 		}
 		case "null": return {
@@ -407,6 +668,7 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 				context,
 				imports,
 				existingReferencedProperties,
+				existingReferencedAllOfRefs,
 				splitMockImplementations,
 				allowOverride
 			});
@@ -470,7 +732,8 @@ function stripArrayMarkerSegments(s) {
 function resolveMockOverride(properties = {}, item, nonNullableOption) {
 	const path = item.path ?? `#.${item.name}`;
 	const normalizedPath = stripArrayMarkerSegments(path);
-	const property = Object.entries(properties).find(([key]) => {
+	const entries = Object.entries(properties);
+	let property = entries.find(([key]) => {
 		if (isRegex(key)) {
 			const regex = new RegExp(key.slice(1, -1));
 			if (regex.test(item.name) || regex.test(path)) return true;
@@ -478,6 +741,7 @@ function resolveMockOverride(properties = {}, item, nonNullableOption) {
 		if (`#.${stripArrayMarkerSegments(key)}` === normalizedPath) return true;
 		return false;
 	});
+	if (!property) property = entries.find(([key]) => !isRegex(key) && !key.includes(".") && key === item.name);
 	if (!property) return;
 	return {
 		value: getNullable(property[1], isNullableSchema(item), nonNullableOption),
@@ -544,7 +808,7 @@ function hasOverrideTouchingSchema(schemaProperties, mockOptions, operationId, t
 		});
 	});
 }
-function resolveMockValue({ schema, mockOptions, operationId, tags, combine, context, imports, existingReferencedProperties, splitMockImplementations, allowOverride }) {
+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);
@@ -586,10 +850,11 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 				schemaFactory: true
 			});
 			return {
-				value: getNullable(newSchema.type === "object" || !!newSchema.allOf || !!newSchema.oneOf || !!newSchema.anyOf ? `{ ...${factoryName}() }` : `${factoryName}()`, Boolean(newSchema.nullable), mockOptions?.nonNullable),
+				value: getNullable(newSchema.type === "object" || !!newSchema.allOf || resolvesToObjectLike(newSchema, context) ? `{ ...${factoryName}() }` : `${factoryName}()`, Boolean(newSchema.nullable), mockOptions?.nonNullable),
 				imports,
 				name: newSchema.name,
-				type: getType(newSchema)
+				type: getType(newSchema),
+				nullWrapped: Boolean(newSchema.nullable) && !mockOptions?.nonNullable
 			};
 		}
 		const scalar = getMockScalar({
@@ -604,6 +869,7 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 			context,
 			imports,
 			existingReferencedProperties,
+			existingReferencedAllOfRefs,
 			splitMockImplementations,
 			allowOverride
 		});
@@ -611,9 +877,13 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 			const funcName = `get${pascal(operationId)}Response${pascal(newSchema.name)}Mock`;
 			if (!splitMockImplementations.some((f) => f.includes(`export const ${funcName}`))) {
 				const discriminatedProperty = newSchema.discriminator?.propertyName;
-				let type = `Partial<${newSchema.name}>`;
-				if (discriminatedProperty) type = `Omit<${type}, '${discriminatedProperty}'>`;
-				const func = `export const ${funcName} = (${`${overrideVarName}: ${type} = {}`}): ${newSchema.name} => ({${scalar.value.startsWith("...") ? "" : "..."}${scalar.value}, ...${overrideVarName}});`;
+				let overrideType = `Partial<${newSchema.name}>`;
+				if (discriminatedProperty) overrideType = `Omit<${overrideType}, '${discriminatedProperty}'>`;
+				const { param, returnType, returnCast } = getMockFactorySignatureParts(newSchema.name, mockOptions, {
+					isOverridable: true,
+					overrideType
+				});
+				const func = formatMockFactoryDeclaration(funcName, param, returnType, `{${scalar.value.startsWith("...") ? "" : "..."}${scalar.value}, ...${overrideVarName}}`, returnCast, { terminateStatement: true });
 				splitMockImplementations.push(func);
 			}
 			scalar.value = newSchema.nullable ? `${funcName}()` : `{...${funcName}()}`;
@@ -634,6 +904,7 @@ function resolveMockValue({ schema, mockOptions, operationId, tags, combine, con
 			context,
 			imports,
 			existingReferencedProperties,
+			existingReferencedAllOfRefs,
 			splitMockImplementations,
 			allowOverride
 		}),
@@ -644,13 +915,27 @@ function getType(schema) {
 	if (isReference(schema)) return;
 	return schema.type ?? (schema.properties ? "object" : schema.items ? "array" : void 0);
 }
+function resolvesToObjectLike(schema, context, seen = /* @__PURE__ */ new Set()) {
+	let resolved;
+	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;
+	} else resolved = schema;
+	if (!resolved) return false;
+	if (resolved.type === "object" || resolved.properties || resolved.additionalProperties || resolved.allOf) return true;
+	const branches = resolved.oneOf ?? resolved.anyOf;
+	if (branches && branches.length > 0) return branches.every((branch) => resolvesToObjectLike(branch, context, seen));
+	return false;
+}
 //#endregion
 //#region src/faker/getters/combine.ts
 function getReferenceName(ref, context) {
 	if (!ref) return "";
 	return getRefInfo(ref, context).name;
 }
-function combineSchemasMock({ item, separator, mockOptions, operationId, tags, combine, context, imports, existingReferencedProperties, splitMockImplementations }) {
+function combineSchemasMock({ item, separator, mockOptions, operationId, tags, combine, context, imports, existingReferencedProperties, existingReferencedAllOfRefs = [], splitMockImplementations }) {
 	const combineImports = [];
 	const includedProperties = [...combine?.includedProperties ?? []];
 	const separatorItems = item[separator] ?? [];
@@ -687,6 +972,7 @@ function combineSchemasMock({ item, separator, mockOptions, operationId, tags, c
 		context,
 		imports,
 		existingReferencedProperties,
+		existingReferencedAllOfRefs,
 		splitMockImplementations
 	}) : void 0;
 	includedProperties.push(...itemResolvedValue?.includedProperties ?? []);
@@ -700,7 +986,7 @@ function combineSchemasMock({ item, separator, mockOptions, operationId, tags, c
 	let value = separator === "allOf" ? "" : "faker.helpers.arrayElement([";
 	for (const val of separatorItems) {
 		const refName = isReference(val) ? getReferenceName(val.$ref, context) : "";
-		if (separator === "allOf" ? refName && (refName === item.name || existingReferencedProperties.includes(refName) && !item.isRef) : refName && existingReferencedProperties.includes(refName)) {
+		if (separator === "allOf" ? refName && (refName === item.name || existingReferencedProperties.includes(refName) && !item.isRef || existingReferencedAllOfRefs.includes(refName)) : refName && existingReferencedProperties.includes(refName)) {
 			if (separatorItems.length === 1) value = "undefined";
 			continue;
 		}
@@ -730,6 +1016,7 @@ function combineSchemasMock({ item, separator, mockOptions, operationId, tags, c
 			context,
 			imports,
 			existingReferencedProperties,
+			existingReferencedAllOfRefs: separator === "allOf" && refName ? [...existingReferencedAllOfRefs, refName] : [],
 			splitMockImplementations
 		});
 		combineImports.push(...resolvedValue.imports);
@@ -825,6 +1112,7 @@ function getMockWithoutFunc(spec, override) {
 		numberMin: override?.mock?.numberMin,
 		numberMax: override?.mock?.numberMax,
 		required: override?.mock?.required,
+		nonNullable: override?.mock?.nonNullable,
 		fractionDigits: override?.mock?.fractionDigits,
 		...override?.mock?.properties ? { properties: getMockPropertiesWithoutFunc(override.mock.properties, spec) } : {},
 		...override?.mock?.format ? { format: getMockPropertiesWithoutFunc(override.mock.format, spec) } : {},
@@ -1023,7 +1311,28 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
 	const overrideResponseType = `Partial<Extract<${nonVoidMockReturnType}, object>>`;
 	const shouldPreferJsonResponse = hasJsonContentType && !hasStringReturnType;
 	const needsRuntimeContentTypeSwitch = isTextResponse && hasJsonContentType && hasStringReturnType && mockReturnType !== "string";
-	const mockImplementation = isReturnHttpResponse ? `${mockImplementations}export const ${getResponseMockFunctionName} = (${isResponseOverridable ? `overrideResponse: ${overrideResponseType} = {}` : ""})${mockData ? "" : `: ${nonVoidMockReturnType}`} => (${value})\n\n` : mockImplementations;
+	const mockOptionsFromOverride = override.mock;
+	const strictMock = isStrictMock(mockOptionsFromOverride);
+	const schemaTypeNames = strictMock ? getSchemaTypeNamesFromResponses(responses) : [];
+	const strictMockReturnType = strictMock ? applyStrictMockReturnType(nonVoidMockReturnType, schemaTypeNames) : nonVoidMockReturnType;
+	const simpleSchemaReturnType = strictMock ? getSimpleSchemaReturnType(nonVoidMockReturnType, schemaTypeNames) : void 0;
+	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;
+	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";
 	const resolvedResponseExpr = `overrideResponse !== undefined
@@ -1093,35 +1402,40 @@ export const ${handlerName} = (overrideResponse?: ${mockReturnType} | ((${infoPa
 			handlerName,
 			handler: handlerImplementation
 		},
-		imports: includeResponseImports
+		imports: includeResponseImports,
+		strictMockSchemaTypeNames: strictMock && schemaTypeNames.length > 0 ? schemaTypeNames : void 0
 	};
 }
 function generateMSW(generatorVerbOptions, generatorOptions) {
 	const { pathRoute, override, mock } = generatorOptions;
-	const { operationId, response } = generatorVerbOptions;
+	const { operationName, response } = generatorVerbOptions;
 	const overrideBaseUrl = override.mock && "baseUrl" in override.mock ? override.mock.baseUrl : void 0;
 	const mockBaseUrl = mock && isMswMock(mock) ? mock.baseUrl : void 0;
 	const route = getRouteMSW(pathRoute, overrideBaseUrl ?? mockBaseUrl);
-	const handlerName = `get${pascal(operationId)}MockHandler`;
-	const getResponseMockFunctionName = `get${pascal(operationId)}ResponseMock`;
+	const handlerName = `get${pascal(operationName)}MockHandler`;
+	const getResponseMockFunctionName = `get${pascal(operationName)}ResponseMock`;
 	const splitMockImplementations = [];
 	const baseDefinition = generateDefinition("", route, getResponseMockFunctionName, handlerName, generatorVerbOptions, generatorOptions, response.definition.success, response.types.success[0]?.key ?? "200", response.imports, response.types.success, response.contentTypes, splitMockImplementations);
 	const mockImplementations = [baseDefinition.implementation.function];
 	const handlerImplementations = [baseDefinition.implementation.handler];
 	const imports = [...baseDefinition.imports];
+	const strictMockSchemaTypeNames = new Set(baseDefinition.strictMockSchemaTypeNames);
 	if (generatorOptions.mock && isObject(generatorOptions.mock) && generatorOptions.mock.generateEachHttpStatus) for (const statusResponse of [...response.types.success, ...response.types.errors]) {
 		const definition = generateDefinition(statusResponse.key, route, getResponseMockFunctionName, handlerName, generatorVerbOptions, generatorOptions, statusResponse.value, statusResponse.key, response.imports, [statusResponse], [statusResponse.contentType], splitMockImplementations);
 		mockImplementations.push(definition.implementation.function);
 		handlerImplementations.push(definition.implementation.handler);
 		imports.push(...definition.imports);
+		for (const name of definition.strictMockSchemaTypeNames ?? []) strictMockSchemaTypeNames.add(name);
 	}
+	const aggregatedStrictNames = [...strictMockSchemaTypeNames];
 	return {
 		implementation: {
 			function: mockImplementations.join("\n"),
 			handlerName,
 			handler: handlerImplementations.join("\n")
 		},
-		imports
+		imports,
+		strictMockSchemaTypeNames: aggregatedStrictNames.length > 0 ? aggregatedStrictNames : void 0
 	};
 }
 //#endregion
@@ -1158,7 +1472,8 @@ function generateFaker(generatorVerbOptions, generatorOptions) {
 			handler: "",
 			handlerName: ""
 		},
-		imports: result.imports
+		imports: result.imports,
+		strictMockSchemaTypeNames: result.strictMockSchemaTypeNames
 	};
 }
 /**
@@ -1172,6 +1487,7 @@ function generateFaker(generatorVerbOptions, generatorOptions) {
 */
 function generateFakerForSchemas(schemas, context, options) {
 	const factories = [];
+	const strictMockTypeNames = /* @__PURE__ */ new Set();
 	const allImports = [];
 	const splitMockImplementations = [];
 	const localFactoryNames = new Set(schemas.filter((s) => !!s.schema).map((s) => `get${pascal(s.name)}Mock`));
@@ -1198,7 +1514,12 @@ function generateFakerForSchemas(schemas, context, options) {
 		});
 		allImports.push(...result.imports, ...factoryImports);
 		const typeName = pascal(name);
-		const factory = `export const ${factoryName} = (${result.value.includes("overrideResponse") ? `overrideResponse: Partial<${typeName}> = {}` : ""}): ${typeName} => (${result.value});\n`;
+		const { param, returnType, returnCast } = getMockFactorySignatureParts(typeName, mockOptions, {
+			isOverridable: result.value.includes("overrideResponse"),
+			overrideType: `Partial<${typeName}>`
+		});
+		const factory = formatMockFactoryDeclaration(factoryName, param, returnType, result.value, returnCast);
+		if (isStrictMock(mockOptions)) strictMockTypeNames.add(typeName);
 		factories.push(factory);
 		allImports.push({
 			name: pascal(name),
@@ -1217,9 +1538,12 @@ function generateFakerForSchemas(schemas, context, options) {
 		if (!existing.values && imp.values) mergedImports.set(key, imp);
 	}
 	const uniqueImports = [...mergedImports.values()];
+	const implementation = [...splitMockImplementations, ...factories].filter(Boolean).join("\n\n");
+	const aggregatedStrictNames = [...strictMockTypeNames];
 	return {
-		implementation: [...splitMockImplementations, ...factories].join("\n"),
-		imports: uniqueImports
+		implementation,
+		imports: uniqueImports,
+		strictMockSchemaTypeNames: aggregatedStrictNames.length > 0 ? aggregatedStrictNames : void 0
 	};
 }
 //#endregion
@@ -1267,6 +1591,6 @@ function generateMock(generatorVerbOptions, generatorOptions) {
 	}
 }
 //#endregion
-export { DEFAULT_FAKER_OPTIONS, DEFAULT_MSW_OPTIONS, generateFaker, generateFakerForSchemas, generateFakerImports, generateMSW, generateMSWImports, generateMock, generateMockImports, getDefaultMockOptionsForType };
+export { DEFAULT_FAKER_OPTIONS, DEFAULT_MSW_OPTIONS, buildStrictMockTypeFileHeader, dedupeStrictMockTypeDeclarations, generateFaker, generateFakerForSchemas, generateFakerImports, generateMSW, generateMSWImports, generateMock, generateMockImports, getDefaultMockOptionsForType };
 
 //# sourceMappingURL=index.mjs.map