PowerSync Setup Guide

config:
  edition: 3
streams:
  shared_data:
    auto_subscribe: true
    queries:
      - SELECT * FROM todos
      - SELECT * FROM lists WHERE NOT archived

config:
  edition: 3
streams:
  shared_data:
    auto_subscribe: true
    # MongoDB uses "_id" but PowerSync uses "id" on the client
    queries:
      - SELECT *, _id as id FROM lists
      - SELECT *, _id as id FROM todos WHERE archived = false

config:
  edition: 3
streams:
  shared_data:
    auto_subscribe: true
    queries:
      - SELECT * FROM todos
      - SELECT * FROM lists WHERE NOT archived

config:
  edition: 3
streams:
  shared_data:
    auto_subscribe: true
    queries:
      - SELECT * FROM todos
      - SELECT * FROM lists WHERE NOT archived

import { column, Schema, Table } from '@powersync/react-native';

const todos = new Table(
  {
    list_id: column.text,
    created_at: column.text,
    completed_at: column.text,
    description: column.text,
    created_by: column.text,
    completed_by: column.text,
    completed: column.integer
  },
  { indexes: { list: ['list_id'] } }
);

export const AppSchema = new Schema({
  todos
});

import { column, Schema, Table } from '@powersync/web';

const todos = new Table(
  {
    list_id: column.text,
    created_at: column.text,
    completed_at: column.text,
    description: column.text,
    created_by: column.text,
    completed_by: column.text,
    completed: column.integer
  },
  { indexes: { list: ['list_id'] } }
);

export const AppSchema = new Schema({
  todos
});

import { column, Schema, Table } from '@powersync/common';

const todos = new Table(
  {
    list_id: column.text,
    created_at: column.text,
    completed_at: column.text,
    description: column.text,
    created_by: column.text,
    completed_by: column.text,
    completed: column.integer
  },
  { indexes: { list: ['list_id'] } }
);

export const AppSchema = new Schema({
  todos
});

import { column, Schema, Table } from '@powersync/node';

const todos = new Table(
  {
    list_id: column.text,
    created_at: column.text,
    completed_at: column.text,
    description: column.text,
    created_by: column.text,
    completed_by: column.text,
    completed: column.integer
  },
  { indexes: { list: ['list_id'] } }
);

export const AppSchema = new Schema({
  todos
});

import com.powersync.db.schema.Column
import com.powersync.db.schema.Schema
import com.powersync.db.schema.Table
import com.powersync.db.schema.Index
import com.powersync.db.schema.IndexedColumn

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")
      ),
      indexes = listOf(
        Index("list", listOf(IndexedColumn.descending("list_id")))
      )
    )
  )
)

import PowerSync

let todos = Table(
  name: "todos",
  columns: [
    Column.text("list_id"),
    Column.text("description"),
    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.ascending("list_id")]
    )
  ]
)

let AppSchema = Schema(todos)

import 'package:powersync/powersync.dart';

const schema = Schema(([
  Table('todos', [
    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'),
  ], indexes: [
    Index('list', [IndexedColumn('list_id')])
  ])
]));

using PowerSync.Common.DB.Schema;
using PowerSync.Common.DB.Schema.Attributes;

[Table("todos"), Index("list", ["list_id"])]
public class Todo
{
    // Attribute-based schema requires an explicit id; other syntaxes define an implicit id key. Learn more in the .NET SDK reference.
    [Column("id")]
    public string TodoId { get; set; }

    [Column("list_id")]
    public string ListId { get; set; }

    [Column("created_at")]
    public string CreatedAt { get; set; }

    [Column("completed_at")]
    public string CompletedAt { get; set; }

    [Column("description")]
    public string Description { get; set; }

    [Column("created_by")]
    public string CreatedBy { get; set; }

    [Column("completed_by")]
    public string CompletedBy { get; set; }

    [Column("completed")]
    public bool Completed { get; set; }
}

public static Schema PowerSyncSchema = new Schema(typeof(Todo));

use powersync::schema::{Column, Schema, Table};

pub fn app_schema() -> Schema {
    let mut schema = Schema::default();
    let todos = Table::create(
        "todos",
        vec![
            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"),
        ],
        |_| {},
    );
    schema.tables.push(todos);
    schema
}

