@powersync/web 0.0.0-dev-20260630141119 → 0.0.0-dev-20260708103617

package/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.ts

@@ -1,31 +1,70 @@
-import { DBAdapter, LogLevels, PowerSyncLogger, SQLOpenFactory } from '@powersync/common';
+import { createLogger, DBAdapter, ILogger, SQLOpenFactory, type ILogLevel } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { ResolvedWebSQLOpenOptions, WebSQLOpenOptions } from '../options.js';
+import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
+import {
+  DEFAULT_CACHE_SIZE_KB,
+  isServerSide,
+  ResolvedWebSQLFlags,
+  ResolvedWebSQLOpenOptions,
+  resolveWebSQLFlags,
+  TemporaryStorageOption,
+  WebSQLOpenFactoryOptions
+} from '../web-sql-flags.js';
 import { SSRDBAdapter } from '../SSRDBAdapter.js';
 import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from './vfs.js';
 import { MultiDatabaseServer } from '../../../worker/db/MultiDatabaseServer.js';
 import { DatabaseClient, OpenWorkerConnection } from './DatabaseClient.js';
 import { generateTabCloseSignal } from '../../../shared/tab_close_signal.js';
 import { AsyncDbAdapter, PoolConnection } from '../AsyncWebAdapter.js';
-import { RawWaSqliteDatabaseOptions } from './RawSqliteConnection.js';
-import { resolveAndValidateOptions } from '../resolveAndValidateOptions.js';
-import { connectToExistingWorker, connectToWorker, WorkerConnection } from '../../../worker/client.js';
 
