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

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@powersync/web",
-  "version": "0.0.0-dev-20260708104358",
+  "version": "0.0.0-dev-20260917074240",
   "description": "PowerSync Web SDK",
-  "main": "lib/src/index.js",
-  "module": "lib/src/index.js",
+  "main": "lib/index.js",
+  "module": "lib/index.js",
   "type": "module",
-  "types": "lib/src/index.d.ts",
+  "types": "lib/index.d.ts",
   "bin": {
     "powersync-web": "bin/powersync.cjs"
   },
@@ -18,25 +18,24 @@
   ],
   "exports": {
     ".": {
-      "types": "./lib/src/index.d.ts",
-      "default": "./lib/src/index.js"
+      "types": "./lib/index.d.ts",
+      "react-native-web": "./dist/index.react_native_web.js",
+      "react-native": "./dist/index.react_native_web.js",
+      "default": "./lib/index.js"
     },
-    "./umd": {
-      "types": "./lib/src/index.d.ts",
-      "default": "./dist/index.umd.js"
+    "./extra/shared-memory-pool": {
+      "types": "./lib/db/adapters/memory-pool/client.d.ts",
+      "default": "./lib/db/adapters/memory-pool/client.js"
     },
-    "./umd/worker/db": {
-      "types": "./lib/src/index.d.ts",
-      "import": "./dist/worker/WASQLiteDB.umd.js",
-      "require": "./dist/worker/WASQLiteDB.umd.js"
-    },
-    "./umd/worker/sync": {
-      "types": "./lib/src/index.d.ts",
-      "import": "./dist/worker/SharedSyncImplementation.umd.js",
-      "require": "./dist/worker/SharedSyncImplementation.umd.js"
+    "./bundled_worker": {
+      "types": "./lib/worker/worker.d.ts",
+      "default": "./dist/worker/worker.js"
     }
   },
-  "repository": "https://github.com/powersync-ja/powersync-js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/powersync-ja/powersync-js"
+  },
   "bugs": {
     "url": "https://github.com/powersync-ja/powersync-js/issues"
   },
@@ -55,37 +54,37 @@
   "author": "PowerSync",
   "license": "Apache-2.0",
   "peerDependencies": {
-    "@journeyapps/wa-sqlite": "^1.5.0",
-    "@powersync/common": "^1.57.1"
+    "@powersync/common": "^2.2.1",
+    "@powersync/shared-internals": "0.0.0-dev-20260917074240"
   },
   "dependencies": {
+    "@journeyapps/wa-sqlite": "2.0.4",
     "comlink": "^4.4.2",
     "commander": "^12.1.0",
-    "@powersync/common": "1.57.1"
+    "@powersync/common": "2.2.1",
+    "@powersync/shared-internals": "0.0.0-dev-20260917074240"
   },
   "devDependencies": {
-    "@journeyapps/wa-sqlite": "^1.7.0",
     "@types/uuid": "^9.0.6",
     "bson": "^6.10.4",
     "glob": "^11.0.0",
     "p-defer": "^4.0.1",
     "source-map-loader": "^5.0.0",
-    "terser-webpack-plugin": "^5.3.9",
     "uuid": "^11.1.0",
     "vite": "^7.3.1",
-    "webpack": "^5.90.1",
-    "webpack-cli": "^5.1.4",
-    "webpack-node-externals": "^3.0.0"
+    "rollup": "^4.52.5",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^1.0.0",
+    "estree-walker": "^3.0.3",
+    "magic-string": "^0.30.21"
   },
   "scripts": {
     "build:tsc": "tsc --build",
-    "build:webpack-main": "webpack",
-    "build:webpack-workers": "webpack --config webpack.workers.config.js",
-    "build": "pnpm run build:tsc && pnpm run build:webpack-main && pnpm run build:webpack-workers",
-    "build:prod": "pnpm run build:tsc --sourceMap false && pnpm run build:webpack-main && pnpm run build:webpack-workers",
+    "build": "pnpm run build:tsc && rollup --config",
+    "build:prod": "pnpm run build",
     "clean": "rm -rf lib dist tsconfig.tsbuildinfo",
     "watch": "tsc --build -w",
     "test": "pnpm build && vitest",
-    "test:exports": "attw --pack . --entrypoints . --profile=esm-only "
+    "test:exports": "attw --pack . --entrypoints . extra/shared-memory-pool --profile=esm-only "
   }
 }

