@powersync/web 1.15.1 → 1.17.0

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.15.1",
+    "version": "1.17.0",
     "description": "PowerSync web SDK. Sync Postgres, MongoDB or MySQL with SQLite in your web app",
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
@@ -61,7 +61,7 @@
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "^1.2.2",
-        "@powersync/common": "workspace:^1.25.0"
+        "@powersync/common": "workspace:^1.26.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",

package/lib/src/db/adapters/AsyncDatabaseConnection.d.ts

@@ -19,6 +19,7 @@ export interface AsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOption
     init(): Promise<void>;
     close(): Promise<void>;
     execute(sql: string, params?: any[]): Promise<ProxiedQueryResult>;
+    executeRaw(sql: string, params?: any[]): Promise<any[][]>;
     executeBatch(sql: string, params?: any[]): Promise<ProxiedQueryResult>;
     registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
     getConfig(): Promise<Config>;

package/lib/src/db/adapters/LockedAsyncDatabaseAdapter.d.ts

@@ -51,6 +51,7 @@ export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsync
      */
     refreshSchema(): Promise<void>;
     execute(query: string, params?: any[] | undefined): Promise<QueryResult>;
+    executeRaw(query: string, params?: any[] | undefined): Promise<any[][]>;
     executeBatch(query: string, params?: any[][]): Promise<QueryResult>;
     /**
      * Attempts to close the connection.
@@ -75,6 +76,10 @@ export declare class LockedAsyncDatabaseAdapter extends BaseObserver<LockedAsync
      * Wraps the worker execute function, awaiting for it to be available
      */
     private _execute;
+    /**
+     * Wraps the worker executeRaw function, awaiting for it to be available
+     */
+    private _executeRaw;
     /**
      * Wraps the worker executeBatch function, awaiting for it to be available
      */

package/lib/src/db/adapters/LockedAsyncDatabaseAdapter.js

@@ -40,7 +40,8 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
             };
         }
         this.dbGetHelpers = this.generateDBHelpers({
-            execute: (query, params) => this.acquireLock(() => this._execute(query, params))
+            execute: (query, params) => this.acquireLock(() => this._execute(query, params)),
+            executeRaw: (query, params) => this.acquireLock(() => this._executeRaw(query, params))
         });
         this.initPromise = this._init();
     }
@@ -98,6 +99,9 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     async execute(query, params) {
         return this.writeLock((ctx) => ctx.execute(query, params));
     }
+    async executeRaw(query, params) {
+        return this.writeLock((ctx) => ctx.executeRaw(query, params));
+    }
     async executeBatch(query, params) {
         return this.writeLock((ctx) => this._executeBatch(query, params));
     }
@@ -124,11 +128,11 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
     }
     async readLock(fn, options) {
         await this.waitForInitialized();
-        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute })));
+        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })));
     }
     async writeLock(fn, options) {
         await this.waitForInitialized();
-        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute })));
+        return this.acquireLock(async () => fn(this.generateDBHelpers({ execute: this._execute, executeRaw: this._executeRaw })));
     }
     acquireLock(callback) {
         return getNavigatorLocks().request(`db-lock-${this._dbIdentifier}`, callback);
@@ -225,6 +229,13 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
             }
         };
     };
+    /**
+     * Wraps the worker executeRaw function, awaiting for it to be available
+     */
+    _executeRaw = async (sql, bindings) => {
+        await this.waitForInitialized();
+        return await this.baseDB.executeRaw(sql, bindings);
+    };
     /**
      * Wraps the worker executeBatch function, awaiting for it to be available
      */

package/lib/src/db/adapters/SSRDBAdapter.d.ts

@@ -16,6 +16,7 @@ export declare class SSRDBAdapter extends BaseObserver<DBAdapterListener> implem
     writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions): Promise<T>;
     writeTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions): Promise<T>;
     execute(query: string, params?: any[]): Promise<QueryResult>;
+    executeRaw(query: string, params?: any[]): Promise<any[][]>;
     executeBatch(query: string, params?: any[][]): Promise<QueryResult>;
     getAll<T>(sql: string, parameters?: any[]): Promise<T[]>;
     getOptional<T>(sql: string, parameters?: any[] | undefined): Promise<T | null>;

package/lib/src/db/adapters/SSRDBAdapter.js

@@ -34,6 +34,9 @@ export class SSRDBAdapter extends BaseObserver {
     async execute(query, params) {
         return this.writeMutex.runExclusive(async () => MOCK_QUERY_RESPONSE);
     }
+    async executeRaw(query, params) {
+        return this.writeMutex.runExclusive(async () => []);
+    }
     async executeBatch(query, params) {
         return this.writeMutex.runExclusive(async () => MOCK_QUERY_RESPONSE);
     }

package/lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.d.ts

@@ -35,6 +35,7 @@ export declare class WorkerWrappedAsyncDatabaseConnection<Config extends Resolve
     registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
     close(): Promise<void>;
     execute(sql: string, params?: any[]): Promise<ProxiedQueryResult>;
+    executeRaw(sql: string, params?: any[]): Promise<any[][]>;
     executeBatch(sql: string, params?: any[]): Promise<ProxiedQueryResult>;
     getConfig(): Promise<ResolvedWebSQLOpenOptions>;
 }

package/lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.js

