@mastra/upstash 0.1.5 → 0.1.6-alpha.1

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @mastra/upstash@0.1.5-alpha.2 build /home/runner/work/mastra/mastra/stores/upstash
+> @mastra/upstash@0.1.6-alpha.1 build /home/runner/work/mastra/mastra/stores/upstash
 > tsup src/index.ts --format esm --experimental-dts --clean --treeshake
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.3.6
 TSC Build start
-TSC ⚡️ Build success in 8405ms
+TSC ⚡️ Build success in 8433ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.7.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/upstash/dist/_tsup-dts-rollup.d.ts
-DTS ⚡️ Build success in 6810ms
+DTS ⚡️ Build success in 6040ms
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js 16.11 KB
-ESM ⚡️ Build success in 633ms
+ESM dist/index.js 15.98 KB
+ESM ⚡️ Build success in 577ms

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @mastra/upstash
 
+## 0.1.6-alpha.1
+
+### Patch Changes
+
+- Updated dependencies [0d185b1]
+- Updated dependencies [ed55f1d]
+- Updated dependencies [8d13b14]
+- Updated dependencies [3ee4831]
+- Updated dependencies [108793c]
+- Updated dependencies [5f28f44]
+  - @mastra/core@0.4.3-alpha.1
+
+## 0.1.6-alpha.0
+
+### Patch Changes
+
+- Updated dependencies [06aa827]
+  - @mastra/core@0.4.3-alpha.0
+
 ## 0.1.5
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.ts

@@ -1,16 +1,16 @@
 import { BaseFilterTranslator } from '@mastra/core/filter';
-import { EvalRow } from '@mastra/core/storage';
-import { Filter } from '@mastra/core/filter';
+import type { EvalRow } from '@mastra/core/storage';
+import type { Filter } from '@mastra/core/filter';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
-import { MessageType } from '@mastra/core/memory';
-import { OperatorSupport } from '@mastra/core/filter';
+import type { MessageType } from '@mastra/core/memory';
+import type { OperatorSupport } from '@mastra/core/filter';
 import type { QueryResult } from '@mastra/core/vector';
