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

package/lib/sync/stream/fetch.js

@@ -0,0 +1,31 @@
+import { LogLevels } from '@powersync/common';
+export function defaultFetchImplementation(logger) {
+    return (resolvedDefault ??= resolveDefaultFetchImplementation(logger));
+}
+let resolvedDefault;
+function resolveDefaultFetchImplementation(logger) {
+    try {
+        const { fetch } = require('expo/fetch');
+        return {
+            supportsStreams: true,
+            run({ resource, request }) {
+                return fetch(resource, request);
+            }
+        };
+    }
+    catch (expoNotFound) {
+        logger.log({
+            level: LogLevels.debug,
+            message: 'Could not resolve expo/fetch, HTTP streams are unavailable.',
+            error: expoNotFound
+        });
+        // Fetch polyfill built in to React Native. This one doesn't support streaming responses.
+        return {
+            supportsStreams: false,
+            run({ resource, request }) {
+                return fetch(resource, request);
+            }
+        };
+    }
+}
+//# sourceMappingURL=fetch.js.map

package/lib/sync/stream/fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.js","sourceRoot":"","sources":["../../../src/sync/stream/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAmB,MAAM,mBAAmB,CAAC;AAc/D,MAAM,UAAU,0BAA0B,CAAC,MAAuB;IAChE,OAAO,CAAC,eAAe,KAAK,iCAAiC,CAAC,MAAM,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,IAAI,eAAyD,CAAC;AAE9D,SAAS,iCAAiC,CAAC,MAAuB;IAChE,IAAI,CAAC;QACH,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;QACxC,OAAO;YACL,eAAe,EAAE,IAAI;YACrB,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE;gBACvB,OAAO,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAClC,CAAC;SACF,CAAC;IACJ,CAAC;IAAC,OAAO,YAAY,EAAE,CAAC;QACtB,MAAM,CAAC,GAAG,CAAC;YACT,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,OAAO,EAAE,6DAA6D;YACtE,KAAK,EAAE,YAAY;SACpB,CAAC,CAAC;QAEH,yFAAyF;QACzF,OAAO;YACL,eAAe,EAAE,KAAK;YACtB,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE;gBACvB,OAAO,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAClC,CAAC;SACF,CAAC;IACJ,CAAC;AACH,CAAC"}

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@powersync/react-native",
-  "version": "0.0.0-dev-20260525085311",
+  "version": "0.0.0-dev-20260630144038",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "description": "PowerSync React Native SDK",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
+  "type": "module",
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "files": [
     "lib",
-    "dist",
-    "src"
+    "src",
+    "android",
+    "ios",
+    "*.podspec"
   ],
   "repository": {
     "type": "git",
@@ -25,37 +28,22 @@
   },
   "homepage": "https://docs.powersync.com/",
   "peerDependencies": {
-    "@journeyapps/react-native-quick-sqlite": "^2.5.2",
-    "@powersync/common": "^1.53.1",
+    "@op-engineering/op-sqlite": "^17.1.0",
+    "@powersync/common": "0.0.0-dev-20260630144038",
     "react": "*",
     "react-native": "*"
   },
-  "peerDependenciesMeta": {
-    "@journeyapps/react-native-quick-sqlite": {
-      "optional": true
-    }
-  },
   "dependencies": {
-    "@powersync/react": "1.10.0",
-    "@powersync/common": "1.53.1"
+    "@powersync/common": "0.0.0-dev-20260630144038",
+    "@powersync/react": "0.0.0-dev-20260630144038",
+    "@powersync/shared-internals": "1.0.0"
   },
   "devDependencies": {
-    "@craftzdog/react-native-buffer": "^6.0.5",
-    "@journeyapps/react-native-quick-sqlite": "^2.5.2",
-    "@rollup/plugin-alias": "^5.1.0",
-    "@rollup/plugin-commonjs": "^29.0.0",
-    "@rollup/plugin-inject": "^5.0.5",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-replace": "^5.0.7",
-    "@rollup/plugin-terser": "^0.4.4",
+    "@op-engineering/op-sqlite": "^17.1.0",
+    "expo": "^56.0.0",
     "@types/react": "^19.1.1",
     "react": "^19.2.0",
-    "react-native": "0.83.1",
-    "react-native-fetch-api": "^3.0.0",
-    "rollup": "^4.52.5",
-    "text-encoding": "^0.7.0",
-    "web-streams-polyfill": "3.2.1"
+    "react-native": "^0.85.0"
   },
   "keywords": [
     "data sync",
@@ -65,11 +53,10 @@
     "live data"
   ],
   "scripts": {
-    "build": "tsc -b && rollup -c rollup.config.mjs",
-    "build:prod": "tsc -b && rollup -c rollup.config.mjs",
-    "clean": "rm -rf lib dist tsconfig.tsbuildinfo",
+    "build": "tsc -b",
+    "build:prod": "tsc -b",
+    "clean": "rm -rf lib tsconfig.tsbuildinfo",
     "test": "vitest --config vitest.config.ts",
-    "watch": "tsc -b -w",
-    "test:exports": "attw --pack ."
+    "watch": "tsc -b -w"
   }
 }

