@mastra/dynamodb 1.4.2 → 1.4.3

package/dist/index.js

@@ -1,7 +1,7 @@
 import { DescribeTableCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
 import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
-import { BackgroundTasksStorage, MastraCompositeStore, MemoryStorage, RunFenceConflictError, SCORERS_SCHEMA, ScoresStorage, TABLE_BACKGROUND_TASKS, TABLE_MEMORY_RUN_FENCES, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_RUN_OWNERS, TABLE_WORKFLOW_SNAPSHOT, WorkflowsStorage, calculatePagination, createStorageErrorId, isRunFenceConflictError, matchesExpectedWorkflowStatus, matchesRunFence, normalizePerPage, resolveRunFence, storageMessageMatchesMetadataFilter, validateStorageMetadataFilter } from "@mastra/core/storage";
+import { BackgroundTasksStorage, MastraCompositeStore, MemoryStorage, RunFenceConflictError, SCORERS_SCHEMA, ScoresStorage, TABLE_BACKGROUND_TASKS, TABLE_MEMORY_RUN_FENCES, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_RUN_OWNERS, TABLE_WORKFLOW_SNAPSHOT, WorkflowsStorage, calculatePagination, createStorageErrorId, executeRetentionPrune, isRunFenceConflictError, matchesExpectedWorkflowStatus, matchesRunFence, normalizePerPage, resolveRetentionTargets, resolveRunFence, retentionCutoffMs, storageMessageMatchesMetadataFilter, validateStorageMetadataFilter } from "@mastra/core/storage";
 import { Entity, Service } from "electrodb";
 import { MessageList } from "@mastra/core/agent";
 import { saveScorePayloadSchema } from "@mastra/core/evals";
@@ -1686,9 +1686,52 @@ async function goWithRunFence(service, check, write) {
 		await backoff(attempt);
 	}
 }
+/**
+* Deletes up to `limit` items of a run claim entity whose epoch-ms `attribute`
+* is older than `cutoff`. These entities have no index on the anchor, so this
+* scans for them. Each delete repeats the cutoff as its condition, so an item
+* claimed or raised again since the scan is kept.
+*/
+async function pruneRunClaims(service, entityName, attribute, cutoff, limit) {
+	const entity = service.entities[entityName];
+	const olderThanCutoff = (attr, op) => op.lt(attr[attribute], cutoff);
+	let deleted = 0;
+	let cursor = null;
+	do {
+		const page = await entity.scan.where(olderThanCutoff).go({
+			cursor,
+			limit: limit - deleted
+		});
+		for (const item of page.data) {
+			try {
+				await retryOnTransactionConflict(() => entity.delete({
+					entity: entityName,
+					run_id: item.run_id
+				}).where(olderThanCutoff).go());
+				deleted++;
+			} catch (error) {
+				if (!isConditionalCheckFailed(error)) throw error;
+			}
+			if (deleted >= limit) return deleted;
+		}
+		cursor = page.cursor;
+	} while (cursor);
+	return deleted;
+}
 //#endregion
 //#region src/storage/domains/memory/index.ts
-var MemoryStorageDynamoDB = class extends MemoryStorage {
+var MemoryStorageDynamoDB = class MemoryStorageDynamoDB extends MemoryStorage {
+	/**
+	* Tables `prune()` can clean up. Run fences anchor on `retiredAt` (epoch ms), which stays unset 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"
+	} };
 	supportsPartialThreadUpdate = true;
 	service;
 	ttlConfig;
@@ -1701,6 +1744,19 @@ var MemoryStorageDynamoDB = class extends MemoryStorage {
 	supportsRunFencing() {
 		return true;
 	}
+	async prune(policies, options) {
+		return executeRetentionPrune({
+			domain: "memory",
+			targets: resolveRetentionTargets({
+				policies,
+				descriptor: MemoryStorageDynamoDB.retentionTables,
+				order: ["runFences"]
+			}),
+			options,
+			cutoffFor: (target, now) => retentionCutoffMs(target.policy, now),
+			deleteBatch: (_target, cutoff, limit) => pruneRunClaims(this.service, "memory_run_fence", "retiredAt", Number(cutoff), limit)
+		});
+	}
 	async dangerouslyClearAll() {
 		await deleteTableData(this.service, TABLE_THREADS);
 		await deleteTableData(this.service, TABLE_MESSAGES);
@@ -2832,7 +2888,18 @@ function toRunOwnershipRecord(item) {
 }
 const MAX_RETRIES = 5;
 const BASE_DELAY_MS = 50;
-var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
+var WorkflowStorageDynamoDB = class WorkflowStorageDynamoDB extends WorkflowsStorage {
+	/**
+	* Tables `prune()` can clean up. Run ownership records anchor on `updatedAt` (epoch ms), which every
+	* claim, renewal and release refreshes, so a live execution's record is never
+	* older than its renew interval.
+	*/
+	static retentionTables = { runOwnership: {
+		table: TABLE_WORKFLOW_RUN_OWNERS,
+		column: "updatedAt",
+		indexed: false,
+		anchorType: "epoch-ms"
+	} };
 	service;
 	ttlConfig;
 	constructor(config) {
@@ -2847,6 +2914,19 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
 	supportsRunFencing() {
 		return true;
 	}
+	async prune(policies, options) {
+		return executeRetentionPrune({
+			domain: "workflows",
+			targets: resolveRetentionTargets({
+				policies,
+				descriptor: WorkflowStorageDynamoDB.retentionTables,
+				order: ["runOwnership"]
+			}),
+			options,
+			cutoffFor: (target, now) => retentionCutoffMs(target.policy, now),
+			deleteBatch: (_target, cutoff, limit) => pruneRunClaims(this.service, "workflow_run_owner", "updatedAt", Number(cutoff), limit)
+		});
+	}
 	async dangerouslyClearAll() {
 		await deleteTableData(this.service, TABLE_WORKFLOW_SNAPSHOT);
 		await deleteTableData(this.service, TABLE_WORKFLOW_RUN_OWNERS);