Make Firestore use StructureEncoder and StructureDecoder

FirebaseFunctionsSwift/Sources/Codable/Callable+Codable.swift

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+import FirebaseFunctions
+import FirebaseSharedSwift
+
+extension HTTPSCallable {
+  enum CallableError: Error {
+    case internalError
+  }
+
+  public func call<T: Encodable, U: Decodable>(_ data: T,
+                                               resultAs: U.Type,
+                                               encoder: StructureEncoder = StructureEncoder(),
+                                               decoder: StructureDecoder = StructureDecoder(),
+                                               completion: @escaping (Result<U, Error>)
+                                                 -> Void) throws {
+    let encoded = try encoder.encode(data)
+    call(encoded) { result, error in
+      do {
+        if let result = result {
+          let decoded = try decoder.decode(U.self, from: result.data)
+          completion(.success(decoded))
+        } else if let error = error {
+          completion(.failure(error))
+        } else {
+          completion(.failure(CallableError.internalError))
+        }
+      } catch {
+        completion(.failure(error))
+      }
+    }
+  }
+
+  #if compiler(>=5.5) && canImport(_Concurrency)
+    @available(iOS 15, tvOS 15, macOS 12, watchOS 8, *)
+    public func call<T: Encodable, U: Decodable>(_ data: T,
+                                                 resultAs: U.Type,
+                                                 encoder: StructureEncoder = StructureEncoder(),
+                                                 decoder: StructureDecoder =
+                                                   StructureDecoder()) async throws -> U {
+      let encoded = try encoder.encode(data)
+      let result = try await call(encoded)
+      return try decoder.decode(U.self, from: result.data)
+    }
+  #endif
+}

FirebaseSharedSwift/Sources/third_party/StructureEncoder/StructureEncoder.swift

@@ -14,6 +14,9 @@
 
 import Foundation
 
+public protocol StructureCodingPassthroughType: NSObject { }
+public protocol StructureCodingUncodedUnkeyed {}
+
 extension DecodingError {
   /// Returns a `.typeMismatch` error describing the expected type.
   ///
@@ -233,6 +236,9 @@ public class StructureEncoder {
   /// The strategy to use for encoding keys. Defaults to `.useDefaultKeys`.
   open var keyEncodingStrategy: KeyEncodingStrategy = .useDefaultKeys
 
+  /// If `usePassthroughTypes` is set to `true`, then any value of a type conforming to StructureCodingPassthroughType will not be encoded, but left as is in the resulting structure
+  open var usePassthroughTypes: Bool = false
+
   /// Contextual user-provided information for use during encoding.
   open var userInfo: [CodingUserInfoKey : Any] = [:]
 
@@ -242,6 +248,7 @@ public class StructureEncoder {
     let dataEncodingStrategy: DataEncodingStrategy
     let nonConformingFloatEncodingStrategy: NonConformingFloatEncodingStrategy
     let keyEncodingStrategy: KeyEncodingStrategy
+    let usePassthroughTypes: Bool
     let userInfo: [CodingUserInfoKey : Any]
   }
 
@@ -251,6 +258,7 @@ public class StructureEncoder {
                     dataEncodingStrategy: dataEncodingStrategy,
                     nonConformingFloatEncodingStrategy: nonConformingFloatEncodingStrategy,
                     keyEncodingStrategy: keyEncodingStrategy,
+                    usePassthroughTypes: usePassthroughTypes,
                     userInfo: userInfo)
   }
 
@@ -501,6 +509,7 @@ fileprivate struct _JSONKeyedEncodingContainer<K : CodingKey> : KeyedEncodingCon
   }
 
   public mutating func encode<T : Encodable>(_ value: T, forKey key: Key) throws {
+    if T.self is StructureCodingUncodedUnkeyed.Type { return }
     self.encoder.codingPath.append(key)
     defer { self.encoder.codingPath.removeLast() }
     self.container[_converted(key).stringValue] = try self.encoder.box(value)
@@ -928,6 +937,8 @@ extension __JSONEncoder {
       return (value as! NSDecimalNumber)
     } else if value is _JSONStringDictionaryEncodableMarker {
       return try self.box(value as! [String : Encodable])
+    } else if let passthrough = value as? StructureCodingPassthroughType, self.options.usePassthroughTypes {
+      return passthrough
     }
 
     // The value should request a container from the __JSONEncoder.
@@ -1601,6 +1612,11 @@ fileprivate struct _JSONKeyedDecodingContainer<K : CodingKey> : KeyedDecodingCon
   }
 
   public func decode<T : Decodable>(_ type: T.Type, forKey key: Key) throws -> T {
+    if T.self is StructureCodingUncodedUnkeyed.Type {
+      // Note: not pushing and popping key to codingPath since the key is
+      // not part of the decoded structure.
+      return try T.init(from: self.decoder)
+    }
     guard let entry = self.container[key.stringValue] else {
       throw DecodingError.keyNotFound(key, DecodingError.Context(codingPath: self.decoder.codingPath, debugDescription: "No value associated with key \(_errorDescription(of: key))."))
     }
@@ -2505,6 +2521,9 @@ extension __JSONDecoder {
     } else {
       self.storage.push(container: value)
       defer { self.storage.popContainer() }
+      if let passthrough = value as? StructureCodingPassthroughType, Swift.type(of: value) == type {
+        return passthrough
+      }
       return try type.init(from: self)
     }
   }

