fix: include operator-configured parameter values in recipe metadata (#11680)

## Description

Fixes: #9454

`rad recipe show` does not display the parameter values that operators
configure on an environment recipe. The server returns only the template
schema from the registry (type, defaultValue, min, max) and silently
drops the configured values before sending the response to the CLI.

## Changes

**Server
(`pkg/corerp/frontend/controller/environments/getrecipemetadata.go`)**

After retrieving the template schema from the registry, overlay
`recipeProperties.Parameters` (the operator-configured values) onto the
schema under a `"value"` key. Parameters that are configured but absent
from the template schema are skipped — the response remains a faithful
view of the recipe template.

**CLI (`pkg/cli/cmd/recipe/`)**

- Add `Value` field to `RecipeParameter` type (`types.go`)
- Handle the `"value"` key in the `rad recipe show` parameter loop
(`show/show.go`)
- Add a `VALUE` column to the parameters table between `DEFAULT VALUE`
and `MIN` (`common/objectformats.go`)

## Type of change

- [x] Bug fix

## How Has This Been Tested?

- Added
`TestGetRecipeMetadataFromRegistry_ConfiguredParameterValuesAppearedInResponse`
to `getrecipemetadata_test.go` — a regression test that verifies
configured values are merged into the schema response.
- Added `"Show recipe with operator-configured parameter value -
Success"` test case to `show_test.go` — verifies the CLI populates the
`Value` field when the server returns a `"value"` key.
- Updated existing test cases in `show_test.go` and
`objectformats_test.go` to reflect the new `VALUE` column and the
`Value: "-"` default initialization.
- `golangci-lint run` on modified packages: 0 issues.

## Checklist

- [x] I have followed the [contributing
guidelines](https://github.com/radius-project/radius/blob/main/CONTRIBUTING.md)
- [x] I have updated or added tests
- [x] I have updated documentation as needed

Signed-off-by: Seth Ficke <19766129+sethficke@users.noreply.github.com>
Co-authored-by: Nicole James <101607760+nicolejms@users.noreply.github.com>
Co-authored-by: Nithya Subramanian <98416062+nithyatsu@users.noreply.github.com>

Author: 3 people

pkg/cli/cmd/recipe/common/objectformats.go

@@ -66,6 +66,10 @@ func RecipeParametersFormat() output.FormatterOptions {
 				Heading:  "DEFAULT VALUE",
 				JSONPath: "{ .DefaultValue }",
 			},
+			{
+				Heading:  "VALUE",
+				JSONPath: "{ .Value }",
+			},
 			{
 				Heading:  "MIN",
 				JSONPath: "{ .MinValue }",

pkg/cli/cmd/recipe/common/objectformats_test.go

@@ -55,6 +55,6 @@ func Test_RecipeParametersFormat(t *testing.T) {
 	err := output.Write(output.FormatTable, obj, buffer, RecipeParametersFormat())
 	require.NoError(t, err)
 
-	expected := "PARAMETER  TYPE       DEFAULT VALUE  MIN       MAX\ntest       test-type  1              4         3\n"
+	expected := "PARAMETER  TYPE       DEFAULT VALUE  VALUE     MIN       MAX\ntest       test-type  1              null      4         3\n"
 	require.Equal(t, expected, buffer.String())
 }

pkg/cli/cmd/recipe/show/show.go

@@ -186,6 +186,7 @@ func (r *Runner) Run(ctx context.Context) error {
 		paramItem := types.RecipeParameter{
 			Name:         parameter,
 			DefaultValue: "-",
+			Value:        "-",
 			MaxValue:     "-",
 			MinValue:     "-",
 		}
@@ -196,6 +197,8 @@ func (r *Runner) Run(ctx context.Context) error {
 				paramItem.Type = paramDetailValue.(string)
 			case "defaultValue":
 				paramItem.DefaultValue = paramDetailValue
+			case "value":
+				paramItem.Value = paramDetailValue
 			case "maxValue":
 				paramItem.MaxValue = fmt.Sprintf("%v", paramDetailValue.(float64))
 			case "minValue":

pkg/cli/cmd/recipe/show/show_test.go

@@ -119,13 +119,15 @@ func Test_Run(t *testing.T) {
 			{
 				Name:         "throughput",
 				Type:         "float64",
+				Value:        "-",
 				MaxValue:     "800",
 				MinValue:     "-",
 				DefaultValue: "-",
 			},
 			{
 				Name:         "sku",
 				Type:         "string",
+				Value:        "-",
 				MaxValue:     "-",
 				MinValue:     "-",
 				DefaultValue: "-",
@@ -196,13 +198,15 @@ func Test_Run(t *testing.T) {
 			{
 				Name:         "throughput",
 				Type:         "float64",
+				Value:        "-",
 				MaxValue:     "800",
 				MinValue:     "-",
 				DefaultValue: "-",
 			},
 			{
 				Name:         "sku",
 				Type:         "string",
+				Value:        "-",
 				MaxValue:     "-",
 				MinValue:     "-",
 				DefaultValue: "-",
@@ -246,6 +250,75 @@ func Test_Run(t *testing.T) {
 		require.Equal(t, expected, outputSink.Writes)
 	})
 
+	t.Run("Show recipe with operator-configured parameter value - Success", func(t *testing.T) {
+		// Regression test for https://github.com/radius-project/radius/issues/9454
+		// The server merges operator-configured values into the parameters map.
+		// The CLI must surface them in the VALUE column.
+		ctrl := gomock.NewController(t)
+		envRecipe := v20231001preview.RecipeGetMetadataResponse{
+			TemplateKind: to.Ptr(recipes.TemplateKindBicep),
+			TemplatePath: new("ghcr.io/testpublicrecipe/bicep/modules/redis:v1"),
+			Parameters: map[string]any{
+				"location": map[string]any{
+					"type":  "string",
+					"value": "eastus",
+				},
+			},
+		}
+		recipe := types.EnvironmentRecipe{
+			Name:         "redis-prod",
+			ResourceType: datastoresrp.RedisCachesResourceType,
+			TemplateKind: recipes.TemplateKindBicep,
+			TemplatePath: "ghcr.io/testpublicrecipe/bicep/modules/redis:v1",
+		}
+		recipeParams := []types.RecipeParameter{
+			{
+				Name:         "location",
+				Type:         "string",
+				Value:        "eastus",
+				MaxValue:     "-",
+				MinValue:     "-",
+				DefaultValue: "-",
+			},
+		}
+
+		appManagementClient := clients.NewMockApplicationsManagementClient(ctrl)
+		appManagementClient.EXPECT().
+			GetRecipeMetadata(gomock.Any(), gomock.Any(), gomock.Any()).
+			Return(envRecipe, nil).Times(1)
+
+		outputSink := &output.MockOutput{}
+
+		runner := &Runner{
+			ConnectionFactory: &connections.MockFactory{ApplicationsManagementClient: appManagementClient},
+			Output:            outputSink,
+			Workspace:         &workspaces.Workspace{},
+			Format:            "table",
+			RecipeName:        "redis-prod",
+			ResourceType:      datastoresrp.RedisCachesResourceType,
+		}
+
+		err := runner.Run(context.Background())
+		require.NoError(t, err)
+
+		expected := []any{
+			output.FormattedOutput{
+				Format:  "table",
+				Obj:     recipe,
+				Options: common.RecipeFormat(),
+			},
+			output.LogOutput{
+				Format: "",
+			},
+			output.FormattedOutput{
+				Format:  "table",
+				Obj:     recipeParams,
+				Options: common.RecipeParametersFormat(),
+			},
+		}
+		require.Equal(t, expected, outputSink.Writes)
+	})
+
 	t.Run("Show terraformn recipe details - Success", func(t *testing.T) {
 		ctrl := gomock.NewController(t)
 		envRecipe := v20231001preview.RecipeGetMetadataResponse{
@@ -273,13 +346,15 @@ func Test_Run(t *testing.T) {
 			{
 				Name:         "throughput",
 				Type:         "float64",
+				Value:        "-",
 				MaxValue:     "800",
 				MinValue:     "-",
 				DefaultValue: "-",
 			},
 			{
 				Name:         "sku",
 				Type:         "string",
+				Value:        "-",
 				MaxValue:     "-",
 				MinValue:     "-",
 				DefaultValue: "-",

pkg/cli/cmd/recipe/types.go

@@ -29,6 +29,7 @@ type RecipeParameter struct {
 	Name         string `json:"name,omitempty"`
 	DefaultValue any    `json:"defaultValue,omitempty"`
 	Type         string `json:"type,omitempty"`
+	Value        any    `json:"value,omitempty"`
 	MaxValue     string `json:"maxValue,omitempty"`
 	MinValue     string `json:"minValue,omitempty"`
 }

pkg/corerp/frontend/controller/environments/getrecipemetadata.go

@@ -132,6 +132,19 @@ func (r *GetRecipeMetadata) GetRecipeMetadataFromRegistry(ctx context.Context, r
 		return recipeParameters, err
 	}
 
+	// Overlay operator-configured parameter values so they appear in the response.
+	// The engine returns the template schema (type, defaultValue, etc.) but not the
+	// values an operator has set on the environment. We merge them here so that
+	// `rad recipe show` can display them.
+	for paramName, configuredValue := range recipeProperties.Parameters {
+		schemaEntry, ok := recipeParameters[paramName].(map[string]any)
+		if !ok {
+			// Parameter is configured but absent from the template schema — skip it.
+			continue
+		}
+		schemaEntry["value"] = configuredValue
+	}
+
 	return recipeParameters, nil
 }
 

pkg/corerp/frontend/controller/environments/getrecipemetadata_test.go

@@ -29,6 +29,7 @@ import (
 	"github.com/radius-project/radius/pkg/armrpc/rpctest"
 	"github.com/radius-project/radius/pkg/components/database"
 	"github.com/radius-project/radius/pkg/corerp/api/v20231001preview"
+	"github.com/radius-project/radius/pkg/corerp/datamodel"
 	"github.com/radius-project/radius/pkg/recipes"
 	"github.com/radius-project/radius/pkg/recipes/engine"
 	"github.com/radius-project/radius/test/testutil"
@@ -274,6 +275,61 @@ func TestGetRecipeMetadataRun_20231001Preview(t *testing.T) {
 	})
 }
 
+func TestGetRecipeMetadataFromRegistry_ConfiguredParameterValuesAppearedInResponse(t *testing.T) {
+	// Regression test for https://github.com/radius-project/radius/issues/9454
+	// Operator-configured parameter values stored in the environment must appear in
+	// the GetRecipeMetadata response so that `rad recipe show` can display them.
+	mctrl := gomock.NewController(t)
+	defer mctrl.Finish()
+	mEngine := engine.NewMockEngine(mctrl)
+
+	recipeProperties := datamodel.EnvironmentRecipeProperties{
+		TemplateKind: "bicep",
+		TemplatePath: "ghcr.io/example/recipes/redis:1.0",
+		Parameters: map[string]any{
+			"location": "eastus",
+		},
+	}
+	recipeDataModel := &datamodel.Recipe{
+		Name:         "redis-prod",
+		ResourceType: "Applications.Datastores/redisCaches",
+	}
+
+	// Engine returns the template schema from the registry — no "value" keys here,
+	// only parameter definitions (type, defaultValue, etc.).
+	recipeData := map[string]any{
+		"parameters": map[string]any{
+			"location": map[string]any{
+				"type": "string",
+			},
+		},
+	}
+	mEngine.EXPECT().
+		GetRecipeMetadata(gomock.Any(), gomock.Any()).
+		Return(recipeData, nil)
+
+	databaseClient := database.NewMockClient(mctrl)
+	opts := ctrl.Options{DatabaseClient: databaseClient}
+	ctl, err := NewGetRecipeMetadata(opts, mEngine)
+	require.NoError(t, err)
+
+	controller := ctl.(*GetRecipeMetadata)
+	result, err := controller.GetRecipeMetadataFromRegistry(
+		context.Background(),
+		recipeProperties,
+		recipeDataModel,
+		"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg/providers/applications.core/environments/env0",
+	)
+	require.NoError(t, err)
+
+	// The operator configured location="eastus". That value must appear in the response
+	// so the CLI can display it. Without the fix, this assertion fails because only
+	// {"type": "string"} is returned — the "value" key is absent.
+	locationParam, ok := result["location"].(map[string]any)
+	require.True(t, ok, "location parameter should be present in response")
+	require.Equal(t, "eastus", locationParam["value"], "operator-configured value should appear in response")
+}
+
 func TestParseAndFormatRecipeParams(t *testing.T) {
 	t.Run("parse and format recipe parameters with context", func(t *testing.T) {
 		recipeData := map[string]any{}