@powersync/web 1.27.1 → 1.28.1

package/src/worker/db/WASQLiteDB.worker.ts

@@ -0,0 +1,112 @@
+/**
+ * Supports both shared and dedicated workers, based on how the worker is constructed (new SharedWorker vs new Worker()).
+ */
+
+import '@journeyapps/wa-sqlite';
+import { createBaseLogger, createLogger } from '@powersync/common';
+import * as Comlink from 'comlink';
+import { AsyncDatabaseConnection } from '../../db/adapters/AsyncDatabaseConnection';
+import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+import {
+  ResolvedWASQLiteOpenFactoryOptions,
+  WorkerDBOpenerOptions
+} from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory';
+import { getNavigatorLocks } from '../../shared/navigator';
+
+const baseLogger = createBaseLogger();
+baseLogger.useDefaults();
+const logger = createLogger('db-worker');
+
+/**
+ * Keeps track of open DB connections and the clients which
+ * are using it.
+ */
+type SharedDBWorkerConnection = {
+  clientIds: Set<number>;
+  db: AsyncDatabaseConnection;
+};
+
+const DBMap = new Map<string, SharedDBWorkerConnection>();
+const OPEN_DB_LOCK = 'open-wasqlite-db';
+
+let nextClientId = 1;
+
+const openWorkerConnection = async (options: ResolvedWASQLiteOpenFactoryOptions): Promise<AsyncDatabaseConnection> => {
+  const connection = new WASqliteConnection(options);
+  return {
+    init: Comlink.proxy(() => connection.init()),
+    getConfig: Comlink.proxy(() => connection.getConfig()),
+    close: Comlink.proxy(() => connection.close()),
+    execute: Comlink.proxy(async (sql: string, params?: any[]) => connection.execute(sql, params)),
+    executeRaw: Comlink.proxy(async (sql: string, params?: any[]) => connection.executeRaw(sql, params)),
+    executeBatch: Comlink.proxy(async (sql: string, params?: any[]) => connection.executeBatch(sql, params)),
+    registerOnTableChange: Comlink.proxy(async (callback) => {
+      // Proxy the callback remove function
+      return Comlink.proxy(await connection.registerOnTableChange(callback));
+    })
+  };
+};
+
+const openDBShared = async (options: WorkerDBOpenerOptions): Promise<AsyncDatabaseConnection> => {
+  // Prevent multiple simultaneous opens from causing race conditions
+  return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
+    const clientId = nextClientId++;
+    const { dbFilename, logLevel } = options;
+
+    logger.setLevel(logLevel);
+
+    if (!DBMap.has(dbFilename)) {
+      const clientIds = new Set<number>();
+      const connection = await openWorkerConnection(options);
+      await connection.init();
+      DBMap.set(dbFilename, {
+        clientIds,
+        db: connection
+      });
+    }
+
+    const dbEntry = DBMap.get(dbFilename)!;
+    dbEntry.clientIds.add(clientId);
+    const { db } = dbEntry;
+
+    const wrappedConnection = {
+      ...db,
+      init: Comlink.proxy(async () => {
+        // the init has been done automatically
+      }),
+      close: Comlink.proxy(async () => {
+        const { clientIds } = dbEntry;
+        logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
+        clientIds.delete(clientId);
+        if (clientIds.size == 0) {
+          logger.debug(`Closing connection to ${dbFilename}.`);
+          DBMap.delete(dbFilename);
+          return db.close?.();
+        }
+        logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
+        return;
+      })
+    };
+
+    return Comlink.proxy(wrappedConnection);
+  });
+};
+
+// Check if we're in a SharedWorker context
+if (typeof SharedWorkerGlobalScope !== 'undefined') {
+  const _self: SharedWorkerGlobalScope = self as any;
+  _self.onconnect = function (event: MessageEvent<string>) {
+    const port = event.ports[0];
+    Comlink.expose(openDBShared, port);
+  };
+} else {
+  // A dedicated worker can be shared externally
+  Comlink.expose(openDBShared);
+}
+
+addEventListener('unload', () => {
+  Array.from(DBMap.values()).forEach(async (dbConnection) => {
+    const { db } = dbConnection;
+    db.close?.();
+  });
+});

