The protocol-oriented networking engine for Swift.

let config = NetworkConfiguration(baseURL: "https://api.acme.com")
let client = NetworkClient(configuration: config)
let profile: UserProfile = try await client.request(GetProfileEndpoint())

struct ListUsersEndpoint: Endpoint {
    typealias Response = [User]
    var path: String { "/v1/users" }
    var method: HTTPMethod { .get }
    var queryItems: [URLQueryItem]? { [URLQueryItem(name: "limit", value: "25")] }
    var authRequirement: AuthRequirement { .bearer }
}

var config = NetworkConfiguration(baseURL: "https://api.acme.com")
config.timeoutInterval = 30.0
config.retry = .standard
config.cache = CacheConfiguration(store: DiskCacheStore(), defaultPolicy: .cacheFirst)
config.sslPinning = .publicKeys(["sha256/k2v657xMp4bCWqJaQDZrU3J38RxQL0WPSnguE/9czoq="])

// JSON payload with custom encoder
var body = RequestBody.json(DraftPost(title: "Hello World"))

// Multipart payload
var body = RequestBody.multipart(form)

do {
    let result = try await client.request(endpoint)
} catch let NetworkError.httpError(statusCode, data, context) {
    print("HTTP \(statusCode) failed on \(context.requestURL)")
} catch NetworkError.sslPinningFailed(let host) {
    print("Untrusted certificate on \(host)")
}

let manager = TokenManager(
    storage: KeychainTokenStorage(service: "com.acme.app"),
    refreshHandler: { expiredToken in
        try await authClient.refreshToken(expiredToken)
    }
)
let token = try await manager.validAccessToken()

let storage = KeychainTokenStorage(
    service: "com.acme.app",
    accessibility: .afterFirstUnlockThisDeviceOnly
)

let auth = BearerAuth {
    try await tokenManager.validAccessToken()
}

let flow = AuthorizationCodeFlow(
    clientId: "mobile-client",
    authorizeURL: URL(string: "https://auth.acme.com/authorize")!,
    tokenURL: URL(string: "https://auth.acme.com/token")!,
    redirectURI: URL(string: "acme://callback")!,
    scopes: ["openid", "profile", "offline_access"]
)
let (authURL, verifier, state) = flow.makeAuthorizationURL()

let pinning = SSLPinningConfiguration(
    pinnedHashes: [
        "api.acme.com": ["sha256/k2v657xMp4bCWqJaQDZrU3J38RxQL0WPSnguE/9czoq="]
    ],
    allowBackupKeys: true
)

// Configured for you when NetworkConfiguration.sslPinning is set:
let config = NetworkConfiguration(
    environment: env,
    sslPinning: .publicKeys(["api.acme.com": ["sha256/AAAA...", "sha256/BBBB..."]])
)

let diskCache = DiskCacheStore(directory: cacheDirURL, limitBytes: 100_000_000)
await diskCache.setValue(cachedResponse, forKey: "sha256_hash")

public enum CachePolicy {
    case ignoreCache
    case networkOnly
    case cacheFirst
    case networkFirst
    case cacheOnly
    case staleWhileRevalidate
}

let offlineQueue = OfflineRequestQueue(store: FileOfflineStore(), client: client, monitor: monitor)
let queueID = try await offlineQueue.enqueue(CreateOrderEndpoint(order: newOrder))

let store = FileOfflineStore(directory: offlineSpoolURL)

let policy = RetryPolicy(
    maxRetries: 3,
    backoff: ExponentialBackoff(initialDelay: 0.5, maxDelay: 8.0, jitter: .full),
    retryableStatusCodes: [408, 429, 500, 502, 503, 504]
)

let config = NetworkConfiguration(
    environment: env,
    redactedHeaders: ["x-api-key"],
    redactedBodyKeys: ["password", "otp"]
)

let monitor = PathNetworkMonitor()
for await status in monitor.statusStream {
    if status.isConnected {
        print("Connected via \(status.connectionType)")
    }
}

var form = MultipartFormData()
form.append(value: "Husnain", name: "author")
form.append(fileData: imageBytes, name: "avatar", fileName: "profile.png", mimeType: "image/png")
let (bodyData, boundary) = form.build()

for try await event in client.upload(UploadAvatarEndpoint(), from: avatarFileURL) {
    print("Uploaded \(event.bytesTransferred) of \(event.totalBytes) bytes (\(Int(event.fractionCompleted * 100))%)")
}

struct SignRequest: RequestInterceptor {
    func adapt(_ request: URLRequest, for endpoint: AnyEndpoint) async throws -> URLRequest {
        var r = request
        r.setValue(sign(r), forHTTPHeaderField: "X-Signature")
        return r
    }
}

struct Checkout: Endpoint {
    typealias Response = Receipt
    var path: String { "/checkout" }
    var priority: RequestPriority { .high }
}

for try await page in client.paginate(ListTransactionsEndpoint(cursor: nil)) {
    print("Page received with \(page.count) items")
}

let mock = MockNetworkTransport()
mock.registerStub(for: GetProfileEndpoint.self, result: .success(UserProfile.mock))
let client = NetworkClient(configuration: .mock, transport: mock)

@Observable @MainActor
final class ProfileViewModel {
    let user = NetworkResource<UserProfile>(client: client)
    
    func onAppear() async {
        await user.load(GetProfileEndpoint())
    }
}