A networking layer based on a declarative interface written in Swift

public extension Request {
    /// An enum listing an error.
    enum DeleteError: Swift.Error { case invalid }
    
    /// Delete one of your own posts, matching `identifier`.
    /// Checkout https://github.com/sbertix/Swiftagram for more info.
    ///
    /// - parameter identifier: String
    /// - returns: A locked `AnyObservable`, waiting for authentication `HTTPCookie`s.
    func delete<R: Requester>(_ identifier: String) -> Providers.LockRequester<[HTTPCookie], R, R.Requested<Bool>> {
        // Wait for user defined values.
        .init { cookies, requester in
            // Fetch first info about the post to learn if it's a video or picture
            // as they have slightly different endpoints for deletion.
            Request("https://i.instagram.com/api/v1/media")
                .path(appending: identifier)
                .info   // Equal to `.path(appending: "info")`.
                // Wait for the user to `inject` an array of `HTTPCookie`s.
                // You should implement your own `model` to abstract away
                // authentication cookies, but as this is just an example
                // we leave it to you.
                .header(appending: HTTPCookie.requestHeaderFields(with: cookies))
                // Prepare for the actual request.
                .prepare(with: requester)
                // Check it returned a valid media.
                .map(\.data)
                // Decode it inside a `Wrapper`, allowing to interrogate JSON
                // representations of object without knowing them in advance.
                // (It's literally the missing `AnyCodable`).
                .decode()
                // Switch to a new request.
                .switch { wrapper throws -> R.Requested<Bool> in
                    guard let type = wrapper["items"][0].mediaType.int(),
                          [1, 2, 8].contains(type) else {
                        throw DeleteError.invalid
                    }
                    // Actually delete it now that we have all data.
                    return Request("https://i.instagram.com/api/v1/media")
                        .path(appending: identifier)
                        .path(appending: "delete/")
                        .query(appending: type == 2 ? "VIDEO" : "PHOTO", forKey: "media_type")
                        // This will be applied exactly as before, but you can add whaterver
                        // you need to it, as it will only affect this `Request`.
                        .header(appending: HTTPCookie.requestHeaderFields(with: cookies))
                        // Create the `Publisher`.
                        .prepare(with: requester)
                        .map(\.data)
                        .decode()
                        .map { $0.status == "ok" }
                        .requested(by: requester)
                }
                .requested(by: requester)
        }
    }
}

/// A valid post identifier.
let identifier: String = /* a valid String */
/// A valid array of cookies.
let cookies: [HTTPCookie] = /* an array of HTTPCookies */
/// A *retained* collection of `AnyCancellable`s.
var bin: Set<AnyCancellable> = []

/// Delete it using completion handlers.
Request.delete(identifier)
    .unlock(with: cookies)
    .prepare(with: URLSessionCompletionRequester(session: .shared))
    .onSuccess { _ in } onFailure: { _ in }
    .resume()
    
[…]

/// Delete it using **Combine**.
Request.delete(identifier)
    .unlock(with: cookies)
    .prepare(with: URLSessionCombineRequester(session: .shared))    
    .sink { _ in } receiveValue: { print($0) }
    .store(in: &bin)

[…]

/// Delete it using _async/await_.
let result = try await Request.delete(identifier)
    .unlock(with: cookies)
    .prepare(with: .async(session: .shared))