refactor: implement AWS client factory pattern and consolidate configuration

Blind-Striker · Blind-Striker · commit a9082e9ab085 · 2025-09-02T16:43:49.000+03:00
- Add conditional AWS client builder with LocalStack support for development environments
- Create factory pattern for AWS service clients with lazy initialization and proper disposal
- Implement GitHub package service factory with environment-based configuration validation
- Consolidate application settings into unified Settings class with environment variable parsing
- Remove ILLink descriptors and optimize project dependencies for Native AOT compilation
- Simplify main program structure with cleaner conditional compilation directives

Improves testability, reduces memory footprint, and provides better separation between local development and production AWS service usage.
diff --git a/src/BadgeSmith.Api/BadgeSmith.Api.csproj b/src/BadgeSmith.Api/BadgeSmith.Api.csproj
@@ -21,12 +21,17 @@
     <EventSourceSupport>false</EventSourceSupport>
 
     <EnableTelemetry>true</EnableTelemetry>
+    <EnableLocalStack>true</EnableLocalStack>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(EnableTelemetry)' == 'true'">
     <DefineConstants>$(DefineConstants);ENABLE_TELEMETRY</DefineConstants>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(EnableLocalStack)' == 'true'">
+    <DefineConstants>$(DefineConstants);ENABLE_LOCALSTACK</DefineConstants>
+  </PropertyGroup>
+
   <ItemGroup>
     <PackageReference Include="Amazon.Lambda.RuntimeSupport"/>
     <PackageReference Include="Amazon.Lambda.Core"/>
@@ -39,10 +44,10 @@
     <PackageReference Include="OneOf"/>
     <PackageReference Include="OneOf.SourceGenerator"/>
 
-    <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Memory"/>
     <PackageReference Include="Microsoft.Extensions.Logging.Console"/>
 
-    <PackageReference Include="LocalStack.Client"/>
+    <PackageReference Include="LocalStack.Client" Condition="'$(EnableLocalStack)' == 'true'"/>
 
     <PackageReference Include="NuGet.Versioning"/>
     <PackageReference Include="ZLinq"/>
@@ -79,8 +84,4 @@
       <_Parameter1>DynamicProxyGenAssembly2</_Parameter1>
     </AssemblyAttribute>
   </ItemGroup>
-
-  <ItemGroup>
-    <TrimmerRootDescriptor Include="ILLink.Descriptors.xml"/>
-  </ItemGroup>
 </Project>
diff --git a/src/BadgeSmith.Api/Dockerfile b/src/BadgeSmith.Api/Dockerfile
@@ -27,7 +27,7 @@ RUN --mount=type=cache,id=nuget,target=/root/.nuget/packages \
 
 RUN --mount=type=cache,id=nuget,target=/root/.nuget/packages \
     dotnet publish ${PROJECT} -c ${CONFIG} -r ${RID} --self-contained true \
-      -p:PublishAot=true -p:StripSymbols=true -p:DebugType=none -p:EnableTelemetry=false \
+      -p:PublishAot=true -p:StripSymbols=true -p:DebugType=none -p:EnableTelemetry=false -p:EnableLocalStack=false \
       -p:EnableSourceControlManagerQueries=false \
       -p:EmbedUntrackedSources=false \
       -o ${PUBLISH_DIR} \
