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

package/src/db/adapters/memory-pool/vfs.ts

@@ -0,0 +1,293 @@
+// @ts-ignore
+import { FacadeVFS } from '@journeyapps/wa-sqlite/src/FacadeVFS.js';
+import * as VFS from '@journeyapps/wa-sqlite/src/VFS.js';
+import { emptyWalState, WalIndexChange, WalOverlayEntry, WriteAheadBuffers, WriteAheadState } from './shared.js';
+
+const mainDbSentinel = Symbol();
+
+export class InMemoryWriteAheadLog extends FacadeVFS {
+  // The main /database file is the only file for which we create a write-ahead log. All other files (including the
+  // journal) are local-only.
+  #openedFiles = new Map<number, LocalFile | typeof mainDbSentinel>();
+  #files = new Map<string, LocalFile | typeof mainDbSentinel>();
+
+  #tx: WriteAheadTransaction | undefined = undefined;
+  #newOverlayPagesToSendToMainTab = new Map<number, WalOverlayEntry>();
+
+  writeAheadState: WriteAheadState = emptyWalState();
+
+  constructor(
+    module: any,
+    readonly buffers: WriteAheadBuffers
+  ) {
+    super('InMemoryWriteAheadLog', module);
+    this.#files.set('/database', mainDbSentinel);
+  }
+
+  takeChanges(): WalIndexChange {
+    const added: (number | WalOverlayEntry)[] = [];
+    this.#newOverlayPagesToSendToMainTab.forEach((v, k) => {
+      added.push(k);
+      added.push(v);
+    });
+    this.#newOverlayPagesToSendToMainTab.clear();
+
+    return {
+      cleared: false,
+      walEnd: this.writeAheadState.walEnd,
+      fileSize: this.writeAheadState.fileSize,
+      added
+    };
+  }
+
+  jAccess(zName: string, _pFlags: number, pResOut: DataView) {
+    const file = this.#files.get(zName);
+    pResOut.setInt32(0, file != null ? 1 : 0, true);
+    return VFS.SQLITE_OK;
+  }
+
+  jOpen(zName: string | null, fileId: number, flags: number, pOutFlags: DataView): number {
+    if (flags & VFS.SQLITE_OPEN_MAIN_DB) {
+      this.#openedFiles.set(fileId, mainDbSentinel);
+    } else {
+      // Treat all other files, including the mostly unused journal as temporary.
+      zName ??= `tmp-${crypto.randomUUID()}`;
+
+      const existing = this.#files.get(zName);
+      if (existing != null) {
+        this.#openedFiles.set(fileId, existing);
+      } else {
+        if (!(flags & VFS.SQLITE_OPEN_CREATE)) {
+          return VFS.SQLITE_IOERR;
+        }
+
+        const newFile = new LocalFile(zName);
+        newFile.deleteOnClose = (flags & VFS.SQLITE_OPEN_DELETEONCLOSE) != 0;
+        this.#openedFiles.set(fileId, newFile);
+        this.#files.set(zName, newFile);
+      }
+    }
+
+    pOutFlags.setInt32(0, flags, true);
+    return VFS.SQLITE_OK;
+  }
+
+  jClose(fileid: number) {
+    const file = this.#openedFiles.get(fileid)!;
+    this.#openedFiles.delete(fileid);
+
+    if (file != mainDbSentinel && file.deleteOnClose) {
+      this.#files.delete(file.name);
+    }
+
+    return VFS.SQLITE_OK;
+  }
+
+  jRead(fileId: number, data: Uint8Array, offset: number) {
+    const file = this.#openedFiles.get(fileId)!;
+    let endOffset: number;
+    let readableBytes: number;
+
+    if (file == mainDbSentinel) {
+      const { fileSize, overlay } = this.writeAheadState;
+      const startOffset = Math.min(offset, fileSize);
+      endOffset = Math.min(fileSize, offset + data.byteLength);
+      readableBytes = endOffset - startOffset;
+
+      // Try reading from the write-ahead overlay first. A read on the database file is always a complete page, except
+      // when reading from the 100-byte header.
+      const page = overlay.get(offset < 100 ? 0 : offset);
+
+      if (page != null) {
+        const pageOffset = page.logOffset;
+        const source = new Uint8Array(
+          this.buffers.writeAheadLog,
+          offset < 100 ? pageOffset + offset : pageOffset,
+          readableBytes
+        );
+        data.set(source);
+      } else {
+        // Page is not in WAL overlay, read directly from underlying in-memory buffer.
+        data.set(new Uint8Array(this.buffers.database, startOffset, readableBytes));
+      }
+    } else {
+      const fileSize = file.size;
+      const startOffset = Math.min(offset, fileSize);
+      endOffset = Math.min(fileSize, offset + data.byteLength);
+      readableBytes = endOffset - startOffset;
+
+      if (readableBytes > 0) {
+        data.set(new Uint8Array(file.buffer, startOffset, readableBytes));
+      }
+    }
+
+    if (readableBytes < data.byteLength) {
+      data.fill(0, readableBytes); // Fill rest with zeroes.
+      return VFS.SQLITE_IOERR_SHORT_READ;
+    }
+
+    return VFS.SQLITE_OK;
+  }
+
+  jWrite(fileId: number, data: Uint8Array, offset: number): number {
+    const file = this.#openedFiles.get(fileId)!;
+    // wa-sqlite passes a proxy instead of a real Uint8Array.
+    const actualBuffer = data.subarray();
+
+    if (file === mainDbSentinel) {
+      // Write to the write-ahead overlay.
+      let didWrite = false;
+      if (this.#tx != null) {
+        didWrite = this.#tx.appendPage(offset, actualBuffer);
+      } else {
+        const tx = new WriteAheadTransaction(this.writeAheadState.walEnd, this.writeAheadState.fileSize, this.buffers);
+        didWrite = tx.appendPage(offset, actualBuffer);
+        this.#commit(tx);
+      }
+
+      return didWrite ? VFS.SQLITE_OK : VFS.SQLITE_FULL;
+    } else {
+      const writeLength = data.length;
+      const endOffset = offset + writeLength;
+      if (endOffset > file.buffer.byteLength) {
+        const didGrow = file.growBuffer(endOffset);
+        if (!didGrow) {
+          return VFS.SQLITE_FULL;
+        }
+      }
+
+      new Uint8Array(file.buffer, offset, writeLength).set(actualBuffer);
+      file.size = Math.max(file.size, endOffset);
+      return VFS.SQLITE_OK;
+    }
+  }
+
+  jTruncate(fileid: number, size: number): number {
+    const file = this.#openedFiles.get(fileid)!;
+
+    if (file === mainDbSentinel) {
+      this.writeAheadState.fileSize = Math.min(this.writeAheadState.fileSize, size);
+    } else {
+      file.size = Math.min(size, file.size);
+    }
+
+    return VFS.SQLITE_OK;
+  }
+
+  jFileSize(fileid: number, pSize64: DataView) {
+    const file = this.#openedFiles.get(fileid)!;
+
+    if (file === mainDbSentinel) {
+      pSize64.setBigInt64(0, BigInt(this.writeAheadState.fileSize), true);
+    } else {
+      pSize64.setBigInt64(0, BigInt(file.size), true);
+    }
+
+    return VFS.SQLITE_OK;
+  }
+
+  jDelete(name: string) {
+    if (name === '/database') {
+      return VFS.SQLITE_IOERR_DELETE;
+    }
+
+    this.#files.delete(name);
+    return VFS.SQLITE_OK;
+  }
+
+  jDeviceCharacteristics(): number {
+    return VFS.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN | VFS.SQLITE_IOCAP_BATCH_ATOMIC;
+  }
+
+  jFileControl(fileid: number, op: number) {
+    const file = this.#openedFiles.get(fileid)!;
+    if (file !== mainDbSentinel) return VFS.SQLITE_NOTFOUND;
+
+    switch (op) {
+      case VFS.SQLITE_FCNTL_BEGIN_ATOMIC_WRITE:
+        this.#tx = new WriteAheadTransaction(this.writeAheadState.walEnd, this.writeAheadState.fileSize, this.buffers);
+        break;
+      case VFS.SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE:
+        this.#tx = undefined;
+        break;
+      case VFS.SQLITE_FCNTL_COMMIT_ATOMIC_WRITE:
+        this.#commit(this.#tx!);
+        this.#tx = undefined;
+        break;
+      default:
+        return VFS.SQLITE_NOTFOUND;
+    }
+
+    return VFS.SQLITE_OK;
+  }
+
+  #commit(tx: WriteAheadTransaction) {
+    this.writeAheadState.walEnd = tx.walEndOffset;
+    this.writeAheadState.fileSize = tx.fileSize;
+    tx.changedPages.forEach((walEntry, databaseOffset) => {
+      this.#newOverlayPagesToSendToMainTab.set(databaseOffset, walEntry);
+      this.writeAheadState.overlay.set(databaseOffset, walEntry);
+    });
+  }
+}
+
+class WriteAheadTransaction {
+  walEndOffset: number;
+  fileSize: number;
+  changedPages = new Map<number, WalOverlayEntry>();
+
+  constructor(
+    endOffset: number,
+    fileSize: number,
+    readonly buffers: WriteAheadBuffers
+  ) {
+    this.walEndOffset = endOffset;
+    this.fileSize = fileSize;
+  }
+
+  appendPage(offset: number, data: Uint8Array): boolean {
+    const currentEnd = this.walEndOffset;
+    const newEnd = currentEnd + data.length;
+
+    const wal = this.buffers.writeAheadLog;
+    if (newEnd > wal.byteLength) {
+      if (!this.#growWal(wal, newEnd)) return false;
+    }
+    this.fileSize = Math.max(this.fileSize, offset + data.length);
+    new Uint8Array(wal, currentEnd, data.length).set(data);
+
+    this.walEndOffset = newEnd;
+    this.changedPages.set(offset, { logOffset: currentEnd, size: data.length });
+    return true;
+  }
+
+  #growWal(buffer: SharedArrayBuffer, minSize: number) {
+    const newSize = Math.max(minSize, Math.min(2 * buffer.byteLength, buffer.maxByteLength));
+    if (newSize > buffer.maxByteLength) {
+      return false;
+    }
+
+    buffer.grow(newSize);
+    return true;
+  }
+}
+
+class LocalFile {
+  deleteOnClose = false;
+  name: string;
+  buffer = new ArrayBuffer(1024);
+  size: number = 0;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  growBuffer(minSize: number): boolean {
+    const newSize = Math.max(minSize, 2 * this.buffer.byteLength);
+    const newBuffer = new ArrayBuffer(newSize);
+
+    new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
+    this.buffer = newBuffer;
+    return true;
+  }
+}

