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

package/src/db/adapters/AbstractWebPowerSyncDatabaseOpenFactory.ts

@@ -0,0 +1,47 @@
+import {
+  AbstractPowerSyncDatabase,
+  AbstractPowerSyncDatabaseOpenFactory,
+  PowerSyncDatabaseOptions,
+  PowerSyncOpenFactoryOptions
+} from '@powersync/common';
+import {
+  PowerSyncDatabase,
+  WebPowerSyncDatabaseOptions,
+  WebPowerSyncFlags,
+  resolveWebPowerSyncFlags
+} from '../../db/PowerSyncDatabase.js';
+
+/**
+ * {@link WebPowerSyncFlags}
+ * Maintaining export for consistency with API from previous versions
+ *  */
+export interface WebPowerSyncOpenFlags extends WebPowerSyncFlags {}
+
+export interface WebPowerSyncOpenFactoryOptions extends PowerSyncOpenFactoryOptions {
+  flags?: WebPowerSyncOpenFlags;
+}
+
+/**
+ * Intermediate PowerSync Database Open factory for Web which uses a mock
+ * SSR DB Adapter if running on server side.
+ * Most SQLite DB implementations only run on client side, this will safely return
+ * empty query results in SSR which will allow for generating server partial views.
+ */
+export abstract class AbstractWebPowerSyncDatabaseOpenFactory extends AbstractPowerSyncDatabaseOpenFactory {
+  constructor(protected options: WebPowerSyncOpenFactoryOptions) {
+    super(options);
+  }
+
+  generateOptions(): WebPowerSyncDatabaseOptions {
+    return {
+      ...this.options,
+      database: this.openDB(),
+      schema: this.schema,
+      flags: resolveWebPowerSyncFlags(this.options.flags)
+    };
+  }
+
+  generateInstance(options: PowerSyncDatabaseOptions): AbstractPowerSyncDatabase {
+    return new PowerSyncDatabase(options);
+  }
+}

package/src/db/adapters/AsyncWebAdapter.ts

@@ -1,5 +1,13 @@
-import { DBAdapter, DBAdapterListener, DBLockOptions, LockContext } from '@powersync/common';
-import { Mutex, Semaphore, UnlockFn } from '@powersync/shared-internals';
+import {
+  ConnectionPool,
+  DBAdapterDefaultMixin,
+  DBAdapterListener,
+  DBLockOptions,
+  LockContext,
+  Mutex,
+  Semaphore,
+  UnlockFn
+} from '@powersync/common';
 import { SharedConnectionWorker, WebDBAdapter, WebDBAdapterConfiguration } from './WebDBAdapter.js';
 import { DatabaseClient } from './wa-sqlite/DatabaseClient.js';
 