@@ -29,7 +29,7 @@ export class WorkerWrappedAsyncDatabaseConnection {
          * The `shareConnection` method should not be called on multiple tabs concurrently.
          */
         await new Promise((resolve, reject) => navigator.locks
-            .request(`shared-connection-${this.options.identifier}`, {
+            .request(`shared-connection-${this.options.identifier}-${Date.now()}-${Math.round(Math.random() * 10000)}`, {
             signal: this.lockAbortController.signal
         }, async () => {
             resolve();
@@ -73,6 +73,9 @@ export class WorkerWrappedAsyncDatabaseConnection {
     execute(sql, params) {
         return this.baseConnection.execute(sql, params);
     }
+    executeRaw(sql, params) {
+        return this.baseConnection.executeRaw(sql, params);
+    }
     executeBatch(sql, params) {
         return this.baseConnection.executeBatch(sql, params);
     }

package/lib/src/db/adapters/wa-sqlite/WASQLiteConnection.d.ts

@@ -113,6 +113,7 @@ export declare class WASqliteConnection extends BaseObserver<WASQLiteConnectionL
      * This executes single SQL statements inside a requested lock.
      */
     execute(sql: string | TemplateStringsArray, bindings?: any[]): Promise<ProxiedQueryResult>;
+    executeRaw(sql: string | TemplateStringsArray, bindings?: any[]): Promise<any[][]>;
     close(): Promise<void>;
     registerOnTableChange(callback: OnTableChangeCallback): Promise<() => void>;
     /**
@@ -124,4 +125,9 @@ export declare class WASqliteConnection extends BaseObserver<WASQLiteConnectionL
      * This executes a single statement using SQLite3.
      */
     protected executeSingleStatement(sql: string | TemplateStringsArray, bindings?: any[]): Promise<ProxiedQueryResult>;
+    /**
+     * This executes a single statement using SQLite3 and returns the results as an array of arrays.
+     */
+    protected executeSingleStatementRaw(sql: string | TemplateStringsArray, bindings?: any[]): Promise<any[][]>;
+    private _execute;
 }

package/lib/src/db/adapters/wa-sqlite/WASQLiteConnection.js

@@ -184,8 +184,8 @@ export class WASqliteConnection extends BaseObserver {
         await this.openDB();
         this.registerBroadcastListeners();
         await this.executeSingleStatement(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
-        await this.executeSingleStatement(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
         await this.executeEncryptionPragma();
+        await this.executeSingleStatement(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
         this.sqliteAPI.update_hook(this.dbP, (updateType, dbName, tableName) => {
             if (!tableName) {
                 return;
@@ -271,6 +271,11 @@ export class WASqliteConnection extends BaseObserver {
             return this.executeSingleStatement(sql, bindings);
         });
     }
+    async executeRaw(sql, bindings) {
+        return this.acquireExecuteLock(async () => {
+            return this.executeSingleStatementRaw(sql, bindings);
+        });
+    }
     async close() {
         this.broadcastChannel?.close();
         await this.sqliteAPI.close(this.dbP);
@@ -291,6 +296,35 @@ export class WASqliteConnection extends BaseObserver {
      * This executes a single statement using SQLite3.
      */
     async executeSingleStatement(sql, bindings) {
+        const results = await this._execute(sql, bindings);
+        const rows = [];
+        for (const resultSet of results) {
+            for (const row of resultSet.rows) {
+                const outRow = {};
+                resultSet.columns.forEach((key, index) => {
+                    outRow[key] = row[index];
+                });
+                rows.push(outRow);
+            }
+        }
+        const result = {
+            insertId: this.sqliteAPI.last_insert_id(this.dbP),
+            rowsAffected: this.sqliteAPI.changes(this.dbP),
+            rows: {
+                _array: rows,
+                length: rows.length
+            }
+        };
+        return result;
+    }
+    /**
+     * This executes a single statement using SQLite3 and returns the results as an array of arrays.
+     */
+    async executeSingleStatementRaw(sql, bindings) {
+        const results = await this._execute(sql, bindings);
+        return results.flatMap((resultset) => resultset.rows.map((row) => resultset.columns.map((_, index) => row[index])));
+    }
+    async _execute(sql, bindings) {
         const results = [];
         for await (const stmt of this.sqliteAPI.statements(this.dbP, sql)) {
             let columns;
@@ -321,24 +355,6 @@ export class WASqliteConnection extends BaseObserver {
                 break;
             }
         }
-        const rows = [];
-        for (const resultSet of results) {
-            for (const row of resultSet.rows) {
-                const outRow = {};
-                resultSet.columns.forEach((key, index) => {
-                    outRow[key] = row[index];
-                });
-                rows.push(outRow);
-            }
-        }
-        const result = {
-            insertId: this.sqliteAPI.last_insert_id(this.dbP),
-            rowsAffected: this.sqliteAPI.changes(this.dbP),
-            rows: {
-                _array: rows,
-                length: rows.length
-            }
-        };
-        return result;
+        return results;
     }
 }

package/lib/src/worker/db/WASQLiteDB.worker.js

@@ -15,6 +15,7 @@ const openWorkerConnection = async (options) => {
         getConfig: Comlink.proxy(() => connection.getConfig()),
         close: Comlink.proxy(() => connection.close()),
         execute: Comlink.proxy(async (sql, params) => connection.execute(sql, params)),
+        executeRaw: Comlink.proxy(async (sql, params) => connection.executeRaw(sql, params)),
         executeBatch: Comlink.proxy(async (sql, params) => connection.executeBatch(sql, params)),
         registerOnTableChange: Comlink.proxy(async (callback) => {
             // Proxy the callback remove function