@orval/mock 8.33.0 → 8.35.0

package/dist/index.d.mts

@@ -5,14 +5,14 @@ import { ClientMockGeneratorBuilder, ContextSpec, FakerMockOptions, FinalizeMock
  * imports from `msw`, so this only emits `import { faker } from '@faker-js/faker'`
  * (or the locale-scoped variant) plus any operation-specific imports.
  */
-declare const generateFakerImports: GenerateMockImports;
+export declare const generateFakerImports: GenerateMockImports;
 /**
  * Generates the faker-only mock output for a single operation. This reuses
  * the response-factory portion of {@link generateMSW} and strips out the
  * handler and aggregator entries so callers can write a standalone
  * `<file>.faker.ts` with no `msw` dependency.
  */
-declare function generateFaker(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions): ClientMockGeneratorBuilder;
+export declare function generateFaker(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions): ClientMockGeneratorBuilder;
 interface GenerateFakerForSchemasResult {
   implementation: string;
   imports: GeneratorImport[];
@@ -28,10 +28,10 @@ interface GenerateFakerForSchemasResult {
  * Returns the function bodies plus any `GeneratorImport` references the
  * factories need so the writer can hoist them into the file header.
  */
-declare function generateFakerForSchemas(schemas: GeneratorSchema[], context: ContextSpec, options: GlobalMockOptions): GenerateFakerForSchemasResult;
+export declare function generateFakerForSchemas(schemas: GeneratorSchema[], context: ContextSpec, options: GlobalMockOptions): GenerateFakerForSchemasResult;
 //#endregion
 //#region src/mock-types.d.ts
-declare function buildStrictMockTypeFileHeader(schemaTypeNames: Iterable<string>, kinds?: Readonly<Record<string, StrictMockSchemaKind$1>>): string;
+export declare function buildStrictMockTypeFileHeader(schemaTypeNames: Iterable<string>, kinds?: Readonly<Record<string, StrictMockSchemaKind$1>>): string;
 /**
  * Prepends shared strict-mock helper types and each `{Schema}Mock` alias once at
  * the top of a mock file. Generators pass `strictSchemaTypeNames`; no scraping.
@@ -39,34 +39,34 @@ declare function buildStrictMockTypeFileHeader(schemaTypeNames: Iterable<string>
  * Not idempotent — callers must invoke this exactly once per aggregated mock
  * file (writers and `writeFakerSchemaMocks`), not from import hooks.
  */
-declare function dedupeStrictMockTypeDeclarations(implementation: string, options?: FinalizeMockImplementationOptions): string;
+export declare function dedupeStrictMockTypeDeclarations(implementation: string, options?: FinalizeMockImplementationOptions): string;
 //#endregion
 //#region src/msw/index.d.ts
-declare const generateMSWImports: GenerateMockImports;
-declare function generateMSW(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions): ClientMockGeneratorBuilder;
+export declare const generateMSWImports: GenerateMockImports;
+export declare function generateMSW(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: GeneratorOptions): ClientMockGeneratorBuilder;
 //#endregion
 //#region src/index.d.ts
-declare const DEFAULT_MSW_OPTIONS: MswMockOptions;
-declare const DEFAULT_FAKER_OPTIONS: FakerMockOptions;
+export declare const DEFAULT_MSW_OPTIONS: MswMockOptions;
+export declare const DEFAULT_FAKER_OPTIONS: FakerMockOptions;
 /**
  * Returns the default GlobalMockOptions for a given mock type. Used when
  * normalizing user-provided entries in `output.mock.generators` so callers
  * can omit the per-type defaults.
  */
-declare const getDefaultMockOptionsForType: (type: GlobalMockOptions["type"]) => GlobalMockOptions;
+export declare const getDefaultMockOptionsForType: (type: GlobalMockOptions["type"]) => GlobalMockOptions;
 /**
  * Dispatches mock-file imports generation to the appropriate generator based
  * on the `OutputMockType` discriminator on the mock options.
  */
-declare const generateMockImports: GenerateMockImports;
+export declare const generateMockImports: GenerateMockImports;
 /**
  * Dispatches per-operation mock generation to the appropriate generator
  * based on the `OutputMockType` discriminator. Each entry in
  * `output.mock.generators` is dispatched here individually.
  */
-declare function generateMock(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: Omit<GeneratorOptions, 'mock'> & {
+export declare function generateMock(generatorVerbOptions: GeneratorVerbOptions, generatorOptions: Omit<GeneratorOptions, 'mock'> & {
   mock: GlobalMockOptions;
 }): import("@orval/core").ClientMockGeneratorBuilder;
 //#endregion
-export { DEFAULT_FAKER_OPTIONS, DEFAULT_MSW_OPTIONS, type GenerateFakerForSchemasResult, buildStrictMockTypeFileHeader, dedupeStrictMockTypeDeclarations, generateFaker, generateFakerForSchemas, generateFakerImports, generateMSW, generateMSWImports, generateMock, generateMockImports, getDefaultMockOptionsForType };
+export type { GenerateFakerForSchemasResult };
 //# sourceMappingURL=index.d.mts.map

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) {
@@ -45,7 +45,7 @@ function isComposedObjectSchema(schema) {
 function getStrictMockTypeDeclaration(typeName, kind = "object", options) {
 	const mockTypeName = getStrictMockTypeName(typeName);
 	if (kind === "alias") return `export type ${mockTypeName} = ${typeName};`;
-	if (kind === "binary") return `export type ${mockTypeName} = ArrayBuffer;`;
+	if (kind === "binary") return `export type ${mockTypeName} = Blob;`;
 	const mappedType = `{\n  [K in keyof Required<NonNullable<${typeName}>>]: NonNullable<Required<NonNullable<${typeName}>>[K]>;\n}`;
 	return `export type ${mockTypeName} = ${options?.schemaNullableAtRoot ? `${mappedType} | null` : mappedType};`;
 }
@@ -316,7 +316,7 @@ const isFakerVersionV9 = (packageJson) => {
 //#region src/faker/constants.ts
 const DEFAULT_FORMAT_MOCK = {
 	bic: "faker.finance.bic()",
-	binary: "new ArrayBuffer(faker.number.int({ min: 1, max: 64 }))",
+	binary: "new Blob([new Uint8Array(faker.number.int({ min: 1, max: 64 }))])",
 	city: "faker.location.city()",
 	country: "faker.location.country()",
 	date: "faker.date.past().toISOString().slice(0, 10)",
@@ -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) {
@@ -894,7 +899,7 @@ function getMockScalar({ item, imports, mockOptions, operationId, tags, combine,
 		overrided: false,
 		nullWrapped
 	};
-	if (item.format && ALL_FORMAT[item.format]) {
+	if (item.format && Object.hasOwn(ALL_FORMAT, item.format)) {
 		let value = ALL_FORMAT[item.format];
 		if (["date", "date-time"].includes(item.format) && context.output.override.useDates) value = `new Date(${value})`;
 		return {
@@ -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
@@ -1826,23 +1847,20 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
 	const isTextResponse = isExactlyStringReturnType && hasTextLikeContentType || contentTypesByPreference.some((ct) => isTextLikeContentType(ct));
 	const isSchemaBinary = (r) => r.originalSchema?.format === "binary" || r.originalSchema?.contentMediaType === "application/octet-stream" && !r.originalSchema.contentEncoding;
 	const isBinaryResponse = preferredContentTypeMatch ? responsesByPreference.some((r) => isSchemaBinary(r)) : contentTypesByPreference.some((ct) => isBinaryLikeContentType(ct)) || responsesByPreference.some((r) => isSchemaBinary(r));
-	const binaryRefNames = responsesByPreference.filter((r) => isSchemaBinary(r)).flatMap((r) => r.imports.flatMap((imp) => imp.alias ? [imp.name, imp.alias] : [imp.name]));
 	const isReturnHttpResponse = value && value !== "undefined";
 	const getResponseMockFunctionName = `${getResponseMockFunctionNameBase}${pascal(name)}`;
 	const handlerName = `${handlerNameBase}${pascal(name)}`;
 	const addedSplitMockImplementations = splitMockImplementations.slice(oldSplitMockImplementations.length);
 	splitMockImplementations.push(...addedSplitMockImplementations);
 	const mockImplementations = addedSplitMockImplementations.length > 0 ? `${addedSplitMockImplementations.join("\n\n")}\n\n` : "";
-	const binaryTypeRewriteRegex = new RegExp(String.raw`\b(?:${["Blob", ...binaryRefNames].map((n) => escapeRegExp(n)).join("|")})\b`, "g");
-	const mockReturnType = isBinaryResponse ? returnType.replaceAll(binaryTypeRewriteRegex, "ArrayBuffer") : returnType;
-	const isVoidUnionType = mockReturnType !== "void" && mockReturnType.split("|").some((part) => part.trim() === "void");
+	const isVoidUnionType = returnType !== "void" && returnType.split("|").some((part) => part.trim() === "void");
 	const noContentStatusCode = isVoidUnionType ? assertSafeStatusCode(responses.find((r) => r.value === "void")?.key ?? "204") : void 0;
-	const nonVoidMockReturnType = isVoidUnionType ? mockReturnType.split("|").filter((part) => part.trim() !== "void").join(" | ").trim() : mockReturnType;
+	const nonVoidMockReturnType = isVoidUnionType ? returnType.split("|").filter((part) => part.trim() !== "void").join(" | ").trim() : returnType;
 	const hasJsonContentType = contentTypesByPreference.some((ct) => ct.includes("json") || ct.includes("+json"));
-	const hasStringReturnType = isTypeExactlyString(mockReturnType) || isUnionContainingString(mockReturnType);
+	const hasStringReturnType = isTypeExactlyString(returnType) || isUnionContainingString(returnType);
 	const overrideResponseType = `Partial<Extract<${nonVoidMockReturnType}, object>>`;
 	const shouldPreferJsonResponse = hasJsonContentType && !hasStringReturnType;
-	const needsRuntimeContentTypeSwitch = isTextResponse && hasJsonContentType && hasStringReturnType && mockReturnType !== "string";
+	const needsRuntimeContentTypeSwitch = isTextResponse && hasJsonContentType && hasStringReturnType && returnType !== "string";
 	const mockOptionsFromOverride = override.mock;
 	const strictMock = isStrictMock(mockOptionsFromOverride);
 	const schemaTypeNames = strictMock ? getSchemaTypeNamesFromResponses(responses) : [];
@@ -1890,10 +1908,7 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
 	if (!isReturnHttpResponse) responseBody = `new HttpResponse(null,
       { status: ${statusCode}
       })`;
-	else if (isBinaryResponse) responseBody = `HttpResponse.arrayBuffer(
-      binaryBody instanceof ArrayBuffer
-        ? binaryBody
-        : new ArrayBuffer(0),
+	else if (isBinaryResponse) responseBody = `new HttpResponse(binaryBody,
       { status: ${statusCode},
         headers: { 'Content-Type': '${jsStringLiteralEscape(binaryContentType)}' }
       })`;
@@ -1920,7 +1935,7 @@ function generateDefinition(name, route, getResponseMockFunctionNameBase, handle
       })`;
 	const infoType = `Parameters<Parameters<typeof http.${verb}>[1]>[0]`;
 	const handlerImplementation = `
-export const ${handlerName} = (overrideResponse?: ${mockReturnType} | ((${infoParam}: ${infoType}) => Promise<${mockReturnType}> | ${mockReturnType}), options?: RequestHandlerOptions) => {
+export const ${handlerName} = (overrideResponse?: ${returnType} | ((${infoParam}: ${infoType}) => Promise<${returnType}> | ${returnType}), options?: RequestHandlerOptions) => {
   return http.${verb}('${route}', async (${infoParam}: ${infoType}) => {${delay === false ? "" : `await delay(${isFunction(delay) ? `(${String(delay)})()` : String(delay)});`}
   ${isReturnHttpResponse ? "" : `if (typeof overrideResponse === 'function') {await overrideResponse(info); }`}
   ${responsePrelude}