@mastra/pg 1.20.1-alpha.0 → 1.20.1-alpha.2

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,
@@ -2152,7 +2171,7 @@ async function loadSchemaSnapshot(client, schemaName) {
 	const schema = schemaName || "public";
 	const [tableRows, columnRows, indexRows] = await Promise.all([
 		client.manyOrNone(`SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname = $1`, [schema]),
-		client.manyOrNone(`SELECT c.relname AS table_name, a.attname AS column_name
+		client.manyOrNone(`SELECT c.relname AS table_name, a.attname AS column_name, format_type(a.atttypid, a.atttypmod) AS data_type
          FROM pg_catalog.pg_class c
          JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
          JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid
@@ -2167,6 +2186,7 @@ async function loadSchemaSnapshot(client, schemaName) {
         WHERE n.nspname = $1`, [schema])
 	]);
 	const columns = /* @__PURE__ */ new Map();
+	const columnTypes = /* @__PURE__ */ new Map();
 	for (const row of columnRows) {
 		let set = columns.get(row.table_name);
 		if (!set) {
@@ -2174,6 +2194,12 @@ async function loadSchemaSnapshot(client, schemaName) {
 			columns.set(row.table_name, set);
 		}
 		set.add(row.column_name);
+		let types = columnTypes.get(row.table_name);
+		if (!types) {
+			types = /* @__PURE__ */ new Map();
+			columnTypes.set(row.table_name, types);
+		}
+		types.set(row.column_name, row.data_type);
 	}
 	const indexes = /* @__PURE__ */ new Set();
 	const replicaIdentityIndexes = /* @__PURE__ */ new Set();
@@ -2187,6 +2213,7 @@ async function loadSchemaSnapshot(client, schemaName) {
 		schemaName: schema,
 		tables: new Set(tableRows.map((r) => r.tablename)),
 		columns,
+		columnTypes,
 		indexes,
 		replicaIdentityIndexes,
 		primaryKeyIndexes
@@ -2440,6 +2467,8 @@ var PgDB = class extends MastraBase {
 	skipDefaultIndexes;
 	/** Cache of actual table columns: tableName -> Set<columnName> */
 	tableColumnsCache = /* @__PURE__ */ new Map();
+	/** Cache of column Postgres data types: tableName -> columnName -> data_type */
+	columnTypeCache = /* @__PURE__ */ new Map();
 	constructor(config) {
 		super({
 			component: "STORAGE",
@@ -2514,7 +2543,9 @@ var PgDB = class extends MastraBase {
 			}
 		}
 		this.tableColumnsCache.delete(oldName);
+		this.columnTypeCache.delete(oldName);
 		this.tableColumnsCache.delete(newName);
+		this.columnTypeCache.delete(newName);
 	}
 	/**
 	* Records an out-of-band `DROP TABLE` in the init snapshot. See
@@ -2530,8 +2561,10 @@ var PgDB = class extends MastraBase {
 		if (snapshot) {
 			snapshot.tables.delete(tableName);
 			snapshot.columns.delete(tableName);
+			snapshot.columnTypes.delete(tableName);
 		}
 		this.tableColumnsCache.delete(tableName);
+		this.columnTypeCache.delete(tableName);
 	}
 	/**
 	* Records an out-of-band `ALTER TABLE … ADD COLUMN` in the init snapshot.
@@ -2541,6 +2574,7 @@ var PgDB = class extends MastraBase {
 		const snapshot = this.schemaSnapshot;
 		if (snapshot) this.snapshotColumns(snapshot, tableName).add(column);
 		this.tableColumnsCache.delete(tableName);
+		this.columnTypeCache.delete(tableName);
 	}
 	/**
 	* Gets the set of column names that actually exist in the database table.
@@ -2583,6 +2617,50 @@ var PgDB = class extends MastraBase {
 		]);
 	}
 	/**
+	* Returns the Postgres data type of a column (e.g. `jsonb`, `json`, `text`),
+	* or null when the table or column does not exist.
+	*
+	* Answered from the init snapshot when one is installed, so a warm `init()`
+	* issues no catalog probe. Outside init, results are cached per instance and
+	* the cache is invalidated alongside {@link tableColumnsCache} whenever DDL
+	* changes a table.
+	*/
+	async getColumnType(table, column) {
+		const snapshot = this.schemaSnapshot;
+		if (snapshot) {
+			const types = snapshot.columnTypes.get(table);
+			const known = types?.get(column) ?? types?.get(column.toLowerCase());
+			if (known) return known;
+			if (types) return null;
+		}
+		const cached = this.columnTypeCache.get(table)?.get(column);
+		if (cached !== void 0) return cached;
+		const schema = this.schemaName || "public";
+		const dataType = (await this.client.oneOrNone(`SELECT data_type FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 AND (column_name = $3 OR column_name = $4)`, [
+			schema,
+			table,
+			column,
+			column.toLowerCase()
+		]))?.data_type ?? null;
+		if (dataType) {
+			if (snapshot) {
+				let snapshotTypes = snapshot.columnTypes.get(table);
+				if (!snapshotTypes) {
+					snapshotTypes = /* @__PURE__ */ new Map();
+					snapshot.columnTypes.set(table, snapshotTypes);
+				}
+				snapshotTypes.set(column, dataType);
+			}
+			let types = this.columnTypeCache.get(table);
+			if (!types) {
+				types = /* @__PURE__ */ new Map();
+				this.columnTypeCache.set(table, types);
+			}
+			types.set(column, dataType);
+		}
+		return dataType;
+	}
+	/**
 	* Prepares values for insertion, handling JSONB columns by stringifying them
 	*/
 	prepareValuesForInsert(record, tableName) {
@@ -2781,6 +2859,7 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			}, error);
 		} finally {
 			this.tableColumnsCache.delete(tableName);
+			this.columnTypeCache.delete(tableName);
 		}
 	}
 	async setupTimestampTriggers(tableName) {
@@ -3103,6 +3182,7 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			}, error);
 		} finally {
 			this.tableColumnsCache.delete(tableName);
+			this.columnTypeCache.delete(tableName);
 		}
 	}
 	async load({ tableName, keys }) {
@@ -3166,6 +3246,7 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			}, error);
 		} finally {
 			this.tableColumnsCache.delete(tableName);
+			this.columnTypeCache.delete(tableName);
 		}
 	}
 	async createIndex(options) {
@@ -3717,6 +3798,7 @@ var AgentsPG = class AgentsPG extends AgentsStorage {
 				"workspace",
 				"skills",
 				"skillsFormat",
+				"durable",
 				"browser",
 				"toolProviders"
 			]
@@ -4196,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,
@@ -4222,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,
@@ -4450,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,
@@ -19298,6 +19382,29 @@ function getTableName({ indexName, schemaName }) {
 	const quotedIndexName = `"${indexName}"`;
 	return schemaName ? `${schemaName}.${quotedIndexName}` : quotedIndexName;
 }
+/** Base name (before any schema prefix) of the expression index backing the status filter. */
+const WORKFLOW_SNAPSHOT_STATUS_INDEX = "mastra_workflow_snapshot_name_status_createdat_idx";
+/**
+* Schema-prefixed name of the status index, lowercased and truncated the same way Postgres
+* stores it, so the init snapshot's index set answers "does it exist?" without a probe or a
+* no-op `CREATE INDEX` (schema-prefixed names routinely exceed the 63-byte limit).
+*/
+function workflowSnapshotStatusIndexName(schemaName) {
+	return buildConstraintName({
+		baseName: WORKFLOW_SNAPSHOT_STATUS_INDEX,
+		schemaName: schemaName && schemaName !== "public" ? schemaName : void 0
+	});
+}
+/**
+* Expression index on `(workflow_name, snapshot->>'status', "createdAt" DESC)` so
+* listWorkflowRuns() status filters can use an index instead of scanning every snapshot.
+*/
+function workflowSnapshotStatusIndexSQL(indexName, schemaName) {
+	return `CREATE INDEX IF NOT EXISTS "${indexName}" ON ${getTableName({
+		indexName: TABLE_WORKFLOW_SNAPSHOT,
+		schemaName: getSchemaName(schemaName)
+	})} (workflow_name, (snapshot ->> 'status'), "createdAt" DESC)`;
+}
 /**
 * Sanitizes JSON string for PostgreSQL jsonb:
 * - Removes problematic Unicode sequences:
@@ -19380,6 +19487,7 @@ var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 			includeAllConstraints: true
 		}));
 		for (const idx of WorkflowsPG.getDefaultIndexDefs(schemaPrefix)) statements.push(generateIndexSQL(idx, schemaName));
+		statements.push(`${workflowSnapshotStatusIndexSQL(workflowSnapshotStatusIndexName(parsedSchema), schemaName)};`);
 		return statements;
 	}
 	/**
@@ -19399,6 +19507,13 @@ var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 		} catch (error) {
 			this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
 		}
+		if (await this.#db.getColumnType(TABLE_WORKFLOW_SNAPSHOT, "snapshot") !== "jsonb") return;
+		const indexName = workflowSnapshotStatusIndexName(this.#schema);
+		try {
+			await this.#db.createIndexFromStatement(indexName, workflowSnapshotStatusIndexSQL(indexName, this.#schema));
+		} catch (error) {
+			this.logger?.warn?.(`Failed to create index ${indexName}:`, error);
+		}
 	}
 	async init() {
 		await this.#db.createTable({
@@ -19688,7 +19803,8 @@ var WorkflowsPG = class WorkflowsPG extends WorkflowsStorage {
 				paramIndex++;
 			}
 			if (status) {
-				conditions.push(`regexp_replace(snapshot::text, '\\\\u(0000|[Dd][89A-Fa-f][0-9A-Fa-f]{2})', '', 'g')::jsonb ->> 'status' = $${paramIndex}`);
+				const statusExpr = await this.#db.getColumnType(TABLE_WORKFLOW_SNAPSHOT, "snapshot") === "jsonb" ? `snapshot ->> 'status'` : `regexp_replace(snapshot::text, '\\\\u(0000|[Dd][89A-Fa-f][0-9A-Fa-f]{2})', '', 'g')::jsonb ->> 'status'`;
+				conditions.push(`${statusExpr} = $${paramIndex}`);
 				values.push(status);
 				paramIndex++;
 			}