import { PowerSyncDatabase } from '@powersync/react-native';
import { AppSchema } from './Schema';

export const db = new PowerSyncDatabase({
  schema: AppSchema,
  database: {
    dbFilename: 'powersync.db'
  }
});

import { PowerSyncDatabase } from '@powersync/web';
import { AppSchema } from './Schema';

export const db = new PowerSyncDatabase({
  schema: AppSchema,
  database: {
    dbFilename: 'powersync.db'
  }
});

import { PowerSyncDatabase } from '@powersync/node';
import { AppSchema } from './Schema';

export const db = new PowerSyncDatabase({
  schema: AppSchema,
  database: {
    dbFilename: 'powersync.db'
  }
});

import { PowerSyncTauriDatabase } from '@powersync/tauri-plugin';
import { appDataDir } from '@tauri-apps/api/path';
import { AppSchema } from './AppSchema';

export const db = new PowerSyncTauriDatabase({
  schema: AppSchema,
  database: {
    dbFilename: 'powersync.db',
    // Store the database in the app data directory
    dbLocationAsync: appDataDir,
  }
});

import { PowerSyncDatabase } from '@powersync/capacitor';

// Import general components from the Web SDK package
import { Schema } from '@powersync/web';
import { Connector } from './Connector';
import { AppSchema } from './AppSchema';

/**
 * The Capacitor PowerSyncDatabase will automatically detect the platform
 * and use the appropriate database drivers.
 */
export const db = new PowerSyncDatabase({
  // The schema you defined in the previous step
  schema: AppSchema,
  database: {
    // Filename for the SQLite database — it's important to only instantiate one instance per file.
    dbFilename: 'powersync.db'
  }
});

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

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

val database = PowerSyncDatabase({
  factory: driverFactory,
  schema: AppSchema,
  dbFilename: "powersync.db"
})

import PowerSync

let db = PowerSyncDatabase(
  schema: AppSchema,
  dbFilename: "powersync.sqlite"
)

import 'package:powersync/powersync.dart';
import 'package:path_provider/path_provider.dart';
import 'package:path/path.dart';

openDatabase() async {
  final dir = await getApplicationSupportDirectory();
  final path = join(dir.path, 'powersync-dart.db');
  db = PowerSyncDatabase(schema: schema, path: path);
  await db.initialize();
}

using PowerSync.Common.Client;

class Demo
{
    static async Task Main()
    {
        var db = new PowerSyncDatabase(new PowerSyncDatabaseOptions
        {
            Database = new SQLOpenOptions { DbFilename = "tododemo.db" },
            Schema = AppSchema.PowerSyncSchema,
        });
        await db.Init();
    }
}

using PowerSync.Common.Client;
using PowerSync.Common.MDSQLite;
using PowerSync.Maui.SQLite;

class Demo
{
    static async Task Main() 
    {
        // Ensures the DB file is stored in a platform appropriate location
        var dbPath = Path.Combine(FileSystem.AppDataDirectory, "maui-example.db");
        var factory = new MAUISQLiteDBOpenFactory(new MDSQLiteOpenFactoryOptions()
        {
            DbFilename = dbPath
        });

        var Db = new PowerSyncDatabase(new PowerSyncDatabaseOptions()
        {
            Database = factory, // Supply a factory
            Schema = AppSchema.PowerSyncSchema,
        });

        await db.Init();
    }
}

// 1. Process setup: register PowerSync extension early (e.g. in main()).
// 2. Open a connection pool, create env, then database. Spawn async tasks
//    before connecting (see Connect step). Requires powersync with tokio feature.

use powersync::{ConnectionPool, PowerSyncDatabase, error::PowerSyncError};
use powersync::env::PowerSyncEnvironment;
use std::sync::Arc;
use http_client::IsahcClient;

fn open_pool() -> Result<ConnectionPool, PowerSyncError> {
    ConnectionPool::open("powersync.db")
}

// This example shows the Tokio runtime. You must call 
// `PowerSyncEnvironment::powersync_auto_extension()` before using the SDK and spawn async 
// tasks with `db.async_tasks().spawn_with_tokio()` (or `spawn_with` for other runtimes) 
// before connecting. See the Rust SDK reference for in-memory pools, smol, or custom runtimes.

