refactor(rules): two use cases not handled by current implementation

Author: jeremyfiel

.changeset/nasty-peas-agree.md

@@ -0,0 +1,6 @@
+---
+'@redocly/openapi-core': patch
+'@redocly/cli': patch
+---
+
+Updated `no-required-schema-properties-undefined` rule to cover additional edge cases.

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

@@ -898,6 +898,147 @@ describe('no-required-schema-properties-undefined', () => {
     `);
   });
 
+  it('should not report bare required when property is defined in parent allOf sibling', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          components:
+            schemas:
+              PersonBase:
+                type: object
+                properties:
+                  personName:
+                    type: object
+                    properties:
+                      givenName:
+                        type: string
+                      familyName:
+                        type: string
+              Person:
+                type: object
+                allOf:
+                  - $ref: '#/components/schemas/PersonBase'
+                properties:
+                  personName:
+                    required:
+                      - givenName
+                      - familyName
+                required:
+                  - personName
+        `,
+      '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 bare required in oneOf branches when property is defined in parent allOf sibling', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          components:
+            schemas:
+              PersonBase:
+                type: object
+                properties:
+                  communication:
+                    type: object
+                    properties:
+                      landlines:
+                        type: array
+                      mobiles:
+                        type: array
+                      emails:
+                        type: array
+              Person:
+                type: object
+                allOf:
+                  - $ref: '#/components/schemas/PersonBase'
+                properties:
+                  communication:
+                    oneOf:
+                      - required:
+                          - landlines
+                      - required:
+                          - mobiles
+                      - required:
+                          - emails
+                required:
+                  - communication
+        `,
+      '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 report misspelled required property even when parent allOf sibling defines the property', async () => {
+    const document = parseYamlToDocument(
+      outdent`
+          openapi: 3.0.0
+          components:
+            schemas:
+              PersonBase:
+                type: object
+                properties:
+                  personName:
+                    type: object
+                    properties:
+                      givenName:
+                        type: string
+                      familyName:
+                        type: string
+              Person:
+                type: object
+                allOf:
+                  - $ref: '#/components/schemas/PersonBase'
+                properties:
+                  personName:
+                    required:
+                      - giveName
+                required:
+                  - personName
+        `,
+      'foobar.yaml'
+    );
+
+    const results = await lintDocument({
+      externalRefResolver: new BaseResolver(),
+      document,
+      config: await createConfig({ rules: { 'no-required-schema-properties-undefined': 'error' } }),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      [
+        {
+          "location": [
+            {
+              "pointer": "#/components/schemas/Person/properties/personName/required/0",
+              "reportOnKey": false,
+              "source": "foobar.yaml",
+            },
+          ],
+          "message": "Required property 'giveName' is not defined.",
+          "ruleId": "no-required-schema-properties-undefined",
+          "severity": "error",
+          "suggest": [],
+        },
+      ]
+    `);
+  });
+
   it('should not crash on unresolved $ref', async () => {
     const document = parseYamlToDocument(
       outdent`

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

@@ -81,10 +81,47 @@ export const NoRequiredSchemaPropertiesUndefined:
 
         const compositionRoot = findCompositionRoot(parents.length - 2, currentSchema);
 
+        const hasPropertyInParentContext = (
+          propertyName: string,
+          targetSchema: AnySchema
+        ): boolean => {
+          for (let i = parents.length - 2; i >= 0; i--) {
+            const ancestor = parents[i];
+            const props = ancestor.properties as Record<string, AnySchema> | undefined;
+            if (!props) continue;
+
+            const propKey = (Object.keys(props) as string[]).find((k) => {
+              const val = getOwn(props, k) as AnySchema;
+              if (val === targetSchema) return true;
+              return resolveSchema(val, ctx).schema === targetSchema;
+            });
+            if (!propKey) continue;
+
+            const checkSiblings = (siblings: AnySchema[] | undefined): boolean =>
+              !!siblings?.some((sibling) => {
+                const { schema: s, location } = resolveSchema(sibling, ctx);
+                if (!s?.properties) return false;
+                const propDef = getOwn(s.properties as Record<string, AnySchema>, propKey);
+                if (propDef === undefined) return false;
+                return hasProperty(propDef as AnySchema, propertyName, new Set(), location);
+              });
+
+            if (
+              checkSiblings(ancestor.allOf) ||
+              checkSiblings(ancestor.anyOf) ||
+              checkSiblings(ancestor.oneOf)
+            ) {
+              return true;
+            }
+          }
+          return false;
+        };
+
         for (const [i, requiredProperty] of currentSchema.required.entries()) {
           if (
             !hasProperty(currentSchema, requiredProperty, new Set()) &&
-            !hasProperty(compositionRoot, requiredProperty, new Set())
+            !hasProperty(compositionRoot, requiredProperty, new Set()) &&
+            !hasPropertyInParentContext(requiredProperty, compositionRoot ?? currentSchema)
           ) {
             ctx.report({
               message: `Required property '${requiredProperty}' is not defined.`,