@@ -8,7 +16,7 @@ type PendingListener = { listener: Partial<DBAdapterListener>; closeAfterRegiste
 /**
  * A connection pool implementation delegating to another pool opened asynchronnously.
  */
-export class AsyncDbAdapter extends DBAdapter {
+class AsyncConnectionPool implements ConnectionPool {
   protected readonly state: Promise<PoolState>;
   protected resolvedWriter?: DatabaseClient;
 
@@ -18,7 +26,6 @@ export class AsyncDbAdapter extends DBAdapter {
     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);
@@ -74,19 +81,6 @@ export class AsyncDbAdapter extends DBAdapter {
       };
     }
   }
-
-  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 {
@@ -196,3 +190,18 @@ 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,10 +1,17 @@
-import { DBAdapter, DBLockOptions, LockContext, RawQueryResult } from '@powersync/common';
-import { Mutex } from '@powersync/shared-internals';
+import {
+  BaseObserver,
+  DBAdapterListener,
+  DBAdapter,
+  DBLockOptions,
+  LockContext,
+  QueryResult,
+  Transaction,
+  Mutex,
+  timeoutSignal
+} from '@powersync/common';
 
-const MOCK_QUERY_RESPONSE: RawQueryResult = {
-  rowsAffected: 0,
-  columnNames: [],
-  rawRows: []
+const MOCK_QUERY_RESPONSE: QueryResult = {
+  rowsAffected: 0
 };
 
 /**
@@ -12,7 +19,7 @@ const MOCK_QUERY_RESPONSE: RawQueryResult = {
  * This adapter will return empty results for queries, which will allow
  * server rendered views to initially generate scaffolding components
  */
-export class SSRDBAdapter extends DBAdapter {
+export class SSRDBAdapter extends BaseObserver<DBAdapterListener> implements DBAdapter {
   name: string;
   readMutex: Mutex;
   writeMutex: Mutex;
@@ -27,18 +34,61 @@ export class SSRDBAdapter extends DBAdapter {
   close() {}
 
   async readLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) {
-    return fn(new StubLockContext());
+    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);
   }
 
   async writeLock<T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) {
-    return fn(new StubLockContext());
+    return this.writeMutex.runExclusive(() => fn(this), timeoutSignal(options?.timeoutMs));
   }
 
-  async refreshSchema(): Promise<void> {}
-}
+  async writeTransaction<T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions) {
+    return this.writeLock(() => fn(this.generateMockTransactionContext()), options);
+  }
 
-class StubLockContext extends LockContext {
-  async executeRaw(): Promise<RawQueryResult> {
-    return MOCK_QUERY_RESPONSE;
+  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);
+  }
+
+  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`);
+  }
+
+  /**
+   * 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;
+      }
+    };
+  }
+
+  async refreshSchema(): Promise<void> {}
 }

package/src/db/adapters/WebDBAdapter.ts

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

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

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

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

@@ -2,22 +2,23 @@ import {
   QueryResult,
   LockContext,
   DBLockOptions,
+  DBAdapterListener,
+  ConnectionPool,
   SqlExecutor,
+  DBGetUtilsDefaultMixin,
   BatchedUpdateNotification,
-  SQLOpenOptions,
-  DBAdapter,
-  RawQueryResult,
-  queryResultWithoutRows,
-  BaseQueryResult
+  BaseObserver,
+  ConnectionClosedError,
+  SQLOpenOptions
 } 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 type { ConnectToMultiDatabaseServerOptions } from '../../../worker/db/MultiDatabaseServer.js';
-import { ConnectionClosedError } from '@powersync/shared-internals';
+import { WorkerDBOpenerOptions } from './WASQLiteOpenFactory.js';
 
 export interface OpenWorkerConnection {
-  connect(config: ConnectToMultiDatabaseServerOptions): Promise<ClientConnectionView>;
+  connect(config: WorkerDBOpenerOptions): Promise<ClientConnectionView>;
   connectToExisting(options: { identifier: string; lockName: string }): Promise<ClientConnectionView>;
 }
 
@@ -43,7 +44,10 @@ export interface ClientOptions {
 /**
  * A single-connection {@link ConnectionPool} implementation based on a worker connection.
  */
-export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfiguration> extends DBAdapter {
+export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfiguration>
+  extends BaseObserver<DBAdapterListener>
+  implements ConnectionPool
+{
   #connection: ConnectionState;
   #shareConnectionAbortController = new AbortController();
   #receiveTableUpdates: MessagePort;
@@ -66,7 +70,9 @@ export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfigur
     port2.onmessage = (event) => {
       const tables = event.data as string[];
       const notification: BatchedUpdateNotification = {
-        tables
+        tables,
+        groupedUpdates: {},
+        rawUpdates: []
       };
       this.iterateListeners((l) => {
         l.tablesUpdated && l.tablesUpdated(notification);
@@ -179,17 +185,16 @@ export class DatabaseClient<Config extends SQLOpenOptions = WebDBAdapterConfigur
 }
 
 /**
- * A {@link LockContext} implemented by sending commands to a worker.
+ * A {@link SqlExecutor} 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 ClientLockContext extends LockContext {
+class ClientSqlExecutor implements SqlExecutor {
   readonly #connection: ConnectionState;
   readonly #token: string;
 
   constructor(connection: ConnectionState, token: string) {
-    super();
     this.#connection = connection;
     this.#token = token;
   }
@@ -218,8 +223,37 @@ class ClientLockContext extends LockContext {
     }
   }
 
-  async executeRaw(query: string, params?: any[] | undefined): Promise<RawQueryResult> {
-    return await this.#executeOnWorker(query, params);
+  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 #executeOnWorker(query: string, params: any[] | undefined): Promise<RawQueryResult> {
@@ -229,21 +263,23 @@ class ClientLockContext extends LockContext {
     );
   }
 
-  async executeBatch(query: string, params: any[][] = []): Promise<QueryResult<never>> {
+  async executeBatch(query: string, params: any[][] = []): Promise<QueryResult> {
     const results = await this.maybeTrace(
       (c) => c.executeBatch(this.#token, query, params),
       () => `${query} (batch of ${params.length})`
     );
-    const result: BaseQueryResult = { insertId: undefined, rowsAffected: 0 };
+    const result: QueryResult = { insertId: undefined, rowsAffected: 0 };
     for (const source of results) {
-      result.insertId = source.insertId;
-      result.rowsAffected = (result.rowsAffected ?? 0) + source.rowsAffected;
+      result.insertId = source.lastInsertRowId;
+      result.rowsAffected += source.changes;
     }
 
-    return queryResultWithoutRows(result);
+    return result;
   }
 }
 
+class ClientLockContext extends DBGetUtilsDefaultMixin(ClientSqlExecutor) implements LockContext {}
+
 interface ConnectionState {
   connection: ClientConnectionView;
   notifyRemoteClosed: AbortController | undefined;

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

@@ -1,11 +1,11 @@
-import { LogLevels, PowerSyncLogger } from '@powersync/common';
+import { ILogger } from '@powersync/common';
 import { ConcurrentSqliteConnection, ConnectionLeaseToken } from './ConcurrentConnection.js';
-import { RawWebResult } from './RawSqliteConnection.js';
+import { RawQueryResult } from './RawSqliteConnection.js';
 
 export interface DatabaseServerOptions {
   inner: ConcurrentSqliteConnection;
   onClose: () => void;
-  logger: PowerSyncLogger;
+  logger: ILogger;
 }
 
 /**
@@ -24,7 +24,7 @@ export class DatabaseServer {
   constructor(options: DatabaseServerOptions) {
     this.#options = options;
     const inner = options.inner;
-    this.#updateBroadcastChannel = new BroadcastChannel(`${inner.options.filename}-table-updates`);
+    this.#updateBroadcastChannel = new BroadcastChannel(`${inner.options.dbFilename}-table-updates`);
 
     this.#updateBroadcastChannel.onmessage = ({ data }) => {
       this.#pushTableUpdateToClients(data as string[]);
@@ -85,7 +85,7 @@ export class DatabaseServer {
 
         // If the client holds a connection lease it hasn't returned, return that now.
         for (const { lease } of connectionLeases.values()) {
-          this.#logger.log({ level: LogLevels.debug, message: `Closing connection lease that hasn't been returned.` });
+          this.#logger.debug(`Closing connection lease that hasn't been returned.`);
           await lease.returnLease();
         }
 
