Swift

Source Code

Refer to the powersync-swift repo on GitHub.

API Reference

Full API reference for the PowerSync SDK [External link].

Example Projects

Gallery of example projects/demo apps built with PowerSync and Swift.

Kotlin Multiplatform -> Swift SDK

The PowerSync Swift SDK makes use of the PowerSync Kotlin Multiplatform SDK with the API tool SKIE under the hood to help generate and publish a Swift package. The Swift SDK abstracts the Kotlin SDK behind pure Swift Protocols, enabling us to fully leverage Swift’s native features and libraries. Our ultimate goal is to deliver a Swift-centric experience for developers.

SDK Features

• Real-time streaming of database changes: Changes made by one user are instantly streamed to all other users with access to that data. This keeps clients automatically in sync without manual polling or refresh logic.
• Direct access to a local SQLite database: Data is stored locally, so apps can read and write instantly without network calls. This enables offline support and faster user interactions.
• Asynchronous background execution: The SDK performs database operations in the background to avoid blocking the application’s main thread. This means that apps stay responsive, even during heavy data activity.
• Query subscriptions for live updates: The SDK supports query subscriptions that automatically push real-time updates to client applications as data changes, keeping your UI reactive and up to date.
• Automatic schema management: PowerSync syncs schemaless data and applies a client-defined schema using SQLite views. This architecture means that PowerSync SDKs can handle schema changes gracefully without requiring explicit migrations on the client-side.

Installation

You can add the PowerSync Swift package to your project using either Package.swift or Xcode:

Package.swift

let package = Package(
    //...
    dependencies: [
        //...
        .package(
            url: "https://github.com/powersync-ja/powersync-swift",
            exact: "<version>"
        ),
    ],
    targets: [
        .target(
            name: "YourTargetName",
            dependencies: [
                .product(
                    name: "PowerSync",
                    package: "powersync-swift"
                )
            ]
        )
    ]
)

let package = Package(
    //...
    dependencies: [
        //...
        .package(
            url: "https://github.com/powersync-ja/powersync-swift",
            exact: "<version>"
        ),
    ],
    targets: [
        .target(
            name: "YourTargetName",
            dependencies: [
                .product(
                    name: "PowerSync",
                    package: "powersync-swift"
                )
            ]
        )
    ]
)

1. Follow this guide to add a package to your project.
2. Use https://github.com/powersync-ja/powersync-swift.git as the URL
3. Include the exact version (e.g., 1.0.x)

Getting Started

Before implementing the PowerSync SDK in your project, make sure you have completed these steps:

• Signed up for a PowerSync Cloud account (here) or self-host PowerSync.

• Configured your backend database and connected it to your PowerSync instance.

• Installed the PowerSync SDK.

1. Define the Schema

The first step is defining the schema for the local SQLite database, which is provided to the PowerSyncDatabase constructor via the schema parameter. This schema represents a “view” of the downloaded data. No migrations are required — the schema is applied directly when the PowerSync database is constructed.

The types available are text, integer and real. These should map directly to the values produced by the Sync Rules. If a value doesn’t match, it is cast automatically.

Example:

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)

Note: No need to declare a primary key id column, as PowerSync will automatically create this.

2. Instantiate the PowerSync Database

Next, you need to instantiate the PowerSync database — this is the core managed database.

Its primary function is to record all changes in the local database, whether online or offline. In addition, it automatically uploads changes to your app backend when connected.

Example:

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

3. Integrate with your Backend

Create a connector to integrate with your backend. The PowerSync backend connector provides the connection between your application backend and the PowerSync managed database.

It is used to:

1. Retrieve an auth token to connect to the PowerSync instance.

2. Apply local changes on your backend application server (and from there, to your backend database)

Accordingly, the connector must implement two methods:

1. PowerSyncBackendConnector.fetchCredentials - This is called every couple of minutes and is used to obtain credentials for your app’s backend API. -> See Authentication Setup for instructions on how the credentials should be generated.

2. PowerSyncBackendConnector.uploadData - Use this to upload client-side changes to your app backend. -> See Writing Client Changes for considerations on the app backend implementation.

Example:

import PowerSync

@Observable
class MyConnector: PowerSyncBackendConnector {
    override 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/installation/authentication-setup/development-tokens)
            // to get up and running quickly) to get up and running quickly
            token: "An authentication token"
        )
    }

    override 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/installation/app-backend-setup/writing-client-changes for considerations.
    }
}

Using PowerSync: CRUD functions

Once the PowerSync instance is configured you can start using the SQLite DB functions.

The most commonly used CRUD functions to interact with your SQLite data are:

• PowerSyncDatabase.get - get (SELECT) a single row from a table.

• PowerSyncDatabase.getOptional - get (SELECT) a single row from a table and return null if not found.

• PowerSyncDatabase.getAll - get (SELECT) a set of rows from a table.

• PowerSyncDatabase.watch - execute a read query every time source tables are modified.

• PowerSyncDatabase.execute - execute a write (INSERT/UPDATE/DELETE) query.

Fetching a Single Item ( PowerSync.get / PowerSync.getOptional)

The get method executes a read-only (SELECT) query and returns a single result. It throws an exception if no result is found. Use getOptional to return a single optional result (returns null if no result is found).

// Find a list item by ID
func getList(_ id: String) async throws {
    try await self.db.getAll(
        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")!
            )
        }
    )
}

Querying Items (PowerSync.getAll)

The getAll method executes a read-only (SELECT) query and returns a set of rows.

// Get all lists
func getLists() async throws {
    try await self.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")!
            )
        }
    )
}

Watching Queries (PowerSync.watch)

The watch method executes a read query whenever a change to a dependent table is made.

// You can watch any SQL query
func watchLists(_ callback: @escaping (_ lists: [ListContent]) -> Void ) async {
    do {
        for try await lists in try self.db.watch<ListContent>(
            sql: "SELECT * FROM \(LISTS_TABLE)",
            parameters: [],
            mapper: { cursor in
                try ListContent(
                    id: cursor.getString(name: "id"),
                    name: cursor.getString(name: "name"),
                    createdAt: cursor.getString(name: "created_at"),
                    ownerId: cursor.getString(name: "owner_id")
                )
            }
        ) {
            callback(lists)
        }
    } catch {
        print("Error in watch: \(error)")
    }
}

Mutations (PowerSync.execute)

The execute method executes a write query (INSERT, UPDATE, DELETE) and returns the results (if any).

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]
            )
    })
}

Configure Logging

You can include your own Logger that must conform to the LoggerProtocol as shown here.

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

The DefaultLogger supports the following severity levels: .debug, .info, .warn, .error.

Additional Usage Examples

See Usage Examples for further examples of the SDK.

ORM Support

ORM support is not yet available, we are still investigating options. Please let us know what your needs around ORMs are.

Troubleshooting

See Troubleshooting for pointers to debug common issues.

Assistant

Responses are generated using AI and may contain mistakes.