feat(infrastructure): add DB connection string provider with thread-safe caching

- Implement IDbConnectionStringProvider interface
  * Thread-safe singleton with lock-based synchronization
  * Initialize once during Lambda cold start
  * GetConnectionString for cached retrieval
  * Comprehensive error handling and validation

Author: sl-cloud

src/LeadProcessor.Infrastructure/Services/DbConnectionStringProvider.cs

@@ -0,0 +1,66 @@
+namespace LeadProcessor.Infrastructure.Services;
+
+/// <summary>
+/// Thread-safe implementation of <see cref="IDbConnectionStringProvider"/> that caches the database connection string.
+/// </summary>
+/// <remarks>
+/// This class is designed to be registered as a singleton in the dependency injection container.
+/// The connection string is initialized during Lambda cold start and cached for the lifetime
+/// of the Lambda instance, avoiding repeated calls to AWS Secrets Manager.
+/// All methods are thread-safe and can be called concurrently from multiple threads.
+/// </remarks>
+public sealed class DbConnectionStringProvider : IDbConnectionStringProvider
+{
+    private string? _connectionString;
+    private readonly object _lock = new();
+
+    /// <summary>
+    /// Initializes the connection string provider with the specified connection string.
+    /// </summary>
+    /// <param name="connectionString">The database connection string to store.</param>
+    /// <exception cref="ArgumentNullException">Thrown when connectionString is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when connectionString is empty or whitespace.</exception>
+    /// <remarks>
+    /// This method is thread-safe and can be called multiple times. Each call will overwrite
+    /// the previously stored connection string. In a typical Lambda scenario, this is called
+    /// once during cold start initialization.
+    /// </remarks>
+    public void Initialize(string connectionString)
+    {
+        if (connectionString == null)
+        {
+            throw new ArgumentNullException(nameof(connectionString));
+        }
+
+        if (string.IsNullOrWhiteSpace(connectionString))
+        {
+            throw new ArgumentException("Connection string cannot be empty or whitespace.", nameof(connectionString));
+        }
+
+        lock (_lock)
+        {
+            _connectionString = connectionString;
+        }
+    }
+
+    /// <summary>
+    /// Retrieves the database connection string.
+    /// </summary>
+    /// <returns>The database connection string that was previously initialized.</returns>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when the connection string has not been initialized via <see cref="Initialize"/>.
+    /// </exception>
+    /// <remarks>
+    /// This method is thread-safe and can be called concurrently from multiple threads.
+    /// It will always return the most recently initialized connection string.
+    /// </remarks>
+    public string GetConnectionString()
+    {
+        lock (_lock)
+        {
+            return _connectionString ?? throw new InvalidOperationException(
+                "Connection string not initialized. Call Initialize() before GetConnectionString().");
+        }
+    }
+}
+

src/LeadProcessor.Infrastructure/Services/IDbConnectionStringProvider.cs

@@ -0,0 +1,40 @@
+namespace LeadProcessor.Infrastructure.Services;
+
+/// <summary>
+/// Provides access to the database connection string.
+/// </summary>
+/// <remarks>
+/// This interface enables thread-safe access to the database connection string
+/// which is initialized during Lambda cold start. The connection string is typically
+/// retrieved from AWS Secrets Manager and cached for the lifetime of the Lambda instance.
+/// Implementations must be thread-safe.
+/// </remarks>
+public interface IDbConnectionStringProvider
+{
+    /// <summary>
+    /// Initializes the connection string provider with the specified connection string.
+    /// </summary>
+    /// <param name="connectionString">The database connection string to store.</param>
+    /// <exception cref="ArgumentNullException">Thrown when connectionString is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when connectionString is empty or whitespace.</exception>
+    /// <remarks>
+    /// This method should be called once during Lambda initialization (cold start)
+    /// before any database operations are performed. Subsequent calls will overwrite
+    /// the existing connection string.
+    /// Thread-safe: Can be called from multiple threads simultaneously.
+    /// </remarks>
+    void Initialize(string connectionString);
+
+    /// <summary>
+    /// Retrieves the database connection string.
+    /// </summary>
+    /// <returns>The database connection string.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the connection string has not been initialized.</exception>
+    /// <remarks>
+    /// This method is called by the DbContext factory to obtain the connection string
+    /// for creating database connections. It must be called after Initialize().
+    /// Thread-safe: Can be called from multiple threads simultaneously.
+    /// </remarks>
+    string GetConnectionString();
+}
+