Firestore/Swift/Source/Codable/CodableErrors.swift

@@ -21,4 +21,5 @@ public enum FirestoreDecodingError: Error {
 
 public enum FirestoreEncodingError: Error {
   case encodingIsNotSupported(String)
+  case topLevelTypesAreNotSupported
 }

Firestore/Swift/Source/Codable/CodablePassThroughTypes.swift

@@ -16,11 +16,9 @@
 
 import Foundation
 import FirebaseFirestore
+import FirebaseSharedSwift
 
-internal func isFirestorePassthroughType<T: Any>(_ value: T) -> Bool {
-  return
-    T.self == GeoPoint.self ||
-    T.self == Timestamp.self ||
-    T.self == FieldValue.self ||
-    T.self == DocumentReference.self
-}
+extension GeoPoint: StructureCodingPassthroughType {}
+extension Timestamp: StructureCodingPassthroughType {}
+extension FieldValue: StructureCodingPassthroughType {}
+extension DocumentReference: StructureCodingPassthroughType {}

Firestore/Swift/Source/Codable/CollectionReference+WriteEncodable.swift

@@ -35,6 +35,11 @@ extension CollectionReference {
                                         encoder: Firestore.Encoder = Firestore.Encoder(),
                                         completion: ((Error?) -> Void)? = nil) throws
     -> DocumentReference {
-    return addDocument(data: try encoder.encode(value), completion: completion)
+    encoder.usePassthroughTypes = true
+    let encoded = try encoder.encode(value)
+    guard let dictionaryValue = encoded as? [String: Any] else {
+      throw FirestoreEncodingError.topLevelTypesAreNotSupported
+    }
+    return addDocument(data: dictionaryValue, completion: completion)
   }
 }

Firestore/Swift/Source/Codable/DocumentID.swift

@@ -15,6 +15,10 @@
  */
 
 import FirebaseFirestore
+import FirebaseSharedSwift
+
+let documentRefUserInfoKey =
+  CodingUserInfoKey(rawValue: "DocumentRefUserInfoKey")!
 
 /// A type that can initialize itself from a Firestore `DocumentReference`,
 /// which makes it suitable for use with the `@DocumentID` property wrapper.
@@ -44,21 +48,6 @@ extension DocumentReference: DocumentIDWrappable {
   }
 }
 
-/// An internal protocol that allows Firestore.Decoder to test if a type is a
-/// DocumentID of some kind without knowing the specific generic parameter that
-/// the user actually used.
-///
-/// This is required because Swift does not define an existential type for all
-/// instances of a generic class--that is, it has no wildcard or raw type that
-/// matches a generic without any specific parameter. Swift does define an
-/// existential type for protocols though, so this protocol (to which DocumentID
-/// conforms) indirectly makes it possible to test for and act on any
-/// `DocumentID<Value>`.
-internal protocol DocumentIDProtocol {
-  /// Initializes the DocumentID from a DocumentReference.
-  init(from documentReference: DocumentReference?) throws
-}
-
 /// A value that is populated in Codable objects with the `DocumentReference`
 /// of the current document by the Firestore.Decoder when a document is read.
 ///
