@mastra/pg 1.24.0-alpha.1 → 1.24.0-alpha.3

package/dist/index.js

@@ -16078,6 +16078,8 @@ ${buildSelectColumns(FEEDBACK_EVENT_COLUMNS)}`;
 * aggregate, breakdown, time series, and percentiles. OLAP aggregates run
 * over `valueNumber` only; string-valued feedback is excluded.
 */
+const FEEDBACK_CONFLICT_KEYS = /* @__PURE__ */ new Set(["feedbackId", "timestamp"]);
+const FEEDBACK_UPSERT_CLAUSE = `ON CONFLICT ("feedbackId", "timestamp") DO UPDATE SET ${FEEDBACK_EVENT_COLUMNS.map((column) => column.name).filter((column) => !FEEDBACK_CONFLICT_KEYS.has(column)).map((column) => `"${column}" = EXCLUDED."${column}"`).join(", ")}`;
 function applyFeedbackFilters(acc, filters) {
 	applyCommonFilters(acc, filters);
 	applySingleOrArrayFilter(acc, "feedbackType", filters?.feedbackType);
@@ -16108,12 +16110,12 @@ function pushFeedbackIdentity(acc, feedbackType, feedbackSource) {
 	acc.conditions.push(`"valueNumber" IS NOT NULL`);
 }
 async function createFeedback(client, schema, args) {
-	const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, [feedbackRecordToRow(args.feedback)]);
+	const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, [feedbackRecordToRow(args.feedback)], FEEDBACK_UPSERT_CLAUSE);
 	if (insert) await client.query(insert.text, insert.values);
 }
 async function batchCreateFeedback(client, schema, args) {
 	if (args.feedbacks.length === 0) return;
-	const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, args.feedbacks.map(feedbackRecordToRow));
+	const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, [...new Map(args.feedbacks.map((feedback) => [feedback.feedbackId, feedback])).values()].map(feedbackRecordToRow), FEEDBACK_UPSERT_CLAUSE);
 	if (insert) await client.query(insert.text, insert.values);
 }
 async function updateFeedbackReviewStatus(client, schema, args) {
@@ -16131,6 +16133,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);
@@ -16891,6 +16913,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);
@@ -17094,6 +17136,17 @@ const SCORE_FIELDS = {
 	parentEntityVersionId: "s.\"parentEntityVersionId\"",
 	rootEntityVersionId: "s.\"rootEntityVersionId\""
 };
+const FEEDBACK_FIELDS = {
+	feedbackType: "s.\"feedbackType\"",
+	feedbackSource: "s.\"feedbackSource\"",
+	feedbackUserId: "s.\"feedbackUserId\"",
+	sourceId: "s.\"sourceId\"",
+	entityVersionId: "s.\"entityVersionId\"",
+	parentEntityVersionId: "s.\"parentEntityVersionId\"",
+	rootEntityVersionId: "s.\"rootEntityVersionId\"",
+	timestamp: "s.\"timestamp\"",
+	comment: "s.\"comment\""
+};
 const TRACE_SELECT = `
   r."traceId" AS "traceId",
   r."spanId" AS "rootSpanId",
@@ -17183,6 +17236,35 @@ function compileScalarPredicate(predicate, registry, parameterOffset, allowMetad
 		values: [...fieldValues, predicate.value]
 	};
 }
