@quereus/quereus 0.6.4 → 0.6.6

package/src/util/ast-stringify.ts

@@ -497,6 +497,13 @@ export function insertToString(stmt: AST.InsertStmt): string {
 		parts.push(`(${stmt.columns.map(quoteIdentifierIfNeeded).join(', ')})`);
 	}
 
+	if (stmt.contextValues && stmt.contextValues.length > 0) {
+		const contextAssignments = stmt.contextValues.map(assign =>
+			`${quoteIdentifierIfNeeded(assign.name)} = ${expressionToString(assign.value)}`
+		);
+		parts.push('with context', contextAssignments.join(', '));
+	}
+
 	if (stmt.values) {
 		const valueRows = stmt.values.map(row =>
 			`(${row.map(expressionToString).join(', ')})`
@@ -533,7 +540,16 @@ export function updateToString(stmt: AST.UpdateStmt): string {
 		parts.push(withClauseToString(stmt.withClause));
 	}
 
-	parts.push('update', expressionToString(stmt.table), 'set');
+	parts.push('update', expressionToString(stmt.table));
+
+	if (stmt.contextValues && stmt.contextValues.length > 0) {
+		const contextAssignments = stmt.contextValues.map(assign =>
+			`${quoteIdentifierIfNeeded(assign.name)} = ${expressionToString(assign.value)}`
+		);
+		parts.push('with context', contextAssignments.join(', '));
+	}
+
+	parts.push('set');
 
 	const assignments = stmt.assignments.map(assign =>
 		`${quoteIdentifierIfNeeded(assign.column)} = ${expressionToString(assign.value)}`
@@ -573,6 +589,13 @@ export function deleteToString(stmt: AST.DeleteStmt): string {
 
 	parts.push('delete from', expressionToString(stmt.table));
 
+	if (stmt.contextValues && stmt.contextValues.length > 0) {
+		const contextAssignments = stmt.contextValues.map(assign =>
+			`${quoteIdentifierIfNeeded(assign.name)} = ${expressionToString(assign.value)}`
+		);
+		parts.push('with context', contextAssignments.join(', '));
+	}
+
 	if (stmt.where) {
 		parts.push('where', expressionToString(stmt.where));
 	}

package/src/util/hash.ts

@@ -1,90 +1,90 @@
-/**
- * Hash and encoding utilities
- */
-
-/**
- * Computes FNV-1a hash of a string (64-bit variant)
- * Returns an 8-byte array representing the hash
- * 
- * FNV-1a is a fast, non-cryptographic hash function with good distribution.
- * See: http://www.isthe.com/chongo/tech/comp/fnv/
- */
-export function fnv1aHash(str: string): Uint8Array {
-	// FNV-1a 64-bit parameters
-	// Using two 32-bit integers to represent 64-bit hash (JavaScript limitation)
-	let hashHigh = 0xcbf29ce4; // Upper 32 bits of FNV offset basis
-	let hashLow = 0x84222325;  // Lower 32 bits of FNV offset basis
-	
-	const fnvPrimeHigh = 0x00000100; // Upper 32 bits of FNV prime
-	const fnvPrimeLow = 0x000001b3;  // Lower 32 bits of FNV prime
-
-	for (let i = 0; i < str.length; i++) {
-		const charCode = str.charCodeAt(i);
-		
-		// XOR with byte (handle multi-byte characters)
-		hashLow ^= charCode & 0xff;
-		
-		// Multiply by FNV prime (64-bit multiplication using 32-bit parts)
-		const aHigh = hashHigh;
-		const aLow = hashLow;
-		
-		hashLow = (aLow * fnvPrimeLow) >>> 0;
-		hashHigh = (aHigh * fnvPrimeLow + aLow * fnvPrimeHigh + (hashLow / 0x100000000)) >>> 0;
-		hashLow = hashLow >>> 0;
-		
-		// Handle high byte of character if present
-		if (charCode > 0xff) {
-			hashLow ^= (charCode >>> 8) & 0xff;
-			const bHigh = hashHigh;
-			const bLow = hashLow;
-			hashLow = (bLow * fnvPrimeLow) >>> 0;
-			hashHigh = (bHigh * fnvPrimeLow + bLow * fnvPrimeHigh + (hashLow / 0x100000000)) >>> 0;
-			hashLow = hashLow >>> 0;
-		}
-	}
-
-	// Convert to 8-byte array
-	const bytes = new Uint8Array(8);
-	bytes[0] = (hashHigh >>> 24) & 0xff;
-	bytes[1] = (hashHigh >>> 16) & 0xff;
-	bytes[2] = (hashHigh >>> 8) & 0xff;
-	bytes[3] = hashHigh & 0xff;
-	bytes[4] = (hashLow >>> 24) & 0xff;
-	bytes[5] = (hashLow >>> 16) & 0xff;
-	bytes[6] = (hashLow >>> 8) & 0xff;
-	bytes[7] = hashLow & 0xff;
-	
-	return bytes;
-}
-
-/**
- * Converts a byte array to base64url encoding
- * (URL-safe base64 without padding: uses - and _ instead of + and /, no = padding)
- * 
- * Base64url is defined in RFC 4648 Section 5.
- */
-export function toBase64Url(bytes: Uint8Array): string {
-	const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
-	let result = '';
-	
-	for (let i = 0; i < bytes.length; i += 3) {
-		// Get 3 bytes (24 bits) and convert to 4 base64 characters (6 bits each)
-		const byte1 = bytes[i];
-		const byte2 = i + 1 < bytes.length ? bytes[i + 1] : 0;
-		const byte3 = i + 2 < bytes.length ? bytes[i + 2] : 0;
-		
-		const triplet = (byte1 << 16) | (byte2 << 8) | byte3;
-		
-		result += base64Chars[(triplet >>> 18) & 0x3f];
-		result += base64Chars[(triplet >>> 12) & 0x3f];
-		if (i + 1 < bytes.length) {
-			result += base64Chars[(triplet >>> 6) & 0x3f];
-		}
-		if (i + 2 < bytes.length) {
-			result += base64Chars[triplet & 0x3f];
-		}
-	}
-	
-	return result;
-}
-
+/**
+ * Hash and encoding utilities
+ */
+
+/**
+ * Computes FNV-1a hash of a string (64-bit variant)
+ * Returns an 8-byte array representing the hash
+ * 
+ * FNV-1a is a fast, non-cryptographic hash function with good distribution.
+ * See: http://www.isthe.com/chongo/tech/comp/fnv/
+ */
+export function fnv1aHash(str: string): Uint8Array {
+	// FNV-1a 64-bit parameters
+	// Using two 32-bit integers to represent 64-bit hash (JavaScript limitation)
+	let hashHigh = 0xcbf29ce4; // Upper 32 bits of FNV offset basis
+	let hashLow = 0x84222325;  // Lower 32 bits of FNV offset basis
+	
+	const fnvPrimeHigh = 0x00000100; // Upper 32 bits of FNV prime
+	const fnvPrimeLow = 0x000001b3;  // Lower 32 bits of FNV prime
+
+	for (let i = 0; i < str.length; i++) {
+		const charCode = str.charCodeAt(i);
+		
+		// XOR with byte (handle multi-byte characters)
+		hashLow ^= charCode & 0xff;
+		
+		// Multiply by FNV prime (64-bit multiplication using 32-bit parts)
+		const aHigh = hashHigh;
+		const aLow = hashLow;
+		
+		hashLow = (aLow * fnvPrimeLow) >>> 0;
+		hashHigh = (aHigh * fnvPrimeLow + aLow * fnvPrimeHigh + (hashLow / 0x100000000)) >>> 0;
+		hashLow = hashLow >>> 0;
+		
+		// Handle high byte of character if present
+		if (charCode > 0xff) {
+			hashLow ^= (charCode >>> 8) & 0xff;
+			const bHigh = hashHigh;
+			const bLow = hashLow;
+			hashLow = (bLow * fnvPrimeLow) >>> 0;
+			hashHigh = (bHigh * fnvPrimeLow + bLow * fnvPrimeHigh + (hashLow / 0x100000000)) >>> 0;
+			hashLow = hashLow >>> 0;
+		}
+	}
+
+	// Convert to 8-byte array
+	const bytes = new Uint8Array(8);
+	bytes[0] = (hashHigh >>> 24) & 0xff;
+	bytes[1] = (hashHigh >>> 16) & 0xff;
+	bytes[2] = (hashHigh >>> 8) & 0xff;
+	bytes[3] = hashHigh & 0xff;
+	bytes[4] = (hashLow >>> 24) & 0xff;
+	bytes[5] = (hashLow >>> 16) & 0xff;
+	bytes[6] = (hashLow >>> 8) & 0xff;
+	bytes[7] = hashLow & 0xff;
+	
+	return bytes;
+}
+
+/**
+ * Converts a byte array to base64url encoding
+ * (URL-safe base64 without padding: uses - and _ instead of + and /, no = padding)
+ * 
+ * Base64url is defined in RFC 4648 Section 5.
+ */
+export function toBase64Url(bytes: Uint8Array): string {
+	const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+	let result = '';
+	
+	for (let i = 0; i < bytes.length; i += 3) {
+		// Get 3 bytes (24 bits) and convert to 4 base64 characters (6 bits each)
+		const byte1 = bytes[i];
+		const byte2 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+		const byte3 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+		
+		const triplet = (byte1 << 16) | (byte2 << 8) | byte3;
+		
+		result += base64Chars[(triplet >>> 18) & 0x3f];
+		result += base64Chars[(triplet >>> 12) & 0x3f];
+		if (i + 1 < bytes.length) {
+			result += base64Chars[(triplet >>> 6) & 0x3f];
+		}
+		if (i + 2 < bytes.length) {
+			result += base64Chars[triplet & 0x3f];
+		}
+	}
+	
+	return result;
+}
+

package/src/util/mutation-statement.ts

@@ -0,0 +1,129 @@
+import type { Row, SqlValue } from '../common/types.js';
+import type { TableSchema } from '../schema/table.js';
+import type * as AST from '../parser/ast.js';
+import { insertToString, updateToString, deleteToString } from './ast-stringify.js';
+
+/**
+ * Builds a deterministic INSERT statement for mutation logging.
+ * Creates an AST and uses insertToString for consistency.
+ */
+export function buildInsertStatement(
+	tableSchema: TableSchema,
+	newRow: Row,
+	contextRow?: Row
+): string {
+	// Build INSERT AST
+	const stmt: AST.InsertStmt = {
+		type: 'insert',
+		table: { type: 'identifier', name: tableSchema.name },
+		columns: tableSchema.columns.map(col => col.name),
+		values: [newRow.map(sqlValueToLiteralExpr)],
+		contextValues: buildContextAssignments(tableSchema, contextRow)
+	};
+
+	return insertToString(stmt);
+}
+
+/**
+ * Builds a deterministic UPDATE statement for mutation logging.
+ */
+export function buildUpdateStatement(
+	tableSchema: TableSchema,
+	newRow: Row,
+	oldKeyValues: Row,
+	contextRow?: Row
+): string {
+	const pkDef = tableSchema.primaryKeyDefinition;
+
+	// Build UPDATE AST
+	const stmt: AST.UpdateStmt = {
+		type: 'update',
+		table: { type: 'identifier', name: tableSchema.name },
+		contextValues: buildContextAssignments(tableSchema, contextRow),
+		assignments: tableSchema.columns.map((col, idx) => ({
+			column: col.name,
+			value: sqlValueToLiteralExpr(newRow[idx])
+		})),
+		where: buildWhereClause(pkDef, oldKeyValues, tableSchema)
+	};
+
+	return updateToString(stmt);
+}
+
+/**
+ * Builds a deterministic DELETE statement for mutation logging.
+ */
+export function buildDeleteStatement(
+	tableSchema: TableSchema,
+	oldKeyValues: Row,
+	contextRow?: Row
+): string {
+	const pkDef = tableSchema.primaryKeyDefinition;
+
+	// Build DELETE AST
+	const stmt: AST.DeleteStmt = {
+		type: 'delete',
+		table: { type: 'identifier', name: tableSchema.name },
+		contextValues: buildContextAssignments(tableSchema, contextRow),
+		where: buildWhereClause(pkDef, oldKeyValues, tableSchema)
+	};
+
+	return deleteToString(stmt);
+}
+
+/**
+ * Converts a SqlValue to a LiteralExpr AST node.
+ */
+function sqlValueToLiteralExpr(value: SqlValue): AST.LiteralExpr {
+	return {
+		type: 'literal',
+		value: value
+	};
+}
+
+/**
+ * Builds context assignments from context row values.
+ */
+function buildContextAssignments(
+	tableSchema: TableSchema,
+	contextRow?: Row
+): AST.ContextAssignment[] | undefined {
+	if (!contextRow || contextRow.length === 0 || !tableSchema.mutationContext) {
+		return undefined;
+	}
+
+	return tableSchema.mutationContext.map((ctx, idx) => ({
+		name: ctx.name,
+		value: sqlValueToLiteralExpr(contextRow[idx])
+	}));
+}
+
+/**
+ * Builds a WHERE clause for primary key matching.
+ * Returns an AND expression of pk_col = value for each PK column.
+ */
+function buildWhereClause(
+	pkDef: TableSchema['primaryKeyDefinition'],
+	keyValues: Row,
+	tableSchema: TableSchema
+): AST.Expression {
+	const conditions: AST.Expression[] = pkDef.map((pkCol, idx) => ({
+		type: 'binary' as const,
+		operator: '=' as const,
+		left: { type: 'column' as const, name: tableSchema.columns[pkCol.index].name },
+		right: sqlValueToLiteralExpr(keyValues[idx])
+	}));
+
+	if (conditions.length === 1) {
+		return conditions[0];
+	}
+
+	// Build nested AND expressions: (a AND b) AND c AND ...
+	return conditions.reduce((acc, cond) => ({
+		type: 'binary' as const,
+		operator: 'and' as const,
+		left: acc,
+		right: cond
+	}));
+}
+

package/src/util/plugin-helper.ts

@@ -1,110 +1,110 @@
-/**
- * Plugin registration helper for static plugin loading
- * 
- * This module provides utilities for registering plugins without dynamic imports,
- * which is useful for React Native and other environments where dynamic imports
- * are not supported.
- */
-
-import type { Database } from '../core/database.js';
-import type { PluginRegistrations } from '../vtab/manifest.js';
-import type { SqlValue } from '../common/types.js';
-
-/**
- * Plugin function type - what a plugin exports as its default export
- */
-export type PluginFunction = (
-	db: Database,
-	config?: Record<string, SqlValue>
-) => Promise<PluginRegistrations> | PluginRegistrations;
-
-/**
- * Register a plugin's components with the database.
- * 
- * This is a helper function for static plugin loading that handles calling
- * the plugin function and registering all returned components (vtables,
- * functions, collations, types) with the database.
- * 
- * @param db Database instance to register with
- * @param plugin Plugin function (the default export from a plugin module)
- * @param config Optional configuration object to pass to the plugin
- * 
- * @example
- * ```typescript
- * import { Database } from '@quereus/quereus';
- * import { registerPlugin } from '@quereus/quereus';
- * import myPlugin from './plugins/my-plugin';
- * 
- * const db = new Database();
- * await registerPlugin(db, myPlugin, { apiKey: 'secret' });
- * ```
- * 
- * @example
- * ```typescript
- * // Register multiple plugins
- * await registerPlugin(db, stringFunctions);
- * await registerPlugin(db, customCollations);
- * await registerPlugin(db, jsonTable, { cacheSize: 100 });
- * ```
- */
-export async function registerPlugin(
-	db: Database,
-	plugin: PluginFunction,
-	config: Record<string, SqlValue> = {}
-): Promise<void> {
-	// Call the plugin function to get registrations
-	const registrations = await plugin(db, config);
-
-	// Register virtual table modules
-	if (registrations.vtables) {
-		for (const vtable of registrations.vtables) {
-			try {
-				db.registerVtabModule(vtable.name, vtable.module, vtable.auxData);
-			} catch (error) {
-				throw new Error(
-					`Failed to register vtable module '${vtable.name}': ${error instanceof Error ? error.message : String(error)}`
-				);
-			}
-		}
-	}
-
-	// Register functions
-	if (registrations.functions) {
-		for (const func of registrations.functions) {
-			try {
-				db.registerFunction(func.schema);
-			} catch (error) {
-				throw new Error(
-					`Failed to register function '${func.schema.name}/${func.schema.numArgs}': ${error instanceof Error ? error.message : String(error)}`
-				);
-			}
-		}
-	}
-
-	// Register collations
-	if (registrations.collations) {
-		for (const collation of registrations.collations) {
-			try {
-				db.registerCollation(collation.name, collation.func);
-			} catch (error) {
-				throw new Error(
-					`Failed to register collation '${collation.name}': ${error instanceof Error ? error.message : String(error)}`
-				);
-			}
-		}
-	}
-
-	// Register types
-	if (registrations.types) {
-		for (const type of registrations.types) {
-			try {
-				db.registerType(type.name, type.definition);
-			} catch (error) {
-				throw new Error(
-					`Failed to register type '${type.name}': ${error instanceof Error ? error.message : String(error)}`
-				);
-			}
-		}
-	}
-}
-
+/**
+ * Plugin registration helper for static plugin loading
+ * 
+ * This module provides utilities for registering plugins without dynamic imports,
+ * which is useful for React Native and other environments where dynamic imports
+ * are not supported.
+ */
+
+import type { Database } from '../core/database.js';
+import type { PluginRegistrations } from '../vtab/manifest.js';
+import type { SqlValue } from '../common/types.js';
+
+/**
+ * Plugin function type - what a plugin exports as its default export
+ */
+export type PluginFunction = (
+	db: Database,
+	config?: Record<string, SqlValue>
+) => Promise<PluginRegistrations> | PluginRegistrations;
+
+/**
+ * Register a plugin's components with the database.
+ * 
+ * This is a helper function for static plugin loading that handles calling
+ * the plugin function and registering all returned components (vtables,
+ * functions, collations, types) with the database.
+ * 
+ * @param db Database instance to register with
+ * @param plugin Plugin function (the default export from a plugin module)
+ * @param config Optional configuration object to pass to the plugin
+ * 
+ * @example
+ * ```typescript
+ * import { Database } from '@quereus/quereus';
+ * import { registerPlugin } from '@quereus/quereus';
+ * import myPlugin from './plugins/my-plugin';
+ * 
+ * const db = new Database();
+ * await registerPlugin(db, myPlugin, { apiKey: 'secret' });
+ * ```
+ * 
+ * @example
+ * ```typescript
+ * // Register multiple plugins
+ * await registerPlugin(db, stringFunctions);
+ * await registerPlugin(db, customCollations);
+ * await registerPlugin(db, jsonTable, { cacheSize: 100 });
+ * ```
+ */
+export async function registerPlugin(
+	db: Database,
+	plugin: PluginFunction,
+	config: Record<string, SqlValue> = {}
+): Promise<void> {
+	// Call the plugin function to get registrations
+	const registrations = await plugin(db, config);
+
+	// Register virtual table modules
+	if (registrations.vtables) {
+		for (const vtable of registrations.vtables) {
+			try {
+				db.registerVtabModule(vtable.name, vtable.module, vtable.auxData);
+			} catch (error) {
+				throw new Error(
+					`Failed to register vtable module '${vtable.name}': ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		}
+	}
+
+	// Register functions
+	if (registrations.functions) {
+		for (const func of registrations.functions) {
+			try {
+				db.registerFunction(func.schema);
+			} catch (error) {
+				throw new Error(
+					`Failed to register function '${func.schema.name}/${func.schema.numArgs}': ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		}
+	}
+
+	// Register collations
+	if (registrations.collations) {
+		for (const collation of registrations.collations) {
+			try {
+				db.registerCollation(collation.name, collation.func);
+			} catch (error) {
+				throw new Error(
+					`Failed to register collation '${collation.name}': ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		}
+	}
+
+	// Register types
+	if (registrations.types) {
+		for (const type of registrations.types) {
+			try {
+				db.registerType(type.name, type.definition);
+			} catch (error) {
+				throw new Error(
+					`Failed to register type '${type.name}': ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		}
+	}
+}
+

package/src/util/sql-literal.ts

@@ -0,0 +1,22 @@
+import type { SqlValue } from '../common/types.js';
+import { expressionToString } from './ast-stringify.js';
+import type * as AST from '../parser/ast.js';
+
+/**
+ * Converts a SqlValue to its SQL literal string representation.
+ * This is used for mutation logging to create deterministic, replayable SQL statements.
+ * Uses the existing expressionToString function for consistency.
+ *
+ * @param value The value to convert to a SQL literal
+ * @returns SQL literal string representation
+ */
+export function sqlValueToLiteral(value: SqlValue): string {
+	// Create a literal expression AST node and use expressionToString
+	const literalExpr: AST.LiteralExpr = {
+		type: 'literal',
+		value: value
+	};
+
+	return expressionToString(literalExpr);
+}
+

package/src/vtab/memory/table.ts

@@ -123,16 +123,11 @@ export class MemoryTable extends VirtualTable {
 	// Note: getBestAccessPlan is handled by the MemoryTableModule, not the table instance.
 
 	/** Performs mutation through the connection's transaction layer */
-	async update(
-		operation: 'insert' | 'update' | 'delete',
-		values: Row | undefined,
-		oldKeyValues?: Row,
-		onConflict?: ConflictResolution
-	): Promise<Row | undefined> {
+	async update(args: import('../table.js').UpdateArgs): Promise<Row | undefined> {
 		const conn = await this.ensureConnection();
 		// Delegate mutation to the manager.
-		// This assumes manager.performMutation will be updated to this signature and logic.
-		return this.manager.performMutation(conn, operation, values, oldKeyValues, onConflict);
+		// Note: mutationStatement is ignored by memory table (could be logged if needed)
+		return this.manager.performMutation(conn, args.operation, args.values, args.oldKeyValues, args.onConflict);
 	}
 
 	/** Begins a transaction for this connection */

package/src/vtab/table.ts

@@ -9,6 +9,22 @@ import type { ConflictResolution } from '../common/constants.js';
 import type { VirtualTableConnection } from './connection.js';
 import type { PlanNode } from '../planner/nodes/plan-node.js';
 
+/**
+ * Arguments passed to VirtualTable.update() method.
+ */
+export interface UpdateArgs {
+	/** The operation to perform (insert, update, delete) */
+	operation: RowOp;
+	/** For INSERT/UPDATE, the values to insert/update. For DELETE, undefined */
+	values: Row | undefined;
+	/** For UPDATE/DELETE, the old key values of the row to modify. Undefined for INSERT */
+	oldKeyValues?: Row;
+	/** Conflict resolution mode (defaults to ABORT if unspecified) */
+	onConflict?: ConflictResolution;
+	/** Optional: Deterministic SQL statement that reproduces this mutation (if logMutations is enabled) */
+	mutationStatement?: string;
+}
+
 /**
  * Base class representing a virtual table instance.
  * Module implementations should subclass this to provide specific table behavior.
@@ -21,6 +37,13 @@ export abstract class VirtualTable {
 	public errorMessage?: string;
 	public tableSchema?: TableSchema;
 
+	/**
+	 * When true, the update() method will receive a mutationStatement parameter
+	 * containing a deterministic SQL statement that reproduces the mutation.
+	 * This enables replication, audit logging, and change data capture.
+	 */
+	public wantStatements?: boolean;
+
 	constructor(db: Database, module: AnyVirtualTableModule, schemaName: string, tableName: string) {
 		this.db = db;
 		this.module = module;
@@ -69,19 +92,11 @@ export abstract class VirtualTable {
 
 	/**
 	 * Performs an INSERT, UPDATE, or DELETE operation
-	 * @param operation The operation to perform (insert, update, delete)
-	 * @param values For INSERT/UPDATE, the values to insert/update. For DELETE, undefined
-	 * @param oldKeyValues For UPDATE/DELETE, the old key values of the row to modify. Undefined for INSERT
-	 * @param onConflict Conflict resolution mode (defaults to ABORT if unspecified)
+	 * @param args Arguments object containing operation details and optional mutation statement
 	 * @returns new row for INSERT/UPDATE, undefined for DELETE
 	 * @throws QuereusError or ConstraintError on failure
 	 */
-	abstract update(
-		operation: RowOp,
-		values: Row | undefined,
-		oldKeyValues?: Row,
-		onConflict?: ConflictResolution
-	): Promise<Row | undefined>;
+	abstract update(args: UpdateArgs): Promise<Row | undefined>;
 
 	/**
 	 * (Optional) Creates a new connection for transaction support.