diff --git a/src/BadgeSmith.Api/Domain/AWS/AwsClientBuilder.cs b/src/BadgeSmith.Api/Domain/AWS/AwsClientBuilder.cs
@@ -0,0 +1,130 @@
+﻿#if !ENABLE_LOCALSTACK
+using Amazon.Runtime;
+
+namespace BadgeSmith.Api.Domain.AWS;
+
+internal static class AwsClientBuilder
+{
+    public static TClient CreateAwsClient<TClient>() where TClient : AmazonServiceClient, IAmazonService, new()
+    {
+        return new TClient();
+    }
+}
+#endif
+
+#if ENABLE_LOCALSTACK
+
+using System.Globalization;
+using Amazon.Runtime;
+using LocalStack.Client;
+using LocalStack.Client.Contracts;
+using LocalStack.Client.Options;
+
+namespace BadgeSmith.Api.Domain.AWS;
+
+internal static class AwsClientBuilder
+{
+    private static readonly ISession Session = SessionStandalone
+        .Init()
+        .WithConfigurationOptions(BuildConfigOptions())
+        .WithSessionOptions(BuildSessionOptions())
+        .Create();
+
+    public static TClient CreateAwsClient<TClient>() where TClient : AmazonServiceClient, IAmazonService, new()
+    {
+        return Settings.UseLocalStack ? Session.CreateClientByImplementation<TClient>() : new TClient();
+    }
+
+    public static ConfigOptions BuildConfigOptions()
+    {
+        var localStackHost = Environment.GetEnvironmentVariable("LocalStack__Config__LocalStackHost");
+        var localStackPort = Environment.GetEnvironmentVariable("LocalStack__Config__EdgePort");
+        var useLegacyPorts = Environment.GetEnvironmentVariable("LocalStack__Config__UseLegacyPorts");
+        var useSsl = Environment.GetEnvironmentVariable("LocalStack__Config__UseSsl");
+
+        if (string.IsNullOrEmpty(localStackHost) || string.IsNullOrEmpty(localStackPort))
+        {
+            var localStackConnection = Environment.GetEnvironmentVariable("ConnectionStrings__localstack");
+            if (!string.IsNullOrEmpty(localStackConnection) && Uri.TryCreate(localStackConnection, UriKind.Absolute, out var uri))
+            {
+                localStackHost ??= uri.Host;
+                localStackPort ??= uri.Port.ToString(CultureInfo.InvariantCulture);
+            }
+        }
+
+        if (string.IsNullOrEmpty(localStackHost) && string.IsNullOrEmpty(localStackPort) && string.IsNullOrEmpty(useLegacyPorts) && string.IsNullOrEmpty(useSsl))
+        {
+            return new ConfigOptions();
+        }
+
+        int? edgePort;
+        if (string.IsNullOrEmpty(localStackPort))
+        {
+            edgePort = null;
+        }
+        else if (int.TryParse(localStackPort, CultureInfo.InvariantCulture, out var port))
+        {
+            edgePort = port;
+        }
+        else
+        {
+            edgePort = null;
+        }
+
+        bool? legacyPorts;
+        if (string.IsNullOrEmpty(useLegacyPorts))
+        {
+            legacyPorts = null;
+        }
+        else if (bool.TryParse(useLegacyPorts, out var legacy))
+        {
+            legacyPorts = legacy;
+        }
+        else
+        {
+            legacyPorts = null;
+        }
+
+        bool? ssl;
+        if (string.IsNullOrEmpty(useSsl))
+        {
+            ssl = null;
+        }
+        else if (bool.TryParse(useSsl, out var sslValue))
+        {
+            ssl = sslValue;
+        }
+        else
+        {
+            ssl = null;
+        }
+
+        return new ConfigOptions(
+            localStackHost ?? LocalStack.Client.Models.Constants.LocalStackHost,
+            legacyPorts ?? LocalStack.Client.Models.Constants.UseLegacyPorts,
+            ssl ?? LocalStack.Client.Models.Constants.UseSsl,
+            edgePort ?? LocalStack.Client.Models.Constants.EdgePort
+        );
+    }
+
+    public static SessionOptions BuildSessionOptions()
+    {
+        var awsAccessKey = Environment.GetEnvironmentVariable("LocalStack__Session__AwsAccessKey");
+        var awsAccessKeyId = Environment.GetEnvironmentVariable("LocalStack__Session__AwsAccessKeyId");
+        var awsSessionToken = Environment.GetEnvironmentVariable("LocalStack__Session__AwsSessionToken");
+        var regionName = Environment.GetEnvironmentVariable("LocalStack__Session__RegionName");
+
+        if (string.IsNullOrEmpty(awsAccessKey) && string.IsNullOrEmpty(awsAccessKeyId) && string.IsNullOrEmpty(awsSessionToken) && string.IsNullOrEmpty(regionName))
+        {
+            return new SessionOptions();
+        }
+
+        return new SessionOptions(
+            awsAccessKeyId: string.IsNullOrEmpty(awsAccessKeyId) ? LocalStack.Client.Models.Constants.AwsAccessKeyId : awsAccessKeyId,
+            awsAccessKey: string.IsNullOrEmpty(awsAccessKey) ? LocalStack.Client.Models.Constants.AwsAccessKey : awsAccessKey,
+            awsSessionToken: string.IsNullOrEmpty(awsSessionToken) ? LocalStack.Client.Models.Constants.AwsSessionToken : awsSessionToken,
+            regionName: string.IsNullOrEmpty(regionName) ? LocalStack.Client.Models.Constants.RegionName : regionName
+        );
+    }
+}
+#endif
diff --git a/src/BadgeSmith.Api/Domain/AWS/AwsClientFactory.cs b/src/BadgeSmith.Api/Domain/AWS/AwsClientFactory.cs
@@ -0,0 +1,13 @@
+﻿using Amazon.DynamoDBv2;
+using Amazon.SecretsManager;
+
+namespace BadgeSmith.Api.Domain.AWS;
+
+internal static class AwsClientFactory
+{
+    private static readonly Lazy<AmazonDynamoDBClient> DynamoDbClientLazy = new(AwsClientBuilder.CreateAwsClient<AmazonDynamoDBClient>);
+    private static readonly Lazy<AmazonSecretsManagerClient> AmazonSecretsManagerClientLazy = new(AwsClientBuilder.CreateAwsClient<AmazonSecretsManagerClient>);
+
+    public static AmazonDynamoDBClient AmazonDynamoDbClient => DynamoDbClientLazy.Value;
+    public static AmazonSecretsManagerClient AmazonSecretsManagerClient => AmazonSecretsManagerClientLazy.Value;
+}
diff --git a/src/BadgeSmith.Api/Domain/Services/Contracts/IGithubPackageServiceFactory.cs b/src/BadgeSmith.Api/Domain/Services/Contracts/IGithubPackageServiceFactory.cs
@@ -0,0 +1,8 @@
+using BadgeSmith.Api.Domain.Services.Github;
+
+namespace BadgeSmith.Api.Domain.Services.Contracts;
+
+internal interface IGithubPackageServiceFactory
+{
+    public GithubOrgSecretsService GithubOrgSecretsService { get; }
+}
diff --git a/src/BadgeSmith.Api/Domain/Services/Github/GithubPackageServiceFactory.cs b/src/BadgeSmith.Api/Domain/Services/Github/GithubPackageServiceFactory.cs
@@ -0,0 +1,31 @@
+﻿using BadgeSmith.Api.Domain.AWS;
+using BadgeSmith.Api.Domain.Services.Contracts;
+using BadgeSmith.Api.Infrastructure.Caching;
+using BadgeSmith.Api.Infrastructure.Observability;
+
+namespace BadgeSmith.Api.Domain.Services.Github;
+
+internal class GithubPackageServiceFactory : IGithubPackageServiceFactory
+{
+    private static readonly Lazy<GithubOrgSecretsService> GithubOrgSecretsServiceLazy = new(CreateGithubOrgSecretsService);
+
+    public GithubOrgSecretsService GithubOrgSecretsService => GithubOrgSecretsServiceLazy.Value;
+
+    private static GithubOrgSecretsService CreateGithubOrgSecretsService()
+    {
+        var amazonDynamoDbClient = AwsClientFactory.AmazonDynamoDbClient;
+        var amazonSecretsManagerClient = AwsClientFactory.AmazonSecretsManagerClient;
+
+        var secretsTableName = Environment.GetEnvironmentVariable("AWS_RESOURCE_ORG_SECRETS_TABLE");
+
+        if (string.IsNullOrWhiteSpace(secretsTableName))
+        {
+            throw new InvalidOperationException("AWS_RESOURCE_ORG_SECRETS_TABLE environment variable is not set");
+        }
+
+        var githubSecretsLogger = LoggerFactory.CreateLogger<GithubOrgSecretsService>();
+
+        var memoryAppCache = new MemoryAppCache();
+        return new GithubOrgSecretsService(amazonSecretsManagerClient, amazonDynamoDbClient, secretsTableName, memoryAppCache, githubSecretsLogger);
+    }
+}
diff --git a/src/BadgeSmith.Api/ILLink.Descriptors.xml b/src/BadgeSmith.Api/ILLink.Descriptors.xml
diff --git a/src/BadgeSmith.Api/Infrastructure/Caching/MemoryAppCache.cs b/src/BadgeSmith.Api/Infrastructure/Caching/MemoryAppCache.cs
@@ -4,11 +4,11 @@ namespace BadgeSmith.Api.Infrastructure.Caching;
 
 internal sealed class MemoryAppCache : IAppCache, IDisposable
 {
-    private readonly MemoryCache _cache = new(new MemoryCacheOptions());
+    private static readonly MemoryCache Cache = new(new MemoryCacheOptions());
 
     public bool TryGetValue<T>(string key, out T? value)
     {
-        if (_cache.TryGetValue(key, out var obj) && obj is T v)
+        if (Cache.TryGetValue(key, out var obj) && obj is T v)
         {
             value = v;
             return true;
@@ -20,13 +20,13 @@ public bool TryGetValue<T>(string key, out T? value)
 
     public void Set<T>(string key, T value, TimeSpan ttl)
     {
-        using var entry = _cache.CreateEntry(key);
+        using var entry = Cache.CreateEntry(key);
         entry.AbsoluteExpirationRelativeToNow = ttl;
         entry.Value = value;
     }
 
     public void Dispose()
     {
-        _cache.Dispose();
+        Cache.Dispose();
     }
 }
diff --git a/src/BadgeSmith.Api/Infrastructure/Handlers/HandlerFactoy.cs b/src/BadgeSmith.Api/Infrastructure/Handlers/HandlerFactoy.cs
@@ -1,14 +1,9 @@
 ﻿#pragma warning disable S125, RCS1093
 
-using Amazon.DynamoDBv2;
-using Amazon.SecretsManager;
 using BadgeSmith.Api.Domain.Services.Github;
 using BadgeSmith.Api.Domain.Services.Nuget;
-using BadgeSmith.Api.Infrastructure.Caching;
 using BadgeSmith.Api.Infrastructure.Handlers.Contracts;
 using BadgeSmith.Api.Infrastructure.Observability;
-using LocalStack.Client;
-using LocalStack.Client.Options;
 
 namespace BadgeSmith.Api.Infrastructure.Handlers;
 
@@ -21,9 +16,6 @@ internal class HandlerFactory : IHandlerFactory
     private static readonly Lazy<ITestResultRedirectionHandler> TestResultRedirectionHandlerLazy = new(CreateTestResultRedirectionHandler);
     private static readonly Lazy<ITestResultIngestionHandler> TestResultIngestionHandlerLazy = new(CreateTestResultIngestionHandler);
 
-    private static readonly Lazy<IAmazonSecretsManager> SecretsManagerLazy = new(CreateSecretsManagerClient());
-    private static readonly Lazy<IAmazonDynamoDB> DynamoDbClientLazy = new(CreateDynamoDbClient);
-
     public IHealthCheckHandler HealthCheckHandler => HealthCheckHandlerLazy.Value;
 
     public INugetPackageBadgeHandler NugetPackageBadgeHandler => NugetPackageBadgeHandlerLazy.Value;
@@ -47,24 +39,14 @@ private static NuGetPackageBadgeHandler CreateNugetPackageBadgeHandler()
         var logger = LoggerFactory.CreateLogger<NuGetPackageBadgeHandler>();
         var nugetPackageServiceFactory = new NuGetPackageServiceFactory();
 
-        return new NuGetPackageBadgeHandler(logger, nugetPackageServiceFactory);
+        return new NuGetPackageBadgeHandler(logger, nugetPackageServiceFactory.NuGetPackageService);
     }
 
     private static GithubPackagesBadgeHandler CreateGithubPackagesBadgeHandler()
     {
         var githubPackagesLogger = LoggerFactory.CreateLogger<GithubPackagesBadgeHandler>();
-        var githubSecretsLogger = LoggerFactory.CreateLogger<GithubOrgSecretsService>();
-
-        var secretsTableName = Environment.GetEnvironmentVariable("AWS_RESOURCE_ORG_SECRETS_TABLE");
-
-        if (string.IsNullOrWhiteSpace(secretsTableName))
-        {
-            throw new InvalidOperationException("AWS_RESOURCE_ORG_SECRETS_TABLE environment variable is not set");
-        }
-
-        var memoryAppCache = new MemoryAppCache();
-        var githubOrgSecretsService = new GithubOrgSecretsService(SecretsManagerLazy.Value, DynamoDbClientLazy.Value, secretsTableName, memoryAppCache, githubSecretsLogger);
-        return new GithubPackagesBadgeHandler(githubPackagesLogger, githubOrgSecretsService);
+        var githubPackageServiceFactory = new GithubPackageServiceFactory();
+        return new GithubPackagesBadgeHandler(githubPackagesLogger, githubPackageServiceFactory.GithubOrgSecretsService);
     }
 
     private static TestResultsBadgeHandler CreateTestResultsBadgeHandler()
@@ -84,40 +66,4 @@ private static TestResultIngestionHandler CreateTestResultIngestionHandler()
         var logger = LoggerFactory.CreateLogger<TestResultIngestionHandler>();
         return new TestResultIngestionHandler(logger);
     }
