Node.js Client SDK

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

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',
    // Optional. Directory where the database file is located.
    // dbLocation: 'path/to/directory'
  },
});

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

export class Connector {
    async fetchCredentials() {
        // Implement fetchCredentials to obtain a JWT from your authentication service. 
        // See https://docs.powersync.com/configuration/auth/overview
        return {
            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'
        };
    }

    async uploadData(database) {
      // Implement uploadData to send local changes to your backend service.
      // You can omit this method if you only want to sync data from the database to the client

      // See example implementation here: https://docs.powersync.com/client-sdks/usage-examples#send-changes-in-local-data-to-your-backend-service
    }
}

await db.connect(new Connector());
await db.waitForFirstSync(); // Optional, to wait for a complete snapshot of data to be available

// Subscribe to a stream with parameters
const sub = await db.syncStream('list_todos', { list_id: 'abc123' }).subscribe();

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

// Use db.get() to fetch a single row:
console.log(await db.get('SELECT powersync_rs_version();'));

// Or db.getAll() to fetch all:
console.log(await db.getAll('SELECT * FROM lists;'));

// And db.execute for inserts, updates and deletes:
await db.execute(
  "INSERT INTO lists (id, created_at, name, owner_id) VALUES (uuid(), datetime('now'), ?, uuid());",
  ['My new list']
);

import { createConsoleLogger, LogLevels } from '@powersync/node';

// Create a logger with trace minimum level to see all log messages
// Available levels: trace, debug, info, warn, error
const logger = createConsoleLogger({ minLevel: LogLevels.trace });

// This worker uses bindings to sqlite3 multiple ciphers instead of the original better-sqlite3 worker.
import Database from 'better-sqlite3-multiple-ciphers';

import { startPowerSyncWorker } from '@powersync/node/worker.js';

async function resolveBetterSqlite3() {
  return Database;
}

startPowerSyncWorker({ loadBetterSqlite3: resolveBetterSqlite3 });

const encryptionKey = 'todo: generate encryption key and store it safely';

const db = new PowerSyncDatabase({
  schema: AppSchema,
  database: {
    dbFilename: 'app.db',
    openWorker: (_, options) => {
      return new Worker(new URL('./database.worker.js', import.meta.url), options);
    },
    initializeConnection: async (db) => {
      if (encryptionKey.length) {
        const escapedKey = encryptionKey.replaceAll("'", "''");
        await db.execute(`pragma key = '${escapedKey}'`);
      }

      // Make sure the database is readable, this fails early if the key is wrong.
      await db.execute('pragma user_version');
    }
  },
  logger
});

const database = new PowerSyncDatabase({
  schema: AppSchema,
  database: {
    dbFilename: 'app.db',
    dbLocation: directory,
    // Use node:sqlite instead of better-sqlite3
    implementation: { type: 'node:sqlite' }
  }
});