Add support for anyOf to skip_prompt_if

libs/jsonschema/instance.go

@@ -24,10 +24,7 @@ func (s *Schema) LoadInstance(path string) (map[string]any, error) {
 	// We convert integer properties from float64 to int64 here.
 	for name, v := range instance {
 		propertySchema, ok := s.Properties[name]
-		if !ok {
-			continue
-		}
-		if propertySchema.Type != IntegerType {
+		if !ok || propertySchema.Type != IntegerType {
 			continue
 		}
 		integerValue, err := toInteger(v)
@@ -47,6 +44,8 @@ func (s *Schema) ValidateInstance(instance map[string]any) error {
 		s.validateRequired,
 		s.validateTypes,
 		s.validatePattern,
+		s.validateConst,
+		s.validateAnyOf,
 	}
 
 	for _, fn := range validations {
@@ -74,12 +73,20 @@ func (s *Schema) validateAdditionalProperties(instance map[string]any) error {
 	return nil
 }
 
+type RequiredPropertyMissingError struct {
+	Name string
+}
+
+func (err RequiredPropertyMissingError) Error() string {
+	return fmt.Sprintf("no value provided for required property %s", err.Name)
+}
+
 // This function validates that all require properties in the schema have values
 // in the instance.
 func (s *Schema) validateRequired(instance map[string]any) error {
 	for _, name := range s.Required {
 		if _, ok := instance[name]; !ok {
-			return fmt.Errorf("no value provided for required property %s", name)
+			return RequiredPropertyMissingError{Name: name}
 		}
 	}
 	return nil
@@ -103,10 +110,7 @@ func (s *Schema) validateTypes(instance map[string]any) error {
 func (s *Schema) validateEnum(instance map[string]any) error {
 	for k, v := range instance {
 		fieldInfo, ok := s.Properties[k]
-		if !ok {
-			continue
-		}
-		if fieldInfo.Enum == nil {
+		if !ok || fieldInfo.Enum == nil {
 			continue
 		}
 		if !slices.Contains(fieldInfo.Enum, v) {
@@ -129,3 +133,34 @@ func (s *Schema) validatePattern(instance map[string]any) error {
 	}
 	return nil
 }
+
+func (s *Schema) validateConst(instance map[string]any) error {
+	for k, v := range instance {
+		fieldInfo, ok := s.Properties[k]
+		if !ok || fieldInfo.Const == nil {
+			continue
+		}
+		if v != fieldInfo.Const {
+			return fmt.Errorf("expected value of property %s to be %v. Found: %v", k, fieldInfo.Const, v)
+		}
+	}
+	return nil
+}
+
+// Validates that the instance matches at least one of the schemas in anyOf
+// but will also succeed if the property values are omitted.
+// For more information, see https://json-schema.org/understanding-json-schema/reference/combining#anyof.
+func (s *Schema) validateAnyOf(instance map[string]any) error {
+	if s.AnyOf == nil {
+		return nil
+	}
+	// Currently, we only validate const for anyOf schemas since anyOf is
+	// only used by skip_prompt_if, which only supports const.
+	for _, anyOf := range s.AnyOf {
+		err := anyOf.validateConst(instance)
+		if err == nil {
+			return nil
+		}
+	}
+	return fmt.Errorf("instance does not match any of the schemas in anyOf")
+}

libs/jsonschema/instance_test.go

@@ -222,3 +222,92 @@ func TestValidateInstanceForMultiplePatterns(t *testing.T) {
 	assert.EqualError(t, schema.validatePattern(invalidInstanceValue), "invalid value for bar: \"xyz\". Expected to match regex pattern: ^[d-f]+$")
 	assert.EqualError(t, schema.ValidateInstance(invalidInstanceValue), "invalid value for bar: \"xyz\". Expected to match regex pattern: ^[d-f]+$")
 }
+
+func TestValidateInstanceForConst(t *testing.T) {
+	schema, err := Load("./testdata/instance-validate/test-schema-const.json")
+	require.NoError(t, err)
+
+	// Valid values for both foo and bar
+	validInstance := map[string]any{
+		"foo": "abc",
+		"bar": "def",
+	}
+	assert.NoError(t, schema.validateConst(validInstance))
+	assert.NoError(t, schema.ValidateInstance(validInstance))
+
+	// Empty instance
+	emptyInstanceValue := map[string]any{}
+	assert.NoError(t, schema.validateConst(emptyInstanceValue))
+	assert.NoError(t, schema.ValidateInstance(emptyInstanceValue))
+
+	// Missing value for bar
+	missingInstanceValue := map[string]any{
+		"foo": "abc",
+	}
+	assert.NoError(t, schema.validateConst(missingInstanceValue))
+	assert.NoError(t, schema.ValidateInstance(missingInstanceValue))
+
+	// Valid value for bar, invalid value for foo
+	invalidInstanceValue := map[string]any{
+		"foo": "xyz",
+		"bar": "def",
+	}
+	assert.EqualError(t, schema.validateConst(invalidInstanceValue), "expected value of property foo to be abc. Found: xyz")
+	assert.EqualError(t, schema.ValidateInstance(invalidInstanceValue), "expected value of property foo to be abc. Found: xyz")
+
+	// Valid value for foo, invalid value for bar
+	invalidInstanceValue = map[string]any{
+		"foo": "abc",
+		"bar": "xyz",
+	}
+	assert.EqualError(t, schema.validateConst(invalidInstanceValue), "expected value of property bar to be def. Found: xyz")
+	assert.EqualError(t, schema.ValidateInstance(invalidInstanceValue), "expected value of property bar to be def. Found: xyz")
+}
+
+func TestValidateInstanceForAnyOf(t *testing.T) {
+	schema, err := Load("./testdata/instance-validate/test-schema-anyof.json")
+	require.NoError(t, err)
+
+	// Valid values for both foo and bar
+	validInstance := map[string]any{
+		"foo": "abc",
+		"bar": "abc",
+	}
+	assert.NoError(t, schema.validateAnyOf(validInstance))
+	assert.NoError(t, schema.ValidateInstance(validInstance))
+
+	// Valid values for bar
+	validInstance = map[string]any{
+		"foo": "abc",
+		"bar": "def",
+	}
+	assert.NoError(t, schema.validateAnyOf(validInstance))
+	assert.NoError(t, schema.ValidateInstance(validInstance))
+
+	// Empty instance
+	emptyInstanceValue := map[string]any{}
+	assert.NoError(t, schema.validateAnyOf(emptyInstanceValue))
+	assert.NoError(t, schema.ValidateInstance(emptyInstanceValue))
+
+	// Missing values for bar, invalid value for foo
+	missingInstanceValue := map[string]any{
+		"foo": "xyz",
+	}
+	assert.NoError(t, schema.validateAnyOf(missingInstanceValue))
+	assert.NoError(t, schema.ValidateInstance(missingInstanceValue))
+
+	// Valid value for bar, invalid value for foo
+	invalidInstanceValue := map[string]any{
+		"foo": "xyz",
+		"bar": "abc",
+	}
+	assert.EqualError(t, schema.validateAnyOf(invalidInstanceValue), "instance does not match any of the schemas in anyOf")
+	assert.EqualError(t, schema.ValidateInstance(invalidInstanceValue), "instance does not match any of the schemas in anyOf")
+
+	// Invalid value for both
+	invalidInstanceValue = map[string]any{
+		"bar": "xyz",
+	}
+	assert.EqualError(t, schema.validateAnyOf(invalidInstanceValue), "instance does not match any of the schemas in anyOf")
+	assert.EqualError(t, schema.ValidateInstance(invalidInstanceValue), "instance does not match any of the schemas in anyOf")
+}

libs/jsonschema/schema.go

@@ -60,6 +60,9 @@ type Schema struct {
 
 	// Extension embeds our custom JSON schema extensions.
 	Extension
+
+	// Schema that must match any of the schemas in the array
+	AnyOf []*Schema `json:"anyOf,omitempty"`
 }
 
 // Default value defined in a JSON Schema, represented as a string.

libs/jsonschema/testdata/instance-validate/test-schema-anyof.json

@@ -0,0 +1,24 @@
+{
+    "anyOf": [
+        {
+            "properties": {
+                "foo": {
+                    "type": "string",
+                    "const": "abc"
+                },
+                "bar": {
+                    "type": "string",
+                    "const": "abc"
+                }
+            }
+        },
+        {
+            "properties": {
+                "bar": {
+                    "type": "string",
+                    "const": "def"
+                }
+            }
+        }
+    ]
+}

libs/jsonschema/testdata/instance-validate/test-schema-const.json

@@ -0,0 +1,12 @@
+{
+    "properties": {
+        "foo": {
+            "type": "string",
+            "const": "abc"
+        },
+        "bar": {
+            "type": "string",
+            "const": "def"
+        }
+    }
+}

libs/template/config.go

@@ -125,12 +125,30 @@ func (c *config) skipPrompt(p jsonschema.Property, r *renderer) (bool, error) {
 		return false, nil
 	}
 
-	// Check if conditions specified by template author for skipping the prompt
-	// are satisfied. If they are not, we have to prompt for a user input.
-	for name, property := range p.Schema.SkipPromptIf.Properties {
-		if v, ok := c.values[name]; ok && v == property.Const {
-			continue
+	// All fields referred to in a SkipPromptIf condition are implicitly made required and
+	// we diverge from strictly following the JSON schema because it makes the author UX better.
+	required := make(map[string]struct{})
+	for _, k := range p.Schema.SkipPromptIf.Required {
+		required[k] = struct{}{}
+	}
+	for k := range p.Schema.SkipPromptIf.Properties {
+		required[k] = struct{}{}
+	}
+	for _, schema := range p.Schema.SkipPromptIf.AnyOf {
+		for k := range schema.Properties {
+			required[k] = struct{}{}
 		}
+	}
+	p.Schema.SkipPromptIf.Required = maps.Keys(required)
+
+	// Validate the partial config against skip_prompt_if schema
+	validationErr := p.Schema.SkipPromptIf.ValidateInstance(c.values)
+
+	target := jsonschema.RequiredPropertyMissingError{}
+	if errors.As(validationErr, &target) {
+		return false, fmt.Errorf("property %s is used in skip_prompt_if but has no value assigned", target.Name)
+	}
+	if validationErr != nil {
 		return false, nil
 	}