-export interface WASQLiteOpenFactoryOptions {
-  open: WebSQLOpenOptions;
-  logger: PowerSyncLogger;
+export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
+  vfs?: WASQLiteVFS;
+  /**
+   * If the {@link vfs} supports it, an additional amount of read-only connections to open. Using additional read
+   * connections can speed up queries by dispatching them to multiple workers running them concurrently.
+   *
+   * {@link WASQLiteVFS.OPFSWriteAheadVFS} is the only VFS with support for multiple connections, so this option is
+   * ignored for other VFS implementations.
+   *
+   * Defaults to 1.
+   */
+  additionalReaders?: number;
+}
+
+export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
+  vfs: WASQLiteVFS;
+
+  /**
+   * Whether this is a read-only connection opened for the `OPFSWriteAheadVFS` file system.
+   */
+  isReadOnly: boolean;
+}
+
+export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
+  logLevel: ILogLevel;
+  /**
+   * A lock that is currently held by the client. When the lock is returned, we know the client is gone and that we need
+   * to clean up resources.
+   */
+  lockName: string;
 }
 
 /**
  * Opens a SQLite connection using WA-SQLite.
  */
 export class WASQLiteOpenFactory implements SQLOpenFactory {
-  private options: ResolvedWebSQLOpenOptions;
-  private logger: PowerSyncLogger;
+  private resolvedFlags: ResolvedWebSQLFlags;
+  private logger: ILogger;
+
+  constructor(private options: WASQLiteOpenFactoryOptions) {
+    assertValidWASQLiteOpenFactoryOptions(options);
+    this.resolvedFlags = resolveWebSQLFlags(options.flags);
+    this.logger = options.logger ?? createLogger(`WASQLiteOpenFactory - ${this.options.dbFilename}`);
+  }
 
-  constructor(options: WASQLiteOpenFactoryOptions) {
-    this.options = resolveAndValidateOptions(options.open);
-    this.logger = options.logger;
+  get waOptions(): WASQLiteOpenFactoryOptions {
+    // Cast to extended type
+    return this.options;
   }
 
   protected openAdapter(): DBAdapter {
@@ -33,80 +72,84 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
   }
 
   openDB(): DBAdapter {
-    const { disableSSRWarning, enableMultiTabs, ssrMode } = this.options;
-
+    const {
+      resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() }
+    } = this;
     if (ssrMode) {
       if (!disableSSRWarning) {
-        this.logger.log({
-          level: LogLevels.warn,
-          message: `
+        this.logger.warn(
+          `
       Running PowerSync in SSR mode.
       Only empty query results will be returned.
       Disable this warning by setting 'disableSSRWarning: true' in options.`
-        });
+        );
       }
 
       return new SSRDBAdapter();
     }
 
     if (!enableMultiTabs) {
-      this.logger.log({
-        level: LogLevels.warn,
-        message: 'Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.'
-      });
+      this.logger.warn(
+        'Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.'
+      );
     }
 
     return this.openAdapter();
   }
 
   async openConnection(): Promise<PoolConnection> {
-    const { enableMultiTabs, useWebWorker, vfs, dbFilename, encryptionKey, temporaryStorage, cacheSizeKb } =
-      this.options;
+    const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
+    const {
+      vfs = WASQLiteVFS.IDBBatchAtomicVFS,
+      temporaryStorage = TemporaryStorageOption.MEMORY,
+      cacheSizeKb = DEFAULT_CACHE_SIZE_KB,
+      encryptionKey
+    } = this.waOptions;
 
     if (!enableMultiTabs) {
-      this.logger.log({ level: LogLevels.warn, message: 'Multiple tabs are not enabled in this browser' });
+      this.logger.warn('Multiple tabs are not enabled in this browser');
     }
 
+    const resolveOptions = (isReadOnly: boolean): ResolvedWASQLiteOpenFactoryOptions => ({
+      dbFilename: this.options.dbFilename,
+      dbLocation: this.options.dbLocation,
+      debugMode: this.options.debugMode,
+      vfs,
+      temporaryStorage,
+      cacheSizeKb,
+      flags: this.resolvedFlags,
+      encryptionKey: encryptionKey,
+      isReadOnly
+    });
+
     let client: DatabaseClient;
     let additionalReaders: DatabaseClient[] = [];
     let requiresPersistentTriggers = vfsRequiresDedicatedWorkers(vfs);
 
-    function resolveRawWaSqliteDatabaseOptions(readonly: boolean): RawWaSqliteDatabaseOptions {
-      return {
-        filename: dbFilename,
-        readonly,
-        vfs,
-        encryptionKey,
-        temporaryStorage,
-        cacheSizeKb
-      };
-    }
-
     if (useWebWorker) {
       const optionsDbWorker = this.options.worker;
 
-      const openDatabaseWorker = async (readonly: boolean): Promise<DatabaseClient> => {
-        let workerConnection: WorkerConnection;
-        if (typeof optionsDbWorker == 'function') {
-          const worker = optionsDbWorker(this.options);
-          workerConnection = connectToExistingWorker(worker, 'database');
-        } else {
-          const needsDedicated = vfsRequiresDedicatedWorkers(vfs);
-          const useShared = !needsDedicated && enableMultiTabs;
-
-          workerConnection = connectToWorker({
-            service: 'database',
-            databaseIdentifier: this.options.dbFilename,
-            shared: useShared,
-            customWorker: optionsDbWorker
-          });
-        }
-
-        const source = Comlink.wrap<OpenWorkerConnection>(workerConnection.endpoint);
+      const openDatabaseWorker = async (
+        resolvedOptions: ResolvedWASQLiteOpenFactoryOptions
+      ): Promise<DatabaseClient> => {
+        const workerPort =
+          typeof optionsDbWorker == 'function'
+            ? resolveWorkerDatabasePortFactory(() =>
+                optionsDbWorker({
+                  ...this.options,
+                  temporaryStorage,
+                  cacheSizeKb,
+                  flags: this.resolvedFlags,
+                  encryptionKey
+                })
+              )
+            : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
+
+        const source = Comlink.wrap<OpenWorkerConnection>(workerPort);
         const closeSignal = new AbortController();
         const connection = await source.connect({
-          database: resolveRawWaSqliteDatabaseOptions(readonly),
-          logLevel: this.options.databaseWorkerLogLevel,
+          ...resolvedOptions,
+          logLevel: this.logger.getLevel(),
           lockName: await generateTabCloseSignal(closeSignal.signal)
         });
         const clientOptions = {
@@ -116,24 +159,28 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
           remoteCanCloseUnexpectedly: false,
           onClose: () => {
             closeSignal.abort();
-            workerConnection.close();
+            if (workerPort instanceof Worker) {
+              workerPort.terminate();
+            } else {
+              workerPort.close();
+            }
           }
         };
 
         return new DatabaseClient(clientOptions, {
-          ...this.options,
+          ...resolvedOptions,
           requiresPersistentTriggers
         });
       };
 
-      client = await openDatabaseWorker(false);
+      client = await openDatabaseWorker(resolveOptions(false));
 
       if (vfs == WASQLiteVFS.OPFSWriteAheadVFS) {
         // This VFS supports concurrent reads, so we can open additional workers to host read-only connections for
         // concurrent reads / writes.
         const additionalReadersCount = this.options.additionalReaders ?? 1;
         for (let i = 0; i < additionalReadersCount; i++) {
-          const reader = await openDatabaseWorker(true);
+          const reader = await openDatabaseWorker(resolveOptions(true));
           additionalReaders.push(reader);
         }
       }
@@ -142,11 +189,12 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
       const localServer = new MultiDatabaseServer(this.logger);
       requiresPersistentTriggers = true;
 
-      const connection = await localServer.openConnectionLocally(this.logger, resolveRawWaSqliteDatabaseOptions(false));
+      const resolvedOptions = resolveOptions(false);
+      const connection = await localServer.openConnectionLocally(resolvedOptions);
       client = new DatabaseClient(
         { connection, source: null, remoteCanCloseUnexpectedly: false },
         {
-          ...this.options,
+          ...resolvedOptions,
           requiresPersistentTriggers
         }
       );
@@ -158,3 +206,18 @@ export class WASQLiteOpenFactory implements SQLOpenFactory {
     };
   }
 }
+
+/**
+ * Asserts that the factory options are valid.
+ */
+function assertValidWASQLiteOpenFactoryOptions(options: WASQLiteOpenFactoryOptions): void {
+  // The OPFS VFS only works in dedicated web workers.
+  if ('vfs' in options && 'flags' in options) {
+    const { vfs, flags = {} } = options;
+    if (vfs && vfsRequiresDedicatedWorkers(vfs) && 'useWebWorker' in flags && !flags.useWebWorker) {
+      throw new Error(
+        `Invalid configuration: The 'useWebWorker' flag must be true when using an OPFS-based VFS (${vfs}).`
+      );
+    }
+  }
+}

package/src/db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.ts

@@ -0,0 +1,24 @@
+import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions } from '@powersync/common';
+import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase.js';
+import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory.js';
+import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
+
+/**
+ * @deprecated {@link PowerSyncDatabase} can now be constructed directly
+ * @example
+ * ```typescript
+ * const powersync = new PowerSyncDatabase({database: {
+ *  dbFileName: 'powersync.db'
+ * }});
+ * ```
+ */
+export class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDatabaseOpenFactory {
+  protected openDB(): DBAdapter {
+    const factory = new WASQLiteOpenFactory(this.options);
+    return factory.openDB();
+  }
+
+  generateInstance(options: PowerSyncDatabaseOptions): AbstractPowerSyncDatabase {
+    return new PowerSyncDatabase(options);
+  }
+}

package/src/db/adapters/wa-sqlite/vfs.ts

@@ -1,4 +1,5 @@
 import type * as SQLite from '@journeyapps/wa-sqlite';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
 
 /**
  * List of currently tested virtual filesystems
@@ -7,31 +8,36 @@ export enum WASQLiteVFS {
   IDBBatchAtomicVFS = 'IDBBatchAtomicVFS',
   OPFSCoopSyncVFS = 'OPFSCoopSyncVFS',
   AccessHandlePoolVFS = 'AccessHandlePoolVFS',
-  OPFSWriteAheadVFS = 'OPFSWriteAheadVFS'
+  OPFSWriteAheadVFS = 'OPFSWriteAheadVFS',
+  /**
+   * A virtual file system storing data in-memory only, without persistence.
+   *
+   * This file system can be used in three configurations:
+   *
+   * 1. In shared workers (the default when available): All tabs share the same in-memory database, which is cleared
+   *    once the last tab is closed.
+   * 2. In dedicated workers (used when `enableMultiTabs` is disabled). Each tab has its own in-memory database cleared
+   *    when the tab is closed. Queries are offloaded to a dedicated worker.
+   * 3. In the context of the tab itself (used when both `enableMultiTabs` and `useWebWorker` are disabled). The per-tab
+   *    database is hosted in the tab itself, and queries run synchronously. This is _a lot_ faster than any other
+   *    single-threadedVFS, but can block JavaScript for computationally-intensive queries.
+   *
+   * This VFS primarily intended for development, but it also useful for online-first deployments not syncing large
+   * amounts of data, as it is quicker to start up.
+   */
+  InMemoryVfs = 'InMemoryVFS'
 }
 
 export function vfsRequiresDedicatedWorkers(vfs: WASQLiteVFS) {
-  return vfs != WASQLiteVFS.IDBBatchAtomicVFS;
+  return vfs != WASQLiteVFS.IDBBatchAtomicVFS && vfs != WASQLiteVFS.InMemoryVfs;
 }
 
-/**
- * @internal
- */
-export type WASQLiteModuleFactoryOptions = { dbFileName: string; encryptionKey?: string };
-
 /**
  * @internal
  */
 export type SQLiteModule = Parameters<typeof SQLite.Factory>[0];
 
-/**
- * @internal
- */
-export type WASQLiteModuleFactory = (
-  options: WASQLiteModuleFactoryOptions
-) => Promise<{ module: SQLiteModule; vfs: SQLiteVFS }>;
-
-async function asyncModuleFactory(encryptionKey: unknown) {
+async function asyncModuleFactory(encryptionKey: string | undefined): Promise<SQLiteModule> {
   if (encryptionKey) {
     const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite-async.mjs');
     return factory();
@@ -41,7 +47,7 @@ async function asyncModuleFactory(encryptionKey: unknown) {
   }
 }
 
-async function syncModuleFactory(encryptionKey: unknown) {
+async function syncModuleFactory(encryptionKey: string | undefined): Promise<SQLiteModule> {
   if (encryptionKey) {
     const { default: factory } = await import('@journeyapps/wa-sqlite/dist/mc-wa-sqlite.mjs');
     return factory();
@@ -54,43 +60,50 @@ async function syncModuleFactory(encryptionKey: unknown) {
 /**
  * @internal
  */
-export const DEFAULT_MODULE_FACTORIES = {
-  [WASQLiteVFS.IDBBatchAtomicVFS]: async (options: WASQLiteModuleFactoryOptions) => {
-    const module = await asyncModuleFactory(options.encryptionKey);
-    const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
-    return {
-      module,
+export async function loadModuleAndVfs({
+  vfs,
+  dbFilename,
+  encryptionKey
+}: ResolvedWASQLiteOpenFactoryOptions): Promise<{ module: SQLiteModule; vfs: SQLiteVFS }> {
+  let moduleFactory = syncModuleFactory;
+  let resolveVfs: (module: any) => Promise<SQLiteVFS>;
+
+  switch (vfs) {
+    case WASQLiteVFS.IDBBatchAtomicVFS: {
+      moduleFactory = asyncModuleFactory;
+      const { IDBBatchAtomicVFS } = await import('@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js');
+      resolveVfs = (module) => {
+        // @ts-expect-error The types for this static method are missing upstream
+        return IDBBatchAtomicVFS.create(filename, module, { lockPolicy: 'exclusive' });
+      };
+      break;
+    }
+    case WASQLiteVFS.AccessHandlePoolVFS: {
+      // @ts-expect-error The types for this import are missing upstream
+      const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
+      resolveVfs = (module) => AccessHandlePoolVFS.create(dbFilename, module);
+      break;
+    }
+    case WASQLiteVFS.OPFSCoopSyncVFS: {
+      // @ts-expect-error The types for this import are missing upstream
+      const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
+      resolveVfs = (module) => OPFSCoopSyncVFS.create(dbFilename, module);
+      break;
+    }
+    case WASQLiteVFS.OPFSWriteAheadVFS: {
+      // @ts-expect-error The types for this import are missing upstream
+      const { OPFSWriteAheadVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js');
+      resolveVfs = (module) => OPFSWriteAheadVFS.create(dbFilename, module, {});
+      break;
+    }
+    case WASQLiteVFS.InMemoryVfs: {
+      const { MemoryVFS } = await import('@journeyapps/wa-sqlite/src/examples/MemoryVFS.js');
       // @ts-expect-error The types for this static method are missing upstream
-      vfs: await IDBBatchAtomicVFS.create(options.dbFileName, module, { lockPolicy: 'exclusive' })
-    };
-  },
-  [WASQLiteVFS.AccessHandlePoolVFS]: async (options: WASQLiteModuleFactoryOptions) => {
-    const module = await syncModuleFactory(options.encryptionKey);
-    // @ts-expect-error The types for this static method are missing upstream
-    const { AccessHandlePoolVFS } = await import('@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js');
-    return {
-      module,
-      vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
-    };
-  },
-  [WASQLiteVFS.OPFSCoopSyncVFS]: async (options: WASQLiteModuleFactoryOptions) => {
-    const module = await syncModuleFactory(options.encryptionKey);
-    // @ts-expect-error The types for this static method are missing upstream
-    const { OPFSCoopSyncVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js');
-    const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
-    return {
-      module,
-      vfs
-    };
-  },
-  [WASQLiteVFS.OPFSWriteAheadVFS]: async (options: WASQLiteModuleFactoryOptions) => {
-    const module = await syncModuleFactory(options.encryptionKey);
-    // @ts-expect-error The types for this static method are missing upstream
-    const { OPFSWriteAheadVFS } = await import('@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js');
-    const vfs = await OPFSWriteAheadVFS.create(options.dbFileName, module, {});
-    return {
-      module,
-      vfs
-    };
+      resolveVfs = (module) => MemoryVFS.create(dbFilename, module);
+      break;
+    }
   }
-};
+
+  const module = await moduleFactory(encryptionKey);
+  return { module, vfs: await resolveVfs(module) };
+}

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

@@ -0,0 +1,141 @@
+import { type ILogger, SQLOpenOptions } from '@powersync/common';
+
+/**
+ * Common settings used when creating SQL connections on web.
+ */
+export interface WebSQLFlags {
+  /**
+   * Broadcast logs from shared workers, such as the shared sync worker,
+   * to individual tabs. This defaults to true.
+   */
+  broadcastLogs?: boolean;
+
+  /**
+   * SQLite operations are currently not supported in SSR mode.
+   * A warning will be logged if attempting to use SQLite in SSR.
+   * Setting this to `true` will disabled the warning above.
+   */
+  disableSSRWarning?: boolean;
+
+  /**
+   * Enables multi tab support
+   */
+  enableMultiTabs?: boolean;
+
+  /**
+   * The SQLite connection is often executed through a web worker
+   * in order to offload computation. This can be used to manually
+   * disable the use of web workers in environments where web workers
+   * might be unstable.
+   */
+  useWebWorker?: boolean;
+
+  /**
+   * Open in SSR placeholder mode. DB operations and Sync operations will be a No-op
+   */
+  ssrMode?: boolean;
+}
+
+export type ResolvedWebSQLFlags = Required<WebSQLFlags>;
+
+export interface ResolvedWebSQLOpenOptions extends SQLOpenOptions {
+  flags: ResolvedWebSQLFlags;
+  /**
+   * Where to store SQLite temporary files. Defaults to 'MEMORY'.
+   * 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.
+   */
+  encryptionKey?: string;
+}
+
+export enum TemporaryStorageOption {
+  MEMORY = 'memory',
+  FILESYSTEM = 'file'
+}
+
+export const DEFAULT_CACHE_SIZE_KB = 50 * 1024;
+
+/**
+ * Options for opening a Web SQL connection
+ */
+export interface WebSQLOpenFactoryOptions extends SQLOpenOptions {
+  flags?: WebSQLFlags;
+
+  /**
+   * Allows you to override the default wasqlite db worker.
+   *
+   * You can either provide a path to the worker script
+   * or a factory method that returns a worker.
+   */
+  worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
+
+  /**
+   * Use an existing port to an initialized worker.
+   * A worker will be initialized if none is provided
+   */
+  workerPort?: MessagePort;
+
+  logger?: ILogger;
+
+  /**
+   * 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.
+   */
+  encryptionKey?: string;
+}
+
+export function isServerSide() {
+  return typeof window == 'undefined';
+}
+
+export const DEFAULT_WEB_SQL_FLAGS: ResolvedWebSQLFlags = {
+  broadcastLogs: true,
+  disableSSRWarning: false,
+  ssrMode: isServerSide(),
+  /**
+   * Multiple tabs are by default not supported on Android, iOS and Safari.
+   * Other platforms will have multiple tabs enabled by default.
+   */
+  enableMultiTabs:
+    typeof globalThis.navigator !== 'undefined' && // For SSR purposes
+    typeof SharedWorker !== 'undefined' &&
+    !navigator.userAgent.match(/(Android|iPhone|iPod|iPad)/i) &&
+    !(window as any).safari,
+  useWebWorker: true
+};
+
+export function resolveWebSQLFlags(flags?: WebSQLFlags): ResolvedWebSQLFlags {
+  const resolvedFlags = {
+    ...DEFAULT_WEB_SQL_FLAGS,
+    ...(flags ?? {})
+  };
+  if (typeof flags?.enableMultiTabs != 'undefined') {
+    resolvedFlags.enableMultiTabs = flags.enableMultiTabs;
+  }
+  if (flags?.useWebWorker === false) {
+    resolvedFlags.enableMultiTabs = false;
+  }
+  return resolvedFlags;
+}

package/src/db/sync/SSRWebStreamingSyncImplementation.ts

@@ -1,5 +1,14 @@
-import { BaseObserver, SyncStatus } from '@powersync/common';
-import { Mutex, StreamingSyncImplementation, LockOptions, LockType } from '@powersync/shared-internals';
+import {
+  AbstractStreamingSyncImplementationOptions,
+  BaseObserver,
+  LockOptions,
+  LockType,
+  Mutex,
+  PowerSyncConnectionOptions,
+  StreamingSyncImplementation,
+  SyncStatus,
+  SyncStatusOptions
+} from '@powersync/common';
 
 export class SSRStreamingSyncImplementation extends BaseObserver implements StreamingSyncImplementation {
   syncMutex: Mutex;
@@ -7,11 +16,13 @@ export class SSRStreamingSyncImplementation extends BaseObserver implements Stre
 
   isConnected: boolean;
   lastSyncedAt?: Date | undefined;
+  syncStatus: SyncStatus;
 
-  constructor() {
+  constructor(options: AbstractStreamingSyncImplementationOptions) {
     super();
     this.syncMutex = new Mutex();
     this.crudMutex = new Mutex();
+    this.syncStatus = new SyncStatus({});
     this.isConnected = false;
   }
 
@@ -23,7 +34,7 @@ export class SSRStreamingSyncImplementation extends BaseObserver implements Stre
   /**
    * This is a no-op in SSR mode
    */
-  async connect(): Promise<void> {}
+  async connect(options?: PowerSyncConnectionOptions): Promise<void> {}
 
   async dispose() {}
 
@@ -37,6 +48,13 @@ export class SSRStreamingSyncImplementation extends BaseObserver implements Stre
    */
   async waitForReady() {}
 
+  /**
+   * This will never resolve in SSR Mode.
+   */
+  async waitForStatus(status: SyncStatusOptions) {
+    return this.waitUntilStatusMatches(() => false);
+  }
+
   /**
    * This will never resolve in SSR Mode.
    */