Swift 2 is coming! I think redesigning APIKit for Swift 2 is necessary to take full advantage of it.

• protocol extension makes Reuqest protocol more flexilble.
• ErrorType is useful to express errors in APIKit.
• do-try-catch introduced easier error handling model (if process is synchronous).

Here are tasks:

• [x] Move default configuration of request to extension of Request.
• [x] Detailed and comprehensive errors using ErrorType.
• [x] Adopt do-try-catch in synchronous error handling.

Any comments are welcome.

This PR implements a mechanism to intercept each requests for following purposes:

• Insert common operations before/after each requests.
• Manage network indicator visibility.

An interceptor type looks like below:

class MyRequestInterceptor: RequestInterceptorType {
    func interceptBeforeRequest<T: RequestType>(request: T) {
        /* To be called before each requests */
    }

    func interceptAfterRequest<T: RequestType>(request: T, result: Result<T.Response, APIError>) {
        /* To be called after each requests */
    }
}

Then, append its instance to requestInterceptors of an instance of Session:

let session = /* Get the session to add interceptors. */
session.requestInterceptors.append(interceptor)

Users of APIKit may want to implement delegate methods of NSURLSession to hook events or to handle authentication challenge, so I think we have to provide instances for each subclasses of API and re-implement wrapper of NSURLSession using delegate methods (not block). Currently, an instance of API subclass is provided as a singleton because I would like to keep interface simple and multiple clients are not necessary for one web API.

@ikesyo how do you think?

Hey there,

I have a specific requirement for my app that I'm working on. The API web service uses JSON Web Tokens. It requires me to pass in a valid x-session-token header for each protected API endpoint.

These session tokens expire every 24h, which means I need to reauthenticate and retry my existing request. Is that currently possible with APIKit? I've seen some PRs about interceptors for version 2.0 but I'm not sure if that's what I need.

Here's an example of what I mean: Let's say I need to call the GET /user endpoint of my API and it requires me to pass in a valid x-session-token in the header. If the token has expired, I will get an error response, something like this:

success: false, error: {
    code = E1100;
    hint = Token;
    message = "Session token has expired.";
}

Now whenever I get an error response with the error.code == "E1100", what I want to do is, automatically call the POST /authenticate_session endpoint, get the new session token and automatically retry the GET /user request with the updated x-session-token header.

Can you point me in the right direction of how I could best implement this with APIKit?

I'm currently using a different API library for my app and it's proving to be a pain (I'm literally at the point of where I'm trying to fight and go against how the framework was intended to work). Before I start implementing my API logic from scratch, I'm exploring my options and would like to research if I could accomplish this functionality requirement using APIKit (or any other open source library).

Thanks for your help.

以下のようなリクエストを送っています。 idsというkeyでInt型のArrayを送信したいのですが、パラメータが["(\n 672,\n 669\n)"]こういった形になってしまします。 やり方が悪いのでしょうか...? 何卒よろしくお願いします。

struct deleteImage: UserImageRequestType {
            typealias Response = Bool

            let ids:        [Int]
            let method    = HTTPMethod.DELETE
            var path:       String { return "/v1/user_images/delete" }
            var parameters: [String: AnyObject] { return ["ids": ids] }

            func responseFromObject(object: AnyObject, URLResponse: NSHTTPURLResponse) -> Response? {
                 ...
        }
}

Hi, When i use APIKit with Carthage i get some errors, this is my Cartfile github "ishkawa/APIKit" ~> 1.0

first issue is that it checks out as Checking out APIKit at "1.0.0-beta5" and i think the problem is that you changed beta5 to point style (beta.6) so it always checks out at beta5 and the second issue is that i get this error: A shell task failed with exit code 128: fatal: reference is not a tree: 2e38ee3e7a3e1dd01be31edb94368c2f4a840915

Sorry if i ask too many question here, wonder if there is any way we could get a progress when we upload a file like Alamofire upload method. Thanks 👍

Fixed parameter handling when its value is null.

For example, there are some scenarios when some_api?query=&page=1 should be replaced as some_api?query&page=1 (no query=).

Hi

Recently we are trying the use SwiftPackage of APIKit into our project. After importing, Xcode build successfully but the xcodebuild command part failed.

By looking into the log, since APIKit have this code:

#if SWIFT_PACKAGE
    class AbstractInputStream: InputStream {
        init() {
            super.init(data: Data())
        }
    }
#endif

and the overriding & super related code failed. It looks like it cannot be archive the correct super one.

I would be appreciate if you could tell me how we could fix it.

Best regards

Here is the script of the failed log:

❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:170:22: property does not override any property from its superclass

        override var hasBytesAvailable: Bool {
                                      ^~~~~~~~~~~~~~



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:174:23: method does not override any method from its superclass

        override func read(_ buffer: UnsafeMutablePointer<UInt8>, maxLength: Int) -> Int {
        ~~~~~~~~     ^



❌  SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:127:37: use of undeclared type 'AbstractInputStream'

    internal class PartInputStream: AbstractInputStream {
        ~~~~~~~~      ^



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:259:22: property does not override any property from its superclass

        override var streamStatus: Stream.Status {
                                    ^~~~~~~~~~~~~~~~~~~



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:263:22: property does not override any property from its superclass

        override var hasBytesAvailable: Bool {
        ~~~~~~~~     ^



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:267:23: method does not override any method from its superclass

        override func open() {
        ~~~~~~~~     ^



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:271:23: method does not override any method from its superclass

        override func close() {
        ~~~~~~~~      ^



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:275:23: method does not override any method from its superclass

        override func read(_ buffer: UnsafeMutablePointer<UInt8>, maxLength: Int) -> Int {
        ~~~~~~~~      ^



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:315:22: property does not override any property from its superclass

        override var delegate: StreamDelegate? {
        ~~~~~~~~      ^



❌ SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:320:23: method does not override any method from its superclass

        override func schedule(in aRunLoop: RunLoop, forMode mode: RunLoop.Mode) {
        ~~~~~~~~     ^



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:324:23: method does not override any method from its superclass

        override func remove(from aRunLoop: RunLoop, forMode mode: RunLoop.Mode) {
        ~~~~~~~~      ^



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:215:42: use of undeclared type 'AbstractInputStream'

    internal class MultipartInputStream: AbstractInputStream {
        ~~~~~~~~      ^



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:51:33: cannot convert value of type 'MultipartFormDataBodyParameters.MultipartInputStream' to expected argument type 'InputStream'

            return .inputStream(inputStream)
                                         ^~~~~~~~~~~~~~~~~~~



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:54:48: cannot convert value of type 'MultipartFormDataBodyParameters.MultipartInputStream' to expected argument type 'InputStream'

            return .data(try Data(inputStream: inputStream))
                                ^~~~~~~~~~~



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:154:13: 'super' members cannot be referenced in a root class

            super.init()
                                               ^~~~~~~~~~~



❌  /SourcePackages/checkouts/APIKit/Sources/APIKit/BodyParameters/MultipartFormDataBodyParameters.swift:231:13: 'super' members cannot be referenced in a root class

            super.init()

Hi, there.

RunLoopMode is remated to RunLoop.Mode at Swift4.2

In MultipartFormDataBodyParameters.swift: I think these functions

    override func schedule(in aRunLoop: RunLoop, forMode mode: RunLoopMode) {

    }

    override func remove(from aRunLoop: RunLoop, forMode mode: RunLoopMode) {

    }

should be

    #if swift(>=4.2)
    override func schedule(in aRunLoop: RunLoop, forMode mode: RunLoop.Mode) {

    }

    override func remove(from aRunLoop: RunLoop, forMode mode: RunLoop.Mode) {

    }
   #else 
    override func schedule(in aRunLoop: RunLoop, forMode mode: RunLoopMode) {

    }

    override func remove(from aRunLoop: RunLoop, forMode mode: RunLoopMode) {

    }
   #endif

Thanks

This resolves #13. This change makes implementation simpler and more obvious.

• Add defaultURLSession that has a delegate with minimal implementation of NSURLSessionDataDelegate.
• Remove instance pair, which is singleton instance pair of API and NSURLSession.

Breaking changes:

• API does not creates singleton instances for each API subclasses. If an API subclass needs a separated session, defaultURLSession should be overrided.
• API.instance is no longer available.
• API.session is no longer available.
• Delegate methods implemented in API should be moved to custom delegate class, and its instance should be set to delegate of defaultURLSession.

See the discussion on #13 for more details.

This problem occurred on MultipartFormDataBodyParameters.Part(data: Data).

The declaration code was like below:

struct MyFormRequest: Request {
    let baseURL = URL(string: "https://example.com/")!

    let method: HTTPMethod = .get

    let path = "/"

    typealias Response = Void

    private let parts: [MultipartFormDataBodyParameters.Part]

    init(images: [UIImage]) throws {
        parts = try images.map {
            guard let data = $0.jpegData() else { throw AppError.invalidSession }
            return data
            }.enumerated().map { (i, data) in
                MultipartFormDataBodyParameters.Part(
                    data: data,
                    name: "images[]",
                    mimeType: "image/jpeg",
                    fileName: "imagae\(i).jpg")
        }
    }
    var bodyParameters: BodyParameters? {
        return MultipartFormDataBodyParameters(
            parts: parts,
            boundary: "0123456789abcdef")
    }

    func response(from object: Any, urlResponse: HTTPURLResponse) throws {
    }
}

Then, call it like below:

func execute(images: [UIImage]) {
   let request = MyFormRequest(images: images)
   Session.send(request: request) { result in
    if case .success = result { return }
    // retry the request. (with the same instance)
    Session.send(request: request) { result2 in
       // it will be never success or failure!!!
    }
   }
}

I noticed this problem occured because of the class MultipartFormDataBodyParameters reads InputStream without rewinding or renewing stream.

# MultipartFormDataBodyParameters.swift:

                case bodyRange:
                    if bodyPart.inputStream.streamStatus == .notOpen {
                        bodyPart.inputStream.open()
                    }

                    // this line never finished when calling `read` twice on same instance.
                    let readLength = bodyPart.inputStream.read(offsetBuffer, maxLength: availableLength) 

                    sentLength += readLength
                    totalSentLength += readLength

So I resolved it by changing Request class like below finally.

struct MyFormRequest: Request {
    let baseURL = URL(string: "https://example.com/")!

    let method: HTTPMethod = .get

    let path = "/"

    typealias Response = Void

    private let images: [Data] 

    init(images: [UIImage]) throws {
        images = try images.map {
            guard let data = $0.jpegData() else { throw AppError.invalidSession }
            return data
            }
        // Do not create Part instance while initialization.
    }
    var bodyParameters: BodyParameters? {
       // Recreate part instance for each request.
       let parts = images.enumerated().map { (i, data) in
                MultipartFormDataBodyParameters.Part(
                    data: data,
                    name: "images[]",
                    mimeType: "image/jpeg",
                    fileName: "imagae\(i).jpg")
        }
        return MultipartFormDataBodyParameters(
            parts: parts,
            boundary: "0123456789abcdef")
    }

    func response(from object: Any, urlResponse: HTTPURLResponse) throws {
    }
}

To begin with, I think the request instance should not be reuse. But in our project, we have to reuse it. (We wrap APIKit with RxSwift. When the retryable error (network connection error or somethink) occurred, to retry the request, we have to re-subscribe the same stream(Observable) with same request instance)

I hope this post can help someone.

Environment: APIKit version 4.0.0, iOS 12.1.4, Xcode 10.2.1(10E1001)

I'm trying to update an app that depended on APIKit 4.0.0-beta.1 (swift 3) to current swift version. The app is using progressHandler. However, 4.0.0-beta.1 tag is on develop/4.0 branch. It seems that the branch is not merged into master and latest release tag 5.0.0.

Currently if user calls Session.send(request) without setting the callback queue, it will use main thread for processing the callback.

But APIKit, in layered architecture designing, should be in the infrastructure layer or persistence layer; And on the other side, main queue in iOS, since it mainly handles UI process, is usually considered in the UI layer.

Therefore, it's probably not a good idea to let APIKit know about the main queue. it's a UI world thing, which an infrastructure world thing probably should not know.

And by using main queue, which may also be used by any object in the program, as the default queue, it's very easy to cause a deadlock if a user tries to use a semaphore to stop current thread until the response received.

So my opinion is that in Session's initializer, maybe it's better to set the default value of callbackQueue to DispatchQueue.global() or DispatchQueue(label: someLabel)

Thanks for considering this issue.

Hi

I found this exception in Crashlytics crash logs from my production app. I can reproduce and paste it bellow. But I cannot find how to fix it. So, I just report this.

*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '*** -propertyForKey: only defined for abstract class.  Define -[_TtCV6APIKit31MultipartFormDataBodyParameters20MultipartInputStream propertyForKey:]!'

• Xcode 8.3.3
• iOS 10.3 SDK
• iPhone Plus (iOS 10.3 simulator)

import UIKit
import APIKit

protocol HttpBinRequest: Request {

}

extension HttpBinRequest {
    var baseURL: URL {
        return URL(string: "https://httpbin.org")!
    }
}

struct PostRequest: HttpBinRequest {
    typealias Response = Any

    var method: HTTPMethod {
        return .post
    }

    var path: String {
        return "/post"
    }

    var bodyParameters: BodyParameters? {
        let p = try! MultipartFormDataBodyParameters.Part(
            value: "value",
            name: "name"
        )

        return MultipartFormDataBodyParameters(parts: [p], entityType: .inputStream)
    }

    func response(from object: Any, urlResponse: HTTPURLResponse) throws -> Response {
        return object
    }
}

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

        let request = PostRequest()

        Session.send(request) { result in
            print(result)
            switch result {
            case .success(let response):
                print(response)
            case .failure(let error):
                print("error: \(error)")
            }
        }
    }
}