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

package/dist/index.js

@@ -541,6 +541,7 @@ function buildFilterQuery(filter, minScore, topK) {
 }
 //#endregion
 //#region src/vector/index.ts
+const MAX_UPSERT_ROWS_PER_STATEMENT = Math.floor(65535 / 3);
 var PgVector = class extends MastraVector {
 	pool;
 	describeIndexCache = /* @__PURE__ */ new Map();
@@ -933,23 +934,41 @@ var PgVector = class extends MastraVector {
 			const indexInfo = await this.getIndexInfo({ indexName });
 			const qualifiedVectorType = this.getVectorTypeName(indexInfo.vectorType, indexInfo.dimension);
 			const ops = this.getVectorOps(indexInfo.vectorType, indexInfo.metric ?? "cosine");
-			for (let i = 0; i < vectors.length; i++) {
+			if (new Set(vectorIds).size !== vectorIds.length) for (let i = 0; i < vectors.length; i++) {
 				const vectorStr = ops.formatVector(vectors[i], indexInfo.dimension);
 				const query = `
-          INSERT INTO ${tableName} (vector_id, embedding, metadata)
-          VALUES ($1, $2::${qualifiedVectorType}, $3::jsonb)
-          ON CONFLICT (vector_id)
-          DO UPDATE SET
-            embedding = $2::${qualifiedVectorType},
-            metadata = $3::jsonb
-          RETURNING embedding::text
-        `;
+            INSERT INTO ${tableName} (vector_id, embedding, metadata)
+            VALUES ($1, $2::${qualifiedVectorType}, $3::jsonb)
+            ON CONFLICT (vector_id)
+            DO UPDATE SET
+              embedding = $2::${qualifiedVectorType},
+              metadata = $3::jsonb
+          `;
 				await client.query(query, [
 					vectorIds[i],
 					vectorStr,
 					JSON.stringify(metadata?.[i] || {})
 				]);
 			}
+			else for (let start = 0; start < vectors.length; start += MAX_UPSERT_ROWS_PER_STATEMENT) {
+				const end = Math.min(start + MAX_UPSERT_ROWS_PER_STATEMENT, vectors.length);
+				const rows = [];
+				const values = [];
+				for (let i = start; i < end; i++) {
+					const base = values.length;
+					rows.push(`($${base + 1}, $${base + 2}::${qualifiedVectorType}, $${base + 3}::jsonb)`);
+					values.push(vectorIds[i], ops.formatVector(vectors[i], indexInfo.dimension), JSON.stringify(metadata?.[i] || {}));
+				}
+				const query = `
+            INSERT INTO ${tableName} (vector_id, embedding, metadata)
+            VALUES ${rows.join(", ")}
+            ON CONFLICT (vector_id)
+            DO UPDATE SET
+              embedding = EXCLUDED.embedding,
+              metadata = EXCLUDED.metadata
+          `;
+				await client.query(query, values);
+			}
 			await client.query("COMMIT");
 			this.logger?.debug(`Upserted ${vectors.length} vectors to ${indexName}`, {
 				indexName,
@@ -3779,6 +3798,7 @@ var AgentsPG = class AgentsPG extends AgentsStorage {
 				"workspace",
 				"skills",
 				"skillsFormat",
+				"durable",
 				"browser",
 				"toolProviders"
 			]
@@ -4258,10 +4278,10 @@ var AgentsPG = class AgentsPG extends AgentsStorage {
           "defaultOptions", workflows, agents, "integrationTools", "toolProviders",
           "inputProcessors", "outputProcessors", memory, scorers,
           "mcpClients", "requestContextSchema", workspace, skills, "skillsFormat",
-          browser,
+          durable, browser,
           "changedFields", "changeMessage",
           "createdAt", "createdAtZ"
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27)`, [
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28)`, [
 				input.id,
 				input.agentId,
 				input.versionNumber,
@@ -4284,6 +4304,7 @@ var AgentsPG = class AgentsPG extends AgentsStorage {
 				input.workspace ? JSON.stringify(input.workspace) : null,
 				input.skills ? JSON.stringify(input.skills) : null,
 				input.skillsFormat ?? null,
+				input.durable !== void 0 ? JSON.stringify(input.durable) : null,
 				input.browser ? JSON.stringify(input.browser) : null,
 				input.changedFields ? JSON.stringify(input.changedFields) : null,
 				input.changeMessage ?? null,
@@ -4512,6 +4533,7 @@ var AgentsPG = class AgentsPG extends AgentsStorage {
 			workspace: parseJsonResilient(row.workspace, "workspace"),
 			skills: parseJsonResilient(row.skills, "skills"),
 			skillsFormat: row.skillsFormat,
+			durable: parseJsonResilient(row.durable, "durable"),
 			browser: parseJsonResilient(row.browser, "browser"),
 			changedFields: parseJsonResilient(row.changedFields, "changedFields"),
 			changeMessage: row.changeMessage,
@@ -20728,6 +20750,38 @@ var PgFactoryStorageOps = class {
 * Supports serializable app-table transactions for cross-replica invariant
 * enforcement and `authDatabase()` exposing the shared pool.
 */
+/**
+* A pool-level `error` listener only covers *idle* clients: pg hands ownership
+* of a client to the borrower for the duration of a checkout and takes its own
+* listener off. So a backend restart or network blip that lands on a client
+* mid-transaction reaches an emitter with no listener, and Node escalates that
+* to an uncaughtException that kills the process — the pool handler logs the
+* idle siblings and the borrowed one still brings everything down.
+*
+* Attach a listener once per physical connection instead. `connect` fires when
+* the pool establishes a client, so the client stays covered for its whole life
+* and there is nothing to remove on release.
+*
+* That listener outlives the checkout, so it also sees the failures the pool is
+* already reporting through its own idle listener. Follow `acquire`/`release`
+* to tell the two apart and stay quiet while the client is idle — otherwise one
+* dropped connection is announced twice, the second time as the wrong thing.
+*
+* The pool still discards the failed connection; this only keeps the failure
+* reportable instead of fatal.
+*/
+function guardCheckedOutClientErrors(pool, warn = console.warn) {
+	const borrowed = /* @__PURE__ */ new WeakSet();
+	pool.on("connect", (client) => {
+		borrowed.add(client);
+		client.on("error", (err) => {
+			if (!borrowed.has(client)) return;
+			warn(`PgFactoryStorage: client error while checked out (the pool discards this connection): ${err instanceof Error ? err.message : String(err)}`);
+		});
+	});
+	pool.on("acquire", (client) => borrowed.add(client));
+	pool.on("release", (_err, client) => borrowed.delete(client));
+}
 var PgFactoryStorage = class extends FactoryStorage {
 	ops;
 	#pool;
@@ -20748,6 +20802,7 @@ var PgFactoryStorage = class extends FactoryStorage {
 			this.#pool.on("error", (err) => {
 				console.warn(`PgFactoryStorage: idle pool client error (pool discards the client and reconnects on next checkout): ${err instanceof Error ? err.message : String(err)}`);
 			});
+			guardCheckedOutClientErrors(this.#pool);
 		}
 		this.ops = new PgFactoryStorageOps(this.#pool, this.#schemas);
 	}