Support prompt and assign user-defined parameter types (bicep)

cli/azd/pkg/azure/arm_template.go

@@ -28,6 +28,7 @@ type ArmTemplate struct {
 	ContentVersion string                          `json:"contentVersion"`
 	Parameters     ArmTemplateParameterDefinitions `json:"parameters"`
 	Outputs        ArmTemplateOutputs              `json:"outputs"`
+	Definitions    ArmTemplateParameterDefinitions `json:"definitions"`
 }
 
 var cResourceDeploymentTemplateSchemaLower = strings.ToLower("deploymentTemplate.json")
@@ -60,14 +61,16 @@ type ArmTemplateParameterDefinitions map[string]ArmTemplateParameterDefinition
 type ArmTemplateOutputs map[string]ArmTemplateOutput
 
 type ArmTemplateParameterDefinition struct {
-	Type          string                     `json:"type"`
-	DefaultValue  any                        `json:"defaultValue"`
-	AllowedValues *[]any                     `json:"allowedValues,omitempty"`
-	MinValue      *int                       `json:"minValue,omitempty"`
-	MaxValue      *int                       `json:"maxValue,omitempty"`
-	MinLength     *int                       `json:"minLength,omitempty"`
-	MaxLength     *int                       `json:"maxLength,omitempty"`
-	Metadata      map[string]json.RawMessage `json:"metadata"`
+	Type          string                          `json:"type"`
+	DefaultValue  any                             `json:"defaultValue"`
+	AllowedValues *[]any                          `json:"allowedValues,omitempty"`
+	MinValue      *int                            `json:"minValue,omitempty"`
+	MaxValue      *int                            `json:"maxValue,omitempty"`
+	MinLength     *int                            `json:"minLength,omitempty"`
+	MaxLength     *int                            `json:"maxLength,omitempty"`
+	Metadata      map[string]json.RawMessage      `json:"metadata"`
+	Ref           string                          `json:"$ref"`
+	Properties    ArmTemplateParameterDefinitions `json:"properties,omitempty"`
 }
 
 func (d *ArmTemplateParameterDefinition) Secure() bool {

cli/azd/pkg/infra/provisioning/bicep/bicep_provider.go

@@ -1439,23 +1439,34 @@ type compileBicepResult struct {
 }
 
 func (p *BicepProvider) compileBicep(
-	ctx context.Context, modulePath string,
+	ctx context.Context,
+	modulePath string,
+) (*compileBicepResult, error) {
+	currentPrincipalId, err := p.curPrincipal.CurrentPrincipalId(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("fetching current principal id for bicepparam compilation: %w", err)
+	}
+	return compileBicep(ctx, modulePath, p.env, currentPrincipalId, p.bicepCli)
+}
+
+func compileBicep(
+	ctx context.Context,
+	modulePath string,
+	env *environment.Environment,
+	currentPrincipalId string,
+	bicepCli bicep.BicepCli,
 ) (*compileBicepResult, error) {
 	var compiled string
 	var parameters azure.ArmParameters
 
 	if isBicepParamFile(modulePath) {
-		azdEnv := p.env.Environ()
+		azdEnv := env.Environ()
 		// append principalID (not stored to .env by default). For non-bicepparam, principalId is resolved
 		// without looking at .env
-		if _, exists := p.env.LookupEnv(environment.PrincipalIdEnvVarName); !exists {
-			currentPrincipalId, err := p.curPrincipal.CurrentPrincipalId(ctx)
-			if err != nil {
-				return nil, fmt.Errorf("fetching current principal id for bicepparam compilation: %w", err)
-			}
+		if _, exists := env.LookupEnv(environment.PrincipalIdEnvVarName); !exists {
 			azdEnv = append(azdEnv, fmt.Sprintf("%s=%s", environment.PrincipalIdEnvVarName, currentPrincipalId))
 		}
-		compiledResult, err := p.bicepCli.BuildBicepParam(ctx, modulePath, azdEnv)
+		compiledResult, err := bicepCli.BuildBicepParam(ctx, modulePath, azdEnv)
 		if err != nil {
 			return nil, fmt.Errorf("failed to compile bicepparam template: %w", err)
 		}
@@ -1474,7 +1485,7 @@ func (p *BicepProvider) compileBicep(
 		}
 		parameters = params.Parameters
 	} else {
-		res, err := p.bicepCli.Build(ctx, modulePath)
+		res, err := bicepCli.Build(ctx, modulePath)
 		if err != nil {
 			return nil, fmt.Errorf("failed to compile bicep template: %w", err)
 		}
@@ -1489,6 +1500,25 @@ func (p *BicepProvider) compileBicep(
 		return nil, fmt.Errorf("failed unmarshalling arm template from json: %w", err)
 	}
 
+	// update user-defined parameters
+	for paramKey, param := range template.Parameters {
+		paramRef := param.Ref
+		isUserDefinedType := paramRef != ""
+		if isUserDefinedType {
+			definitionKeyNameTokens := strings.Split(paramRef, "/")
+			definitionKeyNameTokensLen := len(definitionKeyNameTokens)
+			if definitionKeyNameTokensLen < 1 {
+				return nil, fmt.Errorf("failed resolving user defined parameter type: %s", paramRef)
+			}
+			definitionKeyName := definitionKeyNameTokens[definitionKeyNameTokensLen-1]
+			paramDefinition, findDefinition := template.Definitions[definitionKeyName]
+			if !findDefinition {
+				return nil, fmt.Errorf("did not find definition for parameter type: %s", definitionKeyName)
+			}
+			template.Parameters[paramKey] = paramDefinition
+		}
+	}
+
 	return &compileBicepResult{
 		RawArmTemplate: rawTemplate,
 		Template:       template,

cli/azd/pkg/infra/provisioning/bicep/bicep_provider_test.go

@@ -878,3 +878,179 @@ func (m *mockedScope) ListDeployments(ctx context.Context) ([]*armresources.Depl
 		},
 	}, nil
 }
+
+func TestUserDefinedTypes(t *testing.T) {
+	mockContext := mocks.NewMockContext(context.Background())
+	mockContext.CommandRunner.When(func(args exec.RunArgs, command string) bool {
+		return strings.Contains(args.Cmd, "bicep") && args.Args[0] == "--version"
+	}).Respond(exec.RunResult{
+		Stdout: fmt.Sprintf("Bicep CLI version %s (abcdef0123)", bicep.BicepVersion.String()),
+		Stderr: "",
+	})
+
+	bicepCli, err := bicep.NewBicepCli(*mockContext.Context, mockContext.Console, mockContext.CommandRunner)
+	require.NoError(t, err)
+	env := environment.EphemeralWithValues("test-env", map[string]string{})
+
+	mockContext.CommandRunner.When(func(args exec.RunArgs, command string) bool {
+		return strings.Contains(args.Cmd, "bicep") && args.Args[0] == "build"
+	}).Respond(exec.RunResult{
+		Stdout: userDefinedParamsSample,
+		Stderr: "",
+	})
+
+	compiled, err := compileBicep(*mockContext.Context, "user-defined-types", env, "principalId", bicepCli)
+
+	require.NoError(t, err)
+	require.NotNil(t, compiled)
+
+	template := compiled.Template
+
+	stringParam, exists := template.Parameters["stringParam"]
+	require.True(t, exists)
+	require.Equal(t, "string", stringParam.Type)
+	require.Nil(t, stringParam.AllowedValues)
+
+	stringLimitedParam, exists := template.Parameters["stringLimitedParam"]
+	require.True(t, exists)
+	require.Equal(t, "string", stringLimitedParam.Type)
+	require.NotNil(t, stringLimitedParam.AllowedValues)
+	require.Equal(t, []interface{}{"arm", "azure", "bicep"}, *stringLimitedParam.AllowedValues)
+
+	intType, exists := template.Parameters["intType"]
+	require.True(t, exists)
+	require.Equal(t, "int", intType.Type)
+	require.NotNil(t, intType.AllowedValues)
+	require.Equal(t, []interface{}{float64(10)}, *intType.AllowedValues)
+
+	boolParam, exists := template.Parameters["boolParam"]
+	require.True(t, exists)
+	require.Equal(t, "bool", boolParam.Type)
+	require.NotNil(t, boolParam.AllowedValues)
+	require.Equal(t, []interface{}{true}, *boolParam.AllowedValues)
+
+	arrayStringType, exists := template.Parameters["arrayParam"]
+	require.True(t, exists)
+	require.Equal(t, "array", arrayStringType.Type)
+	require.Nil(t, arrayStringType.AllowedValues)
+
+	arrayLimitedParam, exists := template.Parameters["arrayLimitedParam"]
+	require.True(t, exists)
+	require.Equal(t, "array", arrayLimitedParam.Type)
+	require.NotNil(t, arrayLimitedParam.AllowedValues)
+	require.Equal(t, []interface{}{"a", "b", "c"}, *arrayLimitedParam.AllowedValues)
+
+	mixedParam, exists := template.Parameters["mixedParam"]
+	require.True(t, exists)
+	require.Equal(t, "array", mixedParam.Type)
+	require.NotNil(t, mixedParam.AllowedValues)
+	require.Equal(
+		t, []interface{}{"fizz", float64(42), nil, map[string]interface{}{"an": "object"}}, *mixedParam.AllowedValues)
+
+	objectParam, exists := template.Parameters["objectParam"]
+	require.True(t, exists)
+	require.Equal(t, "object", objectParam.Type)
+	require.Nil(t, objectParam.AllowedValues)
+	require.NotNil(t, objectParam.Properties)
+	require.Equal(
+		t,
+		azure.ArmTemplateParameterDefinitions{
+			"name": {Type: "string"},
+			"sku":  {Type: "string"},
+		},
+		objectParam.Properties)
+
+}
+
+const userDefinedParamsSample = `{
+	"$schema": "https://schema.management.azure.com/schemas/2018-05-01/subscriptionDeploymentTemplate.json#",
+	"languageVersion": "2.0",
+	"definitions": {
+	  "stringType": {
+		"type": "string"
+	  },
+	  "stringLimitedType": {
+		"type": "string",
+		"allowedValues": [
+		  "arm",
+		  "azure",
+		  "bicep"
+		]
+	  },
+	  "intType": {
+		"type": "int",
+		"allowedValues": [
+		  10
+		]
+	  },
+	  "boolType": {
+		"type": "bool",
+		"allowedValues": [
+		  true
+		]
+	  },
+	  "arrayStringType": {
+		"type": "array",
+		"items": {
+		  "type": "string"
+		}
+	  },
+	  "arrayStringLimitedType": {
+		"type": "array",
+		"allowedValues": [
+		  "a",
+		  "b",
+		  "c"
+		]
+	  },
+	  "mixedType": {
+		"type": "array",
+		"allowedValues": [
+		  "fizz",
+		  42,
+		  null,
+		  {
+			"an": "object"
+		  }
+		]
+	  },
+	  "objectType": {
+		"type": "object",
+		"properties": {
+		  "name": {
+			"type": "string"
+		  },
+		  "sku": {
+			"type": "string"
+		  }
+		}
+	  }
+	},
+	"parameters": {
+	  "stringParam": {
+		"$ref": "#/definitions/stringType"
+	  },
+	  "stringLimitedParam": {
+		"$ref": "#/definitions/stringLimitedType"
+	  },
+	  "intType": {
+		"$ref": "#/definitions/intType"
+	  },
+	  "boolParam": {
+		"$ref": "#/definitions/boolType"
+	  },
+	  "arrayParam": {
+		"$ref": "#/definitions/arrayStringType"
+	  },
+	  "arrayLimitedParam": {
+		"$ref": "#/definitions/arrayStringLimitedType"
+	  },
+	  "mixedParam": {
+		"$ref": "#/definitions/mixedType"
+	  },
+	  "objectParam": {
+		"$ref": "#/definitions/objectType"
+	  }
+	},
+	"resources": {}
+}`