Merge branch 'master' into gitlive/kotlin-1.8.21-gradle-8

Author: nbransby

README.md

@@ -88,6 +88,7 @@ db.collection("cities").document("LA").set(City.serializer(), city, encodeDefaul
 ```
 
 The `encodeDefaults` parameter is optional and defaults to `true`, set this to false to omit writing optional properties if they are equal to theirs default values.
+Using [@EncodeDefault](https://kotlinlang.org/api/kotlinx.serialization/kotlinx-serialization-core/kotlinx.serialization/-encode-default/) on properties is a recommended way to locally override the behavior set with `encodeDefaults`.
 
 You can also omit the serializer but this is discouraged due to a [current limitation on Kotlin/JS and Kotlin/Native](https://github.com/Kotlin/kotlinx.serialization/issues/1116#issuecomment-704342452)
 
@@ -110,6 +111,21 @@ data class Post(
 )
 ```
 
+In addition `firebase-firestore` provides [GeoPoint] and [DocumentReference] classes which allow persisting
+geo points and document references in a native way:
+
+```kotlin
+@Serializable
+data class PointOfInterest(
+    val reference: DocumentReference, 
+    val location: GeoPoint
+)
+val document = PointOfInterest(
+    reference = Firebase.firestore.collection("foo").document("bar"),
+    location = GeoPoint(51.939, 4.506)
+)
+```
+
 <h4>Polymorphic serialization (sealed classes)</h4>
 
 This sdk will handle polymorphic serialization automatically if you have a sealed class and its children marked as `Serializable`. It will include a `type` property that will be used to discriminate which child class is the serialized.

build.gradle.kts

@@ -65,7 +65,28 @@ subprojects {
         onlyIf { project.gradle.startParameter.taskNames.contains("MavenRepository") }
     }
 
+    val skipPublishing = project.name == "test-utils" // skip publishing for test utils
+
     tasks {
+        withType<Test> {
+            testLogging {
+                showExceptions = true
+                exceptionFormat = TestExceptionFormat.FULL
+                showStandardStreams = true
+                showCauses = true
+                showStackTraces = true
+                events = setOf(
+                    TestLogEvent.STARTED,
+                    TestLogEvent.FAILED,
+                    TestLogEvent.PASSED,
+                    TestLogEvent.SKIPPED,
+                    TestLogEvent.STANDARD_OUT,
+                    TestLogEvent.STANDARD_ERROR
+                )
+            }
+        }
+
+        if (skipPublishing) return@tasks
 
         register<Exec>("updateVersion") {
             commandLine("npm", "--allow-same-version", "--prefix", projectDir, "version", "${project.property("${project.name}.version")}")
@@ -136,24 +157,6 @@ subprojects {
                 commandLine("npm", "publish")
             }
         }
-
-        withType<Test> {
-            testLogging {
-                showExceptions = true
-                exceptionFormat = TestExceptionFormat.FULL
-                showStandardStreams = true
-                showCauses = true
-                showStackTraces = true
-                events = setOf(
-                    TestLogEvent.STARTED,
-                    TestLogEvent.FAILED,
-                    TestLogEvent.PASSED,
-                    TestLogEvent.SKIPPED,
-                    TestLogEvent.STANDARD_OUT,
-                    TestLogEvent.STANDARD_ERROR
-                )
-            }
-        }
     }
 
     afterEvaluate  {
@@ -184,8 +187,10 @@ subprojects {
         }
     }
 
-    apply(plugin="maven-publish")
-    apply(plugin="signing")
+    if (skipPublishing) return@subprojects
+
+    apply(plugin = "maven-publish")
+    apply(plugin = "signing")
 
 
     configure<PublishingExtension> {
@@ -238,6 +243,7 @@ subprojects {
                 }
             }
         }
+
     }
 
     // Workaround for setting kotlinOptions.jvmTarget

firebase-auth/src/iosMain/kotlin/dev/gitlive/firebase/auth/auth.kt

@@ -19,8 +19,9 @@ import platform.Foundation.*
 actual val Firebase.auth
     get() = FirebaseAuth(FIRAuth.auth())
 
