@mastra/pg 1.25.0-alpha.1 → 1.25.0

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-pg
 description: Documentation for @mastra/pg. Use when working with @mastra/pg APIs, configuration, or implementation.
 metadata:
   package: "@mastra/pg"
-  version: "1.25.0-alpha.1"
+  version: "1.25.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.25.0-alpha.1",
+  "version": "1.25.0",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

package/dist/index.cjs

@@ -13207,6 +13207,27 @@ var NotificationsPG = class NotificationsPG extends _mastra_core_storage.Notific
 		if (!updated) throw new Error(`Notification ${input.id} was not found for thread ${input.threadId}`);
 		return updated;
 	}
+	async updateNotificationsStatus(input) {
+		const ids = Array.from(new Set(input.ids));
+		if (ids.length === 0) return [];
+		const now = /* @__PURE__ */ new Date();
+		const assignments = {
+			status: input.status,
+			...statusTimestamp(input.status, now),
+			updatedAt: now
+		};
+		const columns = Object.keys(assignments);
+		const setClause = columns.map((column, index) => `"${(0, _mastra_core_utils.parseSqlIdentifier)(column, "column name")}" = $${index + 1}`).join(", ");
+		const tableName = getTableName$5({
+			indexName: _mastra_core_storage.TABLE_NOTIFICATIONS,
+			schemaName: getSchemaName$5(this.#schema)
+		});
+		return (await this.#db.client.manyOrNone(`UPDATE ${tableName} SET ${setClause} WHERE "threadId" = $${columns.length + 1} AND "id" = ANY($${columns.length + 2}::text[]) RETURNING *`, [
+			...Object.values(assignments),
+			input.threadId,
+			ids
+		])).map(rowToNotification);
+	}
 	async findCoalescable(input) {
 		if (!input.dedupeKey && !input.coalesceKey) return void 0;
 		const tableName = getTableName$5({
@@ -17361,6 +17382,13 @@ function collectRelationCollections(predicate, collections = /* @__PURE__ */ new
 	else if (predicate.type === "not") collectRelationCollections(predicate.arg, collections);
 	return collections;
 }
+function collectThreadRelationCollections(predicate, collections) {
+	if (!predicate) return collections;
+	if (predicate.type === "relation") collectRelationCollections(predicate.predicate, collections);
+	else if (predicate.type === "boolean") for (const arg of predicate.args) collectThreadRelationCollections(arg, collections);
+	else collectThreadRelationCollections(predicate.arg, collections);
+	return collections;
+}
 function compilePredicate(predicate, parameterOffset) {
 	if (predicate.type === "relation") {
 		const compiled = predicate.collection === "feedback" ? compileFeedbackScalarPredicate(predicate.predicate, parameterOffset) : compileScalarPredicate(predicate.predicate, predicate.collection === "spans" ? SPAN_FIELDS : SCORE_FIELDS, parameterOffset);
@@ -17395,12 +17423,41 @@ function compilePredicate(predicate, parameterOffset) {
 	}
 	return compileScalarPredicate(predicate, TRACE_FIELDS, parameterOffset, true);
 }
-function compilePostgresTraceQuery(schema, plan) {
+function compileThreadPredicate(predicate, parameterOffset) {
+	if (predicate.type === "relation") {
+		const compiled = compilePredicate(predicate.predicate, parameterOffset);
+		const existence = `EXISTS (
+      SELECT 1 FROM eligible_roots r
+      WHERE r."threadId" = t."threadId"
+        AND (${compiled.sql})
+    )`;
+		return {
+			sql: predicate.quantifier === "some" ? existence : `NOT ${existence}`,
+			values: compiled.values
+		};
+	}
+	if (predicate.type === "boolean") {
+		const values = [];
+		return {
+			sql: predicate.args.map((arg) => {
+				const compiled = compileThreadPredicate(arg, parameterOffset + values.length);
+				values.push(...compiled.values);
+				return `(${compiled.sql})`;
+			}).join(predicate.operator === "and" ? " AND " : " OR "),
+			values
+		};
+	}
+	const compiled = compileThreadPredicate(predicate.arg, parameterOffset);
+	return {
+		sql: `NOT (${compiled.sql})`,
+		values: compiled.values
+	};
+}
+function compilePostgresTraceScope(schema, selection, relationCollections) {
 	const spanTable = qualifiedTable(schema, TABLE_SPAN_EVENTS);
 	const scoreTable = qualifiedTable(schema, TABLE_SCORE_EVENTS);
 	const feedbackTable = qualifiedTable(schema, TABLE_FEEDBACK_EVENTS);
-	const values = [plan.timeRange.from, plan.timeRange.to];
-	const relationCollections = collectRelationCollections(plan.where);
+	const values = [selection.timeRange.from, selection.timeRange.to];
 	const ctes = [`root_scope AS MATERIALIZED (
     SELECT *
     FROM ${spanTable} r
@@ -17475,6 +17532,13 @@ function compilePostgresTraceQuery(schema, plan) {
       AND s."traceId" IN (SELECT "traceId" FROM root_scope)
       AND ${latestFeedbackPredicate(feedbackTable)}
   )`);
+	return {
+		ctes,
+		values
+	};
+}
+function compilePostgresTraceQuery(schema, plan) {
+	const { ctes, values } = compilePostgresTraceScope(schema, plan, collectRelationCollections(plan.where));
 	let predicateSql = "TRUE";
 	if (plan.where) {
 		const predicate = compilePredicate(plan.where, values.length + 1);
@@ -17522,6 +17586,51 @@ LIMIT $${values.length}`,
 		values
 	};
 }
+function compilePostgresThreadQuery(schema, plan) {
+	const relationCollections = collectRelationCollections(plan.traces.where);
+	collectThreadRelationCollections(plan.where, relationCollections);
+	const { ctes, values } = compilePostgresTraceScope(schema, plan.traces, relationCollections);
+	let eligibilitySql = "TRUE";
+	if (plan.traces.where) {
+		const eligibility = compilePredicate(plan.traces.where, values.length + 1);
+		eligibilitySql = eligibility.sql;
+		values.push(...eligibility.values);
+	}
+	ctes.push(`eligible_roots AS MATERIALIZED (
+    SELECT *
+    FROM root_scope r
+    WHERE ${eligibilitySql}
+  )`);
+	ctes.push(`thread_ids AS (
+    SELECT "threadId" COLLATE "C" AS "threadId"
+    FROM eligible_roots
+    WHERE "threadId" IS NOT NULL
+    GROUP BY "threadId" COLLATE "C"
+  )`);
+	let threadPredicateSql = "TRUE";
+	if (plan.where) {
+		const predicate = compileThreadPredicate(plan.where, values.length + 1);
+		threadPredicateSql = predicate.sql;
+		values.push(...predicate.values);
+	}
+	ctes.push(`qualified_threads AS (
+    SELECT t."threadId"
+    FROM thread_ids t
+    WHERE ${threadPredicateSql}
+  )`);
+	const pageCondition = plan.cursor ? `WHERE "threadId" > $${values.length + 1}` : "";
+	if (plan.cursor) values.push(plan.cursor.threadId);
+	values.push(plan.limit + 1);
+	return {
+		text: `WITH ${ctes.join(",\n")}
+SELECT "threadId"
+FROM qualified_threads
+${pageCondition}
+ORDER BY "threadId" ASC
+LIMIT $${values.length}`,
+		values
+	};
+}
 function asIsoTimestamp$1(value) {
 	if (value === null || value === void 0) throw new Error("Trace query returned a null timestamp");
 	return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
@@ -17580,6 +17689,19 @@ async function queryTraces(client, schema, plan, timeoutMs) {
 		}) : null }
 	});
 }
+async function queryThreads(client, schema, plan, timeoutMs) {
+	const query = compilePostgresThreadQuery(schema, plan);
+	const rows = await runWithPostgresTraceQueryTimeout(client, timeoutMs, (transaction) => transaction.any(query.text, query.values));
+	const threads = rows.slice(0, plan.limit).map((row) => ({ threadId: String(row.threadId) }));
+	const last = threads.at(-1);
+	return _mastra_core_storage.queryThreadsResultSchema.parse({
+		threads,
+		page: { next: rows.length > plan.limit && last ? _mastra_core_storage.encodeTraceQueryCursor(plan, {
+			result: "threads",
+			threadId: last.threadId
+		}) : null }
+	});
+}
 //#endregion
 //#region src/storage/domains/observability/v-next/traces.ts
 /**
@@ -18475,13 +18597,15 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 		if (!deltaPollingFeatureEnabled()) return [
 			"metrics",
 			"logs",
-			"trace-query"
+			"trace-query",
+			"thread-query"
 		];
 		return [
 			"metrics",
 			"logs",
 			"delta-polling",
-			"trace-query"
+			"trace-query",
+			"thread-query"
 		];
 	}
 	async #run(op, fn, details) {
@@ -18527,6 +18651,9 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 	async queryTraces(plan) {
 		return this.#run("QUERY_TRACES", () => queryTraces(this.#readClient, this.#schema, plan, this.#traceQueryTimeoutMs));
 	}
+	async queryThreads(plan) {
+		return this.#run("QUERY_THREADS", () => queryThreads(this.#readClient, this.#schema, plan, this.#traceQueryTimeoutMs));
+	}
 	async listBranches(args) {
 		return this.#run("LIST_BRANCHES", () => listBranches(this.#readClient, this.#schema, args));
 	}