@powersync/web 0.0.0-dev-20260708104358 → 0.0.0-dev-20260917074240

package/src/worker/client.ts

@@ -0,0 +1,121 @@
+import { LogLevels, PowerSyncLogger } from '@powersync/common';
+import { SharedWorkerConnectionRequest, WorkerService } from './SharedWorkerConnectionRequest.js';
+
+export interface OpenWorkerOptions {
+  service: WorkerService;
+  databaseIdentifier: string;
+  customWorker?: string | URL;
+  shared: boolean;
+  loggerForErrors: PowerSyncLogger;
+}
+
+export interface WorkerConnection {
+  endpoint: MessagePort | Worker;
+  worker: Worker | SharedWorker;
+  close: () => void;
+}
+
+export function connectToWorker({
+  service,
+  databaseIdentifier,
+  customWorker,
+  shared,
+  loggerForErrors
+}: OpenWorkerOptions): WorkerConnection {
+  const name = `${shared ? 'shared-' : ''}powersync-${databaseIdentifier}`;
+  let worker: Worker | SharedWorker;
+
+  if (customWorker) {
+    worker = shared
+      ? new SharedWorker(customWorker, {
+          /* @vite-ignore */
+          name,
+          type: 'module'
+        })
+      : new Worker(customWorker, {
+          /* @vite-ignore */
+          name,
+          type: 'module'
+        });
+  } else {
+    worker = spawnDefaultPowerSyncWorker(shared, name);
+  }
+
+  return connectToExistingWorker(worker, loggerForErrors, service);
+}
+
+/**
+ * Opens the default PowerSync worker.
+ *
+ * When users depend on the web SDK, we assume they use their own bundler (either vite or webpack). Both recognize the
+ * syntax of worker constructors with a string literal and will rewrite the URL as part of their bundling processes.
+ *
+ * React Native / Metro users can't rely on this on the web, as their app is not a JavaScript module and import.meta.url
+ * is not rewritten by Metro. For those users, we include a pre-bundled worker they can copy into a static assets
+ * directory and load with a custom URI. This also means that defaultWorker cannot work with Metro for React Native Web.
+ * We have a custom rollup plugin and conditional exports that replaces this function with a throwing stub for that
+ * platform. This allows a helpful error message.
+ */
+// Note: When changing this function, also update disableDefaultWorkers in rollup.config.ts.
+function spawnDefaultPowerSyncWorker(shared: boolean, name: string): Worker | SharedWorker {
+  return shared
+    ? new SharedWorker(new URL('./worker.js', import.meta.url), {
+        /* @vite-ignore */
+        name,
+        type: 'module'
+      })
+    : new Worker(new URL('./worker.js', import.meta.url), {
+        /* @vite-ignore */
+        name,
+        type: 'module'
+      });
+}
+
+export function connectToExistingWorker(
+  worker: Worker | SharedWorker,
+  logger: PowerSyncLogger,
+  service: WorkerService
+): WorkerConnection {
+  function logError(event: ErrorEvent) {
+    // TODO: Ideally, we should be able to handle worker errors by forwarding them to async Comlink callers.
+    // Currently, comlink calls on errored workers would just be stuck forever.
+    logger.log({
+      level: LogLevels.error,
+      error: event.error,
+      message: 'Error in database or sync worker, this likely disrupts PowerSync.'
+    });
+  }
+
+  (worker as AbstractWorker).addEventListener('error', logError);
+
+  const isShared = isSharedWorker(worker);
+  if (isShared) {
+    const { port1, port2 } = new MessageChannel();
+    const mainPort = (worker as SharedWorker).port;
+    mainPort.start();
+    mainPort.postMessage({ port: port1, service } satisfies SharedWorkerConnectionRequest, [port1]);
+
+    port2.start();
+    return {
+      endpoint: port2,
+      worker,
+      close() {
+        worker.removeEventListener('error', logError);
+        port2.close();
+      }
+    };
+  } else {
+    return {
+      endpoint: worker as Worker,
+      worker,
+      close() {
+        worker.removeEventListener('error', logError);
+        worker.terminate();
+      }
+    };
+  }
+}
+
+export function isSharedWorker(worker: Worker | SharedWorker): worker is SharedWorker {
+  return 'port' in worker;
+}

package/src/worker/db/MultiDatabaseServer.ts

