Creating a Swift Download Dependency with AsyncThrowingStream

In this post, we’ll walk through how to create a modular, testable download client in Swift using AsyncThrowingStream, @DependencyClient, and a throttled progress mechanism.

Why AsyncThrowingStream?

AsyncThrowingStream allows you to emit values over time, which makes it a great fit for use cases like downloading files and reporting progress or errors as they occur.

Step 1: Define the DownloadClient

We define a dependency client using the new @DependencyClient macro:

import Dependencies
import DependenciesMacros
import CasePaths
import Foundation

@DependencyClient
struct DownloadClient {
  var download: @Sendable (_ url: URL) -> AsyncThrowingStream<Event, any Error> = { _ in .finished() }

  @CasePathable
  enum Event: Equatable {
    case response(Data)
    case updateProgress(Double)
  }
}

Step 2: Add it to DependencyValues

This enables access via @Dependency(\.downloadClient):

extension DependencyValues {
  var downloadClient: DownloadClient {
    get { self[DownloadClient.self] }
    set { self[DownloadClient.self] = newValue }
  }
}

Step 3: Implement the Live Client

This is the real implementation using URLSession.shared.bytes:

extension DownloadClient: DependencyKey {
  static var liveValue: DownloadClient {
    .production
  }

  static var production: DownloadClient {
    .init { url in
      .init { continuation in
        Task {
          do {
            let (bytes, response) = try await URLSession.shared.bytes(from: url)
            var data = Data()
            var progress = 0
            for try await byte in bytes {
              data.append(byte)
              let newProgress = Int(Double(data.count) / Double(response.expectedContentLength) * 100)
              if newProgress != progress {
                progress = newProgress
                continuation.yield(.updateProgress(Double(progress) / 100))
              }
            }
            continuation.yield(.response(data))
            continuation.finish()
          } catch {
            continuation.finish(throwing: error)
          }
        }
      }
    }
  }

Step 4: Add Mocks for Preview and Test

  static var previewValue: DownloadClient { .mock }
  static var testValue: DownloadClient { .mock }

  static var mock: DownloadClient {
    .init { _ in .finished() }
  }
}

Throttle Progress Updates

We reduce UI work by only emitting progress when the integer percent changes:

let newProgress = Int(Double(data.count) / Double(response.expectedContentLength) * 100)
if newProgress != progress {
  progress = newProgress
  continuation.yield(.updateProgress(Double(progress) / 100))
}

This avoids flooding the UI with updates like 0.231 → 0.232 → 0.233... and instead yields at most 100 clean updates from 0.00 → 1.00.

Example Usage

@Dependency(\.downloadClient) var downloadClient

func startDownload(from url: URL) async {
  do {
    for try await event in downloadClient.download(url) {
      switch event {
      case let .updateProgress(value):
        print("Progress: \(Int(value * 100))%")
      case let .response(data):
        print("Download completed, size: \(data.count) bytes")
      }
    }
  } catch {
    print("Download failed: \(error.localizedDescription)")
  }
}

---

Full Source Code

import Dependencies
import DependenciesMacros
import CasePaths
import Foundation

@DependencyClient
struct DownloadClient {
  var download: @Sendable (_ url: URL) -> AsyncThrowingStream<Event, any Error> = { _ in .finished() }

  @CasePathable
  enum Event: Equatable {
    case response(Data)
    case updateProgress(Double)
  }
}

extension DependencyValues {
  var downloadClient: DownloadClient {
    get { self[DownloadClient.self] }
    set { self[DownloadClient.self] = newValue }
  }
}

extension DownloadClient: DependencyKey {
  static var liveValue: DownloadClient { .production }

  static var production: DownloadClient {
    .init { url in
      .init { continuation in
        Task {
          do {
            let (bytes, response) = try await URLSession.shared.bytes(from: url)
            var data = Data()
            var progress = 0
            for try await byte in bytes {
              data.append(byte)
              let newProgress = Int(Double(data.count) / Double(response.expectedContentLength) * 100)
              if newProgress != progress {
                progress = newProgress
                continuation.yield(.updateProgress(Double(progress) / 100))
              }
            }
            continuation.yield(.response(data))
            continuation.finish()
          } catch {
            continuation.finish(throwing: error)
          }
        }
      }
    }
  }

  static var previewValue: DownloadClient { .mock }
  static var testValue: DownloadClient { .mock }

  static var mock: DownloadClient {
    .init { _ in .finished() }
  }
}

This approach makes your download logic modular, testable, and optimized for UI responsiveness. Perfect for SwiftUI + TCA projects.