Remove Get dependency

Author: grdsdev

Package.resolved

@@ -12,15 +12,13 @@ let package = Package(
     .tvOS(.v13),
   ],
   products: [
-    .library(name: "Functions", targets: ["Functions"]),
-  ],
-  dependencies: [
-    .package(url: "https://github.com/kean/Get", from: "2.1.5"),
+    .library(name: "Functions", targets: ["Functions"])
   ],
+  dependencies: [],
   targets: [
     .target(
       name: "Functions",
-      dependencies: ["Get"]
+      dependencies: []
     ),
     .testTarget(
       name: "FunctionsTests",

Package.swift

@@ -1,23 +1,22 @@
-@preconcurrency import Foundation
-@preconcurrency import Get
+import Foundation
 
 public final class FunctionsClient {
+  public typealias FetchHandler = (URLRequest) async throws -> (Data, URLResponse)
+
   let url: URL
   var headers: [String: String]
 
-  let client: APIClient
+  private let fetch: FetchHandler
 
   public init(
     url: URL,
     headers: [String: String] = [:],
-    apiClientDelegate: APIClientDelegate? = nil
+    fetch: @escaping FetchHandler = URLSession.shared.data(for:)
   ) {
     self.url = url
     self.headers = headers
     self.headers["X-Client-Info"] = "functions-swift/\(version)"
-    client = APIClient(baseURL: url) {
-      $0.delegate = apiClientDelegate
-    }
+    self.fetch = fetch
   }
 
   /// Updates the authorization header.
@@ -74,28 +73,28 @@ public final class FunctionsClient {
     functionName: String,
     invokeOptions: FunctionInvokeOptions
   ) async throws -> (Data, HTTPURLResponse) {
-    let request = Request(
-      path: functionName,
-      method: .post,
-      body: invokeOptions.body,
-      headers: invokeOptions.headers.merging(headers) { first, _ in first }
-    )
+    let url = self.url.appendingPathComponent(functionName)
+
+    var urlRequest = URLRequest(url: url)
+    urlRequest.allHTTPHeaderFields = invokeOptions.headers.merging(headers) { first, _ in first }
+    urlRequest.httpMethod = "POST"
+    urlRequest.httpBody = invokeOptions.body
 
-    let response = try await client.data(for: request)
+    let (data, response) = try await fetch(urlRequest)
 
-    guard let httpResponse = response.response as? HTTPURLResponse else {
+    guard let httpResponse = response as? HTTPURLResponse else {
       throw URLError(.badServerResponse)
     }
 
-    guard 200 ..< 300 ~= httpResponse.statusCode else {
-      throw FunctionsError.httpError(code: httpResponse.statusCode, data: response.data)
+    guard 200..<300 ~= httpResponse.statusCode else {
+      throw FunctionsError.httpError(code: httpResponse.statusCode, data: data)
     }
 
     let isRelayError = httpResponse.value(forHTTPHeaderField: "x-relay-error") == "true"
     if isRelayError {
       throw FunctionsError.relayError
     }
 
-    return (response.data, httpResponse)
+    return (data, httpResponse)
   }
 }

Sources/Functions/FunctionsClient.swift

@@ -1,6 +1,7 @@
-@testable import Functions
 import XCTest
 
+@testable import Functions
+
 final class FunctionInvokeOptionsTests: XCTestCase {
   func testStringBody() {
     let options = FunctionInvokeOptions(body: "string value")

Tests/FunctionsTests/FunctionInvokeOptionsTests.swift

@@ -0,0 +1,92 @@
+import XCTest
+
+@testable import Functions
+
+final class FunctionsClientTests: XCTestCase {
+  let url = URL(string: "http://localhost:5432/functions/v1")!
+  let apiKey = "supabase.anon.key"
+
+  func testInvoke() async throws {
+    var _request: URLRequest?
+    let sut = FunctionsClient(url: url, headers: ["apikey": apiKey]) {
+      _request = $0
+      return (Data(), HTTPURLResponse.mock(url: self.url))
+    }
+
+    let body = ["name": "Supabase"]
+
+    try await sut.invoke(
+      functionName: "hello_world",
+      invokeOptions: .init(headers: ["X-Custom-Key": "value"], body: body)
+    )
+
+    let request = try XCTUnwrap(_request)
+
+    XCTAssertEqual(request.url, URL(string: "http://localhost:5432/functions/v1/hello_world"))
+    XCTAssertEqual(request.httpMethod, "POST")
+    XCTAssertEqual(request.value(forHTTPHeaderField: "apikey"), apiKey)
+    XCTAssertEqual(request.value(forHTTPHeaderField: "X-Custom-Key"), "value")
+    XCTAssertEqual(
+      request.value(forHTTPHeaderField: "X-Client-Info"), "functions-swift/\(Functions.version)")
+  }
+
+  func testInvoke_shouldThrow_URLError_badServerResponse() async {
+    let sut = FunctionsClient(url: url) { _ in
+      (Data(), URLResponse())
+    }
+
+    do {
+      try await sut.invoke(functionName: "hello_world")
+    } catch let urlError as URLError {
+      XCTAssertEqual(urlError.code, .badServerResponse)
+    } catch {
+      XCTFail("Unexpected error thrown \(error)")
+    }
+  }
+
+  func testInvoke_shouldThrow_FunctionsError_httpError() async {
+    let sut = FunctionsClient(url: url) { _ in
+      (
+        "error".data(using: .utf8)!,
+        HTTPURLResponse.mock(url: self.url, statusCode: 300)
+      )
+    }
+
+    do {
+      try await sut.invoke(functionName: "hello_world")
+      XCTFail("Invoke should fail.")
+    } catch let FunctionsError.httpError(code, data) {
+      XCTAssertEqual(code, 300)
+      XCTAssertEqual(data, "error".data(using: .utf8))
+    } catch {
+      XCTFail("Unexpected error thrown \(error)")
+    }
+  }
+
+  func testInvoke_shouldThrow_FunctionsError_relayError() async {
+    let sut = FunctionsClient(url: url) { _ in
+      (
+        Data(),
+        HTTPURLResponse.mock(url: self.url, headerFields: ["x-relay-error": "true"])
+      )
+    }
+
+    do {
+      try await sut.invoke(functionName: "hello_world")
+      XCTFail("Invoke should fail.")
+    } catch FunctionsError.relayError {
+    } catch {
+      XCTFail("Unexpected error thrown \(error)")
+    }
+  }
+}
+
+extension HTTPURLResponse {
+  static func mock(
+    url: URL,
+    statusCode: Int = 200,
+    headerFields: [String: String]? = nil
+  ) -> HTTPURLResponse {
+    HTTPURLResponse(url: url, statusCode: statusCode, httpVersion: nil, headerFields: headerFields)!
+  }
+}