@mastra/spanner 1.9.4 → 1.9.5-alpha.0

package/dist/index.js

@@ -272,6 +272,51 @@ var SpannerDB = class extends MastraBase {
 		}
 	}
 	/**
+	* Delete up to `limit` rows keyed by `runId` whose epoch-ms `column` is
+	* older than `cutoff`. Used to prune the run fencing tables.
+	*/
+	async pruneRunRows({ tableName, column, cutoff, limit }) {
+		const table = quoteIdent(tableName, "table name");
+		const col = quoteIdent(column, "column name");
+		const runId = quoteIdent("runId", "column name");
+		const [rows] = await this.database.run({
+			sql: `SELECT ${runId} FROM ${table} WHERE ${col} IS NOT NULL AND ${col} < @cutoff ORDER BY ${col} LIMIT @limit`,
+			params: {
+				cutoff,
+				limit
+			},
+			types: {
+				cutoff: "int64",
+				limit: "int64"
+			},
+			json: true
+		});
+		const runIds = rows.map((row) => row.runId);
+		if (runIds.length === 0) return 0;
+		let deleted = 0;
+		await this.runWithAbortRetry(async () => {
+			await this.database.runTransactionAsync(async (tx) => {
+				const [count] = await tx.runUpdate({
+					sql: `DELETE FROM ${table} WHERE ${runId} IN UNNEST(@runIds) AND ${col} < @cutoff`,
+					params: {
+						runIds,
+						cutoff
+					},
+					types: {
+						runIds: {
+							type: "array",
+							child: "string"
+						},
+						cutoff: "int64"
+					}
+				});
+				await tx.commit();
+				deleted = count;
+			});
+		});
+		return deleted;
+	}
+	/**
 	* Determine the primary-key column list for a table. Some core tables (like
 	* `mastra_workflow_snapshot`) don't carry a single-column PK in the schema,
 	* so we hardcode known composite PKs here.
@@ -6760,6 +6805,17 @@ var MemorySpanner = class MemorySpanner extends MemoryStorage {
 		TABLE_MESSAGES,
 		TABLE_RESOURCES
 	];
+	/**
+	* Tables `prune()` can clean up. Run fences anchor on `retiredAt` (epoch ms), which stays NULL until the
+	* execution holding the fence settles, so a running execution's fence is
+	* never pruned.
+	*/
+	static retentionTables = { runFences: {
+		table: TABLE_MEMORY_RUN_FENCES,
+		column: "retiredAt",
+		indexed: false,
+		anchorType: "epoch-ms"
+	} };
 	constructor(config) {
 		super();
 		const { database, indexes, skipDefaultIndexes, initMode } = resolveSpannerConfig(config);
@@ -6816,6 +6872,24 @@ var MemorySpanner = class MemorySpanner extends MemoryStorage {
 		await this.db.createIndexes(this.indexes);
 	}
 	/** Removes every row from threads/messages/resources and run fence tables. Intended for tests. */
+	async prune(policies, options) {
+		return executeRetentionPrune({
+			domain: "memory",
+			targets: resolveRetentionTargets({
+				policies,
+				descriptor: MemorySpanner.retentionTables,
+				order: ["runFences"]
+			}),
+			options,
+			cutoffFor: (target, now) => retentionCutoffMs(target.policy, now),
+			deleteBatch: (target, cutoff, limit) => this.db.pruneRunRows({
+				tableName: target.table,
+				column: target.column,
+				cutoff,
+				limit
+			})
+		});
+	}
 	async dangerouslyClearAll() {
 		await this.db.clearTable({ tableName: TABLE_MESSAGES });
 		await this.db.clearTable({ tableName: TABLE_THREADS });
@@ -12478,6 +12552,17 @@ var WorkflowsSpanner = class WorkflowsSpanner extends WorkflowsStorage {
 	skipDefaultIndexes;
 	indexes;
 	static MANAGED_TABLES = [TABLE_WORKFLOW_SNAPSHOT];
+	/**
+	* Tables `prune()` can clean up. Run ownership rows anchor on `updatedAt` (epoch ms), which every
+	* claim, renewal and release refreshes, so a live execution's row is never
+	* older than its renew interval.
+	*/
+	static retentionTables = { runOwnership: {
+		table: TABLE_WORKFLOW_RUN_OWNERS,
+		column: "updatedAt",
+		indexed: false,
+		anchorType: "epoch-ms"
+	} };
 	constructor(config) {
 		super();
 		const { database, indexes, skipDefaultIndexes, initMode } = resolveSpannerConfig(config);
@@ -12610,6 +12695,24 @@ var WorkflowsSpanner = class WorkflowsSpanner extends WorkflowsStorage {
 		await this.db.createIndexes(this.indexes);
 	}
 	/** Removes every workflow snapshot and run ownership row. Intended for tests. */
+	async prune(policies, options) {
+		return executeRetentionPrune({
+			domain: "workflows",
+			targets: resolveRetentionTargets({
+				policies,
+				descriptor: WorkflowsSpanner.retentionTables,
+				order: ["runOwnership"]
+			}),
+			options,
+			cutoffFor: (target, now) => retentionCutoffMs(target.policy, now),
+			deleteBatch: (target, cutoff, limit) => this.db.pruneRunRows({
+				tableName: target.table,
+				column: target.column,
+				cutoff,
+				limit
+			})
+		});
+	}
 	async dangerouslyClearAll() {
 		await this.db.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
 		await this.db.clearTable({ tableName: TABLE_WORKFLOW_RUN_OWNERS });