package/src/db/adapters/memory-pool/worker.ts

@@ -0,0 +1,53 @@
+import * as Comlink from 'comlink';
+import { applyWalChanges, DatabaseServer, WalIndexChange, WriteAheadBuffers } from './shared.js';
+import { RawQueryResult } from '@powersync/common';
+import { InMemoryWriteAheadLog } from './vfs.js';
+import { RawSqliteConnection, RawWaSqliteDatabaseOptions, RawWebResult } from '../wa-sqlite/RawSqliteConnection.js';
+import { WASQLiteVFS } from '../wa-sqlite/vfs.js';
+import { TemporaryStorageOption } from '../options.js';
+
+class MemoryDatabaseServer implements DatabaseServer {
+  #vfs!: InMemoryWriteAheadLog;
+  #connection!: RawSqliteConnection;
+
+  async open(buffers: WriteAheadBuffers, options: Partial<RawWaSqliteDatabaseOptions>): Promise<void> {
+    const { default: factory } = await import('@journeyapps/wa-sqlite/dist/wa-sqlite.mjs');
+    const module = await factory();
+    const vfs = (this.#vfs = new InMemoryWriteAheadLog(module, buffers));
+
+    const connection = new RawSqliteConnection({
+      encryptionKey: undefined,
+      vfs: WASQLiteVFS.InMemoryVfs,
+      // Unused, since we register our own VFS. Only needed to satisfy the type.
+      temporaryStorage: TemporaryStorageOption.MEMORY,
+      cacheSizeKb: 50 * 1024,
+      preparedStatementsCache: 0,
+      ...options,
+      // The rest of these options is not overridable: The VFS handles /database reads and writes in a special way and
+      // there can only be one database per buffers instance.
+      filename: '/database',
+      readonly: false
+    });
+    await connection.initWithModule(module, vfs);
+    this.#connection = connection;
+  }
+
+  async updateWalState(overlay: WalIndexChange): Promise<void> {
+    const currentState = this.#vfs.writeAheadState;
+    applyWalChanges(currentState, overlay);
+  }
+
+  async executeRaw(query: string, params?: any[] | undefined): Promise<RawQueryResult> {
+    return await this.#connection.execute(query, params);
+  }
+
+  async executeBatch(query: string, params: any[][]): Promise<RawWebResult[]> {
+    return await this.#connection.executeBatch(query, params);
+  }
+
+  async takeWalChanges(): Promise<WalIndexChange> {
+    return this.#vfs.takeChanges();
+  }
+}
+
+Comlink.expose(new MemoryDatabaseServer());

package/src/db/adapters/options.ts

@@ -0,0 +1,108 @@
+import { LogLevels, SQLOpenOptions } from '@powersync/common';
+import { WASQLiteVFS } from './wa-sqlite/vfs.js';
+
+export interface WebSpecificOpenOptions {
+  /**
+   * 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.
+   *
+   * Enabling multi-tab support will transparently make PowerSync manage the sync process in a shared worker collecting
+   * Sync Streams across tabs. Additionally, it enables a shared worker for IndexedDB databases.
+   *
+   * It is still valid to open multiple tabs when this option is disabled, but the experience may be degrated as only
+   * one tab can sync at the time.
+   *
+   * This is enabled by default on Desktop browsers if shared workers are enabled, except for Safari.
+   */
+  enableMultiTabs: boolean;
+
+  /**
+   * The SQLite connection is often executed through a web worker in order to offload computation and because some file
+   * system implementations (notably those based on web filesystem APIs like OPFS) are only available in workers.
+   *
+   * Manually disabling the use of web workers is not recommended, but can be useful for testing or for environments
+   * or toolchains where web workers are not supported.
+   */
+  useWebWorker: boolean;
+
+  /**
+   * Open in SSR placeholder mode. DB operations and Sync operations will be a No-op
+   */
+  ssrMode: boolean;
+
+  /**
+   * The log level for database workers.
+   *
+   * Defaults to {@link LogLevels.info}.
+   */
+  databaseWorkerLogLevel: number;
+
+  /**
+   * Where to store SQLite temporary files. Defaults to 'MEMORY'.
+   * Setting this to `FILESYSTEM` can cause issues with larger queries or datasets.
+   */
+  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 | undefined;
+
+  vfs: WASQLiteVFS;
+
+  /**
+   * If the {@link vfs} supports it, an additional amount of read-only connections to open. Using additional read
+   * connections can speed up queries by dispatching them to multiple workers running them concurrently.
+   *
+   * {@link WASQLiteVFS.OPFSWriteAheadVFS} is the only VFS with support for multiple connections, so this option is
+   * ignored for other VFS implementations.
+   *
+   * Defaults to 1.
+   */
+  additionalReaders: number;
+
+  /**
+   * 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 | undefined;
+
+  /**
+   * If set to a value greater than zero, the worker will cache prepared statements to avoid preparing them every time
+   * a query runs.
+   *
+   * Defaults to 0 (disabling the cache).
+   */
+  preparedStatementsCache?: number;
+}
+
+export interface ResolvedWebSQLOpenOptions extends SQLOpenOptions, WebSpecificOpenOptions {}
+
+export interface WebSQLOpenOptions extends SQLOpenOptions, Partial<WebSpecificOpenOptions> {}
+
+export enum TemporaryStorageOption {
+  MEMORY = 'memory',
+  FILESYSTEM = 'file'
+}

package/src/db/adapters/resolveAndValidateOptions.ts

@@ -0,0 +1,49 @@
+import { LogLevels } from '@powersync/common';
+import { TemporaryStorageOption, WebSpecificOpenOptions } from './options.js';
+import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from './wa-sqlite/vfs.js';
+
+/**
+ * The maximum length of a db filename we support.
+ *
+ * We configure the same on WA-SQLite (which otherwise defaults to a maximum length of 64). We don't want to support
+ * very long path names as Safari maps OPFS files directly to OS files, and APFS has a 255-byte filename limit. Since
+ * some VFS append additional characters for pooled file access handles, we want to stay well below that.
+ */
+export const maxPathNameLength = 128;
+
+/**
+ * @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/db/adapters/wa-sqlite/ConcurrentConnection.ts

@@ -1,6 +1,5 @@
-import { Mutex, UnlockFn } from '@powersync/common';
-import { RawSqliteConnection } from './RawSqliteConnection.js';
-import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
+import { Mutex, UnlockFn } from '@powersync/shared-internals';
+import { RawSqliteConnection, RawWaSqliteDatabaseOptions } from './RawSqliteConnection.js';
 
 /**
  * A wrapper around a {@link RawSqliteConnection} allowing multiple tabs to access it.
@@ -33,7 +32,7 @@ export class ConcurrentSqliteConnection {
     this.leaseMutex = needsNavigatorLocks ? null : new Mutex();
   }
 
-  get options(): ResolvedWASQLiteOpenFactoryOptions {
+  get options(): RawWaSqliteDatabaseOptions {
     return this.inner.options;
   }
 
@@ -46,7 +45,7 @@ export class ConcurrentSqliteConnection {
       const options: LockOptions = { signal: abort };
 
       navigator.locks
-        .request(`db-lock-${this.options.dbFilename}`, options, (_) => {
+        .request(`db-lock-${this.options.filename}`, options, (_) => {
           return new Promise<void>((returnLock) => {
             return resolve(() => {
               returnLock();

package/src/db/adapters/wa-sqlite/DatabaseClient.ts

@@ -2,23 +2,22 @@ import {
   QueryResult,
   LockContext,
   DBLockOptions,
-  DBAdapterListener,
-  ConnectionPool,
   SqlExecutor,
-  DBGetUtilsDefaultMixin,
   BatchedUpdateNotification,
-  BaseObserver,
-  ConnectionClosedError,
-  SQLOpenOptions
+  SQLOpenOptions,
+  DBAdapter,
+  RawQueryResult,
+  queryResultWithoutRows,
+  BaseQueryResult
 } from '@powersync/common';
 import { SharedConnectionWorker, WebDBAdapterConfiguration } from '../WebDBAdapter.js';
 import { ClientConnectionView } from './DatabaseServer.js';
-import { RawQueryResult } from './RawSqliteConnection.js';
 import * as Comlink from 'comlink';
-import { WorkerDBOpenerOptions } from './WASQLiteOpenFactory.js';
+import type { ConnectToMultiDatabaseServerOptions } from '../../../worker/db/MultiDatabaseServer.js';
+import { ConnectionClosedError } from '@powersync/shared-internals';
 
 export interface OpenWorkerConnection {
-  connect(config: WorkerDBOpenerOptions): Promise<ClientConnectionView>;
+  connect(config: ConnectToMultiDatabaseServerOptions): Promise<ClientConnectionView>;
   connectToExisting(options: { identifier: string; lockName: string }): Promise<ClientConnectionView>;
 }
 
@@ -44,10 +43,7 @@ export interface ClientOptions {
 /**
  * A single-connection {@link ConnectionPool} implementation based on a worker connection.
  */
-export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfiguration>
-  extends BaseObserver<DBAdapterListener>
-  implements ConnectionPool
-{
+export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfiguration> extends DBAdapter {
   #connection: ConnectionState;
   #shareConnectionAbortController = new AbortController();
   #receiveTableUpdates: MessagePort;
@@ -70,9 +66,7 @@ export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfigur
     port2.onmessage = (event) => {
       const tables = event.data as string[];
       const notification: BatchedUpdateNotification = {
-        tables,
-        groupedUpdates: {},
-        rawUpdates: []
+        tables
       };
       this.iterateListeners((l) => {
         l.tablesUpdated && l.tablesUpdated(notification);
@@ -185,16 +179,17 @@ export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfigur
 }
 
 /**
- * A {@link SqlExecutor} implemented by sending commands to a worker.
+ * A {@link LockContext} implemented by sending commands to a worker.
  *
  * While an instance is active, it has exclusive access to the underlying database connection (as represented by its
  * token).
  */
-class ClientSqlExecutor implements SqlExecutor {
+class ClientLockContext extends LockContext {
   readonly #connection: ConnectionState;
   readonly #token: string;
 
   constructor(connection: ConnectionState, token: string) {
+    super();
     this.#connection = connection;
     this.#token = token;
   }
@@ -223,37 +218,8 @@ class ClientSqlExecutor implements SqlExecutor {
     }
   }
 
-  async execute(query: string, params?: any[] | undefined): Promise<QueryResult> {
-    const rs = await this.#executeOnWorker(query, params);
-    let rows: QueryResult['rows'] | undefined;
-    if (rs.resultSet) {
-      const resultSet = rs.resultSet;
-
-      function rowToJavaScriptObject(row: any[]): Record<string, any> {
-        const obj: Record<string, any> = {};
-        resultSet.columns.forEach((key, idx) => (obj[key] = row[idx]));
-        return obj;
-      }
-
-      const mapped = resultSet.rows.map(rowToJavaScriptObject);
-
-      rows = {
-        _array: mapped,
-        length: mapped.length,
-        item: (idx: number) => mapped[idx]
-      };
-    }
-
-    return {
-      rowsAffected: rs.changes,
-      insertId: rs.lastInsertRowId,
-      rows
-    };
-  }
-
-  async executeRaw(query: string, params?: any[] | undefined): Promise<any[][]> {
-    const rs = await this.#executeOnWorker(query, params);
-    return rs.resultSet?.rows ?? [];
+  async executeRaw(query: string, params?: any[] | undefined): Promise<RawQueryResult> {
+    return await this.#executeOnWorker(query, params);
   }
 
   async #executeOnWorker(query: string, params: any[] | undefined): Promise<RawQueryResult> {
@@ -263,23 +229,21 @@ class ClientSqlExecutor implements SqlExecutor {
     );
   }
 
-  async executeBatch(query: string, params: any[][] = []): Promise<QueryResult> {
+  async executeBatch(query: string, params: any[][] = []): Promise<QueryResult<never>> {
     const results = await this.maybeTrace(
       (c) => c.executeBatch(this.#token, query, params),
       () => `${query} (batch of ${params.length})`
     );
-    const result: QueryResult = { insertId: undefined, rowsAffected: 0 };
+    const result: BaseQueryResult = { insertId: undefined, rowsAffected: 0 };
     for (const source of results) {
-      result.insertId = source.lastInsertRowId;
-      result.rowsAffected += source.changes;
+      result.insertId = source.insertId;
+      result.rowsAffected = (result.rowsAffected ?? 0) + source.rowsAffected;
     }
 
-    return result;
+    return queryResultWithoutRows(result);
   }
 }
 
-class ClientLockContext extends DBGetUtilsDefaultMixin(ClientSqlExecutor) implements LockContext {}
-
 interface ConnectionState {
   connection: ClientConnectionView;
   notifyRemoteClosed: AbortController | undefined;