It builds

Author: ryanwilson

FirebaseFunctionsSwift/Sources/Codable/Callable+Codable.swift

@@ -13,28 +13,8 @@
 // limitations under the License.
 
 import Foundation
-import FirebaseFunctions
 import FirebaseSharedSwift
 
-public extension Functions {
-  /// Creates a reference to the Callable HTTPS trigger with the given name, the type of an `Encodable`
-  /// request and the type of a `Decodable` response.
-  /// - Parameter name: The name of the Callable HTTPS trigger
-  /// - Parameter requestAs: The type of the `Encodable` entity to use for requests to this `Callable`
-  /// - Parameter responseAs: The type of the `Decodable` entity to use for responses from this `Callable`
-  /// - Parameter encoder: The encoder instance to use to run the encoding.
-  /// - Parameter decoder: The decoder instance to use to run the decoding.
-  func httpsCallable<Request: Encodable,
-    Response: Decodable>(_ name: String,
-                         requestAs: Request.Type = Request.self,
-                         responseAs: Response.Type = Response.self,
-                         encoder: FirebaseDataEncoder = FirebaseDataEncoder(),
-                         decoder: FirebaseDataDecoder = FirebaseDataDecoder())
-    -> Callable<Request, Response> {
-    return Callable(callable: httpsCallable(name), encoder: encoder, decoder: decoder)
-  }
-}
-
 // A `Callable` is reference to a particular Callable HTTPS trigger in Cloud Functions.
 public struct Callable<Request: Encodable, Response: Decodable> {
   /// The timeout to use when calling the function. Defaults to 60 seconds.

FirebaseFunctionsSwift/Sources/Functions.swift

@@ -0,0 +1,301 @@
+//
+//  File.swift
+//  
+//
+//  Created by Ryan Wilson on 2022-01-25.
+//
+
+import Foundation
+import FirebaseCore
+import FirebaseSharedSwift
+import GTMSessionFetcherCore
+
+// PLACEHOLDERS
+protocol AuthInterop {
+  func getToken(forcingRefresh: Bool, callback: (Result<String, Error>) -> Void)
+}
+protocol MessagingInterop {
+  var fcmToken: String { get }
+}
+protocol AppCheckInterop {
+  func getToken(forcingRefresh: Bool, callback: (Result<String, Error>) -> Void)
+}
+
+// END PLACEHOLDERS
+
+private enum Constants {
+  static let appCheckTokenHeader = "X-Firebase-AppCheck"
+  static let fcmTokenHeader = "Firebase-Instance-ID-Token"
+}
+
+/**
+ * `Functions` is the client for Cloud Functions for a Firebase project.
+ */
+@objc public class Functions : NSObject {
+
+  // MARK: - Private Variables
+
+  /// The network client to use for http requests.
+  private let fetcherService: GTMSessionFetcherService
+  // The projectID to use for all function references.
+  private let projectID: String
+  // The region to use for all function references.
+  private let region: String
+  // The custom domain to use for all functions references (optional).
+  private let customDomain: String?
+  // A serializer to encode/decode data and return values.
+  private let serializer = FUNSerializer()
+  // A factory for getting the metadata to include with function calls.
+  private let contextProvider: FunctionsContextProvider
+
+  /**
+   * The current emulator origin, or nil if it is not set.
+   */
+  private(set) var emulatorOrigin: String?
+
+  /**
+   * Creates a Cloud Functions client with the given app and region, or returns a pre-existing
+   * instance if one already exists.
+   * @param app The app for the Firebase project.
+   * @param region The region for the http trigger, such as "us-central1".
+   */
+  class func functions(app: FirebaseApp = FirebaseApp.app()!, region: String = "us-central1") -> Functions {
+    return Functions(app: app, region: region, customDomain: nil)
+  }
+
+  /**
+   * Creates a Cloud Functions client with the given app and region, or returns a pre-existing
+   * instance if one already exists.
+   * @param app The app for the Firebase project.
+   * @param customDomain A custom domain for the http trigger, such as "https://mydomain.com".
+   */
+  class func functions(app: FirebaseApp = FirebaseApp.app()!, customDomain: String) -> Functions {
+    return Functions(app: app, region: "us-central1", customDomain: customDomain)
+  }
+
+  internal convenience init(app: FirebaseApp,
+                            region: String,
+                            customDomain: String?) {
+    #warning("Should be fetched from the App's component container instead.")
+    /*
+     id<FIRFunctionsProvider> provider = FIR_COMPONENT(FIRFunctionsProvider, app.container);
+     return [provider functionsForApp:app region:region customDomain:customDomain type:[self class]];
+     */
+    self.init(projectID: app.options.projectID!,
+              region: region,
+              customDomain: customDomain,
+              // TODO: Get this out of the app.
+              auth: nil,
+              messaging: nil,
+              appCheck: nil)
+  }
+
+  private init(projectID: String,
+               region: String,
+               customDomain: String?,
+               auth: AuthInterop?,
+               messaging: MessagingInterop?,
+               appCheck: AppCheckInterop?,
+               fetcherService: GTMSessionFetcherService = GTMSessionFetcherService()) {
+    self.projectID = projectID
+    self.region = region
+    self.customDomain = customDomain
+    self.emulatorOrigin = nil
+    self.contextProvider = FunctionsContextProvider(auth: auth,
+                                                    messaging: messaging,
+                                                    appCheck: appCheck)
+    self.fetcherService = fetcherService
+  }
+
+  /**
+   * Creates a reference to the Callable HTTPS trigger with the given name.
+   * @param name The name of the Callable HTTPS trigger.
+   */
+  func httpsCallable(_ name: String) -> HTTPSCallable {
+    return HTTPSCallable(functions: self, name: name)
+  }
+
+  /**
+   * Changes this instance to point to a Cloud Functions emulator running locally.
+   * See https://firebase.google.com/docs/functions/local-emulator
+   * @param host The host of the local emulator, such as "localhost".
+   * @param port The port of the local emulator, for example 5005.
+   */
+  func useEmulator(withHost host: String, port: Int) {
+    let prefix = host.hasPrefix("http") ? "" : "http://"
+    let origin = String(format: "\(prefix)\(host):%li", port)
+    emulatorOrigin = origin
+  }
+
+  /// Creates a reference to the Callable HTTPS trigger with the given name, the type of an `Encodable`
+  /// request and the type of a `Decodable` response.
+  /// - Parameter name: The name of the Callable HTTPS trigger
+  /// - Parameter requestAs: The type of the `Encodable` entity to use for requests to this `Callable`
+  /// - Parameter responseAs: The type of the `Decodable` entity to use for responses from this `Callable`
+  /// - Parameter encoder: The encoder instance to use to run the encoding.
+  /// - Parameter decoder: The decoder instance to use to run the decoding.
+  func httpsCallable<Request: Encodable,
+    Response: Decodable>(_ name: String,
+                         requestAs: Request.Type = Request.self,
+                         responseAs: Response.Type = Response.self,
+                         encoder: FirebaseDataEncoder = FirebaseDataEncoder(),
+                         decoder: FirebaseDataDecoder = FirebaseDataDecoder())
+    -> Callable<Request, Response> {
+    return Callable(callable: httpsCallable(name), encoder: encoder, decoder: decoder)
+  }
+
+  // MARK: - Private Funcs
+
+  private func urlWithName(_ name: String) -> String {
+    assert(!name.isEmpty, "Name cannot be empty")
+
+    // Check if we're using the emulator
+    if let emulatorOrigin = emulatorOrigin {
+      return "\(emulatorOrigin)/\(projectID)/\(region)/\(name)"
+    }
+
+    // Check the custom domain.
+    if let customDomain = customDomain {
+      return "\(customDomain)/\(name)"
+    }
+
+    return "https://\(region)-\(projectID).cloudfunctions.net/\(name)"
+  }
+
+  internal func callFunction(name: String,
+                             withObject data: Any?,
+                             timeout: TimeInterval,
+                             completion: @escaping ((Result<HTTPSCallableResult, Error>) -> Void)) {
+    // Get context first.
+    contextProvider.getContext { context, error in
+      // Note: context is always non-nil since some checks could succeed, we're only failing if
+      // there's an error.
+      if let error = error {
+        completion(.failure(error))
+      } else {
+        self.callFunction(name: name,
+                          withObject: data,
+                          timeout: timeout,
+                          context: context,
+                          completion: completion)
+      }
+    }
+
+  }
+
+  private func callFunction(name: String,
+                             withObject data: Any?,
+                             timeout: TimeInterval,
+                             context: FunctionsContext,
+                             completion: @escaping ((Result<HTTPSCallableResult, Error>) -> Void)) {
+    let url = URL(string: urlWithName(name))!
+    let request = URLRequest(url: url,
+                             cachePolicy: .useProtocolCachePolicy,
+                             timeoutInterval: timeout)
+    let fetcher = fetcherService.fetcher(with: request)
+    let body = NSMutableDictionary()
+
+    // Encode the data in the body.
+    var localData = data
+    if data == nil {
+      localData = NSNull()
+    }
+    // Force unwrap to match the old invalid argument thrown.
+    let encoded = try! serializer.encode(localData!)
+    body["data"] = encoded
+
+    do {
+      let payload = try JSONSerialization.data(withJSONObject: body)
+      fetcher.bodyData = payload
+    } catch {
+      DispatchQueue.main.async {
+        completion(.failure(error))
+      }
+      return
+    }
+
+    // Set the headers.
+    fetcher.setRequestValue("application/json", forHTTPHeaderField: "Content-Type")
+    if let authToken = context.authToken {
+      let value = "Bearer \(authToken)"
+      fetcher.setRequestValue(value, forHTTPHeaderField: "Authorization")
+    }
+
+    if let fcmToken = context.fcmToken {
+      fetcher.setRequestValue(fcmToken, forHTTPHeaderField: Constants.fcmTokenHeader)
+    }
+
+    if let appCheckToken = context.appCheckToken {
+      fetcher.setRequestValue(appCheckToken, forHTTPHeaderField: Constants.appCheckTokenHeader)
+    }
+
+    // Override normal security rules if this is a local test.
+    if emulatorOrigin != nil {
+      fetcher.allowLocalhostRequest = true
+      fetcher.allowedInsecureSchemes = ["http"]
+    }
+
+    fetcher.beginFetch { data, error in
+      // If there was an HTTP error, convert it to our own error domain.
+      var localError: Error? = nil
+      if let error = error as NSError? {
+        if error.domain == kGTMSessionFetcherStatusDomain {
+          localError = FunctionsErrorForResponse(status: error.code, body: data, serializer: self.serializer)
+        } else if error.domain == NSURLErrorDomain, error.code == NSURLErrorTimedOut {
+          localError = FunctionsErrorCode.deadlineExceeded.generatedError(userInfo: nil)
+        }
+      } else {
+        // If there wasn't an HTTP error, see if there was an error in the body.
+        localError = FunctionsErrorForResponse(status: 200, body: data, serializer: self.serializer)
+      }
+
+      // If there was an error, report it to the user and stop.
+      if let localError = localError {
+        completion(.failure(localError))
+        return
+      }
+
+      // Porting: this check is new since we didn't previously check if `data` was nil.
+      guard let data = data else {
+        completion(.failure(FunctionsErrorCode.internal.generatedError(userInfo: nil)))
+        return
+      }
+
+      let responseJSONObject: Any
+      do {
+        responseJSONObject = try JSONSerialization.jsonObject(with: data)
+      } catch {
+        completion(.failure(error))
+        return
+      }
+
+      guard let responseJSON = responseJSONObject as? NSDictionary else {
+        let userInfo = [NSLocalizedDescriptionKey: "Response was not a dictionary."]
+        completion(.failure(FunctionsErrorCode.internal.generatedError(userInfo: userInfo)))
+        return
+      }
+
+      // TODO(klimt): Allow "result" instead of "data" for now, for backwards compatibility.
+      let dataJSON = responseJSON["data"] ?? responseJSON["result"]
+      guard let dataJSON = dataJSON as AnyObject? else {
+        let userInfo = [NSLocalizedDescriptionKey: "Response is missing data field."]
+        completion(.failure(FunctionsErrorCode.internal.generatedError(userInfo: userInfo)))
+        return
+      }
+
+      let resultData: Any?
+      do {
+        resultData = try self.serializer.decode(dataJSON)
+      } catch {
+        completion(.failure(error))
+        return
+      }
+
+      // TODO: Force unwrap... gross
+      let result = HTTPSCallableResult(data: resultData!)
+#warning("This copied comment appears to be incorrect - it's impossible to have a nil callable result.")
+      // If there's no result field, this will return nil, which is fine.
+      completion(.success(result))
+    }
+  }
+}