package/src/db/NavigatorTriggerClaimManager.ts

@@ -1,4 +1,4 @@
-import { TriggerClaimManager } from '@powersync/common';
+import { TriggerClaimManager } from '@powersync/shared-internals';
 import { getNavigatorLocks } from '../shared/navigator.js';
 
 /**

package/src/db/PowerSyncDatabase.ts

@@ -1,53 +1,50 @@
 import {
-  AbstractPowerSyncDatabase,
+  type PowerSyncBackendConnector,
+  type PowerSyncCloseOptions,
+  LogLevels,
+  BasePowerSyncDatabaseOptions,
+  DatabaseSource,
   DBAdapter,
-  PowerSyncDatabaseOptions,
-  PowerSyncDatabaseOptionsWithDBAdapter,
-  PowerSyncDatabaseOptionsWithOpenFactory,
-  PowerSyncDatabaseOptionsWithSettings,
+  PowerSyncDatabaseConstructor,
+  CommonPowerSyncDatabase
+} from '@powersync/common';
+import {
+  BasePowerSyncDatabase,
+  BucketStorageAdapter,
+  CreateSyncImplementationOptions,
+  Mutex,
   SqliteBucketStorage,
   StreamingSyncImplementation,
   TriggerManagerConfig,
-  isDBAdapter,
-  isSQLOpenFactory,
-  Mutex,
-  type BucketStorageAdapter,
-  type PowerSyncBackendConnector,
-  type PowerSyncCloseOptions,
-  type RequiredAdditionalConnectionOptions
-} from '@powersync/common';
+  openDatabase
+} from '@powersync/shared-internals';
 import { getNavigatorLocks } from '../shared/navigator.js';
 import { NAVIGATOR_TRIGGER_CLAIM_MANAGER } from './NavigatorTriggerClaimManager.js';
 import { WebDBAdapter } from './adapters/WebDBAdapter.js';
 import { WASQLiteOpenFactory } from './adapters/wa-sqlite/WASQLiteOpenFactory.js';
-import {
-  DEFAULT_WEB_SQL_FLAGS,
-  ResolvedWebSQLOpenOptions,
-  WebSQLFlags,
-  isServerSide,
-  resolveWebSQLFlags
-} from './adapters/web-sql-flags.js';
+import { WebSpecificOpenOptions, WebSQLOpenOptions } from './adapters/options.js';
 import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation.js';
 import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation.js';
 import { WebRemote } from './sync/WebRemote.js';
-import {
-  WebStreamingSyncImplementation,
-  WebStreamingSyncImplementationOptions
-} from './sync/WebStreamingSyncImplementation.js';
+import { WebStreamingSyncImplementationOptions } from './sync/WebStreamingSyncImplementation.js';
 import { AsyncDbAdapter } from './adapters/AsyncWebAdapter.js';
+import { resolveAndValidateOptions } from './adapters/resolveAndValidateOptions.js';
+import { TabLocalStreamingSyncImplementation } from './sync/TabLocalStreamingSyncImplementation.js';
+
+export type WebPowerSyncDatabaseOptions = BasePowerSyncDatabaseOptions &
+  DatabaseSource<WebSQLOpenOptions> &
+  WebSpecificOptions;
+
+export interface WebSpecificOptions {
+  sync?: WebSyncOptions;
 
-export interface WebPowerSyncFlags extends WebSQLFlags {
   /**
-   * @deprecated This flag is no longer used. Navigator locks now handle tab detection automatically.
-   * Externally unload open PowerSync database instances when the window closes.
-   * Setting this to `true` requires calling `close` on all open PowerSyncDatabase
-   * instances before the window unloads
+   * Broadcast logs from shared workers, such as the shared sync worker,
+   * to individual tabs. This defaults to true.
    */
