Kotlin SDK

// AppSchema.kt
import com.powersync.db.schema.Column
import com.powersync.db.schema.Index
import com.powersync.db.schema.IndexedColumn
import com.powersync.db.schema.Schema
import com.powersync.db.schema.Table

val AppSchema: Schema = Schema(
    listOf(
        Table(
            name = "todos",
            columns = listOf(
                Column.text("list_id"),
                Column.text("created_at"),
                Column.text("completed_at"),
                Column.text("description"),
                Column.integer("completed"),
                Column.text("created_by"),
                Column.text("completed_by")
            ),
            // Index to allow efficient lookup within a list
            indexes = listOf(
                Index("list", listOf(IndexedColumn.descending("list_id")))
            )
        ),
        Table(
            name = "lists",
            columns = listOf(
                Column.text("created_at"),
                Column.text("name"),
                Column.text("owner_id")
            )
        )
    )
)

// commonMain

import com.powersync.DatabaseDriverFactory
import com.powersync.PowerSyncDatabase

// Android
val driverFactory = DatabaseDriverFactory(this)
// iOS & Desktop
val driverFactory = DatabaseDriverFactory()

// commonMain

val database = PowerSyncDatabase(
  factory = driverFactory, // The factory you defined above
  schema = AppSchema, // The schema you defined in the previous step
  dbFilename = "powersync.db",
  // logger = YourLogger, // Optional. Your own Kermit Logger.
  // dbDirectory = "path/to/directory", // Optional. Directory for the database file. Ignored on iOS.
)

// commonMain

// Uses the backend connector that you create in the next step
database.connect(MyConnector())

// commonMain
val database = rememberPowerSyncDatabase(schema)
remember {
    database.connect(MyConnector())
}

// PowerSync.kt
import com.powersync.DatabaseDriverFactory
import com.powersync.PowerSyncDatabase

class MyConnector : PowerSyncBackendConnector() {
    override suspend fun fetchCredentials(): PowerSyncCredentials {
        // implement fetchCredentials to obtain the necessary credentials to connect to your backend
        // See an example implementation in https://github.com/powersync-ja/powersync-kotlin/blob/main/integrations/supabase/src/commonMain/kotlin/com/powersync/connector/supabase/SupabaseConnector.kt

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

    override suspend fun uploadData(database: PowerSyncDatabase) {
        // 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.
    }
}

// Subscribe to a stream with parameters
val sub = database.syncStream("list_todos", mapOf("list_id" to JsonParam.String("abc123")))
  .subscribe()

// Wait for the initial data to sync
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
sub.unsubscribe()

// Find a list item by ID
suspend fun find(id: Any): TodoList {
    return database.get(
                "SELECT * FROM lists WHERE id = ?", 
                listOf(id)
            ) { cursor ->
                TodoList.fromCursor(cursor)
            }
}

// Get all list IDs
suspend fun getLists(): List<String> {
    return database.getAll(
                "SELECT id FROM lists WHERE id IS NOT NULL"
            ) { cursor ->
                cursor.getString("id")
            }
}

fun watchPendingLists(): Flow<List<ListItem>> =
    db.watch(
        "SELECT * FROM lists WHERE state = ?",
        listOf("pending"),
    ) { cursor ->
        ListItem(
            id = cursor.getString("id"),
            name = cursor.getString("name"),
        )
    }

suspend fun insertCustomer(name: String, email: String) {
    database.writeTransaction { tx ->
        tx.execute(
            sql = "INSERT INTO customers (id, name, email) VALUES (uuid(), ?, ?)",
            parameters = listOf(name, email)
        )
    }
}

suspend fun updateCustomer(id: String, name: String, email: String) {
    database.execute(
        sql = "UPDATE customers SET name = ? WHERE email = ?",
        parameters = listOf(name, email)
    )
}

suspend fun deleteCustomer(id: String? = null) {
    // If no id is provided, delete the first customer in the database
    val targetId =
        id ?: database.getOptional(
            sql = "SELECT id FROM customers LIMIT 1",
            mapper = { cursor ->
                cursor.getString(0)!!
            }
        ) ?: return

    database.writeTransaction { tx ->
        tx.execute(
            sql = "DELETE FROM customers WHERE id = ?",
            parameters = listOf(targetId)
        )
    }
}

PowerSyncDatabase(
  ...
  logger: Logger? = YourLogger
)

val defaultLogger: Logger = Logger

// Severity is set to Verbose in Debug and Warn in Release
if(BuildConfig.isDebug) {
    Logger.setMinSeverity(Severity.Verbose)
} else {
    Logger.setMinSeverity(Severity.Warn)
}

return defaultLogger

import co.touchlab.kermit.Logger

Logger.i("Some information");
Logger.e("Some error");
...

import com.powersync.sync.SyncClientConfiguration
import com.powersync.sync.SyncOptions
import io.ktor.client.plugins.defaultRequest
import io.ktor.client.request.header

db.connect(
    connector,
    options = SyncOptions(
        clientConfiguration = SyncClientConfiguration.ExtendedConfig {
            // For more options, see https://ktor.io/docs/client-create-and-configure.html#plugins
            defaultRequest {
                header("X-Custom-Header", "Used by PowerSync")
            }
        }
    )
)

import com.powersync.sync.configureSyncHttpClient

db.connect(
    connector,
    options = SyncOptions(
        clientConfiguration = SyncClientConfiguration.ExistingClient(HttpClient(YourPreferredClientEngine) {
            // Important: This configures a minimal set of plugins required by the PowerSync sync client.
            configureSyncHttpClient()
        })
    )
)