@powersync/op-sqlite 0.0.0-dev-20241014170110 → 0.0.0-dev-20250121082529

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powersync/op-sqlite",
-  "version": "0.0.0-dev-20241014170110",
-  "description": "Powersync",
+  "version": "0.0.0-dev-20250121082529",
+  "description": "PowerSync - sync Postgres or MongoDB with SQLite in your React Native app for offline-first and real-time data",
   "source": "./src/index.ts",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -58,17 +58,17 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@op-engineering/op-sqlite": "^9.1.3",
-    "@powersync/common": "^1.20.0",
+    "@op-engineering/op-sqlite": "^11.2.13",
+    "@powersync/common": "^1.22.2",
     "react": "*",
     "react-native": "*"
   },
   "dependencies": {
     "async-lock": "^1.4.0",
-    "@powersync/common": "1.20.0"
+    "@powersync/common": "1.22.2"
   },
   "devDependencies": {
-    "@op-engineering/op-sqlite": "^9.1.3",
+    "@op-engineering/op-sqlite": "^11.2.13",
     "@react-native/eslint-config": "^0.73.1",
     "@types/async-lock": "^1.4.0",
     "@types/react": "^18.2.44",
@@ -131,6 +131,6 @@
     "build:prod": "bob build",
     "typecheck": "tsc",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
-    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib"
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib node_modules"
   }
 }

package/powersync-op-sqlite.podspec

@@ -11,13 +11,13 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   s.platforms    = { :ios => min_ios_version_supported }
-  s.source       = { :git => "https://github.com/mugikhan/powersync-op-sqlite.git", :tag => "#{s.version}" }
+  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.3.0"
+  s.dependency "powersync-sqlite-core", "~> 0.3.8"
   if defined?(install_modules_dependencies())
     install_modules_dependencies(s)
   else

package/src/db/OPSQLiteConnection.ts

@@ -1,40 +1,85 @@
-import { DB, SQLBatchTuple } from '@op-engineering/op-sqlite';
-import { BaseObserver, DBAdapterListener, QueryResult, RowUpdateType } from '@powersync/common';
+import { DB, SQLBatchTuple, UpdateHookOperation } from '@op-engineering/op-sqlite';
+import {
+  BaseObserver,
+  BatchedUpdateNotification,
+  DBAdapterListener,
+  QueryResult,
+  RowUpdateType,
+  UpdateNotification
+} from '@powersync/common';
 
 export type OPSQLiteConnectionOptions = {
   baseDB: DB;
 };
 
