Add conditional mode to ReferenceExpression with polyglot codegen support

src/Aspire.Hosting.Azure.AppContainers/BaseContainerAppContext.cs

@@ -25,7 +25,7 @@ internal abstract class BaseContainerAppContext(IResource resource, ContainerApp
     /// </summary>
     public string NormalizedContainerAppName => resource.Name.ToLowerInvariant();
 
-    protected record struct EndpointMapping(string Scheme, string Host, int Port, int? TargetPort, bool IsHttpIngress, bool External);
+    protected record struct EndpointMapping(string Scheme, string Host, int Port, int? TargetPort, bool IsHttpIngress, bool External, bool TlsEnabled);
     protected readonly Dictionary<string, EndpointMapping> _endpointMapping = [];
 
     // Resolved environment variables and command line args
@@ -186,7 +186,7 @@ private void ProcessVolumes()
 
     private BicepValue<string> GetEndpointValue(EndpointMapping mapping, EndpointProperty property)
     {
-        var (scheme, host, port, targetPort, isHttpIngress, external) = mapping;
+        var (scheme, host, port, targetPort, isHttpIngress, external, tlsEnabled) = mapping;
 
         BicepValue<string> GetHostValue(string? prefix = null, string? suffix = null)
         {
@@ -208,6 +208,7 @@ BicepValue<string> GetHostValue(string? prefix = null, string? suffix = null)
             EndpointProperty.HostAndPort => GetHostValue(suffix: $":{port}"),
             EndpointProperty.TargetPort => targetPort is null ? AllocateContainerPortParameter() : $"{targetPort}",
             EndpointProperty.Scheme => scheme,
+            EndpointProperty.TlsEnabled => tlsEnabled ? bool.TrueString : bool.FalseString,
             _ => throw new NotSupportedException(),
         };
     }
@@ -286,6 +287,43 @@ BicepValue<string> GetHostValue(string? prefix = null, string? suffix = null)
 
         if (value is ReferenceExpression expr)
         {
+            // Handle conditional expressions
+            if (expr.IsConditional)
+            {
+                var (conditionVal, _) = ProcessValue(expr.Condition!, secretType, parent: expr);
+
+                // If the condition resolves to a static string, evaluate at publish time
+                string? staticCondition = conditionVal is string str ? str : null;
+                if (staticCondition is null && conditionVal is BicepValue<string> bv
+                    && bv.Compile() is StringLiteralExpression sle)
+                {
+                    staticCondition = sle.Value;
+                }
+
+                if (staticCondition is not null)
+                {
+                    var branch = string.Equals(staticCondition, expr.MatchValue, StringComparison.OrdinalIgnoreCase)
+                        ? expr.WhenTrue!
+                        : expr.WhenFalse!;
+                    return ProcessValue(branch, secretType, parent: parent);
+                }
+
+                // Condition is a Bicep parameter/output — emit a ternary expression
+                var (whenTrueVal, trueSecret) = ProcessValue(expr.WhenTrue!, secretType, parent: expr);
+                var (whenFalseVal, falseSecret) = ProcessValue(expr.WhenFalse!, secretType, parent: expr);
+
+                var conditional = new ConditionalExpression(
+                    new BinaryExpression(BicepFunction.ToLower(ResolveValue(conditionVal).Compile()).Compile(), BinaryBicepOperator.Equal, new StringLiteralExpression((expr.MatchValue ?? string.Empty).ToLowerInvariant())),
+                    ResolveValue(whenTrueVal).Compile(),
+                    ResolveValue(whenFalseVal).Compile());
+
+                var finalSecret = trueSecret != SecretType.None || falseSecret != SecretType.None
+                    ? SecretType.Normal
+                    : SecretType.None;
+
+                return (new BicepValue<string>(conditional), finalSecret);
+            }
+
             // Special case simple expressions
             if (expr.Format == "{0}" && expr.ValueProviders.Count == 1)
             {

src/Aspire.Hosting.Azure.AppContainers/ContainerAppContext.cs

@@ -145,12 +145,13 @@ protected override void ProcessEndpoints()
             return;
         }
 
-        // Only http, https, and tcp are supported
-        var unsupportedEndpoints = resolvedEndpoints.Where(r => r.Endpoint.UriScheme is not ("tcp" or "http" or "https")).ToArray();
+        // Validate transport layer: only http-based and tcp transports are supported by Container Apps.
+        // The URI scheme (e.g. "redis", "rediss", "foo") is independent of transport.
+        var unsupportedEndpoints = resolvedEndpoints.Where(r => r.Endpoint.Transport is not ("http" or "http2" or "tcp")).ToArray();
 
         if (unsupportedEndpoints.Length > 0)
         {
-            throw new NotSupportedException($"The endpoint(s) {string.Join(", ", unsupportedEndpoints.Select(r => $"'{r.Endpoint.Name}'"))} specify an unsupported scheme. The supported schemes are 'http', 'https', and 'tcp'.");
+            throw new NotSupportedException($"The endpoint(s) {string.Join(", ", unsupportedEndpoints.Select(r => $"'{r.Endpoint.Name}'"))} specify an unsupported transport. The supported transports are 'http', 'http2', and 'tcp'.");
         }
 
         // Group resolved endpoints by target port (aka destinations), this gives us the logical bindings or destinations
@@ -162,9 +163,9 @@ protected override void ProcessEndpoints()
                 Port = g.Key,
                 ResolvedEndpoints = g.Select(x => x.resolved).ToArray(),
                 External = g.Any(x => x.resolved.Endpoint.IsExternal),
-                IsHttpOnly = g.All(x => x.resolved.Endpoint.UriScheme is "http" or "https"),
+                IsHttpOnly = g.All(x => x.resolved.Endpoint.Transport is "http" or "http2"),
                 AnyH2 = g.Any(x => x.resolved.Endpoint.Transport is "http2"),
-                UniqueSchemes = g.Select(x => x.resolved.Endpoint.UriScheme).Distinct().ToArray(),
+                UniqueTransports = g.Select(x => x.resolved.Endpoint.Transport).Distinct().ToArray(),
                 Index = g.Min(x => x.index)
             })
             .ToList();
