PowerSync SDK on NPM
This SDK is distributed via NPM [External link].
Source Code
Refer to packages/react-native 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 React Native and PowerSync.
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
Add the PowerSync React Native NPM package to your project:Install peer dependencies
PowerSync requires a SQLite database adapter.Using Expo Go? Our native database adapters listed below (OP-SQLite and React Native Quick SQLite) are not compatible with Expo Go’s sandbox environment. To run PowerSync with Expo Go install our JavaScript-based adapter
@powersync/adapter-sql-js
instead. See details here.- Built-in encryption support via SQLCipher
- Smoother transition to React Native’s New Architecture
Polyfills and additional notes:
- For async iterator support with watched queries, additional polyfills are required. See the Babel plugins section in the README.
-
By default, this SDK connects to a PowerSync instance via WebSocket (from
@powersync/react-native@1.11.0
) or HTTP streaming (before@powersync/react-native@1.11.0
). See Developer Notes for more details on connection methods and platform-specific requirements. - When using the OP-SQLite package, we recommend adding this metro config to avoid build issues.
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 React Native 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 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.powersync/AppSchema.ts
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:For getting started and testing PowerSync use the @journeyapps/react-native-quick-sqlite package.
By default, this SDK requires @journeyapps/react-native-quick-sqlite as a peer dependency.
powersync/system.ts
SDK versions lower than 1.8.0In SDK versions lower than 1.8.0, you will need to use the deprecated RNQSPowerSyncDatabaseOpenFactory syntax to instantiate the database.
powersync/system.ts
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)
- 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.
powersync/Connector.ts
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 (returnsnull
if no result is found).
TodoItemWidget.jsx
Querying Items (PowerSync.getAll)
The getAll method returns a set of rows from a table.ListsWidget.jsx
Watching Queries (PowerSync.watch)
The watch method executes a read query whenever a change to a dependent table is made. It can be used with anAsyncGenerator
, or with a callback.
Mutations (PowerSync.execute)
The execute method can be used for executing single SQLite write statements.ListsWidget.jsx
Configure Logging
Enable verbose output in the developer tools for detailed logs.
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.
PowerSyncDatabase.connect()
method uses WebSocket. You can optionally specify the connectionMethod
to override this:
Android: Flipper network plugin for HTTP streams
Not needed when using websockets, which is the default since@powersync/react-native@1.11.0
.
If you are connecting to PowerSync using HTTP streams, you require additional configuration on Android. React Native does not support streams out of the box, so we use the polyfills mentioned. There is currently an open issue where the Flipper network plugin does not allow Stream events to fire. This plugin needs to be disabled in order for HTTP streams to work.
If you are using Java (Expo < 50):
Uncomment the following from android/app/src/debug/java/com/<ProjectName>/ReactNativeFlipper.java
android/gradle.properties
onCreate
in android/app/src/main/java/com/<ProjectName>/example/MainApplication.kt
iOS: use_frameworks and react-native-quick-sqlite
Usinguse_frameworks
(for example, because you are using Google Analytics or Firebase Analytics) will silently break the compilation process of react-native-quick-sqlite on iOS and results in the PowerSync SQLite extension not loading correctly. To solve this, add this to your Podfile: