@fragno-dev/db 0.2.1 → 0.3.0

package/dist/adapters/in-memory/in-memory-uow.js

@@ -0,0 +1,648 @@
+import { FragnoId, FragnoReference } from "../../schema/create.js";
+import { createSQLSerializer } from "../../query/serialize/create-sql-serializer.js";
+import { ReferenceSubquery, encodeValues, encodeValuesWithDbDefaults } from "../../query/value-encoding.js";
+import { createCursorFromRecord, decodeCursor } from "../../query/cursor.js";
+import { buildCondition } from "../../query/condition-builder.js";
+import { isDbNow } from "../../query/db-now.js";
+import { SQLocalDriverConfig } from "../generic-sql/driver-config.js";
+import { compareNormalizedValues } from "./value-comparison.js";
+import { buildIndexKey, ensureNamespaceStore, normalizeIndexValue } from "./store.js";
+import { resolveReferenceSubqueries } from "./reference-resolution.js";
+import { evaluateCondition } from "./condition-evaluator.js";
+
+//#region src/adapters/in-memory/in-memory-uow.ts
+const getResolver = (schema, namespace, resolverFactory) => resolverFactory ? resolverFactory(schema, namespace ?? null) : void 0;
+const getPhysicalTableName = (table, resolver) => resolver ? resolver.getTableName(table.name) : table.name;
+const getPhysicalColumnName = (table, columnName, resolver) => resolver ? resolver.getColumnName(table.name, columnName) : columnName;
+const cursorSerializer = createSQLSerializer(new SQLocalDriverConfig());
+var VersionConflictError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "VersionConflictError";
+	}
+};
+const getNamespaceStore = (store, schema, namespace, resolver) => {
+	return ensureNamespaceStore(store, namespace ?? schema.name, schema, resolver);
+};
+const getTableStore = (namespaceStore, table, resolver) => {
+	const physicalTableName = getPhysicalTableName(table, resolver);
+	const tableStore = namespaceStore.tables.get(physicalTableName);
+	if (!tableStore) throw new Error(`Missing in-memory table store for "${physicalTableName}".`);
+	return tableStore;
+};
+const buildSelection = (table, select, _resolver) => {
+	const selection = /* @__PURE__ */ new Set();
+	if (!select || select === true) for (const columnName of Object.keys(table.columns)) selection.add(columnName);
+	else for (const columnName of select) selection.add(columnName);
+	selection.add("_internalId");
+	selection.add("_version");
+	return selection;
+};
+const selectRow = (row, table, select, resolver) => {
+	const selection = buildSelection(table, select, resolver);
+	const selected = {};
+	for (const columnName of selection) {
+		const physicalColumnName = getPhysicalColumnName(table, columnName, resolver);
+		if (Object.prototype.hasOwnProperty.call(row, physicalColumnName)) selected[columnName] = row[physicalColumnName];
+	}
+	return selected;
+};
+const isNullish = (value) => value === null || value === void 0;
+const prefixSelection = (row, table, select, prefix, resolver) => {
+	const selected = selectRow(row, table, select, resolver);
+	const prefixed = {};
+	for (const key in selected) prefixed[`${prefix}:${key}`] = selected[key];
+	return prefixed;
+};
+const orderRows = (rows, orderBy, resolver) => {
+	if (!orderBy || orderBy.length === 0) return rows;
+	return rows.slice().sort((left, right) => {
+		for (const [column, direction] of orderBy) {
+			const columnName = resolver ? resolver.getColumnName(column.tableName, column.name) : column.name;
+			const comparison = compareNormalizedValues(normalizeIndexValue(left[columnName], column), normalizeIndexValue(right[columnName], column));
+			if (comparison !== 0) return direction === "asc" ? comparison : -comparison;
+		}
+		return 0;
+	});
+};
+const assertOrderByIndexOnly = (table, orderBy, resolver) => {
+	if (!orderBy || orderBy.length === 0) return;
+	const direction = orderBy[0][1];
+	if (!orderBy.every(([, dir]) => dir === direction)) throw new Error(`In-memory adapter only supports orderByIndex; mixed orderBy directions found on table "${table.name}".`);
+	const orderColumnNames = orderBy.map(([column]) => resolver ? resolver.getColumnName(table.name, column.name) : column.name);
+	const idColumnName = resolver ? resolver.getColumnName(table.name, table.getIdColumn().name) : table.getIdColumn().name;
+	if (orderColumnNames.length === 1 && orderColumnNames[0] === idColumnName) return;
+	for (const index of Object.values(table.indexes)) {
+		const indexColumnNames = index.columnNames.map((columnName) => resolver ? resolver.getColumnName(table.name, columnName) : columnName);
+		if (indexColumnNames.length !== orderColumnNames.length) continue;
+		let matches = true;
+		for (let i = 0; i < indexColumnNames.length; i += 1) if (indexColumnNames[i] !== orderColumnNames[i]) {
+			matches = false;
+			break;
+		}
+		if (matches) return;
+	}
+	throw new Error(`In-memory adapter only supports orderByIndex; received orderBy on table "${table.name}".`);
+};
+const findJoinMatches = (parentRow, parentTable, join, namespaceStore, resolver, now = () => /* @__PURE__ */ new Date()) => {
+	const { relation, options } = join;
+	if (options === false) return [];
+	const targetTable = relation.table;
+	const targetStore = getTableStore(namespaceStore, targetTable, resolver);
+	const matches = [];
+	assertOrderByIndexOnly(targetTable, options.orderBy, resolver);
+	for (const row of targetStore.rows.values()) {
+		let matchesJoin = true;
+		for (const [left, right] of relation.on) {
+			const leftColumn = parentTable.columns[left];
+			if (!leftColumn) throw new Error(`Column "${left}" not found on table "${parentTable.name}".`);
+			const rightColumn = targetTable.columns[right];
+			if (!rightColumn) throw new Error(`Column "${right}" not found on table "${targetTable.name}".`);
+			const actualRight = rightColumn.role === "external-id" ? "_internalId" : right;
+			const actualRightColumn = targetTable.columns[actualRight];
+			if (!actualRightColumn) throw new Error(`Column "${actualRight}" not found on table "${targetTable.name}".`);
+			const leftValue = parentRow[getPhysicalColumnName(parentTable, left, resolver)];
+			const rightValue = row[getPhysicalColumnName(targetTable, actualRight, resolver)];
+			if (isNullish(leftValue) || isNullish(rightValue)) {
+				matchesJoin = false;
+				break;
+			}
+			if (compareNormalizedValues(normalizeIndexValue(leftValue, leftColumn), normalizeIndexValue(rightValue, actualRightColumn)) !== 0) {
+				matchesJoin = false;
+				break;
+			}
+		}
+		if (!matchesJoin) continue;
+		if (options.where && !evaluateCondition(options.where, targetTable, row, namespaceStore, resolver, now)) continue;
+		matches.push(row);
+	}
+	const ordered = orderRows(matches, options.orderBy, resolver);
+	if (options.limit !== void 0) return ordered.slice(0, Math.max(0, options.limit));
+	return ordered;
+};
+const applyJoins = (baseOutput, parentRow, parentTable, joins, namespaceStore, resolver, now = () => /* @__PURE__ */ new Date(), parentPath = "") => {
+	if (!joins || joins.length === 0) return [baseOutput];
+	let outputs = [baseOutput];
+	for (const join of joins) {
+		if (join.options === false) continue;
+		const relationPath = parentPath ? `${parentPath}:${join.relation.name}` : join.relation.name;
+		const nextOutputs = [];
+		for (const currentOutput of outputs) {
+			const matches = findJoinMatches(parentRow, parentTable, join, namespaceStore, resolver, now);
+			if (matches.length === 0) {
+				nextOutputs.push(currentOutput);
+				continue;
+			}
+			for (const matchRow of matches) {
+				const prefixed = prefixSelection(matchRow, join.relation.table, join.options.select, relationPath, resolver);
+				const merged = {
+					...currentOutput,
+					...prefixed
+				};
+				if (join.options.join && join.options.join.length > 0) nextOutputs.push(...applyJoins(merged, matchRow, join.relation.table, join.options.join, namespaceStore, resolver, now, relationPath));
+				else nextOutputs.push(merged);
+			}
+		}
+		outputs = nextOutputs;
+	}
+	return outputs;
+};
+const getExternalId = (id) => typeof id === "string" ? id : id.externalId;
+const getVersionToCheck = (id, checkVersion) => {
+	if (!checkVersion) return;
+	if (typeof id === "string") throw new Error("Cannot use checkVersion with a string ID. Version checking requires a FragnoId.");
+	return id.version;
+};
+const resolveReferenceSubqueriesOrThrow = (namespaceStore, table, encodedValues, resolver) => {
+	const resolved = resolveReferenceSubqueries(namespaceStore, encodedValues, resolver);
+	for (const [key, value] of Object.entries(encodedValues)) {
+		if (!(value instanceof ReferenceSubquery)) continue;
+		if (resolved[key] === null || resolved[key] === void 0) throw new Error(`Foreign key constraint violation on table "${table.name}" for column "${key}".`);
+	}
+	return resolved;
+};
+const getReferencedColumn = (table, columnName, resolver) => {
+	const column = table.columns[columnName];
+	if (!column) throw new Error(`Column "${columnName}" not found on table "${table.name}".`);
+	const actualName = column.role === "external-id" ? "_internalId" : columnName;
+	const actualColumn = table.columns[actualName];
+	if (!actualColumn) throw new Error(`Column "${actualName}" not found on table "${table.name}".`);
+	return {
+		name: getPhysicalColumnName(table, actualName, resolver),
+		column: actualColumn
+	};
+};
+const enforceOutgoingForeignKeys = (namespaceStore, table, row, columnsToCheck, resolver) => {
+	for (const relation of Object.values(table.relations)) {
+		if (relation.type !== "one") continue;
+		const localColumnNames = relation.on.map(([local]) => local);
+		if (columnsToCheck && !localColumnNames.some((name) => columnsToCheck.has(name))) continue;
+		if (localColumnNames.map((name) => row[getPhysicalColumnName(table, name, resolver)]).some((value) => value === null || value === void 0)) continue;
+		const referencedTable = relation.table;
+		const referencedStore = getTableStore(namespaceStore, referencedTable, resolver);
+		let foundMatch = false;
+		for (const targetRow of referencedStore.rows.values()) {
+			let matches = true;
+			for (const [localName, foreignName] of relation.on) {
+				if (!table.columns[localName]) throw new Error(`Column "${localName}" not found on table "${table.name}".`);
+				const { name: actualForeignName, column: foreignColumn } = getReferencedColumn(referencedTable, foreignName, resolver);
+				const localValue = row[getPhysicalColumnName(table, localName, resolver)];
+				const targetValue = targetRow[actualForeignName];
+				if (compareNormalizedValues(normalizeIndexValue(localValue, foreignColumn), normalizeIndexValue(targetValue, foreignColumn)) !== 0) {
+					matches = false;
+					break;
+				}
+			}
+			if (matches) {
+				foundMatch = true;
+				break;
+			}
+		}
+		if (!foundMatch) throw new Error(`Foreign key constraint violation on table "${table.name}" for relation "${relation.name}".`);
+	}
+};
+const enforceNoIncomingForeignKeys = (namespaceStore, schema, table, row, resolver) => {
+	for (const sourceTable of Object.values(schema.tables)) for (const relation of Object.values(sourceTable.relations)) {
+		if (relation.type !== "one") continue;
+		if (relation.table.name !== table.name) continue;
+		const sourceStore = getTableStore(namespaceStore, sourceTable, resolver);
+		const targetColumnInfo = relation.on.map(([, foreignName]) => getReferencedColumn(table, foreignName, resolver));
+		const targetValues = targetColumnInfo.map(({ name }) => row[name]);
+		if (targetValues.some((value) => value === null || value === void 0)) continue;
+		for (const sourceRow of sourceStore.rows.values()) {
+			let matches = true;
+			for (let i = 0; i < relation.on.length; i += 1) {
+				const [localName] = relation.on[i];
+				const { column } = targetColumnInfo[i];
+				const localValue = sourceRow[getPhysicalColumnName(sourceTable, localName, resolver)];
+				if (localValue === null || localValue === void 0) {
+					matches = false;
+					break;
+				}
+				if (compareNormalizedValues(normalizeIndexValue(localValue, column), normalizeIndexValue(targetValues[i], column)) !== 0) {
+					matches = false;
+					break;
+				}
+			}
+			if (matches) throw new Error(`Foreign key constraint violation on table "${table.name}" for relation "${relation.name}".`);
+		}
+	}
+};
+const findRowByExternalId = (tableStore, table, externalId, resolver) => {
+	const idColumnName = getPhysicalColumnName(table, table.getIdColumn().name, resolver);
+	for (const [internalId, row] of tableStore.rows) if (row[idColumnName] === externalId) return {
+		internalId,
+		row
+	};
+};
+const resolveCursorValue = (value, column) => {
+	if (value && typeof value === "object") {
+		const maybeExternalId = value.externalId;
+		const maybeInternalId = value.internalId;
+		if (typeof maybeExternalId === "string") {
+			if (column.role === "external-id") return maybeExternalId;
+			if ((column.role === "internal-id" || column.role === "reference") && maybeInternalId) return typeof maybeInternalId === "string" ? BigInt(maybeInternalId) : maybeInternalId;
+		}
+	}
+	return value;
+};
+const buildCursorKey = (cursor, table, columnNames, resolver) => {
+	if (!cursor) return;
+	const cursorObj = typeof cursor === "string" ? decodeCursor(cursor) : cursor;
+	const columnMap = resolver ? resolver.getColumnNameMap(table) : void 0;
+	return columnNames.map((columnName) => {
+		const logicalName = columnMap?.[columnName] ?? columnName;
+		const column = table.columns[logicalName];
+		if (!column) throw new Error(`Column "${logicalName}" not found on table "${table.name}".`);
+		const rawValue = resolveCursorValue(cursorObj.indexValues[column.name], column);
+		if (rawValue === void 0) return;
+		return normalizeIndexValue(cursorSerializer.deserialize(rawValue, column), column);
+	});
+};
+const findRows = (op, namespaceStore, tableStore, resolver, now = () => /* @__PURE__ */ new Date()) => {
+	const table = op.table;
+	const orderByIndex = op.options.orderByIndex;
+	const orderIndexName = orderByIndex?.indexName ?? op.indexName;
+	const orderIndex = tableStore.indexes.get(orderIndexName);
+	if (!orderIndex) throw new Error(`Missing in-memory index "${orderIndexName}" on table "${table.name}".`);
+	const direction = orderByIndex?.direction ?? "asc";
+	const afterKey = buildCursorKey(op.options.after, table, orderIndex.definition.columnNames, resolver);
+	const beforeKey = buildCursorKey(op.options.before, table, orderIndex.definition.columnNames, resolver);
+	const limit = op.withCursor && op.options.pageSize !== void 0 ? op.options.pageSize + 1 : op.options.pageSize;
+	const scanOptions = {
+		direction,
+		limit,
+		start: void 0,
+		startInclusive: true,
+		end: void 0,
+		endInclusive: true
+	};
+	if (afterKey) if (direction === "asc") {
+		scanOptions.start = afterKey;
+		scanOptions.startInclusive = false;
+	} else {
+		scanOptions.end = afterKey;
+		scanOptions.endInclusive = false;
+	}
+	if (beforeKey) if (direction === "asc") {
+		scanOptions.end = beforeKey;
+		scanOptions.endInclusive = false;
+	} else {
+		scanOptions.start = beforeKey;
+		scanOptions.startInclusive = false;
+	}
+	const entries = orderIndex.index.scan(scanOptions);
+	const whereResult = op.options.where ? buildCondition(table.columns, op.options.where) : void 0;
+	if (whereResult === false) return [];
+	const condition = whereResult === true ? void 0 : whereResult;
+	const results = [];
+	for (const entry of entries) {
+		const row = tableStore.rows.get(entry.value);
+		if (!row) continue;
+		if (condition && !evaluateCondition(condition, table, row, namespaceStore, resolver, now)) continue;
+		const baseOutput = selectRow(row, table, op.options.select, resolver);
+		if (op.options.joins && op.options.joins.length > 0) {
+			const joined = applyJoins(baseOutput, row, table, op.options.joins, namespaceStore, resolver, now);
+			for (const joinedRow of joined) {
+				results.push(joinedRow);
+				if (limit !== void 0 && results.length >= limit) break;
+			}
+		} else results.push(baseOutput);
+		if (limit !== void 0 && results.length >= limit) break;
+	}
+	return results;
+};
+const countRows = (op, namespaceStore, tableStore, resolver, now = () => /* @__PURE__ */ new Date()) => {
+	const table = op.table;
+	const whereResult = op.options.where ? buildCondition(table.columns, op.options.where) : void 0;
+	if (whereResult === false) return 0;
+	const condition = whereResult === true ? void 0 : whereResult;
+	let count = 0;
+	for (const row of tableStore.rows.values()) {
+		if (condition && !evaluateCondition(condition, table, row, namespaceStore, resolver, now)) continue;
+		count += 1;
+	}
+	return count;
+};
+const resolveDbNowValue = (value, options) => isDbNow(value) ? options.clock.now() : value;
+const createRow = (op, namespaceStore, tableStore, options, resolver) => {
+	const table = op.schema.tables[op.table];
+	if (!table) throw new Error(`Invalid table name ${op.table}.`);
+	const encoded = encodeValuesWithDbDefaults(op.values, table, {
+		now: options.clock.now,
+		createId: options.idGenerator
+	}, resolver);
+	const resolvedValues = options.enforceConstraints ? resolveReferenceSubqueriesOrThrow(namespaceStore, table, encoded, resolver) : resolveReferenceSubqueries(namespaceStore, encoded, resolver);
+	const row = {};
+	for (const columnName of Object.keys(table.columns)) {
+		const column = table.columns[columnName];
+		if (!column || column.role === "internal-id") continue;
+		const physicalColumnName = getPhysicalColumnName(table, column.name, resolver);
+		const value = resolvedValues[physicalColumnName];
+		if (value === void 0) {
+			if (column.isNullable) {
+				row[physicalColumnName] = null;
+				continue;
+			}
+			if (column.role === "version") {
+				row[physicalColumnName] = 0;
+				continue;
+			}
+			throw new Error(`Missing required value for column "${column.name}".`);
+		}
+		row[physicalColumnName] = resolveDbNowValue(value, options);
+	}
+	const internalId = options.internalIdGeneratorProvided ? options.internalIdGenerator() : tableStore.nextInternalId;
+	if (!options.internalIdGeneratorProvided) tableStore.nextInternalId += 1n;
+	const internalIdColumnName = getPhysicalColumnName(table, "_internalId", resolver);
+	const versionColumnName = getPhysicalColumnName(table, "_version", resolver);
+	row[internalIdColumnName] = internalId;
+	row[versionColumnName] = row[versionColumnName] ?? 0;
+	if (options.enforceConstraints) enforceOutgoingForeignKeys(namespaceStore, table, row, void 0, resolver);
+	tableStore.rows.set(internalId, row);
+	for (const indexStore of tableStore.indexes.values()) {
+		const key = buildIndexKey(table, indexStore.definition, row, resolver);
+		indexStore.index.insert(key, internalId, { enforceUnique: options.enforceConstraints });
+	}
+	return internalId;
+};
+const updateRow = (op, namespaceStore, tableStore, options, resolver) => {
+	const table = op.schema.tables[op.table];
+	if (!table) throw new Error(`Invalid table name ${op.table}.`);
+	const externalId = getExternalId(op.id);
+	const versionToCheck = getVersionToCheck(op.id, op.checkVersion);
+	const existing = findRowByExternalId(tableStore, table, externalId, resolver);
+	if (!existing) {
+		if (versionToCheck !== void 0) throw new VersionConflictError(`Version conflict: row "${externalId}" not found.`);
+		return null;
+	}
+	const versionColumnName = getPhysicalColumnName(table, "_version", resolver);
+	const currentVersion = Number(existing.row[versionColumnName] ?? 0);
+	if (versionToCheck !== void 0 && currentVersion !== versionToCheck) throw new VersionConflictError(`Version conflict: row "${externalId}" has changed.`);
+	const encoded = encodeValues(op.set, table, false, {}, resolver);
+	const resolvedValues = options.enforceConstraints ? resolveReferenceSubqueriesOrThrow(namespaceStore, table, encoded, resolver) : resolveReferenceSubqueries(namespaceStore, encoded, resolver);
+	const resolvedUpdateValues = {};
+	for (const [columnName, value] of Object.entries(resolvedValues)) resolvedUpdateValues[columnName] = resolveDbNowValue(value, options);
+	const updatedRow = {
+		...existing.row,
+		...resolvedUpdateValues
+	};
+	updatedRow[versionColumnName] = currentVersion + 1;
+	if (options.enforceConstraints) enforceOutgoingForeignKeys(namespaceStore, table, updatedRow, new Set(Object.keys(resolvedValues)), resolver);
+	const indexUpdates = Array.from(tableStore.indexes.values()).map((indexStore) => ({
+		indexStore,
+		oldKey: buildIndexKey(table, indexStore.definition, existing.row, resolver),
+		newKey: buildIndexKey(table, indexStore.definition, updatedRow, resolver)
+	}));
+	const applied = [];
+	try {
+		for (const update of indexUpdates) {
+			update.indexStore.index.update(update.oldKey, update.newKey, existing.internalId, { enforceUnique: options.enforceConstraints });
+			applied.push(update);
+		}
+	} catch (error) {
+		for (const update of applied.reverse()) update.indexStore.index.update(update.newKey, update.oldKey, existing.internalId, { enforceUnique: options.enforceConstraints });
+		throw error;
+	}
+	tableStore.rows.set(existing.internalId, updatedRow);
+	return () => {
+		for (const update of indexUpdates.slice().reverse()) update.indexStore.index.update(update.newKey, update.oldKey, existing.internalId, { enforceUnique: options.enforceConstraints });
+		tableStore.rows.set(existing.internalId, existing.row);
+	};
+};
+const deleteRow = (op, namespaceStore, tableStore, table, options, resolver) => {
+	const externalId = getExternalId(op.id);
+	const versionToCheck = getVersionToCheck(op.id, op.checkVersion);
+	const existing = findRowByExternalId(tableStore, table, externalId, resolver);
+	if (!existing) {
+		if (versionToCheck !== void 0) throw new VersionConflictError(`Version conflict: row "${externalId}" not found.`);
+		return null;
+	}
+	const versionColumnName = getPhysicalColumnName(table, "_version", resolver);
+	const currentVersion = Number(existing.row[versionColumnName] ?? 0);
+	if (versionToCheck !== void 0 && currentVersion !== versionToCheck) throw new VersionConflictError(`Version conflict: row "${externalId}" has changed.`);
+	if (options.enforceConstraints) enforceNoIncomingForeignKeys(namespaceStore, op.schema, table, existing.row, resolver);
+	const indexEntries = Array.from(tableStore.indexes.values()).map((indexStore) => ({
+		indexStore,
+		key: buildIndexKey(table, indexStore.definition, existing.row, resolver)
+	}));
+	const removedEntries = [];
+	for (const entry of indexEntries) {
+		if (!entry.indexStore.index.remove(entry.key, existing.internalId)) {
+			for (const removedEntry of removedEntries) removedEntry.indexStore.index.insert(removedEntry.key, existing.internalId, { enforceUnique: options.enforceConstraints });
+			throw new Error("Failed to remove index entry during delete.");
+		}
+		removedEntries.push(entry);
+	}
+	tableStore.rows.delete(existing.internalId);
+	return () => {
+		tableStore.rows.set(existing.internalId, existing.row);
+		for (const entry of indexEntries) entry.indexStore.index.insert(entry.key, existing.internalId, { enforceUnique: options.enforceConstraints });
+	};
+};
+const checkRow = (op, tableStore, table, resolver) => {
+	const existing = findRowByExternalId(tableStore, table, op.id.externalId, resolver);
+	if (!existing) throw new VersionConflictError(`Version conflict: row "${op.id.externalId}" not found.`);
+	const versionColumnName = getPhysicalColumnName(table, "_version", resolver);
+	if (Number(existing.row[versionColumnName] ?? 0) !== op.id.version) throw new VersionConflictError(`Version conflict: row "${op.id.externalId}" has changed.`);
+};
+const createInMemoryUowCompiler = () => ({
+	compileRetrievalOperation(op) {
+		return op;
+	},
+	compileMutationOperation(op) {
+		return {
+			query: op,
+			operation: op,
+			op: op.type,
+			expectedAffectedRows: null,
+			expectedReturnedRows: null
+		};
+	}
+});
+const createInMemoryUowExecutor = (store, options, resolverFactory) => ({
+	async executeRetrievalPhase(retrievalBatch) {
+		const results = [];
+		for (const compiled of retrievalBatch) {
+			if (compiled.type === "count" || compiled.type === "find") {
+				const resolver = getResolver(compiled.schema, compiled.namespace, resolverFactory);
+				const namespaceStore = getNamespaceStore(store, compiled.schema, compiled.namespace, resolver);
+				const tableStore = getTableStore(namespaceStore, compiled.table, resolver);
+				if (compiled.type === "find") results.push(findRows(compiled, namespaceStore, tableStore, resolver, options.clock.now));
+				else results.push([{ count: countRows(compiled, namespaceStore, tableStore, resolver, options.clock.now) }]);
+				continue;
+			}
+			throw new Error(`Unsupported in-memory retrieval operation: ${compiled.type}`);
+		}
+		return results;
+	},
+	async executeMutationPhase(mutationBatch) {
+		const createdInternalIds = [];
+		const rollbackActions = [];
+		try {
+			for (const compiled of mutationBatch) {
+				const operation = compiled.query;
+				if (operation.type === "create") {
+					const resolver = getResolver(operation.schema, operation.namespace, resolverFactory);
+					const namespaceStore = getNamespaceStore(store, operation.schema, operation.namespace, resolver);
+					const table = operation.schema.tables[operation.table];
+					if (!table) throw new Error(`Invalid table name ${operation.table}.`);
+					const tableStore = getTableStore(namespaceStore, table, resolver);
+					const previousInternalId = tableStore.nextInternalId;
+					const internalId = createRow(operation, namespaceStore, tableStore, options, resolver);
+					createdInternalIds.push(internalId);
+					rollbackActions.push(() => {
+						const row = tableStore.rows.get(internalId);
+						if (row) {
+							for (const indexStore of tableStore.indexes.values()) {
+								const key = buildIndexKey(table, indexStore.definition, row, resolver);
+								indexStore.index.remove(key, internalId);
+							}
+							tableStore.rows.delete(internalId);
+						}
+						tableStore.nextInternalId = previousInternalId;
+					});
+					continue;
+				}
+				if (operation.type === "update") {
+					const resolver = getResolver(operation.schema, operation.namespace, resolverFactory);
+					const namespaceStore = getNamespaceStore(store, operation.schema, operation.namespace, resolver);
+					const table = operation.schema.tables[operation.table];
+					if (!table) throw new Error(`Invalid table name ${operation.table}.`);
+					const rollback = updateRow(operation, namespaceStore, getTableStore(namespaceStore, table, resolver), options, resolver);
+					if (rollback) rollbackActions.push(rollback);
+					continue;
+				}
+				if (operation.type === "delete") {
+					const resolver = getResolver(operation.schema, operation.namespace, resolverFactory);
+					const namespaceStore = getNamespaceStore(store, operation.schema, operation.namespace, resolver);
+					const table = operation.schema.tables[operation.table];
+					if (!table) throw new Error(`Invalid table name ${operation.table}.`);
+					const rollback = deleteRow(operation, namespaceStore, getTableStore(namespaceStore, table, resolver), table, options, resolver);
+					if (rollback) rollbackActions.push(rollback);
+					continue;
+				}
+				if (operation.type === "check") {
+					const resolver = getResolver(operation.schema, operation.namespace, resolverFactory);
+					const namespaceStore = getNamespaceStore(store, operation.schema, operation.namespace, resolver);
+					const table = operation.schema.tables[operation.table];
+					if (!table) throw new Error(`Invalid table name ${operation.table}.`);
+					checkRow(operation, getTableStore(namespaceStore, table, resolver), table, resolver);
+					continue;
+				}
+				throw new Error(`Unsupported in-memory mutation "${operation.type}".`);
+			}
+		} catch (error) {
+			for (const rollback of rollbackActions.reverse()) rollback();
+			if (error instanceof VersionConflictError) return { success: false };
+			throw error;
+		}
+		return {
+			success: true,
+			createdInternalIds
+		};
+	}
+});
+var InMemoryUowDecoder = class {
+	#resolverFactory;
+	constructor(resolverFactory) {
+		this.#resolverFactory = resolverFactory;
+	}
+	decode(rawResults, operations) {
+		if (rawResults.length !== operations.length) throw new Error("rawResults and ops must have the same length");
+		return rawResults.map((result, index) => {
+			const op = operations[index];
+			if (!op) throw new Error("op must be defined");
+			if (op.type === "count") return this.decodeCount(result);
+			const resolver = getResolver(op.schema, op.namespace, this.#resolverFactory);
+			const decodedRows = result.map((row) => this.decodeRow(row, op.table, resolver));
+			if (op.withCursor) return this.decodeCursorResult(decodedRows, op.table, op);
+			return decodedRows;
+		});
+	}
+	decodeCount(result) {
+		if (typeof result === "number") return result;
+		const first = result[0];
+		if (!first) return 0;
+		const count = Number(first.count);
+		if (Number.isNaN(count)) throw new Error(`Unexpected result for count, received: ${first.count}`);
+		return count;
+	}
+	decodeRow(row, table, resolver) {
+		const output = {};
+		const columnValues = {};
+		const relationData = {};
+		const columnMap = resolver ? resolver.getColumnNameMap(table) : void 0;
+		for (const key in row) {
+			const colonIndex = key.indexOf(":");
+			if (colonIndex === -1) {
+				const logicalName = columnMap?.[key] ?? key;
+				if (table.columns[logicalName]) columnValues[logicalName] = row[key];
+				continue;
+			}
+			const relationName = key.slice(0, colonIndex);
+			const remainder = key.slice(colonIndex + 1);
+			if (!table.relations[relationName]) continue;
+			relationData[relationName] ??= {};
+			relationData[relationName][remainder] = row[key];
+		}
+		for (const relationName in relationData) {
+			const relation = table.relations[relationName];
+			if (!relation) continue;
+			output[relationName] = this.decodeRow(relationData[relationName], relation.table, resolver);
+		}
+		for (const key in columnValues) {
+			const column = table.columns[key];
+			if (!column) continue;
+			if (column.isHidden) continue;
+			if (column.role === "external-id" && columnValues["_internalId"] !== void 0) {
+				output[key] = new FragnoId({
+					externalId: columnValues[key],
+					internalId: columnValues["_internalId"],
+					version: columnValues["_version"]
+				});
+				continue;
+			}
+			if (column.role === "reference") {
+				const value = columnValues[key];
+				output[key] = value === null || value === void 0 ? null : FragnoReference.fromInternal(value);
+				continue;
+			}
+			output[key] = columnValues[key];
+		}
+		return output;
+	}
+	decodeCursorResult(decodedRows, table, operation) {
+		let cursor;
+		let hasNextPage = false;
+		let items = decodedRows;
+		if (operation.options.pageSize && operation.options.pageSize > 0 && decodedRows.length > operation.options.pageSize) {
+			hasNextPage = true;
+			items = decodedRows.slice(0, operation.options.pageSize);
+			if (operation.options.orderByIndex) {
+				const lastItem = items[items.length - 1];
+				const indexName = operation.options.orderByIndex.indexName;
+				let indexColumns;
+				if (indexName === "_primary") indexColumns = [table.getIdColumn()];
+				else {
+					const index = table.indexes[indexName];
+					if (index) indexColumns = index.columns;
+				}
+				if (indexColumns && lastItem) cursor = createCursorFromRecord(lastItem, indexColumns, {
+					indexName: operation.options.orderByIndex.indexName,
+					orderDirection: operation.options.orderByIndex.direction,
+					pageSize: operation.options.pageSize
+				});
+			}
+		}
+		return {
+			items,
+			cursor,
+			hasNextPage
+		};
+	}
+};
+
+//#endregion
+export { InMemoryUowDecoder, createInMemoryUowCompiler, createInMemoryUowExecutor };
+//# sourceMappingURL=in-memory-uow.js.map