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

package/src/db/adapters/resolveAndValidateOptions.ts

@@ -1,40 +0,0 @@
-import { LogLevels } from '@powersync/common';
-import { TemporaryStorageOption, WebSpecificOpenOptions } from './options.js';
-import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from './wa-sqlite/vfs.js';
-
-/**
- * @internal
- */
-export function resolveAndValidateOptions<And = {}>(
-  options: Partial<WebSpecificOpenOptions> & And
-): WebSpecificOpenOptions & And {
-  const defaults: WebSpecificOpenOptions = {
-    disableSSRWarning: false,
-    ssrMode: !('window' in globalThis),
-    /**
-     * 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,
-    databaseWorkerLogLevel: LogLevels.info,
-    temporaryStorage: TemporaryStorageOption.MEMORY,
-    cacheSizeKb: 50 * 1024,
-    encryptionKey: undefined,
-    vfs: WASQLiteVFS.IDBBatchAtomicVFS,
-    additionalReaders: 1
-  };
-
-  const resolved = Object.assign(defaults, options);
-  if (vfsRequiresDedicatedWorkers(resolved.vfs) && !resolved.useWebWorker) {
-    throw new Error(
-      `Invalid configuration: The 'useWebWorker' flag must be true when using an OPFS-based VFS (${resolved.vfs}).`
-    );
-  }
-
-  return resolved;
-}

package/src/worker/SharedWorkerConnectionRequest.ts

@@ -1,6 +0,0 @@
-export type WorkerService = 'database' | 'sync';
-
-export interface SharedWorkerConnectionRequest {
-  service: WorkerService;
-  port: MessagePort;
-}

package/src/worker/client.ts

@@ -1,100 +0,0 @@
-import { SharedWorkerConnectionRequest, WorkerService } from './SharedWorkerConnectionRequest.js';
-
-export interface OpenWorkerOptions {
-  service: WorkerService;
-  databaseIdentifier: string;
-  customWorker?: string | URL;
-  shared: boolean;
-}
-
-export interface WorkerConnection {
-  endpoint: MessagePort | Worker;
-  worker: Worker | SharedWorker;
-  close: () => void;
-}
-
-export function connectToWorker({
-  service,
-  databaseIdentifier,
-  customWorker,
-  shared
-}: 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, 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, service: WorkerService): WorkerConnection {
-  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() {
-        port2.close();
-      }
-    };
-  } else {
-    return {
-      endpoint: worker as Worker,
-      worker,
-      close() {
-        worker.terminate();
-      }
-    };
-  }
-}
-
-export function isSharedWorker(worker: Worker | SharedWorker): worker is SharedWorker {
-  return 'port' in worker;
-}

package/src/worker/worker.ts

@@ -1,38 +0,0 @@
-import * as Comlink from 'comlink';
-
-import { createConsoleLogger, LogLevels } from '@powersync/common';
-import { isSharedWorker, MultiDatabaseServer } from './db/MultiDatabaseServer.js';
-import { SharedSyncImplementation } from './sync/SharedSyncImplementation.js';
-import { OpenWorkerConnection } from '../db/adapters/wa-sqlite/DatabaseClient.js';
-import { SharedWorkerConnectionRequest } from './SharedWorkerConnectionRequest.js';
-import { WorkerClient } from './sync/WorkerClient.js';
-
-const server = new MultiDatabaseServer(createConsoleLogger({ prefix: 'db-worker', minLevel: LogLevels.trace }));
-
-const exposedDatabaseFunctions: OpenWorkerConnection = {
-  connect: (config) => server.handleConnection(config),
-  connectToExisting: ({ identifier, lockName }) => server.connectToExisting(identifier, lockName)
-};
-
-if (isSharedWorker) {
-  const sharedSyncImplementation = new SharedSyncImplementation();
-
-  // A shared worker can either be an IndexedDB-VFS database server or a shared sync coordinator.
-  // To be able to know what service a client is connecting to, we let clients send an inner MessagePort through the
-  // top-level port along with a tag describing what they need.
-  const _self = self as unknown as SharedWorkerGlobalScope;
-  _self.onconnect = (outerEvent: MessageEvent) => {
-    const port = outerEvent.ports[0];
-    port.onmessage = (event: MessageEvent<SharedWorkerConnectionRequest>) => {
-      const { service, port } = event.data;
-      if (service === 'database') {
-        Comlink.expose(exposedDatabaseFunctions, port);
-      } else if (service === 'sync') {
-        new WorkerClient(sharedSyncImplementation, port);
-      }
-    };
-  };
-} else {
-  // Dedicated workers are only used for databases, so we don't need an intermediate layer.
-  Comlink.expose(exposedDatabaseFunctions);
-}