feat(mock): emit strict Mock return types when required and nonNullable are both true

packages/core/src/types.ts

@@ -1305,6 +1305,7 @@ export interface GeneratorMockOutput {
   type: OutputMockType;
   implementation: string;
   imports: GeneratorImport[];
+  strictMockSchemaTypeNames?: string[];
 }
 
 export interface GeneratorMockOutputFull {
@@ -1315,6 +1316,7 @@ export interface GeneratorMockOutputFull {
     handlerName: string;
   };
   imports: GeneratorImport[];
+  strictMockSchemaTypeNames?: string[];
 }
 
 export interface GeneratorTarget {
@@ -1482,6 +1484,7 @@ export interface ClientMockGeneratorImplementation {
 export interface ClientMockGeneratorBuilder {
   imports: GeneratorImport[];
   implementation: ClientMockGeneratorImplementation;
+  strictMockSchemaTypeNames?: string[];
 }
 
 export type ClientMockBuilder = (
@@ -1644,6 +1647,11 @@ export type ResReqTypesValue = ScalarValue & {
   originalSchema?: OpenApiSchemaObject;
 };
 
+export interface FinalizeMockImplementationOptions {
+  mockOptions?: Pick<MockOptions, 'required' | 'nonNullable'>;
+  strictSchemaTypeNames?: readonly string[];
+}
+
 export interface WriteSpecBuilder {
   operations: GeneratorOperations;
   verbOptions: Record<string, GeneratorVerbOptions>;
@@ -1653,6 +1661,11 @@ export interface WriteSpecBuilder {
   footer: GeneratorClientFooter;
   imports: GeneratorClientImports;
   importsMock: GenerateMockImports;
+  /** Hoists shared strict-mock type aliases once per aggregated mock file. */
+  finalizeMockImplementation?: (
+    implementation: string,
+    options: FinalizeMockImplementationOptions,
+  ) => string;
   extraFiles: ClientFileBuilder[];
   info: OpenApiInfoObject;
   target: string;
@@ -1740,6 +1753,11 @@ export type GeneratorApiBuilder = GeneratorApiOperations & {
   footer: GeneratorClientFooter;
   imports: GeneratorClientImports;
   importsMock: GenerateMockImports;
+  /** Hoists shared strict-mock type aliases once per aggregated mock file. */
+  finalizeMockImplementation?: (
+    implementation: string,
+    options: FinalizeMockImplementationOptions,
+  ) => string;
   extraFiles: ClientFileBuilder[];
 };
 

packages/core/src/writers/finalize-mock-implementation.ts

@@ -0,0 +1,34 @@
+import type {
+  FinalizeMockImplementationOptions,
+  GeneratorMockOutput,
+  NormalizedOutputOptions,
+} from '../types';
+
+type MockOutputWithStrictNames = Pick<
+  GeneratorMockOutput,
+  'strictMockSchemaTypeNames'
+>;
+
+export function getFinalizeMockImplementationOptions(
+  output: NormalizedOutputOptions,
+  mockOutputs: MockOutputWithStrictNames | readonly MockOutputWithStrictNames[],
+): FinalizeMockImplementationOptions {
+  const outputs: readonly MockOutputWithStrictNames[] = Array.isArray(
+    mockOutputs,
+  )
+    ? mockOutputs
+    : [mockOutputs];
+  const strictSchemaTypeNames = [
+    ...new Set(
+      outputs.flatMap(
+        (mockOutput) => mockOutput.strictMockSchemaTypeNames ?? [],
+      ),
+    ),
+  ];
+
+  return {
+    mockOptions: output.override.mock,
+    strictSchemaTypeNames:
+      strictSchemaTypeNames.length > 0 ? strictSchemaTypeNames : undefined,
+  };
+}

packages/core/src/writers/single-mode.ts

@@ -10,6 +10,7 @@ import {
 } from '../utils';
 import { escapeRegExp } from '../utils/string';
 import { writeGeneratedFile } from './file';
+import { getFinalizeMockImplementationOptions } from './finalize-mock-implementation';
 import { generateImportsForBuilder } from './generate-imports-for-builder';
 import { collapseInlineMockOutputs } from './mock-outputs';
 import { generateTarget } from './target';
@@ -56,6 +57,12 @@ export async function writeSingleMode({
     const implementationMock = mockOutputs
       .map((m) => m.implementation)
       .join('\n\n');
+    const finalizedImplementationMock = builder.finalizeMockImplementation
+      ? builder.finalizeMockImplementation(
+          implementationMock,
+          getFinalizeMockImplementationOptions(output, mockOutputs),
+        )
+      : implementationMock;
     // Aggregate imports across all mock entries for the value-import promotion
     // pass below.
     const importsMock = mockOutputs.flatMap((m) => m.imports);
@@ -222,7 +229,7 @@ export async function writeSingleMode({
 
     if (mockOutputs.length > 0) {
       data += '\n\n';
-      data += implementationMock;
+      data += finalizedImplementationMock;
     }
 
     await writeGeneratedFile(path, data);

packages/core/src/writers/split-mode.ts

@@ -16,6 +16,7 @@ import {
 } from '../utils';
 import { getMockFileExtensionByTypeName } from '../utils/file-extensions';
 import { writeGeneratedFile } from './file';
+import { getFinalizeMockImplementationOptions } from './finalize-mock-implementation';
 import { generateImportsForBuilder } from './generate-imports-for-builder';
 import { generateTarget } from './target';
 import { getOrvalGeneratedTypes, getTypedResponse } from './types';
@@ -184,15 +185,21 @@ export async function writeSplitMode({
         relativeSchemasPath,
       );
       let mockData = header;
+      const finalizedMockImplementation = builder.finalizeMockImplementation
+        ? builder.finalizeMockImplementation(
+            mockOutput.implementation,
+            getFinalizeMockImplementationOptions(output, mockOutput),
+          )
+        : mockOutput.implementation;
       mockData += builder.importsMock({
-        implementation: mockOutput.implementation,
+        implementation: finalizedMockImplementation,
         imports: importsMockForBuilder,
         projectName,
         hasSchemaDir: !!output.schemas,
         isAllowSyntheticDefaultImports,
         options: entry,
       });
-      mockData += `\n${mockOutput.implementation}`;
+      mockData += `\n${finalizedMockImplementation}`;
 
       const mockPath = path.join(
         dirname,

packages/core/src/writers/split-tags-mode.ts

@@ -20,6 +20,7 @@ import {
 } from '../utils';
 import { getMockFileExtensionByTypeName } from '../utils/file-extensions';
 import { writeGeneratedFile } from './file';
+import { getFinalizeMockImplementationOptions } from './finalize-mock-implementation';
 import { generateImportsForBuilder } from './generate-imports-for-builder';
 import { generateTargetForTags } from './target-tags';
 import { getOrvalGeneratedTypes, getTypedResponse } from './types';
@@ -264,16 +265,22 @@ export async function writeSplitTagsMode({
             relativeSchemasPath,
           );
 
+          const finalizedMockImplementation = builder.finalizeMockImplementation
+            ? builder.finalizeMockImplementation(
+                mockOutput.implementation,
+                getFinalizeMockImplementationOptions(output, mockOutput),
+              )
+            : mockOutput.implementation;
           let mockData = header;
           mockData += builder.importsMock({
-            implementation: mockOutput.implementation,
+            implementation: finalizedMockImplementation,
             imports: importsMockForBuilder,
             projectName,
             hasSchemaDir: !!output.schemas,
             isAllowSyntheticDefaultImports,
             options: entry,
           });
-          mockData += `\n${mockOutput.implementation}`;
+          mockData += `\n${finalizedMockImplementation}`;
 
           const mockPath = path.join(
             dirname,

packages/core/src/writers/tags-mode.ts

@@ -13,6 +13,7 @@ import {
 } from '../utils';
 import { escapeRegExp } from '../utils/string';
 import { writeGeneratedFile } from './file';
+import { getFinalizeMockImplementationOptions } from './finalize-mock-implementation';
 import { generateImportsForBuilder } from './generate-imports-for-builder';
 import { collapseInlineMockOutputs } from './mock-outputs';
 import { generateTargetForTags } from './target-tags';
@@ -70,6 +71,12 @@ export async function writeTagsMode({
         const implementationMock = mockOutputs
           .map((m) => m.implementation)
           .join('\n\n');
+        const finalizedImplementationMock = builder.finalizeMockImplementation
+          ? builder.finalizeMockImplementation(
+              implementationMock,
+              getFinalizeMockImplementationOptions(output, mockOutputs),
+            )
+          : implementationMock;
 
         let data = header;
 
@@ -231,7 +238,7 @@ export async function writeTagsMode({
         if (mockOutputs.length > 0) {
           data += '\n\n';
 
-          data += implementationMock;
+          data += finalizedImplementationMock;
         }
 
         const implementationPath = path.join(

packages/core/src/writers/target-tags.ts

@@ -39,6 +39,7 @@ function flattenMockOutput(full: GeneratorMockOutputFull): GeneratorMockOutput {
     type: full.type,
     implementation: full.implementation.function + full.implementation.handler,
     imports: full.imports,
+    strictMockSchemaTypeNames: full.strictMockSchemaTypeNames,
   };
 }
 
@@ -58,6 +59,14 @@ function mergeOperationMockOutputs(
       result.push(acc);
     }
     acc.imports.push(...op.imports);
+    if (op.strictMockSchemaTypeNames?.length) {
+      acc.strictMockSchemaTypeNames = [
+        ...new Set([
+          ...(acc.strictMockSchemaTypeNames ?? []),
+          ...op.strictMockSchemaTypeNames,
+        ]),
+      ];
+    }
     acc.implementation.function += op.implementation.function;
     acc.implementation.handler += op.implementation.handler;
     if (op.implementation.handlerName) {

packages/core/src/writers/target.ts

@@ -24,6 +24,7 @@ function flattenMockOutput(full: GeneratorMockOutputFull): GeneratorMockOutput {
     type: full.type,
     implementation: full.implementation.function + full.implementation.handler,
     imports: full.imports,
+    strictMockSchemaTypeNames: full.strictMockSchemaTypeNames,
   };
 }
 
@@ -70,6 +71,14 @@ export function generateTarget(
         target.mockOutputs.push(acc);
       }
       acc.imports.push(...opMock.imports);
+      if (opMock.strictMockSchemaTypeNames?.length) {
+        acc.strictMockSchemaTypeNames = [
+          ...new Set([
+            ...(acc.strictMockSchemaTypeNames ?? []),
+            ...opMock.strictMockSchemaTypeNames,
+          ]),
+        ];
+      }
       acc.implementation.function += opMock.implementation.function;
       acc.implementation.handler += opMock.implementation.handler;
       if (opMock.implementation.handlerName) {

packages/mock/src/faker/getters/array-item-factory.ts

@@ -13,6 +13,10 @@ import {
   resolveRef,
 } from '@orval/core';
 
+import {
+  formatMockFactoryDeclaration,
+  getMockFactorySignatureParts,
+} from '../../mock-types';
 import type { MockSchema } from '../../types';
 import { overrideVarName } from './object';
 import { extractItemsRef } from './scalar';
@@ -300,11 +304,24 @@ export function extractArrayItemMock({
     );
 
   if (!alreadyExtracted) {
-    const args = `${overrideVarName}: Partial<${typeName}> = {}`;
+    const mockOptions = context.output.override.mock;
+    const { param, returnType, returnCast } = getMockFactorySignatureParts(
+      typeName,
+      mockOptions,
+      {
+        isOverridable: true,
+        overrideType: `Partial<${typeName}>`,
+      },
+    );
     const spreadPrefix = mapValue.startsWith('...') ? '' : '...';
-    const func =
-      `export const ${factoryName} = (${args}): ${typeName} => ` +
-      `({${spreadPrefix}${mapValue}, ...${overrideVarName}});`;
+    const func = formatMockFactoryDeclaration(
+      factoryName,
+      param,
+      returnType,
+      `{${spreadPrefix}${mapValue}, ...${overrideVarName}}`,
+      returnCast,
+      { terminateStatement: true },
+    );
     splitMockImplementations.push(func);
     fileLevelFactories.add(factoryName);
   }

packages/mock/src/faker/index.test.ts

@@ -10,7 +10,12 @@ import type {
 import { isFakerMock, isMswMock, OutputMockType } from '@orval/core';
 import { describe, expect, expectTypeOf, it } from 'vitest';
 
-import { generateFaker, generateFakerImports } from './index';
+import { createTestContextSpec } from '../../../core/src/test-utils/context';
+import {
+  generateFaker,
+  generateFakerForSchemas,
+  generateFakerImports,
+} from './index';
 
 const mockVerbOptions = {
   operationId: 'getUser',
@@ -155,3 +160,47 @@ describe('discriminated GlobalMockOptions union', () => {
     expect(isFakerMock(mock)).toBe(false);
   });
 });
+
+describe('generateFakerForSchemas strict mock types (#3525)', () => {
+  const context = createTestContextSpec({
+    override: {
+      mock: {
+        required: true,
+        nonNullable: true,
+      },
+    },
+  });
+
+  it('emits PetMock alias and return type for schema factories', () => {
+    const result = generateFakerForSchemas(
+      [
+        {
+          name: 'Pet',
+          model: 'Pet',
+          imports: [],
+          schema: {
+            type: 'object',
+            required: ['id', 'name'],
+            properties: {
+              id: { type: 'integer' },
+              name: { type: 'string' },
+              tag: { type: 'string', nullable: true },
+            },
+          },
+        },
+      ],
+      context,
+      { type: OutputMockType.FAKER, schemas: true },
+    );
+
+    expect(result.implementation).toContain('export type PetMock = {');
+    expect(result.implementation).toContain('export type KeysWithNull<O>');
+    expect(result.implementation).toContain(
+      'export const getPetMock = <O extends Partial<Pet> = {}>(overrideResponse?: O): MockWithNullableOverrides<Pet, O, PetMock> =>',
+    );
+    expect(result.implementation).toContain(
+      ') as MockWithNullableOverrides<Pet, O, PetMock>;',
+    );
+    expect(result.implementation).not.toContain(', null]');
+  });
+});