chore: add tests

Author: DominicGBauer

.github/workflows/build_and_test.yaml

@@ -0,0 +1,22 @@
+name: Build and test
+
+on:
+  push
+
+jobs:
+  build:
+    name: Swift ${{ matrix.swift }} on ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        swift: ["5.7", "6.0"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: swift-actions/setup-swift@v2
+        with:
+          swift-version: ${{ matrix.swift }}
+      - uses: actions/checkout@v4
+      - name: Build
+        run: swift build
+      - name: Run tests
+        run: swift test

Demo/PowerSyncExample/Components/AddListView.swift

@@ -13,9 +13,9 @@ struct AddListView: View {
                 Task.detached {
                     do {
                         try await powerSync.insertList(newList)
-                        completion(.success(true))
+                        await completion(.success(true))
                     } catch {
-                        completion(.failure(error))
+                        await completion(.failure(error))
                         throw error
                     }
                 }

Demo/PowerSyncExample/Components/AddTodoListView.swift

@@ -15,9 +15,9 @@ struct AddTodoListView: View {
                 Task.detached {
                     do {
                         try await powerSync.insertTodo(newTodo, listId)
-                        completion(.success(true))
+                        await completion(.success(true))
                     } catch {
-                        completion(.failure(error))
+                        await completion(.failure(error))
                         throw error
                     }
                 }

Demo/PowerSyncExample/PowerSync/PowerSyncManager.swift

@@ -8,14 +8,14 @@ class PowerSyncManager {
     let schema = AppSchema
     var db: PowerSyncDatabaseProtocol!
 
+    // openDb must be called before connect
     func openDb() {
         db = PowerSyncDatabase(schema: schema, dbFilename: "powersync-swift.sqlite")
     }
-
-    // openDb must be called before connect
+    
     func connect() async {
         do {
-            try await db.connect(connector: connector, crudThrottleMs: 1000, retryDelayMs:5000, params: [:])
+            try await db.connect(connector: connector)
         } catch {
             print("Unexpected error: \(error.localizedDescription)") // Catches any other error
         }
@@ -30,12 +30,12 @@ class PowerSyncManager {
     }
 
     func signOut() async throws -> Void {
-        try await db.disconnectAndClear(clearLocal: true)
+        try await db.disconnectAndClear()
         try await connector.client.auth.signOut()
     }
 
     func watchLists(_ callback: @escaping (_ lists: [ListContent]) -> Void ) async {
-        for await lists in self.db.watch(
+        for await lists in self.db.watch<[ListContent]>(
             sql: "SELECT * FROM \(LISTS_TABLE)",
             parameters: [],
             mapper: { cursor in

Demo/PowerSyncExample/PowerSync/Schema.swift

@@ -1,5 +1,5 @@
 import Foundation
-import PowerSync
+import PowerSyncSwift
 
 let LISTS_TABLE = "lists"
 let TODOS_TABLE = "todos"
@@ -8,40 +8,32 @@ let lists = Table(
     name: LISTS_TABLE,
     columns: [
         // ID column is automatically included
-        Column(name: "name", type: ColumnType.text),
-        Column(name: "created_at", type: ColumnType.text),
-        Column(name: "owner_id", type: ColumnType.text)
-    ],
-    indexes: [],
-    localOnly: false,
-    insertOnly: false,
-    viewNameOverride: LISTS_TABLE
+        .text("name"),
+        .text("created_at"),
+        .text("owner_id")
+    ]
 )
 
 let todos = Table(
     name: TODOS_TABLE,
     // ID column is automatically included
     columns: [
-        Column(name: "list_id", type: ColumnType.text),
-        Column(name: "photo_id", type: ColumnType.text),
-        Column(name: "description", type: ColumnType.text),
+        Column.text("list_id"),
+        Column.text("photo_id"),
+        Column.text("description"),
         // 0 or 1 to represent false or true
-        Column(name: "completed", type: ColumnType.integer),
-        Column(name: "created_at", type: ColumnType.text),
-        Column(name: "completed_at", type: ColumnType.text),
-        Column(name: "created_by", type: ColumnType.text),
-        Column(name: "completed_by", type: ColumnType.text)
-        
+        Column.integer("completed"),
+        Column.text("created_at"),
+        Column.text("completed_at"),
+        Column.text("created_by"),
+        Column.text("completed_by")
     ],
     indexes: [
         Index(
             name: "list_id",
-            columns: [IndexedColumn(column: "list_id", ascending: true, columnDefinition: nil, type: nil)]
+            columns: [IndexedColumn.ascending("list_id")]
         )
-    ],
-    localOnly: false,
-    insertOnly: false,
-    viewNameOverride: TODOS_TABLE
+    ]
 )
 
-let AppSchema = Schema(tables: [lists, todos])
+let AppSchema = Schema(lists, todos)

Demo/PowerSyncExample/PowerSync/SupabaseConnector.swift

@@ -21,7 +21,7 @@ class SupabaseConnector: PowerSyncBackendConnector {
             guard let self = self else { return }
 
             for await (event, session) in self.client.auth.authStateChanges {
-                guard [.initialSession, .signedIn, .signedOut].contains(event) else { throw AuthError.sessionNotFound }
+                guard [.initialSession, .signedIn, .signedOut].contains(event) else { throw AuthError.sessionMissing }
 
                 self.session = session
             }
@@ -40,7 +40,7 @@ class SupabaseConnector: PowerSyncBackendConnector {
         session = try await client.auth.session
 
         if (self.session == nil) {
-            throw AuthError.sessionNotFound
+            throw AuthError.sessionMissing
         }
 
         let token = session!.accessToken
@@ -49,7 +49,7 @@ class SupabaseConnector: PowerSyncBackendConnector {
         return PowerSyncCredentials(endpoint: self.powerSyncEndpoint, token: token, userId: currentUserID)
     }
 
-    override func uploadData(database: any PowerSyncDatabase) async throws {
+    override func uploadData(database: PowerSyncDatabase) async throws {
 
         guard let transaction = try await database.getNextCrudTransaction() else { return }
 

Sources/PowerSyncSwift/Kotlin/KotlinAdapter.swift

@@ -0,0 +1,64 @@
+import PowerSync
+
+internal struct KotlinAdapter {
+    struct Index {
+        static func toKotlin(_ index: IndexProtocol) -> PowerSync.Index {
+            PowerSync.Index(
+                name: index.name,
+                columns: index.columns.map { IndexedColumn.toKotlin($0) }
+            )
+        }
+    }
+    
+    struct IndexedColumn {
+        static func toKotlin(_ column: IndexedColumnProtocol) -> PowerSync.IndexedColumn {
+            return PowerSync.IndexedColumn(
+                column: column.column,
+                ascending: column.ascending,
+                columnDefinition: nil,
+                type: nil
+            )
+        }
+    }
+    
+    struct Table {
+        static func toKotlin(_ table: TableProtocol) -> PowerSync.Table {
+            PowerSync.Table(
+                name: table.name,
+                columns: table.columns.map {Column.toKotlin($0)},
+                indexes: table.indexes.map { Index.toKotlin($0) },
+                localOnly: table.localOnly,
+                insertOnly: table.insertOnly,
+                viewNameOverride: table.viewNameOverride
+            )
+        }
+    }
+    
+    struct Column {
+        static func toKotlin(_ column: any ColumnProtocol) -> PowerSync.Column {
+            PowerSync.Column(
+                name: column.name,
+                type: columnType(from: column.type)
+            )
+        }
+        
+        private static func columnType(from swiftType: ColumnData) -> PowerSync.ColumnType {
+            switch swiftType {
+            case .text:
+                return PowerSync.ColumnType.text
+            case .integer:
+                return PowerSync.ColumnType.integer
+            case .real:
+                return PowerSync.ColumnType.real
+            }
+        }
+    }
+    
+    struct Schema {
+        static func toKotlin(_ schema: SchemaProtocol) -> PowerSync.Schema {
+            PowerSync.Schema(
+                tables: schema.tables.map { Table.toKotlin($0) }
+            )
+        }
+    }
+}

Sources/PowerSyncSwift/PowerSyncDatabaseImpl.swift renamed to Sources/PowerSyncSwift/Kotlin/KotlinPowerSyncDatabaseImpl.swift

@@ -1,9 +1,7 @@
 import Foundation
 import PowerSync
 
-/// Implementation of PowerSyncDatabaseProtocol that initially wraps the KMP implementation
-/// and allows for gradual migration to pure Swift code
-final class PowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
+final class KotlinPowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
     private let kmpDatabase: PowerSync.PowerSyncDatabase
 
     var currentStatus: SyncStatus {
@@ -17,12 +15,11 @@ final class PowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
         let factory = PowerSync.DatabaseDriverFactory()
         self.kmpDatabase = PowerSyncDatabase(
             factory: factory,
-            schema: schema,
+            schema: KotlinAdapter.Schema.toKotlin(schema),
             dbFilename: dbFilename
         )
     }
 
-    
     func waitForFirstSync() async throws {
         try await kmpDatabase.waitForFirstSync()
     }
@@ -33,7 +30,6 @@ final class PowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
         retryDelayMs: Int64 = 5000,
         params: [String: JsonParam?] = [:]
     ) async throws {
-        // Convert Swift types to KMP types
         try await kmpDatabase.connect(
             connector: connector,
             crudThrottleMs: crudThrottleMs,
@@ -63,7 +59,7 @@ final class PowerSyncDatabaseImpl: PowerSyncDatabaseProtocol {
     }
 
     func execute(sql: String, parameters: [Any]?) async throws -> Int64 {
-        Int64(try await kmpDatabase.execute(sql: sql, parameters: parameters))
+        Int64(truncating: try await kmpDatabase.execute(sql: sql, parameters: parameters))
     }
 
     func get<RowType>(

Sources/PowerSyncSwift/KotlinTypes.swift renamed to Sources/PowerSyncSwift/Kotlin/KotlinTypes.swift

@@ -1,7 +1,5 @@
 import PowerSync
 
-public typealias Schema = PowerSync.Schema
-typealias KmpPowerSyncDatabase = PowerSync.PowerSyncDatabase
 public typealias PowerSyncBackendConnector = PowerSync.PowerSyncBackendConnector
 public typealias CrudEntry = PowerSync.CrudEntry
 public typealias CrudBatch = PowerSync.CrudBatch

Sources/PowerSyncSwift/PowerSyncDatabase.swift

@@ -8,13 +8,13 @@ public let DEFAULT_DB_FILENAME = "powersync.db"
 ///   - schema: The database schema
 ///   - dbFilename: The database filename. Defaults to "powersync.db"
 /// - Returns: A configured PowerSyncDatabase instance
+@MainActor
 public func PowerSyncDatabase(
     schema: Schema,
     dbFilename: String = DEFAULT_DB_FILENAME
 ) -> PowerSyncDatabaseProtocol {
 
-    
-    return PowerSyncDatabaseImpl(
+    return KotlinPowerSyncDatabaseImpl(
         schema: schema,
         dbFilename: dbFilename
     )

Sources/PowerSyncSwift/PowerSyncDatabaseProtocol.swift

@@ -91,3 +91,27 @@ public protocol PowerSyncDatabaseProtocol: Queries {
     /// - Parameter clearLocal: Set to false to preserve data in local-only tables.
     func disconnectAndClear(clearLocal: Bool) async throws
 }
+
+public extension PowerSyncDatabaseProtocol {
+    func connect(
+        connector: PowerSyncBackendConnector,
+        crudThrottleMs: Int64 = 1000,
+        retryDelayMs: Int64 = 5000,
+        params: [String: JsonParam?] = [:]
+    ) async throws {
+        try await connect(
+            connector: connector,
+            crudThrottleMs: crudThrottleMs,
+            retryDelayMs: retryDelayMs,
+            params: params
+        )
+    }
+    
+    func disconnectAndClear(clearLocal: Bool = true) async throws {
+        try await disconnectAndClear(clearLocal: clearLocal)
+    }
+    
+    func getCrudBatch(limit: Int32 = 100) async throws -> CrudBatch? {
+        try await getCrudBatch(limit: 100)
+    }
+}