fix(mock): enable arrayItems option for MSW-only mock configs (#3576) (#3577)

Author: kfrederix

docs/content/docs/guides/faker.mdx

@@ -108,13 +108,13 @@ Requires `output.schemas` to be configured (the consolidated file is written int
 
 ### Array Item Factories
 
-Set `arrayItems: true` to emit reusable mock factories for **object-like array item schemas** found in operation responses. This covers array elements that are inlined in the response body (not just entries under `components/schemas`):
+Set `arrayItems: true` on any mock generator entry to emit reusable mock factories for **object-like array item schemas** found in operation responses. This covers array elements that are inlined in the response body (not just entries under `components/schemas`). Works with both `faker` and `msw` generators:
 
 ```ts title="orval.config.ts"
 mock: {
   generators: [
     {
-      type: 'faker',
+      type: 'msw',
       arrayItems: true,
     },
   ],
@@ -146,7 +146,7 @@ When `schemas: true` is also enabled, `$ref` items delegate to the consolidated
 
 ## Options
 
-Set faker-specific options on the generator entry:
+Shared mock options apply to both `faker` and `msw` generator entries. Faker-only options are listed separately below.
 
 ```ts title="orval.config.ts"
 mock: {
@@ -157,6 +157,7 @@ mock: {
       generateEachHttpStatus: true,
       locale: 'en_GB',
       preferredContentType: 'application/json',
+      arrayItems: true,
     },
   ],
 }
@@ -168,9 +169,14 @@ mock: {
 | `generateEachHttpStatus` | `boolean` | `false` | Emit a separate factory per HTTP status code defined in the spec (not just the success response). |
 | `locale` | `keyof typeof allLocales` | — | Faker locale. Switches the import to `@faker-js/faker/locale/<x>` (e.g. `'en_GB'`, `'fr'`, `'ja'`). |
 | `preferredContentType` | `string` | — | When an operation has multiple response content types, mock the one matching this MIME type. |
+| `arrayItems` | `boolean` | `false` | Emit reusable mock factories for object-like array item schemas in operation responses. See [Array Item Factories](#array-item-factories). |
+
+Faker-only options:
+
+| Option | Type | Default | Description |
+|---|---|---|---|
 | `schemas` | `boolean` | `false` | Emit a consolidated `get<SchemaName>Mock` factory per `components/schemas` entry into `<schemas-dir>/index.faker.ts`. See [Schema Factories](#schema-factories). |
 | `operationResponses` | `boolean` | `true` | Emit per-operation `get<OperationId>ResponseMock` factories. Set to `false` (typically with `schemas: true`) to skip operation-level factories. |
-| `arrayItems` | `boolean` | `false` | Emit reusable mock factories for object-like array item schemas in operation responses. See [Array Item Factories](#array-item-factories). |
 
 ## Customizing Mock Values
 

docs/content/docs/guides/msw.mdx

@@ -95,6 +95,21 @@ export default defineConfig({
 
 `preferredContentType` accepts common MIME literals and any custom string (via a loose `(string & {})` fallback), so vendor-specific types are supported too.
 
+### Array Item Factories
+
+Set `arrayItems: true` on the MSW generator entry to emit reusable mock factories for object-like array item schemas in operation responses (for example, `getTenantResponseModelDtoMock` for `value: TenantResponseModelDto[]`). The factories are written into the same `.msw.ts` / endpoints mock file as the handlers and response mocks. See the [Faker guide — Array Item Factories](/docs/guides/faker#array-item-factories) for configuration details and supported shapes.
+
+```ts title="orval.config.ts"
+mock: {
+  generators: [
+    {
+      type: 'msw',
+      arrayItems: true,
+    },
+  ],
+}
+```
+
 ### 2. Aggregated Handlers
 
 Functions that combine all handlers for easy setup:

packages/core/src/types.ts

@@ -470,6 +470,10 @@ export interface CommonMockOptions {
   locale?: keyof typeof allLocales;
   // Selects which response schema is mocked when multiple content types exist
   preferredContentType?: string;
+  // Emit reusable mock factories for object-like array item schemas found in
+  // operation responses (e.g. `getTenantResponseModelDtoMock` for
+  // `value: TenantResponseModelDto[]`). Defaults to `false`.
+  arrayItems?: boolean;
 }
 
 export interface MswMockOptions extends CommonMockOptions {
@@ -497,10 +501,6 @@ export interface FakerMockOptions extends CommonMockOptions {
   // Defaults to `true`. Set to `false` together with `schemas: true` to get
   // only the consolidated schema factories.
   operationResponses?: boolean;
-  // Emit reusable mock factories for object-like array item schemas found in
-  // operation responses (e.g. `getTenantResponseModelDtoMock` for
-  // `value: TenantResponseModelDto[]`). Defaults to `false`.
-  arrayItems?: boolean;
   // Custom output directory for faker mock files. Overrides the shared
   // `OutputMocksConfig.path` when set. When provided in `single` or `tags`
   // modes, mock code is written to separate files instead of being inlined

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

@@ -73,6 +73,18 @@ describe('shouldExtractArrayItemFactories', () => {
     );
   });
 
+  it('returns true when arrayItems is enabled on an MSW-only generator', () => {
+    const context = {
+      output: {
+        mock: {
+          generators: [{ type: 'msw', arrayItems: true }],
+        },
+      },
+    } as unknown as ContextSpec;
+
+    expect(shouldExtractArrayItemFactories(context)).toBe(true);
+  });
+
   it('returns false when arrayItems is not enabled', () => {
     expect(shouldExtractArrayItemFactories(contextWithoutArrayItems)).toBe(
       false,
@@ -107,6 +119,50 @@ describe('extractArrayItemMock', () => {
     expect(imports).toEqual([{ name: 'TenantResponseModelDto' }]);
   });
 
+  it('extracts a reusable factory for $ref array items with an MSW generator', () => {
+    const splitMockImplementations: string[] = [];
+    const context = {
+      output: {
+        mock: {
+          generators: [{ type: 'msw', arrayItems: true }],
+        },
+        override: {
+          components: { schemas: { suffix: '', itemSuffix: 'Item' } },
+        },
+      },
+      spec: {
+        openapi: '3.0.3',
+        components: {
+          schemas: {
+            TenantResponseModelDto: {
+              type: 'object',
+              properties: {
+                id: { type: 'string' },
+                name: { type: 'string' },
+              },
+            },
+          },
+        },
+      },
+    } as unknown as ContextSpec;
+
+    const call = extractArrayItemMock({
+      items: { $ref: '#/components/schemas/TenantResponseModelDto' },
+      propertyName: 'value',
+      operationId: 'getTenantsByRef',
+      tags: [],
+      mapValue,
+      context,
+      splitMockImplementations,
+      imports: [],
+    });
+
+    expect(call).toBe('{...getTenantResponseModelDtoMock()}');
+    expect(splitMockImplementations[0]).toContain(
+      'export const getTenantResponseModelDtoMock',
+    );
+  });
+
   it('extracts a reusable factory for inline object array items', () => {
     const splitMockImplementations: string[] = [];
 

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

@@ -59,17 +59,13 @@ function getFileLevelExtractedFactories(
 }
 
 /**
- * True when the active faker generator entry opts into reusable array-item
- * mock factories for object-like array item schemas in operation responses.
+ * True when any mock generator entry opts into reusable array-item mock
+ * factories for object-like array item schemas in operation responses.
  */
 export function shouldExtractArrayItemFactories(context: ContextSpec): boolean {
-  const fakerEntry = context.output.mock.generators.find(
-    (g) =>
-      !isFunction(g) &&
-      g.type === OutputMockType.FAKER &&
-      g.arrayItems === true,
+  return context.output.mock.generators.some(
+    (g) => !isFunction(g) && g.arrayItems === true,
   );
-  return !!fakerEntry;
 }
 
 /**

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

@@ -1399,6 +1399,147 @@ describe('generateMSW', () => {
   });
 });
 
+describe('arrayItems option', () => {
+  const tenantListResponseType = {
+    key: '200',
+    value: 'TenantListResponse',
+    contentType: 'application/json',
+    originalSchema: { $ref: '#/components/schemas/TenantListResponse' },
+    imports: [{ name: 'TenantListResponse' }],
+    schemas: [],
+    type: 'object',
+    isEnum: false,
+    isRef: true,
+    hasReadonlyProps: false,
+  };
+
+  const tenantsByRefVerbOptions = {
+    operationId: 'getTenantsByRef',
+    operationName: 'getTenantsByRef',
+    verb: 'get',
+    tags: ['tenants'],
+    response: {
+      imports: [{ name: 'TenantListResponse' }],
+      definition: { success: 'TenantListResponse' },
+      types: { success: [tenantListResponseType] },
+      contentTypes: ['application/json'],
+    },
+  } as unknown as GeneratorVerbOptions;
+
+  const arrayItemsContext = {
+    target: 'test',
+    workspace: '',
+    spec: {
+      openapi: '3.0.3',
+      info: { title: 'Test', version: '1.0.0' },
+      paths: {},
+      components: {
+        schemas: {
+          TenantListResponse: {
+            type: 'object',
+            required: ['value', 'count'],
+            properties: {
+              value: {
+                type: 'array',
+                items: {
+                  $ref: '#/components/schemas/TenantResponseModelDto',
+                },
+              },
+              count: { type: 'integer' },
+            },
+          },
+          TenantResponseModelDto: {
+            type: 'object',
+            required: ['id', 'name'],
+            properties: {
+              id: { type: 'string', format: 'uuid' },
+              name: { type: 'string' },
+            },
+          },
+        },
+      },
+    },
+    output: {
+      target: 'test',
+      namingConvention: 'camelCase',
+      fileExtension: '.ts',
+      schemaFileExtension: '.ts',
+      mode: 'single',
+      mock: {
+        indexMockFiles: false,
+        generators: [
+          { type: OutputMockType.MSW, arrayItems: true, delay: false },
+        ],
+      },
+      override: {
+        operations: {},
+        tags: {},
+        components: { schemas: { suffix: '', itemSuffix: 'Item' } },
+      },
+      client: 'axios-functions',
+      httpClient: 'fetch',
+      clean: false,
+      docs: false,
+      formatter: undefined,
+      headers: false,
+      indexFiles: true,
+      allParamsOptional: false,
+      urlEncodeParameters: false,
+      unionAddMissingProperties: false,
+      optionsParamRequired: false,
+      propertySortOrder: 'specification',
+    },
+  };
+
+  const arrayItemsOptions = {
+    route: '/tenants-by-ref',
+    pathRoute: '/tenants-by-ref',
+    output: 'test',
+    override: { operations: {}, tags: {} } as NormalizedOverrideOutput,
+    context: arrayItemsContext,
+    mock: {
+      type: OutputMockType.MSW,
+      arrayItems: true,
+      delay: false,
+    },
+  } as unknown as GeneratorOptions;
+
+  it('extracts reusable array item factories when arrayItems is enabled on the MSW generator', () => {
+    const result = generateMSW(tenantsByRefVerbOptions, arrayItemsOptions);
+
+    expect(result.implementation.function).toContain(
+      'export const getTenantResponseModelDtoMock',
+    );
+    expect(result.implementation.function).toContain(
+      'getGetTenantsByRefResponseMock',
+    );
+    expect(result.implementation.function).toContain(
+      '...getTenantResponseModelDtoMock()',
+    );
+  });
+
+  it('does not extract array item factories when arrayItems is disabled', () => {
+    const result = generateMSW(tenantsByRefVerbOptions, {
+      ...arrayItemsOptions,
+      mock: { type: OutputMockType.MSW, delay: false },
+      context: {
+        ...arrayItemsContext,
+        output: {
+          ...arrayItemsContext.output,
+          mock: {
+            indexMockFiles: false,
+            generators: [{ type: OutputMockType.MSW, delay: false }],
+          },
+        },
+      },
+    } as unknown as GeneratorOptions);
+
+    expect(result.implementation.function).not.toContain(
+      'export const getTenantResponseModelDtoMock',
+    );
+  });
+});
+
 describe('strict mock types (#3525)', () => {
   const petResponseType = {
     key: '200',