#[tokio::main]
async fn main() {
    PowerSyncEnvironment::powersync_auto_extension()
        .expect("could not load PowerSync core extension");

    let pool = open_pool().expect("open pool");
    let client = Arc::new(IsahcClient::new());
    let env = PowerSyncEnvironment::custom(
        client.clone(),
        pool,
        Box::new(PowerSyncEnvironment::tokio_timer()),
    );

    let db = PowerSyncDatabase::new(env, app_schema());
    db.async_tasks().spawn_with_tokio();
    // Connect with a backend connector in the next step.
}

import { AbstractPowerSyncDatabase, PowerSyncBackendConnector, PowerSyncCredentials } from '@powersync/react-native';
import { db } from './Database';

class Connector implements PowerSyncBackendConnector {
  async fetchCredentials(): Promise<PowerSyncCredentials> {
    // for development: use development token
    return {
      endpoint: 'https://your-instance.powersync.com',
      token: 'your-development-token-here'
    };
  }

  async uploadData(database: AbstractPowerSyncDatabase) {
    const transaction = await database.getNextCrudTransaction();
    if (!transaction) return;

    for (const op of transaction.crud) {
      const record = { ...op.opData, id: op.id };
      // upload to your backend API
    }

    await transaction.complete();
  }
}

// connect the database to PowerSync Service
const connector = new Connector();
await db.connect(connector);

import { AbstractPowerSyncDatabase, PowerSyncBackendConnector, PowerSyncCredentials } from '@powersync/web';
import { db } from './Database';

class Connector implements PowerSyncBackendConnector {
  async fetchCredentials(): Promise<PowerSyncCredentials> {
    // for development: use development token
    return {
      endpoint: 'https://your-instance.powersync.com',
      token: 'your-development-token-here'
    };
  }

  async uploadData(database: AbstractPowerSyncDatabase) {
    const transaction = await database.getNextCrudTransaction();
    if (!transaction) return;

    for (const op of transaction.crud) {
      const record = { ...op.opData, id: op.id };
      // upload to your backend API
    }

    await transaction.complete();
  }
}

// connect the database to PowerSync Service
const connector = new Connector();
await db.connect(connector);

import { PowerSyncBackendConnector } from '@powersync/node';

export class Connector implements PowerSyncBackendConnector {
    async fetchCredentials() {
        // for development: use development token
        return {
            endpoint: 'https://your-instance.powersync.com',
            token: 'your-development-token-here'
        };
    }

    async uploadData(database) {
      // upload to your backend API
    }
}

// connect the database to PowerSync Service
const connector = new Connector();
await db.connect(connector);

import com.powersync.PowerSyncCredentials
import com.powersync.PowerSyncDatabase

class MyConnector : PowerSyncBackendConnector {
  override suspend fun fetchCredentials(): PowerSyncCredentials {
    // for development: use development token
    return PowerSyncCredentials(
      endpoint = "https://your-instance.powersync.com",
      token = "your-development-token-here"
    )
  }

  override suspend fun uploadData(database: PowerSyncDatabase) {
    val transaction = database.getNextCrudTransaction() ?: return
    
    for (op in transaction.crud) {
      val record = op.opData + ("id" to op.id)
      // upload to your backend API
    }
    
    transaction.complete()
  }
}

// connect the database to PowerSync Service
database.connect(MyConnector())

import PowerSync

class Connector: PowerSyncBackendConnector {
  func fetchCredentials() async throws -> PowerSyncCredentials {
    // for development: use development token
    return PowerSyncCredentials(
      endpoint: "https://your-instance.powersync.com",
      token: "your-development-token-here"
    )
  }

  func uploadData(database: PowerSyncDatabase) async throws {
    guard let transaction = try await database.getNextCrudTransaction() else {
      return
    }
    
    for op in transaction.crud {
      var record = op.opData
      record["id"] = op.id
      // upload to your backend API
    }
    
    try await transaction.complete()
  }
}

// connect the database to PowerSync Service
let connector = Connector()
await db.connect(connector: connector)

import 'package:powersync/powersync.dart';

