YoullNetwork

BricksNetwork.shared
  ├── Apollo GraphQL
  │   ├── ApolloMission (query/mutation wrapper)
  │   ├── LandingModule (JSON parsing bridge)
  │   ├── Response Models (DecodableResponse protocol)
  │   └── 55 queries, 23 mutations, 22+ fragments
  │
  └── REST (async/await HTTP methods)
      ├── get / post / patch / put / delete
      └── URL construction + token injection

// BricksNetwork.swift
public class BricksNetwork: @unchecked Sendable {

    public nonisolated(unsafe) static var shared: BricksNetwork?

    let environment: Environment
    lazy var apollo: ApolloClient = makeApolloClient()
    lazy var cachePolicy: CachePolicy = .fetchIgnoringCacheCompletely
    weak var dataSource: BricksNetworkDataSource?
    var queue = DispatchQueue.global(qos: .userInitiated)
    public var extraLang: String = ""
    public var coreDataStore: CoreDataStore

    public static func buildNetwork(
        environment: Environment,
        dataSource: BricksNetworkDataSource? = nil,
        extraLang: String? = nil
    ) {
        BricksNetwork.shared = BricksNetwork(
            environment: environment,
            dataSource: dataSource,
            extraLang: extraLang
        )
    }
}

public struct Environment {
    let endpointURL: URL  // GraphQL (Hasura) endpoint
    let restURL: URL?     // REST API base URL

    public init(apiUrl: URL, restUrl: URL? = nil)
}

public protocol BricksNetworkDataSource: AnyObject {
    typealias Completion = (_ token: String?) -> Void

    var isLoggedIn: Bool { get }
    var accessToken: String? { get }
    var currentUserInfoHeaders: UserInfoHeaders { get }

    func requiresTokenForNetworkRequest(operation: String) -> Bool
    func refreshToken(completion: Completion?)
}

// Utils/String+Token.swift
extension String {
    var isValidJWTToken: Bool {
        // Decode base64url payload, extract "exp" claim, compare to Date()
    }
}

class UserManagementInterceptor: ApolloInterceptor {
    enum UserError: Error {
        case noUserLoggedIn
        case refreshTokenFailed
    }

    func interceptAsync<Operation: GraphQLOperation>(
        chain: RequestChain,
        request: HTTPRequest<Operation>,
        response: HTTPResponse<Operation>?,
        completion: @escaping (Result<GraphQLResult<Operation.Data>, Error>) -> Void
    ) {
        // 1. Check if this operation requires a token
        if dataSource?.requiresTokenForNetworkRequest(operation: Operation.operationName) == false {
            // Add token if available (optional), add user info headers, proceed
            chain.proceedAsync(...)
            return
        }

        // 2. Token required but missing -> error
        guard let token = dataSource?.accessToken else {
            chain.handleErrorAsync(UserError.noUserLoggedIn, ...)
            return
        }

        // 3. Token valid -> add and proceed
        if token.isValidJWTToken {
            addTokenAndProceed(token, ...)
        } else {
            // 4. Token expired -> refresh, then retry
            refreshTokenAndRetry(...)
        }
    }
}

private func createURLRequest(token: String?, path: String, ...) async throws -> URLRequest? {
    var accessToken = token ?? dataSource?.accessToken

    // If token required but missing, throw
    if accessToken == nil && requiresToken {
        throw NetworkError.missingAccessToken
    }

    // If token expired and required, refresh via async continuation
    if let isValidToken = accessToken?.isValidJWTToken, !isValidToken && requiresToken {
        accessToken = await refreshToken()
    }

    // Build request with token and headers
    ...
}

public struct UserInfoHeaders {
    let userID: String?
    let deviceID: String
    let role: String  // "user" if userID != nil, "guest" otherwise
    let appVersion: String?

    public func getUserInfoHeaders() -> [String: String] {
        var headers = ["x-hasura-role": role, "device-id": deviceID]
        if let userID { headers["x-hasura-user-id"] = userID }
        return headers
    }
}

final class ApolloMission {
    typealias Response<T> = Future<T, Error>

    // Query returning array of Decodable items
    static func launch<Q: Query, T: Decodable>(
        query: Q,
        into network: BricksNetwork,
        cachePolicy: CachePolicy? = nil
    ) -> Response<[T]>

    // Query returning array via DecodableResponse transformation
    static func launch<Q: Query, T: DecodableResponse>(
        query: Q,
        into network: BricksNetwork,
        cachePolicy: CachePolicy? = nil,
        landingModel: T.Type
    ) -> Response<[T.Model]>

    // Combined query returning single Decodable object
    static func launch<Q: Query, T: Decodable>(
        combinedQuery: Q,
        into network: BricksNetwork
    ) -> Response<T>

    // Void mutation (fire-and-forget)
    static func execute<M: Mutation>(
        mutation: M,
        into network: BricksNetwork
    ) -> Response<Void>

    // Mutation returning array
    static func execute<M: Mutation, T: Decodable>(
        mutation: M,
        into network: BricksNetwork
    ) -> Response<[T]>
}

