Add git configuration

src/Confix.Tool/src/Confix.Library/Entities/Component/Providers/Git/GitComponentProvider.cs

@@ -52,10 +52,10 @@ public async Task ExecuteAsync(IComponentProviderContext context)
     {
         var components = context.ComponentReferences.Where(x => x.Provider == _name && x.IsEnabled);
 
-        var refs = await FetchRefsAsync(context.CancellationToken);
+        var refs = await FetchRefsAsync(context);
 
         var tasks = components
-            .Select(x => ProcessComponentAsync(x, refs, context.Logger, context.CancellationToken))
+            .Select(x => ProcessComponentAsync(x, refs, context))
             .ToArray();
 
         List<string>? errors = null;
@@ -82,18 +82,20 @@ public async Task ExecuteAsync(IComponentProviderContext context)
     }
 
     private async Task<IReadOnlyDictionary<string, string>> FetchRefsAsync(
-        CancellationToken cancellationToken)
+        IComponentProviderContext context)
     {
         var directory =
             new DirectoryInfo(Path.Combine(_cloneDirectory.FullName, "__refs"));
         var refs = new Dictionary<string, string>();
+
+        string gitUrl = GitUrl.Create(_repositoryUrl, context.Parameter);
 
         var sparseConfig =
-            new GitSparseCheckoutConfiguration(_repositoryUrl, directory.FullName, _arguments);
-        await _git.SparseCheckoutAsync(sparseConfig, cancellationToken);
+            new GitSparseCheckoutConfiguration(gitUrl, directory.FullName, _arguments);
+        await _git.SparseCheckoutAsync(sparseConfig, context.CancellationToken);
 
         var showRefConfig = new GitShowRefsConfiguration(directory.FullName, _arguments);
-        var refsOutput = await _git.ShowRefsAsync(showRefConfig, cancellationToken);
+        var refsOutput = await _git.ShowRefsAsync(showRefConfig, context.CancellationToken);
 
         foreach (var line in refsOutput.Split('\n'))
         {
@@ -115,8 +117,7 @@ private async Task<IReadOnlyDictionary<string, string>> FetchRefsAsync(
     private async Task<ComponentOrError?> ProcessComponentAsync(
         ComponentReferenceDefinition definition,
         IReadOnlyDictionary<string, string> refs,
-        IConsoleLogger logger,
-        CancellationToken cancellationToken)
+        IComponentProviderContext context)
     {
         var version = definition.Version ?? "latest";
         var componentName = definition.ComponentName;
@@ -129,13 +130,15 @@ private async Task<IReadOnlyDictionary<string, string>> FetchRefsAsync(
             directory.EnsureFolder();
 
             var cloneArgument = _arguments.ToList();
+
+            string gitUrl = GitUrl.Create(_repositoryUrl, context.Parameter);
 
             var cloneConfiguration = new GitCloneConfiguration(
-                _repositoryUrl,
+                gitUrl,
                 directory.FullName,
                 cloneArgument.ToArray());
 
-            await _git.CloneAsync(cloneConfiguration, cancellationToken);
+            await _git.CloneAsync(cloneConfiguration, context.CancellationToken);
 
             if (version is not "latest")
             {
@@ -147,7 +150,7 @@ private async Task<IReadOnlyDictionary<string, string>> FetchRefsAsync(
 
                 await _git.CheckoutAsync(
                     new GitCheckoutConfiguration(directory.FullName, hash, cloneArgument.ToArray()),
-                    cancellationToken);
+                    context.CancellationToken);
             }
 
             var pathToComponent = Path
@@ -159,7 +162,7 @@ await _git.CheckoutAsync(
                     $"Could not find component {componentName} ({version}) in git repository");
             }
 
-            logger.FoundComponent(componentName, version);
+            context.Logger.FoundComponent(componentName, version);
 
             var json = JsonSchema.FromFile(pathToComponent);
             var component =

src/Confix.Tool/src/Confix.Library/Entities/Component/Providers/Git/GitUrl.cs

@@ -0,0 +1,28 @@
+using Confix.Tool.Common.Pipelines;
+
+namespace Confix.Tool.Entities.Components.Git;
+
+public static class GitUrl
+{
+    public static string Create(string repositoryUrl, IParameterCollection parameters)
+    {
+        parameters.TryGet(GitUsernameOptions.Instance, out string? username);
+        parameters.TryGet(GitTokenOptions.Instance, out string? token);
+
+        if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(token))
+        {
+            if (repositoryUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+            {
+                var uri = new Uri(repositoryUrl);
+                var builder = new UriBuilder(uri)
+                {
+                    UserName = username,
+                    Password = token
+                };
+                return builder.Uri.ToString();
+            }
+        }
+
+        return repositoryUrl;
+    }
+}

src/Confix.Tool/src/Confix.Library/Middlewares/Project/BuildProjectMiddleware.cs

@@ -9,6 +9,10 @@ public sealed class BuildProjectMiddleware : IMiddleware
     /// <inheritdoc />
     public async Task InvokeAsync(IMiddlewareContext context, MiddlewareDelegate next)
     {
+        var variableContext = new VariableProviderContext(
+            context.Parameter,
+            context.CancellationToken);
+
         context.SetStatus("Building the project files");
 
         var cancellationToken = context.CancellationToken;
@@ -32,7 +36,7 @@ public async Task InvokeAsync(IMiddlewareContext context, MiddlewareDelegate nex
             context.Logger.ReplaceVariablesOfConfigurationFile(file);
 
             file.Content = await variableReplacer
-                .RewriteOrThrowAsync(content, context.CancellationToken);
+                .RewriteOrThrowAsync(content, variableContext);
         }
 
         await next(context);

src/Confix.Tool/src/Confix.Library/Middlewares/Project/RestoreProjectMiddleware.cs

@@ -5,6 +5,7 @@
 using Confix.Tool.Entities.Components.DotNet;
 using Confix.Tool.Middlewares.JsonSchemas;
 using Confix.Tool.Schema;
+using Confix.Variables;
 
 namespace Confix.Tool.Middlewares.Project;
 
@@ -30,6 +31,10 @@ public async Task InvokeAsync(IMiddlewareContext context, MiddlewareDelegate nex
         var jsonSchemas = context.Features.Get<JsonSchemaFeature>();
         var configuration = context.Features.Get<ConfigurationFeature>();
         var files = context.Features.Get<ConfigurationFileFeature>().Files;
+
+        var variableContext = new VariableProviderContext(
+            context.Parameter,
+            context.CancellationToken);
 
         configuration.EnsureProjectScope();
 
@@ -42,7 +47,7 @@ public async Task InvokeAsync(IMiddlewareContext context, MiddlewareDelegate nex
 
         context.SetStatus("Loading variables...");
         var variableResolver = context.Features.Get<VariablesFeature>().Resolver;
-        var variables = await variableResolver.ListVariables(cancellationToken);
+        var variables = await variableResolver.ListVariables(variableContext);
 
         context.SetStatus("Composing the schema...");
         var jsonSchema = _projectComposer.Compose(components, variables);

src/Confix.Tool/src/Confix.Library/Options/GitTokenOptions.cs

@@ -0,0 +1,15 @@
+using System.CommandLine;
+
+namespace Confix.Tool;
+
+internal sealed class GitTokenOptions : Option<string>
+{
+    public static GitTokenOptions Instance { get; } = new();
+
+    private GitTokenOptions()
+        : base("--git-token")
+    {
+        Arity = ArgumentArity.ZeroOrOne;
+        Description = "The token used for git authentication.";
+    }
+}

src/Confix.Tool/src/Confix.Library/Options/GitUsernameOptions.cs

@@ -0,0 +1,15 @@
+using System.CommandLine;
+
+namespace Confix.Tool;
+
+internal sealed class GitUsernameOptions : Option<string>
+{
+    public static GitUsernameOptions Instance { get; } = new();
+
+    private GitUsernameOptions()
+        : base("--git-username")
+    {
+        Arity = ArgumentArity.ZeroOrOne;
+        Description = "The username used for git authentication.";
+    }
+}

src/Confix.Tool/src/Confix.Library/Pipelines/BuildCommandPipeline.cs

@@ -17,6 +17,8 @@ protected override void Configure(IPipelineDescriptor builder)
             .AddOption(ActiveEnvironmentOption.Instance)
             .AddOption(OutputFileOption.Instance)
             .AddOption(EncryptionOption.Instance)
+            .AddOption(GitUsernameOptions.Instance)
+            .AddOption(GitTokenOptions.Instance)
             .UseHandler(InvokeAsync);
     }
 

src/Confix.Tool/src/Confix.Library/Pipelines/Project/ProjectBuildPipeline.cs

@@ -12,6 +12,8 @@ protected override void Configure(IPipelineDescriptor builder)
     {
         builder
             .AddOption(NoRestoreOptions.Instance)
+            .AddOption(GitUsernameOptions.Instance)
+            .AddOption(GitTokenOptions.Instance)
             .Use<LoadConfigurationMiddleware>()
             .UseReadConfigurationFiles()
             .UseEnvironment()

src/Confix.Tool/src/Confix.Library/Pipelines/Reporting/ProjectReportMiddleware.cs

@@ -9,6 +9,7 @@
 using Confix.Tool.Middlewares.Reporting;
 using Confix.Tool.Schema;
 using Confix.Utilities;
+using Confix.Variables;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Confix.Tool.Reporting;
@@ -215,11 +216,18 @@ private static async Task<List<VariableReport>> GetVariablesAsync(
         ConfigurationFile file,
         CancellationToken ct)
     {
+        var variableContext = new VariableProviderContext(
+            context.Parameter,
+            context.CancellationToken);
+
         var variablesFeature = context.Features.Get<VariablesFeature>();
         var variables = new List<VariableReport>();
 
         var content = await file.TryLoadContentAsync(ct);
-        foreach (var variable in await variablesFeature.Extractor.ExtractAsync(content, ct))
+        var variableInfos = await variablesFeature.Extractor
+            .ExtractAsync(content, variableContext);
+
+        foreach (var variable in variableInfos)
         {
             var hash = SHA256.HashData(Encoding.UTF8.GetBytes(variable.VariableValue));
 

src/Confix.Tool/src/Confix.Library/Pipelines/RestoreCommandPipeline.cs

@@ -13,6 +13,8 @@ protected override void Configure(IPipelineDescriptor builder)
     {
         builder
             .AddOption(DotnetConfigurationOptions.Instance)
+            .AddOption(GitUsernameOptions.Instance)
+            .AddOption(GitTokenOptions.Instance)
             .Use<LoadConfigurationMiddleware>()
             .UseEnvironment()
             .UseHandler(InvokeAsync);

src/Confix.Tool/src/Confix.Library/Pipelines/Variable/VariableCopyPipeline.cs

@@ -23,7 +23,9 @@ protected override void Configure(IPipelineDescriptor builder)
 
     private static async Task InvokeAsync(IMiddlewareContext context)
     {
-        var cancellationToken = context.CancellationToken;
+        var variableContext = new VariableProviderContext(
+            context.Parameter,
+            context.CancellationToken);
 
         var variableFeature = context.Features.Get<VariablesFeature>();
 
@@ -48,9 +50,9 @@ private static async Task InvokeAsync(IMiddlewareContext context)
         context.Status.Message =
             $"Copy variable {fromVariablePath.ToString().AsHighlighted()} to {toVariablePath.ToString().AsHighlighted()}...";
 
-        var fromValue = await fromResolver.ResolveOrThrowAsync(fromVariablePath, cancellationToken);
+        var fromValue = await fromResolver.ResolveOrThrowAsync(fromVariablePath, variableContext);
 
-        var result = await toResolver.SetVariable(toVariablePath, fromValue, cancellationToken);
+        var result = await toResolver.SetVariable(toVariablePath, fromValue, variableContext);
 
         context.Logger.VariableSet(result);
     }

src/Confix.Tool/src/Confix.Library/Pipelines/Variable/VariableGetPipeline.cs

@@ -20,6 +20,10 @@ protected override void Configure(IPipelineDescriptor builder)
 
     private static async Task InvokeAsync(IMiddlewareContext context)
     {
+        var variableContext = new VariableProviderContext(
+            context.Parameter,
+            context.CancellationToken);
+
         var resolver = context.Features.Get<VariablesFeature>().Resolver;
 
         if (!context.Parameter.TryGet(VariableNameOption.Instance, out string variableName))
@@ -32,7 +36,7 @@ private static async Task InvokeAsync(IMiddlewareContext context)
         context.Status.Message = $"Resolving variable {variablePath.ToString().AsHighlighted()}...";
 
         var result = await resolver
-            .ResolveOrThrowAsync(variablePath, context.CancellationToken);
+            .ResolveOrThrowAsync(variablePath, variableContext);
 
         context.Logger.PrintVariableResolved(variablePath, result.ToJsonString());
 

src/Confix.Tool/src/Confix.Library/Pipelines/Variable/VariableListPipeline.cs

@@ -26,16 +26,20 @@ private static async Task InvokeAsync(IMiddlewareContext context)
         IEnumerable<VariablePath> variables;
 
         context.Status.Message = "Fetching Variables...";
+
+        var variableContext = new VariableProviderContext(
+            context.Parameter,
+            context.CancellationToken);
 
         if (context.Parameter
             .TryGet(VariableProviderNameOption.Instance, out string? variableProviderName))
         {
             variables =
-                await resolver.ListVariables(variableProviderName, context.CancellationToken);
+                await resolver.ListVariables(variableProviderName, variableContext);
         }
         else
         {
-            variables = await resolver.ListVariables(context.CancellationToken);
+            variables = await resolver.ListVariables(variableContext);
         }
 
         context.Logger.PrintVariables(variables);

src/Confix.Tool/src/Confix.Library/Pipelines/Variable/VariableSetPipeline.cs

@@ -25,6 +25,10 @@ private static async Task InvokeAsync(IMiddlewareContext context)
     {
         context.Features.Get<ConfigurationFeature>().EnsureProjectScope();
 
+        var variableContext = new VariableProviderContext(
+            context.Parameter,
+            context.CancellationToken);
+
         var resolver = context.Features.Get<VariablesFeature>().Resolver;
         if (!context.Parameter.TryGet(VariableNameOption.Instance, out string variableName))
         {
@@ -44,7 +48,7 @@ private static async Task InvokeAsync(IMiddlewareContext context)
                 $"Setting variable {parsed.Value.ToString().AsHighlighted()}...";
 
             var result = await resolver
-                .SetVariable(parsed.Value, value, context.CancellationToken);
+                .SetVariable(parsed.Value, value, variableContext);
 
             context.Logger.VariableSet(result);
         }