Support Swift 6 Strict Concurrency Checking (#70)

Author: stevensJourney

.github/workflows/build_and_test.yaml

@@ -19,3 +19,20 @@ jobs:
           xcodebuild test -scheme PowerSync -destination "platform=iOS Simulator,name=iPhone 16"
           xcodebuild test -scheme PowerSync -destination "platform=macOS,arch=arm64,name=My Mac"
           xcodebuild test -scheme PowerSync -destination "platform=watchOS Simulator,arch=arm64,name=Apple Watch Ultra 2 (49mm)"
+
+  buildSwift6:
+    name: Build and test with Swift 6
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up XCode
+        uses: maxim-lobanov/setup-xcode@v1
+        with:
+          xcode-version: latest-stable
+      - name: Use Swift 6
+        run: |
+          sed -i '' 's|^// swift-tools-version:.*$|// swift-tools-version:6.1|' Package.swift
+      - name: Build and Test
+        run: |
+          swift build -Xswiftc -strict-concurrency=complete
+          swift test -Xswiftc -strict-concurrency=complete

.gitignore

@@ -69,6 +69,7 @@ DerivedData/
 .swiftpm/configuration/registries.json
 .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 .netrc
-
+.vscode
+.sourcekit-lsp
 
 Secrets.swift

CHANGELOG.md

@@ -3,6 +3,13 @@
 ## Unreleased
 
 * Fix null values in CRUD entries being reported as strings.
+* Added support for Swift 6 strict concurrency checking.
+  - Accepted query parameter types have been updated from `[Any]` to `[Sendable]`. This should cover all supported query parameter types.
+  - Query and lock methods' return `Result` generic types now should extend `Sendable`.
+  - Deprecated default `open class PowerSyncBackendConnector`. Devs should preferably implement the `PowerSyncBackendConnectorProtocol`
+
+* *Potential Breaking Change*: Attachment helpers have been updated to better support Swift 6 strict concurrency checking. `Actor` isolation is improved, but developers who customize or extend `AttachmentQueue` will need to update their implementations. The default instantiation of `AttachmentQueue` remains unchanged.
+`AttachmentQueueProtocol` now defines the basic requirements for an attachment queue, with most base functionality provided via an extension. Custom implementations should extend `AttachmentQueueProtocol`.
 * [Internal] Instantiate Kotlin Kermit logger directly.
 * [Internal] Improved connection context error handling.
 

Demo/PowerSyncExample.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -38,7 +38,7 @@ private enum PostgresFatalCodes {
 }
 
 @Observable
-class SupabaseConnector: PowerSyncBackendConnector {
+final class SupabaseConnector: PowerSyncBackendConnectorProtocol {
     let powerSyncEndpoint: String = Secrets.powerSyncEndpoint
     let client: SupabaseClient = .init(
         supabaseURL: Secrets.supabaseURL,
@@ -50,8 +50,7 @@ class SupabaseConnector: PowerSyncBackendConnector {
     @ObservationIgnored
     private var observeAuthStateChangesTask: Task<Void, Error>?
 
-    override init() {
-        super.init()
+    init() {
         session = client.auth.currentSession
         observeAuthStateChangesTask = Task { [weak self] in
             guard let self = self else { return }
@@ -80,7 +79,7 @@ class SupabaseConnector: PowerSyncBackendConnector {
         return client.storage.from(bucket)       
     }
 
-    override func fetchCredentials() async throws -> PowerSyncCredentials? {
+    func fetchCredentials() async throws -> PowerSyncCredentials? {
         session = try await client.auth.session
 
         if session == nil {
@@ -92,7 +91,7 @@ class SupabaseConnector: PowerSyncBackendConnector {
         return PowerSyncCredentials(endpoint: powerSyncEndpoint, token: token)
     }
 
-    override func uploadData(database: PowerSyncDatabaseProtocol) async throws {
+    func uploadData(database: PowerSyncDatabaseProtocol) async throws {
         guard let transaction = try await database.getNextCrudTransaction() else { return }
 
         var lastEntry: CrudEntry?

Demo/PowerSyncExample/PowerSync/SupabaseConnector.swift

@@ -225,17 +225,17 @@ class SystemManager {
         if let attachments, let photoId = todo.photoId {
             try await attachments.deleteFile(
                 attachmentId: photoId
-            ) { tx, _ in
+            ) { transaction, _ in
                 try self.deleteTodoInTX(
                     id: todo.id,
-                    tx: tx
+                    tx: transaction
                 )
             }
         } else {
-            try await db.writeTransaction { tx in
+            try await db.writeTransaction { transaction in
                 try self.deleteTodoInTX(
                     id: todo.id,
-                    tx: tx
+                    tx: transaction
                 )
             }
         }

Demo/PowerSyncExample/PowerSync/SystemManager.swift

@@ -6,23 +6,23 @@ import PowerSyncKotlin
 private class KermitLogWriterAdapter: Kermit_coreLogWriter {
     /// The underlying Swift log writer to forward log messages to.
     let logger: any LoggerProtocol
-    
+
     /// Initializes a new adapter.
     ///
     /// - Parameter logger: A Swift log writer that will handle log output.
     init(logger: any LoggerProtocol) {
         self.logger = logger
         super.init()
     }
-    
+
     /// Called by Kermit to log a message.
     ///
     /// - Parameters:
     ///   - severity: The severity level of the log.
     ///   - message: The content of the log message.
     ///   - tag: A string categorizing the log.
     ///   - throwable: An optional Kotlin exception (ignored here).
-    override func log(severity: Kermit_coreSeverity, message: String, tag: String, throwable: KotlinThrowable?) {
+    override func log(severity: Kermit_coreSeverity, message: String, tag: String, throwable _: KotlinThrowable?) {
         switch severity {
         case PowerSyncKotlin.Kermit_coreSeverity.verbose:
             return logger.debug(message, tag: tag)
@@ -43,7 +43,7 @@ private class KermitLogWriterAdapter: Kermit_coreLogWriter {
 class KotlinKermitLoggerConfig: PowerSyncKotlin.Kermit_coreLoggerConfig {
     var logWriterList: [Kermit_coreLogWriter]
     var minSeverity: PowerSyncKotlin.Kermit_coreSeverity
-    
+
     init(logWriterList: [Kermit_coreLogWriter], minSeverity: PowerSyncKotlin.Kermit_coreSeverity) {
         self.logWriterList = logWriterList
         self.minSeverity = minSeverity
@@ -54,46 +54,46 @@ class KotlinKermitLoggerConfig: PowerSyncKotlin.Kermit_coreLoggerConfig {
 ///
 /// This class bridges Swift log writers with the Kotlin logging system and supports
 /// runtime configuration of severity levels and writer lists.
-class DatabaseLogger: LoggerProtocol {
+final class DatabaseLogger: LoggerProtocol {
     /// The underlying Kermit logger instance provided by the PowerSyncKotlin SDK.
     public let kLogger: PowerSyncKotlin.KermitLogger
     public let logger: any LoggerProtocol
-    
+
     /// Initializes a new logger with an optional list of writers.
     ///
     /// - Parameter logger: A logger which will be called for each internal log operation
     init(_ logger: any LoggerProtocol) {
         self.logger = logger
         // Set to the lowest severity. The provided logger should filter by severity
-        self.kLogger = PowerSyncKotlin.KermitLogger(
+        kLogger = PowerSyncKotlin.KermitLogger(
             config: KotlinKermitLoggerConfig(
                 logWriterList: [KermitLogWriterAdapter(logger: logger)],
                 minSeverity: Kermit_coreSeverity.verbose
             ),
             tag: "PowerSync"
         )
     }
-    
+
     /// Logs a debug-level message.
     public func debug(_ message: String, tag: String?) {
         logger.debug(message, tag: tag)
     }
-    
+
     /// Logs an info-level message.
     public func info(_ message: String, tag: String?) {
         logger.info(message, tag: tag)
     }
-    
+
     /// Logs a warning-level message.
     public func warning(_ message: String, tag: String?) {
         logger.warning(message, tag: tag)
     }
-    
+
     /// Logs an error-level message.
     public func error(_ message: String, tag: String?) {
         logger.error(message, tag: tag)
     }
-    
+
     /// Logs a fault (assert-level) message, typically used for critical issues.
     public func fault(_ message: String, tag: String?) {
         logger.fault(message, tag: tag)