Swift extension for RTDB (#6568)

* Added pristine version of JSONEncoder.swift to the project

* Renamed JSONEncoder and JSONDecoder and namespaced them under Database. Skip JSONSerialization steps of encoding and decoding

* Added convenience decoding to DataSnapshot and encoding to DatabaseReference

* Convert to 2 space indentation

* Added ServerTimestamp - modelled on Firestore ditto

* Added a ServerIncrement enum/property wrapper. Not too happy about the property wrapper API though

* Fix ServerTimestamp Date decoding and encoding

* Fix ServerTimestamp Date decoding and encoding

* Added API for setting default decoder and encoder

* Fix typo and linter error

* Changed requirement for ServerIncrement generic parameter to be AdditiveArithmetic instead of Numeric. Added tests for server value coding.

* Add test for alternative ServerIncrement API and demonstrate that this version of the API also models actual optionality

* Test the default encoder and decoder

* Added more tests derived from corresponding Firestore coding tests

* Ran linter

* Delete EncoderTests.swift

Ooops, I added this file prematurely.

* Added modified version of tests from apple/swift

* Rename all but a few occurrences of 'json' and add a reference to the original file from apple/swift

* Made it possible to decode Optional types

* Updated copyright messages

* Removed CodableErrors and force cast ServerValue.timestamp() based on feedback on PR

* Changed completion handler to take a Result<Void, Error>

* Add escaping to closure parameter

* Fixed format

* Change completion handler type to accept and Optional Error rather than a Result<Void, Error>

* Remove ServerIncrement for now

* Fix function signature error

* Remove Swift 4 support. Remove default encoder/decoder configuration. Add FirebaseDatabaseSwift.podspec - I don't know if it's good though, as I don't use CocoaPods myself.

* Update podspec with fixes from review

* Run scripts/style.sh

* Add -Beta to FirebaseDatabaseSwift library

Author: mortenbekditlevsen

FirebaseDatabaseSwift.podspec

@@ -0,0 +1,37 @@
+#
+# Be sure to run `pod lib lint FirebaseDatabaseSwift.podspec' to ensure this is a
+# valid spec before submitting.
+#
+
+Pod::Spec.new do |s|
+  s.name                    = 'FirebaseDatabaseSwift'
+  s.version                 = '7.9.0-beta'
+  s.summary                 = 'Swift Extensions for Firebase Realtime Database'
+
+  s.description      = <<-DESC
+Simplify your iOS development, grow your user base, and monetize more effectively with Firebase.
+                       DESC
+
+  s.homepage                = 'https://developers.google.com/'
+  s.license                 = { :type => 'Apache', :file => 'LICENSE' }
+  s.authors                 = 'Google, Inc.'
+
+  s.source                  = {
+    :git => 'https://github.com/Firebase/firebase-ios-sdk.git',
+    :tag => 'CocoaPods-' + s.version.to_s
+  }
+
+  s.swift_version           = '5.1'
+  s.ios.deployment_target   = '10.0'
+  s.osx.deployment_target   = '10.12'
+  s.tvos.deployment_target  = '10.0'
+
+  s.cocoapods_version       = '>= 1.4.0'
+  s.prefix_header_file      = false
+
+  s.source_files = [
+    'FirebaseDatabaseSwift/Sources/**/*.swift',
+  ]
+
+  s.dependency 'FirebaseDatabase', '~> 7.8'
+end

FirebaseDatabaseSwift/Sources/Codable/DataSnapshot+ReadDecodable.swift

@@ -0,0 +1,37 @@
+/*
+ * 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 FirebaseDatabase
+
+extension DataSnapshot {
+  /// Retrieves the value of a snapshot and converts it to an instance of
+  /// caller-specified type.
+  /// Throws `DecodingError.valueNotFound`
+  /// if the document does not exist and `T` is not an `Optional`.
+  ///
+  /// See `Database.Decoder` for more details about the decoding process.
+  ///
+  /// - Parameters
+  ///   - type: The type to convert the document fields to.
+  ///   - decoder: The decoder to use to convert the document. Defaults to use
+  ///              default decoder.
+  public func data<T: Decodable>(as type: T.Type,
+                                 decoder: Database.Decoder =
+                                   Database.Decoder()) throws -> T {
+    try decoder.decode(T.self, from: value ?? NSNull())
+  }
+}

FirebaseDatabaseSwift/Sources/Codable/DatabaseReference+WriteEncodable.swift

@@ -0,0 +1,45 @@
+/*
+ * 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 FirebaseDatabase
+
+extension DatabaseReference {
+  /// Encodes an instance of `Encodable` and overwrites the encoded data
+  /// to the path referred by this `DatabaseReference`. If no value exists,
+  /// it is created. If a value already exists, it is overwritten.
+  ///
+  /// See `Database.Encoder` for more details about the encoding process.
+  ///
+  /// - Parameters:
+  ///   - value: An instance of `Encodable` to be encoded to a document.
+  ///   - encoder: An encoder instance to use to run the encoding.
+  ///   - completion: A block to execute once the value has been successfully
+  ///                 written to the server. This block will not be called while
+  ///                 the client is offline, though local changes will be visible
+  ///                 immediately.
+  public func setValue<T: Encodable>(from value: T,
+                                     encoder: Database.Encoder = Database.Encoder(),
+                                     completion: ((Error?) -> Void)? =
+                                       nil) throws {
+    let encoded = try encoder.encode(value)
+    if let completion = completion {
+      setValue(encoded, withCompletionBlock: { error, _ in completion(error) })
+    } else {
+      setValue(encoded)
+    }
+  }
+}

FirebaseDatabaseSwift/Sources/Codable/ServerTimestamp.swift

@@ -0,0 +1,68 @@
+/*
+ * 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 FirebaseDatabase
+
+/// A property wrapper that marks an `Optional<Date>` field to be
+/// populated with a server timestamp. If a `Codable` object being written
+/// contains a `nil` for an `@ServerTimestamp`-annotated field, it will be
+/// replaced with `ServerValue.timestamp()` as it is sent.
+///
+/// Example:
+/// ```
+/// struct CustomModel {
+///   @ServerTimestamp var ts: Date?
+/// }
+/// ```
+///
+/// Then writing `CustomModel(ts: nil)` will tell server to fill `ts` with
+/// current timestamp.
+@propertyWrapper
+public struct ServerTimestamp: Codable, Equatable, Hashable {
+  var value: Date?
+
+  public init(wrappedValue value: Date?) {
+    self.value = value
+  }
+
+  public var wrappedValue: Date? {
+    get { value }
+    set { value = newValue }
+  }
+
+  // MARK: Codable
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.singleValueContainer()
+    if container.decodeNil() {
+      value = nil
+    } else {
+      let msecs = try container.decode(Int.self)
+      value = Date(timeIntervalSince1970: TimeInterval(msecs) / 1000)
+    }
+  }
+
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    if let value = value {
+      let interval = value.timeIntervalSince1970
+      try container.encode(Int(interval * 1000))
+    } else {
+      let dictionary = ServerValue.timestamp() as! [String: String]
+      try container.encode(dictionary)
+    }
+  }
+}