-
-    private static AmazonDynamoDBClient CreateDynamoDbClient()
-    {
-        if (!Settings.UseLocalStack)
-        {
-            return new AmazonDynamoDBClient();
-        }
-
-        var uri = new Uri(Settings.LocalStackEndpoint!);
-        var localStackHost = uri.Host;
-        var localStackPort = uri.Port;
-        return SessionStandalone
-            .Init()
-            .WithConfigurationOptions(new ConfigOptions(localStackHost, edgePort: localStackPort))
-            .WithSessionOptions(new SessionOptions(regionName: Environment.GetEnvironmentVariable("AWS_REGION")!))
-            .Create()
-            .CreateClientByImplementation<AmazonDynamoDBClient>();
-    }
-
-    private static AmazonSecretsManagerClient CreateSecretsManagerClient()
-    {
-        if (!Settings.UseLocalStack)
-        {
-            return new AmazonSecretsManagerClient();
-        }
-
-        var uri = new Uri(Settings.LocalStackEndpoint!);
-        var localStackHost = uri.Host;
-        var localStackPort = uri.Port;
-        return SessionStandalone
-            .Init()
-            .WithConfigurationOptions(new ConfigOptions(localStackHost, edgePort: localStackPort))
-            .WithSessionOptions(new SessionOptions(regionName: Environment.GetEnvironmentVariable("AWS_REGION")!))
-            .Create()
-            .CreateClientByImplementation<AmazonSecretsManagerClient>();
-    }
 }
