Add option to generate docker compose file with enviroment variables instead of secrets

src/Aspirate.Commands/Actions/Secrets/PopulateInputsAction.cs

@@ -1,5 +1,4 @@
 namespace Aspirate.Commands.Actions.Secrets;
-
 public sealed class PopulateInputsAction(
     IPasswordGenerator passwordGenerator,
     IServiceProvider serviceProvider,

src/Aspirate.Commands/Actions/Secrets/PopulateInputsWithEnvVariablesAction.cs

@@ -0,0 +1,28 @@
+namespace Aspirate.Commands.Actions.Secrets;
+
+public sealed class PopulateInputsWithEnvVariablesAction(IServiceProvider serviceProvider) : BaseAction(serviceProvider)
+{
+    public override Task<bool> ExecuteAsync()
+    {
+        Logger.WriteRuler("[purple]Generating enviroment variable placeholders for inputs[/]");
+
+        var parameterResources = CurrentState.LoadedAspireManifestResources.Where(x => x.Value is ParameterResource).ToArray();
+
+        if (parameterResources.Length == 0)
+        {
+            return Task.FromResult(true);
+        }
+
+        foreach (var parameter in parameterResources)
+        {
+            if (parameter.Value is ParameterResource resource)
+            {
+                resource.Value = $"${{{resource.Name.Replace('-', '_').ToUpperInvariant()}}}";
+            }
+        }
+
+        Logger.MarkupLine($"[green]({EmojiLiterals.CheckMark}) Done: [/] Input values have all been assigned enviroment variables.");
+
+        return Task.FromResult(true);
+    }
+}

src/Aspirate.Commands/Commands/BaseCommand.cs

@@ -40,9 +40,10 @@ private async Task<int> ConstructCommand(TOptions options, IServiceCollection se
         await stateService.RestoreState(stateOptions);
 
         handler.CurrentState.PopulateStateFromOptions(options);
-
-        LoadSecrets(options, secretService, handler);
-
+        if (options.RequiresSecrets)
+        {
+            LoadSecrets(options, secretService, handler);
+        }
         var exitCode = await handler.HandleAsync(options);
 
         await stateService.SaveState(stateOptions);

src/Aspirate.Commands/Commands/BaseCommandOptions.cs

@@ -8,4 +8,5 @@ public abstract class BaseCommandOptions : ICommandOptions
     public bool? DisableState { get; set; }
     public string? SecretPassword { get; set; }
     public string? LaunchProfile { get; set; }
+    public virtual bool RequiresSecrets => true;
 }

src/Aspirate.Commands/Commands/Generate/GenerateCommand.cs

@@ -6,27 +6,28 @@ public sealed class GenerateCommand : BaseCommand<GenerateOptions, GenerateComma
 
     public GenerateCommand() : base("generate", "Builds, pushes containers, generates aspire manifest, helm chart and kustomize manifests.")
     {
-       AddOption(ProjectPathOption.Instance);
-       AddOption(AspireManifestOption.Instance);
-       AddOption(OutputPathOption.Instance);
-       AddOption(SkipBuildOption.Instance);
-       AddOption(SkipFinalKustomizeGenerationOption.Instance);
-       AddOption(ContainerBuilderOption.Instance);
-       AddOption(ContainerImageTagOption.Instance);
-       AddOption(ContainerRegistryOption.Instance);
-       AddOption(ContainerRepositoryPrefixOption.Instance);
-       AddOption(ImagePullPolicyOption.Instance);
-       AddOption(NamespaceOption.Instance);
-       AddOption(OutputFormatOption.Instance);
-       AddOption(RuntimeIdentifierOption.Instance);
-       AddOption(SecretPasswordOption.Instance);
-       AddOption(PrivateRegistryOption.Instance);
-       AddOption(PrivateRegistryUrlOption.Instance);
-       AddOption(PrivateRegistryUsernameOption.Instance);
-       AddOption(PrivateRegistryPasswordOption.Instance);
-       AddOption(PrivateRegistryEmailOption.Instance);
-       AddOption(IncludeDashboardOption.Instance);
-       AddOption(ComposeBuildsOption.Instance);
-       AddOption(ReplaceSecretsOption.Instance);
+        AddOption(ProjectPathOption.Instance);
+        AddOption(AspireManifestOption.Instance);
+        AddOption(OutputPathOption.Instance);
+        AddOption(SkipBuildOption.Instance);
+        AddOption(SkipFinalKustomizeGenerationOption.Instance);
+        AddOption(ContainerBuilderOption.Instance);
+        AddOption(ContainerImageTagOption.Instance);
+        AddOption(ContainerRegistryOption.Instance);
+        AddOption(ContainerRepositoryPrefixOption.Instance);
+        AddOption(ImagePullPolicyOption.Instance);
+        AddOption(NamespaceOption.Instance);
+        AddOption(OutputFormatOption.Instance);
+        AddOption(RuntimeIdentifierOption.Instance);
+        AddOption(SecretPasswordOption.Instance);
+        AddOption(PrivateRegistryOption.Instance);
+        AddOption(PrivateRegistryUrlOption.Instance);
+        AddOption(PrivateRegistryUsernameOption.Instance);
+        AddOption(PrivateRegistryPasswordOption.Instance);
+        AddOption(PrivateRegistryEmailOption.Instance);
+        AddOption(IncludeDashboardOption.Instance);
+        AddOption(ComposeBuildsOption.Instance);
+        AddOption(ReplaceSecretsOption.Instance);
+        AddOption(UseEnvVariablesAsParameterValuesOption.Instance);
     }
 }