-actual fun Firebase.auth(app: FirebaseApp): FirebaseAuth = TODO("Come back to issue")
-//    FirebaseAuth(FIRAuth.authWithApp(app.ios))
+actual fun Firebase.auth(app: FirebaseApp): FirebaseAuth = FirebaseAuth(
+    FIRAuth.authWithApp(app.ios as objcnames.classes.FIRApp)
+)
 
 actual class FirebaseAuth internal constructor(val ios: FIRAuth) {
 

firebase-common/build.gradle.kts

@@ -99,6 +99,7 @@ kotlin {
                 implementation(kotlin("test"))
                 implementation(kotlin("test-common"))
                 implementation(kotlin("test-annotations-common"))
+                implementation(project(":test-utils"))
             }
         }
 

firebase-common/src/androidMain/kotlin/dev/gitlive/firebase/_decoders.kt

@@ -11,7 +11,14 @@ import kotlinx.serialization.descriptors.StructureKind
 
 actual fun FirebaseDecoder.structureDecoder(descriptor: SerialDescriptor): CompositeDecoder = when(descriptor.kind) {
         StructureKind.CLASS, StructureKind.OBJECT, PolymorphicKind.SEALED -> (value as Map<*, *>).let { map ->
-            FirebaseClassDecoder(map.size, { map.containsKey(it) }) { desc, index -> map[desc.getElementName(index)] }
+            FirebaseClassDecoder(map.size, { map.containsKey(it) }) { desc, index ->
+                val elementName = desc.getElementName(index)
+                if (desc.kind is PolymorphicKind && elementName == "value") {
+                    map
+                } else {
+                    map[desc.getElementName(index)]
+                }
+            }
         }
         StructureKind.LIST -> (value as List<*>).let {
             FirebaseCompositeDecoder(it.size) { _, index -> it[index] }

firebase-common/src/commonMain/kotlin/dev/gitlive/firebase/serializers.kt

@@ -108,7 +108,7 @@ class FirebaseListSerializer : KSerializer<Iterable<Any?>> {
  * A special case of serializer for values natively supported by Firebase and
  * don't require an additional encoding/decoding.
  */
-abstract class SpecialValueSerializer<T>(
+class SpecialValueSerializer<T>(
     serialName: String,
     private val toNativeValue: (T) -> Any?,
     private val fromNativeValue: (Any?) -> T

firebase-common/src/commonTest/kotlin/dev/gitlive/firebase/EncodersTest.kt

@@ -11,10 +11,6 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNull
 
-expect fun nativeMapOf(vararg pairs: Pair<String, Any?>): Any
-expect fun nativeListOf(vararg elements: Any): Any
-expect fun nativeAssertEquals(expected: Any?, actual: Any?): Unit
-
 @Serializable
 data class TestData(val map: Map<String, String>, val bool: Boolean = false, val nullableBool: Boolean? = null)
 
@@ -25,6 +21,9 @@ sealed class TestSealed {
     data class ChildClass(val map: Map<String, String>, val bool: Boolean = false): TestSealed()
 }
 
+@Serializable
+data class TestSealedList(val list: List<TestSealed>)
+
 class EncodersTest {
     @Test
     fun encodeMap() {
@@ -74,4 +73,62 @@ class EncodersTest {
         val decoded = decode(TestSealed.serializer(), nativeMapOf("type" to "child", "map" to nativeMapOf("key" to "value"), "bool" to true))
         assertEquals(TestSealed.ChildClass(mapOf("key" to "value"), true), decoded)
     }
+
+    @Test
+    fun encodeSealedClassList() {
+        val toEncode = TestSealedList(
+            list = listOf(
+                TestSealed.ChildClass(
+                    map = mapOf("key" to "value"),
+                    bool = false
+                )
+            )
+        )
+        val encoded = encode<TestSealedList>(
+            TestSealedList.serializer(),
+            toEncode,
+            shouldEncodeElementDefault = true
+        )
+        val expected = nativeMapOf(
+            "list" to nativeListOf(
+                nativeMapOf(
+                    "type" to "child",
+                    "map" to nativeMapOf(
+                        "key" to "value"
+                    ),
+                    "bool" to false
+                )
+            )
+        )
+        nativeAssertEquals(expected, encoded)
+    }
+
+    @Test
+    fun decodeSealedClassList() {
+        val toDecode = nativeMapOf(
+            "list" to nativeListOf(
+                nativeMapOf(
+                    "type" to "child",
+                    "map" to nativeMapOf(
+                        "key" to "value"
+                    ),
+                    "bool" to false
+                )
+            )
+        )
+        val decoded = decode(
+            TestSealedList.serializer(),
+            toDecode
+        )
+        val expected = TestSealedList(
+            list = listOf(
+                TestSealed.ChildClass(
+                    map = mapOf("key" to "value"),
+                    bool = false
+                )
+            )
+        )
+
+        assertEquals(expected, decoded)
+    }
 }

firebase-common/src/iosMain/kotlin/dev/gitlive/firebase/_decoders.kt

@@ -11,7 +11,14 @@ import kotlinx.serialization.descriptors.StructureKind
 
 actual fun FirebaseDecoder.structureDecoder(descriptor: SerialDescriptor): CompositeDecoder = when(descriptor.kind) {
     StructureKind.CLASS, StructureKind.OBJECT, PolymorphicKind.SEALED -> (value as Map<*, *>).let { map ->
-        FirebaseClassDecoder(map.size, { map.containsKey(it) }) { desc, index -> map[desc.getElementName(index)] }
+        FirebaseClassDecoder(map.size, { map.containsKey(it) }) { desc, index ->
+            val elementName = desc.getElementName(index)
+            if (desc.kind is PolymorphicKind && elementName == "value") {
+                map
+            } else {
+                map[desc.getElementName(index)]
+            }
+        }
     }
     StructureKind.LIST -> (value as List<*>).let {
         FirebaseCompositeDecoder(it.size) { _, index -> it[index] }

firebase-common/src/jsMain/kotlin/dev/gitlive/firebase/_decoders.kt

@@ -13,8 +13,13 @@ import kotlin.js.Json
 @Suppress("UNCHECKED_CAST_TO_EXTERNAL_INTERFACE")
 actual fun FirebaseDecoder.structureDecoder(descriptor: SerialDescriptor): CompositeDecoder = when(descriptor.kind) {
     StructureKind.CLASS, StructureKind.OBJECT, PolymorphicKind.SEALED -> (value as Json).let { json ->
-        FirebaseClassDecoder(js("Object").keys(value).length as Int, { json[it] != undefined }) {
-                desc, index -> json[desc.getElementName(index)]
+        FirebaseClassDecoder(js("Object").keys(value).length as Int, { json[it] != undefined }) { desc, index ->
+            val elementName = desc.getElementName(index)
+            if (desc.kind is PolymorphicKind && elementName == "value") {
+                json
+            } else {
+                json[desc.getElementName(index)]
+            }
         }
     }
     StructureKind.LIST -> (value as Array<*>).let {

firebase-common/src/jsMain/kotlin/dev/gitlive/firebase/externals.kt

@@ -276,7 +276,6 @@ external object firebase {
     object functions {
         class Functions {
             fun httpsCallable(name: String, options: Json?): HttpsCallable
-            fun useFunctionsEmulator(origin: String)
             fun useEmulator(host: String, port: Int)
         }
         interface HttpsCallableResult {
@@ -453,6 +452,8 @@ external object firebase {
             fun update(field: FieldPath, value: Any?, vararg moreFieldsAndValues: Any?): Promise<Unit>
             fun delete(): Promise<Unit>
             fun onSnapshot(next: (snapshot: DocumentSnapshot) -> Unit, error: (error: Error) -> Unit): ()->Unit
+
+            fun isEqual(other: DocumentReference): Boolean
         }
 
         open class WriteBatch {
@@ -477,6 +478,8 @@ external object firebase {
             companion object {
                 val documentId: FieldPath
             }
+
+            fun isEqual(other: FieldPath): Boolean
         }
 
         abstract class FieldValue {
@@ -490,6 +493,13 @@ external object firebase {
 
             fun isEqual(other: FieldValue): Boolean
         }
+
+        open class GeoPoint(latitude: Double, longitude: Double) {
+            val latitude: Double
+            val longitude: Double
+
+            fun isEqual(other: GeoPoint): Boolean
+        }
     }
 
     fun remoteConfig(app: App? = definedExternally): remoteConfig.RemoteConfig