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

package/lib/worker/worker.js

@@ -0,0 +1,34 @@
+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 { WorkerClient } from './sync/WorkerClient.js';
+const server = new MultiDatabaseServer(createConsoleLogger({ prefix: 'db-worker', minLevel: LogLevels.trace }));
+const exposedDatabaseFunctions = {
+    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;
+    _self.onconnect = (outerEvent) => {
+        const port = outerEvent.ports[0];
+        port.onmessage = (event) => {
+            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);
+}
+//# sourceMappingURL=worker.js.map

package/lib/worker/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","sourceRoot":"","sources":["../../src/worker/worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAEnC,OAAO,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClF,OAAO,EAAE,wBAAwB,EAAE,MAAM,oCAAoC,CAAC;AAG9E,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,MAAM,MAAM,GAAG,IAAI,mBAAmB,CAAC,mBAAmB,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AAEhH,MAAM,wBAAwB,GAAyB;IACrD,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC;IACpD,iBAAiB,EAAE,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,iBAAiB,CAAC,UAAU,EAAE,QAAQ,CAAC;CAChG,CAAC;AAEF,IAAI,cAAc,EAAE,CAAC;IACnB,MAAM,wBAAwB,GAAG,IAAI,wBAAwB,EAAE,CAAC;IAEhE,+FAA+F;IAC/F,kHAAkH;IAClH,6DAA6D;IAC7D,MAAM,KAAK,GAAG,IAA0C,CAAC;IACzD,KAAK,CAAC,SAAS,GAAG,CAAC,UAAwB,EAAE,EAAE;QAC7C,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACjC,IAAI,CAAC,SAAS,GAAG,CAAC,KAAkD,EAAE,EAAE;YACtE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC;YACrC,IAAI,OAAO,KAAK,UAAU,EAAE,CAAC;gBAC3B,OAAO,CAAC,MAAM,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC;YACjD,CAAC;iBAAM,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC;gBAC9B,IAAI,YAAY,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC;YACnD,CAAC;QACH,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;KAAM,CAAC;IACN,yFAAyF;IACzF,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC;AAC3C,CAAC"}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@powersync/web",
-  "version": "0.0.0-dev-20260503073249",
+  "version": "0.0.0-dev-20260630141119",
   "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,22 +18,14 @@
   ],
   "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"
-    },
-    "./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",
@@ -56,36 +48,34 @@
   "license": "Apache-2.0",
   "peerDependencies": {
     "@journeyapps/wa-sqlite": "^1.5.0",
-    "@powersync/common": "0.0.0-dev-20260503073249"
+    "@powersync/common": "0.0.0-dev-20260630141119",
+    "@powersync/shared-internals": "1.0.0"
   },
   "dependencies": {
-    "bson": "^6.10.4",
     "comlink": "^4.4.2",
     "commander": "^12.1.0",
-    "@powersync/common": "0.0.0-dev-20260503073249"
+    "@powersync/common": "0.0.0-dev-20260630141119",
+    "@powersync/shared-internals": "1.0.0"
   },
   "devDependencies": {
     "@journeyapps/wa-sqlite": "^1.7.0",
     "@types/uuid": "^9.0.6",
-    "crypto-browserify": "^3.12.0",
+    "bson": "^6.10.4",
     "glob": "^11.0.0",
     "p-defer": "^4.0.1",
     "source-map-loader": "^5.0.0",
-    "stream-browserify": "^3.0.0",
-    "terser-webpack-plugin": "^5.3.9",
     "uuid": "^11.1.0",
     "vite": "^7.3.1",
-    "vm-browserify": "^1.1.2",
-    "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",

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,32 +1,28 @@
 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';
@@ -35,19 +31,22 @@ import {
   WebStreamingSyncImplementationOptions
 } from './sync/WebStreamingSyncImplementation.js';
 import { AsyncDbAdapter } from './adapters/AsyncWebAdapter.js';
+import { resolveAndValidateOptions } from './adapters/resolveAndValidateOptions.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 +54,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 +109,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,44 +127,43 @@ 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);
+    return new SqliteBucketStorage(this.database, this.logger);
   }
 
   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 () => {
@@ -236,23 +175,42 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     };
 
     switch (true) {
-      case this.resolvedFlags.ssrMode:
-        return new SSRStreamingSyncImplementation(syncOptions);
-      case this.resolvedFlags.enableMultiTabs:
-        if (!this.resolvedFlags.broadcastLogs) {
+      case this.resolvedOpenOptions.ssrMode:
+        return new SSRStreamingSyncImplementation();
+      case 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);
+          logger ? logger.log({ level: LogLevels.warn, message: warning }) : console.warn(warning);
         }
         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);
     }
   }
 }