-import { StorageColumn } from '@mastra/core/storage';
-import { StorageGetMessagesArg } from '@mastra/core/storage';
-import { StorageThreadType } from '@mastra/core/memory';
-import { TABLE_NAMES } from '@mastra/core/storage';
-import { WorkflowRunState } from '@mastra/core/workflows';
+import type { StorageColumn } from '@mastra/core/storage';
+import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageThreadType } from '@mastra/core/memory';
+import type { TABLE_NAMES } from '@mastra/core/storage';
+import type { WorkflowRunState } from '@mastra/core/workflows';
 
 declare interface UpstashConfig {
     url: string;
@@ -34,12 +34,12 @@ export declare class UpstashFilterTranslator extends BaseFilterTranslator {
 }
 
 declare class UpstashStore extends MastraStorage {
-    batchInsert({ tableName, records }: {
+    batchInsert(_input: {
         tableName: TABLE_NAMES;
         records: Record<string, any>[];
     }): Promise<void>;
-    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
-    getTraces({ name, scope, page, perPage, attributes, }: {
+    getEvalsByAgentName(_agentName: string, _type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getTraces(_input: {
         name?: string;
         scope?: string;
         page: number;

package/dist/index.js

@@ -1,6 +1,4 @@
-import '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
-import '@mastra/core/workflows';
 import { Redis } from '@upstash/redis';
 import { MastraVector } from '@mastra/core/vector';
 import { Index } from '@upstash/vector';
@@ -8,19 +6,13 @@ import { BaseFilterTranslator } from '@mastra/core/filter';
 
 // src/storage/index.ts
 var UpstashStore = class extends MastraStorage {
-  batchInsert({ tableName, records }) {
+  batchInsert(_input) {
     throw new Error("Method not implemented.");
   }
-  getEvalsByAgentName(agentName, type) {
+  getEvalsByAgentName(_agentName, _type) {
     throw new Error("Method not implemented.");
   }
-  getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes
-  }) {
+  getTraces(_input) {
     throw new Error("Method not implemented.");
   }
   redis;

package/eslint.config.js

@@ -0,0 +1,6 @@
+import { createConfig } from '@internal/lint/eslint';
+
+const config = await createConfig();
+
+/** @type {import("eslint").Linter.Config[]} */
+export default [...config];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.1.5",
+  "version": "0.1.6-alpha.1",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -17,20 +17,23 @@
   "dependencies": {
     "@upstash/redis": "^1.28.3",
     "@upstash/vector": "^1.1.7",
-    "@mastra/core": "^0.4.2"
+    "@mastra/core": "^0.4.3-alpha.1"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",
     "@types/node": "^22.13.1",
     "tsup": "^8.0.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.4"
+    "vitest": "^3.0.4",
+    "eslint": "^9.20.1",
+    "@internal/lint": "0.0.0"
   },
   "scripts": {
     "pretest": "docker compose up -d",
     "test": "vitest run",
     "posttest": "docker compose down",
     "build": "tsup src/index.ts --format esm --experimental-dts --clean --treeshake",
-    "build:watch": "pnpm build --watch"
+    "build:watch": "pnpm build --watch",
+    "lint": "eslint ."
   }
 }

package/src/storage/index.ts

@@ -1,12 +1,7 @@
-import { type StorageThreadType, type MessageType } from '@mastra/core/memory';
-import {
-  MastraStorage,
-  type TABLE_NAMES,
-  type StorageColumn,
-  type StorageGetMessagesArg,
-  type EvalRow,
-} from '@mastra/core/storage';
-import { type WorkflowRunState } from '@mastra/core/workflows';
+import type { StorageThreadType, MessageType } from '@mastra/core/memory';
+import { MastraStorage } from '@mastra/core/storage';
+import type { TABLE_NAMES, StorageColumn, StorageGetMessagesArg, EvalRow } from '@mastra/core/storage';
+import type { WorkflowRunState } from '@mastra/core/workflows';
 import { Redis } from '@upstash/redis';
 
 export interface UpstashConfig {
@@ -15,19 +10,13 @@ export interface UpstashConfig {
 }
 
 export class UpstashStore extends MastraStorage {
-  batchInsert({ tableName, records }: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
+  batchInsert(_input: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
     throw new Error('Method not implemented.');
   }
-  getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
+  getEvalsByAgentName(_agentName: string, _type?: 'test' | 'live'): Promise<EvalRow[]> {
     throw new Error('Method not implemented.');
   }
-  getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes,
-  }: {
+  getTraces(_input: {
     name?: string;
     scope?: string;
     page: number;

package/src/storage/upstash.test.ts

@@ -3,379 +3,385 @@ import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest';
 
 import { UpstashStore } from './index';
 
-describe('UpstashStore', () => {
-  let store: UpstashStore;
-  const testTableName = 'test_table';
-  const testTableName2 = 'test_table2';
-
-  beforeAll(async () => {
-    store = new UpstashStore({
-      url: 'http://localhost:8079',
-      token: 'test_token',
-    });
-    await store.init();
-  });
-
-  afterAll(async () => {
-    // Clean up test tables
-    await store.clearTable({ tableName: testTableName });
-    await store.clearTable({ tableName: testTableName2 });
-    await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
-    await store.clearTable({ tableName: MastraStorage.TABLE_MESSAGES });
-  });
-
-  describe('Table Operations', () => {
-    it('should create a new table with schema', async () => {
-      await store.createTable({
-        tableName: testTableName,
-        schema: {
-          id: { type: 'text', primaryKey: true },
-          data: { type: 'text', nullable: true },
-        },
-      });
-
-      // Verify table exists by inserting and retrieving data
-      await store.insert({
-        tableName: testTableName,
-        record: { id: 'test1', data: 'test-data' },
+describe(
+  'UpstashStore',
+  () => {
+    let store: UpstashStore;
+    const testTableName = 'test_table';
+    const testTableName2 = 'test_table2';
+
+    beforeAll(async () => {
+      store = new UpstashStore({
+        url: 'http://localhost:8079',
+        token: 'test_token',
       });
+      await store.init();
+    });
 
-      const result = await store.load({ tableName: testTableName, keys: { id: 'test1' } });
-      expect(result).toBeTruthy();
+    afterAll(async () => {
+      // Clean up test tables
+      await store.clearTable({ tableName: testTableName });
+      await store.clearTable({ tableName: testTableName2 });
+      await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
+      await store.clearTable({ tableName: MastraStorage.TABLE_MESSAGES });
     });
 
-    it('should handle multiple table creation', async () => {
-      await store.createTable({
-        tableName: testTableName2,
-        schema: {
-          id: { type: 'text', primaryKey: true },
-          data: { type: 'text', nullable: true },
-        },
-      });
+    describe('Table Operations', () => {
+      it('should create a new table with schema', async () => {
+        await store.createTable({
+          tableName: testTableName,
+          schema: {
+            id: { type: 'text', primaryKey: true },
+            data: { type: 'text', nullable: true },
+          },
+        });
+
+        // Verify table exists by inserting and retrieving data
+        await store.insert({
+          tableName: testTableName,
+          record: { id: 'test1', data: 'test-data' },
+        });
 
-      // Verify both tables work independently
-      await store.insert({
-        tableName: testTableName2,
-        record: { id: 'test2', data: 'test-data-2' },
+        const result = await store.load({ tableName: testTableName, keys: { id: 'test1' } });
+        expect(result).toBeTruthy();
       });
 
-      const result = await store.load({ tableName: testTableName2, keys: { id: 'test2' } });
-      expect(result).toBeTruthy();
-    });
-  });
+      it('should handle multiple table creation', async () => {
+        await store.createTable({
+          tableName: testTableName2,
+          schema: {
+            id: { type: 'text', primaryKey: true },
+            data: { type: 'text', nullable: true },
+          },
+        });
 
-  describe('Thread Operations', () => {
-    beforeEach(async () => {
-      await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
-    });
+        // Verify both tables work independently
+        await store.insert({
+          tableName: testTableName2,
+          record: { id: 'test2', data: 'test-data-2' },
+        });
 
-    it('should create and retrieve a thread', async () => {
-      const now = new Date();
-      const thread = {
-        id: 'thread-1',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: now,
-        updatedAt: now,
-        metadata: { key: 'value' },
-      };
-
-      const savedThread = await store.saveThread({ thread });
-      expect(savedThread).toEqual(thread);
-
-      const retrievedThread = await store.getThreadById({ threadId: thread.id });
-      expect(retrievedThread).toEqual({
-        ...thread,
-        createdAt: new Date(now.toISOString()),
-        updatedAt: new Date(now.toISOString()),
+        const result = await store.load({ tableName: testTableName2, keys: { id: 'test2' } });
+        expect(result).toBeTruthy();
       });
     });
 
-    it('should return null for non-existent thread', async () => {
-      const result = await store.getThreadById({ threadId: 'non-existent' });
-      expect(result).toBeNull();
-    });
+    describe('Thread Operations', () => {
+      beforeEach(async () => {
+        await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
+      });
 
-    it('should get threads by resource ID', async () => {
-      const resourceId = 'resource-1';
-      const threads = [
-        {
+      it('should create and retrieve a thread', async () => {
+        const now = new Date();
+        const thread = {
           id: 'thread-1',
-          resourceId,
-          title: 'Thread 1',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-          metadata: {},
-        },
-        {
-          id: 'thread-2',
-          resourceId,
-          title: 'Thread 2',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-          metadata: {},
-        },
-      ];
-
-      await Promise.all(threads.map(thread => store.saveThread({ thread })));
-
-      const retrievedThreads = await store.getThreadsByResourceId({ resourceId });
-      expect(retrievedThreads).toHaveLength(2);
-      expect(retrievedThreads.map(t => t.id)).toEqual(expect.arrayContaining(['thread-1', 'thread-2']));
-    });
-
-    it('should update thread metadata', async () => {
-      const thread = {
-        id: 'thread-1',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: { initial: 'value' },
-      };
-
-      await store.saveThread({ thread });
-
-      const updatedThread = await store.updateThread({
-        id: thread.id,
-        title: 'Updated Title',
-        metadata: { updated: 'value' },
+          resourceId: 'resource-1',
+          title: 'Test Thread',
+          createdAt: now,
+          updatedAt: now,
+          metadata: { key: 'value' },
+        };
+
+        const savedThread = await store.saveThread({ thread });
+        expect(savedThread).toEqual(thread);
+
+        const retrievedThread = await store.getThreadById({ threadId: thread.id });
+        expect(retrievedThread).toEqual({
+          ...thread,
+          createdAt: new Date(now.toISOString()),
+          updatedAt: new Date(now.toISOString()),
+        });
       });
 
-      expect(updatedThread.title).toBe('Updated Title');
-      expect(updatedThread.metadata).toEqual({
-        initial: 'value',
-        updated: 'value',
+      it('should return null for non-existent thread', async () => {
+        const result = await store.getThreadById({ threadId: 'non-existent' });
+        expect(result).toBeNull();
       });
-    });
-  });
 
-  describe('Date Handling', () => {
-    beforeEach(async () => {
-      await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
-    });
+      it('should get threads by resource ID', async () => {
+        const resourceId = 'resource-1';
+        const threads = [
+          {
+            id: 'thread-1',
+            resourceId,
+            title: 'Thread 1',
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            metadata: {},
+          },
+          {
+            id: 'thread-2',
+            resourceId,
+            title: 'Thread 2',
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            metadata: {},
+          },
+        ];
 
-    it('should handle Date objects in thread operations', async () => {
-      const now = new Date();
-      const thread = {
-        id: 'thread-1',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: now,
-        updatedAt: now,
-        metadata: {},
-      };
-
-      await store.saveThread({ thread });
-      const retrievedThread = await store.getThreadById({ threadId: thread.id });
-      expect(retrievedThread?.createdAt).toBeInstanceOf(Date);
-      expect(retrievedThread?.updatedAt).toBeInstanceOf(Date);
-      expect(retrievedThread?.createdAt.toISOString()).toBe(now.toISOString());
-      expect(retrievedThread?.updatedAt.toISOString()).toBe(now.toISOString());
-    });
+        await Promise.all(threads.map(thread => store.saveThread({ thread })));
 
-    it('should handle ISO string dates in thread operations', async () => {
-      const now = new Date();
-      const thread = {
-        id: 'thread-2',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: now.toISOString(),
-        updatedAt: now.toISOString(),
-        metadata: {},
-      };
-
-      await store.saveThread({ thread: thread as any });
-      const retrievedThread = await store.getThreadById({ threadId: thread.id });
-      expect(retrievedThread?.createdAt).toBeInstanceOf(Date);
-      expect(retrievedThread?.updatedAt).toBeInstanceOf(Date);
-      expect(retrievedThread?.createdAt.toISOString()).toBe(now.toISOString());
-      expect(retrievedThread?.updatedAt.toISOString()).toBe(now.toISOString());
-    });
+        const retrievedThreads = await store.getThreadsByResourceId({ resourceId });
+        expect(retrievedThreads).toHaveLength(2);
+        expect(retrievedThreads.map(t => t.id)).toEqual(expect.arrayContaining(['thread-1', 'thread-2']));
+      });
 
-    it('should handle mixed date formats in thread operations', async () => {
-      const now = new Date();
-      const thread = {
-        id: 'thread-3',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: now,
-        updatedAt: now.toISOString(),
-        metadata: {},
-      };
-
-      await store.saveThread({ thread: thread as any });
-      const retrievedThread = await store.getThreadById({ threadId: thread.id });
-      expect(retrievedThread?.createdAt).toBeInstanceOf(Date);
-      expect(retrievedThread?.updatedAt).toBeInstanceOf(Date);
-      expect(retrievedThread?.createdAt.toISOString()).toBe(now.toISOString());
-      expect(retrievedThread?.updatedAt.toISOString()).toBe(now.toISOString());
+      it('should update thread metadata', async () => {
+        const thread = {
+          id: 'thread-1',
+          resourceId: 'resource-1',
+          title: 'Test Thread',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          metadata: { initial: 'value' },
+        };
+
+        await store.saveThread({ thread });
+
+        const updatedThread = await store.updateThread({
+          id: thread.id,
+          title: 'Updated Title',
+          metadata: { updated: 'value' },
+        });
+
+        expect(updatedThread.title).toBe('Updated Title');
+        expect(updatedThread.metadata).toEqual({
+          initial: 'value',
+          updated: 'value',
+        });
+      });
     });
 
-    it('should handle date serialization in getThreadsByResourceId', async () => {
-      const now = new Date();
-      const threads = [
-        {
+    describe('Date Handling', () => {
+      beforeEach(async () => {
+        await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
+      });
+
+      it('should handle Date objects in thread operations', async () => {
+        const now = new Date();
+        const thread = {
           id: 'thread-1',
           resourceId: 'resource-1',
-          title: 'Thread 1',
+          title: 'Test Thread',
           createdAt: now,
-          updatedAt: now.toISOString(),
+          updatedAt: now,
           metadata: {},
-        },
-        {
+        };
+
+        await store.saveThread({ thread });
+        const retrievedThread = await store.getThreadById({ threadId: thread.id });
+        expect(retrievedThread?.createdAt).toBeInstanceOf(Date);
+        expect(retrievedThread?.updatedAt).toBeInstanceOf(Date);
+        expect(retrievedThread?.createdAt.toISOString()).toBe(now.toISOString());
+        expect(retrievedThread?.updatedAt.toISOString()).toBe(now.toISOString());
+      });
+
+      it('should handle ISO string dates in thread operations', async () => {
+        const now = new Date();
+        const thread = {
           id: 'thread-2',
           resourceId: 'resource-1',
-          title: 'Thread 2',
+          title: 'Test Thread',
           createdAt: now.toISOString(),
-          updatedAt: now,
+          updatedAt: now.toISOString(),
           metadata: {},
-        },
-      ];
-
-      await Promise.all(threads.map(thread => store.saveThread({ thread: thread as any })));
-
-      const retrievedThreads = await store.getThreadsByResourceId({ resourceId: 'resource-1' });
-      expect(retrievedThreads).toHaveLength(2);
-      retrievedThreads.forEach(thread => {
-        expect(thread.createdAt).toBeInstanceOf(Date);
-        expect(thread.updatedAt).toBeInstanceOf(Date);
-        expect(thread.createdAt.toISOString()).toBe(now.toISOString());
-        expect(thread.updatedAt.toISOString()).toBe(now.toISOString());
+        };
+
+        await store.saveThread({ thread: thread as any });
+        const retrievedThread = await store.getThreadById({ threadId: thread.id });
+        expect(retrievedThread?.createdAt).toBeInstanceOf(Date);
+        expect(retrievedThread?.updatedAt).toBeInstanceOf(Date);
+        expect(retrievedThread?.createdAt.toISOString()).toBe(now.toISOString());
+        expect(retrievedThread?.updatedAt.toISOString()).toBe(now.toISOString());
       });
-    });
-  });
-
-  describe('Message Operations', () => {
-    const threadId = 'test-thread';
-
-    beforeEach(async () => {
-      await store.clearTable({ tableName: MastraStorage.TABLE_MESSAGES });
-      await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
 
-      // Create a test thread
-      await store.saveThread({
-        thread: {
-          id: threadId,
+      it('should handle mixed date formats in thread operations', async () => {
+        const now = new Date();
+        const thread = {
+          id: 'thread-3',
           resourceId: 'resource-1',
           title: 'Test Thread',
-          createdAt: new Date(),
-          updatedAt: new Date(),
+          createdAt: now,
+          updatedAt: now.toISOString(),
           metadata: {},
-        },
+        };
+
+        await store.saveThread({ thread: thread as any });
+        const retrievedThread = await store.getThreadById({ threadId: thread.id });
+        expect(retrievedThread?.createdAt).toBeInstanceOf(Date);
+        expect(retrievedThread?.updatedAt).toBeInstanceOf(Date);
+        expect(retrievedThread?.createdAt.toISOString()).toBe(now.toISOString());
+        expect(retrievedThread?.updatedAt.toISOString()).toBe(now.toISOString());
       });
-    });
 
-    it('should save and retrieve messages in order', async () => {
-      const messages = [
-        {
-          id: 'msg-1',
-          threadId,
-          role: 'user',
-          type: 'text',
-          content: [{ type: 'text', text: 'First' }],
-          createdAt: new Date().toISOString(),
-        },
-        {
-          id: 'msg-2',
-          threadId,
-          role: 'assistant',
-          type: 'text',
-          content: [{ type: 'text', text: 'Second' }],
-          createdAt: new Date().toISOString(),
-        },
-        {
-          id: 'msg-3',
-          threadId,
-          role: 'user',
-          type: 'text',
-          content: [{ type: 'text', text: 'Third' }],
-          createdAt: new Date().toISOString(),
-        },
-      ];
-
-      await store.saveMessages({ messages });
-
-      const retrievedMessages = await store.getMessages({ threadId });
-      expect(retrievedMessages).toHaveLength(3);
-      expect(retrievedMessages.map(m => m.content[0].text)).toEqual(['First', 'Second', 'Third']);
+      it('should handle date serialization in getThreadsByResourceId', async () => {
+        const now = new Date();
+        const threads = [
+          {
+            id: 'thread-1',
+            resourceId: 'resource-1',
+            title: 'Thread 1',
+            createdAt: now,
+            updatedAt: now.toISOString(),
+            metadata: {},
+          },
+          {
+            id: 'thread-2',
+            resourceId: 'resource-1',
+            title: 'Thread 2',
+            createdAt: now.toISOString(),
+            updatedAt: now,
+            metadata: {},
+          },
+        ];
+
+        await Promise.all(threads.map(thread => store.saveThread({ thread: thread as any })));
+
+        const retrievedThreads = await store.getThreadsByResourceId({ resourceId: 'resource-1' });
+        expect(retrievedThreads).toHaveLength(2);
+        retrievedThreads.forEach(thread => {
+          expect(thread.createdAt).toBeInstanceOf(Date);
+          expect(thread.updatedAt).toBeInstanceOf(Date);
+          expect(thread.createdAt.toISOString()).toBe(now.toISOString());
+          expect(thread.updatedAt.toISOString()).toBe(now.toISOString());
+        });
+      });
     });
 
-    it('should handle empty message array', async () => {
-      const result = await store.saveMessages({ messages: [] });
-      expect(result).toEqual([]);
-    });
+    describe('Message Operations', () => {
+      const threadId = 'test-thread';
+
+      beforeEach(async () => {
+        await store.clearTable({ tableName: MastraStorage.TABLE_MESSAGES });
+        await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
+
+        // Create a test thread
+        await store.saveThread({
+          thread: {
+            id: threadId,
+            resourceId: 'resource-1',
+            title: 'Test Thread',
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            metadata: {},
+          },
+        });
+      });
 
-    it('should handle messages with complex content', async () => {
-      const messages = [
-        {
-          id: 'msg-1',
-          threadId,
-          role: 'user',
-          type: 'text',
-          content: [
-            { type: 'text', text: 'Message with' },
-            { type: 'code', text: 'code block', language: 'typescript' },
-            { type: 'text', text: 'and more text' },
-          ],
-          createdAt: new Date().toISOString(),
-        },
-      ];
-
-      await store.saveMessages({ messages });
-
-      const retrievedMessages = await store.getMessages({ threadId });
-      expect(retrievedMessages[0].content).toEqual(messages[0].content);
-    });
-  });
+      it('should save and retrieve messages in order', async () => {
+        const messages = [
+          {
+            id: 'msg-1',
+            threadId,
+            role: 'user',
+            type: 'text',
+            content: [{ type: 'text', text: 'First' }],
+            createdAt: new Date().toISOString(),
+          },
+          {
+            id: 'msg-2',
+            threadId,
+            role: 'assistant',
+            type: 'text',
+            content: [{ type: 'text', text: 'Second' }],
+            createdAt: new Date().toISOString(),
+          },
+          {
+            id: 'msg-3',
+            threadId,
+            role: 'user',
+            type: 'text',
+            content: [{ type: 'text', text: 'Third' }],
+            createdAt: new Date().toISOString(),
+          },
+        ];
 
-  describe('Workflow Operations', () => {
-    const testNamespace = 'test';
-    const testWorkflow = 'test-workflow';
-    const testRunId = 'test-run';
+        await store.saveMessages({ messages });
 
-    beforeEach(async () => {
-      await store.clearTable({ tableName: MastraStorage.TABLE_WORKFLOW_SNAPSHOT });
-    });
+        const retrievedMessages = await store.getMessages({ threadId });
+        expect(retrievedMessages).toHaveLength(3);
+        expect(retrievedMessages.map(m => m.content[0].text)).toEqual(['First', 'Second', 'Third']);
+      });
+
+      it('should handle empty message array', async () => {
+        const result = await store.saveMessages({ messages: [] });
+        expect(result).toEqual([]);
+      });
 
-    it('should persist and load workflow snapshots', async () => {
-      const mockSnapshot = {
-        value: { step1: 'completed' },
-        context: {
-          stepResults: {
-            step1: { status: 'success', payload: { result: 'done' } },
+      it('should handle messages with complex content', async () => {
+        const messages = [
+          {
+            id: 'msg-1',
+            threadId,
+            role: 'user',
+            type: 'text',
+            content: [
+              { type: 'text', text: 'Message with' },
+              { type: 'code', text: 'code block', language: 'typescript' },
+              { type: 'text', text: 'and more text' },
+            ],
+            createdAt: new Date().toISOString(),
           },
-          attempts: {},
-          triggerData: {},
-        },
-        runId: testRunId,
-        activePaths: [],
-        timestamp: Date.now(),
-      };
-
-      await store.persistWorkflowSnapshot({
-        namespace: testNamespace,
-        workflowName: testWorkflow,
-        runId: testRunId,
-        snapshot: mockSnapshot,
+        ];
+
+        await store.saveMessages({ messages });
+
+        const retrievedMessages = await store.getMessages({ threadId });
+        expect(retrievedMessages[0].content).toEqual(messages[0].content);
       });
+    });
+
+    describe('Workflow Operations', () => {
+      const testNamespace = 'test';
+      const testWorkflow = 'test-workflow';
+      const testRunId = 'test-run';
 
-      const loadedSnapshot = await store.loadWorkflowSnapshot({
-        namespace: testNamespace,
-        workflowName: testWorkflow,
-        runId: testRunId,
+      beforeEach(async () => {
+        await store.clearTable({ tableName: MastraStorage.TABLE_WORKFLOW_SNAPSHOT });
       });
 
-      expect(loadedSnapshot).toEqual(mockSnapshot);
-    });
+      it('should persist and load workflow snapshots', async () => {
+        const mockSnapshot = {
+          value: { step1: 'completed' },
+          context: {
+            stepResults: {
+              step1: { status: 'success', payload: { result: 'done' } },
+            },
+            attempts: {},
+            triggerData: {},
+          },
+          runId: testRunId,
+          activePaths: [],
+          timestamp: Date.now(),
+        };
+
+        await store.persistWorkflowSnapshot({
+          namespace: testNamespace,
+          workflowName: testWorkflow,
+          runId: testRunId,
+          snapshot: mockSnapshot,
+        });
+
+        const loadedSnapshot = await store.loadWorkflowSnapshot({
+          namespace: testNamespace,
+          workflowName: testWorkflow,
+          runId: testRunId,
+        });
+
+        expect(loadedSnapshot).toEqual(mockSnapshot);
+      });
 
-    it('should return null for non-existent snapshot', async () => {
-      const result = await store.loadWorkflowSnapshot({
-        namespace: testNamespace,
-        workflowName: 'non-existent',
-        runId: 'non-existent',
+      it('should return null for non-existent snapshot', async () => {
+        const result = await store.loadWorkflowSnapshot({
+          namespace: testNamespace,
+          workflowName: 'non-existent',
+          runId: 'non-existent',
+        });
+        expect(result).toBeNull();
       });
-      expect(result).toBeNull();
     });
-  });
-});
+  },
+  {
+    timeout: 30000,
+  },
+);

package/src/vector/filter.ts

@@ -1,4 +1,5 @@
-import { BaseFilterTranslator, type Filter, type FieldCondition, type OperatorSupport } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/filter';
+import type { Filter, FieldCondition, OperatorSupport } from '@mastra/core/filter';
 
 export class UpstashFilterTranslator extends BaseFilterTranslator {
   protected override getSupportedOperators(): OperatorSupport {

package/src/vector/index.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeAll, afterAll, beforeEach, test } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 
 import { UpstashVector } from './';