Fix generate schema

Author: nolannbiron

packages/react-openapi/src/generateSchemaExample.test.ts

@@ -1037,4 +1037,77 @@ describe('generateSchemaExample', () => {
             })
         ).toBeUndefined();
     });
+
+    it('handles oneOf -> allOf returning a string without spreading characters', () => {
+        // Create a circular reference that will return "[Circular Reference]" string
+        const circularSchema = {
+            type: 'object',
+            properties: {
+                nested: {},
+            },
+        } satisfies OpenAPIV3.SchemaObject;
+        circularSchema.properties.nested = circularSchema;
+
+        const schema = {
+            type: 'object',
+            properties: {
+                foo: {
+                    type: 'string',
+                },
+            },
+            oneOf: [
+                {
+                    allOf: [circularSchema],
+                },
+            ],
+        } satisfies OpenAPIV3.SchemaObject;
+
+        const result = generateSchemaExample(schema);
+
+        expect(result).toBeDefined();
+        expect(result).toHaveProperty('foo');
+    });
+
+    it('merges object properties from oneOf -> allOf', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                discriminator: {
+                    type: 'string',
+                },
+            },
+            oneOf: [
+                {
+                    allOf: [
+                        {
+                            type: 'object',
+                            properties: {
+                                bar: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                        {
+                            type: 'object',
+                            properties: {
+                                baz: {
+                                    type: 'number',
+                                },
+                            },
+                        },
+                        {
+                            type: 'string', // This will return a string, but should be ignored
+                        },
+                    ],
+                },
+            ],
+        } satisfies OpenAPIV3.SchemaObject;
+
+        const result = generateSchemaExample(schema);
+
+        expect(result).toBeDefined();
+        expect(result).toHaveProperty('discriminator');
+        expect(result).toHaveProperty('bar');
+        expect(result).toHaveProperty('baz');
+    });
 });

packages/react-openapi/src/generateSchemaExample.ts

@@ -99,6 +99,13 @@ function guessFromFormat(schema: Record<string, any>, fallback = '') {
     return genericExampleValues[schema.format] ?? fallback;
 }
 
+/**
+ * Check if a value is a plain object (not null, not array)
+ */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 /**
  * This function takes an OpenAPI schema and generates an example from it
  * Forked from : https://github.com/scalar/scalar/blob/main/packages/oas-utils/src/spec-getters/getExampleFromSchema.ts
@@ -147,6 +154,23 @@ const getExampleFromSchema = (
         return result;
     }
 
+    // Process allOf items and merge object results into the response
+    function mergeAllOfIntoResponse(
+        allOfItems: Record<string, unknown>[],
+        response: Record<string, unknown>,
+        parent: Record<string, unknown> | undefined
+    ): void {
+        const allOfResults = allOfItems
+            .map((item: Record<string, unknown>) =>
+                getExampleFromSchema(item, options, level + 1, parent, undefined, resultCache)
+            )
+            .filter(isPlainObject);
+
+        if (allOfResults.length > 0) {
+            Object.assign(response, ...allOfResults);
+        }
+    }
+
     // Check if the result is already cached
     if (resultCache.has(schema)) {
         return resultCache.get(schema);
@@ -307,45 +331,43 @@ const getExampleFromSchema = (
         }
 
         if (schema.anyOf !== undefined) {
-            Object.assign(
-                response,
-                getExampleFromSchema(
-                    schema.anyOf[0],
+            const anyOfItem = schema.anyOf[0];
+            // If anyOf[0] has allOf, process allOf items individually to merge object results
+            if (anyOfItem?.allOf !== undefined && Array.isArray(anyOfItem.allOf)) {
+                mergeAllOfIntoResponse(anyOfItem.allOf, response, anyOfItem);
+            } else {
+                const anyOfResult = getExampleFromSchema(
+                    anyOfItem,
                     options,
                     level + 1,
                     undefined,
                     undefined,
                     resultCache
-                )
-            );
+                );
+                if (isPlainObject(anyOfResult)) {
+                    Object.assign(response, anyOfResult);
+                }
+            }
         } else if (schema.oneOf !== undefined) {
-            Object.assign(
-                response,
-                getExampleFromSchema(
-                    schema.oneOf[0],
+            const oneOfItem = schema.oneOf[0];
+            // If oneOf[0] has allOf, process allOf items individually to merge object results
+            if (oneOfItem?.allOf !== undefined && Array.isArray(oneOfItem.allOf)) {
+                mergeAllOfIntoResponse(oneOfItem.allOf, response, oneOfItem);
+            } else {
+                const oneOfResult = getExampleFromSchema(
+                    oneOfItem,
                     options,
                     level + 1,
                     undefined,
                     undefined,
                     resultCache
-                )
-            );
+                );
+                if (isPlainObject(oneOfResult)) {
+                    Object.assign(response, oneOfResult);
+                }
+            }
         } else if (schema.allOf !== undefined) {
-            Object.assign(
-                response,
-                ...schema.allOf
-                    .map((item: Record<string, any>) =>
-                        getExampleFromSchema(
-                            item,
-                            options,
-                            level + 1,
-                            schema,
-                            undefined,
-                            resultCache
-                        )
-                    )
-                    .filter((item: any) => item !== undefined)
-            );
+            mergeAllOfIntoResponse(schema.allOf, response, schema);
         }
 
         return cache(schema, response);