diff --git a/src/BadgeSmith.Api/Infrastructure/Handlers/NuGetPackageBadgeHandler.cs b/src/BadgeSmith.Api/Infrastructure/Handlers/NuGetPackageBadgeHandler.cs
@@ -15,10 +15,10 @@ internal class NuGetPackageBadgeHandler : INugetPackageBadgeHandler
     private readonly ILogger<NuGetPackageBadgeHandler> _logger;
     private readonly INuGetPackageService _nugetPackageService;
 
-    public NuGetPackageBadgeHandler(ILogger<NuGetPackageBadgeHandler> logger, INugetPackageServiceFactory nugetPackageServiceFactory)
+    public NuGetPackageBadgeHandler(ILogger<NuGetPackageBadgeHandler> logger, INuGetPackageService nuGetPackageService)
     {
         _logger = logger;
-        _nugetPackageService = nugetPackageServiceFactory.NuGetPackageService;
+        _nugetPackageService = nuGetPackageService;
     }
 
     public async Task<APIGatewayHttpApiV2ProxyResponse> HandleAsync(RouteContext routeContext, CancellationToken ct = default)
diff --git a/src/BadgeSmith.Api/Program.Telemetry.cs b/src/BadgeSmith.Api/Program.Telemetry.cs
@@ -45,8 +45,7 @@ static async Task<APIGatewayHttpApiV2ProxyResponse> FunctionCoreAsync(APIGateway
 {
     SetHttpTags(request, context);
 
-    var timeout = TimeSpan.FromSeconds(Constants.LambdaTimeoutInSeconds).Subtract(TimeSpan.FromSeconds(2));
-    using var cts = new CancellationTokenSource(timeout);
+    using var cts = new CancellationTokenSource(LambdaTimeout);
 
     var httpMethod = request.RequestContext.Http.Method ?? "UNKNOWN";
     var path = request.RequestContext.Http.Path ?? "/";
diff --git a/src/BadgeSmith.Api/Program.cs b/src/BadgeSmith.Api/Program.cs
diff --git a/src/BadgeSmith.Api/Settings.cs b/src/BadgeSmith.Api/Settings.cs

Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,11 @@ namespace BadgeSmith.Api.Infrastructure.Caching;`
`4`	`4`
`5`	`5`	`internal sealed class MemoryAppCache : IAppCache, IDisposable`
`6`	`6`	`{`
`7`		`- private readonly MemoryCache _cache = new(new MemoryCacheOptions());`
	`7`	`+ private static readonly MemoryCache Cache = new(new MemoryCacheOptions());`
`8`	`8`
`9`	`9`	`public bool TryGetValue<T>(string key, out T? value)`
`10`	`10`	`{`
`11`		`- if (_cache.TryGetValue(key, out var obj) && obj is T v)`
	`11`	`+ if (Cache.TryGetValue(key, out var obj) && obj is T v)`
`12`	`12`	`{`
`13`	`13`	`value = v;`
`14`	`14`	`return true;`
`@@ -20,13 +20,13 @@ public bool TryGetValue<T>(string key, out T? value)`
`20`	`20`
`21`	`21`	`public void Set<T>(string key, T value, TimeSpan ttl)`
`22`	`22`	`{`
`23`		`- using var entry = _cache.CreateEntry(key);`
	`23`	`+ using var entry = Cache.CreateEntry(key);`
`24`	`24`	`entry.AbsoluteExpirationRelativeToNow = ttl;`
`25`	`25`	`entry.Value = value;`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`public void Dispose()`
`29`	`29`	`{`
`30`		`- _cache.Dispose();`
	`30`	`+ Cache.Dispose();`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,10 +15,10 @@ internal class NuGetPackageBadgeHandler : INugetPackageBadgeHandler`
`15`	`15`	`private readonly ILogger<NuGetPackageBadgeHandler> _logger;`
`16`	`16`	`private readonly INuGetPackageService _nugetPackageService;`
`17`	`17`
`18`		`- public NuGetPackageBadgeHandler(ILogger<NuGetPackageBadgeHandler> logger, INugetPackageServiceFactory nugetPackageServiceFactory)`
	`18`	`+ public NuGetPackageBadgeHandler(ILogger<NuGetPackageBadgeHandler> logger, INuGetPackageService nuGetPackageService)`
`19`	`19`	`{`
`20`	`20`	`_logger = logger;`
`21`		`- _nugetPackageService = nugetPackageServiceFactory.NuGetPackageService;`
	`21`	`+ _nugetPackageService = nuGetPackageService;`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public async Task<APIGatewayHttpApiV2ProxyResponse> HandleAsync(RouteContext routeContext, CancellationToken ct = default)`