[Update] Change APIParameterBuilder from block to struct type

Also contains several changes, see 1.1.0 release note for details

Author: rakuyoMo

Demo.playground/Pages/Basic.xcplaygroundpage/Contents.swift

@@ -42,27 +42,19 @@ extension BasicAPI {
     /// The full api address is: [](https://postman-echo.com/post) .
     /// The api is entered as a **tuple** type and requires two parameters, where the second parameter can be `nil`.
     @POST("/post")
-    static var postWithTuple: APIParameterBuilder<(foo1: String, foo2: Int?)>? = {
+    static var postWithTuple: APIParameterBuilder<(foo1: String, foo2: Int?)>? = .init {
         [
             "foo1": $0.foo1,
-            "foo2": $0.foo2,
+            "foo2": $0.foo2
         ]
-        
-        // Eliminate the warning by explicitly converting to `[String: Any?]`.
-        // Also ensure that `nil` parameters can be filtered.
-        as [String: Any?]
     }
 
     /// This is an api for requests using the **POST** method.
     ///
     /// The full api address is: [](https://postman-echo.com/post) .
     /// This api is referenced with the `Arg` type.
     @POST("/post")
-    static var postWithModel: APIParameterBuilder<Arg>? = {
-        // You can have your model follow the `APIParameterConvertible` protocol.
-        // or use `AnyAPIHashableParameter` to wrap your model in an outer layer.
-        AnyAPIHashableParameter($0)
-    }
+    static var postWithModel: APIParameterBuilder<Arg>? = .init { $0 }
 }
 
 do {

README.md

@@ -31,17 +31,16 @@ The good thing is that you can easily integrate `RaAPIWrapper` into your existin
 static var noParamAPI: APIParameterBuilder<()>? = nil
 
 @POST("/api/v1/tuple_param")
-static var tupleParamAPI: APIParameterBuilder<(id: Int, name: String?)>? = {
-    // Eliminate the warning by explicitly converting to `[String: Any?]`.
-    // Also ensure that `nil` parameters can be filtered.
-    ["id": $0.id, "name": $0.name] as [String: Any?]
+static var tupleParamAPI: APIParameterBuilder<(id: Int, name: String?)>? = .init {
+    // `Dictionary` and `Array` can be used directly as parameters.
+    ["id": $0.id, "name": $0.name]
 }
 
 @POST("/post")
-static var postWithModel: APIParameterBuilder<Arg>? = {
-    // You can have your model follow the `APIParameterConvertible` protocol,
-    // or use `AnyAPIParameter` to wrap your model in an outer layer.
-    AnyAPIParameter($0)
+static var postWithModel: APIParameterBuilder<Arg>? = .init {
+    // When the parameter `Arg` complies with the `APIParameter` (`Encodable & Hashable`) protocol, 
+    // it can be used directly as a parameter.
+    $0
 }
 ```
 

README_CN.md

@@ -29,15 +29,15 @@
 static var noParamAPI: APIParameterBuilder<()>? = nil
 
 @POST("/api/v1/tuple_param")
-static var tupleParamAPI: APIParameterBuilder<(id: Int, name: String?)>? = {
-    // 通过显式转换为 `[String: Any?]` 来消除警告，同时确保为 `nil` 的参数能够被过滤。
-    ["id": $0.id, "name": $0.name] as [String: Any?]
+static var tupleParamAPI: APIParameterBuilder<(id: Int, name: String?)>? = .init {
+    // 字典和数组可直接作为参数使用
+    ["id": $0.id, "name": $0.name]
 }
 
 @POST("/post")
-static var postWithModel: APIParameterBuilder<Arg>? = {
-    // 您可以让您的模型遵循 `APIParameterConvertible` 协议，或者使用 `AnyAPIParameter` 在外面包裹一层。
-    AnyAPIParameter($0)
+static var postWithModel: APIParameterBuilder<Arg>? = .init {
+    // 当参数 `Arg` 遵守 `APIParameter`（`Encodable & Hashable`） 协议时，可直接作为参数使用。
+    $0
 }
 ```
 

…s/Core/RequestInfo/AnyAPIParameter.swift …rces/Core/RequestInfo/APIParameter.swiftSources/Core/RequestInfo/AnyAPIParameter.swift renamed to Sources/Core/RequestInfo/APIParameter.swift Sources/Core/RequestInfo/AnyAPIParameter.swift renamed to Sources/Core/RequestInfo/APIParameter.swift

@@ -1,5 +1,5 @@
 //
-//  AnyAPIParameter.swift
+//  APIParameter.swift
 //  RaAPIWrapper
 //
 //  Created by Rakuyo on 2023/01/13.
@@ -8,5 +8,8 @@
 
 import Foundation
 
+/// Used to constrain what types can be used as api parameters.
+public typealias APIParameter = AnyAPIHashableParameter.Input
+
 /// Represents an arbitrary api parameter.
 public typealias AnyAPIParameter = AnyAPIHashableParameter

Sources/Core/RequestInfo/APIParameterConvertible.swift

@@ -31,20 +31,35 @@ public struct APIRequestInfo {
     /// You can use this property to store some custom data.
     public let userInfo: APIRequestUserInfo
 
-    public init(
+    public init<ParamType>(
         path: String,
         specialBaseURL: URL? = nil,
         httpMethod: APIHTTPMethod,
         header: APIHeaders? = nil,
-        parameters: AnyAPIParameter? = nil,
+        parameterBuild: APIParameterBuilder<ParamType>? = nil,
+        parameterInput: ParamType? = nil,
         userInfo: APIRequestUserInfo = [:]
     ) {
         self.path = path
         self.specialBaseURL = specialBaseURL
         self.httpMethod = httpMethod
         self.header = header
-        self.parameters = parameters
         self.userInfo = userInfo
+        
+        self.parameters = {
+            guard
+                let parameter = parameterInput,
+                let build = parameterBuild
+            else {
+                return nil
+            }
+            
+            let result = build(parameter)
+            if let value = result as? AnyAPIParameter {
+                return value
+            }
+            return .init(result)
+        }()
     }
 }
 

Sources/Core/RequestInfo/APIParametrizable.swift

@@ -8,9 +8,6 @@
 
 import Foundation
 
-/// Parameter constructor for the api. Supports passing one parameter.
-public typealias APIParameterBuilder<ParamType> = (ParamType) -> APIParameterConvertible
-
 /// Used to encapsulate the `APIHTTPMethod` object provided to the `API`.
 public protocol APIHTTPMethodWrapper {
     static var httpMethod: APIHTTPMethod { get }
@@ -75,7 +72,8 @@ public extension API {
             specialBaseURL: specialBaseURL,
             httpMethod: Self.httpMethod.httpMethod,
             header: headerBuilder?(parameter),
-            parameters: wrappedValue?(parameter).toParameters,
+            parameterBuild: wrappedValue,
+            parameterInput: parameter,
             userInfo: userInfo
         )
     }

Sources/Core/RequestInfo/APIRequestInfo.swift

@@ -0,0 +1,37 @@
+//
+//  APIParameterBuilder.swift
+//  RaAPIWrapper
+//
+//  Created by Rakuyo on 2023/01/13.
+//  Copyright © 2022 Rakuyo. All rights reserved.
+//
+
+import Foundation
+
+public struct APIParameterBuilder<Input> {
+    public typealias Output = any APIParameter
+    
+    public typealias ParameterBuilder = (Input) -> Output
+    
+    private let parameterBuild: ParameterBuilder
+    
+    public init(_ build: @escaping ParameterBuilder) {
+        self.parameterBuild = build
+    }
+}
+
+public extension APIParameterBuilder {
+    init(_ build: @escaping (Input) -> [Any?]) {
+        self.parameterBuild = { build($0).toParameters }
+    }
+    
+    init(_ build: @escaping (Input) -> [String: Any?]) {
+        self.parameterBuild = { build($0).toParameters }
+    }
+}
+
+extension APIParameterBuilder {
+    func callAsFunction(_ input: Input) -> Output {
+        return parameterBuild(input)
+    }
+}

Sources/Core/Wrapper/API.swift

@@ -0,0 +1,75 @@
+//
+//  APIParameterConvertible.swift
+//  RaAPIWrapper
+//
+//  Created by Rakuyo on 2022/8/25.
+//  Copyright © 2022 Rakuyo. All rights reserved.
+//
+
+import Foundation
+
+/// Means that the type can be converted to an interface parameter for requesting an api.
+protocol APIParameterConvertible {
+    /// Converts the target to an Encodable-compliant type.
+    var toParameters: AnyAPIParameter { get }
+}
+
+// MARK: - Array
+
+extension Array: APIParameterConvertible {
+    /// For `[AnyObject]` arrays, or a mixed array with very complex elements.
+    var toParameters: AnyAPIParameter {
+        let filtered = (self as [Any?]).compactMap { $0 }
+        
+        let result: [AnyAPIParameter] = filtered.compactMap {
+            if let value = $0 as? AnyAPIParameter { return value }
+            if let value = $0 as? (any APIParameter) { return .init(value) }
+            if let value = $0 as? APIParameterConvertible { return value.toParameters }
+            return mapAnyObjectToEncodable($0 as AnyObject)
+        }
+        
+        assert(filtered.count == result.count, "There are elements in the container type that are not nil that cannot be converted to AnyAPIParameter type. This behavior will cause the parameter to be discarded and not sent to the server. This behavior is usually dangerous and needs to be fixed, please check your code!")
+        
+        return .init(result)
+    }
+}
+
+// MARK: - Dictionary
+
+extension Dictionary: APIParameterConvertible where Key == String {
+    /// For a `[String: AnyObject]` dictionary, or a mixed dictionary with very complex elements.
+    var toParameters: AnyAPIParameter {
+        let filtered = (self as [String: Any?]).compactMapValues { $0 }
+        
+        let result: [String: AnyAPIParameter] = filtered.compactMapValues {
+            if let value = $0 as? AnyAPIParameter { return value }
+            if let value = $0 as? (any APIParameter) { return .init(value) }
+            if let value = $0 as? APIParameterConvertible { return value.toParameters }
+            return mapAnyObjectToEncodable($0 as AnyObject)
+        }
+        
+        assert(filtered.count == result.count, "There are elements in the container type that are not nil that cannot be converted to AnyAPIParameter type. This behavior will cause the parameter to be discarded and not sent to the server. This behavior is usually dangerous and needs to be fixed, please check your code!")
+        
+        return .init(result)
+    }
+}
+
+// MARK: - Tools
+
+private extension APIParameterConvertible {
+    func mapAnyObjectToEncodable(_ value: AnyObject) -> AnyAPIParameter? {
+        if let result = value as? String { return .init(result) }
+        if let result = value as? Character { return .init(String(result)) }
+        if let result = value as? Int { return .init(result) }
+        if let result = value as? UInt { return .init(result) }
+        if let result = value as? Double { return .init(result) }
+        if let result = value as? Float { return .init(result) }
+        if let result = value as? Bool { return .init(result) }
+        if let result = value as? Data { return .init(result) }
+        if let result = value as? Date { return .init(result) }
+        if let result = value as? [String: Any] { return result.toParameters }
+        if let result = value as? [Any] { return result.toParameters }
+        
+        return nil
+    }
+}