@mastra/pg 0.10.1 → 0.10.2-alpha.1

package/src/storage/index.test.ts

@@ -1,7 +1,22 @@
 import { randomUUID } from 'crypto';
-import type { MetricResult } from '@mastra/core/eval';
-import type { MastraMessageV1 } from '@mastra/core/memory';
-import { TABLE_WORKFLOW_SNAPSHOT, TABLE_MESSAGES, TABLE_THREADS, TABLE_EVALS } from '@mastra/core/storage';
+import {
+  createSampleEval,
+  createSampleTraceForDB,
+  createSampleThread,
+  createSampleMessageV1,
+  createSampleMessageV2,
+  createSampleWorkflowSnapshot,
+  resetRole,
+} from '@internal/storage-test-utils';
+import type { MastraMessageV1, StorageThreadType } from '@mastra/core/memory';
+import type { StorageColumn, TABLE_NAMES } from '@mastra/core/storage';
+import {
+  TABLE_WORKFLOW_SNAPSHOT,
+  TABLE_MESSAGES,
+  TABLE_THREADS,
+  TABLE_EVALS,
+  TABLE_TRACES,
+} from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 import pgPromise from 'pg-promise';
 import { describe, it, expect, beforeAll, beforeEach, afterAll, afterEach, vi } from 'vitest';
