@mastra/spanner 1.5.0-alpha.0 → 1.5.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @mastra/spanner
 
+## 1.5.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
+
 ## 1.5.0-alpha.0
 
 ### Minor Changes

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-spanner
 description: Documentation for @mastra/spanner. Use when working with @mastra/spanner APIs, configuration, or implementation.
 metadata:
   package: "@mastra/spanner"
-  version: "1.5.0-alpha.0"
+  version: "1.5.0-alpha.1"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.0-alpha.0",
+  "version": "1.5.0-alpha.1",
   "package": "@mastra/spanner",
   "exports": {},
   "modules": {}

package/dist/index.cjs

@@ -11501,6 +11501,169 @@ var SkillsSpanner = class SkillsSpanner extends _mastra_core_storage.SkillsStora
 	}
 };
 //#endregion
+//#region src/storage/domains/workflow-definitions/index.ts
+function rowToDefinition(row) {
+	const parsed = transformFromSpannerRow({
+		tableName: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS,
+		row
+	});
+	if (parsed.inputSchema == null || parsed.outputSchema == null || parsed.graph == null) throw new Error(`Workflow definition row "${String(parsed.id)}" is missing required JSON columns.`);
+	const def = {
+		id: String(parsed.id),
+		inputSchema: parsed.inputSchema,
+		outputSchema: parsed.outputSchema,
+		graph: parsed.graph,
+		status: parsed.status,
+		source: parsed.source,
+		createdAt: parsed.createdAt instanceof Date ? parsed.createdAt : new Date(parsed.createdAt),
+		updatedAt: parsed.updatedAt instanceof Date ? parsed.updatedAt : new Date(parsed.updatedAt)
+	};
+	if (parsed.description != null) def.description = parsed.description;
+	if (parsed.metadata != null) def.metadata = parsed.metadata;
+	if (parsed.stateSchema != null) def.stateSchema = parsed.stateSchema;
+	if (parsed.requestContextSchema != null) def.requestContextSchema = parsed.requestContextSchema;
+	if (parsed.authorId != null) def.authorId = parsed.authorId;
+	return def;
+}
+var WorkflowDefinitionsSpanner = class WorkflowDefinitionsSpanner extends _mastra_core_storage.WorkflowDefinitionsStorage {
+	database;
+	db;
+	skipDefaultIndexes;
+	indexes;
+	static MANAGED_TABLES = [_mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS];
+	constructor(config) {
+		super();
+		const { database, indexes, skipDefaultIndexes, initMode } = resolveSpannerConfig(config);
+		this.database = database;
+		this.db = new SpannerDB({
+			database,
+			skipDefaultIndexes,
+			initMode
+		});
+		this.skipDefaultIndexes = skipDefaultIndexes;
+		this.indexes = indexes?.filter((idx) => WorkflowDefinitionsSpanner.MANAGED_TABLES.includes(idx.table));
+	}
+	async init() {
+		await this.db.createTable({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS,
+			schema: _mastra_core_storage.WORKFLOW_DEFINITIONS_SCHEMA
+		});
+		await this.createDefaultIndexes();
+		await this.createCustomIndexes();
+	}
+	getDefaultIndexDefinitions() {
+		return [{
+			name: "mastra_workflow_definitions_status_idx",
+			table: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS,
+			columns: ["status"]
+		}];
+	}
+	async createDefaultIndexes() {
+		if (this.skipDefaultIndexes) return;
+		await this.db.createIndexes(this.getDefaultIndexDefinitions());
+	}
+	async createCustomIndexes() {
+		if (!this.indexes || this.indexes.length === 0) return;
+		await this.db.createIndexes(this.indexes);
+	}
+	async dangerouslyClearAll() {
+		await this.db.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.db.insert({
+					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.db.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 row = await this.db.load({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS,
+			keys: { id }
+		});
+		return row ? rowToDefinition(row) : null;
+	}
+	async list(args) {
+		const params = {};
+		const conditions = [];
+		if (args?.status) {
+			params.status = args.status;
+			conditions.push(`${quoteIdent("status", "column name")} = @status`);
+		}
+		if (args?.authorId !== void 0) {
+			params.authorId = args.authorId;
+			conditions.push(`${quoteIdent("authorId", "column name")} = @authorId`);
+		}
+		const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+		const sql = `SELECT * FROM ${quoteIdent(_mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS, "table name")} ${where} ORDER BY ${quoteIdent("updatedAt", "column name")} DESC`;
+		const [rows] = await this.database.run({
+			sql,
+			params,
+			json: true
+		});
+		const definitions = rows.map(rowToDefinition);
+		return {
+			definitions,
+			total: definitions.length
+		};
+	}
+	async delete(id) {
+		await this.db.runDml({
+			sql: `DELETE FROM ${quoteIdent(_mastra_core_storage.TABLE_WORKFLOW_DEFINITIONS, "table name")} WHERE id = @id`,
+			params: { id }
+		});
+	}
+};
+//#endregion
 //#region src/storage/domains/workflows/index.ts
 /**
 * Spanner-backed storage for workflow run snapshots, including persistence,
@@ -12669,7 +12832,8 @@ const SPANNER_DOMAIN_KEYS = [
 	"datasets",
 	"experiments",
 	"favorites",
-	"workspaces"
+	"workspaces",
+	"workflowDefinitions"
 ];
 const isPreConfiguredDatabase = (config) => "database" in config && !!config.database;
 /**
@@ -12757,7 +12921,8 @@ var SpannerStore = class extends _mastra_core_storage.MastraCompositeStore {
 				...wants("datasets") && { datasets: new DatasetsSpanner(domainConfig) },
 				...wants("experiments") && { experiments: new ExperimentsSpanner(domainConfig) },
 				...wants("favorites") && { favorites: new FavoritesSpanner(domainConfig) },
-				...wants("workspaces") && { workspaces: new WorkspacesSpanner(domainConfig) }
+				...wants("workspaces") && { workspaces: new WorkspacesSpanner(domainConfig) },
+				...wants("workflowDefinitions") && { workflowDefinitions: new WorkflowDefinitionsSpanner(domainConfig) }
 			};
 		} catch (e) {
 			throw new _mastra_core_error.MastraError({
@@ -12813,7 +12978,8 @@ var SpannerStore = class extends _mastra_core_storage.MastraCompositeStore {
 				"datasets",
 				"experiments",
 				"workspaces",
-				"favorites"
+				"favorites",
+				"workflowDefinitions"
 			]) {
 				const store = this.stores?.[key];
 				if (store) await store.init();
@@ -12863,6 +13029,7 @@ exports.ScorerDefinitionsSpanner = ScorerDefinitionsSpanner;
 exports.ScoresSpanner = ScoresSpanner;
 exports.SkillsSpanner = SkillsSpanner;
 exports.SpannerStore = SpannerStore;
+exports.WorkflowDefinitionsSpanner = WorkflowDefinitionsSpanner;
 exports.WorkflowsSpanner = WorkflowsSpanner;
 exports.WorkspacesSpanner = WorkspacesSpanner;