refactor(mock): emit strict mock types once from structured names (#3543)

Author: Hypenate

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

@@ -11,6 +11,7 @@ import { isFakerMock, isMswMock, OutputMockType } from '@orval/core';
 import { describe, expect, expectTypeOf, it } from 'vitest';
 
 import { createTestContextSpec } from '../../../core/src/test-utils/context';
+import { dedupeStrictMockTypeDeclarations } from '../mock-types';
 import {
   generateFaker,
   generateFakerForSchemas,
@@ -171,7 +172,7 @@ describe('generateFakerForSchemas strict mock types (#3525)', () => {
     },
   });
 
-  it('emits PetMock alias and return type for schema factories', () => {
+  it('exposes strict schema names and omits inline type declarations', () => {
     const result = generateFakerForSchemas(
       [
         {
@@ -193,8 +194,9 @@ describe('generateFakerForSchemas strict mock types (#3525)', () => {
       { type: OutputMockType.FAKER, schemas: true },
     );
 
-    expect(result.implementation).toContain('export type PetMock = {');
-    expect(result.implementation).toContain('export type KeysWithNull<O>');
+    expect(result.strictMockSchemaTypeNames).toEqual(['Pet']);
+    expect(result.implementation).not.toContain('export type PetMock = {');
+    expect(result.implementation).not.toContain('export type KeysWithNull<O>');
     expect(result.implementation).toContain(
       'export const getPetMock = <O extends Partial<Pet> = {}>(overrideResponse?: O): MockWithNullableOverrides<Pet, O, PetMock> =>',
     );
@@ -203,4 +205,40 @@ describe('generateFakerForSchemas strict mock types (#3525)', () => {
     );
     expect(result.implementation).not.toContain(', null]');
   });
+
+  it('includes non-overridable strict schemas in strictMockSchemaTypeNames', () => {
+    const result = generateFakerForSchemas(
+      [
+        {
+          name: 'Status',
+          model: 'Status',
+          imports: [],
+          schema: {
+            type: 'string',
+            enum: ['active', 'inactive'],
+          },
+        },
+      ],
+      context,
+      { type: OutputMockType.FAKER, schemas: true },
+    );
+
+    expect(result.strictMockSchemaTypeNames).toEqual(['Status']);
+    expect(result.implementation).not.toContain('overrideResponse');
+    expect(result.implementation).toContain(
+      'export const getStatusMock = (): StatusMock =>',
+    );
+    expect(result.implementation).not.toContain('export type StatusMock = {');
+
+    const finalized = dedupeStrictMockTypeDeclarations(result.implementation, {
+      mockOptions: { required: true, nonNullable: true },
+      strictSchemaTypeNames: result.strictMockSchemaTypeNames,
+    });
+
+    expect(finalized).toContain('export type StatusMock = {');
+    expect(finalized).toContain('export type KeysWithNull<O>');
+    expect(finalized.indexOf('export type StatusMock')).toBeLessThan(
+      finalized.indexOf('export const getStatusMock'),
+    );
+  });
 });

packages/mock/src/faker/index.ts

@@ -15,8 +15,6 @@ import {
 import {
   formatMockFactoryDeclaration,
   getMockFactorySignatureParts,
-  getStrictMockHelperTypeDeclarations,
-  getStrictMockTypeDeclaration,
   isStrictMock,
 } from '../mock-types';
 import { generateMSW } from '../msw';
@@ -84,6 +82,7 @@ export function generateFaker(
 export interface GenerateFakerForSchemasResult {
   implementation: string;
   imports: GeneratorImport[];
+  strictMockSchemaTypeNames?: string[];
 }
 
 /**
@@ -166,7 +165,7 @@ export function generateFakerForSchemas(
       returnCast,
     );
 
-    if (isStrictMock(mockOptions) && isOverridable) {
+    if (isStrictMock(mockOptions)) {
       strictMockTypeNames.add(typeName);
     }
 
@@ -215,26 +214,16 @@ export function generateFakerForSchemas(
   // Helper factories from union/discriminator handling (`splitMockImplementations`)
   // are emitted before the public `get<Schema>Mock` factories so call sites
   // declared after them resolve cleanly without TS hoisting concerns.
-  const strictHelperBlock = isStrictMock(mockOptions)
-    ? getStrictMockHelperTypeDeclarations()
-    : '';
-  const strictTypeDeclarations = isStrictMock(mockOptions)
-    ? [...strictMockTypeNames]
-        .map((typeName) => getStrictMockTypeDeclaration(typeName))
-        .join('\n\n')
-    : '';
-  const strictTypeBlock = strictTypeDeclarations;
-  const implementation = [
-    ...splitMockImplementations,
-    strictHelperBlock,
-    strictTypeBlock,
-    ...factories,
-  ]
+  const implementation = [...splitMockImplementations, ...factories]
     .filter(Boolean)
     .join('\n\n');
 
+  const aggregatedStrictNames = [...strictMockTypeNames];
+
   return {
     implementation,
     imports: uniqueImports,
+    strictMockSchemaTypeNames:
+      aggregatedStrictNames.length > 0 ? aggregatedStrictNames : undefined,
   };
 }

packages/mock/src/index.ts

@@ -85,7 +85,6 @@ export {
 } from './faker';
 export {
   buildStrictMockTypeFileHeader,
-  collectStrictMockSchemaTypeNames,
   dedupeStrictMockTypeDeclarations,
 } from './mock-types';
 export { generateMSW, generateMSWImports } from './msw';

packages/mock/src/mock-types.test.ts

@@ -4,8 +4,6 @@ import { describe, expect, it } from 'vitest';
 import {
   applyStrictMockReturnType,
   buildStrictMockTypeFileHeader,
-  collectStrictMockSchemaNamesFromUsage,
-  collectStrictMockSchemaTypeNames,
   dedupeStrictMockTypeDeclarations,
   getMockFactoryReturnType,
   getMockFactorySignatureParts,
@@ -152,34 +150,26 @@ describe('mock-types', () => {
       strictSchemaTypeNames: ['Pet'],
     };
 
-    it('hoists helpers and schema mock aliases once for concatenated operation mocks', () => {
-      const perOp = `${getStrictMockHelperTypeDeclarations()}\n\n${getStrictMockTypeDeclaration('Pet')}\n\nexport const getGetPetResponseMock = () => ({})`;
-      const duplicated = `${perOp}\n\n${perOp}\n\n${perOp}`;
+    it('prepends helpers and schema mock aliases once from structured type names', () => {
+      const body =
+        'export const getGetPetResponseMock = () => ({})\n\nexport const getListPetsResponseMock = () => []';
 
-      const result = dedupeStrictMockTypeDeclarations(
-        duplicated,
-        strictOptions,
-      );
+      const result = dedupeStrictMockTypeDeclarations(body, strictOptions);
 
       expect(result.match(/export type KeysWithNull/g)?.length).toBe(1);
       expect(
         result.match(/export type MockWithNullableOverrides/g)?.length,
       ).toBe(1);
       expect(result.match(/export type PetMock/g)?.length).toBe(1);
+      expect(result.indexOf('export type PetMock')).toBeLessThan(
+        result.indexOf('export const getGetPetResponseMock'),
+      );
       expect(result.match(/export const getGetPetResponseMock/g)?.length).toBe(
-        3,
+        1,
       );
-    });
-
-    it('strips invalid strict mock aliases for factory value imports', () => {
-      const invalid = `export type getPetMockMock = {
-  [K in keyof Required<getPetMock>]: NonNullable<Required<getPetMock>[K]>;
-};\n\nexport const getListPetsResponseMock = () => []`;
-
-      const result = dedupeStrictMockTypeDeclarations(invalid, strictOptions);
-
-      expect(result).not.toContain('getPetMockMock');
-      expect(result).not.toContain('Required<getPetMock>');
+      expect(
+        result.match(/export const getListPetsResponseMock/g)?.length,
+      ).toBe(1);
     });
 
     it('is a no-op for non-strict mocks even when a schema is named WidgetMock', () => {
@@ -191,6 +181,16 @@ describe('mock-types', () => {
       expect(result).not.toContain('export type KeysWithNull');
       expect(result).not.toContain('Required<Widget>');
     });
+
+    it('returns implementation unchanged when strict mode is on but no type names are provided', () => {
+      const body = 'export const getGetPetResponseMock = () => ({})';
+
+      const result = dedupeStrictMockTypeDeclarations(body, {
+        mockOptions: { required: true, nonNullable: true },
+      });
+
+      expect(result).toBe(body);
+    });
   });
 
   describe('getSchemaTypeNamesFromResponses', () => {
@@ -271,47 +271,4 @@ describe('mock-types', () => {
       expect(header.match(/export type PetMock/g)?.length).toBe(1);
     });
   });
-
-  describe('collectStrictMockSchemaTypeNames', () => {
-    it('reads schema names from strict mock alias declarations', () => {
-      const names = collectStrictMockSchemaTypeNames(
-        getStrictMockTypeDeclaration('Pet'),
-      );
-
-      expect(names).toEqual(['Pet']);
-    });
-  });
-
-  describe('collectStrictMockSchemaNamesFromUsage', () => {
-    it('collects schema names referenced by MockWithNullableOverrides factories', () => {
-      const names = collectStrictMockSchemaNamesFromUsage(
-        '(): MockWithNullableOverrides<Pet, O, PetMock> => ({}) as MockWithNullableOverrides<Pet, O, PetMock>;\nexport const getListPetsResponseMock = (): PetMock[] => []',
-      );
-
-      expect(names).toEqual(['Pet']);
-    });
-
-    it('does not treat a schema named WidgetMock as a strict alias usage', () => {
-      const names = collectStrictMockSchemaNamesFromUsage(
-        'export const getGetWidgetResponseMock = (overrideResponse: Partial<WidgetMock> = {}) => ({})',
-      );
-
-      expect(names).toEqual([]);
-    });
-  });
-
-  describe('dedupeStrictMockTypeDeclarations with usage-only mocks', () => {
-    it('hoists helpers when factories reference strict types without inline declarations', () => {
-      const body = `export const getGetPetResponseMock = (): MockWithNullableOverrides<Pet, O, PetMock> => ({}) as MockWithNullableOverrides<Pet, O, PetMock>;\nexport const getListPetsResponseMock = (): PetMock[] => []`;
-
-      const result = dedupeStrictMockTypeDeclarations(body, {
-        mockOptions: { required: true, nonNullable: true },
-        strictSchemaTypeNames: ['Pet'],
-      });
-
-      expect(result).toContain('export type KeysWithNull');
-      expect(result).toContain('export type PetMock');
-      expect(result.match(/export type PetMock/g)?.length).toBe(1);
-    });
-  });
 });

packages/mock/src/mock-types.ts

@@ -161,41 +161,6 @@ export function getSchemaTypeNamesFromResponses(
   return [...names];
 }
 
-const STRICT_MOCK_SCHEMA_DECL_PATTERN =
-  /export type (\w+) = \{\n  \[K in keyof Required<(\w+)>]: NonNullable<Required<\2>\[K\]>;\n\};/g;
-
-/** Removes invalid strict-mock aliases emitted for value imports (e.g. getPetMockMock). */
-const INVALID_STRICT_MOCK_DECL_PATTERN =
-  /export type get\w+Mock = \{[\s\S]*?\};\n*/g;
-
-export function collectStrictMockSchemaTypeNames(
-  implementation: string,
-): string[] {
-  const names = new Set<string>();
-
-  for (const match of implementation.matchAll(
-    STRICT_MOCK_SCHEMA_DECL_PATTERN,
-  )) {
-    names.add(match[2]);
-  }
-
-  return [...names];
-}
-
-export function collectStrictMockSchemaNamesFromUsage(
-  implementation: string,
-): string[] {
-  const names = new Set<string>();
-
-  for (const match of implementation.matchAll(
-    /MockWithNullableOverrides<(\w+),/g,
-  )) {
-    names.add(match[1]);
-  }
-
-  return [...names];
-}
-
 export function buildStrictMockTypeFileHeader(
   schemaTypeNames: Iterable<string>,
 ): string {
@@ -208,8 +173,11 @@ export function buildStrictMockTypeFileHeader(
 }
 
 /**
- * MSW/faker operation mocks are concatenated per file with no dedup. Hoist the
- * shared strict-mock helper types and each `{Schema}Mock` alias once at the top.
+ * 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.
  */
 export function dedupeStrictMockTypeDeclarations(
   implementation: string,
@@ -219,36 +187,16 @@ export function dedupeStrictMockTypeDeclarations(
     return implementation;
   }
 
-  let body = implementation.replaceAll(INVALID_STRICT_MOCK_DECL_PATTERN, '');
-
-  const schemaTypeNames = [
-    ...new Set([
-      ...(options.strictSchemaTypeNames ?? []),
-      ...collectStrictMockSchemaTypeNames(body),
-      ...collectStrictMockSchemaNamesFromUsage(body),
-    ]),
-  ];
-
-  if (
-    schemaTypeNames.length === 0 &&
-    !body.includes('MockWithNullableOverrides<') &&
-    !body.includes('export type KeysWithNull')
-  ) {
-    return body;
-  }
-
-  const helperBlock = getStrictMockHelperTypeDeclarations();
-
-  body = body.replaceAll(helperBlock, '');
-
-  for (const typeName of schemaTypeNames) {
-    body = body.replaceAll(getStrictMockTypeDeclaration(typeName), '');
+  const schemaTypeNames = options.strictSchemaTypeNames
+    ? [...new Set(options.strictSchemaTypeNames)]
+    : [];
+  if (schemaTypeNames.length === 0) {
+    return implementation;
   }
 
-  const trimmedBody = body.replace(/^\n+/, '').trimStart();
   const header = buildStrictMockTypeFileHeader(schemaTypeNames);
 
-  return header ? `${header}\n\n${trimmedBody}` : trimmedBody;
+  return `${header}\n\n${implementation.trimStart()}`;
 }
 
 export function applyStrictMockReturnType(

packages/orval/src/write-specs.ts

@@ -181,16 +181,20 @@ async function writeFakerSchemaMocks(
     output,
   };
 
-  const { implementation, imports } = generateFakerForSchemas(
-    schemasWithDef,
-    context,
-    fakerEntry,
-  );
+  const { implementation, imports, strictMockSchemaTypeNames } =
+    generateFakerForSchemas(schemasWithDef, context, fakerEntry);
 
   if (!implementation.trim()) {
     return undefined;
   }
 
+  const finalizedImplementation = builder.finalizeMockImplementation
+    ? builder.finalizeMockImplementation(implementation, {
+        mockOptions: output.override.mock,
+        strictSchemaTypeNames: strictMockSchemaTypeNames,
+      })
+    : implementation;
+
   let filePath: string;
   let schemaImportPath: string | undefined;
   const fileExtension = output.fileExtension || '.ts';
@@ -242,7 +246,7 @@ async function writeFakerSchemaMocks(
   }
 
   const importsHeader = generateDependencyImports(
-    implementation,
+    finalizedImplementation,
     [
       {
         exports: [{ name: 'faker', values: true }],
@@ -260,7 +264,7 @@ async function writeFakerSchemaMocks(
     false,
   );
 
-  const content = `${header}${importsHeader}\n\n${implementation}`;
+  const content = `${header}${importsHeader}\n\n${finalizedImplementation}`;
   await writeGeneratedFile(filePath, content);
   return filePath;
 }