+/**
+ * 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,13 +1,5 @@
-import {
-  ConnectionPool,
-  DBAdapterDefaultMixin,
-  DBAdapterListener,
-  DBLockOptions,
-  LockContext,
-  Mutex,
-  Semaphore,
-  UnlockFn
-} from '@powersync/common';
+import { DBAdapter, DBAdapterListener, DBLockOptions, LockContext } from '@powersync/common';
+import { Mutex, Semaphore, UnlockFn } from '@powersync/shared-internals';
 import { SharedConnectionWorker, WebDBAdapter, WebDBAdapterConfiguration } from './WebDBAdapter.js';
 import { DatabaseClient } from './wa-sqlite/DatabaseClient.js';
 
@@ -16,7 +8,7 @@ type PendingListener = { listener: Partial<DBAdapterListener>; closeAfterRegiste
 /**
  * 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 +18,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 +74,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 {
@@ -190,18 +196,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.');
-  }
-}

package/src/db/adapters/SSRDBAdapter.ts

@@ -1,17 +1,10 @@
-import {
-  BaseObserver,
-  DBAdapterListener,
-  DBAdapter,
-  DBLockOptions,
-  LockContext,
-  QueryResult,
-  Transaction,
-  Mutex,
-  timeoutSignal
-} from '@powersync/common';
+import { DBAdapter, DBLockOptions, LockContext, RawQueryResult } from '@powersync/common';
+import { Mutex } from '@powersync/shared-internals';
 
-const MOCK_QUERY_RESPONSE: QueryResult = {
-  rowsAffected: 0
+const MOCK_QUERY_RESPONSE: RawQueryResult = {
+  rowsAffected: 0,
+  columnNames: [],
+  rawRows: []
 };
 
 /**
@@ -19,7 +12,7 @@ const MOCK_QUERY_RESPONSE: QueryResult = {
  * This adapter will return empty results for queries, which will allow
  * server rendered views to initially generate scaffolding components
  */
-export class SSRDBAdapter extends BaseObserver<DBAdapterListener> implements DBAdapter {
+export class SSRDBAdapter extends DBAdapter {
   name: string;
   readMutex: Mutex;
   writeMutex: Mutex;
@@ -34,61 +27,18 @@ export class SSRDBAdapter extends BaseObserver<DBAdapterListener> implements DBA
   close() {}
 
   async readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) {
-    return this.readMutex.runExclusive(() => fn(this), timeoutSignal(options?.timeoutMs));
-  }
-
-  async readTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions) {
-    return this.readLock(() => fn(this.generateMockTransactionContext()), options);
+    return fn(new StubLockContext());
   }
 
   async writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) {
-    return this.writeMutex.runExclusive(() => fn(this), timeoutSignal(options?.timeoutMs));
-  }
-
-  async writeTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions) {
-    return this.writeLock(() => fn(this.generateMockTransactionContext()), options);
-  }
-
-  async execute(query: string, params?: any[]): Promise<QueryResult> {
-    return this.writeMutex.runExclusive(async () => MOCK_QUERY_RESPONSE);
-  }
-
-  async executeRaw(query: string, params?: any[]): Promise<any[][]> {
-    return this.writeMutex.runExclusive(async () => []);
-  }
-
-  async executeBatch(query: string, params?: any[][]): Promise<QueryResult> {
-    return this.writeMutex.runExclusive(async () => MOCK_QUERY_RESPONSE);
+    return fn(new StubLockContext());
   }
 
-  async getAll<T>(sql: string, parameters?: any[]): Promise<T[]> {
-    return [];
-  }
-
-  async getOptional<T>(sql: string, parameters?: any[] | undefined): Promise<T | null> {
-    return null;
-  }
-
-  async get<T>(sql: string, parameters?: any[] | undefined): Promise<T> {
-    throw new Error(`No values are returned in SSR mode`);
-  }
+  async refreshSchema(): Promise<void> {}
+}
 
-  /**
-   * Generates a mock context for use in read/write transactions.
-   * `this` already mocks most of the API, commit and rollback mocks
-   *  are added here
-   */
-  private generateMockTransactionContext(): Transaction {
-    return {
-      ...this,
-      commit: async () => {
-        return MOCK_QUERY_RESPONSE;
-      },
-      rollback: async () => {
-        return MOCK_QUERY_RESPONSE;
-      }
-    };
+class StubLockContext extends LockContext {
+  async executeRaw(): Promise<RawQueryResult> {
+    return MOCK_QUERY_RESPONSE;
   }
-
-  async refreshSchema(): Promise<void> {}
 }

package/src/db/adapters/WebDBAdapter.ts

@@ -1,5 +1,5 @@
 import { DBAdapter } from '@powersync/common';
-import { ResolvedWebSQLOpenOptions } from './web-sql-flags.js';
+import { ResolvedWebSQLOpenOptions } from './options.js';
 
 export type SharedConnectionWorker = {
   identifier: string;