@mastra/mysql 0.6.0-alpha.0 → 0.6.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @mastra/mysql
 
+## 0.6.0-alpha.1
+
+### Minor Changes
+
+- Stored workflow definitions now persist across restarts on every major database backend. ([#20471](https://github.com/mastra-ai/mastra/pull/20471))
+
+  Implement the `workflowDefinitions` storage domain for libsql, pg, mysql, mssql, mongodb, and spanner. Previously the stored-workflow persistence path (`POST /stored/workflows`, `Mastra.addStoredWorkflow`) only worked against `@mastra/core`'s in-memory store. Persistent adapters returned `undefined` from `storage.getStore('workflowDefinitions')` and threw when the HTTP handler tried to read/write a workflow.
+
+  ```ts
+  const workflowDefinitions = await storage.getStore('workflowDefinitions');
+  if (!workflowDefinitions) {
+    throw new Error('This storage adapter does not support the workflowDefinitions domain');
+  }
+
+  await workflowDefinitions.upsert({
+    id: 'greeting-workflow',
+    inputSchema: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+    outputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] },
+    graph: [{ type: 'agent', id: 'greet', agentId: 'greeter-agent' }],
+  });
+
+  const { definitions, total } = await workflowDefinitions.list({ status: 'active' });
+  const definition = await workflowDefinitions.get('greeting-workflow');
+  await workflowDefinitions.delete('greeting-workflow');
+  ```
+
+  Each adapter now ships a `WorkflowDefinitions*` domain that:
+
+  - Creates the shared `mastra_workflow_definitions` table (or Mongo collection) from `WORKFLOW_DEFINITIONS_SCHEMA` during `init()`, plus a default index on `status`.
+  - Implements `upsert` / `get` / `list` / `delete` matching `WorkflowDefinitionsStorage` semantics (`list` supports `status` and `authorId` filters and orders by `updatedAt` desc). Partial upserts preserve unspecified fields, including `authorId` updates and `createdAt` / `updatedAt` semantics.
+  - Handles concurrent first-writes race-safely: if two callers upsert the same new id simultaneously, the losing insert detects the duplicate key, re-reads the row, and applies the partial-update path instead of failing.
+  - Round-trips the JSON columns (`inputSchema`, `outputSchema`, `stateSchema`, `requestContextSchema`, `metadata`, `graph`) through each adapter's JSON handling, so declarative workflow graphs rehydrate identically no matter which backend they were stored in. Malformed persisted JSON surfaces as an actionable error naming the row and column instead of hydrating raw strings.
+
+  Exported class names by adapter: `WorkflowDefinitionsLibSQL`, `WorkflowDefinitionsPG`, `WorkflowDefinitionsMySQL`, `WorkflowDefinitionsMSSQL`, `MongoDBWorkflowDefinitionsStore`, `WorkflowDefinitionsSpanner`. The composite stores (`LibSQLStore`, `PostgresStore`, `MySQLStore`, `MSSQLStore`, `MongoDBStore`, `SpannerStore`) auto-wire the new domain, so callers do not need to construct it manually — `storage.getStore('workflowDefinitions')` now returns a live handle.
+
+  The pg adapter reads `createdAt` / `updatedAt` from the auto-added `createdAtZ` / `updatedAtZ` `timestamptz` companion columns to avoid the naive-timestamp / local-TZ drift that a plain `TIMESTAMP` read exhibits under node-pg.
+
+  `@mastra/clickhouse` and `@mastra/cloudflare` register the new `mastra_workflow_definitions` table in their table/type maps so shared table constants stay exhaustive (no workflow-definitions domain implementation yet).
+
+### Patch Changes
+
+- Updated dependencies [[`4844167`](https://github.com/mastra-ai/mastra/commit/4844167cff2d5ec5004e94edd34970833040fa3f), [`5faf93f`](https://github.com/mastra-ai/mastra/commit/5faf93f03e19daea394b9e2a923f2e4f833407f2), [`80ad891`](https://github.com/mastra-ai/mastra/commit/80ad891f8cd10379aa5b5af7510c763783b2ab56), [`a1cb98d`](https://github.com/mastra-ai/mastra/commit/a1cb98d11990b560b98482292a1f34aa1a2d9092), [`598ad82`](https://github.com/mastra-ai/mastra/commit/598ad82d41c41389a686338a1d0e50b7400e1938), [`1fd6aad`](https://github.com/mastra-ai/mastra/commit/1fd6aad1ea4a9d32f65efa832307c35e981a4c0a)]:
+  - @mastra/core@1.56.0-alpha.4
+
 ## 0.6.0-alpha.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -9177,6 +9177,140 @@ var ToolProviderConnectionsMySQL = class ToolProviderConnectionsMySQL extends _m
 	}
 };
 //#endregion
+//#region src/storage/domains/workflow-definitions/index.ts
+function rowToDefinition(row) {
+	const transformed = transformFromSqlRow({
+		tableName: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS,
+		sqlRow: row
+	});
+	const def = {
+		id: String(transformed.id),
+		inputSchema: transformed.inputSchema,
+		outputSchema: transformed.outputSchema,
+		graph: transformed.graph,
+		status: String(transformed.status),
+		source: String(transformed.source),
+		createdAt: transformed.createdAt,
+		updatedAt: transformed.updatedAt
+	};
+	if (transformed.description != null) def.description = String(transformed.description);
+	if (transformed.metadata != null) def.metadata = transformed.metadata;
+	if (transformed.stateSchema != null) def.stateSchema = transformed.stateSchema;
+	if (transformed.requestContextSchema != null) def.requestContextSchema = transformed.requestContextSchema;
+	if (transformed.authorId != null) def.authorId = String(transformed.authorId);
+	return def;
+}
+var WorkflowDefinitionsMySQL = class extends _mastra_core_storage.WorkflowDefinitionsStorage {
+	pool;
+	operations;
+	database;
+	static MANAGED_TABLES = [_mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS];
+	static getExportDDL() {
+		return [generateTableSQL({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS,
+			schema: _mastra_core_storage.WORKFLOW_DEFINITIONS_SCHEMA
+		})];
+	}
+	constructor({ pool, operations, database }) {
+		super();
+		this.pool = pool;
+		this.operations = operations;
+		this.database = database;
+	}
+	async init() {
+		await this.operations.createTable({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS,
+			schema: _mastra_core_storage.WORKFLOW_DEFINITIONS_SCHEMA
+		});
+	}
+	async dangerouslyClearAll() {
+		await this.operations.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS });
+	}
+	async upsert(input) {
+		const now = /* @__PURE__ */ new Date();
+		if (!await this.get(input.id)) {
+			if (!("inputSchema" in input) || input.inputSchema === void 0) throw new Error(`Cannot create workflow definition "${input.id}": inputSchema is required.`);
+			if (!("outputSchema" in input) || input.outputSchema === void 0) throw new Error(`Cannot create workflow definition "${input.id}": outputSchema is required.`);
+			if (!("graph" in input) || input.graph === void 0) throw new Error(`Cannot create workflow definition "${input.id}": graph is required.`);
+			const record = {
+				id: input.id,
+				description: input.description ?? null,
+				metadata: input.metadata ?? null,
+				inputSchema: input.inputSchema,
+				outputSchema: input.outputSchema,
+				stateSchema: input.stateSchema ?? null,
+				requestContextSchema: input.requestContextSchema ?? null,
+				graph: input.graph,
+				status: "active",
+				source: "storage",
+				authorId: "authorId" in input ? input.authorId ?? null : null,
+				createdAt: now,
+				updatedAt: now
+			};
+			try {
+				await this.operations.insertOnly({
+					tableName: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS,
+					record
+				});
+			} catch (error) {
+				if (!await this.get(input.id)) throw error;
+				return this.applyUpdate(input, now);
+			}
+			const created = await this.get(input.id);
+			if (!created) throw new Error(`Failed to persist workflow definition "${input.id}".`);
+			return created;
+		}
+		return this.applyUpdate(input, now);
+	}
+	async applyUpdate(input, now) {
+		const data = { updatedAt: now };
+		if ("description" in input && input.description !== void 0) data.description = input.description;
+		if ("metadata" in input && input.metadata !== void 0) data.metadata = input.metadata;
+		if ("inputSchema" in input && input.inputSchema !== void 0) data.inputSchema = input.inputSchema;
+		if ("outputSchema" in input && input.outputSchema !== void 0) data.outputSchema = input.outputSchema;
+		if ("stateSchema" in input && input.stateSchema !== void 0) data.stateSchema = input.stateSchema;
+		if ("requestContextSchema" in input && input.requestContextSchema !== void 0) data.requestContextSchema = input.requestContextSchema;
+		if ("graph" in input && input.graph !== void 0) data.graph = input.graph;
+		if ("status" in input && input.status !== void 0) data.status = input.status;
+		if ("authorId" in input && input.authorId !== void 0) data.authorId = input.authorId;
+		await this.operations.update({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS,
+			keys: { id: input.id },
+			data
+		});
+		const updated = await this.get(input.id);
+		if (!updated) throw new Error(`Failed to update workflow definition "${input.id}".`);
+		return updated;
+	}
+	async get(id) {
+		const [rows] = await this.pool.execute(`SELECT * FROM ${formatTableName(_mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS, this.database)} WHERE ${quoteIdentifier("id", "column name")} = ?`, [id]);
+		if (!rows.length) return null;
+		return rowToDefinition(rows[0]);
+	}
+	async list(args) {
+		const conditions = [];
+		const params = [];
+		if (args?.status) {
+			conditions.push(`${quoteIdentifier("status", "column name")} = ?`);
+			params.push(args.status);
+		}
+		if (args?.authorId !== void 0) {
+			conditions.push(`${quoteIdentifier("authorId", "column name")} = ?`);
+			params.push(args.authorId);
+		}
+		const where = conditions.length ? ` WHERE ${conditions.join(" AND ")}` : "";
+		const [rows] = await this.pool.execute(`SELECT * FROM ${formatTableName(_mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS, this.database)}${where} ORDER BY ${quoteIdentifier("updatedAt", "column name")} DESC`, params);
+		const definitions = rows.map((row) => rowToDefinition(row));
+		return {
+			definitions,
+			total: definitions.length
+		};
+	}
+	async delete(id) {
+		await this.pool.execute(`DELETE FROM ${formatTableName(_mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS, this.database)} WHERE ${quoteIdentifier("id", "column name")} = ?`, [id]);
+	}
+};
+//#endregion
 //#region src/storage/domains/workflows/index.ts
 function parseSnapshot(snapshot) {
 	if (typeof snapshot === "string") try {
@@ -10257,6 +10391,11 @@ var MySQLStore = class extends _mastra_core_storage.MastraCompositeStore {
 			skipDefaultIndexes: config.skipDefaultIndexes,
 			indexes: config.indexes
 		});
+		const workflowDefinitions = new WorkflowDefinitionsMySQL({
+			pool: this.pool,
+			operations,
+			database
+		});
 		this.stores = {
 			memory,
 			workflows,
@@ -10276,7 +10415,8 @@ var MySQLStore = class extends _mastra_core_storage.MastraCompositeStore {
 			channels,
 			favorites,
 			schedules,
-			toolProviderConnections
+			toolProviderConnections,
+			workflowDefinitions
 		};
 	}
 	async init() {