+function compileFeedbackScalarPredicate(predicate, parameterOffset) {
+	if (predicate.type === "boolean") {
+		const values = [];
+		return {
+			sql: predicate.args.map((arg) => {
+				const compiled = compileFeedbackScalarPredicate(arg, parameterOffset + values.length);
+				values.push(...compiled.values);
+				return `(${compiled.sql})`;
+			}).join(predicate.operator === "and" ? " AND " : " OR "),
+			values
+		};
+	}
+	if (predicate.type === "not") {
+		const compiled = compileFeedbackScalarPredicate(predicate.arg, parameterOffset);
+		return {
+			sql: `NOT (${compiled.sql})`,
+			values: compiled.values
+		};
+	}
+	if (predicate.field !== "value") return compileScalarPredicate(predicate, FEEDBACK_FIELDS, parameterOffset);
+	if (predicate.type === "presence") {
+		const present = `(s."valueString" IS NOT NULL OR s."valueNumber" IS NOT NULL)`;
+		return {
+			sql: predicate.operator === "exists" ? present : `NOT ${present}`,
+			values: []
+		};
+	}
+	return compileScalarPredicate(predicate, { value: typeof (predicate.type === "membership" ? predicate.values[0] : predicate.value) === "number" ? "s.\"valueNumber\"" : "s.\"valueString\"" }, parameterOffset);
+}
 function latestRootPredicate$1(spanTable) {
 	return `NOT EXISTS (
     SELECT 1 FROM ${spanTable} newer
@@ -17206,6 +17288,13 @@ function latestScorePredicate(scoreTable) {
       AND newer."cursorId" > s."cursorId"
   )`;
 }
+function latestFeedbackPredicate(feedbackTable) {
+	return `NOT EXISTS (
+    SELECT 1 FROM ${feedbackTable} newer
+    WHERE newer."feedbackId" = s."feedbackId"
+      AND newer."cursorId" > s."cursorId"
+  )`;
+}
 function collectRelationCollections(predicate, collections = /* @__PURE__ */ new Set()) {
 	if (!predicate) return collections;
 	if (predicate.type === "relation") collections.add(predicate.collection);
@@ -17215,11 +17304,11 @@ function collectRelationCollections(predicate, collections = /* @__PURE__ */ new
 }
 function compilePredicate(predicate, parameterOffset) {
 	if (predicate.type === "relation") {
-		const registry = predicate.collection === "spans" ? SPAN_FIELDS : SCORE_FIELDS;
-		const compiled = compileScalarPredicate(predicate.predicate, registry, parameterOffset);
+		const compiled = predicate.collection === "feedback" ? compileFeedbackScalarPredicate(predicate.predicate, parameterOffset) : compileScalarPredicate(predicate.predicate, predicate.collection === "spans" ? SPAN_FIELDS : SCORE_FIELDS, parameterOffset);
 		const existence = `EXISTS (
-      SELECT 1 FROM ${predicate.collection === "spans" ? "current_spans" : "current_scores"} s
-      WHERE s."traceId" = r."traceId"
+      SELECT 1 FROM ${predicate.collection === "spans" ? "current_spans" : predicate.collection === "scores" ? "current_scores" : "current_feedback"} s
+      WHERE s."traceId" IS NOT NULL
+        AND s."traceId" = r."traceId"
         AND (${compiled.sql})
     )`;
 		return {
@@ -17250,6 +17339,7 @@ function compilePredicate(predicate, parameterOffset) {
 function compilePostgresTraceQuery(schema, plan) {
 	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 ctes = [`root_scope AS MATERIALIZED (
@@ -17306,6 +17396,25 @@ function compilePostgresTraceQuery(schema, plan) {
     WHERE s."traceId" IS NOT NULL
       AND s."traceId" IN (SELECT "traceId" FROM root_scope)
       AND ${latestScorePredicate(scoreTable)}
+  )`);
+	if (relationCollections.has("feedback")) ctes.push(`current_feedback AS MATERIALIZED (
+    SELECT
+      s."traceId",
+      s."feedbackType",
+      s."feedbackSource",
+      s."feedbackUserId",
+      s."sourceId",
+      s."valueString",
+      s."valueNumber",
+      s."comment",
+      s."timestamp",
+      s."entityVersionId",
+      s."parentEntityVersionId",
+      s."rootEntityVersionId"
+    FROM ${feedbackTable} s
+    WHERE s."traceId" IS NOT NULL
+      AND s."traceId" IN (SELECT "traceId" FROM root_scope)
+      AND ${latestFeedbackPredicate(feedbackTable)}
   )`);
 	let predicateSql = "TRUE";
 	if (plan.where) {
@@ -18380,6 +18489,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));
 	}