@@ -183,12 +184,11 @@ protected override void ProcessEndpoints()
             throw new NotSupportedException("External non-HTTP(s) endpoints are not supported");
         }
 
-        // Don't allow mixing http and tcp endpoints
-        // This means we want to fail if we see a group with http/https and tcp endpoints
-        static bool Compatible(string[] schemes) =>
-            schemes.All(s => s is "http" or "https") || schemes.All(s => s is "tcp");
+        // Don't allow mixing http and tcp transports on the same target port
+        static bool Compatible(string[] transports) =>
+            transports.All(t => t is "http" or "http2") || transports.All(t => t is "tcp");
 
-        if (endpointsByTargetPort.Any(g => !Compatible(g.UniqueSchemes)))
+        if (endpointsByTargetPort.Any(g => !Compatible(g.UniqueTransports)))
         {
             throw new NotSupportedException("HTTP(s) and TCP endpoints cannot be mixed");
         }
@@ -233,7 +233,7 @@ static bool Compatible(string[] schemes) =>
                 var scheme = preserveHttp ? endpoint.UriScheme : "https";
                 var port = scheme is "http" ? 80 : 443;
 
-                _endpointMapping[endpoint.Name] = new(scheme, NormalizedContainerAppName, port, targetPort, true, httpIngress.External);
+                _endpointMapping[endpoint.Name] = new(scheme, NormalizedContainerAppName, port, targetPort, true, httpIngress.External, endpoint.TlsEnabled);
             }
 
             // Record HTTP endpoints being upgraded (logged once at environment level)
@@ -265,7 +265,7 @@ static bool Compatible(string[] schemes) =>
             foreach (var resolved in g.ResolvedEndpoints)
             {
                 var endpoint = resolved.Endpoint;
-                _endpointMapping[endpoint.Name] = new(endpoint.UriScheme, NormalizedContainerAppName, resolved.ExposedPort.Value ?? g.Port.Value, g.Port.Value, false, g.External);
+                _endpointMapping[endpoint.Name] = new(endpoint.UriScheme, NormalizedContainerAppName, resolved.ExposedPort.Value ?? g.Port.Value, g.Port.Value, false, g.External, endpoint.TlsEnabled);
             }
         }
     }

src/Aspire.Hosting.Azure.AppService/AzureAppServiceWebsiteContext.cs

