feat: add functionality to handle anyOf and allOf checks

Author: AlbinaBlazhko17

packages/core/src/rules/oas3/no-illogical-composition-keywords.ts

@@ -25,73 +25,88 @@ export const NoIllogicalCompositionKeywords: Oas3Rule = (): Oas3Visitor => {
   return {
     Schema: {
       skip(node) {
-        return !node.oneOf;
+        return !node.oneOf && !node.anyOf && !node.allOf;
       },
       enter(schema, { report, location, resolve }) {
-        if (!Array.isArray(schema.oneOf)) return;
-        const oneOfSchemas = schema.oneOf;
+        // Helper function to get the composition keyword and schemas
+        const compositionData = (() => {
+          if (schema.oneOf && Array.isArray(schema.oneOf)) {
+            return { keyword: 'oneOf' as const, schemas: schema.oneOf };
+          }
+          if (schema.anyOf && Array.isArray(schema.anyOf)) {
+            return { keyword: 'anyOf' as const, schemas: schema.anyOf };
+          }
+          if (schema.allOf && Array.isArray(schema.allOf)) {
+            return { keyword: 'allOf' as const, schemas: schema.allOf };
+          }
+          return null;
+        })();
+
+        if (!compositionData) return;
 
-        if (oneOfSchemas.length < 2) {
+        const { keyword, schemas } = compositionData;
+
+        // Check for minimum schema count (oneOf and anyOf require at least 2)
+        if ((keyword === 'oneOf' || keyword === 'anyOf') && schemas.length < 2) {
           report({
-            message: `Schema object \`oneOf\` should contain at least 2 schemas. Use the schema directly instead.`,
-            location: location.child(['oneOf']),
+            message: `Schema object \`${keyword}\` should contain at least 2 schemas. Use the schema directly instead.`,
+            location: location.child([keyword]),
           });
           return;
         }
 
-        // Check for empty schema
-        for (let i = 0; i < oneOfSchemas.length; i++) {
-          const resolvedSchema = resolveSchema(oneOfSchemas[i], resolve);
+        // Check for empty schemas (applies to all composition keywords)
+        for (let i = 0; i < schemas.length; i++) {
+          const resolvedSchema = resolveSchema(schemas[i], resolve);
           if (isEmptyObject(resolvedSchema)) {
             report({
-              message:
-                'Schema in `oneOf` is empty, which makes it impossible to discriminate between schemas.',
-              location: location.child(['oneOf', String(i)]),
+              message: `Schema in \`${keyword}\` is empty, which provides no validation constraints.`,
+              location: location.child([keyword, String(i)]),
             });
             return;
           }
         }
 
-        // Check for nullable type
-        // Check for impossible nullable + oneOf with null type combination
-        if (hasNullableType(schema)) {
-          const hasNullTypeInOneOf = oneOfSchemas.some((subSchema) => {
-            const resolved = resolveSchema(subSchema, resolve);
-            return hasNullableType(resolved);
-          });
-
-          if (hasNullTypeInOneOf) {
+        // Check for duplicate schemas
+        for (let i = 0; i < schemas.length - 1; i++) {
+          if (dequal(Object.values(schemas[i]), Object.values(schemas[i + 1]))) {
             report({
-              message: `Schema with nullable type cannot have a oneOf option that is also nullable. This creates ambiguity when the value is null.`,
-              location: location.child(['oneOf']),
+              message: `Duplicate schemas found in \`${keyword}\`, which makes it impossible to discriminate between schemas.`,
+              location: location.child([keyword]),
             });
-
             return;
           }
         }
 
-        for (let i = 0; i < oneOfSchemas.length - 1; i++) {
-          if (dequal(Object.values(oneOfSchemas[i]), Object.values(oneOfSchemas[i + 1]))) {
-            report({
-              message:
-                'Duplicate schemas found in `oneOf`, which makes it impossible to discriminate between schemas.',
-              location: location.child(['oneOf']),
+        // oneOf-specific checks
+        if (keyword === 'oneOf') {
+          // Check for nullable type conflict
+          if (hasNullableType(schema)) {
+            const hasNullTypeInOneOf = schemas.some((subSchema) => {
+              const resolved = resolveSchema(subSchema, resolve);
+              return hasNullableType(resolved);
             });
 
-            return;
+            if (hasNullTypeInOneOf) {
+              report({
+                message: `Schema with nullable type cannot have a oneOf option that is also nullable. This creates ambiguity when the value is null.`,
+                location: location.child(['oneOf']),
+              });
+              return;
+            }
           }
-        }
 
-        // Always check mutual exclusivity - oneOf schemas should ALWAYS be mutually exclusive
-        const { isExclusive, reasons } = areOneOfSchemasMutuallyExclusive(oneOfSchemas, resolve);
-
-        if (!isExclusive && reasons && reasons.length > 0) {
-          // Report each ambiguous pair as a separate warning
-          for (const reason of reasons) {
-            report({
-              message: reason,
-              location: location.child(['oneOf']),
-            });
+          // Check mutual exclusivity - oneOf schemas should ALWAYS be mutually exclusive
+          const { isExclusive, reasons } = areOneOfSchemasMutuallyExclusive(schemas, resolve);
+
+          if (!isExclusive && reasons && reasons.length > 0) {
+            // Report each ambiguous pair as a separate warning
+            for (const reason of reasons) {
+              report({
+                message: reason,
+                location: location.child(['oneOf']),
+              });
+            }
           }
         }
       },