fix(core): fix Ajv error discriminator

.changeset/sixty-falcons-glow.md

@@ -0,0 +1,5 @@
+---
+"@redocly/respect-core": patch
+---
+
+Fix AJV validation error when using discriminator with constraint patterns allOf + not . AJV with `discriminator: true` requires discriminator properties to have `const` or `enum` directly, but valid OpenAPI schemas can use `allOf + not` patterns. The schema check now strips discriminators before AJV validation which allows full dereferenced schemas with complex constraints to validate correctly while maintaining data validation semantics.

packages/respect-core/src/modules/__tests__/flow-runner/schema/schema-checker.test.ts

@@ -401,6 +401,59 @@ describe('checkSchema', () => {
     ]);
   });
 
+  it('should handle discriminator with allOf + not pattern without throwing', () => {
+    const discriminatorDescriptionOperation = {
+      ...descriptionOperation,
+      responses: {
+        '200': {
+          description: 'successful operation',
+          content: {
+            'application/json': {
+              schema: {
+                oneOf: [
+                  {
+                    type: 'object',
+                    properties: {
+                      method: {
+                        allOf: [
+                          { enum: ['cash', 'payment-card', 'paypal'] },
+                          { not: { enum: ['payment-card', 'paypal'] } },
+                        ],
+                      },
+                    },
+                  },
+                  {
+                    type: 'object',
+                    properties: {
+                      method: { const: 'payment-card' },
+                    },
+                  },
+                ],
+                discriminator: { propertyName: 'method' },
+              },
+            },
+          },
+        },
+      },
+    };
+
+    expect(() =>
+      checkSchema({
+        stepCallCtx: {
+          ...stepCallCtx,
+          $response: {
+            body: { method: 'cash' },
+            statusCode: 200,
+            header: { 'content-type': 'application/json' },
+            contentType: 'application/json',
+          },
+        } as unknown as StepCallContext,
+        descriptionOperation: discriminatorDescriptionOperation,
+        ctx,
+      })
+    ).not.toThrow();
+  });
+
   it('should return empty checks if no response available', () => {
     const stepCtx = {
       $request: {

packages/respect-core/src/modules/flow-runner/schema/schema-checker.ts

@@ -10,6 +10,7 @@ import {
 } from '../../../types.js';
 import { printErrors as printAjvErrors } from '../../../utils/ajv-errors.js';
 import { checkCircularRefsInSchema } from '../../../utils/check-circular-refs-in-schema.js';
+import { removeDiscriminatorsFromSchema } from '../../../utils/remove-discriminators-from-schema.js';
 import { CHECKS } from '../../checks/index.js';
 import { removeWriteOnlyProperties } from '../../description-parser/index.js';
 
@@ -79,18 +80,14 @@ function checkSchemaFromDescription({
 
   if (schemaFromDescription && !isSchemaWithCircularRef) {
     try {
+      const processedSchema = removeDiscriminatorsFromSchema(
+        removeWriteOnlyProperties(schemaFromDescription as JSONSchemaType<unknown>)
+      );
       checks.push({
         name: CHECKS.SCHEMA_CHECK,
-        passed: ajvStrict.validate(
-          removeWriteOnlyProperties(schemaFromDescription as JSONSchemaType<unknown>),
-          resultBody
-        ),
+        passed: ajvStrict.validate(processedSchema, resultBody),
         message: ajvStrict.errors
-          ? printAjvErrors(
-              removeWriteOnlyProperties(schemaFromDescription as JSONSchemaType<unknown>),
-              resultBody,
-              ajvStrict.errors
-            )
+          ? printAjvErrors(processedSchema, resultBody, ajvStrict.errors)
           : '',
         severity: ctx.severity['SCHEMA_CHECK'],
       });

packages/respect-core/src/utils/__tests__/remove-discriminators-from-schema.test.ts

@@ -0,0 +1,78 @@
+import { removeDiscriminatorsFromSchema } from '../remove-discriminators-from-schema.js';
+
+describe('removeDiscriminatorsFromSchema', () => {
+  it('should return schema unchanged when no discriminator is present', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        method: { type: 'string' },
+      },
+    };
+    expect(removeDiscriminatorsFromSchema(schema)).toEqual(schema);
+  });
+
+  it('should remove top-level discriminator', () => {
+    const schema = {
+      oneOf: [{ properties: { method: { const: 'card' } } }],
+      discriminator: { propertyName: 'method' },
+    };
+    const result = removeDiscriminatorsFromSchema(schema);
+    expect(result).not.toHaveProperty('discriminator');
+    expect(result.oneOf).toBeDefined();
+  });
+
+  it('should remove nested discriminators', () => {
+    const schema = {
+      properties: {
+        instrument: {
+          oneOf: [{ properties: { method: { const: 'card' } } }],
+          discriminator: { propertyName: 'method' },
+        },
+      },
+    };
+    const result = removeDiscriminatorsFromSchema(schema);
+    expect(result.properties.instrument).not.toHaveProperty('discriminator');
+  });
+
+  it('should handle allOf + not pattern (the discriminator bug case)', () => {
+    const schema = {
+      oneOf: [
+        {
+          properties: {
+            method: {
+              allOf: [
+                { enum: ['cash', 'payment-card', 'paypal', 'ach'] },
+                { not: { enum: ['payment-card', 'paypal', 'ach'] } },
+              ],
+            },
+          },
+        },
+        {
+          properties: {
+            method: { const: 'payment-card' },
+          },
+        },
+      ],
+      discriminator: { propertyName: 'method' },
+    };
+    const result = removeDiscriminatorsFromSchema(schema);
+    expect(result).not.toHaveProperty('discriminator');
+    expect(result.oneOf).toHaveLength(2);
+    expect(result.oneOf[0].properties.method.allOf).toBeDefined();
+  });
+
+  it('should not mutate the original schema', () => {
+    const schema = {
+      oneOf: [{ properties: { method: { const: 'card' } } }],
+      discriminator: { propertyName: 'method' },
+    };
+    removeDiscriminatorsFromSchema(schema);
+    expect(schema).toHaveProperty('discriminator');
+  });
+
+  it('should handle null and non-object values gracefully', () => {
+    expect(removeDiscriminatorsFromSchema(null)).toBeNull();
+    expect(removeDiscriminatorsFromSchema('string')).toBe('string');
+    expect(removeDiscriminatorsFromSchema(42)).toBe(42);
+  });
+});

packages/respect-core/src/utils/remove-discriminators-from-schema.ts

@@ -0,0 +1,28 @@
+/**
+ * removes `discriminator` keywords from a fully-dereferenced schema.
+ */
+export function removeDiscriminatorsFromSchema(schema: any): any {
+  if (!schema || typeof schema !== 'object') return schema;
+
+  stripDiscriminators(schema);
+  return schema;
+}
+
+function stripDiscriminators(node: any): void {
+  if (!node || typeof node !== 'object') return;
+
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      stripDiscriminators(item);
+    }
+    return;
+  }
+
+  if ('discriminator' in node) {
+    delete node.discriminator;
+  }
+
+  for (const key of Object.keys(node)) {
+    stripDiscriminators(node[key]);
+  }
+}