fix(functions): checkPolymorphicProperty

checkPolymorphicProperty correctly checked anyOf/oneOf/allOf but only
one level deep and didn't respect `$ref`. This fixes the code to
recursively descend down the schemas and respect references to ensure
that all properties, even if not directly defined on the object,
are found.

Author: matoous

functions/openapi/schema_type.go

@@ -646,35 +646,65 @@ func (st SchemaTypeCheck) validateDependentRequired(schema *v3.Schema, context *
 	return results
 }
 
-// checkPolymorphicProperty checks if a property is defined in anyOf, oneOf, or allOf schemas
+// checkPolymorphicProperty checks if a property is defined in anyOf, oneOf, or allOf schemas,
+// including nested compositions and referenced schemas.
 func (st SchemaTypeCheck) checkPolymorphicProperty(schema *v3.Schema, propertyName string) bool {
-	// check in AnyOf schemas
-	if schema.Value.AnyOf != nil {
-		for _, anyOfSchema := range schema.Value.AnyOf {
-			if anyOfSchema.Schema() != nil && anyOfSchema.Schema().Properties != nil &&
-				anyOfSchema.Schema().Properties.GetOrZero(propertyName) != nil {
-				return true
-			}
-		}
+	if schema == nil || schema.Value == nil {
+		return false
 	}
 
-	// check in OneOf schemas
-	if schema.Value.OneOf != nil {
-		for _, oneOfSchema := range schema.Value.OneOf {
-			if oneOfSchema.Schema() != nil && oneOfSchema.Schema().Properties != nil &&
-				oneOfSchema.Schema().Properties.GetOrZero(propertyName) != nil {
-				return true
-			}
+	visited := make(map[*lowBase.Schema]struct{})
+	return st.checkSchemaPropertyRecursive(schema.Value, propertyName, visited)
+}
+
+// checkSchemaPropertyRecursive recursively traverses down the schema looking for the existance
+// of a specific property. It ensures that all references are properly resolved.
+func (st SchemaTypeCheck) checkSchemaPropertyRecursive(schema *highBase.Schema, propertyName string, visited map[*lowBase.Schema]struct{}) bool {
+	if schema == nil {
+		return false
+	}
+
+	if low := schema.GoLow(); low != nil {
+		if _, seen := visited[low]; seen {
+			return false
 		}
+		visited[low] = struct{}{}
 	}
 
-	// check in AllOf schemas
-	if schema.Value.AllOf != nil {
-		for _, allOfSchema := range schema.Value.AllOf {
-			if allOfSchema.Schema() != nil && allOfSchema.Schema().Properties != nil &&
-				allOfSchema.Schema().Properties.GetOrZero(propertyName) != nil {
-				return true
-			}
+	if schema.Properties != nil && schema.Properties.GetOrZero(propertyName) != nil {
+		return true
+	}
+
+	if st.checkSchemaProxiesForProperty(schema.AnyOf, propertyName, visited) {
+		return true
+	}
+	if st.checkSchemaProxiesForProperty(schema.OneOf, propertyName, visited) {
+		return true
+	}
+	if st.checkSchemaProxiesForProperty(schema.AllOf, propertyName, visited) {
+		return true
+	}
+
+	return false
+}
+
+func (st SchemaTypeCheck) checkSchemaProxiesForProperty(
+	proxies []*highBase.SchemaProxy,
+	propertyName string,
+	visited map[*lowBase.Schema]struct{},
+) bool {
+	for _, proxy := range proxies {
+		if proxy == nil {
+			continue
+		}
+
+		subSchema := proxy.Schema()
+		if subSchema == nil {
+			continue
+		}
+
+		if st.checkSchemaPropertyRecursive(subSchema, propertyName, visited) {
+			return true
 		}
 	}
 

functions/openapi/schema_type_test.go

@@ -3272,6 +3272,26 @@ components:
           cat: '#/components/schemas/Cat'`,
 			expectedErrors: []struct{ message, path string }{},
 		},
+		{
+			name: "PropertyInAllOfNestedRef",
+			yaml: `openapi: 3.0.3
+components:
+  schemas:
+    Pet:
+      allOf:
+        - $ref: '#/components/schemas/PetBase'
+      discriminator:
+        propertyName: petType
+    PetBase:
+      allOf:
+        - type: object
+          properties:
+            petType:
+              type: string
+            name:
+              type: string`,
+			expectedErrors: []struct{ message, path string }{},
+		},
 		{
 			name: "PropertyInOneOf",
 			yaml: `openapi: 3.0.3
@@ -3444,4 +3464,3 @@ components:
 	assert.Contains(t, res[0].Message, "minimum")
 	assert.Contains(t, res[0].Message, "null")
 }
-