class Connector extends PowerSyncBackendConnector {
  @override
  Future<PowerSyncCredentials> fetchCredentials() async {
    return PowerSyncCredentials(
      endpoint: 'https://your-instance.powersync.com',
      token: 'your-development-token-here'
    );
  }

  @override
  Future<void> uploadData(PowerSyncDatabase database) async {
    final transaction = await database.getNextCrudTransaction();
    if (transaction == null) return;

    for (final op in transaction.crud) {
      final record = {...op.opData, 'id': op.id};
      // upload to your backend API
    }

    await transaction.complete();
  }
}

// connect the database to PowerSync Service
final connector = Connector();
await db.connect(connector);

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using PowerSync.Common.Client;
using PowerSync.Common.Client.Connection;
using PowerSync.Common.DB.Crud;

public class MyConnector : IPowerSyncBackendConnector
{
    public MyConnector()
    {
    }

    public async Task<PowerSyncCredentials?> FetchCredentials()
    {
        var powerSyncUrl = "https://your-instance.powersync.com";
        var authToken = "your-development-token-here";

        // Return credentials with PowerSync endpoint and JWT token
        return new PowerSyncCredentials(powerSyncUrl, authToken);
    }

    public async Task UploadData(IPowerSyncDatabase database)
    {
        // upload to your backend API
    }
}

// connect the database to PowerSync Service
await db.Connect(new MyConnector());

use async_trait::async_trait;
use powersync::{BackendConnector, PowerSyncCredentials, PowerSyncDatabase, SyncOptions};
use powersync::error::PowerSyncError;
use std::sync::Arc;

struct MyBackendConnector {
    client: Arc<dyn http_client::HttpClient>,
    db: PowerSyncDatabase,
}

#[async_trait]
impl BackendConnector for MyBackendConnector {
    async fn fetch_credentials(&self) -> Result<PowerSyncCredentials, PowerSyncError> {
        // for development: use development token
        Ok(PowerSyncCredentials {
            endpoint: "https://your-instance.powersync.com".to_string(),
            token: "your-development-token-here".to_string(),
        })
    }

    async fn upload_data(&self) -> Result<(), PowerSyncError> {
        let mut local_writes = self.db.crud_transactions();
        while let Some(tx) = local_writes.try_next().await? {
            // upload to your backend API
            tx.complete().await?;
        }
        Ok(())
    }
}

// connect the database to PowerSync Service
db.connect(SyncOptions::new(MyBackendConnector {
    client,
    db: db.clone(),
}))
.await;

// For Tauri, connecting to PowerSync must be done in Rust so that sync state
// is shared across all windows. Calling connect() from JavaScript will throw.
//
// 1. Define your backend connector in Rust:

use async_trait::async_trait;
use tauri_plugin_powersync::PowerSyncExt;
use powersync::{BackendConnector, PowerSyncCredentials, PowerSyncDatabase, SyncOptions};
use powersync::error::PowerSyncError;

struct MyBackendConnector {
    db: PowerSyncDatabase,
}

#[async_trait]
impl BackendConnector for MyBackendConnector {
    async fn fetch_credentials(&self) -> Result<PowerSyncCredentials, PowerSyncError> {
        // for development: use development token
        Ok(PowerSyncCredentials {
            endpoint: "https://your-instance.powersync.com".to_string(),
            token: "your-development-token-here".to_string(),
        })
    }

    async fn upload_data(&self) -> Result<(), PowerSyncError> {
        let mut local_writes = self.db.crud_transactions();
        while let Some(tx) = local_writes.try_next().await? {
            // upload to your backend API
            tx.complete().await?;
        }
        Ok(())
    }
}

// 2. Add a Tauri command that receives the database handle from JavaScript:
#[tauri::command]
async fn connect<R: tauri::Runtime>(
    app: tauri::AppHandle<R>,
    handle: usize,
) -> tauri_plugin_powersync::Result<()> {
    let database = app.powersync().database_from_javascript_handle(handle)?;
    let options = SyncOptions::new(MyBackendConnector { db: database.clone() });
    database.connect(options).await;
    Ok(())
}

// 3. Register the command in your Tauri builder:
// .invoke_handler(tauri::generate_handler![connect])

// 4. Then call it from JavaScript after initializing the database:
// await db.init();
// await invoke('connect', { handle: db.rustHandle });

