fix(mock): emit bare factory call for primitive-union $ref in additionalProperties (#3200) (#3504)

* fix(mock): emit bare factory call for primitive-union $ref in additionalProperties (#3200)

When `schemas: true` emits per-schema faker factories, an `additionalProperties`
dictionary whose value is a $ref to a primitive `oneOf`/`anyOf` (e.g. `number |
string`) delegated to `get<X>Mock()` but wrapped the call in `{ ...get<X>Mock()
}`. The factory returns a primitive union, which is not spreadable: the output
failed to compile (TS2698) and would discard the value as `{}` at runtime.

The delegation now treats a `oneOf`/`anyOf` as object-like only when every
branch resolves to an object, so primitive unions emit the bare `get<X>Mock()`
call while object compositions keep the spread form.

Closes #3200

* fix(mock): isolate $ref cycle guard per branch in object-likeness check (#3200)

Addresses review feedback on the additionalProperties dictionary fix:

- The cycle-guard `Set` was shared and mutated across all `oneOf`/`anyOf`
  branches, so the first branch could poison its siblings: a composition like
  `oneOf: [{$ref: Foo}, {$ref: Foo}]` made the second branch look cyclic and
  return `false`, misclassifying an object-only union as non-object-like. The
  guard now takes a fresh copy at each `$ref` hop, so siblings sharing a `$ref`
  no longer trip it.
- Rename `compositionResolvesToObject` -> `resolvesToObjectLike`; it also
  recognizes plain object schemas (`properties`/`additionalProperties`/`allOf`),
  not just compositions.
- Return early when a `$ref` is not a string instead of using an `''` fallback
  key, and initialize `resolved` via an explicit if/else for clarity.
- Make the regression assertions whitespace-tolerant and detect a spread
  regardless of brace formatting.

---------

Co-authored-by: Melloware <mellowaredev@gmail.com>

Author: wadakatu

packages/mock/src/faker/resolvers/value.ts

@@ -341,11 +341,16 @@ export function resolveMockValue({
       // so the spread form keeps callers (combineSchemasMock, object
       // properties) working without other changes. For everything else
       // (scalars, arrays, nullables) emit the bare call.
+      //
+      // A `oneOf`/`anyOf` is only object-like when *every* branch resolves to
+      // an object. A composition of primitives (e.g. `number | string`) makes
+      // the factory return a primitive union, which is not spreadable: emitting
+      // `{ ...get<X>Mock() }` is invalid TypeScript (TS2698) and would discard
+      // the value as `{}` at runtime, so it must use the bare call (#3200).
       const isObjectLike =
         newSchema.type === 'object' ||
         !!newSchema.allOf ||
-        !!newSchema.oneOf ||
-        !!newSchema.anyOf;
+        resolvesToObjectLike(newSchema, context);
       const callValue = isObjectLike
         ? `{ ...${factoryName}() }`
         : `${factoryName}()`;
@@ -449,3 +454,62 @@ function getType(schema: MockSchema) {
     (schema.properties ? 'object' : schema.items ? 'array' : undefined)
   );
 }
+
+// Whether a schema (or a `$ref` to one) ultimately produces an object mock.
+// Used to decide if a delegated `get<X>Mock()` call may be spread into an
+// object literal. Object-like schemas are `type: 'object'`, `properties`,
+// `additionalProperties` and `allOf`; a `oneOf`/`anyOf` qualifies only when
+// every branch resolves to an object. A union containing a primitive
+// (e.g. `number | string`) does not, since spreading that union is invalid
+// TypeScript. `seen` carries the `$ref`s on the current resolution path to
+// guard against self-referential compositions. A fresh copy is taken at each
+// `$ref` hop so sibling branches sharing a `$ref` don't falsely trip the guard.
+function resolvesToObjectLike(
+  schema: MockSchema,
+  context: ContextSpec,
+  seen = new Set<string>(),
+): boolean {
+  let resolved: Partial<OpenApiSchemaObject> | undefined;
+
+  if (isReference(schema)) {
+    // A non-string or already-visited `$ref` can't be resolved further here.
+    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,
+          // @ts-expect-error: refPaths are not guaranteed to be valid keys of the spec
+          ...refPaths,
+        ) as Partial<OpenApiSchemaObject>)
+      : undefined;
+  } else {
+    resolved = schema as Partial<OpenApiSchemaObject>;
+  }
+
+  if (!resolved) {
+    return false;
+  }
+
+  if (
+    resolved.type === 'object' ||
+    resolved.properties ||
+    resolved.additionalProperties ||
+    resolved.allOf
+  ) {
+    return true;
+  }
+
+  const branches = (resolved.oneOf ?? resolved.anyOf) as
+    | MockSchema[]
+    | undefined;
+  if (branches && branches.length > 0) {
+    return branches.every((branch) =>
+      resolvesToObjectLike(branch, context, seen),
+    );
+  }
+
+  return false;
+}

tests/__snapshots__/mock/issue-3200/endpoints.ts

@@ -0,0 +1,48 @@
+/**
+ * Generated by orval v8.14.0 🍺
+ * Do not edit manually.
+ * Issue 3200
+ * Reproduces the case where an object schema used as a dictionary
+ * (`additionalProperties: { $ref: <primitive union> }`) generates an invalid
+ * faker schema mock under `schemas: true`. The delegated `$ref` was wrapped in
+ * `{ ...get<X>Mock() }`, but the factory returns a primitive union
+ * (e.g. number | string), so spreading it is invalid TypeScript (TS2698) and
+ * yields `{}` at runtime. The generated dictionary value should be the bare
+ * `get<X>Mock()` call instead.
+ *
+ * OpenAPI spec version: 1.0.0
+ */
+import axios from 'axios';
+import type { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+
+import type { StringToIntegerMap, StringToNumberMap } from './model';
+
+import { faker } from '@faker-js/faker';
+
+import { getIntegerLikeMock, getNumberLikeMock } from './model/index.faker';
+
+export const getIssue3200 = (axiosInstance: AxiosInstance = axios) => {
+  const getIntegerMap = (
+    options?: AxiosRequestConfig,
+  ): Promise<AxiosResponse<StringToIntegerMap>> => {
+    return axiosInstance.get(`/integer-map`, options);
+  };
+
+  const getNumberMap = (
+    options?: AxiosRequestConfig,
+  ): Promise<AxiosResponse<StringToNumberMap>> => {
+    return axiosInstance.get(`/number-map`, options);
+  };
+
+  return { getIntegerMap, getNumberMap };
+};
+export type GetIntegerMapResult = AxiosResponse<StringToIntegerMap>;
+export type GetNumberMapResult = AxiosResponse<StringToNumberMap>;
+
+export const getGetIntegerMapResponseMock = (): StringToIntegerMap => ({
+  [faker.string.alphanumeric(5)]: getIntegerLikeMock(),
+});
+
+export const getGetNumberMapResponseMock = (): StringToNumberMap => ({
+  [faker.string.alphanumeric(5)]: getNumberLikeMock(),
+});

tests/__snapshots__/mock/issue-3200/model/index.faker.ts

@@ -0,0 +1,42 @@
+/**
+ * Generated by orval v8.14.0 🍺
+ * Do not edit manually.
+ * Issue 3200
+ * Reproduces the case where an object schema used as a dictionary
+ * (`additionalProperties: { $ref: <primitive union> }`) generates an invalid
+ * faker schema mock under `schemas: true`. The delegated `$ref` was wrapped in
+ * `{ ...get<X>Mock() }`, but the factory returns a primitive union
+ * (e.g. number | string), so spreading it is invalid TypeScript (TS2698) and
+ * yields `{}` at runtime. The generated dictionary value should be the bare
+ * `get<X>Mock()` call instead.
+ *
+ * OpenAPI spec version: 1.0.0
+ */
+import { faker } from '@faker-js/faker';
+
+import type {
+  IntegerLike,
+  NumberLike,
+  StringToIntegerMap,
+  StringToNumberMap,
+} from '.';
+
+export const getIntegerLikeMock = (): IntegerLike =>
+  faker.helpers.arrayElement([
+    faker.number.int(),
+    faker.string.alpha({ length: { min: 10, max: 20 } }),
+  ]);
+
+export const getStringToIntegerMapMock = (): StringToIntegerMap => ({
+  [faker.string.alphanumeric(5)]: getIntegerLikeMock(),
+});
+
+export const getNumberLikeMock = (): NumberLike =>
+  faker.helpers.arrayElement([
+    faker.number.float({ fractionDigits: 2 }),
+    faker.string.alpha({ length: { min: 10, max: 20 } }),
+  ]);
+
+export const getStringToNumberMapMock = (): StringToNumberMap => ({
+  [faker.string.alphanumeric(5)]: getNumberLikeMock(),
+});

tests/__snapshots__/mock/issue-3200/model/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Generated by orval v8.14.0 🍺
+ * Do not edit manually.
+ * Issue 3200
+ * Reproduces the case where an object schema used as a dictionary
+ * (`additionalProperties: { $ref: <primitive union> }`) generates an invalid
+ * faker schema mock under `schemas: true`. The delegated `$ref` was wrapped in
+ * `{ ...get<X>Mock() }`, but the factory returns a primitive union
+ * (e.g. number | string), so spreading it is invalid TypeScript (TS2698) and
+ * yields `{}` at runtime. The generated dictionary value should be the bare
+ * `get<X>Mock()` call instead.
+ *
+ * OpenAPI spec version: 1.0.0
+ */
+
+export * from './integerLike';
+export * from './numberLike';
+export * from './stringToIntegerMap';
+export * from './stringToNumberMap';

tests/__snapshots__/mock/issue-3200/model/integerLike.ts

@@ -0,0 +1,16 @@
+/**
+ * Generated by orval v8.14.0 🍺
+ * Do not edit manually.
+ * Issue 3200
+ * Reproduces the case where an object schema used as a dictionary
+ * (`additionalProperties: { $ref: <primitive union> }`) generates an invalid
+ * faker schema mock under `schemas: true`. The delegated `$ref` was wrapped in
+ * `{ ...get<X>Mock() }`, but the factory returns a primitive union
+ * (e.g. number | string), so spreading it is invalid TypeScript (TS2698) and
+ * yields `{}` at runtime. The generated dictionary value should be the bare
+ * `get<X>Mock()` call instead.
+ *
+ * OpenAPI spec version: 1.0.0
+ */
+
+export type IntegerLike = number | string;

tests/__snapshots__/mock/issue-3200/model/numberLike.ts

@@ -0,0 +1,16 @@
+/**
+ * Generated by orval v8.14.0 🍺
+ * Do not edit manually.
+ * Issue 3200
+ * Reproduces the case where an object schema used as a dictionary
+ * (`additionalProperties: { $ref: <primitive union> }`) generates an invalid
+ * faker schema mock under `schemas: true`. The delegated `$ref` was wrapped in
+ * `{ ...get<X>Mock() }`, but the factory returns a primitive union
+ * (e.g. number | string), so spreading it is invalid TypeScript (TS2698) and
+ * yields `{}` at runtime. The generated dictionary value should be the bare
+ * `get<X>Mock()` call instead.
+ *
+ * OpenAPI spec version: 1.0.0
+ */
+
+export type NumberLike = number | string;

tests/__snapshots__/mock/issue-3200/model/stringToIntegerMap.ts

@@ -0,0 +1,19 @@
+/**
+ * Generated by orval v8.14.0 🍺
+ * Do not edit manually.
+ * Issue 3200
+ * Reproduces the case where an object schema used as a dictionary
+ * (`additionalProperties: { $ref: <primitive union> }`) generates an invalid
+ * faker schema mock under `schemas: true`. The delegated `$ref` was wrapped in
+ * `{ ...get<X>Mock() }`, but the factory returns a primitive union
+ * (e.g. number | string), so spreading it is invalid TypeScript (TS2698) and
+ * yields `{}` at runtime. The generated dictionary value should be the bare
+ * `get<X>Mock()` call instead.
+ *
+ * OpenAPI spec version: 1.0.0
+ */
+import type { IntegerLike } from './integerLike';
+
+export interface StringToIntegerMap {
+  [key: string]: IntegerLike;
+}

tests/__snapshots__/mock/issue-3200/model/stringToNumberMap.ts

@@ -0,0 +1,19 @@
+/**
+ * Generated by orval v8.14.0 🍺
+ * Do not edit manually.
+ * Issue 3200
+ * Reproduces the case where an object schema used as a dictionary
+ * (`additionalProperties: { $ref: <primitive union> }`) generates an invalid
+ * faker schema mock under `schemas: true`. The delegated `$ref` was wrapped in
+ * `{ ...get<X>Mock() }`, but the factory returns a primitive union
+ * (e.g. number | string), so spreading it is invalid TypeScript (TS2698) and
+ * yields `{}` at runtime. The generated dictionary value should be the bare
+ * `get<X>Mock()` call instead.
+ *
+ * OpenAPI spec version: 1.0.0
+ */
+import type { NumberLike } from './numberLike';
+
+export interface StringToNumberMap {
+  [key: string]: NumberLike;
+}

tests/api-generation.spec.ts

@@ -797,6 +797,33 @@ test('mock issue-3484 required nullable scalars get a single null branch', async
   );
 });
 
+test('mock issue-3200 dictionary values delegate to a bare factory call for primitive-union $refs', async () => {
+  // Regression for #3200: with `schemas: true`, an `additionalProperties`
+  // dictionary whose value is a `$ref` to a primitive `oneOf`/`anyOf`
+  // (e.g. `number | string`) delegated to `get<X>Mock()`. The delegation
+  // wrapped the call in `{ ...get<X>Mock() }`, but the factory returns a
+  // primitive union which is not spreadable: that is invalid TypeScript
+  // (TS2698, enforced by scripts/typecheck-generated.mjs) and would discard
+  // the value as `{}` at runtime. The dictionary value must be the bare call.
+  const content = await readFile(
+    generated('mock', 'issue-3200', 'model', 'index.faker.ts'),
+    'utf8',
+  );
+
+  // Whitespace-tolerant so the assertion survives formatter/generator tweaks
+  // while still pinning the behavior: the dictionary value is the bare call.
+  expect(content).toMatch(
+    /\[faker\.string\.alphanumeric\(5\)\]:\s*getIntegerLikeMock\(\)/,
+  );
+  expect(content).toMatch(
+    /\[faker\.string\.alphanumeric\(5\)\]:\s*getNumberLikeMock\(\)/,
+  );
+  // The primitive-union factory call must never be spread into the object,
+  // regardless of how the braces would be formatted.
+  expect(content).not.toContain('...getIntegerLikeMock()');
+  expect(content).not.toContain('...getNumberLikeMock()');
+});
+
 test('zod issue-3171 applies required from a sibling allOf member to $ref base props', async () => {
   // `User`/`UserFull` define their properties in a $ref base (UserBase) and
   // carry `required` only in a sibling allOf member. The required array must be

tests/configs/mock.config.ts

@@ -464,6 +464,23 @@ export default defineConfig({
       target: '../specifications/faker-schemas-string-enum-ref.yaml',
     },
   },
+  issue3200: {
+    output: {
+      target: '../generated/mock/issue-3200/endpoints.ts',
+      schemas: '../generated/mock/issue-3200/model',
+      client: 'axios',
+      mock: {
+        generators: [
+          { type: 'faker', schemas: true, operationResponses: true },
+        ],
+      },
+      clean: true,
+      formatter: 'prettier',
+    },
+    input: {
+      target: '../specifications/issue-3200.yaml',
+    },
+  },
   issue2465: {
     output: {
       target: '../generated/mock/issue-2465/endpoints.ts',