src/Aspirate.Commands/Commands/Generate/GenerateCommandHandler.cs

@@ -12,32 +12,47 @@ public override Task<int> HandleAsync(GenerateOptions options)
         return outputFormat.Name switch
         {
             nameof(OutputFormat.Kustomize) => GenerateKustomizeManifests(),
-            nameof(OutputFormat.DockerCompose) => GenerateDockerComposeManifests(),
+            nameof(OutputFormat.DockerCompose) => GenerateDockerComposeManifests(options.UseEnvVariablesAsParameterValues ?? false),
             nameof(OutputFormat.Helm) => GenerateHelmManifests(),
             _ => throw new ArgumentOutOfRangeException(nameof(options.OutputFormat), $"The output format '{options.OutputFormat}' is not supported."),
         };
     }
 
-    private ActionExecutor BaseGenerateActionSequence() =>
-        ActionExecutor
+    private ActionExecutor BaseGenerateActionSequence(bool useEnvVariablesAsParameterValues = false)
+    {
+        var result = ActionExecutor
             .QueueAction(nameof(LoadConfigurationAction))
             .QueueAction(nameof(GenerateAspireManifestAction))
             .QueueAction(nameof(LoadAspireManifestAction))
-            .QueueAction(nameof(IncludeAspireDashboardAction))
-            .QueueAction(nameof(PopulateInputsAction))
+            .QueueAction(nameof(IncludeAspireDashboardAction));
+        if (!useEnvVariablesAsParameterValues)
+        {
+            result.QueueAction(nameof(PopulateInputsAction));
+        }
+        else
+        {
+            result.QueueAction(nameof(PopulateInputsWithEnvVariablesAction));
+        }
+        result
             .QueueAction(nameof(SubstituteValuesAspireManifestAction))
             .QueueAction(nameof(ApplyDaprAnnotationsAction))
             .QueueAction(nameof(PopulateContainerDetailsForProjectsAction))
             .QueueAction(nameof(BuildAndPushContainersFromProjectsAction))
-            .QueueAction(nameof(BuildAndPushContainersFromDockerfilesAction))
-            .QueueAction(nameof(SaveSecretsAction));
+            .QueueAction(nameof(BuildAndPushContainersFromDockerfilesAction));
+        if (!useEnvVariablesAsParameterValues)
+        {
+            result.QueueAction(nameof(SaveSecretsAction));
+        }
+
+        return result;
+    }
 
     private ActionExecutor BaseKubernetesActionSequence() =>
         BaseGenerateActionSequence()
             .QueueAction(nameof(AskImagePullPolicyAction));
 
-    private Task<int> GenerateDockerComposeManifests() =>
-        BaseGenerateActionSequence()
+    private Task<int> GenerateDockerComposeManifests(bool useEnvVariablesAsParameterValues) =>
+        BaseGenerateActionSequence(useEnvVariablesAsParameterValues)
             .QueueAction(nameof(GenerateDockerComposeManifestAction))
             .ExecuteCommandsAsync();
 

src/Aspirate.Commands/Commands/Generate/GenerateOptions.cs

@@ -30,4 +30,7 @@ public sealed class GenerateOptions : BaseCommandOptions,
     public bool? WithPrivateRegistry { get; set; }
     public bool? IncludeDashboard { get; set; }
     public bool? ReplaceSecrets { get; set; }
+    public bool? UseEnvVariablesAsParameterValues { get; set; }
+
+    public override bool RequiresSecrets => (!UseEnvVariablesAsParameterValues) ?? true;
 }

src/Aspirate.Commands/Options/UseEnvVariablesAsParameterValuesOption.cs