+export type OPSQLiteUpdateNotification = {
+  table: string;
+  operation: UpdateHookOperation;
+  row?: any;
+  rowId: number;
+};
+
 export class OPSQLiteConnection extends BaseObserver<DBAdapterListener> {
   protected DB: DB;
+  private updateBuffer: UpdateNotification[];
+
   constructor(protected options: OPSQLiteConnectionOptions) {
     super();
     this.DB = options.baseDB;
+    this.updateBuffer = [];
+
+    this.DB.rollbackHook(() => {
+      this.updateBuffer = [];
+    });
 
-    // link table update commands
     this.DB.updateHook((update) => {
-      this.iterateListeners((cb) => {
-        let opType: RowUpdateType;
-        switch (update.operation) {
-          case 'INSERT':
-            opType = RowUpdateType.SQLITE_INSERT;
-            break;
-          case 'DELETE':
-            opType = RowUpdateType.SQLITE_DELETE;
-            break;
-          case 'UPDATE':
-            opType = RowUpdateType.SQLITE_UPDATE;
-            break;
-        }
-        cb.tablesUpdated?.({
-          table: update.table,
-          opType,
-          rowId: update.rowId
-        });
-      });
+      this.addTableUpdate(update);
+    });
+  }
+
+  addTableUpdate(update: OPSQLiteUpdateNotification) {
+    let opType: RowUpdateType;
+    switch (update.operation) {
+      case 'INSERT':
+        opType = RowUpdateType.SQLITE_INSERT;
+        break;
+      case 'DELETE':
+        opType = RowUpdateType.SQLITE_DELETE;
+        break;
+      case 'UPDATE':
+        opType = RowUpdateType.SQLITE_UPDATE;
+        break;
+    }
+
+    this.updateBuffer.push({
+      table: update.table,
+      opType,
+      rowId: update.rowId
     });
   }
 
+  flushUpdates() {
+    if (!this.updateBuffer.length) {
+      return;
+    }
+
+    const groupedUpdates = this.updateBuffer.reduce((grouping: Record<string, UpdateNotification[]>, update) => {
+      const { table } = update;
+      const updateGroup = grouping[table] || (grouping[table] = []);
+      updateGroup.push(update);
+      return grouping;
+    }, {});
+
+    const batchedUpdate: BatchedUpdateNotification = {
+      groupedUpdates,
+      rawUpdates: this.updateBuffer,
+      tables: Object.keys(groupedUpdates)
+    };
+
+    this.updateBuffer = [];
+    this.iterateListeners((l) => l.tablesUpdated?.(batchedUpdate));
+  }
+
   close() {
     return this.DB.close();
   }
@@ -64,12 +109,12 @@ export class OPSQLiteConnection extends BaseObserver<DBAdapterListener> {
 
   async getAll<T>(sql: string, parameters?: any[]): Promise<T[]> {
     const result = await this.DB.execute(sql, parameters);
-    return result.rows ?? [];
+    return (result.rows ?? []) as T[];
   }
 
   async getOptional<T>(sql: string, parameters?: any[]): Promise<T | null> {
     const result = await this.DB.execute(sql, parameters);
-    return result.rows?.[0] ?? null;
+    return (result.rows?.[0] as T) ?? null;
   }
 
   async get<T>(sql: string, parameters?: any[]): Promise<T> {
@@ -79,4 +124,8 @@ export class OPSQLiteConnection extends BaseObserver<DBAdapterListener> {
     }
     return result as T;
   }
+
+  async refreshSchema() {
+    await this.get("PRAGMA table_info('sqlite_master')");
+  }
 }

package/src/db/OPSqliteAdapter.ts

@@ -4,14 +4,19 @@ import {
   DBAdapterListener,
   DBLockOptions,
   QueryResult,
-  SQLOpenOptions,
   Transaction
 } from '@powersync/common';
-import { ANDROID_DATABASE_PATH, IOS_LIBRARY_PATH, open, type DB } from '@op-engineering/op-sqlite';
+import {
+  ANDROID_DATABASE_PATH,
+  getDylibPath,
+  IOS_LIBRARY_PATH,
+  open,
+  type DB
+} from '@op-engineering/op-sqlite';
 import Lock from 'async-lock';
 import { OPSQLiteConnection } from './OPSQLiteConnection';
-import { NativeModules, Platform } from 'react-native';
-import { DEFAULT_SQLITE_OPTIONS, SqliteOptions } from './SqliteOptions';
+import { Platform } from 'react-native';
+import { SqliteOptions } from './SqliteOptions';
 
 /**
  * Adapter for React Native Quick SQLite
@@ -35,10 +40,12 @@ export class OPSQLiteDBAdapter extends BaseObserver<DBAdapterListener> implement
 
   protected initialized: Promise<void>;
 
-  protected readConnections: OPSQLiteConnection[] | null;
+  protected readConnections: Array<{ busy: boolean; connection: OPSQLiteConnection }> | null;
 
   protected writeConnection: OPSQLiteConnection | null;
 
+  private readQueue: Array<() => void> = [];
+
   constructor(protected options: OPSQLiteAdapterOptions) {
     super();
     this.name = this.options.name;
@@ -50,15 +57,10 @@ export class OPSQLiteDBAdapter extends BaseObserver<DBAdapterListener> implement
   }
 
   protected async init() {
-    const { lockTimeoutMs, journalMode, journalSizeLimit, synchronous } = this.options.sqliteOptions;
-    // const { dbFilename, dbLocation } = this.options;
+    const { lockTimeoutMs, journalMode, journalSizeLimit, synchronous, encryptionKey } = this.options.sqliteOptions;
     const dbFilename = this.options.name;
-    //This is needed because an undefined dbLocation will cause the open function to fail
-    const location = this.getDbLocation(this.options.dbLocation);
-    const DB: DB = open({
-      name: dbFilename,
-      location: location
-    });
+
+    this.writeConnection = await this.openConnection(dbFilename);
 
     const statements: string[] = [
       `PRAGMA busy_timeout = ${lockTimeoutMs}`,
@@ -70,7 +72,7 @@ export class OPSQLiteDBAdapter extends BaseObserver<DBAdapterListener> implement
     for (const statement of statements) {
       for (let tries = 0; tries < 30; tries++) {
         try {
-          await DB.execute(statement);
+          await this.writeConnection!.execute(statement);
           break;
         } catch (e: any) {
           if (e instanceof Error && e.message.includes('database is locked') && tries < 29) {
@@ -82,37 +84,26 @@ export class OPSQLiteDBAdapter extends BaseObserver<DBAdapterListener> implement
       }
     }
 
-    this.loadExtension(DB);
-
-    await DB.execute('SELECT powersync_init()');
+    // Changes should only occur in the write connection
+    this.writeConnection!.registerListener({
+      tablesUpdated: (notification) => this.iterateListeners((cb) => cb.tablesUpdated?.(notification))
+    });
 
     this.readConnections = [];
     for (let i = 0; i < READ_CONNECTIONS; i++) {
-      // Workaround to create read-only connections
-      let dbName = './'.repeat(i + 1) + dbFilename;
-      const conn = await this.openConnection(location, dbName);
+      const conn = await this.openConnection(dbFilename);
       await conn.execute('PRAGMA query_only = true');
-      this.readConnections.push(conn);
+      this.readConnections.push({ busy: false, connection: conn });
     }
-
-    this.writeConnection = new OPSQLiteConnection({
-      baseDB: DB
-    });
-
-    // Changes should only occur in the write connection
-    this.writeConnection!.registerListener({
-      tablesUpdated: (notification) => this.iterateListeners((cb) => cb.tablesUpdated?.(notification))
-    });
   }
 
-  protected async openConnection(dbLocation: string, filenameOverride?: string): Promise<OPSQLiteConnection> {
-    const DB: DB = open({
-      name: filenameOverride ?? this.options.name,
-      location: dbLocation
-    });
+  protected async openConnection(filenameOverride?: string): Promise<OPSQLiteConnection> {
+    const dbFilename = filenameOverride ?? this.options.name;
+    const DB: DB = this.openDatabase(dbFilename, this.options.sqliteOptions.encryptionKey);
 
-    //Load extension for all connections
-    this.loadExtension(DB);
+    //Load extensions for all connections
+    this.loadAdditionalExtensions(DB);
+    this.loadPowerSyncExtension(DB);
 
     await DB.execute('SELECT powersync_init()');
 
@@ -129,10 +120,35 @@ export class OPSQLiteDBAdapter extends BaseObserver<DBAdapterListener> implement
     }
   }
 
-  private loadExtension(DB: DB) {
+  private openDatabase(dbFilename: string, encryptionKey?: string): DB {
+    //This is needed because an undefined/null dbLocation will cause the open function to fail
+    const location = this.getDbLocation(this.options.dbLocation);
+    //Simarlily if the encryption key is undefined/null when using SQLCipher it will cause the open function to fail
+    if (encryptionKey) {
+      return open({
+        name: dbFilename,
+        location: location,
+        encryptionKey: encryptionKey
+      });
+    } else {
+      return open({
+        name: dbFilename,
+        location: location
+      });
+    }
+  }
+
+  private loadAdditionalExtensions(DB: DB) {
+    if (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 bundlePath: string = NativeModules.PowerSyncOpSqlite.getBundlePath();
-      const libPath = `${bundlePath}/Frameworks/powersync-sqlite-core.framework/powersync-sqlite-core`;
+      const libPath = getDylibPath('co.powersync.sqlitecore', 'powersync-sqlite-core');
       DB.loadExtension(libPath, 'sqlite3_powersync_init');
     } else {
       DB.loadExtension('libpowersync', 'sqlite3_powersync_init');
@@ -142,36 +158,46 @@ export class OPSQLiteDBAdapter extends BaseObserver<DBAdapterListener> implement
   close() {
     this.initialized.then(() => {
       this.writeConnection!.close();
-      this.readConnections!.forEach((c) => c.close());
+      this.readConnections!.forEach((c) => c.connection.close());
     });
   }
 
   async readLock<T>(fn: (tx: OPSQLiteConnection) => Promise<T>, options?: DBLockOptions): Promise<T> {
     await this.initialized;
-    // TODO: Use async queues to handle multiple read connections
-    const sortedConnections = this.readConnections!.map((connection, index) => ({
-      lockKey: `${LockType.READ}-${index}`,
-      connection
-    })).sort((a, b) => {
-      const aBusy = this.locks.isBusy(a.lockKey);
-      const bBusy = this.locks.isBusy(b.lockKey);
-      // Sort by ones which are not busy
-      return aBusy > bBusy ? 1 : 0;
+    return new Promise(async (resolve, reject) => {
+      const execute = async () => {
+        // Find an available connection that is not busy
+        const availableConnection = this.readConnections!.find((conn) => !conn.busy);
+
+        // If we have an available connection, use it
+        if (availableConnection) {
+          availableConnection.busy = true;
+          try {
+            resolve(await fn(availableConnection.connection));
+          } catch (error) {
+            reject(error);
+          } finally {
+            availableConnection.busy = false;
+            // After query execution, process any queued tasks
+            this.processQueue();
+          }
+        } else {
+          // If no available connections, add to the queue
+          this.readQueue.push(execute);
+        }
+      };
+
+      execute();
     });
+  }
 
-    return new Promise(async (resolve, reject) => {
-      try {
-        await this.locks.acquire(
-          sortedConnections[0].lockKey,
-          async () => {
-            resolve(await fn(sortedConnections[0].connection));
-          },
-          { timeout: options?.timeoutMs }
-        );
-      } catch (ex) {
-        reject(ex);
+  private async processQueue(): Promise<void> {
+    if (this.readQueue.length > 0) {
+      const next = this.readQueue.shift();
+      if (next) {
+        next();
       }
-    });
+    }
   }
 
   async writeLock<T>(fn: (tx: OPSQLiteConnection) => Promise<T>, options?: DBLockOptions): Promise<T> {
@@ -179,13 +205,18 @@ export class OPSQLiteDBAdapter extends BaseObserver<DBAdapterListener> implement
 
     return new Promise(async (resolve, reject) => {
       try {
-        await this.locks.acquire(
-          LockType.WRITE,
-          async () => {
-            resolve(await fn(this.writeConnection!));
-          },
-          { timeout: options?.timeoutMs }
-        );
+        await this.locks
+          .acquire(
+            LockType.WRITE,
+            async () => {
+              resolve(await fn(this.writeConnection!));
+            },
+            { timeout: options?.timeoutMs }
+          )
+          .then(() => {
+            // flush updates once a write lock has been released
+            this.writeConnection!.flushUpdates();
+          });
       } catch (ex) {
         reject(ex);
       }
@@ -256,4 +287,13 @@ export class OPSQLiteDBAdapter extends BaseObserver<DBAdapterListener> implement
       throw ex;
     }
   }
+
+  async refreshSchema(): Promise<void> {
+    await this.initialized;
+    await this.writeConnection!.refreshSchema();
+
+    for (let readConnection of this.readConnections) {
+      await readConnection.connection.refreshSchema();
+    }
+  }
 }

package/src/db/SqliteOptions.ts

@@ -23,6 +23,21 @@ export interface SqliteOptions {
    * Set to null or zero to fail immediately when the database is locked.
    */
   lockTimeoutMs?: number;
+
+  /**
+   * Encryption key for the database.
+   * If set, the database will be encrypted using SQLCipher.
+   */
+  encryptionKey?: string;
+
+  /**
+   * Load extensions using the path and entryPoint.
+   * More info can be found here https://op-engineering.github.io/op-sqlite/docs/api#loading-extensions.
+   */
+  extensions?: Array<{
+    path: string;
+    entryPoint?: string;
+  }>;
 }
 
 // SQLite journal mode. Set on the primary connection.
