Add typed variants of CRUD data

Author: simolus3

CHANGELOG.md

@@ -5,6 +5,8 @@
 * Added the ability to log PowerSync service HTTP request information via specifying a
   `SyncClientConfiguration` in the `SyncOptions.clientConfiguration` parameter used in
   `PowerSyncDatabase.connect()` calls.
+* `CrudEntry`: Add `data` and `typedPreviousValues` fields as typed variants of
+  `opData` and `previousValues`, respectively.
 
 ## 1.3.1
 

core/src/commonIntegrationTest/kotlin/com/powersync/CrudTest.kt

@@ -90,4 +90,59 @@ class CrudTest {
             val batch = database.getNextCrudTransaction()
             batch shouldBe null
         }
+
+    @Test
+    fun typedUpdates() =
+        databaseTest {
+            database.updateSchema(
+                Schema(
+                    Table(
+                        "foo",
+                        listOf(
+                            Column.text("a"),
+                            Column.integer("b"),
+                            Column.integer("c"),
+                        ),
+                        trackPreviousValues = TrackPreviousValuesOptions(onlyWhenChanged = true),
+                    ),
+                ),
+            )
+
+            database.writeTransaction { tx ->
+                tx.execute(
+                    "INSERT INTO foo (id,a,b,c) VALUES (uuid(), ?, ?, ?)",
+                    listOf(
+                        "text",
+                        42,
+                        13.37,
+                    ),
+                )
+                tx.execute(
+                    "UPDATE foo SET a = ?, b = NULL",
+                    listOf(
+                        "te\"xt",
+                    ),
+                )
+            }
+
+            val batch = database.getNextCrudTransaction()!!
+            batch.crud[0].data shouldBe
+                mapOf(
+                    "a" to "text",
+                    "b" to 42,
+                    "c" to 13.37,
+                )
+            batch.crud[0].typedPreviousValues shouldBe null
+
+            batch.crud[1].data shouldBe
+                mapOf(
+                    "a" to "te\"xt",
+                    "b" to null,
+                )
+            batch.crud[1].typedPreviousValues shouldBe
+                mapOf(
+                    "a" to "text",
+                    "b" to 42,
+                )
+        }
 }

core/src/commonMain/kotlin/com/powersync/db/crud/CrudEntry.kt

@@ -1,16 +1,17 @@
 package com.powersync.db.crud
 
-import com.powersync.PowerSyncDatabase
 import com.powersync.db.schema.Table
 import com.powersync.utils.JsonUtil
-import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
 
 /**
  * A single client-side change.
  */
-public data class CrudEntry(
+@ConsistentCopyVisibility
+public data class CrudEntry internal constructor(
     /**
      * ID of the changed row.
      */
@@ -57,35 +58,75 @@ public data class CrudEntry(
      *
      * For DELETE, this is null.
      */
+    @Deprecated("Use data instead", replaceWith = ReplaceWith("data"))
     val opData: Map<String, String?>?,
+    /**
+     * Data associated with the change.
+     *
+     * For PUT, this is contains all non-null columns of the row.
+     *
+     * For PATCH, this is contains the columns that changed.
+     *
+     * For DELETE, this is null.
+     */
+    val data: Map<String, Any?>?,
     /**
      * Previous values before this change.
      *
      * These values can be tracked for `UPDATE` statements when [Table.trackPreviousValues] is
      * enabled.
      */
+    @Deprecated("Use typedPreviousValues instead", replaceWith = ReplaceWith("typedPreviousValues"))
     val previousValues: Map<String, String?>? = null,
+    /**
+     * Previous values before this change.
+     *
+     * These values can be tracked for `UPDATE` statements when [Table.trackPreviousValues] is
+     * enabled.
+     */
+    val typedPreviousValues: Map<String, Any?>? = null,
 ) {
     public companion object {
         public fun fromRow(row: CrudRow): CrudEntry {
             val data = JsonUtil.json.parseToJsonElement(row.data).jsonObject
+            val opData = data["data"]?.asData()
+            val previousValues = data["old"]?.asData()
+
             return CrudEntry(
                 id = data["id"]!!.jsonPrimitive.content,
                 clientId = row.id.toInt(),
                 op = UpdateType.fromJsonChecked(data["op"]!!.jsonPrimitive.content),
-                opData =
-                    data["data"]?.jsonObject?.mapValues { (_, value) ->
-                        value.jsonPrimitive.contentOrNull
-                    },
+                opData = opData?.toStringMap(),
+                data = opData,
                 table = data["type"]!!.jsonPrimitive.content,
                 transactionId = row.txId,
                 metadata = data["metadata"]?.jsonPrimitive?.content,
-                previousValues =
-                    data["old"]?.jsonObject?.mapValues { (_, value) ->
-                        value.jsonPrimitive.contentOrNull
-                    },
+                typedPreviousValues = previousValues,
+                previousValues = previousValues?.toStringMap(),
             )
         }
+
+        private fun JsonElement.asData(): Map<String, Any?> =
+            jsonObject.mapValues { (_, value) ->
+                val primitive = value.jsonPrimitive
+                if (primitive === JsonNull) {
+                    null
+                } else if (primitive.isString) {
+                    primitive.content
+                } else {
+                    primitive.content.jsonNumberOrBoolean()
+                }
+            }
+
+        private fun String.jsonNumberOrBoolean(): Any =
+            when {
+                this == "true" -> true
+                this == "false" -> false
+                this.any { char -> char == '.' || char == 'e' || char == 'E' } -> this.toDouble()
+                else -> this.toInt()
+            }
+
+        private fun Map<String, Any?>.toStringMap(): Map<String, String> = mapValues { (_, v) -> v.toString() }
     }
 
     override fun toString(): String = "CrudEntry<$transactionId/$clientId ${op.toJson()} $table/$id $opData>"

core/src/commonTest/kotlin/com/powersync/bucket/BucketStorageTest.kt

@@ -79,6 +79,7 @@ class BucketStorageTest {
                         mapOf(
                             "key" to "value",
                         ),
+                    data = mapOf("key" to "value"),
                 )
             mockDb =
                 mock<InternalDatabase> {

core/src/commonTest/kotlin/com/powersync/sync/SyncStreamTest.kt

@@ -106,6 +106,7 @@ class SyncStreamTest {
                         mapOf(
                             "key" to "value",
                         ),
+                    data = mapOf("key" to "value"),
                 )
             bucketStorage =
                 mock<BucketStorage> {