@powersync/web 0.0.0-dev-20250207081035 → 0.0.0-dev-20250210155038

package/lib/package.json

@@ -74,20 +74,16 @@
     "devDependencies": {
         "@journeyapps/wa-sqlite": "^1.2.0",
         "@types/uuid": "^9.0.6",
-        "@vitest/browser": "^2.1.4",
         "crypto-browserify": "^3.12.0",
         "p-defer": "^4.0.1",
         "source-map-loader": "^5.0.0",
         "stream-browserify": "^3.0.0",
         "terser-webpack-plugin": "^5.3.9",
-        "typescript": "^5.5.3",
         "uuid": "^9.0.1",
-        "vite": "^5.4.10",
-        "vite-plugin-top-level-await": "^1.4.1",
+        "vite": "^6.1.0",
+        "vite-plugin-top-level-await": "^1.4.4",
         "vite-plugin-wasm": "^3.3.0",
-        "vitest": "^2.1.4",
         "vm-browserify": "^1.1.2",
-        "webdriverio": "^8.40.6",
         "webpack": "^5.90.1",
         "webpack-cli": "^5.1.4",
         "webpack-node-externals": "^3.0.0"

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

@@ -20,6 +20,8 @@ export type WrappedWorkerConnectionOptions<Config extends ResolvedWebSQLOpenOpti
  */
 export declare class WorkerWrappedAsyncDatabaseConnection<Config extends ResolvedWebSQLOpenOptions = ResolvedWebSQLOpenOptions> implements AsyncDatabaseConnection {
     protected options: WrappedWorkerConnectionOptions<Config>;
+    protected releaseSharedConnectionLock: (() => void) | null;
+    protected lockAbortController: AbortController;
     constructor(options: WrappedWorkerConnectionOptions<Config>);
     protected get baseConnection(): AsyncDatabaseConnection<ResolvedWebSQLOpenOptions>;
     init(): Promise<void>;

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

@@ -5,8 +5,12 @@ import * as Comlink from 'comlink';
  */
 export class WorkerWrappedAsyncDatabaseConnection {
     options;
+    releaseSharedConnectionLock;
+    lockAbortController;
     constructor(options) {
         this.options = options;
+        this.releaseSharedConnectionLock = null;
+        this.lockAbortController = new AbortController();
     }
     get baseConnection() {
         return this.options.baseConnection;
@@ -19,6 +23,30 @@ export class WorkerWrappedAsyncDatabaseConnection {
      */
     async shareConnection() {
         const { identifier, remote } = this.options;
+        /**
+         * Hold a navigator lock in order to avoid features such as Chrome's frozen tabs,
+         * or Edge's sleeping tabs from pausing the thread for this connection.
+         * This promise resolves once a lock is obtained.
+         * This lock will be held as long as this connection is open.
+         * The `shareConnection` method should not be called on multiple tabs concurrently.
+         */
+        await new Promise((lockObtained) => navigator.locks
+            .request(`shared-connection-${this.options.identifier}`, {
+            signal: this.lockAbortController.signal
+        }, async () => {
+            lockObtained();
+            // Free the lock when the connection is already closed.
+            if (this.lockAbortController.signal.aborted) {
+                return;
+            }
+            // Hold the lock while the shared connection is in use.
+            await new Promise((releaseLock) => {
+                // We can use the resolver to free the lock
+                this.releaseSharedConnectionLock = releaseLock;
+            });
+        })
+            // We aren't concerned with errors here
+            .catch(() => { }));
         const newPort = await remote[Comlink.createEndpoint]();
         return { port: newPort, identifier };
     }
@@ -30,6 +58,9 @@ export class WorkerWrappedAsyncDatabaseConnection {
         return this.baseConnection.registerOnTableChange(Comlink.proxy(callback));
     }
     async close() {
+        // Abort any pending lock requests.
+        this.lockAbortController.abort();
+        this.releaseSharedConnectionLock?.();
         await this.baseConnection.close();
         this.options.remote[Comlink.releaseProxy]();
         this.options.onClose?.();

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

@@ -184,6 +184,7 @@ 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();
         this.sqliteAPI.update_hook(this.dbP, (updateType, dbName, tableName) => {
             if (!tableName) {

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

@@ -17,6 +17,7 @@ export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptio
     worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
     vfs?: WASQLiteVFS;
     temporaryStorage?: TemporaryStorageOption;
+    cacheSizeKb?: number;
     /**
      * Encryption key for the database.
      * If set, the database will be encrypted using multiple-ciphers.

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

@@ -1,7 +1,7 @@
 import * as Comlink from 'comlink';
 import { resolveWebPowerSyncFlags } from '../../PowerSyncDatabase';
 import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { TemporaryStorageOption } from '../web-sql-flags';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags';
 import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
 import { WASQLiteOpenFactory } from './WASQLiteOpenFactory';
 /**
@@ -12,7 +12,7 @@ export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
         super({
             name: options.dbFilename,
             openConnection: async () => {
-                const { workerPort, temporaryStorage } = options;
+                const { workerPort, temporaryStorage, cacheSizeKb } = options;
                 if (workerPort) {
                     const remote = Comlink.wrap(workerPort);
                     return new WorkerWrappedAsyncDatabaseConnection({
@@ -21,6 +21,7 @@ export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
                         baseConnection: await remote({
                             ...options,
                             temporaryStorage: temporaryStorage ?? TemporaryStorageOption.MEMORY,
+                            cacheSizeKb: cacheSizeKb ?? DEFAULT_CACHE_SIZE_KB,
                             flags: resolveWebPowerSyncFlags(options.flags),
                             encryptionKey: options.encryptionKey
                         })
@@ -32,6 +33,7 @@ export class WASQLiteDBAdapter extends LockedAsyncDatabaseAdapter {
                     debugMode: options.debugMode,
                     flags: options.flags,
                     temporaryStorage,
+                    cacheSizeKb,
                     logger: options.logger,
                     vfs: options.vfs,
                     encryptionKey: options.encryptionKey,

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

@@ -2,7 +2,7 @@ import * as Comlink from 'comlink';
 import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
 import { LockedAsyncDatabaseAdapter } from '../LockedAsyncDatabaseAdapter';
-import { TemporaryStorageOption } from '../web-sql-flags';
+import { DEFAULT_CACHE_SIZE_KB, TemporaryStorageOption } from '../web-sql-flags';
 import { WorkerWrappedAsyncDatabaseConnection } from '../WorkerWrappedAsyncDatabaseConnection';
 import { WASqliteConnection, WASQLiteVFS } from './WASQLiteConnection';
 /**
@@ -27,7 +27,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
     }
     async openConnection() {
         const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
-        const { vfs = WASQLiteVFS.IDBBatchAtomicVFS, temporaryStorage = TemporaryStorageOption.MEMORY, encryptionKey } = this.waOptions;
+        const { vfs = WASQLiteVFS.IDBBatchAtomicVFS, temporaryStorage = TemporaryStorageOption.MEMORY, cacheSizeKb = DEFAULT_CACHE_SIZE_KB, encryptionKey } = this.waOptions;
         if (!enableMultiTabs) {
             this.logger.warn('Multiple tabs are not enabled in this browser');
         }
@@ -37,6 +37,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
                 ? resolveWorkerDatabasePortFactory(() => optionsDbWorker({
                     ...this.options,
                     temporaryStorage,
+                    cacheSizeKb,
                     flags: this.resolvedFlags,
                     encryptionKey
                 }))
@@ -48,6 +49,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
                     dbFilename: this.options.dbFilename,
                     vfs,
                     temporaryStorage,
+                    cacheSizeKb,
                     flags: this.resolvedFlags,
                     encryptionKey: encryptionKey
                 }),
@@ -70,6 +72,7 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
                 debugMode: this.options.debugMode,
                 vfs,
                 temporaryStorage,
+                cacheSizeKb,
                 flags: this.resolvedFlags,
                 encryptionKey: encryptionKey
             });

package/lib/src/db/adapters/web-sql-flags.d.ts

@@ -39,6 +39,7 @@ export interface ResolvedWebSQLOpenOptions extends SQLOpenOptions {
      * Setting this to `FILESYSTEM` can cause issues with larger queries or datasets.
      */
     temporaryStorage: TemporaryStorageOption;
+    cacheSizeKb: number;
     /**
      * Encryption key for the database.
      * If set, the database will be encrypted using ChaCha20.
@@ -49,6 +50,7 @@ export declare enum TemporaryStorageOption {
     MEMORY = "memory",
     FILESYSTEM = "file"
 }
+export declare const DEFAULT_CACHE_SIZE_KB: number;
 /**
  * Options for opening a Web SQL connection
  */
@@ -65,8 +67,16 @@ export interface WebSQLOpenFactoryOptions extends SQLOpenOptions {
     /**
      * Where to store SQLite temporary files. Defaults to 'MEMORY'.
      * Setting this to `FILESYSTEM` can cause issues with larger queries or datasets.
+     *
+     * For details, see: https://www.sqlite.org/pragma.html#pragma_temp_store
      */
     temporaryStorage?: TemporaryStorageOption;
+    /**
+     * Maximum SQLite cache size. Defaults to 50MB.
+     *
+     * For details, see: https://www.sqlite.org/pragma.html#pragma_cache_size
+     */
+    cacheSizeKb?: number;
     /**
      * Encryption key for the database.
      * If set, the database will be encrypted using ChaCha20.

package/lib/src/db/adapters/web-sql-flags.js

@@ -3,6 +3,7 @@ export var TemporaryStorageOption;
     TemporaryStorageOption["MEMORY"] = "memory";
     TemporaryStorageOption["FILESYSTEM"] = "file";
 })(TemporaryStorageOption || (TemporaryStorageOption = {}));
+export const DEFAULT_CACHE_SIZE_KB = 50 * 1024;
 export function isServerSide() {
     return typeof window == 'undefined';
 }

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.js

@@ -1,7 +1,7 @@
 import * as Comlink from 'comlink';
 import { AbstractSharedSyncClientProvider } from '../../worker/sync/AbstractSharedSyncClientProvider';
 import { SharedSyncClientEvent } from '../../worker/sync/SharedSyncImplementation';
-import { resolveWebSQLFlags, TemporaryStorageOption } from '../adapters/web-sql-flags';
+import { DEFAULT_CACHE_SIZE_KB, resolveWebSQLFlags, TemporaryStorageOption } from '../adapters/web-sql-flags';
 import { WebStreamingSyncImplementation } from './WebStreamingSyncImplementation';
 /**
  * The shared worker will trigger methods on this side of the message port
@@ -86,10 +86,10 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
          * This worker will manage all syncing operations remotely.
          */
         const resolvedWorkerOptions = {
-            ...options,
             dbFilename: this.options.identifier,
-            // TODO
             temporaryStorage: TemporaryStorageOption.MEMORY,
+            cacheSizeKb: DEFAULT_CACHE_SIZE_KB,
+            ...options,
             flags: resolveWebSQLFlags(options.flags)
         };
         const syncWorker = options.sync?.worker;