@mastra/pg 1.24.1-alpha.0 → 1.25.0-alpha.1

package/dist/index.js

@@ -10668,6 +10668,57 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 			}, error);
 		}
 	}
+	/**
+	* Atomically reassign a thread and all of its messages to a different resource.
+	*
+	* Runs inside a single transaction and takes a `SELECT ... FOR UPDATE` row lock on the
+	* thread, so overlapping transfers of the same thread serialize and can never interleave
+	* the thread update with the message update. Either both the thread and every message move
+	* to the new resource, or neither does — there is no split-ownership window. The thread's
+	* `createdAt` is preserved. Callers are responsible for authorizing the reassignment.
+	*/
+	async updateThreadResourceId({ threadId, resourceId }) {
+		const threadsTable = getTableName$3({
+			indexName: TABLE_THREADS,
+			schemaName: getSchemaName$3(this.#schema)
+		});
+		const messagesTable = getTableName$3({
+			indexName: TABLE_MESSAGES,
+			schemaName: getSchemaName$3(this.#schema)
+		});
+		try {
+			return await this.#db.client.tx(async (t) => {
+				const thread = await t.oneOrNone(`SELECT * FROM ${threadsTable} WHERE id = $1 FOR UPDATE`, [threadId]);
+				if (!thread) throw new Error(`Thread "${threadId}" not found`);
+				const normalized = {
+					id: thread.id,
+					resourceId: thread.resourceId,
+					title: thread.title,
+					metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+					createdAt: thread.createdAtZ || thread.createdAt,
+					updatedAt: thread.updatedAtZ || thread.updatedAt
+				};
+				if (thread.resourceId === resourceId) return normalized;
+				await t.none(`UPDATE ${threadsTable} SET "resourceId" = $1, "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id = $2`, [resourceId, threadId]);
+				await t.none(`UPDATE ${messagesTable} SET "resourceId" = $1 WHERE thread_id = $2`, [resourceId, threadId]);
+				return {
+					...normalized,
+					resourceId,
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("PG", "UPDATE_THREAD_RESOURCE_ID", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					threadId,
+					resourceId
+				}
+			}, error);
+		}
+	}
 	async listThreads(args) {
 		const { page = 0, perPage: perPageInput, orderBy, filter } = args;
 		try {
@@ -11672,7 +11723,7 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 		await this.#db.client.none(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = $${paramIndex}`, values);
 		return updatedResource;
 	}
-	async cloneThread(args) {
+	async copyThread(args) {
 		const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
 		const sourceThread = await this.#getThreadById(this.#db.client, { threadId: sourceThreadId });
 		if (!sourceThread) throw new MastraError({
@@ -11698,10 +11749,9 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 			indexName: TABLE_MESSAGES,
 			schemaName: getSchemaName$3(this.#schema)
 		});
-		const hydrateMessages = options?.hydrateMessages ?? true;
 		try {
 			return await this.#db.client.tx(async (t) => {
-				let messageQuery = `SELECT ${hydrateMessages ? `id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"` : `id, "createdAt"`}
+				let messageQuery = `SELECT id, "createdAt"
                             FROM ${messageTableName} WHERE thread_id = $1`;
 				const messageParams = [sourceThreadId];
 				let paramIndex = 2;
@@ -11762,54 +11812,23 @@ var MemoryPG = class MemoryPG extends MemoryStorage {
 					nowStr,
 					nowStr
 				]);
-				const clonedMessages = [];
 				const messageIdMap = {};
 				const targetResourceId = resourceId || sourceThread.resourceId;
 				for (const sourceMsg of sourceMessages) {
 					const newMessageId = crypto.randomUUID();
 					messageIdMap[sourceMsg.id] = newMessageId;
-					if (!hydrateMessages) {
-						const insertResult = await t.query(`INSERT INTO ${messageTableName} (id, thread_id, content, "createdAt", "createdAtZ", role, type, "resourceId")
-               SELECT $1, $2, content, "createdAt", "createdAtZ", role, type, $3
-               FROM ${messageTableName} WHERE id = $4`, [
-							newMessageId,
-							newThreadId,
-							targetResourceId,
-							sourceMsg.id
-						]);
-						if (insertResult.rowCount !== 1) throw new Error(`Failed to clone message ${sourceMsg.id}: expected 1 row copied but got ${insertResult.rowCount}`);
-						continue;
-					}
-					const normalizedMsg = this.normalizeMessageRow(sourceMsg);
-					let parsedContent = normalizedMsg.content;
-					try {
-						parsedContent = JSON.parse(normalizedMsg.content);
-					} catch {}
-					const createdAt = toUtcISOString(new Date(normalizedMsg.createdAt));
-					await t.none(`INSERT INTO ${messageTableName} (id, thread_id, content, "createdAt", "createdAtZ", role, type, "resourceId")
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, [
+					const insertResult = await t.query(`INSERT INTO ${messageTableName} (id, thread_id, content, "createdAt", "createdAtZ", role, type, "resourceId")
+             SELECT $1, $2, content, "createdAt", "createdAtZ", role, type, $3
+             FROM ${messageTableName} WHERE id = $4`, [
 						newMessageId,
 						newThreadId,
-						typeof normalizedMsg.content === "string" ? normalizedMsg.content : JSON.stringify(normalizedMsg.content),
-						createdAt,
-						createdAt,
-						normalizedMsg.role,
-						normalizedMsg.type || "v2",
-						targetResourceId
+						targetResourceId,
+						sourceMsg.id
 					]);
-					clonedMessages.push({
-						id: newMessageId,
-						threadId: newThreadId,
-						content: parsedContent,
-						role: normalizedMsg.role,
-						type: normalizedMsg.type,
-						createdAt: new Date(normalizedMsg.createdAt),
-						resourceId: targetResourceId
-					});
+					if (insertResult.rowCount !== 1) throw new Error(`Failed to copy message ${sourceMsg.id}: expected 1 row copied but got ${insertResult.rowCount}`);
 				}
 				return {
 					thread: newThread,
-					clonedMessages,
 					messageIdMap
 				};
 			});