fix anyof/oneof visited

Author: tatomyr

packages/core/src/rules/common/__tests__/no-required-schema-properties-undefined.test.ts

@@ -670,6 +670,45 @@ describe('no-required-schema-properties-undefined', () => {
     `);
   });
 
+  it('should NOT report when anyOf branches share a $ref that defines the required property', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          components:
+            schemas:
+              Animal:
+                type: object
+                required:
+                  - name
+                anyOf:
+                  - allOf:
+                      - $ref: '#/components/schemas/Base'
+                      - properties:
+                          kind:
+                            enum: [cat]
+                  - allOf:
+                      - $ref: '#/components/schemas/Base'
+                      - properties:
+                          kind:
+                            enum: [dog]
+              Base:
+                type: object
+                properties:
+                  name:
+                    type: string
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await createConfig({ rules: { 'no-required-schema-properties-undefined': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`[]`);
+  });
+
   it('should NOT report when required property is in allOf sibling reached via oneOf parent', async () => {
     const document = parseYamlToDocument(
       outdent`

packages/core/src/rules/common/no-required-schema-properties-undefined.ts

@@ -43,34 +43,51 @@ export const NoRequiredSchemaPropertiesUndefined:
             return true;
           }
 
-          const check = (s: AnySchema) => hasProperty(s, propertyName, visited, resolved.location);
+          if (
+            resolved.schema.allOf?.some((s) =>
+              hasProperty(s, propertyName, visited, resolved.location)
+            )
+          ) {
+            return true;
+          }
 
-          if (resolved.schema.allOf?.some(check)) return true;
-          if (resolved.schema.anyOf?.every(check)) return true;
-          if (resolved.schema.oneOf?.every(check)) return true;
+          if (
+            resolved.schema.anyOf?.every((s) =>
+              hasProperty(s, propertyName, new Set(visited), resolved.location)
+            )
+          ) {
+            return true;
+          }
+
+          if (
+            resolved.schema.oneOf?.every((s) =>
+              hasProperty(s, propertyName, new Set(visited), resolved.location)
+            )
+          ) {
+            return true;
+          }
 
           return false;
         };
 
         const isCompositionChild = (parent: AnySchema, child: AnySchema): boolean => {
-          const matches = (s: AnySchema) => resolveSchema(s, ctx).schema === child;
+          const matchesChild = (s: AnySchema) => resolveSchema(s, ctx).schema === child;
           return !!(
-            parent.allOf?.some(matches) ||
-            parent.anyOf?.some(matches) ||
-            parent.oneOf?.some(matches)
+            parent.allOf?.some(matchesChild) ||
+            parent.anyOf?.some(matchesChild) ||
+            parent.oneOf?.some(matchesChild)
           );
         };
 
-        const findCompositionRoot = (): AnySchema | undefined => {
-          const walk = (i: number, child: AnySchema): AnySchema | undefined => {
-            if (i < 0) return undefined;
-            const parent = parents[i];
-            return isCompositionChild(parent, child) ? (walk(i - 1, parent) ?? parent) : undefined;
-          };
-          return walk(parents.length - 2, schema);
+        const findCompositionRoot = (i: number, child: AnySchema): AnySchema | undefined => {
+          if (i < 0) return undefined;
+          const parent = parents[i];
+          return isCompositionChild(parent, child)
+            ? (findCompositionRoot(i - 1, parent) ?? parent)
+            : undefined;
         };
 
-        const compositionRoot = findCompositionRoot();
+        const compositionRoot = findCompositionRoot(parents.length - 2, schema);
 
         for (const [i, requiredProperty] of schema.required.entries()) {
           if (