package/src/worker/db/open-worker-database.ts

@@ -0,0 +1,62 @@
+import * as Comlink from 'comlink';
+import { OpenAsyncDatabaseConnection } from '../..//db/adapters/AsyncDatabaseConnection';
+import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
+
+/**
+ * Opens a shared or dedicated worker which exposes opening of database connections
+ */
+export function openWorkerDatabasePort(
+  workerIdentifier: string,
+  multipleTabs = true,
+  worker: string | URL = '',
+  vfs?: WASQLiteVFS
+) {
+  const needsDedicated = vfs == WASQLiteVFS.AccessHandlePoolVFS || vfs == WASQLiteVFS.OPFSCoopSyncVFS;
+
+  if (worker) {
+    return !needsDedicated && multipleTabs
+      ? new SharedWorker(`${worker}`, {
+          /* @vite-ignore */
+          name: `shared-DB-worker-${workerIdentifier}`
+        }).port
+      : new Worker(`${worker}`, {
+          /* @vite-ignore */
+          name: `DB-worker-${workerIdentifier}`
+        });
+  } else {
+    /**
+     *  Webpack V5 can bundle the worker automatically if the full Worker constructor syntax is used
+     *  https://webpack.js.org/guides/web-workers/
+     *  This enables multi tab support by default, but falls back if SharedWorker is not available
+     *  (in the case of Android)
+     */
+    return !needsDedicated && multipleTabs
+      ? new SharedWorker(new URL('./WASQLiteDB.worker.js', import.meta.url), {
+          /* @vite-ignore */
+          name: `shared-DB-worker-${workerIdentifier}`,
+          type: 'module'
+        }).port
+      : new Worker(new URL('./WASQLiteDB.worker.js', import.meta.url), {
+          /* @vite-ignore */
+          name: `DB-worker-${workerIdentifier}`,
+          type: 'module'
+        });
+  }
+}
+
+/**
+ * @returns A function which allows for opening database connections inside
+ * a worker.
+ */
+export function getWorkerDatabaseOpener(workerIdentifier: string, multipleTabs = true, worker: string | URL = '') {
+  return Comlink.wrap<OpenAsyncDatabaseConnection>(openWorkerDatabasePort(workerIdentifier, multipleTabs, worker));
+}
+
+export function resolveWorkerDatabasePortFactory(worker: () => Worker | SharedWorker) {
+  const workerInstance = worker();
+  return isSharedWorker(workerInstance) ? workerInstance.port : workerInstance;
+}
+
+export function isSharedWorker(worker: Worker | SharedWorker): worker is SharedWorker {
+  return 'port' in worker;
+}

package/src/worker/sync/AbstractSharedSyncClientProvider.ts

