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

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

@@ -1,141 +0,0 @@
-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/worker/db/WASQLiteDB.worker.ts

@@ -1,35 +0,0 @@
-/**
- * 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 { isSharedWorker, MultiDatabaseServer } from './MultiDatabaseServer.js';
-import { OpenWorkerConnection } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
-
-const baseLogger = createBaseLogger();
-baseLogger.useDefaults();
-const logger = createLogger('db-worker');
-
-const server = new MultiDatabaseServer(logger);
-const exposedFunctions: OpenWorkerConnection = {
-  connect: (config) => server.handleConnection(config),
-  connectToExisting: ({ identifier, lockName }) => server.connectToExisting(identifier, lockName)
-};
-
-// Check if we're in a SharedWorker context
-if (isSharedWorker) {
-  const _self: SharedWorkerGlobalScope = self as any;
-  _self.onconnect = function (event: MessageEvent<string>) {
-    const port = event.ports[0];
-    Comlink.expose(exposedFunctions, port);
-  };
-} else {
-  // A dedicated worker can be shared externally
-  Comlink.expose(exposedFunctions);
-}
-
-addEventListener('unload', () => {
-  server.closeAll();
-});

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

@@ -1,62 +0,0 @@
-import * as Comlink from 'comlink';
-import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from '../../db/adapters/wa-sqlite/vfs.js';
-import { OpenWorkerConnection } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
-
-/**
- * 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 && vfsRequiresDedicatedWorkers(vfs);
-
-  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<OpenWorkerConnection>(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/SharedSyncImplementation.worker.ts

@@ -1,14 +0,0 @@
-import { createBaseLogger } from '@powersync/common';
-import { SharedSyncImplementation } from './SharedSyncImplementation.js';
-import { WorkerClient } from './WorkerClient.js';
-
-const _self: SharedWorkerGlobalScope = self as any;
-const logger = createBaseLogger();
-logger.useDefaults();
-
-const sharedSyncImplementation = new SharedSyncImplementation();
-
-_self.onconnect = async function (event: MessageEvent<string>) {
-  const port = event.ports[0];
-  new WorkerClient(sharedSyncImplementation, port);
-};