Use latest GRDB package. Update tests and queries.

Author: stevensJourney

Package.resolved

@@ -78,7 +78,7 @@ let package = Package(
         )
     ],
     dependencies: conditionalDependencies + [
-        .package(url: "https://github.com/groue/GRDB.swift.git", from: "6.0.0")
+        .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.

Package.swift

@@ -7,43 +7,79 @@ import SQLite3
 // linking PowerSync provides them
 // Declare the missing function manually
 @_silgen_name("sqlite3_enable_load_extension")
-func sqlite3_enable_load_extension(_ db: OpaquePointer?, _ onoff: Int32) -> Int32
+func sqlite3_enable_load_extension(
+    _ db: OpaquePointer?,
+    _ onoff: Int32
+) -> Int32
 
 // Similarly for sqlite3_load_extension if needed:
 @_silgen_name("sqlite3_load_extension")
-func sqlite3_load_extension(_ db: OpaquePointer?, _ fileName: UnsafePointer<Int8>?, _ procName: UnsafePointer<Int8>?, _ errMsg: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>?) -> Int32
+func sqlite3_load_extension(
+    _ db: OpaquePointer?,
+    _ fileName: UnsafePointer<Int8>?,
+    _ procName: UnsafePointer<Int8>?,
+    _ errMsg: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>?
+) -> Int32
 
-enum PowerSyncGRDBConfigError: Error {
-    case bundleNotFound
+enum PowerSyncGRDBError: Error {
+    case coreBundleNotFound
     case extensionLoadFailed(String)
     case unknownExtensionLoadError
+    case connectionUnavailable
 }
 
-func configurePowerSync(_ config: inout Configuration) {
+struct PowerSyncSchemaSource: DatabaseSchemaSource {
+    let schema: Schema
+
+    func columnsForPrimaryKey(_: Database, inView view: DatabaseObjectID) throws -> [String]? {
+        if schema.tables.first(where: { table in
+            table.viewName == view.name
+        }) != nil {
+            return ["id"]
+        }
+        return nil
+    }
+}
+
+func configurePowerSync(
+    config: inout Configuration,
+    schema: Schema
+) {
+    // Register the PowerSync core extension
     config.prepareDatabase { database in
         guard let bundle = Bundle(identifier: "co.powersync.sqlitecore") else {
-            throw PowerSyncGRDBConfigError.bundleNotFound
+            throw PowerSyncGRDBError.coreBundleNotFound
         }
 
         // Construct the full path to the shared library inside the bundle
         let fullPath = bundle.bundlePath + "/powersync-sqlite-core"
 
-        let rc = sqlite3_enable_load_extension(database.sqliteConnection, 1)
-        if rc != SQLITE_OK {
-            throw PowerSyncGRDBConfigError.extensionLoadFailed("Could not enable extension loading")
+        let extensionLoadResult = sqlite3_enable_load_extension(database.sqliteConnection, 1)
+        if extensionLoadResult != SQLITE_OK {
+            throw PowerSyncGRDBError.extensionLoadFailed("Could not enable extension loading")
         }
         var errorMsg: UnsafeMutablePointer<Int8>?
         let loadResult = sqlite3_load_extension(database.sqliteConnection, fullPath, "sqlite3_powersync_init", &errorMsg)
         if loadResult != SQLITE_OK {
             if let errorMsg = errorMsg {
                 let message = String(cString: errorMsg)
                 sqlite3_free(errorMsg)
-                throw PowerSyncGRDBConfigError.extensionLoadFailed(message)
+                throw PowerSyncGRDBError.extensionLoadFailed(message)
             } else {
-                throw PowerSyncGRDBConfigError.unknownExtensionLoadError
+                throw PowerSyncGRDBError.unknownExtensionLoadError
             }
         }
     }
+
+    // Supply the PowerSync views as a SchemaSource
+    let powerSyncSchemaSource = PowerSyncSchemaSource(
+        schema: schema
+    )
+    if let schemaSource = config.schemaSource {
+        config.schemaSource = schemaSource.then(powerSyncSchemaSource)
+    } else {
+        config.schemaSource = powerSyncSchemaSource
+    }
 }
 
 class GRDBConnectionPool: SQLiteConnectionPoolProtocol {
@@ -60,7 +96,7 @@ class GRDBConnectionPool: SQLiteConnectionPoolProtocol {
     ) async throws {
         try await pool.read { database in
             guard let connection = database.sqliteConnection else {
-                return
+                throw PowerSyncGRDBError.connectionUnavailable
             }
             onConnection(connection)
         }
@@ -72,7 +108,7 @@ class GRDBConnectionPool: SQLiteConnectionPoolProtocol {
         // Don't start an explicit transaction
         try await pool.writeWithoutTransaction { database in
             guard let connection = database.sqliteConnection else {
-                return
+                throw PowerSyncGRDBError.connectionUnavailable
             }
             onConnection(connection)
         }

Sources/PowerSyncGRDB/GRDBPool.swift

@@ -14,12 +14,15 @@ final class GRDBTests: XCTestCase {
         schema = Schema(tables: [
             Table(name: "users", columns: [
                 .text("name"),
-                .text("count")
             ])
         ])
 
         var config = Configuration()
-        configurePowerSync(&config)
+        configurePowerSync(
+            config: &config,
+            schema: schema
+        )
+
         let documentsDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
         let dbURL = documentsDir.appendingPathComponent("test.sqlite")
         pool = try DatabasePool(
@@ -45,40 +48,54 @@ final class GRDBTests: XCTestCase {
     }
 
     func testValidValues() async throws {
-        let result = try await database.get(
-            "SELECT powersync_rs_version() as r"
-        ) { cursor in
-            try cursor.getString(index: 0)
-        }
-        print(result)
+        // Create users with the PowerSync SDK
+        let initialUserName = "Bob"
 
         try await database.execute(
-            "INSERT INTO users(id, name, count) VALUES(uuid(), 'steven', 1)"
+            sql: "INSERT INTO users(id, name) VALUES(uuid(), ?)",
+            parameters: [initialUserName]
         )
 
-        let initialUsers = try await database.getAll(
+        // Fetch those users
+        let initialUserNames = try await database.getAll(
             "SELECT * FROM users"
         ) { cursor in
             try cursor.getString(name: "name")
         }
-        print("initial users \(initialUsers)")
 
-        // Now use a GRDB query
-        struct Users: Codable, Identifiable, FetchableRecord, PersistableRecord {
+        XCTAssertTrue(initialUserNames.first == initialUserName)
+
+        // Now define a GRDB struct for query purposes
+        struct User: Codable, Identifiable, FetchableRecord, PersistableRecord {
             var id: String
             var name: String
-            var count: Int
+
+            static var databaseTableName = "users"
 
             enum Columns {
                 static let name = Column(CodingKeys.name)
-                static let count = Column(CodingKeys.count)
             }
         }
 
-        let grdbUsers = try await pool.write { db in
-            try Users.fetchAll(db)
+        // Query the Users with GRDB, this should have the same result as with PowerSync
+        let grdbUserNames = try await pool.read { database in
+            try User.fetchAll(database)
         }
 
-        print(grdbUsers)
+        XCTAssertTrue(grdbUserNames.first?.name == initialUserName)
+
+        // Insert a user with GRDB
+        try await pool.write { database in
+            try User(
+                id: UUID().uuidString,
+                name: "another",
+            ).insert(database)
+        }
+
+        let grdbUserNames2 = try await pool.read { database in
+            try User.order(User.Columns.name.asc).fetchAll(database)
+        }
+        XCTAssert(grdbUserNames2.count == 2)
+        XCTAssert(grdbUserNames2[1].name == "another")
     }
 }