@mastra/libsql 0.10.3 → 0.10.4-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/libsql",
-  "version": "0.10.3",
+  "version": "0.10.4-alpha.1",
   "description": "Libsql provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -29,9 +29,9 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
-    "@internal/lint": "0.0.13",
-    "@mastra/core": "0.10.6",
-    "@internal/storage-test-utils": "0.0.9"
+    "@internal/storage-test-utils": "0.0.9",
+    "@mastra/core": "0.10.7-alpha.1",
+    "@internal/lint": "0.0.13"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/storage/index.test.ts

@@ -6,6 +6,7 @@ import {
   createTestSuite,
   createSampleMessageV1,
   resetRole,
+  createSampleMessageV2,
 } from '@internal/storage-test-utils';
 import type { MastraMessageV1, StorageThreadType } from '@mastra/core';
 import { Mastra } from '@mastra/core/mastra';
@@ -362,3 +363,167 @@ describe('LibSQLStore Pagination Features', () => {
     });
   });
 });
+
+describe('LibSQLStore updateMessages', () => {
+  let store: LibSQLStore;
+  let thread: StorageThreadType;
+
+  beforeAll(async () => {
+    store = libsql;
+  });
+
+  beforeEach(async () => {
+    await store.clearTable({ tableName: TABLE_MESSAGES });
+    await store.clearTable({ tableName: TABLE_THREADS });
+    const threadData = createSampleThread();
+    thread = await store.saveThread({ thread: threadData as StorageThreadType });
+  });
+
+  it('should update a single field of a message (e.g., role)', async () => {
+    const originalMessage = createSampleMessageV2({ threadId: thread.id, role: 'user' });
+    await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+    const updatedMessages = await store.updateMessages({
+      messages: [{ id: originalMessage.id, role: 'assistant' }],
+    });
+
+    expect(updatedMessages).toHaveLength(1);
+    expect(updatedMessages[0].role).toBe('assistant');
+
+    const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    expect(fromDb[0].role).toBe('assistant');
+  });
+
+  it('should update only the metadata within the content field, preserving other content fields', async () => {
+    const originalMessage = createSampleMessageV2({
+      threadId: thread.id,
+      content: { content: 'hello world', parts: [{ type: 'text', text: 'hello world' }] },
+    });
+    await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+    const newMetadata = { someKey: 'someValue' };
+    await store.updateMessages({
+      messages: [{ id: originalMessage.id, content: { metadata: newMetadata } as any }],
+    });
+
+    const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    expect(fromDb).toHaveLength(1);
+    expect(fromDb[0].content.metadata).toEqual(newMetadata);
+    expect(fromDb[0].content.content).toBe('hello world');
+    expect(fromDb[0].content.parts).toEqual([{ type: 'text', text: 'hello world' }]);
+  });
+
+  it('should update only the content string within the content field, preserving metadata', async () => {
+    const originalMessage = createSampleMessageV2({
+      threadId: thread.id,
+      content: { metadata: { initial: true } },
+    });
+    await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+    const newContentString = 'This is the new content string';
+    await store.updateMessages({
+      messages: [{ id: originalMessage.id, content: { content: newContentString } as any }],
+    });
+
+    const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    expect(fromDb[0].content.content).toBe(newContentString);
+    expect(fromDb[0].content.metadata).toEqual({ initial: true });
+  });
+
+  it('should deep merge metadata, not overwrite it', async () => {
+    const originalMessage = createSampleMessageV2({
+      threadId: thread.id,
+      content: { metadata: { initial: true }, content: 'old content' },
+    });
+    await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+    const newMetadata = { updated: true };
+    await store.updateMessages({
+      messages: [{ id: originalMessage.id, content: { metadata: newMetadata } as any }],
+    });
+
+    const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    expect(fromDb[0].content.content).toBe('old content');
+    expect(fromDb[0].content.metadata).toEqual({ initial: true, updated: true });
+  });
+
+  it('should update multiple messages at once', async () => {
+    const msg1 = createSampleMessageV2({ threadId: thread.id, role: 'user' });
+    const msg2 = createSampleMessageV2({ threadId: thread.id, content: { content: 'original' } });
+    await store.saveMessages({ messages: [msg1, msg2], format: 'v2' });
+
+    await store.updateMessages({
+      messages: [
+        { id: msg1.id, role: 'assistant' },
+        { id: msg2.id, content: { content: 'updated' } as any },
+      ],
+    });
+
+    const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    const updatedMsg1 = fromDb.find(m => m.id === msg1.id)!;
+    const updatedMsg2 = fromDb.find(m => m.id === msg2.id)!;
+
+    expect(updatedMsg1.role).toBe('assistant');
+    expect(updatedMsg2.content.content).toBe('updated');
+  });
+
+  it('should update the parent thread updatedAt timestamp', async () => {
+    const originalMessage = createSampleMessageV2({ threadId: thread.id });
+    await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+    const initialThread = await store.getThreadById({ threadId: thread.id });
+
+    await new Promise(r => setTimeout(r, 10));
+
+    await store.updateMessages({ messages: [{ id: originalMessage.id, role: 'assistant' }] });
+
+    const updatedThread = await store.getThreadById({ threadId: thread.id });
+
+    expect(new Date(updatedThread!.updatedAt).getTime()).toBeGreaterThan(new Date(initialThread!.updatedAt).getTime());
+  });
+
+  it('should update timestamps on both threads when moving a message', async () => {
+    const thread2 = await store.saveThread({ thread: createSampleThread() });
+    const message = createSampleMessageV2({ threadId: thread.id });
+    await store.saveMessages({ messages: [message], format: 'v2' });
+
+    const initialThread1 = await store.getThreadById({ threadId: thread.id });
+    const initialThread2 = await store.getThreadById({ threadId: thread2.id });
+
+    await new Promise(r => setTimeout(r, 10));
+
+    await store.updateMessages({
+      messages: [{ id: message.id, threadId: thread2.id }],
+    });
+
+    const updatedThread1 = await store.getThreadById({ threadId: thread.id });
+    const updatedThread2 = await store.getThreadById({ threadId: thread2.id });
+
+    expect(new Date(updatedThread1!.updatedAt).getTime()).toBeGreaterThan(
+      new Date(initialThread1!.updatedAt).getTime(),
+    );
+    expect(new Date(updatedThread2!.updatedAt).getTime()).toBeGreaterThan(
+      new Date(initialThread2!.updatedAt).getTime(),
+    );
+
+    // Verify the message was moved
+    const thread1Messages = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    const thread2Messages = await store.getMessages({ threadId: thread2.id, format: 'v2' });
+    expect(thread1Messages).toHaveLength(0);
+    expect(thread2Messages).toHaveLength(1);
+    expect(thread2Messages[0].id).toBe(message.id);
+  });
+
+  it('should not fail when trying to update a non-existent message', async () => {
+    const originalMessage = createSampleMessageV2({ threadId: thread.id });
+    await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+    await expect(
+      store.updateMessages({
+        messages: [{ id: randomUUID(), role: 'assistant' }],
+      }),
+    ).resolves.not.toThrow();
+
+    const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    expect(fromDb[0].role).toBe(originalMessage.role);
+  });
+});