@mastra/pg 1.36.0-alpha.4 → 1.36.0-alpha.6

package/dist/index.js

@@ -2066,8 +2066,10 @@ function truncateQuery(query, maxLength = 100) {
 */
 var PoolAdapter = class {
 	$pool;
-	constructor($pool) {
+	onRollbackError;
+	constructor($pool, onRollbackError) {
 		this.$pool = $pool;
+		this.onRollbackError = onRollbackError;
 	}
 	connect() {
 		return this.$pool.connect();
@@ -2104,8 +2106,14 @@ var PoolAdapter = class {
 	}
 	async tx(callback) {
 		const client = await this.$pool.connect();
+		let destroyClient = false;
 		try {
-			await client.query("BEGIN");
+			try {
+				await client.query("BEGIN");
+			} catch (error) {
+				destroyClient = true;
+				throw error;
+			}
 			const txClient = new TransactionClient(client);
 			try {
 				const result = await callback(txClient);
@@ -2117,12 +2125,16 @@ var PoolAdapter = class {
 				try {
 					await client.query("ROLLBACK");
 				} catch (rollbackError) {
-					console.error("Transaction rollback failed:", rollbackError);
+					destroyClient = true;
+					try {
+						if (this.onRollbackError) await this.onRollbackError(rollbackError);
+						else console.error("Failed to rollback transaction:", rollbackError);
+					} catch {}
 				}
 				throw error;
 			}
 		} finally {
-			client.release();
+			client.release(destroyClient || void 0);
 		}
 	}
 };
@@ -2229,6 +2241,7 @@ var TransactionClient = class {
 var PinnedClientAdapter = class {
 	$pool;
 	pinnedClient;
+	onRollbackError;
 	/**
 	* Serialization tail. Domain init() methods fire via Promise.all in
 	* MastraCompositeStore.#runInit(), so without our own gate every domain's
@@ -2239,9 +2252,14 @@ var PinnedClientAdapter = class {
 	* the reliance on pg's internal queue.
 	*/
 	#tail = Promise.resolve();
-	constructor($pool, pinnedClient) {
+	#rollbackError;
+	constructor($pool, pinnedClient, onRollbackError) {
 		this.$pool = $pool;
 		this.pinnedClient = pinnedClient;
+		this.onRollbackError = onRollbackError;
+	}
+	get shouldDestroyClient() {
+		return this.#rollbackError !== void 0;
 	}
 	/**
 	* Run `fn` after any previously enqueued work on this pinned client has
@@ -2249,7 +2267,11 @@ var PinnedClientAdapter = class {
 	* resume on the next caller's turn.
 	*/
 	#enqueue(fn) {
-		const next = this.#tail.then(fn, fn);
+		const run = async () => {
+			if (this.shouldDestroyClient) throw this.#rollbackError;
+			return fn();
+		};
+		const next = this.#tail.then(run, run);
 		this.#tail = next.catch(() => void 0);
 		return next;
 	}
@@ -2301,7 +2323,12 @@ var PinnedClientAdapter = class {
 	}
 	tx(callback) {
 		return this.#enqueue(async () => {
-			await this.pinnedClient.query("BEGIN");
+			try {
+				await this.pinnedClient.query("BEGIN");
+			} catch (error) {
+				this.#rollbackError = error;
+				throw error;
+			}
 			const txClient = new TransactionClient(this.pinnedClient);
 			try {
 				const result = await callback(txClient);
@@ -2313,7 +2340,11 @@ var PinnedClientAdapter = class {
 				try {
 					await this.pinnedClient.query("ROLLBACK");
 				} catch (rollbackError) {
-					console.error("Transaction rollback failed:", rollbackError);
+					this.#rollbackError = rollbackError;
+					try {
+						if (this.onRollbackError) await this.onRollbackError(rollbackError);
+						else console.error("Failed to rollback transaction:", rollbackError);
+					} catch {}
 				}
 				throw error;
 			}
@@ -19368,13 +19399,13 @@ const timingFeatures = [
 * condition for rows level with it. Empty values sort last in both directions, so they are past
 * every value and level only with each other.
 */
-function keysetSortBounds(field, direction, sortValue, values) {
+function keysetSortBounds(field, direction, sortValue, values, stringSort = false) {
 	if (sortValue === null) return {
 		past: [],
 		level: `${field} IS NULL`
 	};
 	values.push(sortValue);
-	const parameter = `$${values.length}::${typeof sortValue === "number" ? "float8" : "timestamptz"}`;
+	const parameter = `$${values.length}::${stringSort ? "text COLLATE \"C\"" : typeof sortValue === "number" ? "float8" : "timestamptz"}`;
 	return {
 		past: [`${field} ${direction === "asc" ? ">" : "<"} ${parameter}`, `${field} IS NULL`],
 		level: `${field} = ${parameter}`
@@ -20422,10 +20453,14 @@ function selectedKeys(rows, values) {
 		return `"${field}" ${field === "traceId" || field === "spanId" ? "=" : "IS NOT DISTINCT FROM"} $${values.length}::text`;
 	}).join(" AND ")})`).join(" OR ");
 }
+function sortColumn(plan) {
+	const column = `s."${plan.orderBy.field}"`;
+	return plan.orderBy.field === "model" || plan.orderBy.field === "provider" ? `${column} COLLATE "C"` : column;
+}
 function afterCursor(plan, values) {
 	if (!plan.cursor) return "TRUE";
 	const cursor = plan.cursor;
-	const { past: terms, level } = keysetSortBounds(`s."${plan.orderBy.field}"`, plan.orderBy.direction, cursor.sortValue, values);
+	const { past: terms, level } = keysetSortBounds(sortColumn(plan), plan.orderBy.direction, cursor.sortValue, values, plan.orderBy.field === "model" || plan.orderBy.field === "provider");
 	const equal = [level];
 	for (const key of identityFields) {
 		const ref = `s."${key}" COLLATE "C"`;
@@ -20506,10 +20541,12 @@ function compilePostgresSpanQuery(schema, plan) {
 			"endedAt",
 			"durationMs",
 			"status",
-			"version"
+			"version",
+			"model",
+			"provider"
 		].map((field) => `s."${field}"`).join(", ")}
   FROM selected s WHERE ${after}
-  ORDER BY s."${plan.orderBy.field}" ${plan.orderBy.direction === "asc" ? "ASC" : "DESC"} NULLS LAST, ${identityOrder}
+  ORDER BY ${sortColumn(plan)} ${plan.orderBy.direction === "asc" ? "ASC" : "DESC"} NULLS LAST, ${identityOrder}
   LIMIT $${values.length}`,
 		values
 	};
@@ -20544,6 +20581,7 @@ async function querySpans(client, schema, plan, timeoutMs) {
 		const rows = await tx.any(query.text, query.values);
 		const selected = rows.map(({ version: _version, startedAt, endedAt, timeToFirstChunkMs, timeToFirstTokenMs, outcome, stopReason, ...row }) => ({
 			...row,
+			...(plan.orderBy.field === "model" || plan.orderBy.field === "provider") && { cursorSortValue: row[plan.orderBy.field] },
 			...timeToFirstChunkSupported && { timeToFirstChunkMs },
 			...timeToFirstTokenSupported && { timeToFirstTokenMs },
 			...spanQueryOutcomeFieldsSupported && {
@@ -21939,6 +21977,7 @@ const spanQueryFeatures = typeof coreStorage.planSpanQuery === "function" ? [
 	"span-query",
 	"span-query-context-fields",
 	...coreStorage.SPAN_QUERY_ORDER_FIELDS?.includes("durationMs") ? ["span-query-duration-sort"] : [],
+	...coreStorage.SPAN_QUERY_ORDER_FIELDS?.includes("model") && coreStorage.SPAN_QUERY_ORDER_FIELDS?.includes("provider") ? ["span-query-model-provider-sort"] : [],
 	..."model" in (coreStorage.SPAN_QUERY_FIELD_REGISTRY ?? {}) ? ["span-query-model-fields"] : []
 ] : [];
 const spanAggregateFeatures = typeof coreStorage.planSpanAggregate === "function" ? ["span-aggregate", ..."model" in (coreStorage.SPAN_AGGREGATE_DIMENSION_REGISTRY ?? {}) ? ["span-aggregate-model-dimensions"] : []] : [];
@@ -28101,18 +28140,29 @@ var PgFactoryStorageOps = class {
 		};
 		if (this.#transactionClient) return run(this.#transactionClient);
 		const client = await this.#queryable.connect();
+		let releaseError;
 		try {
-			await client.query("BEGIN");
+			try {
+				await client.query("BEGIN");
+			} catch (error) {
+				releaseError = error instanceof Error ? error : new Error(String(error));
+				throw error;
+			}
 			try {
 				const result = await run(client);
 				await client.query("COMMIT");
 				return result;
 			} catch (error) {
-				await client.query("ROLLBACK");
+				try {
+					await client.query("ROLLBACK");
+				} catch (rollbackError) {
+					releaseError = rollbackError instanceof Error ? rollbackError : new Error(String(rollbackError));
+					throw new AggregateError([error, rollbackError], "Factory transaction and rollback both failed");
+				}
 				throw error;
 			}
 		} finally {
-			client.release();
+			client.release(releaseError);
 		}
 	}
 };
@@ -28169,7 +28219,12 @@ var PgFactoryStorage = class extends FactoryStorage {
 			let transactionOpen = false;
 			let releaseError;
 			try {
-				await client.query(options?.isolationLevel === "serializable" ? "BEGIN ISOLATION LEVEL SERIALIZABLE" : "BEGIN");
+				try {
+					await client.query(options?.isolationLevel === "serializable" ? "BEGIN ISOLATION LEVEL SERIALIZABLE" : "BEGIN");
+				} catch (error) {
+					releaseError = error instanceof Error ? error : new Error(String(error));
+					throw error;
+				}
 				transactionOpen = true;
 				const result = await fn(new PgFactoryStorageOps(client, this.#schemas, client));
 				await client.query("COMMIT");
@@ -28371,8 +28426,9 @@ var PostgresStore = class extends MastraCompositeStore {
 				this.#ownsWritePool = true;
 			}
 			this.#readPool = config.readPool ?? this.#writePool;
-			this.#db = new RoutingDbClient(new PoolAdapter(this.#writePool));
-			this.#readDb = this.#readPool === this.#writePool ? this.#db : new PoolAdapter(this.#readPool);
+			const onRollbackError = (error) => this.logger?.error?.("Transaction rollback failed", { error });
+			this.#db = new RoutingDbClient(new PoolAdapter(this.#writePool, onRollbackError));
+			this.#readDb = this.#readPool === this.#writePool ? this.#db : new PoolAdapter(this.#readPool, onRollbackError);
 			const domainConfig = {
 				client: this.#db,
 				readClient: this.#readDb,
@@ -28441,7 +28497,7 @@ var PostgresStore = class extends MastraCompositeStore {
 		let pinned;
 		try {
 			pinnedClient = await this.#writePool.connect();
-			pinned = new PinnedClientAdapter(this.#writePool, pinnedClient);
+			pinned = new PinnedClientAdapter(this.#writePool, pinnedClient, (error) => this.logger?.error?.("Transaction rollback failed", { error }));
 			this.#db.pin(pinned);
 			for (let attempt = 1; attempt <= 3; attempt++) {
 				this.#db.setSchemaSnapshot(await loadSchemaSnapshot(pinned, this.schema));
@@ -28466,7 +28522,7 @@ var PostgresStore = class extends MastraCompositeStore {
 			this.#db.setSchemaSnapshot(null);
 			if (pinnedClient) {
 				this.#db.unpin();
-				pinnedClient.release();
+				pinnedClient.release(pinned?.shouldDestroyClient || void 0);
 			}
 		}
 	}