[WIP] GRDB Support

Package.swift

@@ -7,7 +7,7 @@ let packageName = "PowerSync"
 
 // Set this to the absolute path of your Kotlin SDK checkout if you want to use a local Kotlin
 // build. Also see docs/LocalBuild.md for details
-let localKotlinSdkOverride: String? = nil
+let localKotlinSdkOverride: String? = "/Users/stevenontong/Documents/platform_code/powersync/powersync-kotlin"
 
 // Set this to the absolute path of your powersync-sqlite-core checkout if you want to use a
 // local build of the core extension.
@@ -71,9 +71,15 @@ let package = Package(
             // Dynamic linking is particularly important for XCode previews.
             type: .dynamic,
             targets: ["PowerSync"]
+        ),
+        .library(
+            name: "PowerSyncGRDB",
+            targets: ["PowerSyncGRDB"]
         )
     ],
-    dependencies: conditionalDependencies,
+    dependencies: conditionalDependencies + [
+        .package(url: "https://github.com/groue/GRDB.swift.git", branch: "dev/persistable-views")
+    ],
     targets: [
         // Targets are the basic building blocks of a package, defining a module or a test suite.
         // Targets can depend on other targets in this package and products from dependencies.
@@ -84,9 +90,20 @@ let package = Package(
                 .product(name: "PowerSyncSQLiteCore", package: corePackageName)
             ]
         ),
+        .target(
+            name: "PowerSyncGRDB",
+            dependencies: [
+                .target(name: "PowerSync"),
+                .product(name: "GRDB", package: "GRDB.swift")
+            ]
+        ),
         .testTarget(
             name: "PowerSyncTests",
             dependencies: ["PowerSync"]
+        ),
+        .testTarget(
+            name: "PowerSyncGRDBTests",
+            dependencies: ["PowerSync", "PowerSyncGRDB"]
         )
     ] + conditionalTargets
 )

Sources/PowerSync/Kotlin/KotlinPowerSyncDatabaseImpl.swift

@@ -11,18 +11,11 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol,
     let currentStatus: SyncStatus
 
     init(
-        schema: Schema,
-        dbFilename: String,
+        kotlinDatabase: PowerSyncKotlin.PowerSyncDatabase,
         logger: DatabaseLogger
     ) {
-        let factory = PowerSyncKotlin.DatabaseDriverFactory()
-        kotlinDatabase = PowerSyncDatabase(
-            factory: factory,
-            schema: KotlinAdapter.Schema.toKotlin(schema),
-            dbFilename: dbFilename,
-            logger: logger.kLogger
-        )
         self.logger = logger
+        self.kotlinDatabase = kotlinDatabase
         currentStatus = KotlinSyncStatus(
             baseStatus: kotlinDatabase.currentStatus
         )
@@ -401,6 +394,39 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol,
     }
 }
 