@@ -1,33 +1,46 @@
-import { ILogger } from '@powersync/common';
+import { LogLevels, PowerSyncLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { ClientConnectionView, DatabaseServer } from '../../db/adapters/wa-sqlite/DatabaseServer.js';
-import {
-  ResolvedWASQLiteOpenFactoryOptions,
-  WorkerDBOpenerOptions
-} from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
 import { getNavigatorLocks } from '../../shared/navigator.js';
-import { RawSqliteConnection } from '../../db/adapters/wa-sqlite/RawSqliteConnection.js';
+import { RawSqliteConnection, RawWaSqliteDatabaseOptions } from '../../db/adapters/wa-sqlite/RawSqliteConnection.js';
 import { ConcurrentSqliteConnection } from '../../db/adapters/wa-sqlite/ConcurrentConnection.js';
 import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/vfs.js';
+import { Mutex } from '@powersync/shared-internals';
 
 const OPEN_DB_LOCK = 'open-wasqlite-db';
 
+export interface ConnectToMultiDatabaseServerOptions {
+  logLevel: number;
+  database: RawWaSqliteDatabaseOptions;
+  lockName: string;
+}
+
 /**
  * Shared state to manage multiple database connections hosted by a worker.
  */
 export class MultiDatabaseServer {
-  private activeDatabases = new Map<string, DatabaseServer>();
-
-  constructor(readonly logger: ILogger) {}
+  readonly #activeDatabases = new Map<string, DatabaseServer>();
+  readonly #localOpenLock = new Mutex();
+
+  constructor(readonly logger: PowerSyncLogger) {}
+
+  async handleConnection({
+    logLevel,
+    database,
+    lockName
+  }: ConnectToMultiDatabaseServerOptions): Promise<ClientConnectionView> {
+    const logger: PowerSyncLogger = {
+      log: (record) => {
+        if (record.level >= logLevel) this.logger.log(record);
+      }
+    };
 
-  async handleConnection(options: WorkerDBOpenerOptions): Promise<ClientConnectionView> {
-    this.logger.setLevel(options.logLevel);
-    return Comlink.proxy(await this.openConnectionLocally(options, options.lockName));
+    return Comlink.proxy(await this.openConnectionLocally(logger, database, lockName));
   }
 
   async connectToExisting(name: string, lockName: string): Promise<ClientConnectionView> {
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
-      const server = this.activeDatabases.get(name);
+      const server = this.#activeDatabases.get(name);
       if (server == null) {
         throw new Error(`connectToExisting(${name}) failed because the worker doesn't own a database with that name.`);
       }
@@ -36,7 +49,7 @@ export class MultiDatabaseServer {
     });
   }
 
-  async openConnectionLocally(options: ResolvedWASQLiteOpenFactoryOptions, lockName?: string) {
+  async openConnectionLocally(logger: PowerSyncLogger, options: RawWaSqliteDatabaseOptions, lockName?: string) {
     // Especially on Firefox, we're sometimes seeing "NoModificationAllowedError"s when opening OPFS databases we can
     // work around by retrying.
     const maxAttempts = 3;
@@ -44,29 +57,34 @@ export class MultiDatabaseServer {
 
     for (let count = 0; count < maxAttempts - 1; count++) {
       try {
-        server = await this.databaseOpenAttempt(options);
-      } catch (ex) {
-        this.logger.warn(`Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`, ex);
+        server = await this.#databaseOpenAttempt(logger, options);
+      } catch (error) {
+        this.logger.log({
+          level: LogLevels.warn,
+          message: `Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`,
+          error
+        });
         await new Promise((resolve) => setTimeout(resolve, 1000));
       }
     }
 
     // Final attempt if we haven't been able to open the server - rethrow errors if we still can't open.
-    server ??= await this.databaseOpenAttempt(options);
+    server ??= await this.#databaseOpenAttempt(logger, options);
     return server.connect(lockName);
   }
 
-  private async databaseOpenAttempt(options: ResolvedWASQLiteOpenFactoryOptions): Promise<DatabaseServer> {
-    return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
-      const { dbFilename, isReadOnly, vfs } = options;
-
-      let server: DatabaseServer | undefined = this.activeDatabases.get(dbFilename);
+  async #databaseOpenAttempt(logger: PowerSyncLogger, options: RawWaSqliteDatabaseOptions): Promise<DatabaseServer> {
+    const { filename, readonly, vfs } = options;
+    // We don't need navigator locks for shared workers because all queries run in this shared worker exclusively.
+    // For read-only connections, we use a VFS that supports concurrent reads (so a single lock on the connection is
+    // fine). In-memory databases either run in a shared worker or aren't shared across tabs at all, so the internal
+    // lock is enough.
+    const needsNavigatorLocks = !(isSharedWorker || readonly || vfs == WASQLiteVFS.InMemoryVfs);
+    const activeDatabases = this.#activeDatabases;
+
+    async function openDatabase() {
+      let server: DatabaseServer | undefined = activeDatabases.get(filename);
       if (server == null) {
-        // We don't need navigator locks for shared workers because all queries run in this shared worker exclusively.
-        // For read-only connections, we use a VFS that supports concurrent reads (so a single lock on the connection is
-        // fine). In-memory databases either run in a shared worker or aren't shared across tabs at all, so the internal
-        // lock is enough.
-        const needsNavigatorLocks = !(isSharedWorker || isReadOnly || vfs == WASQLiteVFS.InMemoryVfs);
         const connection = new RawSqliteConnection(options);
         const withSafeConcurrency = new ConcurrentSqliteConnection(connection, needsNavigatorLocks);
 
@@ -83,21 +101,29 @@ export class MultiDatabaseServer {
         }
         returnLease();
 
-        const onClose = () => this.activeDatabases.delete(dbFilename);
+        const onClose = () => activeDatabases.delete(filename);
         server = new DatabaseServer({
           inner: withSafeConcurrency,
-          logger: this.logger,
+          logger,
           onClose
         });
-        this.activeDatabases.set(dbFilename, server);
+        activeDatabases.set(filename, server);
       }
 
       return server;
-    });
+    }
+
+    if (needsNavigatorLocks) {
+      return getNavigatorLocks().request(OPEN_DB_LOCK, openDatabase);
+    } else {
+      // Even if we don't need navigator locks, this avoids a race between the activeDatabases.get() call, the async
+      // open logic and the final activeDatabases.set() step.
+      return this.#localOpenLock.runExclusive(openDatabase);
+    }
   }
 
   closeAll() {
-    const existingDatabases = [...this.activeDatabases.values()];
+    const existingDatabases = [...this.#activeDatabases.values()];
     return Promise.all(
       existingDatabases.map((db) => {
         db.forceClose();

package/src/worker/sync/AbstractSharedSyncClientProvider.ts

@@ -1,4 +1,5 @@
-import type { PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
+import type { LogRecord, PowerSyncCredentials } from '@powersync/common';
+import { SyncStatusJson } from '@powersync/shared-internals';
 
 /**
  * The client side port should provide these methods.
@@ -7,15 +8,9 @@ export abstract class AbstractSharedSyncClientProvider {
   abstract fetchCredentials(): Promise<PowerSyncCredentials | null>;
   abstract invalidateCredentials(): void;
   abstract uploadCrud(): Promise<void>;
-  abstract statusChanged(status: SyncStatusOptions): void;
+  abstract postCheckpointRequest(clientId: string, requestId: string): Promise<string | null>;
+  abstract statusChanged(status: SyncStatusJson): 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;
+  abstract log(record: LogRecord): void;
 }

package/src/worker/sync/BroadcastLogger.ts

@@ -1,113 +1,39 @@
-import { type ILogger, type ILogLevel, LogLevel } from '@powersync/common';
+import { PowerSyncLogger, LogLevels, CreateLoggerOptions, createConsoleLogger, LogRecord } from '@powersync/common';
 import { type WrappedSyncPort } from './SharedSyncImplementation.js';
 
 /**
  * Broadcasts logs to all clients
  */
-export class BroadcastLogger implements ILogger {
-  TRACE: ILogLevel;
-  DEBUG: ILogLevel;
-  INFO: ILogLevel;
-  TIME: ILogLevel;
-  WARN: ILogLevel;
-  ERROR: ILogLevel;
-  OFF: ILogLevel;
+export class BroadcastLogger implements PowerSyncLogger {
+  private readonly inner: PowerSyncLogger & CreateLoggerOptions;
+  private currentLevel: number = LogLevels.info;
 
-  private currentLevel: ILogLevel = LogLevel.INFO;
+  sendBroadcasts = true;
 
-  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;
+  constructor(
+    prefix: string,
+    private clients: WrappedSyncPort[]
+  ) {
+    this.inner = createConsoleLogger({ prefix: prefix });
   }
 
-  trace(...x: any[]): void {
-    if (!this.enabledFor(this.TRACE)) return;
+  log(record: LogRecord) {
+    this.inner.log(record);
 
-    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));
+    if (this.sendBroadcasts && record.level >= this.currentLevel) {
+      const sanitized = this.sanitizeRecord(record);
+      this.iterateClients((client) => client.clientProvider.log(sanitized));
+    }
   }
 
   /**
    * Set the global log level.
    */
-  setLevel(level: ILogLevel): void {
+  setLevel(level: number): void {
+    this.inner.minLevel = level;
     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.
@@ -126,17 +52,23 @@ export class BroadcastLogger implements ILogger {
    * 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.';
-      }
-    });
+  protected sanitizeRecord(record: LogRecord): LogRecord {
+    if (!record.error) {
+      return record;
+    }
+
+    let error;
+    try {
+      // Try and clone here first. If it fails it won't be passable over a MessagePort
+      error = structuredClone(record.error);
+    } catch (ex) {
+      console.error(ex);
+      error = 'Could not serialize log params. Check shared worker logs for more details.';
+    }
 
-    return sanitizedParams;
+    return {
+      ...record,
+      error
+    };
   }
 }