Feat: Add HCL configuration variable type

client/api_client.go

@@ -13,8 +13,8 @@ type ApiClient struct {
 
 type ApiClientInterface interface {
 	ConfigurationVariables(scope Scope, scopeId string) ([]ConfigurationVariable, error)
-	ConfigurationVariableCreate(name string, value string, isSensitive bool, scope Scope, scopeId string, type_ ConfigurationVariableType, enumValues []string, description string) (ConfigurationVariable, error)
-	ConfigurationVariableUpdate(id string, name string, value string, isSensitive bool, scope Scope, scopeId string, type_ ConfigurationVariableType, enumValues []string, description string) (ConfigurationVariable, error)
+	ConfigurationVariableCreate(params ConfigurationVariableCreateParams) (ConfigurationVariable, error)
+	ConfigurationVariableUpdate(params ConfigurationVariableUpdateParams) (ConfigurationVariable, error)
 	ConfigurationVariableDelete(id string) error
 	Organization() (Organization, error)
 	organizationId() (string, error)

client/configuration_variable.go

@@ -31,8 +31,8 @@ func (self *ApiClient) ConfigurationVariables(scope Scope, scopeId string) ([]Co
 	return result, nil
 }
 
-func (self *ApiClient) ConfigurationVariableCreate(name string, value string, isSensitive bool, scope Scope, scopeId string, type_ ConfigurationVariableType, enumValues []string, description string) (ConfigurationVariable, error) {
-	if scope == ScopeDeploymentLog || scope == ScopeDeployment {
+func (self *ApiClient) ConfigurationVariableCreate(params ConfigurationVariableCreateParams) (ConfigurationVariable, error) {
+	if params.Scope == ScopeDeploymentLog || params.Scope == ScopeDeployment {
 		return ConfigurationVariable{}, errors.New("Must not create variable on scope deployment / deploymentLog")
 	}
 	organizationId, err := self.organizationId()
@@ -41,23 +41,20 @@ func (self *ApiClient) ConfigurationVariableCreate(name string, value string, is
 	}
 	var result []ConfigurationVariable
 	request := map[string]interface{}{
-		"name":           name,
-		"description":    description,
-		"value":          value,
-		"isSensitive":    isSensitive,
-		"scope":          scope,
-		"type":           type_,
+		"name":           params.Name,
+		"description":    params.Description,
+		"value":          params.Value,
+		"isSensitive":    params.IsSensitive,
+		"scope":          params.Scope,
+		"type":           params.Type,
 		"organizationId": organizationId,
 	}
-	if scope != ScopeGlobal {
-		request["scopeId"] = scopeId
-	}
-	if enumValues != nil {
-		request["schema"] = map[string]interface{}{
-			"type": "string",
-			"enum": enumValues,
-		}
+	if params.Scope != ScopeGlobal {
+		request["scopeId"] = params.ScopeId
 	}
+
+	request["schema"] = getSchema(params)
+
 	requestInArray := []map[string]interface{}{request}
 	err = self.http.Post("configuration", requestInArray, &result)
 	if err != nil {
@@ -66,12 +63,26 @@ func (self *ApiClient) ConfigurationVariableCreate(name string, value string, is
 	return result[0], nil
 }
 
+func getSchema(params ConfigurationVariableCreateParams) map[string]interface{} {
+	schema := map[string]interface{}{
+		"type": "string",
+	}
+	if params.EnumValues != nil {
+		schema["enum"] = params.EnumValues
+	}
+	if params.Format != Text {
+		schema["format"] = params.Format
+	}
+	return schema
+}
+
 func (self *ApiClient) ConfigurationVariableDelete(id string) error {
 	return self.http.Delete("configuration/" + id)
 }
 
-func (self *ApiClient) ConfigurationVariableUpdate(id string, name string, value string, isSensitive bool, scope Scope, scopeId string, type_ ConfigurationVariableType, enumValues []string, description string) (ConfigurationVariable, error) {
-	if scope == ScopeDeploymentLog || scope == ScopeDeployment {
+func (self *ApiClient) ConfigurationVariableUpdate(updateParams ConfigurationVariableUpdateParams) (ConfigurationVariable, error) {
+	commonParams := updateParams.CommonParams
+	if commonParams.Scope == ScopeDeploymentLog || commonParams.Scope == ScopeDeployment {
 		return ConfigurationVariable{}, errors.New("Must not create variable on scope deployment / deploymentLog")
 	}
 	organizationId, err := self.organizationId()
@@ -80,24 +91,21 @@ func (self *ApiClient) ConfigurationVariableUpdate(id string, name string, value
 	}
 	var result []ConfigurationVariable
 	request := map[string]interface{}{
-		"id":             id,
-		"name":           name,
-		"description":    description,
-		"value":          value,
-		"isSensitive":    isSensitive,
-		"scope":          scope,
-		"type":           type_,
+		"id":             updateParams.Id,
+		"name":           commonParams.Name,
+		"description":    commonParams.Description,
+		"value":          commonParams.Value,
+		"isSensitive":    commonParams.IsSensitive,
+		"scope":          commonParams.Scope,
+		"type":           commonParams.Type,
 		"organizationId": organizationId,
 	}
-	if scope != ScopeGlobal {
-		request["scopeId"] = scopeId
-	}
-	if enumValues != nil {
-		request["schema"] = map[string]interface{}{
-			"type": "string",
-			"enum": enumValues,
-		}
+	if commonParams.Scope != ScopeGlobal {
+		request["scopeId"] = commonParams.ScopeId
 	}
+
+	request["schema"] = getSchema(updateParams.CommonParams)
+
 	requestInArray := []map[string]interface{}{request}
 	err = self.http.Post("/configuration", requestInArray, &result)
 	if err != nil {

client/configuration_variable_test.go

@@ -11,6 +11,10 @@ import (
 var _ = Describe("Configuration Variable", func() {
 	isSensitive := true
 	varType := ConfigurationVariableTypeEnvironment
+	schema := ConfigurationVariableSchema{
+		Type:   "string",
+		Format: Hcl,
+	}
 	mockConfigurationVariable := ConfigurationVariable{
 		Id:             "config-var-id-789",
 		Name:           "configName",
@@ -22,6 +26,7 @@ var _ = Describe("Configuration Variable", func() {
 		Type:           &varType,
 		ScopeId:        "project-123",
 		UserId:         "user|123",
+		Schema:         &schema,
 	}
 
 	Describe("ConfigurationVariableCreate", func() {
@@ -39,6 +44,10 @@ var _ = Describe("Configuration Variable", func() {
 				"scopeId":        mockConfigurationVariable.ScopeId,
 				"scope":          mockConfigurationVariable.Scope,
 				"type":           *mockConfigurationVariable.Type,
+				"schema": map[string]interface{}{
+					"type":   mockConfigurationVariable.Schema.Type,
+					"format": mockConfigurationVariable.Schema.Format,
+				},
 			}}
 
 			httpCall = mockHttpClient.EXPECT().
@@ -48,14 +57,17 @@ var _ = Describe("Configuration Variable", func() {
 				})
 
 			createdConfigurationVariable, _ = apiClient.ConfigurationVariableCreate(
-				mockConfigurationVariable.Name,
-				mockConfigurationVariable.Value,
-				*mockConfigurationVariable.IsSensitive,
-				mockConfigurationVariable.Scope,
-				mockConfigurationVariable.ScopeId,
-				*mockConfigurationVariable.Type,
-				nil,
-				mockConfigurationVariable.Description,
+				ConfigurationVariableCreateParams{
+					Name:        mockConfigurationVariable.Name,
+					Value:       mockConfigurationVariable.Value,
+					Description: mockConfigurationVariable.Description,
+					IsSensitive: *mockConfigurationVariable.IsSensitive,
+					Scope:       mockConfigurationVariable.Scope,
+					ScopeId:     mockConfigurationVariable.ScopeId,
+					Type:        *mockConfigurationVariable.Type,
+					EnumValues:  nil,
+					Format:      mockConfigurationVariable.Schema.Format,
+				},
 			)
 		})
 
@@ -103,6 +115,9 @@ var _ = Describe("Configuration Variable", func() {
 				"scopeId":        mockConfigurationVariable.ScopeId,
 				"scope":          mockConfigurationVariable.Scope,
 				"type":           *mockConfigurationVariable.Type,
+				"schema": map[string]interface{}{
+					"type": mockConfigurationVariable.Schema.Type,
+				},
 			}}
 
 			httpCall = mockHttpClient.EXPECT().
@@ -112,15 +127,19 @@ var _ = Describe("Configuration Variable", func() {
 				})
 
 			updatedConfigurationVariable, _ = apiClient.ConfigurationVariableUpdate(
-				mockConfigurationVariable.Id,
-				newName,
-				newValue,
-				*mockConfigurationVariable.IsSensitive,
-				mockConfigurationVariable.Scope,
-				mockConfigurationVariable.ScopeId,
-				*mockConfigurationVariable.Type,
-				nil,
-				newDescription,
+				ConfigurationVariableUpdateParams{
+					Id: mockConfigurationVariable.Id,
+					CommonParams: ConfigurationVariableCreateParams{
+						Name:        newName,
+						Value:       newValue,
+						Description: newDescription,
+						IsSensitive: *mockConfigurationVariable.IsSensitive,
+						Scope:       mockConfigurationVariable.Scope,
+						ScopeId:     mockConfigurationVariable.ScopeId,
+						Type:        *mockConfigurationVariable.Type,
+						EnumValues:  nil,
+					},
+				},
 			)
 		})
 

client/model.go

@@ -98,8 +98,9 @@ type EnvironmentDeployResponse struct {
 }
 
 type ConfigurationVariableSchema struct {
-	Type string   `json:"type"`
-	Enum []string `json:"enum"`
+	Type   string   `json:"type"`
+	Enum   []string `json:"enum"`
+	Format Format   `json:"format,omitempty"`
 }
 
 type ConfigurationVariable struct {
@@ -117,6 +118,30 @@ type ConfigurationVariable struct {
 	ToDelete       *bool                        `json:"toDelete,omitempty"`
 }
 
+type ConfigurationVariableCreateParams struct {
+	Name        string
+	Value       string
+	IsSensitive bool
+	Scope       Scope
+	ScopeId     string
+	Type        ConfigurationVariableType
+	EnumValues  []string
+	Description string
+	Format      Format
+}
+
+type ConfigurationVariableUpdateParams struct {
+	CommonParams ConfigurationVariableCreateParams
+	Id           string
+}
+
+type Format string
+
+const (
+	Text Format = ""
+	Hcl  Format = "HCL"
+)
+
 type Scope string
 
 const (

env0/data_configuration_variable.go

@@ -92,6 +92,12 @@ func dataConfigurationVariable() *schema.Resource {
 					Description: "the configuration variable option",
 				},
 			},
+			"hcl": {
+				Type:        schema.TypeBool,
+				Description: "set to true if the value is in HCL format",
+				Default:     false,
+				Optional:    true,
+			},
 		},
 	}
 }
@@ -127,6 +133,9 @@ func dataConfigurationVariableRead(ctx context.Context, d *schema.ResourceData,
 	d.Set("is_sensitive", variable.IsSensitive)
 	d.Set("scope", variable.Scope)
 	d.Set("enum", variable.Schema.Enum)
+	if variable.Schema.Format == client.Hcl {
+		d.Set("hcl", true)
+	}
 	if *variable.Type == client.ConfigurationVariableTypeEnvironment {
 		d.Set("type", "environment")
 	} else if *variable.Type == client.ConfigurationVariableTypeTerraform {

env0/data_configuration_variable_test.go

@@ -27,7 +27,7 @@ func TestUnitConfigurationVariableData(t *testing.T) {
 		IsSensitive:    &isSensitive,
 		Scope:          client.ScopeEnvironment,
 		Type:           &variableType,
-		Schema:         &client.ConfigurationVariableSchema{Type: "string"},
+		Schema:         &client.ConfigurationVariableSchema{Type: "string", Format: client.Hcl},
 	}
 
 	checkResources := resource.ComposeAggregateTestCheckFunc(
@@ -38,6 +38,7 @@ func TestUnitConfigurationVariableData(t *testing.T) {
 		resource.TestCheckResourceAttr(accessor, "value", configurationVariable.Value),
 		resource.TestCheckResourceAttr(accessor, "scope", string(configurationVariable.Scope)),
 		resource.TestCheckResourceAttr(accessor, "is_sensitive", strconv.FormatBool(*configurationVariable.IsSensitive)),
+		resource.TestCheckResourceAttr(accessor, "hcl", strconv.FormatBool(configurationVariable.Schema.Format == client.Hcl)),
 	)
 
 	t.Run("ScopeGlobal", func(t *testing.T) {