@mastra/spanner 1.6.7-alpha.0 → 1.7.0

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.6.7-alpha.0"
+  version: "1.7.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

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

package/dist/index.cjs

@@ -6959,6 +6959,88 @@ var MemorySpanner = class MemorySpanner extends _mastra_core_storage.MemoryStora
 			}, error);
 		}
 	}
+	/**
+	* Atomically reassign a thread and all of its messages to a different resource.
+	*
+	* Runs inside a single read-write transaction: the thread row is read inside the
+	* transaction (acquiring a lock), then the thread and every message are moved together.
+	* Overlapping transfers of the same thread serialize on the transaction, so they can never
+	* interleave the thread update with the message update — either both move or neither does,
+	* with no split-ownership window. The thread's `createdAt` is preserved. Callers are
+	* responsible for authorizing the reassignment.
+	*/
+	async updateThreadResourceId({ threadId, resourceId }) {
+		const tableThreads = quoteIdent(_mastra_core_storage.TABLE_THREADS, "table name");
+		const messagesTable = quoteIdent(_mastra_core_storage.TABLE_MESSAGES, "table name");
+		const now = /* @__PURE__ */ new Date();
+		let existingThread = null;
+		let noop = false;
+		try {
+			await this.db.runWithAbortRetry(() => this.database.runTransactionAsync(async (tx) => {
+				try {
+					const [rows] = await tx.run({
+						sql: `SELECT * FROM ${tableThreads} WHERE id = @threadId LIMIT 1`,
+						params: { threadId },
+						json: true
+					});
+					const row = rows[0];
+					if (!row) throw new _mastra_core_error.MastraError({
+						id: (0, _mastra_core_storage.createStorageErrorId)("SPANNER", "UPDATE_THREAD_RESOURCE_ID", "NOT_FOUND"),
+						domain: _mastra_core_error.ErrorDomain.STORAGE,
+						category: _mastra_core_error.ErrorCategory.USER,
+						text: `Thread ${threadId} not found`,
+						details: { threadId }
+					});
+					existingThread = this.formatThreadRow(row);
+					if (existingThread.resourceId === resourceId) {
+						noop = true;
+						await tx.commit();
+						return;
+					}
+					await this.db.update({
+						tableName: _mastra_core_storage.TABLE_THREADS,
+						keys: { id: threadId },
+						data: {
+							resourceId,
+							updatedAt: now
+						},
+						transaction: tx
+					});
+					await tx.runUpdate({
+						sql: `UPDATE ${messagesTable} SET ${quoteIdent("resourceId", "column name")} = @resourceId WHERE ${quoteIdent("thread_id", "column name")} = @threadId`,
+						params: {
+							resourceId,
+							threadId
+						}
+					});
+					await tx.commit();
+				} catch (err) {
+					await tx.rollback().catch((rollbackErr) => {
+						throw new AggregateError([err, rollbackErr], "Transaction and rollback both failed");
+					});
+					throw err;
+				}
+			}));
+			const thread = existingThread;
+			if (noop) return thread;
+			return {
+				...thread,
+				resourceId,
+				updatedAt: now
+			};
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("SPANNER", "UPDATE_THREAD_RESOURCE_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					threadId,
+					resourceId
+				}
+			}, error);
+		}
+	}
 	/** Deletes a thread and all its messages atomically. */
 	async deleteThread({ threadId }) {
 		const messagesTable = quoteIdent(_mastra_core_storage.TABLE_MESSAGES, "table name");