Moya async request with handling cancellation

MoyaProvider+Extension.swift

import Foundation
import Moya

struct AsyncRequestError: Error { 
    // TODO: add Description
}

extension MoyaProvider {
    // method #1 - using AsyncThrowingStream
    func request(_ target: Target) async throws -> Response {
        let stream = AsyncThrowingStream<Response, Error> { continuation in
            var didFinish = false
            let cancellable = request(target) {
                switch $0 {
                case .success(let response):
                    continuation.yield(response)
                    didFinish = true
                    continuation.finish()
                case .failure(let error):
                    didFinish = true
                    continuation.finish(throwing: error)
                }
            }

            @Sendable func cancel() {
                cancellable.cancel()
            }

            continuation.onTermination = { [didFinish] termination in
                switch termination {
                case .cancelled where !didFinish:
                    cancel()
                default:
                    break
                }
            }
        }

        let response = try await {
            var response: Response?
            for try await element in stream {
                guard response == nil else { continue }
                response = element
            }
            return response
        }()
        // NOTE: should handle this optional case properly since the sequence can be empty
        guard let response else { throw AsyncRequestError() }
        return response
    }

    // method #2 - using withTaskCancellationHandler & withCheckedThrowingContinuation
    func request(_ target: Target) async throws -> Response {
        let lock = NSLock()

        var checkedContinuation: CheckedContinuation<Response, Error>?
        var result: Result<Response, MoyaError>?

        let cancellable = request(target) {
            lock.lock()
            if let checkedContinuation {
                checkedContinuation.resume(with: $0)
            } else {
                result = $0
            }
            lock.unlock()
        }

        @Sendable func cancel() {
            cancellable.cancel()
        }

        return try await withTaskCancellationHandler {
            try await withCheckedThrowingContinuation { continuation in
                lock.lock()
                if let result {
                    continuation.resume(with: result)
                } else {
                    checkedContinuation = continuation
                }
                lock.unlock()
            }
        } onCancel: { cancel() }
    }
}