Update PowerSync Kotlin and core extension

Author: simolus3

Package.resolved

@@ -38,8 +38,8 @@ if let kotlinSdkPath = localKotlinSdkOverride {
     // Not using a local build, so download from releases
     conditionalTargets.append(.binaryTarget(
         name: "PowerSyncKotlin",
-        url: "https://github.com/powersync-ja/powersync-kotlin/releases/download/v1.7.0/PowersyncKotlinRelease.zip",
-        checksum: "836ac106c26a184c10373c862745d9af195737ad01505bb965f197797aa88535"
+        url: "https://github.com/powersync-ja/powersync-kotlin/releases/download/v1.8.0/PowersyncKotlinRelease.zip",
+        checksum: "31ac7c5e11d747e11bceb0b34f30438d37033e700c621b0a468aa308d887587f"
     ))
 }
 
@@ -51,7 +51,7 @@ if let corePath = localCoreExtension {
     // Not using a local build, so download from releases
     conditionalDependencies.append(.package(
         url: "https://github.com/powersync-ja/powersync-sqlite-core-swift.git",
-        exact: "0.4.6"
+        exact: "0.4.8"
     ))
 }
 

Package.swift

@@ -49,7 +49,8 @@ enum KotlinAdapter {
             return PowerSyncKotlin.RawTable(
                 name: table.name,
                 put: translateStatement(table.put),
-                delete: translateStatement(table.delete)
+                delete: translateStatement(table.delete),
+                clear: table.clear,
             );
         }
 

Sources/PowerSync/Kotlin/KotlinAdapter.swift

@@ -89,7 +89,8 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol,
 
     func disconnectAndClear(clearLocal: Bool = true) async throws {
         try await kotlinDatabase.disconnectAndClear(
-            clearLocal: clearLocal
+            clearLocal: clearLocal,
+            soft: false
         )
     }
 

Sources/PowerSync/Kotlin/KotlinPowerSyncDatabaseImpl.swift

@@ -216,12 +216,20 @@ public protocol PowerSyncDatabaseProtocol: Queries, Sendable {
     func disconnect() async throws
 
     /// Disconnect and clear the database.
-    /// Use this when logging out.
-    /// The database can still be queried after this is called, but the tables
-    /// would be empty.
     ///
-    /// - Parameter clearLocal: Set to false to preserve data in local-only tables. Defaults to `true`.
-    func disconnectAndClear(clearLocal: Bool) async throws
+    /// Clearing the database is useful when a user logs out, to ensure another user logging in later would not see
+    /// previous data.
+    ///
+    /// The database can still be queried after this is called, but the tables would be empty.
+    ///
+    /// To perserve data in local-only tables, set `clearLocal` to `false`.
+    ///
+    /// A `soft` clear deletes publicly visible data, but keeps internal copies of data synced in the database. This
+    /// usually means that if the same user logs out and back in again, the first sync is very fast because all internal
+    /// data is still available. When a different user logs in, no old data would be visible at any point.
+    /// Using soft clears is recommended where it's not a security issue that old data could be reconstructed from
+    /// the database.
+    func disconnectAndClear(clearLocal: Bool, soft: Bool) async throws
 
     /// Close the database, releasing resources.
     /// Also disconnects any active connection.
@@ -289,8 +297,8 @@ public extension PowerSyncDatabaseProtocol {
         )
     }
 
-    func disconnectAndClear() async throws {
-        try await disconnectAndClear(clearLocal: true)
+    func disconnectAndClear(clearLocal: Bool = true, soft: Bool = false) async throws {
+        try await disconnectAndClear(clearLocal: clearLocal, soft: soft)
     }
 
     func getCrudBatch(limit: Int32 = 100) async throws -> CrudBatch? {

Sources/PowerSync/Protocol/PowerSyncDatabaseProtocol.swift

@@ -24,11 +24,15 @@ public struct RawTable: BaseTableProtocol {
 
     /// The statement to run when the sync client has to delete a row.
     public let delete: PendingStatement
+    
+    /// An optional statement to run when the database is cleared.
+    public let clear: String?
 
-    public init(name: String, put: PendingStatement, delete: PendingStatement) {
+    public init(name: String, put: PendingStatement, delete: PendingStatement, clear: String? = nil) {
         self.name = name
         self.put = put
         self.delete = delete
+        self.clear = clear
     }
 }
 

Sources/PowerSync/Protocol/Schema/RawTable.swift

@@ -238,4 +238,19 @@ final class CrudTests: XCTestCase {
         let finalTx = try await database.getNextCrudTransaction()
         XCTAssertEqual(finalTx!.crud.count, 15)
     }
+    
+    func testSoftClear() async throws {
+        try await database.execute(sql: "INSERT INTO users (id, name) VALUES (uuid(), ?)", parameters: ["test"]);
+        try await database.execute(sql: "INSERT INTO ps_buckets (name, last_applied_op) VALUES (?, ?)", parameters: ["bkt", 10])
+        
+        // Doing a soft-clear should delete data but keep the bucket around.
+        try await database.disconnectAndClear(soft: true)
+        let entries = try await database.getAll("SELECT name FROM ps_buckets", mapper: { cursor in try cursor.getString(index: 0) })
+        XCTAssertEqual(entries.count, 1)
+        
+        // Doing a default clear also deletes buckets.
+        try await database.disconnectAndClear();
+        let newEntries = try await database.getAll("SELECT name FROM ps_buckets", mapper: { cursor in try cursor.getString(index: 0) })
+        XCTAssertEqual(newEntries.count, 0)
+    }
 }