@@ -0,0 +1,16 @@
+namespace Aspirate.Commands.Options;
+
+public sealed class UseEnvVariablesAsParameterValuesOption : BaseOption<bool>
+{
+    private static readonly string[] _aliases = ["--use-env-variables-as-parameter-values"];
+
+    private UseEnvVariablesAsParameterValuesOption() : base(_aliases, "ASPIRATE_USE_ENV_VARIABLES", false)
+    {
+        Name = nameof(IGenerateOptions.UseEnvVariablesAsParameterValues);
+        Description = "Replace parameter references with enviroment variable names";
+        Arity = ArgumentArity.ZeroOrOne;
+        IsRequired = false;
+    }
+
+    public static UseEnvVariablesAsParameterValuesOption Instance { get; } = new();
+}

src/Aspirate.Commands/ServiceCollectionExtensions.cs

@@ -1,4 +1,4 @@
-namespace Aspirate.Commands;
+namespace Aspirate.Commands;
 
 /// <summary>
 /// Extension methods for IServiceCollection to register services for AspirateState and AspirateActions.
@@ -39,6 +39,7 @@ public static IServiceCollection AddAspirateActions(this IServiceCollection serv
             .RegisterAction<SubstituteValuesAspireManifestAction>()
             .RegisterAction<ApplyDaprAnnotationsAction>()
             .RegisterAction<PopulateInputsAction>()
+            .RegisterAction<PopulateInputsWithEnvVariablesAction>()
             .RegisterAction<SaveSecretsAction>()
             .RegisterAction<AskPrivateRegistryCredentialsAction>()
             .RegisterAction<IncludeAspireDashboardAction>()

src/Aspirate.Processors/Transformation/Json/JsonExpressionProcessor.cs

@@ -26,7 +26,7 @@ public void ResolveJsonExpressions(JsonNode? jsonNode, JsonNode rootNode)
         } while (_unresolvedExpressionPointers.Count > 0);
     }
 
-    [GeneratedRegex(@"\{([\w\.-]+)\}")]
+    [GeneratedRegex(@"(\$|)\{([\w\.-]+)\}")]
     private static partial Regex PlaceholderPatternRegex();
 
     public static IJsonExpressionProcessor CreateDefaultExpressionProcessor() =>
@@ -103,7 +103,12 @@ private void ReplaceWithResolvedExpression(JsonNode rootNode, JsonNode jsonValue
         for (var i = 0; i < matches.Count; i++)
         {
             var match = matches[i];
-            var jsonPath = match.Groups[1].Value;
+            if (!string.IsNullOrEmpty(match.Groups[1].Value))
+            {
+                continue;
+            }
+
+            var jsonPath = match.Groups[2].Value;
             var pathParts = jsonPath.Split('.');
             if (pathParts.Length == 1)
             {

src/Aspirate.Shared/Interfaces/Commands/Contracts/IGenerateOptions.cs

@@ -8,4 +8,5 @@ public interface IGenerateOptions
     bool? SkipFinalKustomizeGeneration { get; set; }
     string? ImagePullPolicy { get; set; }
     string? OutputFormat { get; set; }
+    bool? UseEnvVariablesAsParameterValues { get; set; }
 }

src/Aspirate.Shared/Models/Aspirate/AspirateState.cs

@@ -135,13 +135,13 @@ public class AspirateState :
     public List<string> AspireComponentsToProcess { get; set; } = [];
 
     [JsonIgnore]
-    public Dictionary<string, Resource> LoadedAspireManifestResources { get; set; } = new();
+    public Dictionary<string, Resource> LoadedAspireManifestResources { get; set; } = [];
 
     [JsonIgnore]
     public string? PrivateRegistryPassword { get; set; }
 
     [JsonIgnore]
-    public Dictionary<string, Resource> FinalResources { get; } = new();
+    public Dictionary<string, Resource> FinalResources { get; } = [];
 
     [JsonIgnore]
     public bool StateWasLoadedFromPrevious { get; set; }
@@ -179,17 +179,20 @@ public class AspirateState :
     [JsonIgnore]
     public string? SecretPassword { get; set; }
 
+    [JsonIgnore]
+    public bool? UseEnvVariablesAsParameterValues { get; set; }
+
     public void AppendToFinalResources(string key, Resource resource) =>
         FinalResources.Add(key, resource);
 
     public bool IsNotDeployable(Resource resource)
     {
         if (OutputFormat.Equals("compose", StringComparison.OrdinalIgnoreCase))
         {
-            return (resource is ParameterResource or ValueResource);
+            return resource is ParameterResource or ValueResource;
         }
 
-        return (resource is DaprResource or ParameterResource or ValueResource);
+        return resource is DaprResource or ParameterResource or ValueResource;
     }
 
     [JsonIgnore]