Implement connection pool in Swift, remove Kotlin framework

CHANGELOG.md

@@ -2,8 +2,14 @@
 
 ## 1.14.0 (unreleased)
 
+* Remove internal dependency on the PowerSync Kotlin SDK. Going forward, the Swift SDK is implemented in Swift!
+  __Important__: While these changes are tested, they are a full rewrite of the internal connection pool logic.
+  Please also test queries in your app after upgrading.
 * Add `opDataTyped` and `previousValuesTyped` to `CrudEntry`, providing typed values instead of strings.
 * Make `CrudBatch`, `CrudEntry` and `CrudTransaction` a concrete struct. Note that these can no longer be created in user code.
+* Remove the internal `withSession` API.
+* Breaking (for internal `SQLiteConnectionPoolProtocol` implementers): Make callbacks generic.
+* Breaking (for internal `SQLiteConnectionLease` implementers): Add methods to run statements.
 
 ## 1.13.1
 

Demos/GRDBDemo/GRDBDemo.xcodeproj/project.pbxproj

@@ -314,7 +314,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = 1;
-				DEVELOPMENT_TEAM = ZGT7463CVJ;
+				DEVELOPMENT_TEAM = N2FNDTNV98;
 				ENABLE_APP_SANDBOX = YES;
 				ENABLE_HARDENED_RUNTIME = YES;
 				ENABLE_INCOMING_NETWORK_CONNECTIONS = NO;
@@ -368,7 +368,7 @@
 				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = 1;
-				DEVELOPMENT_TEAM = ZGT7463CVJ;
+				DEVELOPMENT_TEAM = N2FNDTNV98;
 				ENABLE_APP_SANDBOX = YES;
 				ENABLE_HARDENED_RUNTIME = YES;
 				ENABLE_INCOMING_NETWORK_CONNECTIONS = NO;

Package.swift

@@ -5,10 +5,6 @@ import PackageDescription
 
 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
-
 // Set this to the absolute path of your powersync-sqlite-core checkout if you want to use a
 // local build of the core extension.
 let localCoreExtension: String? = nil
@@ -20,24 +16,6 @@ let localCoreExtension: String? = nil
 // towards a local framework build
 var conditionalDependencies: [Package.Dependency] = []
 var conditionalTargets: [Target] = []