+func openKotlinDBWithFactory(
+    schema: Schema,
+    dbFilename: String,
+    logger: DatabaseLogger
+) -> PowerSyncDatabaseProtocol {
+    return KotlinPowerSyncDatabaseImpl(
+        kotlinDatabase: PowerSyncDatabase(
+            factory: PowerSyncKotlin.DatabaseDriverFactory(),
+            schema: KotlinAdapter.Schema.toKotlin(schema),
+            dbFilename: dbFilename,
+            logger: logger.kLogger
+        ),
+        logger: logger
+    )
+}
+
+func openKotlinDBWithPool(
+    schema: Schema,
+    pool: SQLiteConnectionPoolProtocol,
+    identifier: String,
+    logger: DatabaseLogger
+) -> PowerSyncDatabaseProtocol {
+    return KotlinPowerSyncDatabaseImpl(
+        kotlinDatabase: openPowerSyncWithPool(
+            pool: pool.toKotlin(),
+            identifier: identifier,
+            schema: KotlinAdapter.Schema.toKotlin(schema),
+            logger: logger.kLogger
+        ),
+        logger: logger
+    )
+}
+
 private struct ExplainQueryResult {
     let addr: String
     let opcode: String

Sources/PowerSync/Kotlin/KotlinSQLiteConnectionPool.swift

@@ -0,0 +1,82 @@
+import PowerSyncKotlin
+
+final class SwiftSQLiteConnectionPoolAdapter: PowerSyncKotlin.SwiftPoolAdapter {
+    let pool: SQLiteConnectionPoolProtocol
+
+    init(
+        pool: SQLiteConnectionPoolProtocol
+    ) {
+        self.pool = pool
+    }
+
+    func getPendingUpdates() -> Set<String> {
+        return pool.getPendingUpdates()
+    }
+
+    func __closePool() async throws {
+        do {
+            try pool.close()
+        } catch {
+            try? PowerSyncKotlin.throwPowerSyncException(
+                exception: PowerSyncException(
+                    message: error.localizedDescription,
+                    cause: nil
+                )
+            )
+        }
+    }
+
+    func __leaseRead(callback: @escaping (Any) -> Void) async throws {
+        do {
+            try await pool.read { pointer in
+                callback(UInt(bitPattern: pointer))
+            }
+        } catch {
+            try? PowerSyncKotlin.throwPowerSyncException(
+                exception: PowerSyncException(
+                    message: error.localizedDescription,
+                    cause: nil
+                )
+            )
+        }
+    }
+
+    func __leaseWrite(callback: @escaping (Any) -> Void) async throws {
+        do {
+            try await pool.write { pointer in
+                callback(UInt(bitPattern: pointer))
+            }
+        } catch {
+            try? PowerSyncKotlin.throwPowerSyncException(
+                exception: PowerSyncException(
+                    message: error.localizedDescription,
+                    cause: nil
+                )
+            )
+        }
+    }
+
+    func __leaseAll(callback: @escaping (Any, [Any]) -> Void) async throws {
+        // TODO, actually use all connections
+        do {
+            try await pool.write { pointer in
+                callback(UInt(bitPattern: pointer), [])
+            }
+        } catch {
+            try? PowerSyncKotlin.throwPowerSyncException(
+                exception: PowerSyncException(
+                    message: error.localizedDescription,
+                    cause: nil
+                )
+            )
+        }
+    }
+}
+
+extension SQLiteConnectionPoolProtocol {
+    func toKotlin() -> PowerSyncKotlin.SwiftSQLiteConnectionPool {
+        return PowerSyncKotlin.SwiftSQLiteConnectionPool(
+            adapter: SwiftSQLiteConnectionPoolAdapter(pool: self)
+        )
+    }
+}

Sources/PowerSync/PowerSyncDatabase.swift

@@ -14,10 +14,23 @@ public func PowerSyncDatabase(
     dbFilename: String = DEFAULT_DB_FILENAME,
     logger: (any LoggerProtocol) = DefaultLogger()
 ) -> PowerSyncDatabaseProtocol {
-
-    return KotlinPowerSyncDatabaseImpl(
+    return openKotlinDBWithFactory(
         schema: schema,
         dbFilename: dbFilename,
         logger: DatabaseLogger(logger)
     )
 }
+
+public func OpenedPowerSyncDatabase(
+    schema: Schema,
+    pool: any SQLiteConnectionPoolProtocol,
+    identifier: String,
+    logger: (any LoggerProtocol) = DefaultLogger()
+) -> PowerSyncDatabaseProtocol {
+    return openKotlinDBWithPool(
+        schema: schema,
+        pool: pool,
+        identifier: identifier,
+        logger: DatabaseLogger(logger)
+    )
+}

Sources/PowerSync/Protocol/SQLiteConnectionPool.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+/// An implementation of a connection pool providing asynchronous access to a single writer and multiple readers.
+/// This is the underlying pool implementation on which the higher-level PowerSync Swift SDK is built on.
+public protocol SQLiteConnectionPoolProtocol {
+    func getPendingUpdates() -> Set<String>
+
+    /// Calls the callback with a read-only connection temporarily leased from the pool.
+    func read(
+        onConnection: @Sendable @escaping (OpaquePointer) -> Void,
+    ) async throws
+
+    /// Calls the callback with a read-write connection temporarily leased from the pool.
+    func write(
+        onConnection: @Sendable @escaping (OpaquePointer) -> Void,
+    ) async throws
+
+    /// Invokes the callback with all connections leased from the pool.
+    func withAllConnections(
+        onConnection: @Sendable @escaping (
+            _ writer: OpaquePointer,
+            _ readers: [OpaquePointer]
+        ) -> Void,
+    ) async throws
+
+    /// Closes the connection pool and associated resources.
+    func close() throws
+}