final class LandingModule<T: Decodable> {
    static func parseQuery<Q: Query>(_ query: Q, result: QResult<Q>) -> Output<[T]> {
        // 1. Check for GraphQL errors
        if let error = resultData.errors?.first {
            return .failure(NetworkError.operationFailed)
        }
        // 2. Convert Apollo DataDict to JSON
        guard let json = resultData.data?.__data.convertToJSON() else {
            return .failure(NetworkError.invalidResponse)
        }
        // 3. Decode JSON to [T]
        return decodeObjects(from: json)
    }
}

protocol DecodableResponse where Self: Decodable {
    associatedtype Model: Any
    func model() -> Model
}

extension Array where Element: DecodableResponse {
    func mapToModels() -> [Element.Model] {
        return self.map { $0.model() }
    }
}

extension BricksNetwork {
    // With return value
    public func get<T: Codable>(path: String, queryParams: [String: String]? = nil) async throws -> T
    public func post<T: Codable>(token: String? = nil, path: String, body: Data? = nil) async throws -> T
    public func patch<T: Codable>(path: String, body: Data? = nil) async throws -> T
    public func put<T: Codable>(path: String, queryParams: [String: String], body: Data?) async throws -> T
    public func delete<T: Codable>(path: String) async throws -> T

    // Void variants (no return value)
    public func get(path: String, queryParams: [String: String]? = nil) async throws
    public func post(token: String? = nil, path: String, body: Data? = nil) async throws
    public func patch(path: String, body: Data? = nil) async throws
    public func delete(path: String) async throws
}

public struct EmptyResponse: Codable { }

public class ApiClient {
    public typealias Publisher<T> = AnyPublisher<T, Error>
}

graph LR
    A["GraphQL Response<br/>(Apollo DataDict)"] --> B["Response Model<br/>(internal, Decodable)"]
    B --> C["Domain Model<br/>(public, BN*/YN*)"]
    D["REST Response<br/>(JSON)"] --> C

// Network/API Response Models/ContentResponse.swift
class ContentResponse: Decodable {
    let id: String
    let title: String
    let body: String?
    let asset: AssetResponse
    let thumbnail: AssetResponse?
    let isLiked: Bool
    let isLocked: Bool
    // ... more fields
}

extension ContentResponse: DecodableResponse {
    typealias Model = BNItem

    func model() -> BNItem {
        let content = BNContent(
            id: id,
            title: extraLanguages?.first?.title ?? title,
            // ... maps all fields to the domain model
        )
        return .content(content)
    }
}

// Returns AnyPublisher<[BNCategory], Error>
public static func getCategories(from network: BricksNetwork) -> Publisher<[BNCategory]> {
    let query = GetContentCategoriesQuery(extraLang: network.extraLang)
    return ApolloMission.launch(query: query, into: network, landingModel: CategoryResponse.self)
        .map({ $0.mapToCategory() })
        .eraseToAnyPublisher()
}

// async throws -> YNProfile
public static func getProfile(stats: [String], from network: BricksNetwork) async throws -> YNProfile {
    let path = "/users/me"
    let profile: YNProfile = try await network.get(path: path, queryParams: [...])
    currentUser.value = profile
    return profile
}

// Combine version
public static func getProfile(stats: [String], from network: BricksNetwork) -> Publisher<YNProfile>

// async/await version
public static func getProfile(stats: [String], from network: BricksNetwork) async throws -> YNProfile

public static func getProfile(stats: [String], from network: BricksNetwork) -> Publisher<YNProfile> {
    return Future<YNProfile, Error> { promise in
        Task { @MainActor in
            do {
                let profile = try await getProfile(stats: stats, from: network)
                promise(.success(profile))
            } catch {
                promise(.failure(error))
            }
        }
    }.eraseToAnyPublisher()
}

public enum NetworkError: Error {
    case operationFailed      // GraphQL returned errors in the response
    case invalidRequest       // Could not construct the request (missing REST URL, etc.)
    case invalidResponse      // HTTP status code outside 200-299
    case invalidData          // JSON decoding failed
    case missingAccessToken   // Token required but not available
    case emptyResponse        // Empty data received (unused in practice)
}

let sqliteFileURL = documentsURL.appendingPathComponent("test_apollo_db.sqlite")
if let sqliteCache = try? SQLiteNormalizedCache(fileURL: sqliteFileURL) {
    store = ApolloStore(cache: sqliteCache)
} else {
    store = ApolloStore()  // Falls back to in-memory cache
}

public class CoreDataStore {
    public func fetch<T>(_ type: T.Type, predicate: NSPredicate?, ...) -> [T]?
    public func saveInBackground(task: @escaping (NSManagedObjectContext) -> Void)
    public func deleteAll()
}

public class NetworkReachability {
    public var reachablePublisher = CurrentValueSubject<Bool, Never>(false)
    public var reachable: Bool { reachablePublisher.value }

    nonisolated(unsafe) public static let shared = NetworkReachability()
}

let query = GetContentCategoriesQuery(extraLang: network.extraLang)

ApolloMission.launch(query: query, into: network, cachePolicy: .returnCacheDataAndFetch)