Export resolvePowerSyncLoadableExtensionPath from PowerSync SDK.

Use resolvePowerSyncLoadableExtensionPath for GRDB integration.
Fix WatchOS tests.

Author: stevensJourney

Sources/PowerSync/Kotlin/kotlinResolvePowerSyncLoadableExtensionPath.swift

@@ -0,0 +1,9 @@
+import PowerSyncKotlin
+
+func kotlinResolvePowerSyncLoadableExtensionPath() throws -> String? {
+    do {
+        return try PowerSyncKotlin.resolvePowerSyncLoadableExtensionPath() 
+    } catch {
+        throw PowerSyncError.operationFailed(message: "Failed to resolve PowerSync loadable extension path: \(error.localizedDescription)")
+    }
+}

Sources/PowerSync/resolvePowerSyncLoadableExtensionPath.swift

@@ -0,0 +1,61 @@
+/// Resolves the PowerSync SQLite extension path.
+///
+/// This function returns the file system path to the PowerSync SQLite extension library.
+/// For use with extension loading APIs or SQLite queries.
+///
+/// ## Platform Behavior
+///
+/// ### watchOS
+/// On watchOS, the extension needs to be loaded statically. This function returns `nil`
+/// on watchOS because the extension is statically linked and doesn't require a path.
+/// Calling this function will auto-register the extension in watchOS. The static
+/// initialization ensures the extension is available without requiring dynamic loading.
+///
+/// ### Other Platforms
+/// In other environments (iOS, macOS, tvOS, etc.), the extension needs to be loaded
+/// dynamically using the path returned by this function. You'll need to:
+/// 1. Enable extension loading on your SQLite connection
+/// 2. Load the extension using the returned path
+///
+/// ## Example Usage
+///
+/// ### Loading with SQLite API
+/// ```swift
+/// guard let extensionPath = try resolvePowerSyncLoadableExtensionPath() else {
+///     // On watchOS, extension is statically loaded, no path needed
+///     return
+/// }
+///
+/// // Enable extension loading
+/// sqlite3_enable_load_extension(db, 1)
+///
+/// // Load the extension
+/// var errorMsg: UnsafeMutablePointer<Int8>?
+/// let result = sqlite3_load_extension(
+///     db,
+///     extensionPath,
+///     "sqlite3_powersync_init",
+///     &errorMsg
+/// )
+/// if result != SQLITE_OK {
+///     // Handle error
+/// }
+/// ```
+///
+/// ### Loading with SQL Query
+/// ```swift
+/// guard let extensionPath = try resolvePowerSyncLoadableExtensionPath() else {
+///     // On watchOS, extension is statically loaded, no path needed
+///     return
+/// }
+/// let escapedPath = extensionPath.replacingOccurrences(of: "'", with: "''")
+/// let query = "SELECT load_extension('\(escapedPath)', 'sqlite3_powersync_init')"
+/// try db.execute(sql: query)
+/// ```
+///
+/// - Returns: The file system path to the PowerSync SQLite extension, or `nil` on watchOS
+///   (where the extension is statically loaded and doesn't require a path)
+/// - Throws: An error if the extension path cannot be resolved on platforms that require it
+public func resolvePowerSyncLoadableExtensionPath() throws -> String? {
+    return try kotlinResolvePowerSyncLoadableExtensionPath()
+}

Sources/PowerSyncGRDB/Config/Configuration+PowerSync.swift

@@ -25,37 +25,35 @@ public extension Configuration {
     ) {
         // Register the PowerSync core extension
         prepareDatabase { database in
-            #if os(watchOS)
-                // Use static initialization on watchOS
+            let initResult = sqlite3_powersync_init(database.sqliteConnection, nil, nil)
+            if initResult != SQLITE_OK {
+                throw PowerSyncGRDBError.extensionLoadFailed("Could not initialize PowerSync")
+            }
+            guard let extensionPath = try resolvePowerSyncLoadableExtensionPath() else {
+                // We get the extension path for non WatchOS platforms.
+                // The Kotlin registration for automatically loading the extension does not seem to work.
+                // We explicitly initialize the extension here.
                 let initResult = sqlite3_powersync_init(database.sqliteConnection, nil, nil)
                 if initResult != SQLITE_OK {
                     throw PowerSyncGRDBError.extensionLoadFailed("Could not initialize PowerSync statically")
                 }
-            #else
-                // Dynamic loading on other platforms
-                guard let bundle = Bundle(identifier: "co.powersync.sqlitecore") else {
-                    throw PowerSyncGRDBError.coreBundleNotFound
+                return
+            }
+            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, extensionPath, "sqlite3_powersync_init", &errorMsg)
+            if loadResult != SQLITE_OK {
+                if let errorMsg = errorMsg {
+                    let message = String(cString: errorMsg)
+                    sqlite3_free(errorMsg)
+                    throw PowerSyncGRDBError.extensionLoadFailed(message)
+                } else {
+                    throw PowerSyncGRDBError.unknownExtensionLoadError
                 }
-
-                // Construct the full path to the shared library inside the bundle
-                let fullPath = bundle.bundlePath + "/powersync-sqlite-core"
-
-                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 PowerSyncGRDBError.extensionLoadFailed(message)
-                    } else {
-                        throw PowerSyncGRDBError.unknownExtensionLoadError
-                    }
-                }
-            #endif
+            }
         }
 
         // Supply the PowerSync views as a SchemaSource

Tests/PowerSyncGRDBTests/BasicTest.swift

@@ -63,7 +63,16 @@ final class GRDBTests: XCTestCase {
             schema: schema
         )
 
-        let documentsDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+        guard let documentsDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else {
+            throw XCTestError(
+                .failureWhileWaiting,
+                userInfo: [NSLocalizedDescriptionKey: "Could not access documents directory"]
+            )
+        }
+
+        // Ensure the documents directory exists
+        try FileManager.default.createDirectory(at: documentsDir, withIntermediateDirectories: true, attributes: nil)
+
         let dbURL = documentsDir.appendingPathComponent("test.sqlite")
         pool = try DatabasePool(
             path: dbURL.path,
@@ -80,8 +89,10 @@ final class GRDBTests: XCTestCase {
     }
 
     override func tearDown() async throws {
-        try await database.disconnectAndClear()
+        try? await database?.disconnectAndClear()
         database = nil
+        try? pool?.close()
+        pool = nil
         try await super.tearDown()
     }