Nexio

Lightweight, actor-based Swift networking SDK

Swift Platforms SPM License CI codecov

Typed JSON requests · Auth strategies · Retry with backoff · Interceptor pipeline · SwiftUI image loading · Zero dependencies

Features

Installation

Swift Package Manager

// Package.swift
dependencies: [
 .package(url: "https://github.com/ANSCoder/Nexio", from: "1.0.0")
],
targets: [
 .target(name: "YourApp", dependencies: [
 .product(name: "Nexio", package: "Nexio")
 ])
]

Quick Start

Configure once at app launch

// AppDelegate / App.init
var config = NexioConfig()
config.baseURL = URL(string: "https://api.example.com")
config.timeout = 15
config.retry = .standard // 3 attempts, exponential backoff
config.logLevel = .errors
await NexioClient.shared.configure(config)
await NexioClient.shared.setAuth(.bearer("your-token"))

Make typed requests

// GET — decodes JSON automatically
let users: [User] = try await NexioClient.shared.get("/users")
// POST with body
let body = CreateUserRequest(name: "Alice")
let created: User = try await NexioClient.shared.post("/users", body: body)
// PUT / PATCH / DELETE
let updated: User = try await NexioClient.shared.put("/users/42", body: changes)
try await NexioClient.shared.delete("/users/42")
// Absolute URLs work too (ignores baseURL)
let user: User = try await NexioClient.shared.get("https://api.example.com/users/1")

Top-level shortcuts

// Shorthand for NexioClient.shared.get / .post
let users: [User] = try await nexioGet("/users")
let created: User = try await nexioPost("/users", body: newUser)

Authentication

// Static bearer token
await NexioClient.shared.setAuth(.bearer("jwt-token"))
// API key in a custom header
await NexioClient.shared.setAuth(.apiKey(header: "X-Api-Key", value: "secret"))
// Arbitrary headers
await NexioClient.shared.setAuth(.custom(["X-Tenant-ID": "acme", "X-Version": "2"]))
// Dynamic token — closure called before every request (ideal for OAuth refresh)
let authInterceptor = AuthInterceptor {
 await TokenStore.shared.currentToken() // returns AuthStrategy
}
await NexioClient.shared.addInterceptor(authInterceptor)

Per-endpoint auth override

struct PublicEndpoint: Endpoint {
 var baseURL: URL { URL(string: "https://api.example.com")! }
 var path: String { "/status" }
 var method: HTTPMethod { .get }
 var auth: AuthStrategy? { .some(.none) } // skip global auth for this request
}

Type-Safe Endpoints

struct GetUser: Endpoint {
 let id: Int
 var baseURL: URL { URL(string: "https://api.example.com")! }
 var path: String { "/users/\(id)" }
 var method: HTTPMethod { .get }
}
struct SearchUsers: Endpoint {
 let query: String
 var baseURL: URL { URL(string: "https://api.example.com")! }
 var path: String { "/users/search" }
 var method: HTTPMethod { .get }
 var queryItems: [URLQueryItem] { [URLQueryItem(name: "q", value: query)] }
}
let user: User = try await NexioClient.shared.request(GetUser(id: 42))
let results: [User] = try await NexioClient.shared.request(SearchUsers(query: "alice"))

Retry

// Via config (recommended — applied automatically)
config.retry = .standard // 3 retries, exponential backoff
config.retry = RetryPolicy(maxAttempts: 5,
 backoff: .linear(seconds: 2)) // custom
// Via interceptor (for per-client or programmatic control)
await NexioClient.shared.addInterceptor(
 RetryInterceptor(policy: .standard)
)

Interceptors

struct LoggingInterceptor: Interceptor {
 func adapt(_ request: URLRequest, for session: URLSession) async throws -> URLRequest {
 print("→ \(request.httpMethod ?? "")\(request.url?.absoluteString ?? "")")
 return request
 }
 func retry(_ request: URLRequest, dueTo error: NexioError, attempt: Int) async -> Bool {
 false
 }
}
await NexioClient.shared.addInterceptor(LoggingInterceptor())

Error Handling

do {
 let user: User = try await NexioClient.shared.get("/users/1")
} catch NexioError.unauthorized {
 // Redirect to login
} catch NexioError.notFound {
 // Show 404 UI
} catch NexioError.noInternet {
 // Show offline banner
} catch NexioError.serverError(let statusCode, let data) {
 // Handle 5xx
} catch NexioError.decodingFailed(let underlying, let data) {
 // Log raw response for debugging
 print(String(data: data, encoding: .utf8) ?? "")
} catch NexioError.invalidURL(let string) {
 // Bad URL at call site
}

Image Loading (SwiftUI)

// Default — gray placeholder, photo icon on failure
NexioImage("https://cdn.example.com/photo.jpg")
 .frame(width: 100, height: 100)
 .clipShape(Circle())
// Custom placeholder and failure views
NexioImage(
 "https://cdn.example.com/photo.jpg",
 placeholder: { ProgressView() },
 failureImage: { Image(systemName: "person.crop.circle.fill") }
)
// Prefetch a list for smoother scroll performance
let urls = items.compactMap { URL(string: 0ドル.imageURL) }
await ImageLoader.shared.prefetch(urls)
// Clear cache
await ImageLoader.shared.clearCache()

Concurrency

// Three requests in flight simultaneously
async let users: [User] = NexioClient.shared.get("/users")
async let posts: [Post] = NexioClient.shared.get("/posts")
async let comments: [Comment] = NexioClient.shared.get("/comments")
let (u, p, c) = try await (users, posts, comments)

Testing

var config = NexioConfig()
config.protocolClasses = [MockURLProtocol.self]
await client.configure(config)

Requirements

License