Add "type state" based wrapper around Logging.Logger to handle initialisation via setLogger

Author: finestructure

Sources/App/Core/Dependencies/LoggerClient.swift

@@ -14,18 +14,31 @@
 
 import Dependencies
 import DependenciesMacros
+import IssueReporting
+import Logging
+import Synchronization
 
 
 @DependencyClient
 struct LoggerClient {
-
+    var log: @Sendable (_ level: Logging.Logger.Level, Logging.Logger.Message) -> Void
+    var setLogger: @Sendable (Logging.Logger) -> Void
 }
 
 
 extension LoggerClient: DependencyKey {
     static var liveValue: Self {
-        .init()
+        .init(
+            log: { level, message in
+                _logger.withLock { $0.log(level: level, message) }
+            },
+            setLogger: { logger in
+                _logger.withLock { $0.setLogger(logger) }
+            }
+        )
     }
+
+    private static let _logger = Mutex(Logger.uninitialized(.init()))
 }
 
 
@@ -40,3 +53,70 @@ extension DependencyValues {
         set { self[LoggerClient.self] = newValue }
     }
 }
+
+
+// Modeled after https://swiftology.io/articles/typestate/
+
+extension LoggerClient {
+
+    private enum Logger: ~Copyable {
+        case uninitialized(_UninitializedLogger)
+        case initialized(_InitializedLogger)
+
+        mutating func setLogger(_ logger: Logging.Logger) {
+            self = .initialized(.init(logger: logger))
+        }
+
+        func log(
+            level: Logging.Logger.Level,
+            _ message: @autoclosure () -> Logging.Logger.Message,
+            metadata: @autoclosure () -> Logging.Logger.Metadata? = nil,
+            source: @autoclosure () -> String? = nil,
+            file: String = #fileID,
+            function: String = #function,
+            line: UInt = #line
+        ) {
+            switch self {
+                case .uninitialized:
+                    break
+                case let .initialized(logger):
+                    logger.log(level: level,
+                               message(),
+                               metadata: metadata(),
+                               source: source(),
+                               file: file,
+                               function: function,
+                               line: line)
+            }
+        }
+    }
+
+}
+
+
+private struct _UninitializedLogger: ~Copyable {
+    consuming func setLogger(_ logger: Logging.Logger) -> _InitializedLogger {
+        .init(logger: logger)
+    }
+}
+
+private struct _InitializedLogger: ~Copyable {
+    var logger: Logging.Logger
+
+    init(logger: Logging.Logger) {
+        self.logger = logger
+    }
+
+    func log(
+        level: Logging.Logger.Level,
+        _ message: @autoclosure () -> Logging.Logger.Message,
+        metadata: @autoclosure () -> Logging.Logger.Metadata? = nil,
+        source: @autoclosure () -> String? = nil,
+        file: String = #fileID,
+        function: String = #function,
+        line: UInt = #line
+    ) {
+        logger.log(level: level, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
+    }
+}
+