Swift SDK

import Foundation
import PowerSync

let LISTS_TABLE = "lists"
let TODOS_TABLE = "todos"

let lists = Table(
    name: LISTS_TABLE,
    columns: [
        // ID column is automatically included
        .text("name"),
        .text("created_at"),
        .text("owner_id")
    ]
)

let todos = Table(
    name: TODOS_TABLE,
    // ID column is automatically included
    columns: [
        .text("list_id"),
        .text("photo_id"),
        .text("description"),
        // 0 or 1 to represent false or true
        .integer("completed"),
        .text("created_at"),
        .text("completed_at"),
        .text("created_by"),
        .text("completed_by")
    ],
    indexes: [
        Index(
            name: "list_id",
            columns: [
                IndexedColumn.ascending("list_id")
            ]
        )
    ]
)

let AppSchema = Schema(lists, todos)

let schema = AppSchema // Comes from the AppSchema defined above
let db = PowerSyncDatabase(
    schema: schema,
    dbFilename: "powersync-swift.sqlite"
)

import PowerSync

final class MyConnector: PowerSyncBackendConnectorProtocol {
    func fetchCredentials() async throws -> PowerSyncCredentials? {
        // implement fetchCredentials to obtain the necessary credentials to connect to your backend
        // See an example implementation in https://github.com/powersync-ja/powersync-swift/blob/main/Demo/PowerSyncExample/PowerSync/SupabaseConnector.swift
        return PowerSyncCredentials(
            endpoint: "Your PowerSync instance URL or self-hosted endpoint",
            // Use a development token (see Authentication Setup https://docs.powersync.com/configuration/auth/development-tokens)
            // to get up and running quickly
            token: "An authentication token"
        )
    }

    func uploadData(database: PowerSyncDatabaseProtocol) async throws {
        // Implement uploadData to send local changes to your backend service
        // You can omit this method if you only want to sync data from the server to the client
        // See an example implementation under Usage Examples (sub-page)
        // See https://docs.powersync.com/handling-writes/writing-client-changes for considerations.
    }
}

let connector = MyConnector()

try await db.connect(connector: connector)

// Subscribe to a stream with parameters
let sub = try await db.syncStream(name: "list_todos", params: ["list_id": .string("abc123")]).subscribe()

// Wait for the initial data to sync
try await sub.waitForFirstSync()

// The stream's rows are now in the local SQLite database.
// TODO: Read the todos for this list with a local query.

// When the data is no longer needed
try await sub.unsubscribe()

// Find a list by ID
func getList(_ id: String) async throws -> ListContent {
    try await db.get(
        sql: "SELECT * FROM \(LISTS_TABLE) WHERE id = ?",
        parameters: [id],
        mapper: { cursor in
            ListContent(
                id: try cursor.getString(name: "id")!,
                name: try cursor.getString(name: "name")!,
                createdAt: try cursor.getString(name: "created_at")!,
                ownerId: try cursor.getString(name: "owner_id")!
            )
        }
    )
}

// Get all lists
func getLists() async throws -> [ListContent] {
    try await db.getAll(
        sql: "SELECT * FROM \(LISTS_TABLE)",
        parameters: [],
        mapper: { cursor in
            ListContent(
                id: try cursor.getString(name: "id")!,
                name: try cursor.getString(name: "name")!,
                createdAt: try cursor.getString(name: "created_at")!,
                ownerId: try cursor.getString(name: "owner_id")!
            )
        }
    )
}

func watchPendingLists() throws -> AsyncThrowingStream<[ListContent], Error> {
    try db.watch(
        sql: "SELECT * FROM lists WHERE state = ?",
        parameters: ["pending"],
    ) { cursor in
        try ListContent(
            id: cursor.getString(name: "id"),
            name: cursor.getString(name: "name"),
        )
    }
}

func insertTodo(_ todo: NewTodo, _ listId: String) async throws {
    try await db.execute(
        sql: "INSERT INTO \(TODOS_TABLE) (id, created_at, created_by, description, list_id, completed) VALUES (uuid(), datetime(), ?, ?, ?, ?)",
        parameters: [connector.currentUserID, todo.description, listId, todo.isComplete]
    )
}

func updateTodo(_ todo: Todo) async throws {
    try await db.execute(
        sql: "UPDATE \(TODOS_TABLE) SET description = ?, completed = ?, completed_at = datetime(), completed_by = ? WHERE id = ?",
        parameters: [todo.description, todo.isComplete, connector.currentUserID, todo.id]
    )
}

func deleteTodo(id: String) async throws {
    try await db.writeTransaction(callback: { transaction in
        _ = try transaction.execute(
                sql: "DELETE FROM \(TODOS_TABLE) WHERE id = ?",
                parameters: [id]
            )
    })
}

let logger = DefaultLogger(minSeverity: .debug)
let db = PowerSyncDatabase(
    schema: schema,
    dbFilename: "powersync-swift.sqlite",
    logger: logger
)

let config = URLSessionConfiguration.ephemeral
config.httpAdditionalHeaders = ["x-my-custom-header": "example"]
let session = URLSession(configuration: config)

try await db.connect(
    connector: connector,
    options: ConnectOptions(
        clientConfiguration: SyncClientConfiguration(
            urlSession: session
        )
    )
)