@@ -0,0 +1,21 @@
+import type { PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
+
+/**
+ * The client side port should provide these methods.
+ */
+export abstract class AbstractSharedSyncClientProvider {
+  abstract fetchCredentials(): Promise<PowerSyncCredentials | null>;
+  abstract invalidateCredentials(): void;
+  abstract uploadCrud(): Promise<void>;
+  abstract statusChanged(status: SyncStatusOptions): void;
+  abstract getDBWorkerPort(): Promise<MessagePort>;
+
+  abstract trace(...x: any[]): void;
+  abstract debug(...x: any[]): void;
+  abstract info(...x: any[]): void;
+  abstract log(...x: any[]): void;
+  abstract warn(...x: any[]): void;
+  abstract error(...x: any[]): void;
+  abstract time(label: string): void;
+  abstract timeEnd(label: string): void;
+}

package/src/worker/sync/BroadcastLogger.ts

@@ -0,0 +1,142 @@
+import { type ILogger, type ILogLevel, LogLevel } from '@powersync/common';
+import { type WrappedSyncPort } from './SharedSyncImplementation';
+
+/**
+ * Broadcasts logs to all clients
+ */
+export class BroadcastLogger implements ILogger {
+  TRACE: ILogLevel;
+  DEBUG: ILogLevel;
+  INFO: ILogLevel;
+  TIME: ILogLevel;
+  WARN: ILogLevel;
+  ERROR: ILogLevel;
+  OFF: ILogLevel;
+
+  private currentLevel: ILogLevel = LogLevel.INFO;
+
+  constructor(protected clients: WrappedSyncPort[]) {
+    this.TRACE = LogLevel.TRACE;
+    this.DEBUG = LogLevel.DEBUG;
+    this.INFO = LogLevel.INFO;
+    this.TIME = LogLevel.TIME;
+    this.WARN = LogLevel.WARN;
+    this.ERROR = LogLevel.ERROR;
+    this.OFF = LogLevel.OFF;
+  }
+
+  trace(...x: any[]): void {
+    if (!this.enabledFor(this.TRACE)) return;
+
+    console.trace(...x);
+    const sanitized = this.sanitizeArgs(x);
+    this.iterateClients((client) => client.clientProvider.trace(...sanitized));
+  }
+
+  debug(...x: any[]): void {
+    if (!this.enabledFor(this.DEBUG)) return;
+
+    console.debug(...x);
+    const sanitized = this.sanitizeArgs(x);
+    this.iterateClients((client) => client.clientProvider.debug(...sanitized));
+  }
+
+  info(...x: any[]): void {
+    if (!this.enabledFor(this.INFO)) return;
+
+    console.info(...x);
+    const sanitized = this.sanitizeArgs(x);
+    this.iterateClients((client) => client.clientProvider.info(...sanitized));
+  }
+
+  log(...x: any[]): void {
+    if (!this.enabledFor(this.INFO)) return;
+
+    console.log(...x);
+    const sanitized = this.sanitizeArgs(x);
+    this.iterateClients((client) => client.clientProvider.log(...sanitized));
+  }
+
+  warn(...x: any[]): void {
+    if (!this.enabledFor(this.WARN)) return;
+
+    console.warn(...x);
+    const sanitized = this.sanitizeArgs(x);
+    this.iterateClients((client) => client.clientProvider.warn(...sanitized));
+  }
+
+  error(...x: any[]): void {
+    if (!this.enabledFor(this.ERROR)) return;
+
+    console.error(...x);
+    const sanitized = this.sanitizeArgs(x);
+    this.iterateClients((client) => client.clientProvider.error(...sanitized));
+  }
+
+  time(label: string): void {
+    if (!this.enabledFor(this.TIME)) return;
+
+    console.time(label);
+    this.iterateClients((client) => client.clientProvider.time(label));
+  }
+
+  timeEnd(label: string): void {
+    if (!this.enabledFor(this.TIME)) return;
+
+    console.timeEnd(label);
+    this.iterateClients((client) => client.clientProvider.timeEnd(label));
+  }
+
+  /**
+   * Set the global log level.
+   */
+  setLevel(level: ILogLevel): void {
+    this.currentLevel = level;
+  }
+
+  /**
+   * Get the current log level.
+   */
+  getLevel(): ILogLevel {
+    return this.currentLevel;
+  }
+
+  /**
+   * Returns true if the given level is enabled.
+   */
+  enabledFor(level: ILogLevel): boolean {
+    return level.value >= this.currentLevel.value;
+  }
+
+  /**
+   * Iterates all clients, catches individual client exceptions
+   * and proceeds to execute for all clients.
+   */
+  protected async iterateClients(callback: (client: WrappedSyncPort) => Promise<void>) {
+    for (const client of this.clients) {
+      try {
+        await callback(client);
+      } catch (ex) {
+        console.error('Caught exception when iterating client', ex);
+      }
+    }
+  }
+
+  /**
+   * Guards against any logging errors.
+   * We don't want a logging exception to cause further issues upstream
+   */
+  protected sanitizeArgs(x: any[]): any[] {
+    const sanitizedParams = x.map((param) => {
+      try {
+        // Try and clone here first. If it fails it won't be passable over a MessagePort
+        return structuredClone(param);
+      } catch (ex) {
+        console.error(ex);
+        return 'Could not serialize log params. Check shared worker logs for more details.';
+      }
+    });
+
+    return sanitizedParams;
+  }
+}