@@ -76,7 +65,7 @@ internal protocol DocumentIDProtocol {
 /// Firestore.Encoder leads to an error.
 @propertyWrapper
 public struct DocumentID<Value: DocumentIDWrappable & Codable>:
-  DocumentIDProtocol, Codable {
+  Codable, StructureCodingUncodedUnkeyed {
   var value: Value?
 
   public init(wrappedValue value: Value?) {
@@ -101,9 +90,12 @@ public struct DocumentID<Value: DocumentIDWrappable & Codable>:
   // MARK: - `Codable` implementation.
 
   public init(from decoder: Decoder) throws {
-    throw FirestoreDecodingError.decodingIsNotSupported(
-      "DocumentID values can only be decoded with Firestore.Decoder"
-    )
+    guard let reference = decoder.userInfo[documentRefUserInfoKey] as? DocumentReference else {
+      throw FirestoreDecodingError.decodingIsNotSupported(
+        "Could not find DocumentReference for user info key: \(documentRefUserInfoKey)"
+      )
+    }
+    try self.init(from: reference)
   }
 
   public func encode(to encoder: Encoder) throws {

Firestore/Swift/Source/Codable/DocumentReference+WriteEncodable.swift

@@ -34,7 +34,11 @@ extension DocumentReference {
   public func setData<T: Encodable>(from value: T,
                                     encoder: Firestore.Encoder = Firestore.Encoder(),
                                     completion: ((Error?) -> Void)? = nil) throws {
-    setData(try encoder.encode(value), completion: completion)
+    let encoded = try encoder.encode(value)
+    guard let dictionaryValue = encoded as? [String: Any] else {
+      throw FirestoreEncodingError.topLevelTypesAreNotSupported
+    }
+    setData(dictionaryValue, completion: completion)
   }
 
   /// Encodes an instance of `Encodable` and overwrites the encoded data
@@ -57,7 +61,11 @@ extension DocumentReference {
                                     merge: Bool,
                                     encoder: Firestore.Encoder = Firestore.Encoder(),
                                     completion: ((Error?) -> Void)? = nil) throws {
-    setData(try encoder.encode(value), merge: merge, completion: completion)
+    let encoded = try encoder.encode(value)
+    guard let dictionaryValue = encoded as? [String: Any] else {
+      throw FirestoreEncodingError.topLevelTypesAreNotSupported
+    }
+    setData(dictionaryValue, merge: merge, completion: completion)
   }
 
   /// Encodes an instance of `Encodable` and writes the encoded data to the document referred
@@ -84,6 +92,11 @@ extension DocumentReference {
                                     mergeFields: [Any],
                                     encoder: Firestore.Encoder = Firestore.Encoder(),
                                     completion: ((Error?) -> Void)? = nil) throws {
-    setData(try encoder.encode(value), mergeFields: mergeFields, completion: completion)
+    encoder.usePassthroughTypes = true
+    let encoded = try encoder.encode(value)
+    guard let dictionary = encoded as? [String: Any] else {
+      throw FirestoreEncodingError.topLevelTypesAreNotSupported
+    }
+    setData(dictionary, mergeFields: mergeFields, completion: completion)
   }
 }

Firestore/Swift/Source/Codable/DocumentSnapshot+ReadDecodable.swift

@@ -16,6 +16,7 @@
 
 import Foundation
 import FirebaseFirestore
+import FirebaseSharedSwift
 
 extension DocumentSnapshot {
   /// Retrieves all fields in a document and converts them to an instance of
@@ -37,8 +38,10 @@ extension DocumentSnapshot {
                                  with serverTimestampBehavior: ServerTimestampBehavior = .none,
                                  decoder: Firestore.Decoder? = nil) throws -> T? {
     let d = decoder ?? Firestore.Decoder()
+    d.userInfo[documentRefUserInfoKey] = reference
+    d.dateDecodingStrategy = .timestamp(fallback: d.dateDecodingStrategy)
     if let data = data(with: serverTimestampBehavior) {
-      return try d.decode(T.self, from: data, in: reference)
+      return try d.decode(T.self, from: data)
     }
     return nil
   }

Firestore/Swift/Source/Codable/EncoderDecoder.swift

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import FirebaseFirestore
+import FirebaseSharedSwift
+import Foundation
+
+extension Firestore {
+  public typealias Encoder = StructureEncoder
+  public typealias Decoder = StructureDecoder
+}

Firestore/Swift/Source/Codable/TimestampDecodingStrategy.swift

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+import FirebaseFirestore
+import FirebaseSharedSwift
+
+@available(macOS 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *)
+private var _iso8601Formatter: ISO8601DateFormatter = {
+  let formatter = ISO8601DateFormatter()
+  formatter.formatOptions = .withInternetDateTime
+  return formatter
+}()
+
+extension StructureDecoder.DateDecodingStrategy {
+  public static func timestamp(fallback: StructureDecoder
+    .DateDecodingStrategy = .deferredToDate) -> StructureDecoder.DateDecodingStrategy {
+    return .custom { decoder in
+      let container = try decoder.singleValueContainer()
+      do {
+        let value = try container.decode(Timestamp.self)
+        return value.dateValue()
+      } catch {
+        switch fallback {
+        case .deferredToDate:
+          return try Date(from: decoder)
+
+        case .secondsSince1970:
+          let double = try container.decode(Double.self)
+          return Date(timeIntervalSince1970: double)
+
+        case .millisecondsSince1970:
+          let double = try container.decode(Double.self)
+          return Date(timeIntervalSince1970: double / 1000.0)
+
+        case .iso8601:
+          if #available(macOS 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *) {
+            let string = try container.decode(String.self)
+            guard let date = _iso8601Formatter.date(from: string) else {
+              throw DecodingError.dataCorrupted(DecodingError.Context(
+                codingPath: decoder.codingPath,
+                debugDescription: "Expected date string to be ISO8601-formatted."
+              ))
+            }
+
+            return date
+          } else {
+            fatalError("ISO8601DateFormatter is unavailable on this platform.")
+          }
+
+        case let .formatted(formatter):
+          let string = try container.decode(String.self)
+          guard let date = formatter.date(from: string) else {
+            throw DecodingError.dataCorrupted(DecodingError.Context(
+              codingPath: decoder.codingPath,
+              debugDescription: "Date string does not match format expected by formatter."
+            ))
+          }
+
+          return date
+
+        case let .custom(closure):
+          return try closure(decoder)
+        }
+      }
+    }
+  }
+}