package/powersync-react-native.podspec

@@ -0,0 +1,32 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "powersync-react-native"
+  # Our development versions are not recognized by Cocoapods
+  version = package['version']
+  if version.include?('-dev')
+    s.version = '0.0.0'
+  else
+    s.version = version
+  end
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/powersync-ja/powersync-js.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,cpp}"
+
+  s.dependency "React-callinvoker"
+  s.dependency "React"
+  s.dependency "powersync-sqlite-core", "~> 0.4.12"
+  if defined?(install_modules_dependencies())
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+  end
+end

package/src/db/PowerSyncDatabase.ts

@@ -1,41 +1,45 @@
 import {
-  AbstractPowerSyncDatabase,
-  AbstractStreamingSyncImplementation,
-  BucketStorageAdapter,
+  BasePowerSyncDatabaseOptions,
+  CommonPowerSyncDatabase,
+  DatabaseSource,
   DBAdapter,
   PowerSyncBackendConnector,
-  PowerSyncDatabaseOptionsWithSettings,
-  type RequiredAdditionalConnectionOptions
+  PowerSyncDatabaseConstructor,
+  SyncStreamConnectionMethod
 } from '@powersync/common';
-import { ReactNativeRemote } from '../sync/stream/ReactNativeRemote';
+import {
+  BasePowerSyncDatabase,
+  AbstractStreamingSyncImplementation,
+  BucketStorageAdapter,
+  CreateSyncImplementationOptions,
+  openDatabase
+} from '@powersync/shared-internals';
+import { ReactNativeRemote, ReactNativeRemoteOptions } 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';
+import { OPSqliteOpenFactory, OPSQLiteOpenFactoryOptions } from './adapters/op-sqlite/OPSqliteDBOpenFactory';
+import { defaultFetchImplementation } from '../sync/stream/fetch';
+
+export type ReactNativeDatabaseOptions = BasePowerSyncDatabaseOptions &
+  DatabaseSource<OPSQLiteOpenFactoryOptions> &
+  ReactNativeSpecificOptions;
+
+export interface ReactNativeSpecificOptions {
+  remote?: ReactNativeRemoteOptions;
+}
+
+class ReactNativePowerSyncDatabase extends BasePowerSyncDatabase<ReactNativeDatabaseOptions> {
+  constructor(options: ReactNativeDatabaseOptions) {
+    super(options);
+  }
 
-/**
- * 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 {
   async _initialize(): Promise<void> {}
 
-  /**
-   * Opens a DBAdapter using React Native Quick SQLite as the
-   * default SQLite open factory.
-   */
-  protected openDBAdapter(options: PowerSyncDatabaseOptionsWithSettings): DBAdapter {
-    const defaultFactory = new ReactNativeQuickSqliteOpenFactory(options.database);
-    return defaultFactory.openDB();
+  protected override openDBAdapter(): DBAdapter {
+    return openDatabase(this.options, (database) => {
+      const defaultFactory = new OPSqliteOpenFactory(database);
+      return defaultFactory.openDB();
+    });
   }
 
   protected generateBucketStorageAdapter(): BucketStorageAdapter {
@@ -44,9 +48,9 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
 
   protected generateSyncStreamImplementation(
     connector: PowerSyncBackendConnector,
-    options: RequiredAdditionalConnectionOptions
+    options: CreateSyncImplementationOptions
   ): AbstractStreamingSyncImplementation {
-    const remote = new ReactNativeRemote(connector, this.logger);
+    const remote = new ReactNativeRemote(connector, this.logger, this.options.remote);
 
     return new ReactNativeStreamingSyncImplementation({
       ...options,
@@ -60,4 +64,27 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
       logger: this.logger
     });
   }
+
+  protected get defaultConnectionMethod(): SyncStreamConnectionMethod {
+    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: PowerSyncDatabaseConstructor<ReactNativeDatabaseOptions> = ReactNativePowerSyncDatabase;
+
+export interface PowerSyncDatabase extends CommonPowerSyncDatabase {}

package/src/db/adapters/op-sqlite/OPSQLiteConnection.ts

@@ -0,0 +1,95 @@
+import { DB, SQLBatchTuple, UpdateHookOperation } from '@op-engineering/op-sqlite';
+import {
+  BaseObserver,
+  BatchedUpdateNotification,
+  LockContext,
+  QueryResult,
+  queryResultFromMapped,
+  queryResultWithoutRows,
+  RawQueryResult,
+  SqliteValue
+} from '@powersync/common';
+
+export type OPSQLiteConnectionOptions = {
+  baseDB: DB;
+};
+
+export type OPSQLiteUpdateNotification = {
+  table: string;
+  operation: UpdateHookOperation;
+  row?: any;
+  rowId: number;
+};
+
+export class OPSQLiteConnection extends LockContext {
+  protected DB: DB;
+  private updateBuffer: Set<string>;
+  readonly tableUpdateDispatcher = new BaseObserver();
+
+  constructor(protected options: OPSQLiteConnectionOptions) {
+    super();
+    this.DB = options.baseDB;
+    this.updateBuffer = new Set();
+
+    this.DB.rollbackHook(() => {
+      this.updateBuffer = new Set();
+    });
+
+    this.DB.updateHook((update) => {
+      this.addTableUpdate(update);
+    });
+  }
+
+  addTableUpdate(update: OPSQLiteUpdateNotification) {
+    this.updateBuffer.add(update.table);
+  }
+
+  flushUpdates() {
+    if (!this.updateBuffer.size) {
+      return;
+    }
+
+    const batchedUpdate: BatchedUpdateNotification = {
+      tables: Array.from(this.updateBuffer)
+    };
+
+    this.updateBuffer = new Set();
+    this.tableUpdateDispatcher.iterateListeners((l) => l.tablesUpdated?.(batchedUpdate));
+  }
+
+  close() {
+    return this.DB.close();
+  }
+
+  async execute<T>(query: string, params?: any[]): Promise<QueryResult<T>> {
+    const res = await this.DB.execute(query, params);
+    return queryResultFromMapped(res, res.rows as T[]);
+  }
+
+  async executeRaw(query: string, params?: any[]): Promise<RawQueryResult> {
+    const { insertId, rowsAffected, columnNames, rawRows } = await this.DB.executeRaw(query, params);
+    return {
+      insertId: insertId,
+      rowsAffected: rowsAffected,
+      columnNames,
+      rawRows: (rawRows ?? []) as SqliteValue[][]
+    };
+  }
+
+  // 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: string, params: any[][] = []): Promise<QueryResult<never>> {
+    const tuple: SQLBatchTuple[] = [[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')");
+  }
+}

package/src/db/adapters/op-sqlite/OPSqliteAdapter.ts

@@ -0,0 +1,245 @@
+import { NativeModules } from 'react-native';
+import { getDylibPath, open, type DB } from '@op-engineering/op-sqlite';
+import { DBAdapter, DBLockOptions, QueryResult } from '@powersync/common';
+import { timeoutSignal, Semaphore } from '@powersync/shared-internals';
+import { Platform } from 'react-native';
+import { OPSQLiteConnection } from './OPSQLiteConnection';
+import { SqliteOptions } from './SqliteOptions';
+
+/**
+ * Adapter for React Native Quick SQLite
+ */
+export type OPSQLiteAdapterOptions = {
+  name: string;
+  dbLocation?: string;
+  sqliteOptions?: SqliteOptions;
+};
+
+const READ_CONNECTIONS = 5;
+
+export class OPSQLiteDBAdapter extends DBAdapter {
+  name: string;
+
+  protected initialized: Promise<void>;
+
+  protected readConnections: Semaphore<OPSQLiteConnection> | null;
+  protected writeConnection: Semaphore<OPSQLiteConnection> | null;
+
+  private abortController: AbortController;
+
+  constructor(protected options: OPSQLiteAdapterOptions) {
+    super();
+    this.name = this.options.name;
+
+    this.readConnections = null;
+    this.writeConnection = null;
+    this.abortController = new AbortController();
+    this.initialized = this.init();
+  }
+
+  protected async init() {
+    const { lockTimeoutMs, journalMode, journalSizeLimit, synchronous, cacheSizeKb, temporaryStorage } =
+      this.options.sqliteOptions!;
+    const dbFilename = this.options.name;
+
+    const underlyingWriteConnection = await this.openConnection(false, dbFilename);
+
+    const baseStatements = [
+      `PRAGMA busy_timeout = ${lockTimeoutMs}`,
+      `PRAGMA cache_size = -${cacheSizeKb}`,
+      `PRAGMA temp_store = ${temporaryStorage}`
+    ];
+
+    const writeConnectionStatements = [
+      ...baseStatements,
+      `PRAGMA journal_mode = ${journalMode}`,
+      `PRAGMA journal_size_limit = ${journalSizeLimit}`,
+      `PRAGMA synchronous = ${synchronous}`
+    ];
+
+    for (const statement of writeConnectionStatements) {
+      for (let tries = 0; tries < 30; tries++) {
+        try {
+          await underlyingWriteConnection.execute(statement);
+          break;
+        } catch (e: any) {
+          if (e instanceof Error && e.message.includes('database is locked') && tries < 29) {
+            continue;
+          } else {
+            throw e;
+          }
+        }
+      }
+    }
+
+    // Changes should only occur in the write connection
+    underlyingWriteConnection.tableUpdateDispatcher.registerListener({
+      tablesUpdated: (notification) => this.iterateListeners((cb) => cb.tablesUpdated?.(notification))
+    });
+
+    const underlyingReadConnections = [];
+    for (let i = 0; i < READ_CONNECTIONS; i++) {
+      const conn = await this.openConnection(true, dbFilename);
+      for (let statement of baseStatements) {
+        await conn.execute(statement);
+      }
+      underlyingReadConnections.push(conn);
+    }
+
+    this.writeConnection = new Semaphore([underlyingWriteConnection]);
+    this.readConnections = new Semaphore(underlyingReadConnections);
+  }
+
+  protected async openConnection(readOnly: boolean, filenameOverride?: string): Promise<OPSQLiteConnection> {
+    const dbFilename = filenameOverride ?? this.options.name;
+    const DB: DB = this.openDatabase(dbFilename, readOnly, this.options.sqliteOptions?.encryptionKey ?? undefined);
+
+    //Load extensions for all connections
+    this.loadAdditionalExtensions(DB);
+    this.loadPowerSyncExtension(DB);
+
+    await DB.execute('SELECT powersync_init()');
+
+    return new OPSQLiteConnection({
+      baseDB: DB
+    });
+  }
+
+  private openDatabase(dbFilename: string, readOnly: boolean, encryptionKey?: string): DB {
+    const openOptions: Parameters<typeof open>[0] = {
+      name: dbFilename,
+      readOnly
+    };
+
+    if (this.options.dbLocation) {
+      openOptions.location = this.options.dbLocation;
+    } else if ('NativePowerSyncHelper' in NativeModules) {
+      // In older versions of the PowerSync React Native SDK, we used React Native Quick SQLite instead of OP-SQLite.
+      // On Android, RQNS uses context.getFilesDir() instead of context.getDatabasePath() (which OP-SQLite uses as a
+      // default). So, to ensure that databases opened with RNQS continue to work with OP-SQLite, we have a native
+      // helper method that checks whether the database exists in the old path and would apply that as an explicit
+      // location in that case.
+      const helper: NativePowerSyncHelper = NativeModules.NativePowerSyncHelper;
+      const defaultLocation = helper.resolveDefaultDatabaseLocation(dbFilename);
+      if (defaultLocation) {
+        openOptions.location = defaultLocation;
+      }
+    }
+
+    // If the encryption key is undefined/null when using SQLCipher it will cause the open function to fail
+    if (encryptionKey) {
+      openOptions.encryptionKey = encryptionKey;
+    }
+
+    return open(openOptions);
+  }
+
+  private loadAdditionalExtensions(DB: DB) {
+    if (this.options.sqliteOptions?.extensions && this.options.sqliteOptions.extensions.length > 0) {
+      for (const extension of this.options.sqliteOptions.extensions) {
+        DB.loadExtension(extension.path, extension.entryPoint);
+      }
+    }
+  }
+
+  private async loadPowerSyncExtension(DB: DB) {
+    if (Platform.OS === 'ios') {
+      const libPath = getDylibPath('co.powersync.sqlitecore', 'powersync-sqlite-core');
+      DB.loadExtension(libPath, 'sqlite3_powersync_init');
+    } else {
+      DB.loadExtension('libpowersync', 'sqlite3_powersync_init');
+    }
+  }
+
+  async close() {
+    await this.initialized;
+    // Abort any pending operations
+    this.abortController.abort();
+
+    const { item: writeConnection, release: returnWrite } = await this.writeConnection!.requestOne();
+    const { items: readers, release: returnReaders } = await this.readConnections!.requestAll();
+
+    try {
+      writeConnection.close();
+      readers.forEach((c) => c.close());
+    } finally {
+      returnWrite();
+      returnReaders();
+    }
+  }
+
+  private generateNestedAbortSignal(options?: DBLockOptions) {
+    const outerSignal = this.abortController.signal;
+    let signal: AbortSignal;
+    let cleanUpInnerSignal: (() => void) | undefined;
+
+    if (options?.timeoutMs && !outerSignal.aborted) {
+      // This is essentially an AbortSignal.any() polyfill.
+      const innerController = new AbortController();
+      cleanUpInnerSignal = () => {
+        innerController.abort();
+        outerSignal.removeEventListener('abort', cleanUpInnerSignal!);
+        timeout.removeEventListener('abort', cleanUpInnerSignal!);
+      };
+
+      outerSignal.addEventListener('abort', cleanUpInnerSignal);
+      const timeout = timeoutSignal(options.timeoutMs);
+      timeout.addEventListener('abort', cleanUpInnerSignal);
+
+      signal = innerController.signal;
+    } else {
+      signal = outerSignal;
+    }
+
+    return { signal, cleanUpInnerSignal };
+  }
+
+  async readLock<T>(fn: (tx: OPSQLiteConnection) => Promise<T>, options?: DBLockOptions): Promise<T> {
+    await this.initialized;
+
+    const { signal, cleanUpInnerSignal } = this.generateNestedAbortSignal(options);
+    const { item, release } = await this.readConnections!.requestOne(signal);
+    try {
+      return await fn(item);
+    } finally {
+      release();
+      cleanUpInnerSignal?.();
+    }
+  }
+
+  async writeLock<T>(fn: (tx: OPSQLiteConnection) => Promise<T>, options?: DBLockOptions): Promise<T> {
+    await this.initialized;
+
+    const { signal, cleanUpInnerSignal } = this.generateNestedAbortSignal(options);
+    const { item, release } = await this.writeConnection!.requestOne(signal);
+    try {
+      return await fn(item).finally(() => item.flushUpdates());
+    } finally {
+      release();
+      cleanUpInnerSignal?.();
+    }
+  }
+
+  async refreshSchema(): Promise<void> {
+    await this.initialized;
+    await this.writeLock((l) => l.refreshSchema());
+    const { items, release } = await this.readConnections!.requestAll();
+    try {
+      for (let readConnection of items) {
+        await readConnection.refreshSchema();
+      }
+    } finally {
+      release();
+    }
+  }
+
+  executeBatch(query: string, params?: any[][]): Promise<QueryResult<never>> {
+    // We need to override this because we don't support executeBatch in connection contexts / transactions, only when
+    // called directly on the adapter.
+    return this.writeLock((conn) => conn.executeNativeBatch(query, params));
+  }
+}
+
+interface NativePowerSyncHelper {
+  resolveDefaultDatabaseLocation(dbName: string): string | null;
+}

package/src/db/adapters/op-sqlite/OPSqliteDBOpenFactory.ts

@@ -0,0 +1,25 @@
+import { DBAdapter, SQLOpenFactory, SQLOpenOptions } from '@powersync/common';
+import { OPSQLiteDBAdapter } from './OPSqliteAdapter';
+import { DEFAULT_SQLITE_OPTIONS, SqliteOptions } from './SqliteOptions';
+
+export interface OPSQLiteOpenFactoryOptions extends SQLOpenOptions {
+  sqliteOptions?: SqliteOptions;
+}
+export class OPSqliteOpenFactory implements SQLOpenFactory {
+  private sqliteOptions: Required<SqliteOptions>;
+
+  constructor(protected options: OPSQLiteOpenFactoryOptions) {
+    this.sqliteOptions = {
+      ...DEFAULT_SQLITE_OPTIONS,
+      ...this.options.sqliteOptions
+    };
+  }
+
+  openDB(): DBAdapter {
+    return new OPSQLiteDBAdapter({
+      name: this.options.dbFilename,
+      dbLocation: this.options.dbLocation,
+      sqliteOptions: this.sqliteOptions
+    });
+  }
+}