Treat object parameters as objects in templating

CONTRIBUTORS.md

@@ -101,5 +101,6 @@ and we will add you. **All** contributors belong here. 💯
 - [guangwu guo](https://github.com/testwill)
 - [Eric Herrmann](https://github.com/egherrmann)
 - [Alex Dejanu](https://github.com/dejanu)
+- [Leo Bergnéhr](https://github.com/lbergnehr)
 
 

pkg/runtime/runtime_manifest.go

@@ -6,6 +6,7 @@ import (
 	"compress/gzip"
 	"context"
 	"encoding/base64"
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
@@ -131,15 +132,40 @@ func (m *RuntimeManifest) loadDependencyDefinitions() error {
 	return nil
 }
 
-func (m *RuntimeManifest) resolveParameter(pd manifest.ParameterDefinition) string {
+// This wrapper type serve as a way of formatting a `map[string]interface{}` as
+// JSON when the templating by mustache is done. It makes it possible to
+// maintain the JSON string representation of the map while still allowing the
+// map to be used as a context in the templating, allowing for accessing the
+// map's keys in the template.
+type FormattedObject map[string]interface{}
+
+// Format the `FormattedObject` as a JSON string.
+func (fo FormattedObject) Format(f fmt.State, c rune) {
+	jsonStr, _ := json.Marshal(fo)
+	fmt.Fprintf(f, string(jsonStr))
+}
+
+func (m *RuntimeManifest) resolveParameter(pd manifest.ParameterDefinition) (interface{}, error) {
+	getValue := func(envVar string) (interface{}, error) {
+		value := m.config.Getenv(envVar)
+		if pd.Type == "object" {
+			var obj map[string]interface{}
+			if err := json.Unmarshal([]byte(value), &obj); err != nil {
+				return nil, err
+			}
+			return FormattedObject(obj), nil
+		}
+		return value, nil
+	}
+
 	if pd.Destination.EnvironmentVariable != "" {
-		return m.config.Getenv(pd.Destination.EnvironmentVariable)
+		return getValue(pd.Destination.EnvironmentVariable)
 	}
 	if pd.Destination.Path != "" {
-		return pd.Destination.Path
+		return pd.Destination.Path, nil
 	}
 	envVar := manifest.ParamToEnvVar(pd.Name)
-	return m.config.Getenv(envVar)
+	return getValue(envVar)
 }
 
 func (m *RuntimeManifest) resolveCredential(cd manifest.CredentialDefinition) (string, error) {
@@ -271,9 +297,12 @@ func (m *RuntimeManifest) buildSourceData() (map[string]interface{}, error) {
 		}
 
 		pe := param.Name
-		val := m.resolveParameter(param)
+		val, err := m.resolveParameter(param)
+		if err != nil {
+			return nil, err
+		}
 		if param.Sensitive {
-			m.setSensitiveValue(val)
+			m.setSensitiveValue(val.(string))
 		}
 		params[pe] = val
 	}

pkg/runtime/runtime_manifest_test.go

@@ -34,17 +34,22 @@ func TestResolveMapParam(t *testing.T) {
 	ctx := context.Background()
 	testConfig := config.NewTestConfig(t)
 	testConfig.Setenv("PERSON", "Ralpha")
+	testConfig.Setenv("CONTACT", "{ \"name\": \"Breta\" }")
 
 	mContent := `schemaVersion: 1.0.0-alpha.2
 parameters:
 - name: person
 - name: place
   applyTo: [install]
+- name: contact
+  type: object
 
 install:
 - mymixin:
     Parameters:
       Thing: ${ bundle.parameters.person }
+      ObjectName: ${ bundle.parameters.contact.name }
+      Object: '${ bundle.parameters.contact }'
 `
 	rm := runtimeManifestFromStepYaml(t, testConfig, mContent)
 	s := rm.Install[0]
@@ -62,6 +67,19 @@ install:
 	assert.Equal(t, "Ralpha", val)
 	assert.NotContains(t, "place", pms, "parameters that don't apply to the current action should not be resolved")
 
+	// Asserting `bundle.parameters.contact.name` works.
+	require.IsType(t, "string", pms["ObjectName"], "Data.mymixin.Parameters.ObjectName has incorrect type")
+	contactName := pms["ObjectName"].(string)
+	require.IsType(t, "string", contactName, "Data.mymixin.Parameters.ObjectName.name has incorrect type")
+	assert.Equal(t, "Breta", contactName)
+
+	// Asserting `bundle.parameters.contact` evaluates to the JSON string
+	// representation of the object.
+	require.IsType(t, "string", pms["Object"], "Data.mymixin.Parameters.Object has incorrect type")
+	contact := pms["Object"].(string)
+	require.IsType(t, "string", contact, "Data.mymixin.Parameters.Object has incorrect type")
+	assert.Equal(t, "{\"name\":\"Breta\"}", contact)
+
 	err = rm.Initialize(ctx)
 	require.NoError(t, err)
 }