@@ -21,76 +36,6 @@ const connectionString = `postgresql://${TEST_CONFIG.user}:${TEST_CONFIG.passwor
 
 vi.setConfig({ testTimeout: 60_000, hookTimeout: 60_000 });
 
-// Sample test data factory functions
-const createSampleThread = () => ({
-  id: `thread-${randomUUID()}`,
-  resourceId: `resource-${randomUUID()}`,
-  title: 'Test Thread',
-  createdAt: new Date(),
-  updatedAt: new Date(),
-  metadata: { key: 'value' },
-});
-
-let role: 'user' | 'assistant' = 'assistant';
-const getRole = () => {
-  if (role === `user`) role = `assistant`;
-  else role = `user`;
-  return role;
-};
-const createSampleMessage = (threadId: string): MastraMessageV1 => ({
-  id: `msg-${randomUUID()}`,
-  resourceId: `resource-${randomUUID()}`,
-  role: getRole(),
-  type: 'text',
-  threadId,
-  content: [{ type: 'text', text: 'Hello' }],
-  createdAt: new Date(),
-});
-
-const createSampleWorkflowSnapshot = (status: WorkflowRunState['context'][string]['status'], createdAt?: Date) => {
-  const runId = `run-${randomUUID()}`;
-  const stepId = `step-${randomUUID()}`;
-  const timestamp = createdAt || new Date();
-  const snapshot = {
-    result: { success: true },
-    value: {},
-    context: {
-      [stepId]: {
-        status,
-        payload: {},
-        error: undefined,
-        startedAt: timestamp.getTime(),
-        endedAt: new Date(timestamp.getTime() + 15000).getTime(),
-      },
-      input: {},
-    },
-    serializedStepGraph: [],
-    activePaths: [],
-    suspendedPaths: {},
-    runId,
-    timestamp: timestamp.getTime(),
-  } as unknown as WorkflowRunState;
-  return { snapshot, runId, stepId };
-};
-
-const createSampleEval = (agentName: string, isTest = false) => {
-  const testInfo = isTest ? { testPath: 'test/path.ts', testName: 'Test Name' } : undefined;
-
-  return {
-    id: randomUUID(),
-    agentName,
-    input: 'Sample input',
-    output: 'Sample output',
-    result: { score: 0.8 } as MetricResult,
-    metricName: 'sample-metric',
-    instructions: 'Sample instructions',
-    testInfo,
-    globalRunId: `global-${randomUUID()}`,
-    runId: `run-${randomUUID()}`,
-    createdAt: new Date().toISOString(),
-  };
-};
-
 const checkWorkflowSnapshot = (snapshot: WorkflowRunState | string, stepId: string, status: string) => {
   if (typeof snapshot === 'string') {
     throw new Error('Expected WorkflowRunState, got string');
@@ -114,6 +59,7 @@ describe('PostgresStore', () => {
       await store.clearTable({ tableName: TABLE_MESSAGES });
       await store.clearTable({ tableName: TABLE_THREADS });
       await store.clearTable({ tableName: TABLE_EVALS });
+      await store.clearTable({ tableName: TABLE_TRACES });
     } catch (error) {
       // Ignore errors during table clearing
       console.warn('Error clearing tables:', error);
@@ -221,7 +167,7 @@ describe('PostgresStore', () => {
       await store.saveThread({ thread });
 
       // Add some messages
-      const messages = [createSampleMessage(thread.id), createSampleMessage(thread.id)];
+      const messages = [createSampleMessageV1({ threadId: thread.id }), createSampleMessageV1({ threadId: thread.id })];
       await store.saveMessages({ messages });
 
       await store.deleteThread({ threadId: thread.id });
@@ -240,14 +186,14 @@ describe('PostgresStore', () => {
       const thread = createSampleThread();
       await store.saveThread({ thread });
 
-      const messages = [createSampleMessage(thread.id), createSampleMessage(thread.id)];
+      const messages = [createSampleMessageV1({ threadId: thread.id }), createSampleMessageV1({ threadId: thread.id })];
 
       // Save messages
       const savedMessages = await store.saveMessages({ messages });
       expect(savedMessages).toEqual(messages);
 
       // Retrieve messages
-      const retrievedMessages = await store.getMessages({ threadId: thread.id });
+      const retrievedMessages = await store.getMessages({ threadId: thread.id, format: 'v1' });
       expect(retrievedMessages).toHaveLength(2);
       const checkMessages = messages.map(m => {
         const { resourceId, ...rest } = m;
@@ -265,24 +211,18 @@ describe('PostgresStore', () => {
       const thread = createSampleThread();
       await store.saveThread({ thread });
 
-      const messages = [
-        { ...createSampleMessage(thread.id), content: [{ type: 'text', text: 'First' }] },
-        {
-          ...createSampleMessage(thread.id),
-          content: [{ type: 'text', text: 'Second' }],
-        },
-        { ...createSampleMessage(thread.id), content: [{ type: 'text', text: 'Third' }] },
-      ] satisfies MastraMessageV1[];
+      const messageContent = ['First', 'Second', 'Third'];
 
-      await store.saveMessages({ messages });
+      const messages = messageContent.map(content => createSampleMessageV2({ threadId: thread.id, content }));
+
+      await store.saveMessages({ messages, format: 'v2' });
 
-      const retrievedMessages = await store.getMessages<MastraMessageV1>({ threadId: thread.id });
+      const retrievedMessages = await store.getMessages({ threadId: thread.id, format: 'v2' });
       expect(retrievedMessages).toHaveLength(3);
 
       // Verify order is maintained
       retrievedMessages.forEach((msg, idx) => {
-        // @ts-expect-error
-        expect(msg.content[0].text).toBe(messages[idx].content[0].text);
+        expect((msg.content.parts[0] as any).text).toEqual(messageContent[idx]);
       });
     });
 
@@ -291,8 +231,8 @@ describe('PostgresStore', () => {
       await store.saveThread({ thread });
 
       const messages = [
-        createSampleMessage(thread.id),
-        { ...createSampleMessage(thread.id), id: null } as any, // This will cause an error
+        createSampleMessageV1({ threadId: thread.id }),
+        { ...createSampleMessageV1({ threadId: thread.id }), id: null } as any, // This will cause an error
       ];
 
       await expect(store.saveMessages({ messages })).rejects.toThrow();
@@ -752,78 +692,76 @@ describe('PostgresStore', () => {
     it('should retrieve evals by agent name', async () => {
       const agentName = `test-agent-${randomUUID()}`;
 
-      // Create sample evals
-      const liveEval = createSampleEval(agentName, false);
+      // Create sample evals using the imported helper
+      const liveEval = createSampleEval(agentName, false); // createSampleEval returns snake_case
       const testEval = createSampleEval(agentName, true);
       const otherAgentEval = createSampleEval(`other-agent-${randomUUID()}`, false);
 
-      // Insert evals
+      // Insert evals - ensure DB columns are snake_case
       await store.insert({
         tableName: TABLE_EVALS,
         record: {
-          agent_name: liveEval.agentName,
+          agent_name: liveEval.agent_name, // Use snake_case
           input: liveEval.input,
           output: liveEval.output,
           result: liveEval.result,
-          metric_name: liveEval.metricName,
+          metric_name: liveEval.metric_name, // Use snake_case
           instructions: liveEval.instructions,
-          test_info: null,
-          global_run_id: liveEval.globalRunId,
-          run_id: liveEval.runId,
-          created_at: liveEval.createdAt,
-          createdAt: new Date(liveEval.createdAt),
+          test_info: liveEval.test_info, // test_info from helper can be undefined or object
+          global_run_id: liveEval.global_run_id, // Use snake_case
+          run_id: liveEval.run_id, // Use snake_case
+          created_at: new Date(liveEval.created_at as string), // created_at from helper is string or Date
         },
       });
 
       await store.insert({
         tableName: TABLE_EVALS,
         record: {
-          agent_name: testEval.agentName,
+          agent_name: testEval.agent_name,
           input: testEval.input,
           output: testEval.output,
           result: testEval.result,
-          metric_name: testEval.metricName,
+          metric_name: testEval.metric_name,
           instructions: testEval.instructions,
-          test_info: JSON.stringify(testEval.testInfo),
-          global_run_id: testEval.globalRunId,
-          run_id: testEval.runId,
-          created_at: testEval.createdAt,
-          createdAt: new Date(testEval.createdAt),
+          test_info: testEval.test_info ? JSON.stringify(testEval.test_info) : null,
+          global_run_id: testEval.global_run_id,
+          run_id: testEval.run_id,
+          created_at: new Date(testEval.created_at as string),
         },
       });
 
       await store.insert({
         tableName: TABLE_EVALS,
         record: {
-          agent_name: otherAgentEval.agentName,
+          agent_name: otherAgentEval.agent_name,
           input: otherAgentEval.input,
           output: otherAgentEval.output,
           result: otherAgentEval.result,
-          metric_name: otherAgentEval.metricName,
+          metric_name: otherAgentEval.metric_name,
           instructions: otherAgentEval.instructions,
-          test_info: null,
-          global_run_id: otherAgentEval.globalRunId,
-          run_id: otherAgentEval.runId,
-          created_at: otherAgentEval.createdAt,
-          createdAt: new Date(otherAgentEval.createdAt),
+          test_info: otherAgentEval.test_info, // Can be null/undefined directly
+          global_run_id: otherAgentEval.global_run_id,
+          run_id: otherAgentEval.run_id,
+          created_at: new Date(otherAgentEval.created_at as string),
         },
       });
 
       // Test getting all evals for the agent
       const allEvals = await store.getEvalsByAgentName(agentName);
       expect(allEvals).toHaveLength(2);
-      expect(allEvals.map(e => e.runId)).toEqual(expect.arrayContaining([liveEval.runId, testEval.runId]));
+      // EvalRow type expects camelCase, but PostgresStore.transformEvalRow converts snake_case from DB to camelCase
+      expect(allEvals.map(e => e.runId)).toEqual(expect.arrayContaining([liveEval.run_id, testEval.run_id]));
 
       // Test getting only live evals
       const liveEvals = await store.getEvalsByAgentName(agentName, 'live');
       expect(liveEvals).toHaveLength(1);
-      expect(liveEvals[0].runId).toBe(liveEval.runId);
+      expect(liveEvals[0].runId).toBe(liveEval.run_id); // Comparing with snake_case run_id from original data
 
       // Test getting only test evals
-      const testEvals = await store.getEvalsByAgentName(agentName, 'test');
-      expect(testEvals).toHaveLength(1);
-      expect(testEvals[0].runId).toBe(testEval.runId);
-      expect(testEvals[0].testInfo).toEqual(testEval.testInfo);
+      const testEvalsResult = await store.getEvalsByAgentName(agentName, 'test');
+      expect(testEvalsResult).toHaveLength(1);
+      expect(testEvalsResult[0].runId).toBe(testEval.run_id);
+      expect(testEvalsResult[0].testInfo).toEqual(testEval.test_info);
 
       // Test getting evals for non-existent agent
       const nonExistentEvals = await store.getEvalsByAgentName('non-existent-agent');
@@ -863,6 +801,96 @@ describe('PostgresStore', () => {
     });
   });
 
+  describe('alterTable', () => {
+    const TEST_TABLE = 'test_alter_table';
+    const BASE_SCHEMA = {
+      id: { type: 'integer', primaryKey: true, nullable: false },
+      name: { type: 'text', nullable: true },
+    } as Record<string, StorageColumn>;
+
+    beforeEach(async () => {
+      await store.createTable({ tableName: TEST_TABLE as TABLE_NAMES, schema: BASE_SCHEMA });
+    });
+
+    afterEach(async () => {
+      await store.clearTable({ tableName: TEST_TABLE as TABLE_NAMES });
+    });
+
+    it('adds a new column to an existing table', async () => {
+      await store.alterTable({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        schema: { ...BASE_SCHEMA, age: { type: 'integer', nullable: true } },
+        ifNotExists: ['age'],
+      });
+
+      await store.insert({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        record: { id: 1, name: 'Alice', age: 42 },
+      });
+
+      const row = await store.load<{ id: string; name: string; age?: number }>({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        keys: { id: '1' },
+      });
+      expect(row?.age).toBe(42);
+    });
+
+    it('is idempotent when adding an existing column', async () => {
+      await store.alterTable({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        schema: { ...BASE_SCHEMA, foo: { type: 'text', nullable: true } },
+        ifNotExists: ['foo'],
+      });
+      // Add the column again (should not throw)
+      await expect(
+        store.alterTable({
+          tableName: TEST_TABLE as TABLE_NAMES,
+          schema: { ...BASE_SCHEMA, foo: { type: 'text', nullable: true } },
+          ifNotExists: ['foo'],
+        }),
+      ).resolves.not.toThrow();
+    });
+
+    it('should add a default value to a column when using not null', async () => {
+      await store.insert({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        record: { id: 1, name: 'Bob' },
+      });
+
+      await expect(
+        store.alterTable({
+          tableName: TEST_TABLE as TABLE_NAMES,
+          schema: { ...BASE_SCHEMA, text_column: { type: 'text', nullable: false } },
+          ifNotExists: ['text_column'],
+        }),
+      ).resolves.not.toThrow();
+
+      await expect(
+        store.alterTable({
+          tableName: TEST_TABLE as TABLE_NAMES,
+          schema: { ...BASE_SCHEMA, timestamp_column: { type: 'timestamp', nullable: false } },
+          ifNotExists: ['timestamp_column'],
+        }),
+      ).resolves.not.toThrow();
+
+      await expect(
+        store.alterTable({
+          tableName: TEST_TABLE as TABLE_NAMES,
+          schema: { ...BASE_SCHEMA, bigint_column: { type: 'bigint', nullable: false } },
+          ifNotExists: ['bigint_column'],
+        }),
+      ).resolves.not.toThrow();
+
+      await expect(
+        store.alterTable({
+          tableName: TEST_TABLE as TABLE_NAMES,
+          schema: { ...BASE_SCHEMA, jsonb_column: { type: 'jsonb', nullable: false } },
+          ifNotExists: ['jsonb_column'],
+        }),
+      ).resolves.not.toThrow();
+    });
+  });
+
   describe('Schema Support', () => {
     const customSchema = 'mastra_test';
     let customSchemaStore: PostgresStore;
@@ -931,6 +959,416 @@ describe('PostgresStore', () => {
     });
   });
 
+  describe('Pagination Features', () => {
+    beforeEach(async () => {
+      await store.clearTable({ tableName: TABLE_EVALS });
+      await store.clearTable({ tableName: TABLE_TRACES });
+      await store.clearTable({ tableName: TABLE_MESSAGES });
+      await store.clearTable({ tableName: TABLE_THREADS });
+    });
+
+    describe('getEvals with pagination', () => {
+      it('should return paginated evals with total count (page/perPage)', async () => {
+        const agentName = 'pagination-agent-evals';
+        const evalPromises = Array.from({ length: 25 }, (_, i) => {
+          const evalData = createSampleEval(agentName, i % 2 === 0);
+          return store.insert({
+            tableName: TABLE_EVALS,
+            record: {
+              run_id: evalData.run_id,
+              agent_name: evalData.agent_name,
+              input: evalData.input,
+              output: evalData.output,
+              result: evalData.result,
+              metric_name: evalData.metric_name,
+              instructions: evalData.instructions,
+              test_info: evalData.test_info,
+              global_run_id: evalData.global_run_id,
+              created_at: new Date(evalData.created_at as string),
+            },
+          });
+        });
+        await Promise.all(evalPromises);
+
+        const page1 = await store.getEvals({ agentName, page: 0, perPage: 10 });
+        expect(page1.evals).toHaveLength(10);
+        expect(page1.total).toBe(25);
+        expect(page1.page).toBe(0);
+        expect(page1.perPage).toBe(10);
+        expect(page1.hasMore).toBe(true);
+
+        const page3 = await store.getEvals({ agentName, page: 2, perPage: 10 });
+        expect(page3.evals).toHaveLength(5);
+        expect(page3.total).toBe(25);
+        expect(page3.page).toBe(2);
+        expect(page3.hasMore).toBe(false);
+      });
+
+      it('should support limit/offset pagination for getEvals', async () => {
+        const agentName = 'pagination-agent-lo-evals';
+        const evalPromises = Array.from({ length: 15 }, () => {
+          const evalData = createSampleEval(agentName);
+          return store.insert({
+            tableName: TABLE_EVALS,
+            record: {
+              run_id: evalData.run_id,
+              agent_name: evalData.agent_name,
+              input: evalData.input,
+              output: evalData.output,
+              result: evalData.result,
+              metric_name: evalData.metric_name,
+              instructions: evalData.instructions,
+              test_info: evalData.test_info,
+              global_run_id: evalData.global_run_id,
+              created_at: new Date(evalData.created_at as string),
+            },
+          });
+        });
+        await Promise.all(evalPromises);
+
+        const result = await store.getEvals({ agentName, perPage: 5, page: 2 });
+        expect(result.evals).toHaveLength(5);
+        expect(result.total).toBe(15);
+        expect(result.page).toBe(2);
+        expect(result.perPage).toBe(5);
+        expect(result.hasMore).toBe(false);
+      });
+
+      it('should filter by type with pagination for getEvals', async () => {
+        const agentName = 'pagination-agent-type-evals';
+        const testEvalPromises = Array.from({ length: 10 }, () => {
+          const evalData = createSampleEval(agentName, true);
+          return store.insert({
+            tableName: TABLE_EVALS,
+            record: {
+              run_id: evalData.run_id,
+              agent_name: evalData.agent_name,
+              input: evalData.input,
+              output: evalData.output,
+              result: evalData.result,
+              metric_name: evalData.metric_name,
+              instructions: evalData.instructions,
+              test_info: evalData.test_info,
+              global_run_id: evalData.global_run_id,
+              created_at: new Date(evalData.created_at as string),
+            },
+          });
+        });
+        const liveEvalPromises = Array.from({ length: 8 }, () => {
+          const evalData = createSampleEval(agentName, false);
+          return store.insert({
+            tableName: TABLE_EVALS,
+            record: {
+              run_id: evalData.run_id,
+              agent_name: evalData.agent_name,
+              input: evalData.input,
+              output: evalData.output,
+              result: evalData.result,
+              metric_name: evalData.metric_name,
+              instructions: evalData.instructions,
+              test_info: evalData.test_info,
+              global_run_id: evalData.global_run_id,
+              created_at: new Date(evalData.created_at as string),
+            },
+          });
+        });
+        await Promise.all([...testEvalPromises, ...liveEvalPromises]);
+
+        const testResults = await store.getEvals({ agentName, type: 'test', page: 0, perPage: 5 });
+        expect(testResults.evals).toHaveLength(5);
+        expect(testResults.total).toBe(10);
+
+        const liveResults = await store.getEvals({ agentName, type: 'live', page: 1, perPage: 3 });
+        expect(liveResults.evals).toHaveLength(3);
+        expect(liveResults.total).toBe(8);
+        expect(liveResults.hasMore).toBe(true);
+      });
+
+      it('should filter by date with pagination for getEvals', async () => {
+        const agentName = 'pagination-agent-date-evals';
+        const now = new Date();
+        const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+        const dayBeforeYesterday = new Date(now.getTime() - 48 * 60 * 60 * 1000);
+
+        const createEvalAtDate = (date: Date) => {
+          const evalData = createSampleEval(agentName, false, date); // Pass date to helper
+          return store.insert({
+            tableName: TABLE_EVALS,
+            record: {
+              run_id: evalData.run_id, // Use snake_case from helper
+              agent_name: evalData.agent_name,
+              input: evalData.input,
+              output: evalData.output,
+              result: evalData.result,
+              metric_name: evalData.metric_name,
+              instructions: evalData.instructions,
+              test_info: evalData.test_info,
+              global_run_id: evalData.global_run_id,
+              created_at: evalData.created_at, // Use created_at from helper (already Date or ISO string)
+            },
+          });
+        };
+
+        await Promise.all([
+          createEvalAtDate(dayBeforeYesterday),
+          createEvalAtDate(dayBeforeYesterday),
+          createEvalAtDate(yesterday),
+          createEvalAtDate(yesterday),
+          createEvalAtDate(yesterday),
+          createEvalAtDate(now),
+          createEvalAtDate(now),
+          createEvalAtDate(now),
+          createEvalAtDate(now),
+        ]);
+
+        const fromYesterday = await store.getEvals({ agentName, dateRange: { start: yesterday }, page: 0, perPage: 3 });
+        expect(fromYesterday.total).toBe(7); // 3 yesterday + 4 now
+        expect(fromYesterday.evals).toHaveLength(3);
+        // Evals are sorted DESC, so first 3 are from 'now'
+        fromYesterday.evals.forEach(e =>
+          expect(new Date(e.createdAt).getTime()).toBeGreaterThanOrEqual(yesterday.getTime()),
+        );
+
+        const onlyDayBefore = await store.getEvals({
+          agentName,
+          dateRange: {
+            end: new Date(yesterday.getTime() - 1),
+          },
+          page: 0,
+          perPage: 5,
+        });
+        expect(onlyDayBefore.total).toBe(2);
+        expect(onlyDayBefore.evals).toHaveLength(2);
+      });
+    });
+
+    describe('getTraces with pagination', () => {
+      it('should return paginated traces with total count', async () => {
+        const tracePromises = Array.from({ length: 18 }, (_, i) =>
+          store.insert({ tableName: TABLE_TRACES, record: createSampleTraceForDB(`test-trace-${i}`, 'pg-test-scope') }),
+        );
+        await Promise.all(tracePromises);
+
+        const page1 = await store.getTracesPaginated({
+          scope: 'pg-test-scope',
+          page: 0,
+          perPage: 8,
+        });
+        expect(page1.traces).toHaveLength(8);
+        expect(page1.total).toBe(18);
+        expect(page1.page).toBe(0);
+        expect(page1.perPage).toBe(8);
+        expect(page1.hasMore).toBe(true);
+
+        const page3 = await store.getTracesPaginated({
+          scope: 'pg-test-scope',
+          page: 2,
+          perPage: 8,
+        });
+        expect(page3.traces).toHaveLength(2);
+        expect(page3.total).toBe(18);
+        expect(page3.hasMore).toBe(false);
+      });
+
+      it('should filter by attributes with pagination for getTraces', async () => {
+        const tracesWithAttr = Array.from({ length: 8 }, (_, i) =>
+          store.insert({
+            tableName: TABLE_TRACES,
+            record: createSampleTraceForDB(`trace-${i}`, 'pg-attr-scope', { environment: 'prod' }),
+          }),
+        );
+        const tracesWithoutAttr = Array.from({ length: 5 }, (_, i) =>
+          store.insert({
+            tableName: TABLE_TRACES,
+            record: createSampleTraceForDB(`trace-other-${i}`, 'pg-attr-scope', { environment: 'dev' }),
+          }),
+        );
+        await Promise.all([...tracesWithAttr, ...tracesWithoutAttr]);
+
+        const prodTraces = await store.getTracesPaginated({
+          scope: 'pg-attr-scope',
+          attributes: { environment: 'prod' },
+          page: 0,
+          perPage: 5,
+        });
+        expect(prodTraces.traces).toHaveLength(5);
+        expect(prodTraces.total).toBe(8);
+        expect(prodTraces.hasMore).toBe(true);
+      });
+
+      it('should filter by date with pagination for getTraces', async () => {
+        const scope = 'pg-date-traces';
+        const now = new Date();
+        const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+        const dayBeforeYesterday = new Date(now.getTime() - 48 * 60 * 60 * 1000);
+
+        await Promise.all([
+          store.insert({
+            tableName: TABLE_TRACES,
+            record: createSampleTraceForDB('t1', scope, undefined, dayBeforeYesterday),
+          }),
+          store.insert({ tableName: TABLE_TRACES, record: createSampleTraceForDB('t2', scope, undefined, yesterday) }),
+          store.insert({ tableName: TABLE_TRACES, record: createSampleTraceForDB('t3', scope, undefined, yesterday) }),
+          store.insert({ tableName: TABLE_TRACES, record: createSampleTraceForDB('t4', scope, undefined, now) }),
+          store.insert({ tableName: TABLE_TRACES, record: createSampleTraceForDB('t5', scope, undefined, now) }),
+        ]);
+
+        const fromYesterday = await store.getTracesPaginated({
+          scope,
+          dateRange: {
+            start: yesterday,
+          },
+          page: 0,
+          perPage: 2,
+        });
+        expect(fromYesterday.total).toBe(4); // 2 yesterday + 2 now
+        expect(fromYesterday.traces).toHaveLength(2);
+        fromYesterday.traces.forEach(t =>
+          expect(new Date(t.createdAt).getTime()).toBeGreaterThanOrEqual(yesterday.getTime()),
+        );
+
+        const onlyNow = await store.getTracesPaginated({
+          scope,
+          dateRange: {
+            start: now,
+            end: now,
+          },
+          page: 0,
+          perPage: 5,
+        });
+        expect(onlyNow.total).toBe(2);
+        expect(onlyNow.traces).toHaveLength(2);
+      });
+    });
+
+    describe('getMessages with pagination', () => {
+      it('should return paginated messages with total count', async () => {
+        const thread = createSampleThread();
+        await store.saveThread({ thread });
+        // Reset role to 'assistant' before creating messages
+        resetRole();
+        // Create messages sequentially to ensure unique timestamps
+        for (let i = 0; i < 15; i++) {
+          const message = createSampleMessageV1({ threadId: thread.id, content: `Message ${i + 1}` });
+          await store.saveMessages({
+            messages: [message],
+          });
+          await new Promise(r => setTimeout(r, 5));
+        }
+
+        const page1 = await store.getMessagesPaginated({
+          threadId: thread.id,
+          selectBy: { pagination: { page: 0, perPage: 5 } },
+          format: 'v2',
+        });
+        console.log(page1);
+        expect(page1.messages).toHaveLength(5);
+        expect(page1.total).toBe(15);
+        expect(page1.page).toBe(0);
+        expect(page1.perPage).toBe(5);
+        expect(page1.hasMore).toBe(true);
+
+        const page3 = await store.getMessagesPaginated({
+          threadId: thread.id,
+          selectBy: { pagination: { page: 2, perPage: 5 } },
+          format: 'v2',
+        });
+        expect(page3.messages).toHaveLength(5);
+        expect(page3.total).toBe(15);
+        expect(page3.hasMore).toBe(false);
+      });
+
+      it('should filter by date with pagination for getMessages', async () => {
+        const threadData = createSampleThread();
+        const thread = await store.saveThread({ thread: threadData as StorageThreadType });
+        const now = new Date();
+        const yesterday = new Date(
+          now.getFullYear(),
+          now.getMonth(),
+          now.getDate() - 1,
+          now.getHours(),
+          now.getMinutes(),
+          now.getSeconds(),
+        );
+        const dayBeforeYesterday = new Date(
+          now.getFullYear(),
+          now.getMonth(),
+          now.getDate() - 2,
+          now.getHours(),
+          now.getMinutes(),
+          now.getSeconds(),
+        );
+
+        // Ensure timestamps are distinct for reliable sorting by creating them with a slight delay for testing clarity
+        const messagesToSave: MastraMessageV1[] = [];
+        messagesToSave.push(createSampleMessageV1({ threadId: thread.id, createdAt: dayBeforeYesterday }));
+        await new Promise(r => setTimeout(r, 5));
+        messagesToSave.push(createSampleMessageV1({ threadId: thread.id, createdAt: dayBeforeYesterday }));
+        await new Promise(r => setTimeout(r, 5));
+        messagesToSave.push(createSampleMessageV1({ threadId: thread.id, createdAt: yesterday }));
+        await new Promise(r => setTimeout(r, 5));
+        messagesToSave.push(createSampleMessageV1({ threadId: thread.id, createdAt: yesterday }));
+        await new Promise(r => setTimeout(r, 5));
+        messagesToSave.push(createSampleMessageV1({ threadId: thread.id, createdAt: now }));
+        await new Promise(r => setTimeout(r, 5));
+        messagesToSave.push(createSampleMessageV1({ threadId: thread.id, createdAt: now }));
+
+        await store.saveMessages({ messages: messagesToSave, format: 'v1' });
+        // Total 6 messages: 2 now, 2 yesterday, 2 dayBeforeYesterday (oldest to newest)
+
+        const fromYesterday = await store.getMessagesPaginated({
+          threadId: thread.id,
+          selectBy: { pagination: { page: 0, perPage: 3, dateRange: { start: yesterday } } },
+          format: 'v2',
+        });
+        expect(fromYesterday.total).toBe(4);
+        expect(fromYesterday.messages).toHaveLength(3);
+        const firstMessageTime = new Date((fromYesterday.messages[0] as MastraMessageV1).createdAt).getTime();
+        expect(firstMessageTime).toBeGreaterThanOrEqual(new Date(yesterday.toISOString()).getTime());
+        if (fromYesterday.messages.length > 0) {
+          expect(new Date((fromYesterday.messages[0] as MastraMessageV1).createdAt).toISOString().slice(0, 10)).toEqual(
+            yesterday.toISOString().slice(0, 10),
+          );
+        }
+      });
+    });
+
+    describe('getThreadsByResourceId with pagination', () => {
+      it('should return paginated threads with total count', async () => {
+        const resourceId = `pg-paginated-resource-${randomUUID()}`;
+        const threadPromises = Array.from({ length: 17 }, () =>
+          store.saveThread({ thread: { ...createSampleThread(), resourceId } }),
+        );
+        await Promise.all(threadPromises);
+
+        const page1 = await store.getThreadsByResourceIdPaginated({ resourceId, page: 0, perPage: 7 });
+        expect(page1.threads).toHaveLength(7);
+        expect(page1.total).toBe(17);
+        expect(page1.page).toBe(0);
+        expect(page1.perPage).toBe(7);
+        expect(page1.hasMore).toBe(true);
+
+        const page3 = await store.getThreadsByResourceIdPaginated({ resourceId, page: 2, perPage: 7 });
+        expect(page3.threads).toHaveLength(3); // 17 total, 7 per page, 3rd page has 17 - 2*7 = 3
+        expect(page3.total).toBe(17);
+        expect(page3.hasMore).toBe(false);
+      });
+
+      it('should return paginated results when no pagination params for getThreadsByResourceId', async () => {
+        const resourceId = `pg-non-paginated-resource-${randomUUID()}`;
+        await store.saveThread({ thread: { ...createSampleThread(), resourceId } });
+
+        const results = await store.getThreadsByResourceIdPaginated({ resourceId });
+        expect(Array.isArray(results.threads)).toBe(true);
+        expect(results.threads.length).toBe(1);
+        expect(results.total).toBe(1);
+        expect(results.page).toBe(0);
+        expect(results.perPage).toBe(100);
+        expect(results.hasMore).toBe(false);
+      });
+    });
+  });
+
   describe('Permission Handling', () => {
     const schemaRestrictedUser = 'mastra_schema_restricted_storage';
     const restrictedPassword = 'test123';