@happyvertical/smrt-core 0.49.2 → 0.49.4

package/dist/change-feed.d.ts

@@ -140,6 +140,8 @@ export interface AppendChangeInput {
     /** Tenant the change belongs to (default `null` = global). */
     tenantId?: string | null;
 }
+/** A batch of mutations to append as one framework database statement. */
+export type AppendChangeBatch = readonly AppendChangeInput[];
 /** Retention bounds for {@link pruneChangeFeed}. At least one is required. */
 export interface ChangeFeedRetention {
     /** Prune entries older than this many milliseconds. */
@@ -225,6 +227,16 @@ export declare function ensureChangeFeedTable(db: DatabaseInterface): Promise<vo
  * handle from interleaving inside a manual SAVEPOINT scope.
  */
 export declare function appendChange(db: DatabaseInterface, input: AppendChangeInput): Promise<number | null>;
+/**
+ * Append a mutation batch with one feed row per input entry.
+ *
+ * The batch is deliberately one statement per supported dialect.  In
+ * particular, PostgreSQL enters the existing append helper from one
+ * framework-owned function call, so a caller transaction still stages every
+ * entry, preserves rollback/failure isolation, and never waits on the feed
+ * head.  Direct batches allocate contiguous sequences in input order.
+ */
+export declare function appendChanges(db: DatabaseInterface, inputs: AppendChangeBatch): Promise<Array<number | null>>;
 /**
  * Sequence change-feed entries staged inside caller-managed transactions
  * (issue #2649). PostgreSQL only; a no-op on every other engine.
@@ -417,6 +429,16 @@ export declare const CHANGE_FEED_WAS_PERSISTED_KEY = "_smrtChangeFeedWasPersiste
 export declare function registerChangeFeedWriter(): void;
 /** Unregister the change-feed writer (test helper). */
 export declare function unregisterChangeFeedWriter(): boolean;
+/**
+ * Record a collection mutation through one batch append and publish its direct
+ * entries in feed order.  The collection lifecycle supplies one database
+ * context; malformed or framework-owned instances are skipped just as the
+ * single-instance writer does.
+ */
+export declare function recordInstanceChanges(entries: readonly {
+    instance: SmrtObject;
+    operation: ChangeOperation;
+}[]): Promise<void>;
 /** Record a framework-owned mutation that intentionally bypasses save hooks. */
 export declare function recordInstanceChange(instance: SmrtObject, operation?: ChangeOperation): Promise<void>;
 /**

package/dist/change-feed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"change-feed.d.ts","sourceRoot":"","sources":["../src/change-feed.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"change-feed.d.ts","sourceRoot":"","sources":["../src/change-feed.ts"],"names":[],"mappings":"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"}

package/dist/change-feed.js

@@ -5,7 +5,7 @@ import { resolveDispatchTenantScope } from "./dispatch/tenant-resolver.js";
 import { isEmbeddedDatabase, withEmbeddedWriteQueue } from "./embedded-write-queue.js";
 import { GlobalInterceptors } from "./interceptors.js";
 import { detectEngine } from "./schema/ddl/index.js";
-import { CREATE_SMRT_CHANGES_TABLE, ENSURE_POSTGRES_CHANGE_FEED_APPEND_FUNCTION, ENSURE_POSTGRES_CHANGE_FEED_SCHEMA, FRAMEWORK_OPERATIONAL_TABLES, POSTGRES_CHANGE_FEED_APPEND_FUNCTION_IDENTITY, POSTGRES_CHANGE_FEED_APPEND_FUNCTION_NAME, POSTGRES_CHANGE_FEED_DRAIN_FUNCTION_IDENTITY, POSTGRES_CHANGE_FEED_DRAIN_FUNCTION_NAME, POSTGRES_CHANGE_FEED_HELPER_MARKER, POSTGRES_CHANGE_FEED_PENDING_TABLE, REPLACE_POSTGRES_CHANGE_FEED_APPEND_FUNCTION, RETIRED_SYSTEM_TABLES } from "./system/schema.js";
+import { CREATE_SMRT_CHANGES_TABLE, ENSURE_POSTGRES_CHANGE_FEED_APPEND_FUNCTION, ENSURE_POSTGRES_CHANGE_FEED_SCHEMA, FRAMEWORK_OPERATIONAL_TABLES, POSTGRES_CHANGE_FEED_APPEND_BATCH_FUNCTION_IDENTITY, POSTGRES_CHANGE_FEED_APPEND_BATCH_FUNCTION_NAME, POSTGRES_CHANGE_FEED_APPEND_FUNCTION_IDENTITY, POSTGRES_CHANGE_FEED_APPEND_FUNCTION_NAME, POSTGRES_CHANGE_FEED_DRAIN_FUNCTION_IDENTITY, POSTGRES_CHANGE_FEED_DRAIN_FUNCTION_NAME, POSTGRES_CHANGE_FEED_HELPER_MARKER, POSTGRES_CHANGE_FEED_PENDING_TABLE, REPLACE_POSTGRES_CHANGE_FEED_APPEND_FUNCTION, RETIRED_SYSTEM_TABLES } from "./system/schema.js";
 import { SYSTEM_TABLE_NAMES } from "./schema/system-table-shapes.js";
 import { createLogger } from "@happyvertical/logger";
 //#region src/change-feed.ts
@@ -269,7 +269,10 @@ var VALID_OPERATIONS = /* @__PURE__ */ new Set([
 ]);
 function getEngine(db, typeHint) {
 	const withConfig = db;
-	return detectEngine(db.url || withConfig.config?.url || "", typeHint || withConfig.type || withConfig.config?.type);
+	const engine = detectEngine(db.url || withConfig.config?.url || "", typeHint || withConfig.type || withConfig.config?.type);
+	const isDuckDbConnection = (withConfig.client?.constructor?.name?.toLowerCase() ?? "").includes("duckdb") || withConfig.client !== void 0 && "connection" in withConfig.client;
+	if (engine === "sqlite" && isDuckDbConnection) return "duckdb";
+	return engine;
 }
 /**
 * Positional placeholder factory: Postgres uses `$n`, SQLite/DuckDB use `?`.
@@ -338,14 +341,16 @@ function currentHelperProbe(identity) {
 async function postgresChangeFeedHelpersCurrent(db) {
 	const rows = getQueryRows(await db.query(`SELECT
          ${currentHelperProbe(POSTGRES_CHANGE_FEED_APPEND_FUNCTION_IDENTITY)} AS function_name,
+         ${currentHelperProbe(POSTGRES_CHANGE_FEED_APPEND_BATCH_FUNCTION_IDENTITY)} AS batch_function_name,
          ${currentHelperProbe(POSTGRES_CHANGE_FEED_DRAIN_FUNCTION_IDENTITY)} AS drain_function_name,
          to_regclass('${POSTGRES_CHANGE_FEED_PENDING_TABLE}') AS pending_table_name`));
-	return Boolean(rows[0]?.function_name && rows[0]?.drain_function_name && rows[0]?.pending_table_name);
+	return Boolean(rows[0]?.function_name && rows[0]?.batch_function_name && rows[0]?.drain_function_name && rows[0]?.pending_table_name);
 }
 async function getPostgresChangeFeedSchemaState(db) {
 	const rows = getQueryRows(await db.query(`SELECT
          to_regclass('${CHANGE_FEED_TABLE}') AS table_name,
          ${currentHelperProbe(POSTGRES_CHANGE_FEED_APPEND_FUNCTION_IDENTITY)} AS function_name,
+         ${currentHelperProbe(POSTGRES_CHANGE_FEED_APPEND_BATCH_FUNCTION_IDENTITY)} AS batch_function_name,
          to_regclass('${POSTGRES_CHANGE_FEED_PENDING_TABLE}') AS pending_table_name,
          ${currentHelperProbe(POSTGRES_CHANGE_FEED_DRAIN_FUNCTION_IDENTITY)} AS drain_function_name,
          (
@@ -358,6 +363,7 @@ async function getPostgresChangeFeedSchemaState(db) {
 	return {
 		tableExists: Boolean(rows[0]?.table_name),
 		functionExists: Boolean(rows[0]?.function_name),
+		batchFunctionExists: Boolean(rows[0]?.batch_function_name),
 		pendingTableExists: Boolean(rows[0]?.pending_table_name),
 		drainFunctionExists: Boolean(rows[0]?.drain_function_name),
 		createdAtType: rows[0]?.created_at_type ? String(rows[0].created_at_type) : null
@@ -412,7 +418,7 @@ async function ensurePostgresChangeFeedHelpers(db, typeHint) {
 	const state = await getPostgresChangeFeedSchemaState(db);
 	if (!state.tableExists) return;
 	if (state.createdAtType !== "timestamp with time zone") return;
-	if (state.functionExists && state.pendingTableExists && state.drainFunctionExists) return;
+	if (state.functionExists && state.batchFunctionExists && state.pendingTableExists && state.drainFunctionExists) return;
 	await db.query(ENSURE_POSTGRES_CHANGE_FEED_SCHEMA);
 }
 async function ensureChangeFeedTable(db) {
@@ -420,7 +426,7 @@ async function ensureChangeFeedTable(db) {
 	if (getEngine(db) === "postgres") {
 		const state = await getPostgresChangeFeedSchemaState(db);
 		assertPostgresChangeFeedTimestampCurrent(state);
-		if (state.tableExists && state.functionExists && state.pendingTableExists && state.drainFunctionExists && state.createdAtType === "timestamp with time zone") {
+		if (state.tableExists && state.functionExists && state.batchFunctionExists && state.pendingTableExists && state.drainFunctionExists && state.createdAtType === "timestamp with time zone") {
 			ensuredHandles.add(db);
 			return;
 		}
@@ -522,6 +528,75 @@ async function appendChange(db, input) {
 	throw new Error("appendChange exhausted retries without allocating a seq");
 }
 /**
+* Append a mutation batch with one feed row per input entry.
+*
+* The batch is deliberately one statement per supported dialect.  In
+* particular, PostgreSQL enters the existing append helper from one
+* framework-owned function call, so a caller transaction still stages every
+* entry, preserves rollback/failure isolation, and never waits on the feed
+* head.  Direct batches allocate contiguous sequences in input order.
+*/
+async function appendChanges(db, inputs) {
+	if (inputs.length === 0) return [];
+	const entries = inputs.map((input) => {
+		const table = input.table?.trim();
+		if (!table) throw new Error("appendChanges requires a non-empty table name");
+		const operation = input.operation ?? "update";
+		if (!VALID_OPERATIONS.has(operation)) throw new Error(`appendChanges operation must be one of create/update/delete, got '${String(input.operation)}'`);
+		return {
+			table,
+			rowId: input.rowId ?? null,
+			operation,
+			tenantId: input.tenantId ?? null,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	});
+	const engine = getEngine(db);
+	const p = placeholders(db);
+	const payload = JSON.stringify(entries);
+	const sql = engine === "postgres" ? `SELECT entry_index, allocated_seq, error_code, error_message FROM ${POSTGRES_CHANGE_FEED_APPEND_BATCH_FUNCTION_NAME}(${p(1)}::jsonb)` : engine === "sqlite" ? `WITH input AS (SELECT CAST(key AS INTEGER) AS entry_index, json_extract(value, '$.table') AS table_name, json_extract(value, '$.rowId') AS row_id, json_extract(value, '$.operation') AS operation, json_extract(value, '$.tenantId') AS tenant_id, json_extract(value, '$.timestamp') AS created_at FROM json_each(${p(1)})), numbered AS (SELECT *, COALESCE((SELECT MAX(seq) FROM ${CHANGE_FEED_TABLE}), 0) + row_number() OVER (ORDER BY entry_index) AS seq FROM input) INSERT INTO ${CHANGE_FEED_TABLE} (seq, table_name, row_id, operation, tenant_id, created_at) SELECT seq, table_name, row_id, operation, tenant_id, created_at FROM numbered RETURNING seq` : `WITH input AS (SELECT CAST(key AS INTEGER) AS entry_index, json_extract_string(value, '$.table') AS table_name, json_extract_string(value, '$.rowId') AS row_id, json_extract_string(value, '$.operation') AS operation, json_extract_string(value, '$.tenantId') AS tenant_id, CAST(json_extract_string(value, '$.timestamp') AS TIMESTAMP) AS created_at FROM json_each(${p(1)})), numbered AS (SELECT *, COALESCE((SELECT MAX(seq) FROM ${CHANGE_FEED_TABLE}), 0) + row_number() OVER (ORDER BY entry_index) AS seq FROM input) INSERT INTO ${CHANGE_FEED_TABLE} (seq, table_name, row_id, operation, tenant_id, created_at) SELECT seq, table_name, row_id, operation, tenant_id, created_at FROM numbered RETURNING seq`;
+	const drainedSignals = await drainBeforeAppend(db);
+	const settleDrainedSignals = (sequenced) => {
+		if (drainedSignals.length === 0) return;
+		if (sequenced) publishSignals(db, drainedSignals);
+		else queueDeferredSignals(db, drainedSignals);
+	};
+	for (let attempt = 1; attempt <= MAX_APPEND_ATTEMPTS; attempt++) try {
+		const rows = getQueryRows(await withEmbeddedWriteQueue(db, isEmbeddedDatabase(db), () => db.query(sql, payload)));
+		if (engine === "postgres") {
+			const failure = rows.find((row) => row.error_code != null);
+			if (failure) {
+				const error = new Error(String(failure.error_message || "PostgreSQL change-feed batch append failed"));
+				error.code = String(failure.error_code);
+				throw error;
+			}
+			if (rows.length !== entries.length) throw new Error("PostgreSQL change-feed batch append returned an incomplete result");
+			const result = Array(entries.length).fill(null);
+			const seenIndexes = /* @__PURE__ */ new Set();
+			for (const row of rows) {
+				const index = Number(row.entry_index);
+				if (!Number.isInteger(index) || index < 0 || index >= result.length || seenIndexes.has(index)) throw new Error("PostgreSQL change-feed batch append returned invalid indexes");
+				seenIndexes.add(index);
+				result[index] = row.allocated_seq == null ? null : toSeqNumber(row.allocated_seq);
+			}
+			if (result.some((seq) => seq === null)) noteStagedAppend(db);
+			settleDrainedSignals(!result.some((seq) => seq === null));
+			for (const seq of result) if (seq != null) recordUncommittedDrainMark(db, seq);
+			return result;
+		}
+		if (rows.length !== entries.length) throw new Error("Change feed batch append returned an incomplete result");
+		const result = rows.map((row) => toSeqNumber(row.seq)).sort((a, b) => a - b);
+		settleDrainedSignals(true);
+		return result;
+	} catch (error) {
+		if (!isUniqueViolation(error) || attempt === MAX_APPEND_ATTEMPTS) {
+			queueDeferredSignals(db, drainedSignals);
+			throw error;
+		}
+	}
+	throw new Error("appendChanges exhausted retries without allocating a sequence");
+}
+/**
 * Sequence change-feed entries staged inside caller-managed transactions
 * (issue #2649). PostgreSQL only; a no-op on every other engine.
 *
@@ -1037,6 +1112,21 @@ function registerChangeFeedWriter() {
 		},
 		async afterDelete(instance) {
 			await appendForInstance(instance, "delete");
+		},
+		bulkMutation: {
+			compatible: () => true,
+			async afterSave(entries) {
+				await recordInstanceChanges(entries.map(({ instance, context }) => ({
+					instance,
+					operation: context.metadata?.["_smrtChangeFeedWasPersisted"] === true ? "update" : "create"
+				})));
+			},
+			async afterDelete(entries) {
+				await recordInstanceChanges(entries.map(({ instance }) => ({
+					instance,
+					operation: "delete"
+				})));
+			}
 		}
 	});
 }
@@ -1081,6 +1171,57 @@ async function appendForInstance(instance, operation) {
 		warnAppendFailureOnce(db, table, error);
 	}
 }
+/**
+* Record a collection mutation through one batch append and publish its direct
+* entries in feed order.  The collection lifecycle supplies one database
+* context; malformed or framework-owned instances are skipped just as the
+* single-instance writer does.
+*/
+async function recordInstanceChanges(entries) {
+	const prepared = [];
+	for (const entry of entries) try {
+		const table = entry.instance.tableName;
+		if (!isChangeFeedObservableTable(table)) continue;
+		const id = entry.instance.id;
+		const tenantId = entry.instance.tenantId;
+		prepared.push({
+			db: entry.instance.db,
+			input: {
+				table,
+				rowId: typeof id === "string" && id ? id : null,
+				operation: entry.operation,
+				tenantId: typeof tenantId === "string" && tenantId ? tenantId : null
+			}
+		});
+	} catch {}
+	if (prepared.length === 0) return;
+	const db = prepared[0].db;
+	if (prepared.some((entry) => entry.db !== db)) {
+		await Promise.all(prepared.map(({ input, db: entryDb }) => appendChange(entryDb, input)));
+		return;
+	}
+	try {
+		const sequences = await appendChanges(db, prepared.map(({ input }) => input));
+		for (let index = 0; index < prepared.length; index++) {
+			const seq = sequences[index];
+			if (seq == null) continue;
+			const input = prepared[index].input;
+			try {
+				publishChangeSignal(db, {
+					table: input.table,
+					operation: input.operation ?? "update",
+					rowId: input.rowId ?? null,
+					tenantId: input.tenantId ?? null,
+					seq
+				});
+			} catch (error) {
+				warnSignalPublishFailureOnce(db, input.table, error);
+			}
+		}
+	} catch (error) {
+		warnAppendFailureOnce(db, prepared[0].input.table, error);
+	}
+}
 /** Record a framework-owned mutation that intentionally bypasses save hooks. */
 async function recordInstanceChange(instance, operation = "update") {
 	await appendForInstance(instance, operation);
@@ -1121,6 +1262,6 @@ function resetChangeFeedWarnings() {
 	deferredSignals.clear();
 }
 //#endregion
-export { CHANGE_FEED_EXCLUDED_TABLES, CHANGE_FEED_INTERCEPTOR_NAME, CHANGE_FEED_TABLE, CHANGE_FEED_WAS_PERSISTED_KEY, DEFAULT_CHANGES_LIMIT, MAX_CHANGES_LIMIT, appendChange, bumpChangeFeed, drainChangeFeed, ensureChangeFeedTable, ensurePostgresChangeFeedAppendFunction, ensurePostgresChangeFeedHelpers, getChangesSince, getTableVersion, getTenantScopedChangesSince, isChangeFeedObservableTable, pruneChangeFeed, recordInstanceChange, registerChangeFeedWriter, resetChangeFeedWarnings, unregisterChangeFeedWriter };
+export { CHANGE_FEED_EXCLUDED_TABLES, CHANGE_FEED_INTERCEPTOR_NAME, CHANGE_FEED_TABLE, CHANGE_FEED_WAS_PERSISTED_KEY, DEFAULT_CHANGES_LIMIT, MAX_CHANGES_LIMIT, appendChange, appendChanges, bumpChangeFeed, drainChangeFeed, ensureChangeFeedTable, ensurePostgresChangeFeedAppendFunction, ensurePostgresChangeFeedHelpers, getChangesSince, getTableVersion, getTenantScopedChangesSince, isChangeFeedObservableTable, pruneChangeFeed, recordInstanceChange, recordInstanceChanges, registerChangeFeedWriter, resetChangeFeedWarnings, unregisterChangeFeedWriter };
 
 //# sourceMappingURL=change-feed.js.map