@mastra/pg 1.20.0 → 1.20.1-alpha.1

package/dist/index.cjs

@@ -2176,7 +2176,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
@@ -2191,6 +2191,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) {
@@ -2198,6 +2199,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();
@@ -2211,6 +2218,7 @@ async function loadSchemaSnapshot(client, schemaName) {
 		schemaName: schema,
 		tables: new Set(tableRows.map((r) => r.tablename)),
 		columns,
+		columnTypes,
 		indexes,
 		replicaIdentityIndexes,
 		primaryKeyIndexes
@@ -2464,6 +2472,8 @@ var PgDB = class extends _mastra_core_base.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",
@@ -2538,7 +2548,9 @@ var PgDB = class extends _mastra_core_base.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
@@ -2554,8 +2566,10 @@ var PgDB = class extends _mastra_core_base.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.
@@ -2565,6 +2579,7 @@ var PgDB = class extends _mastra_core_base.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.
@@ -2607,6 +2622,50 @@ var PgDB = class extends _mastra_core_base.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) {
@@ -2805,6 +2864,7 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			}, error);
 		} finally {
 			this.tableColumnsCache.delete(tableName);
+			this.columnTypeCache.delete(tableName);
 		}
 	}
 	async setupTimestampTriggers(tableName) {
@@ -3127,6 +3187,7 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			}, error);
 		} finally {
 			this.tableColumnsCache.delete(tableName);
+			this.columnTypeCache.delete(tableName);
 		}
 	}
 	async load({ tableName, keys }) {
@@ -3190,6 +3251,7 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			}, error);
 		} finally {
 			this.tableColumnsCache.delete(tableName);
+			this.columnTypeCache.delete(tableName);
 		}
 	}
 	async createIndex(options) {
@@ -19322,6 +19384,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: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+		schemaName: getSchemaName(schemaName)
+	})} (workflow_name, (snapshot ->> 'status'), "createdAt" DESC)`;
+}
 /**
 * Sanitizes JSON string for PostgreSQL jsonb:
 * - Removes problematic Unicode sequences:
@@ -19382,33 +19467,55 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			updatedAt: new Date(row.updatedAtZ || row.updatedAt)
 		};
 	}
+	static getDefaultIndexDefs(schemaPrefix) {
+		return [{
+			name: `${schemaPrefix}mastra_workflow_snapshot_name_createdat_idx`,
+			table: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+			columns: ["workflow_name", "createdAt DESC"]
+		}];
+	}
 	/**
 	* Returns all DDL statements for this domain: table with unique constraint.
 	* Used by exportSchemas to produce a complete, reproducible schema export.
 	*/
 	static getExportDDL(schemaName) {
 		const statements = [];
+		const parsedSchema = schemaName ? (0, _mastra_core_utils.parseSqlIdentifier)(schemaName, "schema name") : "";
+		const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
 		statements.push(generateTableSQL({
 			tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT],
 			schemaName,
 			includeAllConstraints: true
 		}));
+		for (const idx of WorkflowsPG.getDefaultIndexDefs(schemaPrefix)) statements.push(generateIndexSQL(idx, schemaName));
+		statements.push(`${workflowSnapshotStatusIndexSQL(workflowSnapshotStatusIndexName(parsedSchema), schemaName)};`);
 		return statements;
 	}
 	/**
 	* Returns default index definitions for the workflows domain tables.
-	* Currently no default indexes are defined for workflows.
 	*/
 	getDefaultIndexDefinitions() {
-		return [];
+		const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+		return WorkflowsPG.getDefaultIndexDefs(schemaPrefix);
 	}
 	/**
 	* Creates default indexes for optimal query performance.
-	* Currently no default indexes are defined for workflows.
 	*/
 	async createDefaultIndexes() {
 		if (this.#skipDefaultIndexes) return;
+		for (const indexDef of this.getDefaultIndexDefinitions()) try {
+			await this.#db.createIndex(indexDef);
+		} catch (error) {
+			this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+		}
+		if (await this.#db.getColumnType(_mastra_core_storage.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({
@@ -19698,7 +19805,8 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 				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(_mastra_core_storage.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++;
 			}