@powersync/react-native 0.0.0-dev-20260525085311 → 0.0.0-dev-20260630141119

package/README.md

@@ -15,17 +15,83 @@ See a summary of features [here](https://docs.powersync.co/client-sdk-references
 ## Install Package
 
 ```bash
-npx expo install @powersync/react-native
+npx expo install @powersync/react-native @op-engineering/op-sqlite
 ```
 
-## Install Peer Dependency: SQLite
+## Configuration options
 
-By default, this SDK requires `@journeyapps/react-native-quick-sqlite` as a peer dependency. Alternatively, you can install OP-SQLite from the [PowerSync OP-SQLite package](https://github.com/powersync-ja/powersync-js/tree/main/packages/powersync-op-sqlite) (currently in Beta).
+### Encryption with SQLCipher
 
-Install it in your app with:
+To enable SQLCipher you need to add the following configuration option to your application's `package.json`. Note that for [monorepos](https://op-engineering.github.io/op-sqlite/docs/installation) you may have to add this configuration to the monorepo root `package.json` instead, this depends on where your package manager tool hoists modules.
 
-```bash
-npx expo install @journeyapps/react-native-quick-sqlite
+```json
+{
+  // your normal package.json
+  // ...
+  "op-sqlite": {
+    "sqlcipher": true
+  }
+}
+```
+
+Additionally you will need to add an [encryption key](https://www.zetetic.net/sqlcipher/sqlcipher-api/#key) to the OPSQLite factory constructor
+
+```typescript
+const db = new PowerSyncDatabase({
+  schema: new Schema(...),
+  database: {
+    dbFilename: 'sqlite.db',
+    sqliteOptions: {
+      encryptionKey: 'your-encryption-key'
+    }
+  }
+});
+```
+
+### Full-Text Search
+
+To enable the `fts5` extension, configure OP-SQLite in your (or for monorepos, the root) `package.json`:
+
+```json
+{
+  // your normal package.json
+  // ...
+  "op-sqlite": {
+    "fts5": true
+  }
+}
+```
+
+### Loading SQLite extensions
+
+To load additional SQLite extensions include the `extensions` option in `sqliteOptions` which expects an array of objects with a `path` and an `entryPoint`:
+
+```js
+sqliteOptions: {
+  extensions: [{ path: libPath, entryPoint: 'sqlite3_powersync_init' }];
+}
+```
+
+More info can be found in the [OP-SQLite docs](https://op-engineering.github.io/op-sqlite/docs/api/#loading-extensions).
+
+Example usage:
+
+```ts
+import { getDylibPath } from '@op-engineering/op-sqlite';
+
+let libPath: string;
+if (Platform.OS === 'ios') {
+  libPath = getDylibPath('co.powersync.sqlitecore', 'powersync-sqlite-core');
+} else {
+  libPath = 'libpowersync';
+}
+
+const factory = new OPSqliteOpenFactory({
+  dbFilename: 'sqlite.db',
+  sqliteOptions: {
+    extensions: [{ path: libPath, entryPoint: 'sqlite3_powersync_init' }]
+  }
+});
 ```
 
 ## Install Polyfills

package/android/build.gradle

@@ -0,0 +1,90 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["PowerSync_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply plugin: "com.facebook.react"
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["PowerSync_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["PowerSync_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.powersync.opsqlite"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation 'com.powersync:powersync-sqlite-core:0.4.12'
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+PowerSync_kotlinVersion=2.4.0
+PowerSync_minSdkVersion=24
+PowerSync_targetSdkVersion=36
+PowerSync_compileSdkVersion=36

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.powersync.opsqlite">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/powersync/opsqlite/PowerSyncOpSqlitePackage.kt

@@ -0,0 +1,46 @@
+package com.powersync.opsqlite
+
+import java.io.File
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.uimanager.ViewManager
+
+class PowerSyncOpSqlitePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf<NativeModule>(NativePowerSyncHelper(reactContext))
+  }
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext
+  ): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}
+
+private class NativePowerSyncHelper(context: ReactApplicationContext): ReactContextBaseJavaModule(context) {
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  fun resolveDefaultDatabaseLocation(dbName: String): String? {
+    // OP-sqlite uses context.getDatabasePath() as a default location for databases, but previous
+    // versions of the PowerSync React Native SDK used React Native Quick SQLite, which used
+    // context.getFileDir() instead. So, check if an old database exists and keep using the existing
+    // path for backwards compatibility.
+    val context = reactApplicationContext
+    val oldDirectory = context.filesDir
+    val filesPath = File(oldDirectory, dbName)
+    if (filesPath.exists()) {
+      return oldDirectory.absolutePath;
+    }
+    return null;
+  }
+
+  override fun getName(): String = NAME
+
+  companion object {
+    const val NAME: String = "NativePowerSyncHelper"
+  }
+}

package/ios/PowerSyncOpSqlite.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface PowerSyncOpSqlite : NSObject <RCTBridgeModule>
+
+@end

package/ios/PowerSyncOpSqlite.mm

@@ -0,0 +1,6 @@
+#import "PowerSyncOpSqlite.h"
+
+@implementation PowerSyncOpSqlite
+RCT_EXPORT_MODULE()
+
+@end

package/lib/db/PowerSyncDatabase.d.ts

@@ -1,4 +1,10 @@
-import { AbstractPowerSyncDatabase, AbstractStreamingSyncImplementation, BucketStorageAdapter, DBAdapter, PowerSyncBackendConnector, PowerSyncDatabaseOptionsWithSettings, type RequiredAdditionalConnectionOptions } from '@powersync/common';
+import { BasePowerSyncDatabaseOptions, CommonPowerSyncDatabase, DatabaseSource, PowerSyncDatabaseConstructor } from '@powersync/common';
+import { ReactNativeRemoteOptions } from '../sync/stream/ReactNativeRemote';
+import { OPSQLiteOpenFactoryOptions } from './adapters/op-sqlite/OPSqliteDBOpenFactory';
+export type ReactNativeDatabaseOptions = BasePowerSyncDatabaseOptions & DatabaseSource<OPSQLiteOpenFactoryOptions> & ReactNativeSpecificOptions;
+export interface ReactNativeSpecificOptions {
+    remote?: ReactNativeRemoteOptions;
+}
 /**
  * A PowerSync database which provides SQLite functionality
  * which is automatically synced.
@@ -13,13 +19,6 @@ import { AbstractPowerSyncDatabase, AbstractStreamingSyncImplementation, BucketS
  * });
  * ```
  */
-export declare class PowerSyncDatabase extends AbstractPowerSyncDatabase {
-    _initialize(): Promise<void>;
-    /**
-     * Opens a DBAdapter using React Native Quick SQLite as the
-     * default SQLite open factory.
-     */
-    protected openDBAdapter(options: PowerSyncDatabaseOptionsWithSettings): DBAdapter;
-    protected generateBucketStorageAdapter(): BucketStorageAdapter;
-    protected generateSyncStreamImplementation(connector: PowerSyncBackendConnector, options: RequiredAdditionalConnectionOptions): AbstractStreamingSyncImplementation;
+export declare const PowerSyncDatabase: PowerSyncDatabaseConstructor<ReactNativeDatabaseOptions>;
+export interface PowerSyncDatabase extends CommonPowerSyncDatabase {
 }

package/lib/db/PowerSyncDatabase.js

@@ -1,37 +1,26 @@
-import { AbstractPowerSyncDatabase } from '@powersync/common';
+import { SyncStreamConnectionMethod } from '@powersync/common';
+import { BasePowerSyncDatabase, openDatabase } from '@powersync/shared-internals';
 import { ReactNativeRemote } from '../sync/stream/ReactNativeRemote';
 import { ReactNativeStreamingSyncImplementation } from '../sync/stream/ReactNativeStreamingSyncImplementation';
 import { ReactNativeBucketStorageAdapter } from './../sync/bucket/ReactNativeBucketStorageAdapter';
-import { ReactNativeQuickSqliteOpenFactory } from './adapters/react-native-quick-sqlite/ReactNativeQuickSQLiteOpenFactory';
-/**
- * A PowerSync database which provides SQLite functionality
- * which is automatically synced.
- *
- * @example
- * ```typescript
- * export const db = new PowerSyncDatabase({
- *  schema: AppSchema,
- *  database: {
- *    dbFilename: 'example.db'
- *  }
- * });
- * ```
- */
-export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
+import { OPSqliteOpenFactory } from './adapters/op-sqlite/OPSqliteDBOpenFactory';
+import { defaultFetchImplementation } from '../sync/stream/fetch';
+class ReactNativePowerSyncDatabase extends BasePowerSyncDatabase {
+    constructor(options) {
+        super(options);
+    }
     async _initialize() { }
-    /**
-     * Opens a DBAdapter using React Native Quick SQLite as the
-     * default SQLite open factory.
-     */
-    openDBAdapter(options) {
-        const defaultFactory = new ReactNativeQuickSqliteOpenFactory(options.database);
-        return defaultFactory.openDB();
+    openDBAdapter() {
+        return openDatabase(this.options, (database) => {
+            const defaultFactory = new OPSqliteOpenFactory(database);
+            return defaultFactory.openDB();
+        });
     }
     generateBucketStorageAdapter() {
         return new ReactNativeBucketStorageAdapter(this.database, this.logger);
     }
     generateSyncStreamImplementation(connector, options) {
-        const remote = new ReactNativeRemote(connector, this.logger);
+        const remote = new ReactNativeRemote(connector, this.logger, this.options.remote);
         return new ReactNativeStreamingSyncImplementation({
             ...options,
             adapter: this.bucketStorageAdapter,
@@ -44,5 +33,24 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
             logger: this.logger
         });
     }
+    get defaultConnectionMethod() {
+        const fetch = this.options.remote?.fetchImplementation ?? defaultFetchImplementation(this.logger);
+        return fetch.supportsStreams ? SyncStreamConnectionMethod.HTTP : SyncStreamConnectionMethod.WEB_SOCKET;
+    }
 }
+/**
+ * A PowerSync database which provides SQLite functionality
+ * which is automatically synced.
+ *
+ * @example
+ * ```typescript
+ * export const db = new PowerSyncDatabase({
+ *  schema: AppSchema,
+ *  database: {
+ *    dbFilename: 'example.db'
+ *  }
+ * });
+ * ```
+ */
+export const PowerSyncDatabase = ReactNativePowerSyncDatabase;
 //# sourceMappingURL=PowerSyncDatabase.js.map

package/lib/db/PowerSyncDatabase.js.map

@@ -1 +1 @@
-{"version":3,"file":"PowerSyncDatabase.js","sourceRoot":"","sources":["../../src/db/PowerSyncDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EAO1B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,sCAAsC,EAAE,MAAM,uDAAuD,CAAC;AAC/G,OAAO,EAAE,+BAA+B,EAAE,MAAM,kDAAkD,CAAC;AACnG,OAAO,EAAE,iCAAiC,EAAE,MAAM,wEAAwE,CAAC;AAE3H;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,iBAAkB,SAAQ,yBAAyB;IAC9D,KAAK,CAAC,WAAW,KAAmB,CAAC;IAErC;;;OAGG;IACO,aAAa,CAAC,OAA6C;QACnE,MAAM,cAAc,GAAG,IAAI,iCAAiC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC/E,OAAO,cAAc,CAAC,MAAM,EAAE,CAAC;IACjC,CAAC;IAES,4BAA4B;QACpC,OAAO,IAAI,+BAA+B,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACzE,CAAC;IAES,gCAAgC,CACxC,SAAoC,EACpC,OAA4C;QAE5C,MAAM,MAAM,GAAG,IAAI,iBAAiB,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAE7D,OAAO,IAAI,sCAAsC,CAAC;YAChD,GAAG,OAAO;YACV,OAAO,EAAE,IAAI,CAAC,oBAAoB;YAClC,MAAM;YACN,UAAU,EAAE,KAAK,IAAI,EAAE;gBACrB,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC1B,MAAM,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACnC,CAAC;YACD,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI;YAC9B,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC,CAAC;IACL,CAAC;CACF"}
+{"version":3,"file":"PowerSyncDatabase.js","sourceRoot":"","sources":["../../src/db/PowerSyncDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,0BAA0B,EAC3B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,qBAAqB,EAIrB,YAAY,EACb,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAA4B,MAAM,kCAAkC,CAAC;AAC/F,OAAO,EAAE,sCAAsC,EAAE,MAAM,uDAAuD,CAAC;AAC/G,OAAO,EAAE,+BAA+B,EAAE,MAAM,kDAAkD,CAAC;AACnG,OAAO,EAAE,mBAAmB,EAA8B,MAAM,4CAA4C,CAAC;AAC7G,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAUlE,MAAM,4BAA6B,SAAQ,qBAAiD;IAC1F,YAAY,OAAmC;QAC7C,KAAK,CAAC,OAAO,CAAC,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,WAAW,KAAmB,CAAC;IAElB,aAAa;QAC9B,OAAO,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,EAAE;YAC7C,MAAM,cAAc,GAAG,IAAI,mBAAmB,CAAC,QAAQ,CAAC,CAAC;YACzD,OAAO,cAAc,CAAC,MAAM,EAAE,CAAC;QACjC,CAAC,CAAC,CAAC;IACL,CAAC;IAES,4BAA4B;QACpC,OAAO,IAAI,+BAA+B,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACzE,CAAC;IAES,gCAAgC,CACxC,SAAoC,EACpC,OAAwC;QAExC,MAAM,MAAM,GAAG,IAAI,iBAAiB,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAElF,OAAO,IAAI,sCAAsC,CAAC;YAChD,GAAG,OAAO;YACV,OAAO,EAAE,IAAI,CAAC,oBAAoB;YAClC,MAAM;YACN,UAAU,EAAE,KAAK,IAAI,EAAE;gBACrB,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC1B,MAAM,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACnC,CAAC;YACD,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI;YAC9B,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC,CAAC;IACL,CAAC;IAED,IAAc,uBAAuB;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,mBAAmB,IAAI,0BAA0B,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAClG,OAAO,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,0BAA0B,CAAC,IAAI,CAAC,CAAC,CAAC,0BAA0B,CAAC,UAAU,CAAC;IACzG,CAAC;CACF;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAA6D,4BAA4B,CAAC"}

package/lib/db/adapters/op-sqlite/OPSQLiteConnection.d.ts

@@ -0,0 +1,25 @@
+import { DB, UpdateHookOperation } from '@op-engineering/op-sqlite';
+import { BaseObserver, LockContext, QueryResult, RawQueryResult } from '@powersync/common';
+export type OPSQLiteConnectionOptions = {
+    baseDB: DB;
+};
+export type OPSQLiteUpdateNotification = {
+    table: string;
+    operation: UpdateHookOperation;
+    row?: any;
+    rowId: number;
+};
+export declare class OPSQLiteConnection extends LockContext {
+    protected options: OPSQLiteConnectionOptions;
+    protected DB: DB;
+    private updateBuffer;
+    readonly tableUpdateDispatcher: BaseObserver<import("@powersync/common").BaseListener>;
+    constructor(options: OPSQLiteConnectionOptions);
+    addTableUpdate(update: OPSQLiteUpdateNotification): void;
+    flushUpdates(): void;
+    close(): void;
+    execute<T>(query: string, params?: any[]): Promise<QueryResult<T>>;
+    executeRaw(query: string, params?: any[]): Promise<RawQueryResult>;
+    executeNativeBatch(query: string, params?: any[][]): Promise<QueryResult<never>>;
+    refreshSchema(): Promise<void>;
+}

package/lib/db/adapters/op-sqlite/OPSQLiteConnection.js

@@ -0,0 +1,63 @@
+import { BaseObserver, LockContext, queryResultFromMapped, queryResultWithoutRows } from '@powersync/common';
+export class OPSQLiteConnection extends LockContext {
+    options;
+    DB;
+    updateBuffer;
+    tableUpdateDispatcher = new BaseObserver();
+    constructor(options) {
+        super();
+        this.options = options;
+        this.DB = options.baseDB;
+        this.updateBuffer = new Set();
+        this.DB.rollbackHook(() => {
+            this.updateBuffer = new Set();
+        });
+        this.DB.updateHook((update) => {
+            this.addTableUpdate(update);
+        });
+    }
+    addTableUpdate(update) {
+        this.updateBuffer.add(update.table);
+    }
+    flushUpdates() {
+        if (!this.updateBuffer.size) {
+            return;
+        }
+        const batchedUpdate = {
+            tables: Array.from(this.updateBuffer)
+        };
+        this.updateBuffer = new Set();
+        this.tableUpdateDispatcher.iterateListeners((l) => l.tablesUpdated?.(batchedUpdate));
+    }
+    close() {
+        return this.DB.close();
+    }
+    async execute(query, params) {
+        const res = await this.DB.execute(query, params);
+        return queryResultFromMapped(res, res.rows);
+    }
+    async executeRaw(query, params) {
+        const { insertId, rowsAffected, columnNames, rawRows } = await this.DB.executeRaw(query, params);
+        return {
+            insertId: insertId,
+            rowsAffected: rowsAffected,
+            columnNames,
+            rawRows: (rawRows ?? [])
+        };
+    }
+    // NOTE: Do not override executeBatch here. OP-sqlite starts a transaction in executeBatch, so we can't use it if
+    // we're already in a transaction. To be safe, we only call this method from the OPSqliteAdapter class overriding
+    // executeBatch when called on the adapter directly (not within readLock / writeLock).
+    async executeNativeBatch(query, params = []) {
+        const tuple = [[query, params[0]]];
+        params.slice(1).forEach((p) => tuple.push([query, p]));
+        const result = await this.DB.executeBatch(tuple);
+        return queryResultWithoutRows({
+            rowsAffected: result.rowsAffected ?? 0
+        });
+    }
+    async refreshSchema() {
+        await this.get("PRAGMA table_info('sqlite_master')");
+    }
+}
+//# sourceMappingURL=OPSQLiteConnection.js.map

package/lib/db/adapters/op-sqlite/OPSQLiteConnection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OPSQLiteConnection.js","sourceRoot":"","sources":["../../../../src/db/adapters/op-sqlite/OPSQLiteConnection.ts"],"names":[],"mappings":"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"}

package/lib/db/adapters/op-sqlite/OPSqliteAdapter.d.ts

@@ -0,0 +1,32 @@
+import { DBAdapter, DBLockOptions, QueryResult } from '@powersync/common';
+import { Semaphore } from '@powersync/shared-internals';
+import { OPSQLiteConnection } from './OPSQLiteConnection';
+import { SqliteOptions } from './SqliteOptions';
+/**
+ * Adapter for React Native Quick SQLite
+ */
+export type OPSQLiteAdapterOptions = {
+    name: string;
+    dbLocation?: string;
+    sqliteOptions?: SqliteOptions;
+};
+export declare class OPSQLiteDBAdapter extends DBAdapter {
+    protected options: OPSQLiteAdapterOptions;
+    name: string;
+    protected initialized: Promise<void>;
+    protected readConnections: Semaphore<OPSQLiteConnection> | null;
+    protected writeConnection: Semaphore<OPSQLiteConnection> | null;
+    private abortController;
+    constructor(options: OPSQLiteAdapterOptions);
+    protected init(): Promise<void>;
+    protected openConnection(readOnly: boolean, filenameOverride?: string): Promise<OPSQLiteConnection>;
+    private openDatabase;
+    private loadAdditionalExtensions;
+    private loadPowerSyncExtension;
+    close(): Promise<void>;
+    private generateNestedAbortSignal;
+    readLock<T>(fn: (tx: OPSQLiteConnection) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    writeLock<T>(fn: (tx: OPSQLiteConnection) => Promise<T>, options?: DBLockOptions): Promise<T>;
+    refreshSchema(): Promise<void>;
+    executeBatch(query: string, params?: any[][]): Promise<QueryResult<never>>;
+}