-  externallyUnload?: boolean;
+  broadcastLogs?: boolean;
 }
 
-type WithWebFlags<Base> = Base & { flags?: WebPowerSyncFlags };
-
 export interface WebSyncOptions {
   /**
    * Allows you to override the default sync worker.
@@ -55,91 +52,31 @@ export interface WebSyncOptions {
    * You can either provide a path to the worker script
    * or a factory method that returns a worker.
    */
-  worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => SharedWorker);
-}
+  worker?: string | URL | (() => SharedWorker);
 
-type WithWebSyncOptions<Base> = Base & {
-  sync?: WebSyncOptions;
-};
-
-export interface WebEncryptionOptions {
   /**
-   * Encryption key for the database.
-   * If set, the database will be encrypted using Multiple Ciphers.
+   * The log level for logs from the sync worker.
+   *
+   * Defaults to {@link LogLevels.info}.
    */
-  encryptionKey?: string;
-}
-
-type WithWebEncryptionOptions<Base> = Base & WebEncryptionOptions;
-
-export type WebPowerSyncDatabaseOptionsWithAdapter = WithWebSyncOptions<
-  WithWebFlags<PowerSyncDatabaseOptionsWithDBAdapter>
->;
-export type WebPowerSyncDatabaseOptionsWithOpenFactory = WithWebSyncOptions<
-  WithWebFlags<PowerSyncDatabaseOptionsWithOpenFactory>
->;
-export type WebPowerSyncDatabaseOptionsWithSettings = WithWebSyncOptions<
-  WithWebFlags<WithWebEncryptionOptions<PowerSyncDatabaseOptionsWithSettings>>
->;
-
-export type WebPowerSyncDatabaseOptions = WithWebSyncOptions<WithWebFlags<PowerSyncDatabaseOptions>>;
-
-export const DEFAULT_POWERSYNC_FLAGS: Required<WebPowerSyncFlags> = {
-  ...DEFAULT_WEB_SQL_FLAGS,
-  externallyUnload: false
-};
-
-export const resolveWebPowerSyncFlags = (flags?: WebPowerSyncFlags): Required<WebPowerSyncFlags> => {
-  return {
-    ...DEFAULT_POWERSYNC_FLAGS,
-    ...flags,
-    ...resolveWebSQLFlags(flags)
-  };
-};
-
-/**
- * Asserts that the database options are valid for custom database constructors.
- */
-function assertValidDatabaseOptions(options: WebPowerSyncDatabaseOptions): void {
-  if ('database' in options && 'encryptionKey' in options) {
-    const { database } = options;
-    if (isSQLOpenFactory(database) || isDBAdapter(database)) {
-      throw new Error(
-        `Invalid configuration: 'encryptionKey' should only be included inside the database object when using a custom ${isSQLOpenFactory(database) ? 'WASQLiteOpenFactory' : 'WASQLiteDBAdapter'} constructor.`
-      );
-    }
-  }
+  logLevel?: number;
 }
 
 /**
- * A PowerSync database which provides SQLite functionality
- * which is automatically synced.
- *
- * @example
- * ```typescript
- * export const db = new PowerSyncDatabase({
- *  schema: AppSchema,
- *  database: {
- *    dbFilename: 'example.db'
- *  }
- * });
- * ```
+ * @internal Use {@link PowerSyncDatabase} instead, this class is only used by other SDKs also needing web support.
  */
-export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
+export class WebPowerSyncDatabase extends BasePowerSyncDatabase<WebPowerSyncDatabaseOptions> {
   static SHARED_MUTEX = new Mutex();
 
-  protected resolvedFlags: WebPowerSyncFlags;
+  protected resolvedOpenOptions: WebSpecificOpenOptions;
+  protected enableBroadcastLogs: boolean;
 
-  constructor(options: WebPowerSyncDatabaseOptionsWithAdapter);
-  constructor(options: WebPowerSyncDatabaseOptionsWithOpenFactory);
-  constructor(options: WebPowerSyncDatabaseOptionsWithSettings);
-  constructor(options: WebPowerSyncDatabaseOptions);
-  constructor(protected options: WebPowerSyncDatabaseOptions) {
-    super(options);
-
-    assertValidDatabaseOptions(options);
+  constructor(options: WebPowerSyncDatabaseOptions) {
+    const resolvedOpenOptions = resolveAndValidateOptions('database' in options ? options.database : {});
 
-    this.resolvedFlags = resolveWebPowerSyncFlags(options.flags);
+    super(options);
+    this.resolvedOpenOptions = resolvedOpenOptions;
+    this.enableBroadcastLogs = options.broadcastLogs ?? true;
   }
 
   async _initialize(): Promise<void> {
@@ -170,13 +107,14 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     };
   }
 
-  protected openDBAdapter(options: WebPowerSyncDatabaseOptionsWithSettings): DBAdapter {
-    const defaultFactory = new WASQLiteOpenFactory({
-      ...options.database,
-      flags: resolveWebPowerSyncFlags(options.flags),
-      encryptionKey: options.encryptionKey
+  protected override openDBAdapter(): DBAdapter {
+    return openDatabase(this.options, (options) => {
+      const defaultFactory = new WASQLiteOpenFactory({
+        logger: this.logger,
+        open: options
+      });
+      return defaultFactory.openDB();
     });
-    return defaultFactory.openDB();
   }
 
   /**
@@ -187,72 +125,86 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
   close(options?: PowerSyncCloseOptions): Promise<void> {
     return super.close({
       // Don't disconnect by default if multiple tabs are enabled
-      disconnect: options?.disconnect ?? !this.resolvedFlags.enableMultiTabs
+      disconnect: options?.disconnect ?? !this.resolvedOpenOptions.enableMultiTabs
     });
   }
 
   protected async loadVersion(): Promise<void> {
-    if (isServerSide()) {
+    if (this.resolvedOpenOptions.ssrMode) {
       return;
     }
     return super.loadVersion();
   }
 
   protected async resolveOfflineSyncStatus() {
-    if (isServerSide()) {
+    if (this.resolvedOpenOptions.ssrMode) {
       return;
     }
     return super.resolveOfflineSyncStatus();
   }
 
-  protected generateBucketStorageAdapter(): BucketStorageAdapter {
-    return new SqliteBucketStorage(this.database);
-  }
-
   protected async runExclusive<T>(cb: () => Promise<T>) {
-    if (this.resolvedFlags.ssrMode) {
-      return PowerSyncDatabase.SHARED_MUTEX.runExclusive(cb);
+    if (this.resolvedOpenOptions.ssrMode) {
+      return WebPowerSyncDatabase.SHARED_MUTEX.runExclusive(cb);
     }
     return getNavigatorLocks().request(`lock-${this.database.name}`, cb);
   }
 
   protected generateSyncStreamImplementation(
     connector: PowerSyncBackendConnector,
-    options: RequiredAdditionalConnectionOptions
+    options: CreateSyncImplementationOptions
   ): StreamingSyncImplementation {
     const remote = new WebRemote(connector, this.logger);
     const syncOptions: WebStreamingSyncImplementationOptions = {
       ...(this.options as {}),
-      ...options,
-      flags: this.resolvedFlags,
-      adapter: this.bucketStorageAdapter,
-      remote,
-      uploadCrud: async () => {
-        await this.waitForReady();
-        await connector.uploadData(this);
-      },
-      identifier: this.database.name,
-      logger: this.logger
+      ...this.commonSyncOptions(connector, options),
+      remote
     };
 
-    switch (true) {
-      case this.resolvedFlags.ssrMode:
-        return new SSRStreamingSyncImplementation(syncOptions);
-      case this.resolvedFlags.enableMultiTabs:
-        if (!this.resolvedFlags.broadcastLogs) {
-          const warning = `
+    if (this.resolvedOpenOptions.ssrMode) {
+      return new SSRStreamingSyncImplementation();
+    } else if (this.resolvedOpenOptions.enableMultiTabs) {
+      if (!this.enableBroadcastLogs) {
+        const warning = `
             Multiple tabs are enabled, but broadcasting of logs is disabled.
             Logs for shared sync worker will only be available in the shared worker context
           `;
-          const logger = this.options.logger;
-          logger ? logger.warn(warning) : console.warn(warning);
-        }
+        const logger = this.options.logger;
+        logger ? logger.log({ level: LogLevels.warn, message: warning }) : console.warn(warning);
+      }
+
+      if ('shareConnection' in this.database) {
         return new SharedWebStreamingSyncImplementation({
           ...syncOptions,
-          db: this.database as WebDBAdapter // This should always be the case
+          db: this.database as WebDBAdapter, // This should always be the case
+          logLevel: this.options.sync?.logLevel ?? LogLevels.info,
+          enableBroadcastLogs: this.enableBroadcastLogs
         });
-      default:
-        return new WebStreamingSyncImplementation(syncOptions);
+      }
+
+      this.logger.log({
+        level: LogLevels.warn,
+        message: "Not using a shared sync worker because the database adapter doesn't support it."
+      });
     }
+
+    return new TabLocalStreamingSyncImplementation(syncOptions);
   }
 }
+/**
+ * A PowerSync database which provides SQLite functionality
+ * which is automatically synced.
+ *
+ * @example
+ * ```typescript
+ * export const db = new PowerSyncDatabase({
+ *  schema: AppSchema,
+ *  database: {
+ *    dbFilename: 'example.db'
+ *  }
+ * });
+ * ```
+ */
+// Typed constructor to avoid leaking AbstractPowerSyncDatabase into the public interface
+export const PowerSyncDatabase: PowerSyncDatabaseConstructor<WebPowerSyncDatabaseOptions> = WebPowerSyncDatabase;
+export interface PowerSyncDatabase extends CommonPowerSyncDatabase {}

package/src/db/adapters/AsyncWebAdapter.ts

@@ -1,22 +1,15 @@
-import {
-  ConnectionPool,
-  DBAdapterDefaultMixin,
-  DBAdapterListener,
-  DBLockOptions,
-  LockContext,
-  Mutex,
-  Semaphore,
-  UnlockFn
-} from '@powersync/common';
-import { SharedConnectionWorker, WebDBAdapter, WebDBAdapterConfiguration } from './WebDBAdapter.js';
+import { DBAdapter, DBAdapterListener, DBLockOptions, LockContext } from '@powersync/common';
+import { Mutex, Semaphore } from '@powersync/shared-internals';
+import { SharedConnectionWorker, WebDBAdapterConfiguration } from './WebDBAdapter.js';
 import { DatabaseClient } from './wa-sqlite/DatabaseClient.js';
+import { acquireFromPool } from './acquireFromPool.js';
 
 type PendingListener = { listener: Partial<DBAdapterListener>; closeAfterRegisteredOnResolvedPool?: () => void };
 
 /**
  * A connection pool implementation delegating to another pool opened asynchronnously.
  */
-class AsyncConnectionPool implements ConnectionPool {
+export class AsyncDbAdapter extends DBAdapter {
   protected readonly state: Promise<PoolState>;
   protected resolvedWriter?: DatabaseClient;
 
@@ -26,6 +19,7 @@ class AsyncConnectionPool implements ConnectionPool {
     inner: Promise<PoolConnection>,
     readonly name: string
   ) {
+    super();
     this.state = inner.then((client) => {
       for (const pending of this.pendingListeners) {
         pending.closeAfterRegisteredOnResolvedPool = client.writer.registerListener(pending.listener);
@@ -81,6 +75,19 @@ class AsyncConnectionPool implements ConnectionPool {
       };
     }
   }
+
+  async shareConnection(): Promise<SharedConnectionWorker> {
+    const state = await this.state;
+    return state.writer.shareConnection();
+  }
+
+  getConfiguration(): WebDBAdapterConfiguration {
+    if (this.resolvedWriter) {
+      return this.resolvedWriter.getConfiguration();
+    }
+
+    throw new Error('AsyncDbAdapter.getConfiguration() can only be called after initializing it.');
+  }
 }
 
 export interface PoolConnection {
@@ -120,65 +127,16 @@ function readWritePoolState(writer: DatabaseClient, readers: DatabaseClient[]):
   return {
     writer,
     async withConnection(allowReadOnly, fn, options) {
-      const abortController = new AbortController();
-      const abortSignal = abortController.signal;
-
-      let timeout: any = null;
-      let release: UnlockFn | undefined;
-      if (options?.timeoutMs) {
-        timeout = setTimeout(() => abortController.abort, options.timeoutMs);
-      }
-
-      try {
-        if (allowReadOnly) {
-          let connection: DatabaseClient;
-
-          // Even if we have a pool of read connections, it's typically very small and we assume that most queries are
-          // reads. So, we want to request any connection from the read pool and the dedicated write connection (which
-          // can also serve reads). We race for the first connection we can obtain this way, and then abort the other
-          // request.
-          [connection, release] = await new Promise<[DatabaseClient, UnlockFn]>((resolve, reject) => {
-            let didComplete = false;
-            function complete() {
-              didComplete = true;
-              abortController.abort();
-            }
-
-            function completeSuccess(connection: DatabaseClient, returnFn: UnlockFn) {
-              if (didComplete) {
-                // We're not going to use this connection, so return it immediately.
-                returnFn();
-              } else {
-                complete();
-                resolve([connection, returnFn]);
-              }
-            }
-
-            function completeError(error: unknown) {
-              // We either have a working connection already, or we've rejected the promise. Either way, we don't need
-              // to do either thing again.
-              if (didComplete) return;
-
-              complete();
-              reject(error);
-            }
-
-            writerMutex.acquire(abortSignal).then((unlock) => completeSuccess(writer, unlock), completeError);
-            readerSemaphore
-              .requestOne(abortSignal)
-              .then(({ item, release }) => completeSuccess(item, release), completeError);
-          });
-
-          return await connection.readLock(fn);
-        } else {
-          return await writerMutex.runExclusive(() => writer.writeLock(fn), abortSignal);
-        }
-      } finally {
-        if (timeout != null) {
-          clearTimeout(timeout);
-        }
-        release?.();
-      }
+      return acquireFromPool(
+        writerMutex,
+        writer,
+        readerSemaphore,
+        (connection) => {
+          return allowReadOnly ? connection.readLock(fn) : connection.writeLock(fn);
+        },
+        options,
+        allowReadOnly
+      );
     },
     async close() {
       await writer.close();
@@ -190,18 +148,3 @@ function readWritePoolState(writer: DatabaseClient, readers: DatabaseClient[]):
     }
   };
 }
-
-export class AsyncDbAdapter extends DBAdapterDefaultMixin(AsyncConnectionPool) implements WebDBAdapter {
-  async shareConnection(): Promise<SharedConnectionWorker> {
-    const state = await this.state;
-    return state.writer.shareConnection();
-  }
-
-  getConfiguration(): WebDBAdapterConfiguration {
-    if (this.resolvedWriter) {
-      return this.resolvedWriter.getConfiguration();
-    }
-
-    throw new Error('AsyncDbAdapter.getConfiguration() can only be called after initializing it.');
-  }
-}