@@ -196,6 +196,43 @@ private void ProcessEndpoints()
 
         if (value is ReferenceExpression expr)
         {
+            // Handle conditional expressions
+            if (expr.IsConditional)
+            {
+                var (conditionVal, _) = ProcessValue(expr.Condition!, secretType, parent: expr, isSlot);
+
+                // If the condition resolves to a static string, evaluate at publish time
+                string? staticCondition = conditionVal is string str ? str : null;
+                if (staticCondition is null && conditionVal is BicepValue<string> bv
+                    && bv.Compile() is StringLiteralExpression sle)
+                {
+                    staticCondition = sle.Value;
+                }
+
+                if (staticCondition is not null)
+                {
+                    var branch = string.Equals(staticCondition, expr.MatchValue, StringComparison.OrdinalIgnoreCase)
+                        ? expr.WhenTrue!
+                        : expr.WhenFalse!;
+                    return ProcessValue(branch, secretType, parent: parent, isSlot);
+                }
+
+                // Condition is a Bicep parameter/output — emit a ternary expression
+                var (whenTrueVal, trueSecret) = ProcessValue(expr.WhenTrue!, secretType, parent: expr, isSlot);
+                var (whenFalseVal, falseSecret) = ProcessValue(expr.WhenFalse!, secretType, parent: expr, isSlot);
+
+                var conditional = new ConditionalExpression(
+                    new BinaryExpression(BicepFunction.ToLower(ResolveValue(conditionVal).Compile()).Compile(), BinaryBicepOperator.Equal, new StringLiteralExpression((expr.MatchValue ?? string.Empty).ToLowerInvariant())),
+                    ResolveValue(whenTrueVal).Compile(),
+                    ResolveValue(whenFalseVal).Compile());
+
+                var finalSecret = trueSecret != SecretType.None || falseSecret != SecretType.None
+                    ? SecretType.Normal
+                    : SecretType.None;
+
+                return (new BicepValue<string>(conditional), finalSecret);
+            }
+
             if (expr.Format == "{0}" && expr.ValueProviders.Count == 1)
             {
                 var val = ProcessValue(expr.ValueProviders[0], secretType, parent: parent, isSlot);

src/Aspire.Hosting.Azure/AzurePublishingContext.cs

@@ -200,12 +200,38 @@ FormattableString EvalExpr(ReferenceExpression expr)
             return FormattableStringFactory.Create(expr.Format, args);
         }
 
+        object EvalConditionalExpr(ReferenceExpression expr)
+        {
+            var conditionVal = Eval(expr.Condition!);
+
+            // If the condition resolves to a static string, evaluate at publish time
+            if (conditionVal is string staticCondition)
+            {
+                var branch = string.Equals(staticCondition, expr.MatchValue, StringComparison.OrdinalIgnoreCase)
+                    ? expr.WhenTrue!
+                    : expr.WhenFalse!;
+                return Eval(branch);
+            }
+
+            // Condition is a Bicep parameter/output — emit a ternary expression
+            var whenTrueVal = ResolveValue(Eval(expr.WhenTrue!));
+            var whenFalseVal = ResolveValue(Eval(expr.WhenFalse!));
+
+            var conditional = new ConditionalExpression(
+                new BinaryExpression(ResolveValue(conditionVal).Compile(), BinaryBicepOperator.Equal, new StringLiteralExpression(expr.MatchValue!)),
+                whenTrueVal.Compile(),
+                whenFalseVal.Compile());
+
+            return new BicepValue<string>(conditional);
+        }
+
         object Eval(object? value) => value switch
         {
             BicepOutputReference b => GetOutputs(moduleMap[b.Resource], b.Name),
             ParameterResource p => ParameterLookup[p],
             ConnectionStringReference r => Eval(r.Resource.ConnectionStringExpression),
             IResourceWithConnectionString cs => Eval(cs.ConnectionStringExpression),
+            ReferenceExpression { IsConditional: true } re => EvalConditionalExpr(re),
             ReferenceExpression re => EvalExpr(re),
             string s => s,
             _ => ""

src/Aspire.Hosting.CodeGeneration.Go/Resources/base.go

@@ -37,25 +37,57 @@ func NewResourceBuilderBase(handle *Handle, client *AspireClient) ResourceBuilde
 }
 
 // ReferenceExpression represents a reference expression.
+// Supports value mode (Format + Args) and conditional mode (Condition + WhenTrue + WhenFalse).
 type ReferenceExpression struct {
 	Format string
 	Args   []any
+
+	// Conditional mode fields
+	Condition     any
+	WhenTrue      *ReferenceExpression
+	WhenFalse     *ReferenceExpression
+	MatchValue    string
+	isConditional bool
 }
 
-// NewReferenceExpression creates a new reference expression.
+// NewReferenceExpression creates a new reference expression in value mode.
 func NewReferenceExpression(format string, args ...any) *ReferenceExpression {
 	return &ReferenceExpression{Format: format, Args: args}
 }
 
+// NewConditionalReferenceExpression creates a conditional reference expression from its parts.
+func NewConditionalReferenceExpression(condition any, matchValue string, whenTrue *ReferenceExpression, whenFalse *ReferenceExpression) *ReferenceExpression {
+	if matchValue == "" {
+		matchValue = "True"
+	}
+	return &ReferenceExpression{
+		Condition:     condition,
+		WhenTrue:      whenTrue,
+		WhenFalse:     whenFalse,
+		MatchValue:    matchValue,
+		isConditional: true,
+	}
+}
+
 // RefExpr is a convenience function for creating reference expressions.
 func RefExpr(format string, args ...any) *ReferenceExpression {
 	return NewReferenceExpression(format, args...)
 }
 
 // ToJSON returns the reference expression as a JSON-serializable map.
 func (r *ReferenceExpression) ToJSON() map[string]any {
+	if r.isConditional {
+		return map[string]any{
+			"$expr": map[string]any{
+				"condition":  SerializeValue(r.Condition),
+				"whenTrue":   r.WhenTrue.ToJSON(),
+				"whenFalse":  r.WhenFalse.ToJSON(),
+				"matchValue": r.MatchValue,
+			},
+		}
+	}
 	return map[string]any{
-		"$refExpr": map[string]any{
+		"$expr": map[string]any{
 			"format": r.Format,
 			"args":   r.Args,
 		},

src/Aspire.Hosting.CodeGeneration.Java/Resources/Base.java

@@ -37,14 +37,40 @@ class ResourceBuilderBase extends HandleWrapperBase {
 
 /**
  * ReferenceExpression represents a reference expression.
+ * Supports value mode (format + args) and conditional mode (condition + whenTrue + whenFalse).
  */
 class ReferenceExpression {
+    // Value mode fields
     private final String format;
     private final Object[] args;
 
+    // Conditional mode fields
+    private final Object condition;
+    private final ReferenceExpression whenTrue;
+    private final ReferenceExpression whenFalse;
+    private final String matchValue;
+    private final boolean isConditional;
+
+    // Value mode constructor
     ReferenceExpression(String format, Object... args) {
         this.format = format;
         this.args = args;
+        this.condition = null;
+        this.whenTrue = null;
+        this.whenFalse = null;
+        this.matchValue = null;
+        this.isConditional = false;
+    }
+
+    // Conditional mode constructor
+    private ReferenceExpression(Object condition, String matchValue, ReferenceExpression whenTrue, ReferenceExpression whenFalse) {
+        this.condition = condition;
+        this.whenTrue = whenTrue;
+        this.whenFalse = whenFalse;
+        this.matchValue = matchValue != null ? matchValue : "True";
+        this.isConditional = true;
+        this.format = null;
+        this.args = null;
     }
 
     String getFormat() {
@@ -56,6 +82,18 @@ Object[] getArgs() {
     }
 
     Map<String, Object> toJson() {
+        if (isConditional) {
+            var condPayload = new java.util.HashMap<String, Object>();
+            condPayload.put("condition", AspireClient.serializeValue(condition));
+            condPayload.put("whenTrue", whenTrue.toJson());
+            condPayload.put("whenFalse", whenFalse.toJson());
+            condPayload.put("matchValue", matchValue);
+
+            var result = new java.util.HashMap<String, Object>();
+            result.put("$refExpr", condPayload);
+            return result;
+        }
+
         Map<String, Object> refExpr = new HashMap<>();
         refExpr.put("format", format);
         refExpr.put("args", Arrays.asList(args));
@@ -71,6 +109,13 @@ Map<String, Object> toJson() {
     static ReferenceExpression refExpr(String format, Object... args) {
         return new ReferenceExpression(format, args);
     }
+
+    /**
+     * Creates a conditional reference expression from its parts.
+     */
+    static ReferenceExpression createConditional(Object condition, String matchValue, ReferenceExpression whenTrue, ReferenceExpression whenFalse) {
+        return new ReferenceExpression(condition, matchValue, whenTrue, whenFalse);
+    }
 }
 
 /**