@mastra/pg 1.23.1-alpha.0 → 1.24.0-alpha.2

package/dist/index.js

@@ -7084,6 +7084,12 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 				name: "idx_experiment_results_org_project",
 				table: TABLE_EXPERIMENT_RESULTS,
 				columns: ["organizationId", "projectId"]
+			},
+			{
+				name: "idx_experiment_results_tags_gin",
+				table: TABLE_EXPERIMENT_RESULTS,
+				columns: ["tags"],
+				method: "gin"
 			}
 		];
 	}
@@ -7692,6 +7698,10 @@ var ExperimentsPG = class ExperimentsPG extends ExperimentsStorage {
 				conditions.push(`"status" = $${paramIndex++}`);
 				queryParams.push(args.status);
 			}
+			for (const tag of args.tags ?? []) {
+				conditions.push(`"tags" @> $${paramIndex++}::jsonb`);
+				queryParams.push(JSON.stringify([tag]));
+			}
 			if (args.filters) {
 				const { organizationId, projectId } = args.filters;
 				if (organizationId !== void 0) {
@@ -16121,6 +16131,26 @@ async function updateFeedbackReviewStatus(client, schema, args) {
 	});
 	return rowToFeedbackRecord(row);
 }
+/**
+* Delete feedback events by feedbackId. Optional `organizationId` and
+* `resourceId` values are ANDed into the predicate to restrict deletion to
+* records with matching scope fields.
+*/
+async function deleteFeedback(client, schema, args) {
+	if (args.feedbackIds.length === 0) return;
+	const table = qualifiedTable(schema, TABLE_FEEDBACK_EVENTS);
+	const values = [...args.feedbackIds];
+	const conditions = [`"feedbackId" IN (${args.feedbackIds.map((_, i) => `$${i + 1}`).join(", ")})`];
+	if (args.organizationId !== void 0) {
+		values.push(args.organizationId);
+		conditions.push(`"organizationId" = $${values.length}`);
+	}
+	if (args.resourceId !== void 0) {
+		values.push(args.resourceId);
+		conditions.push(`"resourceId" = $${values.length}`);
+	}
+	await client.query(`DELETE FROM ${table} WHERE ${conditions.join(" AND ")}`, values);
+}
 async function listFeedback(client, schema, args) {
 	const { mode, filters, pagination, orderBy, after, limit } = listFeedbackArgsSchema.parse(args);
 	const table = qualifiedTable(schema, TABLE_FEEDBACK_EVENTS);
@@ -16881,6 +16911,26 @@ async function batchCreateScores(client, schema, args) {
 	const insert = buildInsert(schema, TABLE_SCORE_EVENTS, args.scores.map(scoreRecordToRow));
 	if (insert) await client.query(insert.text, insert.values);
 }
+/**
+* Delete score events by scoreId. Optional `organizationId` and `resourceId`
+* values are ANDed into the predicate to restrict deletion to records with
+* matching scope fields.
+*/
+async function deleteScores(client, schema, args) {
+	if (args.scoreIds.length === 0) return;
+	const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
+	const values = [...args.scoreIds];
+	const conditions = [`"scoreId" IN (${args.scoreIds.map((_, i) => `$${i + 1}`).join(", ")})`];
+	if (args.organizationId !== void 0) {
+		values.push(args.organizationId);
+		conditions.push(`"organizationId" = $${values.length}`);
+	}
+	if (args.resourceId !== void 0) {
+		values.push(args.resourceId);
+		conditions.push(`"resourceId" = $${values.length}`);
+	}
+	await client.query(`DELETE FROM ${table} WHERE ${conditions.join(" AND ")}`, values);
+}
 async function listScores(client, schema, args) {
 	const { mode, filters, pagination, orderBy, after, limit } = listScoresArgsSchema.parse(args);
 	const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
@@ -17057,12 +17107,32 @@ const TRACE_FIELDS = {
 	status: TRACE_STATUS_SQL
 };
 const SPAN_FIELDS = {
+	name: "s.\"name\"",
 	spanType: "s.\"spanType\"",
-	error: "s.\"error\""
+	model: "s.\"model\"",
+	provider: "s.\"provider\"",
+	startedAt: "s.\"startedAt\"",
+	endedAt: "s.\"endedAt\"",
+	durationMs: "s.\"durationMs\"",
+	status: "s.\"status\"",
+	error: "s.\"error\"",
+	entityType: "s.\"entityType\"",
+	entityId: "s.\"entityId\"",
+	entityName: "s.\"entityName\"",
+	entityVersionId: "s.\"entityVersionId\"",
+	parentEntityVersionId: "s.\"parentEntityVersionId\"",
+	rootEntityVersionId: "s.\"rootEntityVersionId\""
 };
 const SCORE_FIELDS = {
 	scorerId: "s.\"scorerId\"",
-	score: "s.\"score\""
+	scorerVersion: "s.\"scorerVersion\"",
+	scoreSource: "s.\"scoreSource\"",
+	score: "s.\"score\"",
+	timestamp: "s.\"timestamp\"",
+	spanId: "s.\"spanId\"",
+	entityVersionId: "s.\"entityVersionId\"",
+	parentEntityVersionId: "s.\"parentEntityVersionId\"",
+	rootEntityVersionId: "s.\"rootEntityVersionId\""
 };
 const TRACE_SELECT = `
   r."traceId" AS "traceId",
@@ -17080,15 +17150,18 @@ function fieldSql(registry, field) {
 	if (sql === void 0) throw new Error(`Unsupported trusted trace-query field: ${field}`);
 	return sql;
 }
+function isMetadataField(field) {
+	return field.startsWith("metadata.");
+}
 function placeholders(values, offset) {
 	return values.map((_, index) => `$${offset + index}`).join(", ");
 }
-function compileScalarPredicate(predicate, registry, parameterOffset) {
+function compileScalarPredicate(predicate, registry, parameterOffset, allowMetadata = false) {
 	if (predicate.type === "boolean") {
 		const values = [];
 		return {
 			sql: predicate.args.map((arg) => {
-				const compiled = compileScalarPredicate(arg, registry, parameterOffset + values.length);
+				const compiled = compileScalarPredicate(arg, registry, parameterOffset + values.length, allowMetadata);
 				values.push(...compiled.values);
 				return `(${compiled.sql})`;
 			}).join(predicate.operator === "and" ? " AND " : " OR "),
@@ -17096,26 +17169,36 @@ function compileScalarPredicate(predicate, registry, parameterOffset) {
 		};
 	}
 	if (predicate.type === "not") {
-		const compiled = compileScalarPredicate(predicate.arg, registry, parameterOffset);
+		const compiled = compileScalarPredicate(predicate.arg, registry, parameterOffset, allowMetadata);
 		return {
 			sql: `NOT (${compiled.sql})`,
 			values: compiled.values
 		};
 	}
-	const field = fieldSql(registry, predicate.field);
+	let field;
+	let fieldValues = [];
+	if (isMetadataField(predicate.field)) {
+		if (!allowMetadata) throw new Error(`Unsupported trusted trace-query field: ${predicate.field}`);
+		const keyParameter = `$${parameterOffset++}`;
+		field = `COALESCE(
+      CASE WHEN jsonb_typeof(r."metadataSearch" -> ${keyParameter}) = 'string' THEN r."metadataSearch" ->> ${keyParameter} END,
+      CASE WHEN jsonb_typeof(r."metadataRaw" -> ${keyParameter}) = 'string' THEN NULLIF(btrim(r."metadataRaw" ->> ${keyParameter}), '') END
+    )`;
+		fieldValues = [predicate.field.slice(9)];
+	} else field = fieldSql(registry, predicate.field);
 	if (predicate.type === "presence") return {
 		sql: `${field} IS ${predicate.operator === "exists" ? "NOT " : ""}NULL`,
-		values: []
+		values: fieldValues
 	};
 	if (predicate.type === "membership") {
 		const list = placeholders(predicate.values, parameterOffset);
 		if (predicate.operator === "in") return {
 			sql: `${field} IS NOT NULL AND ${field} IN (${list})`,
-			values: predicate.values
+			values: [...fieldValues, ...predicate.values]
 		};
 		return {
 			sql: `${field} IS NULL OR ${field} NOT IN (${list})`,
-			values: predicate.values
+			values: [...fieldValues, ...predicate.values]
 		};
 	}
 	const parameter = `$${parameterOffset}`;
@@ -17127,17 +17210,17 @@ function compileScalarPredicate(predicate, registry, parameterOffset) {
 	};
 	if (predicate.operator === "eq") return {
 		sql: `${field} IS NOT DISTINCT FROM ${parameter}`,
-		values: [predicate.value]
+		values: [...fieldValues, predicate.value]
 	};
 	if (predicate.operator === "ne") return {
 		sql: `${field} IS DISTINCT FROM ${parameter}`,
-		values: [predicate.value]
+		values: [...fieldValues, predicate.value]
 	};
 	const operator = operators[predicate.operator];
 	if (operator === void 0) throw new Error(`Unsupported trusted trace-query operator: ${predicate.operator}`);
 	return {
 		sql: `${field} IS NOT NULL AND ${field} ${operator} ${parameter}`,
-		values: [predicate.value]
+		values: [...fieldValues, predicate.value]
 	};
 }
 function latestRootPredicate$1(spanTable) {
@@ -17202,7 +17285,7 @@ function compilePredicate(predicate, parameterOffset) {
 			values: compiled.values
 		};
 	}
-	return compileScalarPredicate(predicate, TRACE_FIELDS, parameterOffset);
+	return compileScalarPredicate(predicate, TRACE_FIELDS, parameterOffset, true);
 }
 function compilePostgresTraceQuery(schema, plan) {
 	const spanTable = qualifiedTable(schema, TABLE_SPAN_EVENTS);
@@ -17222,14 +17305,43 @@ function compilePostgresTraceQuery(schema, plan) {
 	].join("\n      AND ")}
   )`];
 	if (relationCollections.has("spans")) ctes.push(`current_spans AS MATERIALIZED (
-    SELECT s."traceId", s."spanType", s."error"
+    SELECT
+      s."traceId",
+      s."name",
+      s."spanType",
+      CASE WHEN jsonb_typeof(s."attributes" -> 'model') = 'string' THEN s."attributes" ->> 'model' END AS "model",
+      CASE WHEN jsonb_typeof(s."attributes" -> 'provider') = 'string' THEN s."attributes" ->> 'provider' END AS "provider",
+      s."startedAt",
+      CASE WHEN s."isPending" THEN NULL ELSE s."endedAt" END AS "endedAt",
+      CASE
+        WHEN s."isPending" THEN NULL
+        ELSE EXTRACT(EPOCH FROM (s."endedAt" - s."startedAt")) * 1000
+      END AS "durationMs",
+      CASE WHEN s."error" IS NOT NULL THEN 'error' ELSE 'success' END AS "status",
+      s."error",
+      s."entityType",
+      s."entityId",
+      s."entityName",
+      s."entityVersionId",
+      s."parentEntityVersionId",
+      s."rootEntityVersionId"
     FROM ${spanTable} s
     WHERE s."traceId" IS NOT NULL
       AND s."traceId" IN (SELECT "traceId" FROM root_scope)
       AND ${latestSpanPredicate$1(spanTable)}
   )`);
 	if (relationCollections.has("scores")) ctes.push(`current_scores AS MATERIALIZED (
-    SELECT s."traceId", s."scorerId", s."score"
+    SELECT
+      s."traceId",
+      s."spanId",
+      s."timestamp",
+      s."scorerId",
+      s."scorerVersion",
+      s."scoreSource",
+      s."score",
+      s."entityVersionId",
+      s."parentEntityVersionId",
+      s."rootEntityVersionId"
     FROM ${scoreTable} s
     WHERE s."traceId" IS NOT NULL
       AND s."traceId" IN (SELECT "traceId" FROM root_scope)
@@ -18308,6 +18420,12 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 	async batchCreateFeedback(args) {
 		await this.#run("BATCH_CREATE_FEEDBACK", () => batchCreateFeedback(this.#client, this.#schema, args), { count: args.feedbacks.length });
 	}
+	async deleteScores(args) {
+		await this.#run("DELETE_SCORES", () => deleteScores(this.#client, this.#schema, args), { count: args.scoreIds.length });
+	}
+	async deleteFeedback(args) {
+		await this.#run("DELETE_FEEDBACK", () => deleteFeedback(this.#client, this.#schema, args), { count: args.feedbackIds.length });
+	}
 	async listLogs(args) {
 		return this.#run("LIST_LOGS", () => listLogs(this.#readClient, this.#schema, args));
 	}