// Get all todos
const todos = await db.getAll('SELECT * FROM todos');

// Get a single todo
const todo = await db.get('SELECT * FROM todos WHERE id = ?', [todoId]);

// Watch for changes (reactive query)
const stream = db.watch('SELECT * FROM todos WHERE list_id = ?', [listId]);
for await (const todos of stream) {
  // Update UI when data changes
  console.log(todos);
}

// Note: The above example requires async iterator support in React Native. 
// If you encounter issues, use one of these callback-based APIs instead:

// Option 1: Using onResult callback
// const abortController = new AbortController();
// db.watch(
//   'SELECT * FROM todos WHERE list_id = ?',
//   [listId],
//   {
//     onResult: (todos) => {
//       // Update UI when data changes
//       console.log(todos);
//     }
//   },
//   { signal: abortController.signal }
// );

// Option 2: Using the query builder API
// const query = db
//   .query({
//     sql: 'SELECT * FROM todos WHERE list_id = ?',
//     parameters: [listId]
//   })
//   .watch();
// query.registerListener({
//   onData: (todos) => {
//     // Update UI when data changes
//     console.log(todos);
//   }
// });

// Get all todos
val todos = database.getAll("SELECT * FROM todos") { cursor ->
  Todo.fromCursor(cursor)
}

// Get a single todo
val todo = database.get("SELECT * FROM todos WHERE id = ?", listOf(todoId)) { cursor ->
  Todo.fromCursor(cursor)
}

// Watch for changes
database.watch("SELECT * FROM todos WHERE list_id = ?", listOf(listId))
  .collect { todos ->
    // Update UI when data changes
  }

// Get all todos
let todos = try await db.getAll(
  sql: "SELECT * FROM todos",
  mapper: { cursor in
    TodoContent(
      description: try cursor.getString(name: "description")!,
      completed: try cursor.getBooleanOptional(name: "completed")
    )
  }
)

// Watch for changes
for try await todos in db.watch(
  sql: "SELECT * FROM todos WHERE list_id = ?",
  parameters: [listId]
) {
  // Update UI when data changes
}

// Get all todos
final todos = await db.getAll('SELECT * FROM todos');

// Get a single todo
final todo = await db.get('SELECT * FROM todos WHERE id = ?', [todoId]);

// Watch for changes
db.watch('SELECT * FROM todos WHERE list_id = ?', [listId])
  .listen((todos) {
    // Update UI when data changes
  });

// Define a result type with properties matching schema columns (some columns omitted for brevity)
// public class ListResult { public string id; public string name; public string owner_id; public string created_at; ... }

// Use db.Get() to fetch a single row:
var list = await db.Get<ListResult>("SELECT * FROM lists WHERE id = ?", [listId]);

// Use db.GetAll() to fetch all rows:
var lists = await db.GetAll<ListResult>("SELECT * FROM lists");

// Watch for changes to query results
var query = await db.Watch("SELECT * FROM lists", null, new WatchHandler<ListResult>
{
    OnResult = (results) => Console.WriteLine($"Lists updated: {results.Length} items"),
    OnError = (error) => Console.WriteLine($"Error: {error.Message}")
});

// Call query.Dispose() to stop watching for updates
query.Dispose();

use rusqlite::params;
use futures::StreamExt; // for try_next() on the watch stream

// Get all todos
async fn get_all_todos(db: &PowerSyncDatabase) -> Result<(), PowerSyncError> {
    let reader = db.reader().await?;
    let mut stmt = reader.prepare("SELECT * FROM todos")?;
    let mut rows = stmt.query(params![])?;
    while let Some(row) = rows.next()? {
        let id: String = row.get("id")?;
        let description: String = row.get("description")?;
        // use row data
    }
    Ok(())
}

// Get a single todo
async fn find_todo(db: &PowerSyncDatabase, todo_id: &str) -> Result<(), PowerSyncError> {
    let reader = db.reader().await?;
    let mut stmt = reader.prepare("SELECT * FROM todos WHERE id = ?")?;
    let mut rows = stmt.query(params![todo_id])?;
    while let Some(row) = rows.next()? {
        let id: String = row.get("id")?;
        let description: String = row.get("description")?;
        println!("Found todo: {id}, {description}");
    }
    Ok(())
}

