@mastra/pg 1.26.0-alpha.3 → 1.26.0-alpha.4

package/dist/index.js

@@ -2336,6 +2336,8 @@ var RoutingDbClient = class {
 		return this.active.tx(callback);
 	}
 };
+/** Bytes reserved for the `_xxxxxxxx` collision suffix when hashWhenTruncated applies. */
+const TRUNCATION_HASH_SUFFIX_LENGTH = 9;
 function truncateIdentifier(value, maxLength = 63) {
 	if (maxLength <= 0) return "";
 	if (Buffer.byteLength(value, "utf-8") <= maxLength) return value;
@@ -2356,9 +2358,25 @@ function truncateIdentifier(value, maxLength = 63) {
 * in system catalogs (pg_constraint.conname, pg_indexes.indexname, etc.).
 * Without this normalisation, runtime lookups that compare a mixed-case name
 * against the catalog would silently fail.
+*
+* With `hashWhenTruncated`, a name that exceeds the limit is truncated further
+* to make room for `_` + 8 hex chars of the full name's sha256. Plain
+* truncation cuts the tail, so two names sharing a long `<schema>_<prefix>`
+* collapse to the same identifier and `CREATE INDEX IF NOT EXISTS` (which
+* matches by name only) silently skips the second one. The suffix is
+* deterministic, so creation, warm-init snapshot checks, and DDL export all
+* agree on the same name. Opt-in because renaming already-released constraint
+* names would orphan the existing objects in deployed catalogs.
 */
-function buildConstraintName({ baseName, schemaName, maxLength = 63 }) {
-	return truncateIdentifier(`${schemaName ? `${schemaName}_` : ""}${baseName}`.toLowerCase(), maxLength);
+function buildConstraintName({ baseName, schemaName, maxLength = 63, hashWhenTruncated = false }) {
+	const fullName = `${schemaName ? `${schemaName}_` : ""}${baseName}`.toLowerCase();
+	if (hashWhenTruncated && Buffer.byteLength(fullName, "utf-8") > maxLength) {
+		const suffixLength = Math.min(TRUNCATION_HASH_SUFFIX_LENGTH, maxLength);
+		if (suffixLength < 2) return truncateIdentifier(fullName, maxLength);
+		const hash = createHash("sha256").update(fullName).digest("hex").slice(0, suffixLength - 1);
+		return `${truncateIdentifier(fullName, maxLength - suffixLength)}_${hash}`;
+	}
+	return truncateIdentifier(fullName, maxLength);
 }
 //#endregion
 //#region src/storage/db/pg-errors.ts
@@ -22293,6 +22311,7 @@ const WORKFLOW_SNAPSHOT_STATUS_INDEX = "mastra_workflow_snapshot_name_status_cre
 * Schema-prefixed name of the status index, lowercased and truncated the same way Postgres
 * stores it, so the init snapshot's index set answers "does it exist?" without a probe or a
 * no-op `CREATE INDEX` (schema-prefixed names routinely exceed the 63-byte limit).
+* Exported for tests.
 */
 function workflowSnapshotStatusIndexName(schemaName) {
 	return buildConstraintName({
@@ -22310,6 +22329,48 @@ function workflowSnapshotStatusIndexSQL(indexName, schemaName) {
 		schemaName: getSchemaName(schemaName)
 	})} (workflow_name, (snapshot ->> 'status'), "createdAt" DESC)`;
 }
+/** Base name (before any schema prefix) of the expression index backing the threadId filter. */
+const WORKFLOW_SNAPSHOT_THREAD_ID_INDEX = "mastra_workflow_snapshot_threadid_idx";
+/**
+* Schema-prefixed name of the threadId index (see workflowSnapshotStatusIndexName).
+*
+* Unlike the status index, truncation appends a collision hash: both index names share the
+* long `<schema>_mastra_workflow_snapshot_` prefix, so with a schema name of 37+ bytes plain
+* truncation collapses them to the same 63-byte identifier and `CREATE INDEX IF NOT EXISTS`
+* silently skips this index. The status index keeps plain truncation because its truncated
+* name already exists in deployed catalogs; this index is new and free to adopt the rule.
+* Exported for tests.
+*/
+function workflowSnapshotThreadIdIndexName(schemaName) {
+	return buildConstraintName({
+		baseName: WORKFLOW_SNAPSHOT_THREAD_ID_INDEX,
+		schemaName: schemaName && schemaName !== "public" ? schemaName : void 0,
+		hashWhenTruncated: true
+	});
+}
+/**
+* Expression extracting the thread id embedded in a snapshot (jsonb columns only). Mirrors
+* the canonical extraction in `@mastra/core` (`getSnapshotMemoryInfo`), which reads one of
+* two layouts:
+* 1. agentic-loop: `context.<suspended step>.suspendPayload.__streamState.messageList.memoryInfo.threadId`
+* 2. durable loop: `context.input.messageListState.memoryInfo.threadId`
+*
+* `jsonb_path_query_first(jsonb, jsonpath)` is IMMUTABLE, so the expression is valid in an
+* expression index. The WHERE clause in listWorkflowRuns() must use this exact expression
+* text so the planner can match it against the index. If the snapshot layout changes in
+* core, this expression must be updated in lockstep or it will wrongly exclude rows.
+*/
+const WORKFLOW_SNAPSHOT_THREAD_ID_EXPR = `COALESCE(jsonb_path_query_first(snapshot, '$.context.* ? (@.status == "suspended").suspendPayload.__streamState.messageList.memoryInfo.threadId') #>> '{}', snapshot #>> '{context,input,messageListState,memoryInfo,threadId}')`;
+/**
+* Expression index on the snapshot-embedded thread id so listWorkflowRuns() threadId filters
+* (Agent.listSuspendedRuns) can use an index instead of detoasting every snapshot.
+*/
+function workflowSnapshotThreadIdIndexSQL(indexName, schemaName) {
+	return `CREATE INDEX IF NOT EXISTS "${indexName}" ON ${getTableName({
+		indexName: TABLE_WORKFLOW_SNAPSHOT,
+		schemaName: getSchemaName(schemaName)
+	})} ((${WORKFLOW_SNAPSHOT_THREAD_ID_EXPR}))`;
+}
 var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 	#db;
 	#schema;
@@ -22382,6 +22443,7 @@ var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 		}));
 		for (const idx of WorkflowsPG.getDefaultIndexDefs(schemaPrefix)) statements.push(generateIndexSQL(idx, schemaName));
 		statements.push(`${workflowSnapshotStatusIndexSQL(workflowSnapshotStatusIndexName(parsedSchema), schemaName)};`);
+		statements.push(`${workflowSnapshotThreadIdIndexSQL(workflowSnapshotThreadIdIndexName(parsedSchema), schemaName)};`);
 		return statements;
 	}
 	/**
@@ -22408,6 +22470,12 @@ var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 		} catch (error) {
 			this.logger?.warn?.(`Failed to create index ${indexName}:`, error);
 		}
+		const threadIdIndexName = workflowSnapshotThreadIdIndexName(this.#schema);
+		try {
+			await this.#db.createIndexFromStatement(threadIdIndexName, workflowSnapshotThreadIdIndexSQL(threadIdIndexName, this.#schema));
+		} catch (error) {
+			this.logger?.warn?.(`Failed to create index ${threadIdIndexName}:`, error);
+		}
 	}
 	async init() {
 		await this.#db.createTable({
@@ -22688,7 +22756,7 @@ var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 			}, error);
 		}
 	}
-	async listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId, status } = {}) {
+	async listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId, threadId, status } = {}) {
 		try {
 			const conditions = [];
 			const values = [];
@@ -22709,6 +22777,11 @@ var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 				values.push(resourceId);
 				paramIndex++;
 			} else this.logger?.warn?.(`[${TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+			if (threadId) if (await this.#db.getColumnType(TABLE_WORKFLOW_SNAPSHOT, "snapshot") === "jsonb") {
+				conditions.push(`${WORKFLOW_SNAPSHOT_THREAD_ID_EXPR} = $${paramIndex}`);
+				values.push(threadId);
+				paramIndex++;
+			} else this.logger?.warn?.(`[${TABLE_WORKFLOW_SNAPSHOT}] snapshot column is not jsonb. Skipping threadId filter.`);
 			if (fromDate) {
 				conditions.push(`"createdAt" >= $${paramIndex}`);
 				values.push(fromDate);