-var kotlinTargetDependency = Target.Dependency.target(name: "PowerSyncKotlin")
-
-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.
-    conditionalDependencies.append(.package(path: "\(kotlinSdkPath)/internal/PowerSyncKotlin"))
-
-    kotlinTargetDependency = .product(name: "PowerSyncKotlin", package: "PowerSyncKotlin")
-} else {
-    // 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.11.2/PowersyncKotlinRelease.zip",
-            checksum: "bd4f9a4411a10a30bd67c3231d1d0d0dde42f0ec19161ccbd26d4e58b31efdfd"
-        ))
-}
 
 var corePackageName = "powersync-sqlite-core-swift"
 if let corePath = localCoreExtension {
@@ -84,20 +62,28 @@ let package = Package(
     dependencies: conditionalDependencies + [
         .package(url: "https://github.com/groue/GRDB.swift.git", from: "7.9.0"),
         .package(url: "https://github.com/powersync-ja/CSQLite.git", exact: "3.51.2"),
-        .package(url: "https://github.com/apple/swift-async-algorithms.git", from: "1.1.0")
+        .package(url: "https://github.com/apple/swift-async-algorithms.git", from: "1.1.0"),
+        .package(url: "https://github.com/apple/swift-collections.git", from: "1.4.0")
     ],
     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.
         .target(
             name: packageName,
             dependencies: [
-                kotlinTargetDependency,
-                .product(name: "PowerSyncSQLiteCore", package: corePackageName),
+                .target(name: "PowerSyncCoreShim"),
                 .product(name: "CSQLite", package: "CSQLite"),
-                .product(name: "AsyncAlgorithms", package: "swift-async-algorithms")
+                .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
+                .product(name: "BasicContainers", package: "swift-collections"),
+                .product(name: "DequeModule", package: "swift-collections")
             ]
         ),
+        .target(
+            name: "PowerSyncCoreShim",
+            dependencies: [
+                .product(name: "PowerSyncSQLiteCore", package: corePackageName),
+            ],
+        ),
         .target(
             name: "PowerSyncGRDB",
             dependencies: [

README.md

@@ -118,15 +118,6 @@ Feel free to use the `DatabasePool` for view logic and the `PowerSyncDatabase` f
 - Updating the PowerSync schema, with `updateSchema`, is not currently fully supported with GRDB connections.
 - This integration currently requires statically linking PowerSync and GRDB.
 - This implementation requires defining the PowerSync Schema and GRDB data types. This results in some duplication.
-- This implementation uses the SQLite session API to track updates made by the PowerSync SDK. This could use more memory compared to the Standard PowerSync SQLite implementation.
-- This implementation can cause warnings such as "Thread Performance Checker: Thread running at User-interactive quality-of-service class waiting on a lower QoS thread running at Default quality-of-service class. Investigate ways to avoid priority inversions". This will be addressed in a future release.
-
-## Underlying Kotlin Dependency
-
-The PowerSync Swift SDK makes use of the [PowerSync Kotlin SDK](https://github.com/powersync-ja/powersync-kotlin) and the API tool [SKIE](https://skie.touchlab.co/) under the hood to implement the Swift package.
-However, this dependency is resolved internally and all public APIs are written entirely in Swift.
-
-For more details, see the [Swift SDK reference](https://docs.powersync.com/client-sdk-references/swift) and generated [API references](https://powersync-ja.github.io/powersync-swift/documentation/powersync/).
 
 ## Attachments
 

Sources/PowerSync/Implementation/ActiveInstanceStore.swift

@@ -0,0 +1,65 @@
+final class DatabaseGroupCollection: Sendable {
+    private let groups: Mutex<[ActiveDatabaseGroupData]> = Mutex([])
+
+    fileprivate func closeGroup(identifier: String) {
+        groups.withLock { $0.removeAll { group in group.identifier == identifier } }
+    }
+
+    func referenceGroup(identifier: String, logger: LoggerProtocol) -> ActiveDatabaseGroup {
+        groups.withLock { activeDatabases in
+            let existingGroup = activeDatabases.first { $0.identifier == identifier }
+            let data: ActiveDatabaseGroupData
+            if let existingGroup {
+                logger.warning("""
+Multiple PowerSync instances for the same database have been detected.
+This can cause unexpected results.
+Please check your PowerSync client instantiation logic if this is not intentional.
+""", tag: "DatabaseGroupCollection")
+                data = existingGroup
+            } else {
+                data = ActiveDatabaseGroupData(identifier: identifier)
+                activeDatabases.append(data)
+            }
+
+            return ActiveDatabaseGroup(data: data, collection: self)
+        }
+    }
+
+    static let shared = DatabaseGroupCollection()
+}
+
+private final class ActiveDatabaseGroupData: Sendable {
+    let identifier: String
+    let syncCoordinator = SyncCoordinator()
+
+    init(identifier: String) {
+        self.identifier = identifier
+    }
+}
+
+/// A collection  of PowerSync databases with the same path / identifier.
+///
+/// We expect that each group will only ever have one database because we encourage users to write their databases as
+/// singletons. We print a warning when two databases are part of the same group.
+/// Additionally, we want to avoid two databases in the same group having a sync stream open at the same time to avoid
+/// duplicate resources being used. For this reason, each active database group has a single sync coordinator actor
+/// responsible for initializing the sync process for all databases in the group.
+final class ActiveDatabaseGroup: Sendable {
+    fileprivate let data: ActiveDatabaseGroupData
+    private weak let collection: DatabaseGroupCollection?
+
+    fileprivate init(data: ActiveDatabaseGroupData, collection: DatabaseGroupCollection) {
+        self.data = data
+        self.collection = collection
+    }
+
+    var syncCoordinator: SyncCoordinator {
+        data.syncCoordinator
+    }
+
+    deinit {
+        if let collection {
+            collection.closeGroup(identifier: self.data.identifier)
+        }
+    }
+}