JavaScript Web
Full SDK reference for using PowerSync in JavaScript Web clients
PowerSync SDK on NPM
This SDK is distributed via NPM [External link].
Source Code
Refer to packages/web in the powersync-js repo on GitHub.
API Reference
Full API reference for the PowerSync SDK [External link].
Example Projects
Gallery of example projects/demo apps built with JavaScript Web stacks and PowerSync.
SDK Features
- Provides real-time streaming of database changes.
- Offers direct access to the SQLite database, enabling the use of SQL on both client and server sides.
- Operations are asynchronous by default, ensuring the user interface remains unblocked.
- Enables subscription to queries for receiving live updates.
- Eliminates the need for client-side database migrations as these are managed automatically.
- Allows using PowerSync between multiple tabs
Installation
See the SDK’s README for installation instructions.
Some peer dependencies are required.
Note: As of @powersync/web@1.4.0, polyfills are bundled in the SDK and are no longer required.
See the Readme for the necessary peer dependencies that need to be installed.
By default this SDK connects to a PowerSync instance via WebSocket (from @powersync/web@1.6.0) or HTTP stream (before @powersync/web@1.6.0).
- See the Developer Notes section below for details about connecting with either method.
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 Web SDK.
1. Define the Schema
The first step is defining the schema for the local SQLite database.
This schema represents a “view” of the downloaded data. No migrations are required — the schema is applied directly when the local PowerSync database is constructed (as we’ll show in the next step).
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. For details on how Postgres types are mapped to the types below, see the section on Types in the Sync Rules documentation.
Example:
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 functions are 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:
SDK versions lower than 1.2.0
In SDK versions lower than 1.2.0, you will need to use the deprecated WASQLitePowerSyncDatabaseOpenFactory syntax to instantiate the database.
Once you’ve instantiated your PowerSync database, you will need to call the connect() method to activate it.
3. Integrate with your Backend
The PowerSync backend connector provides the connection between your application backend and the PowerSync client-slide managed SQLite database.
It is used to:
- Retrieve an auth token to connect to the PowerSync instance.
- Apply local changes on your backend application server (and from there, to Postgres)
Accordingly, the connector must implement two methods:
- PowerSyncBackendConnector.fetchCredentials - This is called every couple of minutes and is used to obtain credentials for your app backend API. -> See Authentication Setup for instructions on how the credentials should be generated.
- 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:
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.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
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).
Querying Items (PowerSync.getAll)
The getAll method returns a set of rows from a table.
Watching Queries (PowerSync.watch)
The watch method executes a read query whenever a change to a dependent table is made.
Mutations (PowerSync.execute, PowerSync.writeTransaction)
The execute method can be used for executing single SQLite write statements.
Additional Usage Examples
See Usage Examples for further examples of the SDK.
Developer Notes
Connection Methods
This SDK supports two methods for streaming sync commands:
-
WebSocket (Default)
- The implementation leverages RSocket for handling reactive socket streams.
- Back-pressure is effectively managed through client-controlled command requests.
- Sync commands are transmitted efficiently as BSON (binary) documents.
- This method is recommended since it will support the future BLOB column support feature.
-
HTTP Streaming (Legacy)
- This is the original implementation method.
- This method will not support the future BLOB column feature.
By default, the PowerSyncDatabase.connect()
method uses WebSocket. You can optionally specify the connectionMethod
to override this:
SQLite Virtual File Systems
This SDK supports multiple Virtual File Systems (VFS), responsible for storing the local SQLite database:
1. IDBBatchAtomicVFS (Default)
- This system utilizes IndexedDB as its underlying storage mechanism.
- Multiple tabs are fully supported across most modern browsers.
- Users may experience stability issues when using Safari.
2. OPFS-based Alternatives
PowerSync supports two OPFS (Origin Private File System) implementations that generally offer improved performance:
OPFSCoopSyncVFS (Recommended)
- This implementation provides comprehensive multi-tab support across all major browsers.
- It offers the most reliable compatibility with Safari and Safari iOS.
- Example configuration:
AccessHandlePoolVFS
- This implementation delivers optimal performance for single-tab applications.
- The system is not designed to handle multiple tab scenarios.
- The configuration is similar to
OPFSCoopSyncVFS
, but requires usingWASQLiteVFS.AccessHandlePoolVFS
.
VFS Compatibility Matrix
VFS Type | Multi-Tab Support (Standard Browsers) | Multi-Tab Support (Safari/iOS) | Notes |
---|---|---|---|
IDBBatchAtomicVFS | ✅ | ❌ | Default, some Safari stability issues |
OPFSCoopSyncVFS | ✅ | ✅ | Recommended for multi-tab support |
AccessHandlePoolVFS | ❌ | ❌ | Best for single-tab applications |
Note: There are known issues with OPFS when using Safari’s incognito mode.
Managing OPFS Storage
Unlike IndexedDB, OPFS storage cannot be managed through browser developer tools. The following utility functions can help you manage OPFS storage programmatically:
ORM Support
See JavaScript ORM Support for details.
Troubleshooting
See Troubleshooting for pointers to debug common issues.
Was this page helpful?