@@ -94,10 +94,7 @@ export class DatabaseServer {
         if (this.#activeClients.size == 0) {
           await this.forceClose();
         } else {
-          this.#logger.log({
-            level: LogLevels.debug,
-            message: 'Keeping underlying connection active since its used by other clients.'
-          });
+          this.#logger.debug('Keeping underlying connection active since its used by other clients.');
         }
       }
     };
@@ -136,9 +133,9 @@ export class DatabaseServer {
         try {
           if (lease.write) {
             // Collect update hooks invoked while the client had the write connection.
-            const { rawRows } = await lease.lease.use((conn) => conn.execute(`SELECT powersync_update_hooks('get')`));
-            if (rawRows.length) {
-              const updatedTables: string[] = JSON.parse(rawRows[0][0] as string);
+            const { resultSet } = await lease.lease.use((conn) => conn.execute(`SELECT powersync_update_hooks('get')`));
+            if (resultSet) {
+              const updatedTables: string[] = JSON.parse(resultSet.rows[0][0] as string);
               if (updatedTables.length) {
                 this.#updateBroadcastChannel.postMessage(updatedTables);
                 this.#pushTableUpdateToClients(updatedTables);
@@ -172,7 +169,7 @@ export class DatabaseServer {
   }
 
   async forceClose() {
-    this.#logger.log({ level: LogLevels.debug, message: `Closing connection to ${this.#inner.options}.` });
+    this.#logger.debug(`Closing connection to ${this.#inner.options}.`);
     const connection = this.#inner;
     this.#options.onClose();
     this.#updateBroadcastChannel.close();
@@ -193,8 +190,8 @@ export interface ClientConnectionView {
    * give other clients access to the database afterwards.
    */
   requestAccess(write: boolean, timeoutMs?: number): Promise<string>;
-  execute(token: string, sql: string, params: any[] | undefined): Promise<RawWebResult>;
-  executeBatch(token: string, sql: string, params: any[][]): Promise<RawWebResult[]>;
+  execute(token: string, sql: string, params: any[] | undefined): Promise<RawQueryResult>;
+  executeBatch(token: string, sql: string, params: any[][]): Promise<RawQueryResult[]>;
   completeAccess(token: string): Promise<void>;
 
   /**

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

@@ -1,28 +1,18 @@
 import { Factory as WaSqliteFactory, SQLITE_ROW } from '@journeyapps/wa-sqlite';
 
-import { DEFAULT_MODULE_FACTORIES, WASQLiteModuleFactory, WASQLiteVFS } from './vfs.js';
-import { TemporaryStorageOption } from '../options.js';
-import { RawQueryResult, SqliteValue } from '@powersync/common';
-
-export interface RawWebResult extends Required<RawQueryResult> {
-  autocommit: boolean;
-}
+import { loadModuleAndVfs } from './vfs.js';
+import { ResolvedWASQLiteOpenFactoryOptions } from './WASQLiteOpenFactory.js';
 
 export interface RawResultSet {
-  columnNames: string[];
-  rawRows: SqliteValue[][];
+  columns: string[];
+  rows: SQLiteCompatibleType[][];
 }
 
-/**
- * @internal
- */
-export interface RawWaSqliteDatabaseOptions {
-  filename: string;
-  readonly: boolean;
-  vfs: WASQLiteVFS;
-  encryptionKey: string | undefined;
-  temporaryStorage: TemporaryStorageOption;
-  cacheSizeKb: number;
+export interface RawQueryResult {
+  changes: number;
+  lastInsertRowId: number;
+  autocommit: boolean;
+  resultSet: RawResultSet | undefined;
 }
 
 /**
@@ -37,11 +27,8 @@ export class RawSqliteConnection {
    * The `sqlite3*` connection pointer.
    */
   private db: number = 0;
-  private _moduleFactory: WASQLiteModuleFactory;
 
-  constructor(readonly options: RawWaSqliteDatabaseOptions) {
-    this._moduleFactory = DEFAULT_MODULE_FACTORIES[this.options.vfs];
-  }
+  constructor(readonly options: ResolvedWASQLiteOpenFactoryOptions) {}
 
   get isOpen(): boolean {
     return this.db != 0;
@@ -50,8 +37,8 @@ export class RawSqliteConnection {
   async init() {
     const api = (this._sqliteAPI = await this.openSQLiteAPI());
     this.db = await api.open_v2(
-      this.options.filename,
-      this.options.readonly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */
+      this.options.dbFilename,
+      this.options.isReadOnly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */
     );
     await this.executeRaw(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
     if (this.options.encryptionKey) {
@@ -64,10 +51,7 @@ export class RawSqliteConnection {
   }
 
   private async openSQLiteAPI(): Promise<SQLiteAPI> {
-    const { module, vfs } = await this._moduleFactory({
-      dbFileName: this.options.filename,
-      encryptionKey: this.options.encryptionKey
-    });
+    const { module, vfs } = await loadModuleAndVfs(this.options);
     const sqlite3 = WaSqliteFactory(module);
     sqlite3.vfs_register(vfs, true);
     /**
@@ -79,7 +63,7 @@ export class RawSqliteConnection {
      * Create the multiple cipher vfs if an encryption key is provided
      */
     if (this.options.encryptionKey) {
-      const createResult = module.ccall('sqlite3mc_vfs_create', 'int', ['string', 'int'], [this.options.filename, 1]);
+      const createResult = module.ccall('sqlite3mc_vfs_create', 'int', ['string', 'int'], [this.options.dbFilename, 1]);
       if (createResult !== 0) {
         throw new Error('Failed to create multiple cipher vfs, Database encryption will not work');
       }
@@ -103,12 +87,12 @@ export class RawSqliteConnection {
     return this.requireSqlite().get_autocommit(this.db) != 0;
   }
 
-  async execute(sql: string, bindings?: any[]): Promise<RawWebResult> {
+  async execute(sql: string, bindings?: any[]): Promise<RawQueryResult> {
     const resultSet = await this.executeSingleStatementRaw(sql, bindings);
     return this.wrapQueryResults(this.requireSqlite(), resultSet);
   }
 
-  async executeBatch(sql: string, bindings: any[][]): Promise<RawWebResult[]> {
+  async executeBatch(sql: string, bindings: any[][]): Promise<RawQueryResult[]> {
     const results = [];
     const api = this.requireSqlite();
     for await (const stmt of api.statements(this.db, sql)) {
@@ -126,22 +110,21 @@ export class RawSqliteConnection {
     return results;
   }
 
-  private wrapQueryResults(api: SQLiteAPI, { rawRows, columnNames }: RawResultSet): RawWebResult {
+  private wrapQueryResults(api: SQLiteAPI, rs: RawResultSet | undefined): RawQueryResult {
     return {
-      rowsAffected: api.changes(this.db),
-      insertId: api.last_insert_id(this.db),
+      changes: api.changes(this.db),
+      lastInsertRowId: api.last_insert_id(this.db),
       autocommit: api.get_autocommit(this.db) != 0,
-      rawRows,
-      columnNames
+      resultSet: rs
     };
   }
 
   /**
    * This executes a single statement using SQLite3 and returns the results as a {@link RawResultSet}.
    */
-  private async executeSingleStatementRaw(sql: string, bindings?: any[]): Promise<RawResultSet> {
+  private async executeSingleStatementRaw(sql: string, bindings?: any[]): Promise<RawResultSet | undefined> {
     const results = await this.executeRaw(sql, bindings);
-    return results.length ? results[0] : { columnNames: [], rawRows: [] };
+    return results.length ? results[0] : undefined;
   }
 
   async executeRaw(sql: string, bindings?: any[]): Promise<RawResultSet[]> {
@@ -151,7 +134,7 @@ export class RawSqliteConnection {
       let columns;
 
       const rs = await this.stepThroughStatement(api, stmt, bindings ?? [], columns);
-      columns = rs.columnNames;
+      columns = rs.columns;
       if (columns.length) {
         results.push(rs);
       }
@@ -193,7 +176,7 @@ export class RawSqliteConnection {
     }
 
     knownColumns ??= api.column_names(stmt);
-    return { columnNames: knownColumns, rawRows: rows };
+    return { columns: knownColumns, rows };
   }
 
   async close() {