Merge remote-tracking branch 'origin/encryption' into grdb-csqlite

Author: stevensJourney

Package.resolved

@@ -12,42 +12,26 @@ let localKotlinSdkOverride: String? = nil
 // local build of the core extension.
 let localCoreExtension: String? = nil
 
+// Currently encryption is required for GRDB integration
+let encryption = true
+
 // Our target and dependency setup is different when a local Kotlin SDK is used. Without the local
 // SDK, we have no package dependency on Kotlin and download the XCFramework from Kotlin releases as
 // a binary target.
 // With a local SDK, we point to a `Package.swift` within the Kotlin SDK containing a target pointing
 // towards a local framework build
 var conditionalDependencies: [Package.Dependency] = [
-    // We can't currently build with GRDB using this package
-    // We could use traits for this
-
-    // .package(
-    //     url: "https://github.com/sbooth/CSQLite.git",
-    //     from: "3.50.4",
-    //     traits: [
-    //         .defaults,
-    //         // CSQLite uses THREADSAFE=0 by default, which breaks PowerSync because we're using SQLite on
-    //         // multiple threads (it can lead to race conditions when closing connections sharing resources
-    //         // like shared memory, causing crashes).
-    //         // THREADSAFE=2 overrides the default, and is safe to use as long as a single SQLite connection
-    //         // is not shared between threads.
-    //         // TODO: Technically, we should not use .defaults because there's a logical conflict between
-    //         // the threadsafe options. Instead, we should spell out all defaults again and remove that
-    //         // thread-safety option.
-    //         // However, despite the docs explicitly saying something else, it looks like there's no way to
-    //         // disable default traits anyway (XCode compiles sqlite3.c with the default option even without
-    //         // .defaults being included here).
-    //         "THREADSAFE_2",
-    //         "ENABLE_SESSION"
-    //     ]
-    // )
-
-    // Using SQLCipher here since GRDB doesn't compile with CSQLite
-    .package(url: "https://github.com/sqlcipher/SQLCipher.swift.git", from: "4.10.0")
 ]
+
 var conditionalTargets: [Target] = []
 var kotlinTargetDependency = Target.Dependency.target(name: "PowerSyncKotlin")
 
+if encryption {
+    conditionalDependencies.append(.package(url: "https://github.com/sqlcipher/SQLCipher.swift.git", from: "4.10.0"))
+} else {
+    conditionalDependencies.append(.package(url: "https://github.com/sbooth/CSQLite.git", from: "3.50.4"))
+}
+
 if let kotlinSdkPath = localKotlinSdkOverride {
     // We can't depend on local XCFrameworks outside of this project's root, so there's a Package.swift
     // in the PowerSyncKotlin project pointing towards a local build.
@@ -114,15 +98,17 @@ let package = Package(
             dependencies: [
                 kotlinTargetDependency,
                 .product(name: "PowerSyncSQLiteCore", package: corePackageName),
-                // .product(name: "CSQLite", package: "CSQLite")
-                .product(name: "SQLCipher", package: "SQLCipher.swift") 
+                encryption ?
+                    .product(name: "SQLCipher", package: "SQLCipher.swift") :
+                    .product(name: "CSQLite", package: "CSQLite")
             ]
         ),
         .target(
             name: "PowerSyncGRDB",
             dependencies: [
                 .target(name: "PowerSync"),
                 .product(name: "GRDB", package: "GRDB.swift")
+              
             ]
         ),
         .testTarget(

Package.swift

@@ -393,14 +393,15 @@ final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol,
 func openKotlinDBDefault(
     schema: Schema,
     dbFilename: String,
-    logger: DatabaseLogger
+    logger: DatabaseLogger,
+    initialStatements: [String] = []
 ) -> PowerSyncDatabaseProtocol {
     let rc = sqlite3_initialize()
     if rc != 0 {
         fatalError("Call to sqlite3_initialize() failed with \(rc)")
     }
 
-    let factory = sqlite3DatabaseFactory(initialStatements: [])
+    let factory = sqlite3DatabaseFactory(initialStatements: initialStatements)
     return KotlinPowerSyncDatabaseImpl(
         kotlinDatabase: PowerSyncDatabase(
             factory: factory,

Sources/PowerSync/Kotlin/KotlinPowerSyncDatabaseImpl.swift

@@ -12,12 +12,14 @@ public let DEFAULT_DB_FILENAME = "powersync.db"
 public func PowerSyncDatabase(
     schema: Schema,
     dbFilename: String = DEFAULT_DB_FILENAME,
-    logger: (any LoggerProtocol) = DefaultLogger()
+    logger: (any LoggerProtocol) = DefaultLogger(),
+    initialStatements: [String] = []
 ) -> PowerSyncDatabaseProtocol {
     return openKotlinDBDefault(
         schema: schema,
         dbFilename: dbFilename,
-        logger: DatabaseLogger(logger)
+        logger: DatabaseLogger(logger),
+        initialStatements: initialStatements
     )
 }
 

Sources/PowerSync/PowerSyncDatabase.swift

@@ -0,0 +1,67 @@
+@testable import PowerSync
+import XCTest
+
+
+final class EncryptionTests: XCTestCase {
+
+    func testLinksSqlcipher() async throws {
+        let database = openKotlinDBDefault(
+            schema: Schema(),
+            dbFilename: ":memory:",
+            logger: DatabaseLogger(DefaultLogger())
+        )
+        
+        let version = try await database.get("pragma cipher_version", mapper:  {cursor in
+            try cursor.getString(index: 0)
+        });
+        
+        XCTAssertEqual(version, "4.11.0 community")
+        try await database.close()
+    }
+
+    func testEncryption() async throws {
+        let database = openKotlinDBDefault(
+            schema: Schema(tables: [
+                Table(
+                    name: "users",
+                    columns: [
+                        .text("name")
+                    ]
+                ),
+            ]),
+            dbFilename: "encrypted.db",
+            logger: DatabaseLogger(DefaultLogger()),
+            initialStatements: [
+                "pragma key = 'foobar'"
+            ],
+        )
+
+        try await database.execute("INSERT INTO users (id, name) VALUES (uuid(), 'test')")
+        try await database.close()
+
+        let another = openKotlinDBDefault(
+            schema: Schema(tables: [
+                Table(
+                    name: "users",
+                    columns: [
+                        .text("name")
+                    ]
+                ),
+            ]),
+            dbFilename: "encrypted.db",
+            logger: DatabaseLogger(DefaultLogger()),
+            initialStatements: [
+                "pragma key = 'wrong password'"
+            ],
+        )
+        
+        var hadError = false
+        do {
+            try await database.execute("DELETE FROM users")
+        } catch let error {
+            hadError = true
+        }
+        
+        XCTAssertTrue(hadError)
+    }
+}