fix(core): preserve parent constraints and clone props per variant (#3432)

Address review feedback on the #3432 inline-parent-props rewrite:

- Shallow-copy the parent schema and only strip the keys that would re-create
  the cycle (oneOf, discriminator, allOf, anyOf), so object-level constraints
  like additionalProperties, minProperties, description, etc. carry through to
  the inlined entry. The previous implementation only kept
  type/properties/required, silently dropping every other constraint.
- Per-variant shallow-clone of properties and required so downstream in-place
  mutations on one variant don't leak across siblings under the same parent.
- Drop the inline entry entirely when nothing meaningful beyond type:'object'
  survives — the second allOf member (variant's own object) already asserts
  object-ness, and dropping keeps the existing empty-parent snapshot stable.

Adds two focused unit tests: one asserts that additionalProperties:false,
minProperties, and description propagate from parent to inlined variant
(and that oneOf/discriminator/allOf do not), the other asserts that sibling
variants get independent properties objects.

Author: wadakatu

packages/core/src/getters/discriminators.test.ts

@@ -436,6 +436,109 @@ describe('resolveDiscriminators getter', () => {
     expect(inlined?.required).toEqual(['commonField']);
   });
 
+  it('preserves parent object-level constraints when inlining (#3432)', () => {
+    // Replacing the parent $ref with `{type:'object', properties, required}`
+    // alone would silently drop other parent constraints like
+    // `additionalProperties`, `minProperties`, `description`, etc. The inline
+    // schema must carry those forward so variant validation semantics match
+    // the dereferenced behavior we replaced.
+    const schemas: OpenApiSchemasObject = {
+      Parent: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        description: 'parent shape',
+        required: ['kind', 'commonField'],
+        properties: {
+          kind: { type: 'string', enum: ['a'] },
+          commonField: { type: 'string' },
+        },
+        discriminator: {
+          propertyName: 'kind',
+          mapping: {
+            a: '#/components/schemas/VariantA',
+          },
+        },
+        oneOf: [{ $ref: '#/components/schemas/VariantA' }],
+      },
+      VariantA: {
+        allOf: [
+          { $ref: '#/components/schemas/Parent' },
+          { type: 'object', properties: { extraA: { type: 'number' } } },
+        ],
+      },
+    };
+
+    const result = resolveDiscriminators(structuredClone(schemas), context);
+    const variantA = result.VariantA as NonNullable<
+      OpenApiSchemasObject[string]
+    >;
+    const allOf = variantA.allOf as
+      | (OpenApiSchemaObject | OpenApiReferenceObject)[]
+      | undefined;
+    const inlined = allOf?.[0] as Record<string, unknown> | undefined;
+
+    expect(inlined?.additionalProperties).toBe(false);
+    expect(inlined?.minProperties).toBe(1);
+    expect(inlined?.description).toBe('parent shape');
+    // Composition keys that would re-create the cycle must NOT be copied.
+    expect(inlined).not.toHaveProperty('oneOf');
+    expect(inlined).not.toHaveProperty('discriminator');
+    expect(inlined).not.toHaveProperty('allOf');
+  });
+
+  it('gives each variant its own properties object (#3432)', () => {
+    // The inlined parent properties must be cloned per variant — sharing the
+    // same Record across siblings would couple downstream in-place mutations
+    // (e.g. one variant's property tweak leaking into the other).
+    const schemas: OpenApiSchemasObject = {
+      Parent: {
+        type: 'object',
+        required: ['kind', 'shared'],
+        properties: {
+          kind: { type: 'string', enum: ['a', 'b'] },
+          shared: { type: 'string' },
+        },
+        discriminator: {
+          propertyName: 'kind',
+          mapping: {
+            a: '#/components/schemas/VariantA',
+            b: '#/components/schemas/VariantB',
+          },
+        },
+        oneOf: [
+          { $ref: '#/components/schemas/VariantA' },
+          { $ref: '#/components/schemas/VariantB' },
+        ],
+      },
+      VariantA: {
+        allOf: [
+          { $ref: '#/components/schemas/Parent' },
+          { type: 'object', properties: { extraA: { type: 'number' } } },
+        ],
+      },
+      VariantB: {
+        allOf: [
+          { $ref: '#/components/schemas/Parent' },
+          { type: 'object', properties: { extraB: { type: 'boolean' } } },
+        ],
+      },
+    };
+
+    const result = resolveDiscriminators(structuredClone(schemas), context);
+    const aAllOf = (
+      result.VariantA as NonNullable<OpenApiSchemasObject[string]>
+    ).allOf as (OpenApiSchemaObject | OpenApiReferenceObject)[] | undefined;
+    const bAllOf = (
+      result.VariantB as NonNullable<OpenApiSchemasObject[string]>
+    ).allOf as (OpenApiSchemaObject | OpenApiReferenceObject)[] | undefined;
+    const aInlined = aAllOf?.[0] as OpenApiSchemaObject | undefined;
+    const bInlined = bAllOf?.[0] as OpenApiSchemaObject | undefined;
+
+    expect(aInlined?.properties).not.toBe(bInlined?.properties);
+    expect(aInlined).not.toBe(bInlined);
+  });
+
   it('leaves allOf untouched when parent has no top-level oneOf (#3432 guard)', () => {
     // Sanity check: the existing recursive-discriminator-allof shape (parent
     // is a plain interface, variants inherit via allOf) must keep emitting an

packages/core/src/getters/discriminators.ts

@@ -182,14 +182,39 @@ export function resolveDiscriminators(
           rewritten.push(item);
           continue;
         }
+        // Preserve the parent's other object-level constraints
+        // (additionalProperties, minProperties, description, etc.) by shallow-
+        // cloning the parent and only stripping the parts that would re-create
+        // the cycle or are now meaningless on the variant.
+        const inlinedParent = {
+          ...(parentSchema as Record<string, unknown>),
+        } as OpenApiSchemaObject;
+        delete (inlinedParent as Record<string, unknown>).oneOf;
+        delete (inlinedParent as Record<string, unknown>).discriminator;
+        delete (inlinedParent as Record<string, unknown>).allOf;
+        delete (inlinedParent as Record<string, unknown>).anyOf;
+
         if (hasInheritableProps) {
-          rewritten.push({
-            type: 'object',
-            properties: inheritableProps,
-            ...(inheritableRequired && inheritableRequired.length > 0
-              ? { required: inheritableRequired }
-              : {}),
-          } as OpenApiSchemaObject);
+          // Fresh per-variant clone so downstream in-place mutations on one
+          // variant don't leak across siblings.
+          inlinedParent.properties = { ...inheritableProps };
+        } else {
+          delete (inlinedParent as Record<string, unknown>).properties;
+        }
+        if (inheritableRequired && inheritableRequired.length > 0) {
+          inlinedParent.required = [...inheritableRequired];
+        } else {
+          delete (inlinedParent as Record<string, unknown>).required;
+        }
+
+        // Drop the entry entirely when the parent contributed nothing beyond
+        // a bare `type: 'object'` — the second allOf member (the variant's
+        // own inline object) already asserts object-ness.
+        const meaningfulKeys = Object.keys(
+          inlinedParent as Record<string, unknown>,
+        ).filter((key) => key !== 'type');
+        if (meaningfulKeys.length > 0) {
+          rewritten.push(inlinedParent);
         }
       }