@@ -36,14 +51,14 @@ enum SqliteJournalMode {
   truncate = 'TRUNCATE',
   persist = 'PERSIST',
   memory = 'MEMORY',
-  off = 'OFF',
+  off = 'OFF'
 }
 
 // SQLite file commit mode.
 enum SqliteSynchronous {
   normal = 'NORMAL',
   full = 'FULL',
-  off = 'OFF',
+  off = 'OFF'
 }
 
 export const DEFAULT_SQLITE_OPTIONS: Required<SqliteOptions> = {
@@ -51,4 +66,6 @@ export const DEFAULT_SQLITE_OPTIONS: Required<SqliteOptions> = {
   synchronous: SqliteSynchronous.normal,
   journalSizeLimit: 6 * 1024 * 1024,
   lockTimeoutMs: 30000,
+  encryptionKey: null,
+  extensions: []
 };

package/src/index.ts

@@ -1,30 +1,4 @@
-import { NativeModules, Platform } from 'react-native';
-
-const LINKING_ERROR =
-  `The package '@powersync/op-sqlite' doesn't seem to be linked. Make sure: \n\n` +
-  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
-  '- You rebuilt the app after installing the package\n' +
-  '- You are not using Expo Go\n';
-
-const isTurboModuleEnabled = global.__turboModuleProxy != null;
-
-const PowerSyncOpSqliteModule = isTurboModuleEnabled
-  ? require('./NativePowerSyncOpSqlite').default
-  : NativeModules.PowerSyncOpSqlite;
-
-const PowerSyncOpSqlite = PowerSyncOpSqliteModule
-  ? PowerSyncOpSqliteModule
-  : new Proxy(
-      {},
-      {
-        get() {
-          throw new Error(LINKING_ERROR);
-        }
-      }
-    );
-
-export function getBundlePath(): string {
-  return PowerSyncOpSqlite.getBundlePath();
-}
-
-export { OPSqliteOpenFactory, OPSQLiteOpenFactoryOptions } from './db/OPSqliteDBOpenFactory';
+export {
+  OPSqliteOpenFactory,
+  OPSQLiteOpenFactoryOptions
+} from './db/OPSqliteDBOpenFactory';

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

@@ -1,25 +0,0 @@
-package com.powersync.opsqlite
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
-
-class PowerSyncOpSqliteModule internal constructor(context: ReactApplicationContext) :
-  PowerSyncOpSqliteSpec(context) {
-
-  @ReactMethod
-  override fun getBundlePath(): String {
-    //This method should only be used for iOS platforms
-    //Ensure you wrap its usage with a (Platform.OS === 'ios') check
-    //Returns an empty string for android
-    return ""
-  }
-
-  override fun getName(): String {
-    return NAME
-  }
-
-  companion object {
-    const val NAME = "PowerSyncOpSqlite"
-  }
-}

package/android/src/newarch/PowerSyncOpSqliteSpec.kt

@@ -1,7 +0,0 @@
-package com.powersync.opsqlite
-
-import com.facebook.react.bridge.ReactApplicationContext
-
-abstract class PowerSyncOpSqliteSpec internal constructor(context: ReactApplicationContext) :
-  NativePowerSyncOpSqliteSpec(context) {
-}

package/android/src/oldarch/PowerSyncOpSqliteSpec.kt

@@ -1,11 +0,0 @@
-package com.powersync.opsqlite
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.Promise
-
-abstract class PowerSyncOpSqliteSpec internal constructor(context: ReactApplicationContext) :
-  ReactContextBaseJavaModule(context) {
-
-    abstract fun getBundlePath(): String
-  }

package/lib/commonjs/NativePowerSyncOpSqlite.js

@@ -1,9 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _reactNative = require("react-native");
-var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('PowerSyncOpSqlite');
-//# sourceMappingURL=NativePowerSyncOpSqlite.js.map

package/lib/commonjs/NativePowerSyncOpSqlite.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativePowerSyncOpSqlite.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAMpCC,gCAAmB,CAACC,YAAY,CAAO,mBAAmB,CAAC","ignoreList":[]}

package/lib/module/NativePowerSyncOpSqlite.js

@@ -1,5 +0,0 @@
-"use strict";
-
-import { TurboModuleRegistry } from 'react-native';
-export default TurboModuleRegistry.getEnforcing('PowerSyncOpSqlite');
-//# sourceMappingURL=NativePowerSyncOpSqlite.js.map

package/lib/module/NativePowerSyncOpSqlite.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativePowerSyncOpSqlite.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;AAMlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,mBAAmB,CAAC","ignoreList":[]}

package/lib/typescript/commonjs/src/NativePowerSyncOpSqlite.d.ts

@@ -1,7 +0,0 @@
-import type { TurboModule } from 'react-native';
-export interface Spec extends TurboModule {
-    getBundlePath(): string;
-}
-declare const _default: Spec;
-export default _default;
-//# sourceMappingURL=NativePowerSyncOpSqlite.d.ts.map

package/lib/typescript/commonjs/src/NativePowerSyncOpSqlite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NativePowerSyncOpSqlite.d.ts","sourceRoot":"","sources":["../../../../src/NativePowerSyncOpSqlite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,aAAa,IAAI,MAAM,CAAC;CACzB;;AAED,wBAA2E"}

package/lib/typescript/module/src/NativePowerSyncOpSqlite.d.ts

@@ -1,7 +0,0 @@
-import type { TurboModule } from 'react-native';
-export interface Spec extends TurboModule {
-    getBundlePath(): string;
-}
-declare const _default: Spec;
-export default _default;
-//# sourceMappingURL=NativePowerSyncOpSqlite.d.ts.map

package/lib/typescript/module/src/NativePowerSyncOpSqlite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NativePowerSyncOpSqlite.d.ts","sourceRoot":"","sources":["../../../../src/NativePowerSyncOpSqlite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,aAAa,IAAI,MAAM,CAAC;CACzB;;AAED,wBAA2E"}

package/src/NativePowerSyncOpSqlite.ts

@@ -1,8 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-
-export interface Spec extends TurboModule {
-  getBundlePath(): string;
-}
-
-export default TurboModuleRegistry.getEnforcing<Spec>('PowerSyncOpSqlite');