Add support for conditional prompting in bundle init

libs/jsonschema/extension.go

@@ -27,6 +27,10 @@ type Extension struct {
 	// schema will fail.
 	MinDatabricksCliVersion string `json:"min_databricks_cli_version,omitempty"`
 
+	// Skip prompting if this schema is satisfied by the configuration already present. In
+	// that case the default value of the property is used instead.
+	SkipPromptIf *Schema `json:"skip_prompt_if,omitempty"`
+
 	// Version of the schema. This is used to determine if the schema is
 	// compatible with the current CLI version.
 	Version *int `json:"version,omitempty"`

libs/jsonschema/schema.go

@@ -20,6 +20,10 @@ type Schema struct {
 	// IDE. This is manually injected here using schema.Docs
 	Description string `json:"description,omitempty"`
 
+	// Expected value for the JSON object. The object value must be equal to this
+	// field if it's specified in the schema.
+	Const any `json:"const,omitempty"`
+
 	// Schemas for the fields of an struct. The keys are the first json tag.
 	// The values are the schema for the type of the field
 	Properties map[string]*Schema `json:"properties,omitempty"`
@@ -118,6 +122,18 @@ func (schema *Schema) validateSchemaDefaultValueTypes() error {
 	return nil
 }
 
+func (schema *Schema) validateConstValueTypes() error {
+	for name, property := range schema.Properties {
+		if property.Const == nil {
+			continue
+		}
+		if err := validateType(property.Const, property.Type); err != nil {
+			return fmt.Errorf("type validation for const value of property %s failed: %w", name, err)
+		}
+	}
+	return nil
+}
+
 // Validate enum field values for properties are consistent with types.
 func (schema *Schema) validateSchemaEnumValueTypes() error {
 	for name, property := range schema.Properties {
@@ -203,14 +219,25 @@ func (schema *Schema) validateSchemaMinimumCliVersion(currentVersion string) fun
 	}
 }
 
+func (schema *Schema) validateSchemaSkippedPropertiesHaveDefaults() error {
+	for name, property := range schema.Properties {
+		if property.SkipPromptIf != nil && property.Default == nil {
+			return fmt.Errorf("property %q has a skip_prompt_if clause but no default value", name)
+		}
+	}
+	return nil
+}
+
 func (schema *Schema) validate() error {
 	for _, fn := range []func() error{
 		schema.validateSchemaPropertyTypes,
 		schema.validateSchemaDefaultValueTypes,
 		schema.validateSchemaEnumValueTypes,
+		schema.validateConstValueTypes,
 		schema.validateSchemaDefaultValueIsInEnums,
 		schema.validateSchemaPattern,
 		schema.validateSchemaMinimumCliVersion("v" + build.GetInfo().Version),
+		schema.validateSchemaSkippedPropertiesHaveDefaults,
 	} {
 		err := fn()
 		if err != nil {
@@ -248,6 +275,12 @@ func Load(path string) (*Schema, error) {
 				return nil, fmt.Errorf("failed to parse default value for property %s: %w", name, err)
 			}
 		}
+		if property.Const != nil {
+			property.Const, err = toInteger(property.Const)
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse const value for property %s: %w", name, err)
+			}
+		}
 		for i, enum := range property.Enum {
 			property.Enum[i], err = toInteger(enum)
 			if err != nil {

libs/jsonschema/schema_test.go

@@ -48,6 +48,7 @@ func TestSchemaLoadIntegers(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, int64(1), schema.Properties["abc"].Default)
 	assert.Equal(t, []any{int64(1), int64(2), int64(3)}, schema.Properties["abc"].Enum)
+	assert.Equal(t, int64(5), schema.Properties["def"].Const)
 }
 
 func TestSchemaLoadIntegersWithInvalidDefault(t *testing.T) {
@@ -60,6 +61,11 @@ func TestSchemaLoadIntegersWithInvalidEnums(t *testing.T) {
 	assert.EqualError(t, err, "failed to parse enum value 2.4 at index 1 for property abc: expected integer value, got: 2.4")
 }
 
+func TestSchemaLoadIntergersWithInvalidConst(t *testing.T) {
+	_, err := Load("./testdata/schema-load-int/schema-invalid-const.json")
+	assert.EqualError(t, err, "failed to parse const value for property def: expected integer value, got: 5.1")
+}
+
 func TestSchemaValidateDefaultType(t *testing.T) {
 	invalidSchema := &Schema{
 		Properties: map[string]*Schema{
@@ -250,3 +256,52 @@ func TestValidateSchemaMinimumCliVersion(t *testing.T) {
 	err = s.validateSchemaMinimumCliVersion("v0.0.0-dev")()
 	assert.NoError(t, err)
 }
+
+func TestValidateSchemaConstTypes(t *testing.T) {
+	s := &Schema{
+		Properties: map[string]*Schema{
+			"foo": {
+				Type:  "string",
+				Const: "abc",
+			},
+		},
+	}
+	err := s.validate()
+	assert.NoError(t, err)
+
+	s = &Schema{
+		Properties: map[string]*Schema{
+			"foo": {
+				Type:  "string",
+				Const: 123,
+			},
+		},
+	}
+	err = s.validate()
+	assert.EqualError(t, err, "type validation for const value of property foo failed: expected type string, but value is 123")
+}
+
+func TestValidateSchemaSkippedPropertiesHaveDefaults(t *testing.T) {
+	s := &Schema{
+		Properties: map[string]*Schema{
+			"foo": {
+				Type:      "string",
+				Extension: Extension{SkipPromptIf: &Schema{}},
+			},
+		},
+	}
+	err := s.validate()
+	assert.EqualError(t, err, "property \"foo\" has a skip_prompt_if clause but no default value")
+
+	s = &Schema{
+		Properties: map[string]*Schema{
+			"foo": {
+				Type:      "string",
+				Default:   "abc",
+				Extension: Extension{SkipPromptIf: &Schema{}},
+			},
+		},
+	}
+	err = s.validate()
+	assert.NoError(t, err)
+}

libs/jsonschema/testdata/schema-load-int/schema-invalid-const.json

@@ -0,0 +1,9 @@
+{
+    "type": "object",
+    "properties": {
+        "def": {
+            "type": "integer",
+            "const": 5.1
+        }
+    }
+}

libs/jsonschema/testdata/schema-load-int/schema-valid.json

@@ -5,6 +5,10 @@
             "type": "integer",
             "default": 1,
             "enum": [1,2,3]
+        },
+        "def": {
+            "type": "integer",
+            "const": 5
         }
     }
 }

libs/template/config.go

@@ -105,20 +105,61 @@ func (c *config) assignDefaultValues(r *renderer) error {
 	return nil
 }
 
+func (c *config) skipPrompt(p jsonschema.Property, r *renderer) (bool, error) {
+	// Config already has a value assigned. We don't have to prompt for a user input.
+	if _, ok := c.values[p.Name]; ok {
+		return true, nil
+	}
+
+	if p.Schema.SkipPromptIf == nil {
+		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
+		}
+		return false, nil
+	}
+
+	if p.Schema.Default == nil {
+		return false, fmt.Errorf("property %s has skip_prompt_if set but no default value", p.Name)
+	}
+
+	// Assign default value to property if we are skipping it.
+	if p.Schema.Type != jsonschema.StringType {
+		c.values[p.Name] = p.Schema.Default
+		return true, nil
+	}
+
+	// Execute the default value as a template and assign it to the property.
+	var err error
+	c.values[p.Name], err = r.executeTemplate(p.Schema.Default.(string))
+	if err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
 // Prompts user for values for properties that do not have a value set yet
 func (c *config) promptForValues(r *renderer) error {
 	for _, p := range c.schema.OrderedProperties() {
 		name := p.Name
 		property := p.Schema
 
-		// Config already has a value assigned
-		if _, ok := c.values[name]; ok {
+		// Skip prompting if we can.
+		skip, err := c.skipPrompt(p, r)
+		if err != nil {
+			return err
+		}
+		if skip {
 			continue
 		}
 
 		// Compute default value to display by converting it to a string
 		var defaultVal string
-		var err error
 		if property.Default != nil {
 			defaultValRaw, err := property.DefaultString()
 			if err != nil {