isowords の ApiClient の実装を把握する

public struct ServerRouter: ParserPrinter {
  let date: () -> Date
  let decoder: JSONDecoder
  let encoder: JSONEncoder
  let secrets: [String]
  let sha256: (Data) -> Data

  // ...

  public var body: some Router<ServerRoute> {
    OneOf {
      Route(.case(ServerRoute.api)) {
        Path { "api" }
        // ...
      }
    }
  }

  // ...
}

public enum ServerRoute: Equatable {
  case api(Api)
  case appSiteAssociation
  // ...
  case download
  // ...

  public struct Api: Equatable {
    public let accessToken: AccessToken
    public let isDebug: Bool
    public let route: Route

    // ...

    public enum Route: Equatable, Sendable {
      case changelog(build: Build.Number)
      case config(build: Build.Number)
      // ...
      verifyReceipt(Data)
    }
  }

  // ...
}

import Foundation
import SharedModels

public struct ApiClient {
  public var apiRequest: @Sendable (ServerRoute.Api.Route) async throws -> (Data, URLResponse)
  // ...
  public var request: @Sendable (ServerRoute) async throws -> (Data, URLResponse)

  // ...

  public func apiRequest(
    route: ServerRoute.Api.Route,
    file: StaticString = #file,
    line: UInt = #line
  ) async throws -> (Data, URLResponse) {
    do {
      let (data, response) = try await self.apiRequest(route)
      #if DEBUG
        print(
          """
          API: route: \(route), \
          status: \((response as? HTTPURLResponse)?.statusCode ?? 0), \
          receive data: \(String(decoding: data, as: UTF8.self))
          """
        )
      #endif
      return (data, response)
    } catch {
      throw ApiError(error: error, file: file, line: line)
    }
  }

  public func apiRequest<A: Decodable>(
    route: ServerRoute.Api.Route,
    as: A.Type,
    file: StaticString = #file,
    line: UInt = #line
  ) async throws -> A {
    let (data, _) = try await self.apiRequest(route: route, file: file, line: line)
    do {
      return try apiDecode(A.self, from: data)
    } catch {
      throw ApiError(error: error, file: file, line: line)
    }
  }

  public func request(
    route: ServerRoute,
    file: StaticString = #file,
    line: UInt = #line
  ) async throws -> (Data, URLResponse) {
    do {
      let (data, response) = try await self.request(route)
      #if DEBUG
        print(
          """
          API: route: \(route), \
          status: \((response as? HTTPURLResponse)?.statusCode ?? 0), \
          receive data: \(String(decoding: data, as: UTF8.self))
          """
        )
      #endif
      return (data, response)
    } catch {
      throw ApiError(error: error, file: file, line: line)
    }
  }

  public func request<A: Decodable>(
    route: ServerRoute,
    as: A.Type,
    file: StaticString = #file,
    line: UInt = #line
  ) async throws -> A {
    let (data, _) = try await self.request(route: route, file: file, line: line)
    do {
      return try apiDecode(A.self, from: data)
    } catch {
      throw ApiError(error: error, file: file, line: line)
    }
  }

  // ...  
}

extension ApiClient {
  // ...

  public mutating func override(
    route matchingRoute: ServerRoute.Api.Route,
    withResponse response: @escaping @Sendable () async throws -> (Data, URLResponse)
  ) {
    let fulfill = expectation(description: "route")
    self.apiRequest = { @Sendable [self] route in
      if route == matchingRoute {
        fulfill()
        return try await response()
      } else {
        return try await self.apiRequest(route)
      }
    }
  }

  public mutating func override<Value>(
    routeCase matchingRoute: CasePath<ServerRoute.Api.Route, Value>,
    withResponse response: @escaping @Sendable (Value) async throws -> (Data, URLResponse)
  ) {
    let fulfill = expectation(description: "route")
    self.apiRequest = { @Sendable [self] route in
      if let value = matchingRoute.extract(from: route) {
        fulfill()
        return try await response(value)
      } else {
        return try await self.apiRequest(route)
      }
    }
  }
}

$0.apiClient = {
  var apiClient = ApiClient.noop
  apiClient.override(
    routeCase: /ServerRoute.Api.Route.changelog(build:),
    withResponse: { _ in
      try await OK(
       update(Changelog.current) {
         $0.changes.append(
           Changelog.Change(
             version: "1.0",
             build: 60,
             log: "We launched!"
           )
         )
       }
     )
   }
 )
 return apiClient
}()

#if DEBUG
  import Foundation

  public func OK<A: Encodable>(
    _ value: A, encoder: JSONEncoder = .init()
  ) async throws -> (Data, URLResponse) {
    (
      try encoder.encode(value),
      HTTPURLResponse(
        url: URL(string: "/")!, statusCode: 200, httpVersion: nil, headerFields: nil)!
    )
  }

  public func OK(_ jsonObject: Any) async throws -> (Data, URLResponse) {
    (
      try JSONSerialization.data(withJSONObject: jsonObject, options: []),
      HTTPURLResponse(
        url: URL(string: "/")!, statusCode: 200, httpVersion: nil, headerFields: nil)!
    )
  }
#endif

extension ApiClient: DependencyKey {
  public static let liveValue = Self.live(
    sha256: { Data(SHA256.hash(data: $0)) }
  )

  public static func live(
    baseUrl defaultBaseUrl: URL = URL(string: "http://localhost:9876")!,
    sha256: @escaping (Data) -> Data
  ) -> Self {
    #if DEBUG
      let baseUrl = UserDefaults.standard.url(forKey: baseUrlKey) ?? defaultBaseUrl
    #else
      let baseUrl = URL(string: "https://www.isowords.xyz")!
    #endif

    let router = ServerRouter(
      date: Date.init,
      decoder: decoder,
      encoder: encoder,
      secrets: secrets.split(separator: ",").map(String.init),
      sha256: sha256
    )

    actor Session {
      nonisolated let baseUrl: Isolated<URL>
      nonisolated let currentPlayer: Isolated<CurrentPlayerEnvelope?>
      private let router: ServerRouter

      // ...
    }

    let session = Session(baseUrl: baseUrl, router: router)

    return Self(
      apiRequest: { try await session.apiRequest(route: $0) },
      authenticate: { try await session.authenticate(request: $0) },
      baseUrl: { session.baseUrl.value },
      currentPlayer: { session.currentPlayer.value },
      logout: { await session.logout() },
      refreshCurrentPlayer: { try await session.refreshCurrentPlayer() },
      request: { try await session.request(route: $0) },
      setBaseUrl: { await session.setBaseUrl($0) }
    )
  }
}

// ...