@fragno-dev/db 0.3.0 → 0.4.1

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

@@ -1,16 +1,22 @@
+import { getDbNowOffsetMs, isDbNow } from "../../query/db-now.js";
+import { buildCondition } from "../../query/condition-builder.js";
 import { FragnoId, FragnoReference } from "../../schema/create.js";
+import { SQLocalDriverConfig } from "../generic-sql/driver-config.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 { SETTINGS_NAMESPACE, SETTINGS_TABLE_NAME, internalSchema } from "../../fragments/internal-fragment.schema.js";
+import { encodeVersionstamp, parseOutboxVersionValue, versionstampToHex } from "../../outbox/outbox.js";
+import { buildOutboxPlan, finalizeOutboxPayload } from "../../outbox/outbox-builder.js";
+import "../../fragments/internal-fragment.js";
+import { resolveReferenceSubqueries } from "./reference-resolution.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";
+import superjson from "superjson";
 
 //#region src/adapters/in-memory/in-memory-uow.ts
+const OUTBOX_VERSION_KEY = `${SETTINGS_NAMESPACE}.outbox_version`;
 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;
@@ -98,16 +104,19 @@ const findJoinMatches = (parentRow, parentTable, join, namespaceStore, resolver,
 			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 actualLeft = leftColumn.role === "external-id" && rightColumn.role !== "external-id" ? "_internalId" : left;
+			const actualLeftColumn = parentTable.columns[actualLeft];
+			if (!actualLeftColumn) throw new Error(`Column "${actualLeft}" not found on table "${parentTable.name}".`);
+			const actualRight = rightColumn.role === "external-id" && leftColumn.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 leftValue = parentRow[getPhysicalColumnName(parentTable, actualLeft, 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) {
+			if (compareNormalizedValues(normalizeIndexValue(leftValue, actualLeftColumn), normalizeIndexValue(rightValue, actualRightColumn)) !== 0) {
 				matchesJoin = false;
 				break;
 			}
@@ -174,7 +183,7 @@ const getReferencedColumn = (table, columnName, resolver) => {
 };
 const enforceOutgoingForeignKeys = (namespaceStore, table, row, columnsToCheck, resolver) => {
 	for (const relation of Object.values(table.relations)) {
-		if (relation.type !== "one") continue;
+		if (relation.type !== "one" || relation.foreignKey === false) 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;
@@ -203,7 +212,7 @@ const enforceOutgoingForeignKeys = (namespaceStore, table, row, columnsToCheck,
 };
 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.type !== "one" || relation.foreignKey === false) continue;
 		if (relation.table.name !== table.name) continue;
 		const sourceStore = getTableStore(namespaceStore, sourceTable, resolver);
 		const targetColumnInfo = relation.on.map(([, foreignName]) => getReferencedColumn(table, foreignName, resolver));
@@ -271,7 +280,7 @@ const findRows = (op, namespaceStore, tableStore, resolver, now = () => /* @__PU
 	const limit = op.withCursor && op.options.pageSize !== void 0 ? op.options.pageSize + 1 : op.options.pageSize;
 	const scanOptions = {
 		direction,
-		limit,
+		limit: void 0,
 		start: void 0,
 		startInclusive: true,
 		end: void 0,
@@ -324,7 +333,12 @@ const countRows = (op, namespaceStore, tableStore, resolver, now = () => /* @__P
 	}
 	return count;
 };
-const resolveDbNowValue = (value, options) => isDbNow(value) ? options.clock.now() : value;
+const resolveDbNowValue = (value, options) => {
+	if (!isDbNow(value)) return value;
+	const now = options.clock.now();
+	const offsetMs = getDbNowOffsetMs(value);
+	return offsetMs === 0 ? now : new Date(now.getTime() + offsetMs);
+};
 const createRow = (op, namespaceStore, tableStore, options, resolver) => {
 	const table = op.schema.tables[op.table];
 	if (!table) throw new Error(`Invalid table name ${op.table}.`);
@@ -446,6 +460,173 @@ const checkRow = (op, tableStore, table, resolver) => {
 	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 resolveSchemaForLookup = (table, namespace, schemaByNamespace) => {
+	if (!schemaByNamespace) return null;
+	if (namespace !== void 0) {
+		const entry = schemaByNamespace.get(namespace);
+		if (entry && entry.schema.tables[table.name] === table) return entry;
+		return null;
+	}
+	for (const entry of schemaByNamespace.values()) if (entry.schema.tables[table.name] === table) return entry;
+	return null;
+};
+const reserveOutboxVersion = (store, options, resolverFactory) => {
+	const resolver = getResolver(internalSchema, null, resolverFactory);
+	const namespaceStore = getNamespaceStore(store, internalSchema, null, resolver);
+	const settingsTable = internalSchema.tables[SETTINGS_TABLE_NAME];
+	if (!settingsTable) throw new Error("Missing internal settings table definition.");
+	const tableStore = getTableStore(namespaceStore, settingsTable, resolver);
+	const keyColumnName = getPhysicalColumnName(settingsTable, "key", resolver);
+	const valueColumnName = getPhysicalColumnName(settingsTable, "value", resolver);
+	const idColumnName = getPhysicalColumnName(settingsTable, settingsTable.getIdColumn().name, resolver);
+	for (const row of tableStore.rows.values()) {
+		if (row[keyColumnName] !== OUTBOX_VERSION_KEY) continue;
+		const rawValue = row[valueColumnName];
+		const next = parseOutboxVersionValue(rawValue) + 1n;
+		const externalId = row[idColumnName];
+		if (typeof externalId !== "string") throw new Error("Outbox version row is missing external id.");
+		return {
+			version: next,
+			rollback: updateRow({
+				type: "update",
+				schema: internalSchema,
+				namespace: null,
+				table: settingsTable.name,
+				id: externalId,
+				checkVersion: false,
+				set: { value: next.toString() }
+			}, namespaceStore, tableStore, options, resolver) ?? (() => {})
+		};
+	}
+	const createOp = {
+		type: "create",
+		schema: internalSchema,
+		namespace: null,
+		table: settingsTable.name,
+		values: {
+			key: OUTBOX_VERSION_KEY,
+			value: "0"
+		},
+		generatedExternalId: options.idGenerator()
+	};
+	const previousInternalId = tableStore.nextInternalId;
+	const internalId = createRow(createOp, namespaceStore, tableStore, options, resolver);
+	const rollback = () => {
+		const existingRow = tableStore.rows.get(internalId);
+		if (existingRow) {
+			for (const indexStore of tableStore.indexes.values()) {
+				const key = buildIndexKey(settingsTable, indexStore.definition, existingRow, resolver);
+				indexStore.index.remove(key, internalId);
+			}
+			tableStore.rows.delete(internalId);
+		}
+		tableStore.nextInternalId = previousInternalId;
+	};
+	return {
+		version: 0n,
+		rollback
+	};
+};
+const resolveOutboxRefMap = (store, lookups, resolverFactory, schemaByNamespace) => {
+	if (lookups.length === 0) return;
+	const refMap = {};
+	for (const lookup of lookups) {
+		const schemaEntry = resolveSchemaForLookup(lookup.table, lookup.namespace, schemaByNamespace);
+		if (!schemaEntry) throw new Error(`Failed to resolve schema for outbox lookup on ${lookup.table.name}.`);
+		const resolver = getResolver(schemaEntry.schema, schemaEntry.namespace, resolverFactory);
+		const tableStore = getTableStore(getNamespaceStore(store, schemaEntry.schema, schemaEntry.namespace, resolver), lookup.table, resolver);
+		const internalId = typeof lookup.internalId === "number" ? BigInt(lookup.internalId) : lookup.internalId;
+		const row = tableStore.rows.get(internalId);
+		if (!row) {
+			const tableName = resolver ? resolver.getTableName(lookup.table.name) : lookup.table.name;
+			const internalColumn = resolver ? resolver.getColumnName(lookup.table.name, lookup.table.getInternalIdColumn().name) : lookup.table.getInternalIdColumn().name;
+			throw new Error(`Failed to resolve outbox reference for ${tableName}.${internalColumn}=${String(lookup.internalId)}`);
+		}
+		const externalId = row[getPhysicalColumnName(lookup.table, lookup.table.getIdColumn().name, resolver)];
+		if (typeof externalId !== "string") throw new Error("Outbox reference row is missing external id.");
+		refMap[lookup.key] = externalId;
+	}
+	return Object.keys(refMap).length > 0 ? refMap : void 0;
+};
+const insertOutboxRow = (store, options, resolverFactory, payload) => {
+	const resolver = getResolver(internalSchema, null, resolverFactory);
+	const namespaceStore = getNamespaceStore(store, internalSchema, null, resolver);
+	const outboxTable = internalSchema.tables.fragno_db_outbox;
+	if (!outboxTable) throw new Error("Missing internal outbox table definition.");
+	const tableStore = getTableStore(namespaceStore, outboxTable, resolver);
+	const createOp = {
+		type: "create",
+		schema: internalSchema,
+		namespace: null,
+		table: outboxTable.name,
+		values: {
+			versionstamp: payload.versionstamp,
+			uowId: payload.uowId,
+			payload: payload.payload,
+			...payload.refMap ? { refMap: payload.refMap } : {}
+		},
+		generatedExternalId: options.idGenerator()
+	};
+	const previousInternalId = tableStore.nextInternalId;
+	const internalId = createRow(createOp, namespaceStore, tableStore, options, resolver);
+	return () => {
+		const existingRow = tableStore.rows.get(internalId);
+		if (existingRow) {
+			for (const indexStore of tableStore.indexes.values()) {
+				const key = buildIndexKey(outboxTable, indexStore.definition, existingRow, resolver);
+				indexStore.index.remove(key, internalId);
+			}
+			tableStore.rows.delete(internalId);
+		}
+		tableStore.nextInternalId = previousInternalId;
+	};
+};
+const insertOutboxMutationRows = (store, options, resolverFactory, payload) => {
+	if (payload.mutations.length === 0) return [];
+	const resolver = getResolver(internalSchema, null, resolverFactory);
+	const namespaceStore = getNamespaceStore(store, internalSchema, null, resolver);
+	const mutationsTable = internalSchema.tables.fragno_db_outbox_mutations;
+	if (!mutationsTable) throw new Error("Missing internal outbox mutations table definition.");
+	const tableStore = getTableStore(namespaceStore, mutationsTable, resolver);
+	const rollbackActions = [];
+	try {
+		for (const mutation of payload.mutations) {
+			const createOp = {
+				type: "create",
+				schema: internalSchema,
+				namespace: null,
+				table: mutationsTable.name,
+				values: {
+					entryVersionstamp: payload.entryVersionstamp,
+					mutationVersionstamp: mutation.versionstamp,
+					uowId: payload.uowId,
+					schema: mutation.schema,
+					table: mutation.table,
+					externalId: mutation.externalId,
+					op: mutation.op
+				},
+				generatedExternalId: options.idGenerator()
+			};
+			const previousInternalId = tableStore.nextInternalId;
+			const internalId = createRow(createOp, namespaceStore, tableStore, options, resolver);
+			rollbackActions.push(() => {
+				const existingRow = tableStore.rows.get(internalId);
+				if (existingRow) {
+					for (const indexStore of tableStore.indexes.values()) {
+						const key = buildIndexKey(mutationsTable, indexStore.definition, existingRow, resolver);
+						indexStore.index.remove(key, internalId);
+					}
+					tableStore.rows.delete(internalId);
+				}
+				tableStore.nextInternalId = previousInternalId;
+			});
+		}
+	} catch (error) {
+		for (const rollback of rollbackActions.reverse()) rollback();
+		throw error;
+	}
+	return rollbackActions;
+};
 const createInMemoryUowCompiler = () => ({
 	compileRetrievalOperation(op) {
 		return op;
@@ -460,7 +641,7 @@ const createInMemoryUowCompiler = () => ({
 		};
 	}
 });
-const createInMemoryUowExecutor = (store, options, resolverFactory) => ({
+const createInMemoryUowExecutor = (store, options, resolverFactory, schemaByNamespace) => ({
 	async executeRetrievalPhase(retrievalBatch) {
 		const results = [];
 		for (const compiled of retrievalBatch) {
@@ -479,7 +660,23 @@ const createInMemoryUowExecutor = (store, options, resolverFactory) => ({
 	async executeMutationPhase(mutationBatch) {
 		const createdInternalIds = [];
 		const rollbackActions = [];
+		const outboxEnabled = options.outbox?.enabled ?? false;
+		const shouldInclude = options.outbox?.shouldInclude;
+		const outboxOperations = outboxEnabled ? mutationBatch.flatMap((mutation) => {
+			const operation = mutation.operation;
+			if (!operation) return [];
+			if (shouldInclude && !shouldInclude(operation)) return [];
+			return [operation];
+		}) : [];
+		const outboxPlan = outboxOperations.length > 0 ? buildOutboxPlan(outboxOperations) : null;
+		const shouldWriteOutbox = outboxEnabled && outboxPlan !== null && outboxPlan.drafts.length > 0;
+		let outboxVersion = null;
 		try {
+			if (shouldWriteOutbox) {
+				const reservation = reserveOutboxVersion(store, options, resolverFactory);
+				outboxVersion = reservation.version;
+				rollbackActions.push(reservation.rollback);
+			}
 			for (const compiled of mutationBatch) {
 				const operation = compiled.query;
 				if (operation.type === "create") {
@@ -532,6 +729,26 @@ const createInMemoryUowExecutor = (store, options, resolverFactory) => ({
 				}
 				throw new Error(`Unsupported in-memory mutation "${operation.type}".`);
 			}
+			if (shouldWriteOutbox && outboxPlan && outboxVersion !== null) {
+				const uowId = mutationBatch[0]?.uowId;
+				if (!uowId) throw new Error("Outbox mutation batch is missing uowId.");
+				const refMap = resolveOutboxRefMap(store, outboxPlan.lookups, resolverFactory, schemaByNamespace);
+				const payload = finalizeOutboxPayload(outboxPlan, outboxVersion);
+				const payloadSerialized = superjson.serialize(payload);
+				const versionstamp = versionstampToHex(encodeVersionstamp(outboxVersion, 0));
+				rollbackActions.push(...insertOutboxMutationRows(store, options, resolverFactory, {
+					entryVersionstamp: versionstamp,
+					uowId,
+					mutations: payload.mutations
+				}));
+				const rollback = insertOutboxRow(store, options, resolverFactory, {
+					versionstamp,
+					uowId,
+					payload: payloadSerialized,
+					refMap
+				});
+				rollbackActions.push(rollback);
+			}
 		} catch (error) {
 			for (const rollback of rollbackActions.reverse()) rollback();
 			if (error instanceof VersionConflictError) return { success: false };
@@ -589,7 +806,13 @@ var InMemoryUowDecoder = class {
 		for (const relationName in relationData) {
 			const relation = table.relations[relationName];
 			if (!relation) continue;
-			output[relationName] = this.decodeRow(relationData[relationName], relation.table, resolver);
+			const relationRow = relationData[relationName];
+			const internalIdKey = relation.table.getInternalIdColumn().name;
+			if (Object.prototype.hasOwnProperty.call(relationRow, internalIdKey) && isNullish(relationRow[internalIdKey])) {
+				output[relationName] = relation.type === "many" ? [] : null;
+				continue;
+			}
+			output[relationName] = this.decodeRow(relationRow, relation.table, resolver);
 		}
 		for (const key in columnValues) {
 			const column = table.columns[key];