// Watch for changes
async fn watch_todos(db: &PowerSyncDatabase, list_id: &str) -> Result<(), PowerSyncError> {
    let stream = db.watch_statement(
        "SELECT * FROM todos WHERE list_id = ?".to_string(),
        params![list_id],
        |stmt, params| {
            let mut rows = stmt.query(params)?;
            let mut mapped = vec![];
            while let Some(row) = rows.next()? {
                mapped.push(() /* TODO: Read row into struct */);
            }
            Ok(mapped)
        },
    );
    let mut stream = std::pin::pin!(stream);
    while let Some(_event) = stream.try_next().await? {
        // Update UI when data changes
    }
    Ok(())
}

// Insert a new todo
await db.execute(
  'INSERT INTO todos (id, created_at, list_id, description) VALUES (uuid(), date(), ?, ?)',
  [listId, 'Buy groceries']
);

// Update a todo
await db.execute(
  'UPDATE todos SET completed = 1, completed_at = date() WHERE id = ?',
  [todoId]
);

// Delete a todo
await db.execute('DELETE FROM todos WHERE id = ?', [todoId]);

// Insert a new todo
database.writeTransaction { ctx ->
  ctx.execute(
    sql = "INSERT INTO todos (id, created_at, list_id, description) VALUES (uuid(), date(), ?, ?)",
    parameters = listOf(listId, "Buy groceries")
  )
}

// Update a todo
database.execute(
  sql = "UPDATE todos SET completed = 1, completed_at = date() WHERE id = ?",
  parameters = listOf(todoId)
)

// Delete a todo
database.execute(
  sql = "DELETE FROM todos WHERE id = ?",
  parameters = listOf(todoId)
)

// Insert a new todo
try await db.execute(
  sql: "INSERT INTO todos (id, created_at, list_id, description) VALUES (uuid(), date(), ?, ?)",
  parameters: [listId, "Buy groceries"]
)

// Update a todo
try await db.execute(
  sql: "UPDATE todos SET completed = 1, completed_at = date() WHERE id = ?",
  parameters: [todoId]
)

// Delete a todo
try await db.execute(
  sql: "DELETE FROM todos WHERE id = ?",
  parameters: [todoId]
)

// Insert a new todo
await db.execute(
  'INSERT INTO todos (id, created_at, list_id, description) VALUES (uuid(), date(), ?, ?)',
  [listId, 'Buy groceries']
);

// Update a todo
await db.execute(
  'UPDATE todos SET completed = 1, completed_at = date() WHERE id = ?',
  [todoId]
);

// Delete a todo
await db.execute('DELETE FROM todos WHERE id = ?', [todoId]);

// Insert a new todo
await db.Execute(
  "INSERT INTO todos (id, created_at, list_id, description) VALUES (uuid(), datetime(), ?, ?)",
  [listId, "Buy groceries"]
);

// Update a todo
await db.Execute(
  "UPDATE todos SET completed = 1, completed_at = datetime() WHERE id = ?",
  [todoId]
);

// Delete a todo
await db.Execute("DELETE FROM todos WHERE id = ?", [todoId]);

use rusqlite::params;

// Insert a new todo
async fn insert_todo(
    db: &PowerSyncDatabase,
    list_id: &str,
    description: &str,
) -> Result<(), PowerSyncError> {
    let writer = db.writer().await?;
    writer.execute(
        "INSERT INTO todos (id, created_at, list_id, description) VALUES (uuid(), date(), ?, ?)",
        params![list_id, description],
    )?;
    Ok(())
}

// Update a todo
async fn complete_todo(db: &PowerSyncDatabase, todo_id: &str) -> Result<(), PowerSyncError> {
    let writer = db.writer().await?;
    writer.execute(
        "UPDATE todos SET completed = 1, completed_at = date() WHERE id = ?",
        params![todo_id],
    )?;
    Ok(())
}

// Delete a todo
async fn delete_todo(db: &PowerSyncDatabase, todo_id: &str) -> Result<(), PowerSyncError> {
    let writer = db.writer().await?;
    writer.execute("DELETE FROM todos WHERE id = ?", params![todo_id])?;
    Ok(())
}