@mastra/pg 0.10.2-alpha.0 → 0.10.2-alpha.2

package/src/storage/index.ts

@@ -12,11 +12,13 @@ import {
 } from '@mastra/core/storage';
 import type {
   EvalRow,
+  PaginationInfo,
   StorageColumn,
   StorageGetMessagesArg,
   TABLE_NAMES,
   WorkflowRun,
   WorkflowRuns,
+  PaginationArgs,
 } from '@mastra/core/storage';
 import { parseSqlIdentifier } from '@mastra/core/utils';
 import type { WorkflowRunState } from '@mastra/core/workflows';
@@ -85,6 +87,14 @@ export class PostgresStore extends MastraStorage {
     );
   }
 
+  public get supports(): {
+    selectByIncludeResourceScope: boolean;
+  } {
+    return {
+      selectByIncludeResourceScope: true,
+    };
+  }
+
   private getTableName(indexName: string) {
     const parsedIndexName = parseSqlIdentifier(indexName, 'table name');
     const parsedSchemaName = this.schema ? parseSqlIdentifier(this.schema, 'schema name') : undefined;
@@ -154,6 +164,9 @@ export class PostgresStore extends MastraStorage {
     }
   }
 
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
   public async getTraces(args: {
     name?: string;
     scope?: string;
@@ -163,55 +176,32 @@ export class PostgresStore extends MastraStorage {
     perPage?: number;
     fromDate?: Date;
     toDate?: Date;
-  }): Promise<any[]>;
-  public async getTraces(args: {
-    name?: string;
-    scope?: string;
-    page: number;
-    perPage?: number;
-    attributes?: Record<string, string>;
-    filters?: Record<string, any>;
-    fromDate?: Date;
-    toDate?: Date;
-    returnPaginationResults: true;
-  }): Promise<{
-    traces: any[];
-    total: number;
-    page: number;
-    perPage: number;
-    hasMore: boolean;
-  }>;
-  public async getTraces(args: {
-    name?: string;
-    scope?: string;
-    page: number;
-    perPage?: number;
-    attributes?: Record<string, string>;
-    filters?: Record<string, any>;
-    fromDate?: Date;
-    toDate?: Date;
-    returnPaginationResults?: boolean;
-  }): Promise<
-    | any[]
-    | {
-        traces: any[];
-        total: number;
-        page: number;
-        perPage: number;
-        hasMore: boolean;
-      }
+  }): Promise<any[]> {
+    if (args.fromDate || args.toDate) {
+      (args as any).dateRange = {
+        start: args.fromDate,
+        end: args.toDate,
+      };
+    }
+    const result = await this.getTracesPaginated(args);
+    return result.traces;
+  }
+
+  public async getTracesPaginated(
+    args: {
+      name?: string;
+      scope?: string;
+      attributes?: Record<string, string>;
+      filters?: Record<string, any>;
+    } & PaginationArgs,
+  ): Promise<
+    PaginationInfo & {
+      traces: any[];
+    }
   > {
-    const {
-      name,
-      scope,
-      page,
-      perPage: perPageInput,
-      attributes,
-      filters,
-      fromDate,
-      toDate,
-      returnPaginationResults,
-    } = args;
+    const { name, scope, page = 0, perPage: perPageInput, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
 
     const perPage = perPageInput !== undefined ? perPageInput : 100; // Default perPage
     const currentOffset = page * perPage;
@@ -258,7 +248,7 @@ export class PostgresStore extends MastraStorage {
     const countResult = await this.db.one(countQuery, queryParams);
     const total = parseInt(countResult.count, 10);
 
-    if (total === 0 && returnPaginationResults) {
+    if (total === 0) {
       return {
         traces: [],
         total: 0,
@@ -266,11 +256,11 @@ export class PostgresStore extends MastraStorage {
         perPage,
         hasMore: false,
       };
-    } else if (total === 0) {
-      return [];
     }
 
-    const dataQuery = `SELECT * FROM ${this.getTableName(TABLE_TRACES)} ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+    const dataQuery = `SELECT * FROM ${this.getTableName(
+      TABLE_TRACES,
+    )} ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
     const finalQueryParams = [...queryParams, perPage, currentOffset];
 
     const rows = await this.db.manyOrNone<any>(dataQuery, finalQueryParams);
@@ -291,17 +281,13 @@ export class PostgresStore extends MastraStorage {
       createdAt: row.createdAt,
     }));
 
-    if (returnPaginationResults) {
-      return {
-        traces,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + traces.length < total,
-      };
-    } else {
-      return traces;
-    }
+    return {
+      traces,
+      total,
+      page,
+      perPage,
+      hasMore: currentOffset + traces.length < total,
+    };
   }
 
   private async setupSchema() {
@@ -404,6 +390,57 @@ export class PostgresStore extends MastraStorage {
     }
   }
 
+  protected getDefaultValue(type: StorageColumn['type']): string {
+    switch (type) {
+      case 'timestamp':
+        return 'DEFAULT NOW()';
+      case 'jsonb':
+        return "DEFAULT '{}'::jsonb";
+      default:
+        return super.getDefaultValue(type);
+    }
+  }
+
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists,
+  }: {
+    tableName: TABLE_NAMES;
+    schema: Record<string, StorageColumn>;
+    ifNotExists: string[];
+  }): Promise<void> {
+    const fullTableName = this.getTableName(tableName);
+
+    try {
+      for (const columnName of ifNotExists) {
+        if (schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type);
+          const nullable = columnDef.nullable === false ? 'NOT NULL' : '';
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : '';
+          const parsedColumnName = parseSqlIdentifier(columnName, 'column name');
+          const alterSql =
+            `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
+
+          await this.db.none(alterSql);
+          this.logger?.debug?.(`Ensured column ${parsedColumnName} exists in table ${fullTableName}`);
+        }
+      }
+    } catch (error) {
+      this.logger?.error?.(
+        `Error altering table ${tableName}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      throw new Error(`Failed to alter table ${tableName}: ${error}`);
+    }
+  }
+
   async clearTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
     try {
       await this.db.none(`TRUNCATE TABLE ${this.getTableName(tableName)} CASCADE`);
@@ -491,82 +528,76 @@ export class PostgresStore extends MastraStorage {
     }
   }
 
-  public async getThreadsByResourceId(args: { resourceId: string }): Promise<StorageThreadType[]>;
-  public async getThreadsByResourceId(args: { resourceId: string; page: number; perPage?: number }): Promise<{
-    threads: StorageThreadType[];
-    total: number;
-    page: number;
-    perPage: number;
-    hasMore: boolean;
-  }>;
-  public async getThreadsByResourceId(args: { resourceId: string; page?: number; perPage?: number }): Promise<
-    | StorageThreadType[]
-    | {
-        threads: StorageThreadType[];
-        total: number;
-        page: number;
-        perPage: number;
-        hasMore: boolean;
-      }
-  > {
-    const { resourceId, page, perPage: perPageInput } = args;
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
+  public async getThreadsByResourceId(args: { resourceId: string }): Promise<StorageThreadType[]> {
+    const { resourceId } = args;
 
     try {
       const baseQuery = `FROM ${this.getTableName(TABLE_THREADS)} WHERE "resourceId" = $1`;
       const queryParams: any[] = [resourceId];
 
-      if (page !== undefined) {
-        const perPage = perPageInput !== undefined ? perPageInput : 100;
-        const currentOffset = page * perPage;
-
-        const countQuery = `SELECT COUNT(*) ${baseQuery}`;
-        const countResult = await this.db.one(countQuery, queryParams);
-        const total = parseInt(countResult.count, 10);
-
-        if (total === 0) {
-          return {
-            threads: [],
-            total: 0,
-            page,
-            perPage,
-            hasMore: false,
-          };
-        }
+      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC`;
+      const rows = await this.db.manyOrNone(dataQuery, queryParams);
+      return (rows || []).map(thread => ({
+        ...thread,
+        metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+      }));
+    } catch (error) {
+      this.logger.error(`Error getting threads for resource ${resourceId}:`, error);
+      return [];
+    }
+  }
 
-        const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC LIMIT $2 OFFSET $3`;
-        const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
+  public async getThreadsByResourceIdPaginated(
+    args: {
+      resourceId: string;
+    } & PaginationArgs,
+  ): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+    const { resourceId, page = 0, perPage: perPageInput } = args;
+    try {
+      const baseQuery = `FROM ${this.getTableName(TABLE_THREADS)} WHERE "resourceId" = $1`;
+      const queryParams: any[] = [resourceId];
+      const perPage = perPageInput !== undefined ? perPageInput : 100;
+      const currentOffset = page * perPage;
 
-        const threads = (rows || []).map(thread => ({
-          ...thread,
-          metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
-          createdAt: thread.createdAt, // Assuming already Date objects or ISO strings
-          updatedAt: thread.updatedAt,
-        }));
+      const countQuery = `SELECT COUNT(*) ${baseQuery}`;
+      const countResult = await this.db.one(countQuery, queryParams);
+      const total = parseInt(countResult.count, 10);
 
+      if (total === 0) {
         return {
-          threads,
-          total,
+          threads: [],
+          total: 0,
           page,
           perPage,
-          hasMore: currentOffset + threads.length < total,
+          hasMore: false,
         };
-      } else {
-        // Non-paginated path
-        const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC`;
-        const rows = await this.db.manyOrNone(dataQuery, queryParams);
-        return (rows || []).map(thread => ({
-          ...thread,
-          metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
-          createdAt: thread.createdAt,
-          updatedAt: thread.updatedAt,
-        }));
       }
+
+      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC LIMIT $2 OFFSET $3`;
+      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
+
+      const threads = (rows || []).map(thread => ({
+        ...thread,
+        metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt, // Assuming already Date objects or ISO strings
+        updatedAt: thread.updatedAt,
+      }));
+
+      return {
+        threads,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + threads.length < total,
+      };
     } catch (error) {
       this.logger.error(`Error getting threads for resource ${resourceId}:`, error);
-      if (page !== undefined) {
-        return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
-      }
-      return [];
+      return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
     }
   }
 
@@ -663,203 +694,193 @@ export class PostgresStore extends MastraStorage {
     }
   }
 
+  /**
+   * @deprecated use getMessagesPaginated instead
+   */
   public async getMessages(args: StorageGetMessagesArg & { format?: 'v1' }): Promise<MastraMessageV1[]>;
   public async getMessages(args: StorageGetMessagesArg & { format: 'v2' }): Promise<MastraMessageV2[]>;
   public async getMessages(
     args: StorageGetMessagesArg & {
       format?: 'v1' | 'v2';
-      page: number;
-      perPage?: number;
-      fromDate?: Date;
-      toDate?: Date;
     },
-  ): Promise<{
-    messages: MastraMessageV1[] | MastraMessageV2[];
-    total: number;
-    page: number;
-    perPage: number;
-    hasMore: boolean;
-  }>;
-  public async getMessages(
+  ): Promise<MastraMessageV1[] | MastraMessageV2[]> {
+    const { threadId, format, selectBy } = args;
+
+    const selectStatement = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId"`;
+    const orderByStatement = `ORDER BY "createdAt" DESC`;
+
+    try {
+      let rows: any[] = [];
+      const include = selectBy?.include || [];
+
+      if (include.length) {
+        const unionQueries: string[] = [];
+        const params: any[] = [];
+        let paramIdx = 1;
+
+        for (const inc of include) {
+          const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+          // if threadId is provided, use it, otherwise use threadId from args
+          const searchId = inc.threadId || threadId;
+          unionQueries.push(
+            `
+            SELECT * FROM (
+              WITH ordered_messages AS (
+                SELECT 
+                  *,
+                  ROW_NUMBER() OVER (${orderByStatement}) as row_num
+                FROM ${this.getTableName(TABLE_MESSAGES)}
+                WHERE thread_id = $${paramIdx}
+              )
+              SELECT
+                m.id, 
+                m.content, 
+                m.role, 
+                m.type,
+                m."createdAt", 
+                m.thread_id AS "threadId",
+                m."resourceId"
+              FROM ordered_messages m
+              WHERE m.id = $${paramIdx + 1}
+              OR EXISTS (
+                SELECT 1 FROM ordered_messages target
+                WHERE target.id = $${paramIdx + 1}
+                AND (
+                  -- Get previous messages based on the max withPreviousMessages
+                  (m.row_num <= target.row_num + $${paramIdx + 2} AND m.row_num > target.row_num)
+                  OR
+                  -- Get next messages based on the max withNextMessages
+                  (m.row_num >= target.row_num - $${paramIdx + 3} AND m.row_num < target.row_num)
+                )
+              )
+            ) 
+            `, // Keep ASC for final sorting after fetching context
+          );
+          params.push(searchId, id, withPreviousMessages, withNextMessages);
+          paramIdx += 4;
+        }
+        const finalQuery = unionQueries.join(' UNION ALL ') + ' ORDER BY "createdAt" ASC';
+        const includedRows = await this.db.manyOrNone(finalQuery, params);
+        const dedupedRows = Object.values(
+          includedRows.reduce(
+            (acc, row) => {
+              acc[row.id] = row;
+              return acc;
+            },
+            {} as Record<string, (typeof includedRows)[0]>,
+          ),
+        );
+        rows = dedupedRows;
+      } else {
+        const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
+        if (limit === 0 && selectBy?.last !== false) {
+          // if last is explicitly false, we fetch all
+          // Do nothing, rows will be empty, and we return empty array later.
+        } else {
+          let query = `${selectStatement} FROM ${this.getTableName(
+            TABLE_MESSAGES,
+          )} WHERE thread_id = $1 ${orderByStatement}`;
+          const queryParams: any[] = [threadId];
+          if (limit !== undefined && selectBy?.last !== false) {
+            query += ` LIMIT $2`;
+            queryParams.push(limit);
+          }
+          rows = await this.db.manyOrNone(query, queryParams);
+        }
+      }
+
+      const fetchedMessages = (rows || []).map(message => {
+        if (typeof message.content === 'string') {
+          try {
+            message.content = JSON.parse(message.content);
+          } catch {
+            /* ignore */
+          }
+        }
+        if (message.type === 'v2') delete message.type;
+        return message as MastraMessageV1;
+      });
+
+      // Sort all messages by creation date
+      const sortedMessages = fetchedMessages.sort(
+        (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime(),
+      );
+
+      return format === 'v2'
+        ? sortedMessages.map(
+            m =>
+              ({ ...m, content: m.content || { format: 2, parts: [{ type: 'text', text: '' }] } }) as MastraMessageV2,
+          )
+        : sortedMessages;
+    } catch (error) {
+      this.logger.error('Error getting messages:', error);
+      return [];
+    }
+  }
+
+  public async getMessagesPaginated(
     args: StorageGetMessagesArg & {
       format?: 'v1' | 'v2';
-      page?: number;
-      perPage?: number;
-      fromDate?: Date;
-      toDate?: Date;
     },
-  ): Promise<
-    | MastraMessageV1[]
-    | MastraMessageV2[]
-    | {
-        messages: MastraMessageV1[] | MastraMessageV2[];
-        total: number;
-        page: number;
-        perPage: number;
-        hasMore: boolean;
-      }
-  > {
-    const { threadId, format, page, perPage: perPageInput, fromDate, toDate, selectBy } = args;
+  ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
+    const { threadId, format, selectBy } = args;
+    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
 
     const selectStatement = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId"`;
     const orderByStatement = `ORDER BY "createdAt" DESC`;
 
     try {
-      if (page !== undefined) {
-        const perPage = perPageInput !== undefined ? perPageInput : 40;
-        const currentOffset = page * perPage;
+      const perPage = perPageInput !== undefined ? perPageInput : 40;
+      const currentOffset = page * perPage;
 
-        const conditions: string[] = [`thread_id = $1`];
-        const queryParams: any[] = [threadId];
-        let paramIndex = 2;
+      const conditions: string[] = [`thread_id = $1`];
+      const queryParams: any[] = [threadId];
+      let paramIndex = 2;
 
-        if (fromDate) {
-          conditions.push(`"createdAt" >= $${paramIndex++}`);
-          queryParams.push(fromDate);
-        }
-        if (toDate) {
-          conditions.push(`"createdAt" <= $${paramIndex++}`);
-          queryParams.push(toDate);
-        }
-        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-
-        const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(TABLE_MESSAGES)} ${whereClause}`;
-        const countResult = await this.db.one(countQuery, queryParams);
-        const total = parseInt(countResult.count, 10);
-
-        if (total === 0) {
-          return {
-            messages: [],
-            total: 0,
-            page,
-            perPage,
-            hasMore: false,
-          };
-        }
+      if (fromDate) {
+        conditions.push(`"createdAt" >= $${paramIndex++}`);
+        queryParams.push(fromDate);
+      }
+      if (toDate) {
+        conditions.push(`"createdAt" <= $${paramIndex++}`);
+        queryParams.push(toDate);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
 
-        const dataQuery = `${selectStatement} FROM ${this.getTableName(TABLE_MESSAGES)} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-        const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
-
-        const fetchedMessages = (rows || []).map(message => {
-          if (typeof message.content === 'string') {
-            try {
-              message.content = JSON.parse(message.content);
-            } catch {
-              /* ignore */
-            }
-          }
-          if (message.type === 'v2') delete message.type;
-          return message as MastraMessageV1;
-        });
-
-        const messagesToReturn =
-          format === 'v2'
-            ? fetchedMessages.map(
-                m =>
-                  ({
-                    ...m,
-                    content: m.content || { format: 2, parts: [{ type: 'text', text: '' }] },
-                  }) as MastraMessageV2,
-              )
-            : fetchedMessages;
+      const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(TABLE_MESSAGES)} ${whereClause}`;
+      const countResult = await this.db.one(countQuery, queryParams);
+      const total = parseInt(countResult.count, 10);
 
+      if (total === 0) {
         return {
-          messages: messagesToReturn,
-          total,
+          messages: [],
+          total: 0,
           page,
           perPage,
-          hasMore: currentOffset + fetchedMessages.length < total,
+          hasMore: false,
         };
-      } else {
-        // Non-paginated path: Handle selectBy.include or selectBy.last
-        let rows: any[] = [];
-        const include = selectBy?.include || [];
-
-        if (include.length) {
-          rows = await this.db.manyOrNone(
-            `
-            WITH ordered_messages AS (
-              SELECT 
-                *,
-                ROW_NUMBER() OVER (${orderByStatement}) as row_num
-              FROM ${this.getTableName(TABLE_MESSAGES)}
-              WHERE thread_id = $1
-            )
-            SELECT
-              m.id, 
-              m.content, 
-              m.role, 
-              m.type,
-              m."createdAt", 
-              m.thread_id AS "threadId"
-            FROM ordered_messages m
-            WHERE m.id = ANY($2)
-            OR EXISTS (
-              SELECT 1 FROM ordered_messages target
-              WHERE target.id = ANY($2)
-              AND (
-                -- Get previous messages based on the max withPreviousMessages
-                (m.row_num <= target.row_num + $3 AND m.row_num > target.row_num)
-                OR
-                -- Get next messages based on the max withNextMessages
-                (m.row_num >= target.row_num - $4 AND m.row_num < target.row_num)
-              )
-            )
-            ORDER BY m."createdAt" ASC 
-            `, // Keep ASC for final sorting after fetching context
-            [
-              threadId,
-              include.map(i => i.id),
-              Math.max(0, ...include.map(i => i.withPreviousMessages || 0)), // Ensure non-negative
-              Math.max(0, ...include.map(i => i.withNextMessages || 0)), // Ensure non-negative
-            ],
-          );
-        } else {
-          const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
-          if (limit === 0 && selectBy?.last !== false) {
-            // if last is explicitly false, we fetch all
-            // Do nothing, rows will be empty, and we return empty array later.
-          } else {
-            let query = `${selectStatement} FROM ${this.getTableName(TABLE_MESSAGES)} WHERE thread_id = $1 ${orderByStatement}`;
-            const queryParams: any[] = [threadId];
-            if (limit !== undefined && selectBy?.last !== false) {
-              query += ` LIMIT $2`;
-              queryParams.push(limit);
-            }
-            rows = await this.db.manyOrNone(query, queryParams);
-          }
-        }
+      }
 
-        const fetchedMessages = (rows || []).map(message => {
-          if (typeof message.content === 'string') {
-            try {
-              message.content = JSON.parse(message.content);
-            } catch {
-              /* ignore */
-            }
-          }
-          if (message.type === 'v2') delete message.type;
-          return message as MastraMessageV1;
-        });
+      const dataQuery = `${selectStatement} FROM ${this.getTableName(
+        TABLE_MESSAGES,
+      )} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
 
-        // Sort all messages by creation date
-        const sortedMessages = fetchedMessages.sort(
-          (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime(),
-        );
+      const list = new MessageList().add(rows || [], 'memory');
+      const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
 
-        return format === 'v2'
-          ? sortedMessages.map(
-              m =>
-                ({ ...m, content: m.content || { format: 2, parts: [{ type: 'text', text: '' }] } }) as MastraMessageV2,
-            )
-          : sortedMessages;
-      }
+      return {
+        messages: messagesToReturn,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + rows.length < total,
+      };
     } catch (error) {
       this.logger.error('Error getting messages:', error);
-      if (page !== undefined) {
-        return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
-      }
-      return [];
+      return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
     }
   }
 
@@ -887,16 +908,27 @@ export class PostgresStore extends MastraStorage {
 
       await this.db.tx(async t => {
         for (const message of messages) {
+          if (!message.threadId) {
+            throw new Error(
+              `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`,
+            );
+          }
+          if (!message.resourceId) {
+            throw new Error(
+              `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`,
+            );
+          }
           await t.none(
-            `INSERT INTO ${this.getTableName(TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type) 
-             VALUES ($1, $2, $3, $4, $5, $6)`,
+            `INSERT INTO ${this.getTableName(TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type, "resourceId") 
+             VALUES ($1, $2, $3, $4, $5, $6, $7)`,
             [
               message.id,
-              threadId,
+              message.threadId,
               typeof message.content === 'string' ? message.content : JSON.stringify(message.content),
               message.createdAt || new Date().toISOString(),
               message.role,
               message.type || 'v2',
+              message.resourceId,
             ],
           );
         }
@@ -1134,23 +1166,15 @@ export class PostgresStore extends MastraStorage {
     this.pgp.end();
   }
 
-  async getEvals(options?: {
-    agentName?: string;
-    type?: 'test' | 'live';
-    page?: number;
-    perPage?: number;
-    limit?: number;
-    offset?: number;
-    fromDate?: Date;
-    toDate?: Date;
-  }): Promise<{
-    evals: EvalRow[];
-    total: number;
-    page?: number;
-    perPage?: number;
-    hasMore?: boolean;
-  }> {
-    const { agentName, type, page, perPage, limit, offset, fromDate, toDate } = options || {};
+  async getEvals(
+    options: {
+      agentName?: string;
+      type?: 'test' | 'live';
+    } & PaginationArgs = {},
+  ): Promise<PaginationInfo & { evals: EvalRow[] }> {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
 
     const conditions: string[] = [];
     const queryParams: any[] = [];
@@ -1182,50 +1206,29 @@ export class PostgresStore extends MastraStorage {
     const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(TABLE_EVALS)} ${whereClause}`;
     const countResult = await this.db.one(countQuery, queryParams);
     const total = parseInt(countResult.count, 10);
-
-    let currentLimit: number;
-    let currentOffset: number;
-    let currentPage: number | undefined = page;
-    let currentPerPage: number | undefined = perPage;
-    let hasMore = false;
-
-    if (limit !== undefined && offset !== undefined) {
-      currentLimit = limit;
-      currentOffset = offset;
-      currentPage = undefined;
-      currentPerPage = undefined;
-      hasMore = currentOffset + currentLimit < total;
-    } else if (page !== undefined && perPage !== undefined) {
-      currentLimit = perPage;
-      currentOffset = page * perPage;
-      hasMore = currentOffset + currentLimit < total;
-    } else {
-      currentLimit = perPage || 100;
-      currentOffset = (page || 0) * currentLimit;
-      if (page === undefined) currentPage = 0;
-      if (currentPerPage === undefined) currentPerPage = currentLimit;
-      hasMore = currentOffset + currentLimit < total;
-    }
+    const currentOffset = page * perPage;
 
     if (total === 0) {
       return {
         evals: [],
         total: 0,
-        page: currentPage,
-        perPage: currentPerPage,
+        page,
+        perPage,
         hasMore: false,
       };
     }
 
-    const dataQuery = `SELECT * FROM ${this.getTableName(TABLE_EVALS)} ${whereClause} ORDER BY created_at DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-    const rows = await this.db.manyOrNone(dataQuery, [...queryParams, currentLimit, currentOffset]);
+    const dataQuery = `SELECT * FROM ${this.getTableName(
+      TABLE_EVALS,
+    )} ${whereClause} ORDER BY created_at DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+    const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
 
     return {
       evals: rows?.map(row => this.transformEvalRow(row)) ?? [],
       total,
-      page: currentPage,
-      perPage: currentPerPage,
-      hasMore,
+      page,
+      perPage,
+      hasMore: currentOffset + (rows?.length ?? 0) < total,
     };
   }
 }