@mastra/pg 0.10.1 → 0.10.2-alpha.1

package/dist/index.cjs

@@ -949,6 +949,7 @@ var PostgresStore = class extends storage.MastraStorage {
     const parsedSchemaName = this.schema ? utils.parseSqlIdentifier(this.schema, "schema name") : void 0;
     return parsedSchemaName ? `${parsedSchemaName}."${parsedIndexName}"` : `"${parsedIndexName}"`;
   }
+  /** @deprecated use getEvals instead */
   async getEvalsByAgentName(agentName, type) {
     try {
       const baseQuery = `SELECT * FROM ${this.getTableName(storage.TABLE_EVALS)} WHERE agent_name = $1`;
@@ -999,76 +1000,77 @@ var PostgresStore = class extends storage.MastraStorage {
       throw error;
     }
   }
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes,
-    filters,
-    fromDate,
-    toDate
-  }) {
-    let idx = 1;
-    const limit = perPage;
-    const offset = page * perPage;
-    const args = [];
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
+  async getTraces(args) {
+    if (args.fromDate || args.toDate) {
+      args.dateRange = {
+        start: args.fromDate,
+        end: args.toDate
+      };
+    }
+    const result = await this.getTracesPaginated(args);
+    return result.traces;
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage: perPageInput, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const perPage = perPageInput !== void 0 ? perPageInput : 100;
+    const currentOffset = page * perPage;
+    const queryParams = [];
     const conditions = [];
+    let paramIndex = 1;
     if (name) {
-      conditions.push(`name LIKE CONCAT($${idx++}, '%')`);
+      conditions.push(`name LIKE $${paramIndex++}`);
+      queryParams.push(`${name}%`);
     }
     if (scope) {
-      conditions.push(`scope = $${idx++}`);
+      conditions.push(`scope = $${paramIndex++}`);
+      queryParams.push(scope);
     }
     if (attributes) {
-      Object.keys(attributes).forEach((key) => {
+      Object.entries(attributes).forEach(([key, value]) => {
         const parsedKey = utils.parseSqlIdentifier(key, "attribute key");
-        conditions.push(`attributes->>'${parsedKey}' = $${idx++}`);
+        conditions.push(`attributes->>'${parsedKey}' = $${paramIndex++}`);
+        queryParams.push(value);
       });
     }
     if (filters) {
-      Object.entries(filters).forEach(([key]) => {
+      Object.entries(filters).forEach(([key, value]) => {
         const parsedKey = utils.parseSqlIdentifier(key, "filter key");
-        conditions.push(`${parsedKey} = $${idx++}`);
+        conditions.push(`"${parsedKey}" = $${paramIndex++}`);
+        queryParams.push(value);
       });
     }
     if (fromDate) {
-      conditions.push(`createdAt >= $${idx++}`);
+      conditions.push(`"createdAt" >= $${paramIndex++}`);
+      queryParams.push(fromDate);
     }
     if (toDate) {
-      conditions.push(`createdAt <= $${idx++}`);
+      conditions.push(`"createdAt" <= $${paramIndex++}`);
+      queryParams.push(toDate);
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    if (name) {
-      args.push(name);
-    }
-    if (scope) {
-      args.push(scope);
-    }
-    if (attributes) {
-      for (const [_key, value] of Object.entries(attributes)) {
-        args.push(value);
-      }
-    }
-    if (filters) {
-      for (const [, value] of Object.entries(filters)) {
-        args.push(value);
-      }
-    }
-    if (fromDate) {
-      args.push(fromDate.toISOString());
-    }
-    if (toDate) {
-      args.push(toDate.toISOString());
-    }
-    const result = await this.db.manyOrNone(
-      `SELECT * FROM ${this.getTableName(storage.TABLE_TRACES)} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
-      args
-    );
-    if (!result) {
-      return [];
+    const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(storage.TABLE_TRACES)} ${whereClause}`;
+    const countResult = await this.db.one(countQuery, queryParams);
+    const total = parseInt(countResult.count, 10);
+    if (total === 0) {
+      return {
+        traces: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
     }
-    return result.map((row) => ({
+    const dataQuery = `SELECT * FROM ${this.getTableName(
+      storage.TABLE_TRACES
+    )} ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+    const finalQueryParams = [...queryParams, perPage, currentOffset];
+    const rows = await this.db.manyOrNone(dataQuery, finalQueryParams);
+    const traces = rows.map((row) => ({
       id: row.id,
       parentSpanId: row.parentSpanId,
       traceId: row.traceId,
@@ -1084,6 +1086,13 @@ var PostgresStore = class extends storage.MastraStorage {
       other: row.other,
       createdAt: row.createdAt
     }));
+    return {
+      traces,
+      total,
+      page,
+      perPage,
+      hasMore: currentOffset + traces.length < total
+    };
   }
   async setupSchema() {
     if (!this.schema || this.schemaSetupComplete) {
@@ -1162,6 +1171,48 @@ var PostgresStore = class extends storage.MastraStorage {
       throw error;
     }
   }
+  getDefaultValue(type) {
+    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
+  }) {
+    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 = utils.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 }) {
     try {
       await this.db.none(`TRUNCATE TABLE ${this.getTableName(tableName)} CASCADE`);
@@ -1237,29 +1288,65 @@ var PostgresStore = class extends storage.MastraStorage {
       throw error;
     }
   }
-  async getThreadsByResourceId({ resourceId }) {
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
+  async getThreadsByResourceId(args) {
+    const { resourceId } = args;
     try {
-      const threads = await this.db.manyOrNone(
-        `SELECT 
-          id,
-          "resourceId",
-          title,
-          metadata,
-          "createdAt",
-          "updatedAt"
-        FROM ${this.getTableName(storage.TABLE_THREADS)}
-        WHERE "resourceId" = $1`,
-        [resourceId]
-      );
-      return threads.map((thread) => ({
+      const baseQuery = `FROM ${this.getTableName(storage.TABLE_THREADS)} WHERE "resourceId" = $1`;
+      const queryParams = [resourceId];
+      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) {
-      console.error(`Error getting threads for resource ${resourceId}:`, error);
-      throw error;
+      this.logger.error(`Error getting threads for resource ${resourceId}:`, error);
+      return [];
+    }
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page = 0, perPage: perPageInput } = args;
+    try {
+      const baseQuery = `FROM ${this.getTableName(storage.TABLE_THREADS)} WHERE "resourceId" = $1`;
+      const queryParams = [resourceId];
+      const perPage = perPageInput !== void 0 ? 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 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);
+      return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
     }
   }
   async saveThread({ thread }) {
@@ -1339,84 +1426,140 @@ var PostgresStore = class extends storage.MastraStorage {
       throw error;
     }
   }
-  async getMessages({ threadId, selectBy }) {
+  async getMessages(args) {
+    const { threadId, format, selectBy } = args;
+    const selectStatement = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId"`;
+    const orderByStatement = `ORDER BY "createdAt" DESC`;
     try {
-      const messages = [];
-      const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
+      let rows = [];
       const include = selectBy?.include || [];
       if (include.length) {
-        const includeResult = await this.db.manyOrNone(
+        rows = await this.db.manyOrNone(
           `
-          WITH ordered_messages AS (
-            SELECT 
-              *,
-              ROW_NUMBER() OVER (ORDER BY "createdAt" DESC) as row_num
-            FROM ${this.getTableName(storage.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)
+            WITH ordered_messages AS (
+              SELECT 
+                *,
+                ROW_NUMBER() OVER (${orderByStatement}) as row_num
+              FROM ${this.getTableName(storage.TABLE_MESSAGES)}
+              WHERE thread_id = $1
             )
-          )
-          ORDER BY m."createdAt" DESC
-          `,
+            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(...include.map((i) => i.withPreviousMessages || 0)),
-            Math.max(...include.map((i) => i.withNextMessages || 0))
+            Math.max(0, ...include.map((i) => i.withPreviousMessages || 0)),
+            // Ensure non-negative
+            Math.max(0, ...include.map((i) => i.withNextMessages || 0))
+            // Ensure non-negative
           ]
         );
-        messages.push(...includeResult);
+      } else {
+        const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
+        if (limit === 0 && selectBy?.last !== false) ; else {
+          let query = `${selectStatement} FROM ${this.getTableName(
+            storage.TABLE_MESSAGES
+          )} WHERE thread_id = $1 ${orderByStatement}`;
+          const queryParams = [threadId];
+          if (limit !== void 0 && selectBy?.last !== false) {
+            query += ` LIMIT $2`;
+            queryParams.push(limit);
+          }
+          rows = await this.db.manyOrNone(query, queryParams);
+        }
       }
-      const result = await this.db.manyOrNone(
-        `
-        SELECT 
-            id, 
-            content, 
-            role, 
-            type,
-            "createdAt", 
-            thread_id AS "threadId"
-        FROM ${this.getTableName(storage.TABLE_MESSAGES)}
-        WHERE thread_id = $1
-        AND id != ALL($2)
-        ORDER BY "createdAt" DESC
-        LIMIT $3
-        `,
-        [threadId, messages.map((m) => m.id), limit]
-      );
-      messages.push(...result);
-      messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-      messages.forEach((message) => {
+      const fetchedMessages = (rows || []).map((message) => {
         if (typeof message.content === "string") {
           try {
             message.content = JSON.parse(message.content);
           } catch {
           }
         }
-        if (message.type === `v2`) delete message.type;
+        if (message.type === "v2") delete message.type;
+        return message;
       });
-      return messages;
+      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: "" }] } })
+      ) : sortedMessages;
     } catch (error) {
-      console.error("Error getting messages:", error);
-      throw error;
+      this.logger.error("Error getting messages:", error);
+      return [];
+    }
+  }
+  async getMessagesPaginated(args) {
+    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 {
+      const perPage = perPageInput !== void 0 ? perPageInput : 40;
+      const currentOffset = page * perPage;
+      const conditions = [`thread_id = $1`];
+      const queryParams = [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(storage.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
+        };
+      }
+      const dataQuery = `${selectStatement} FROM ${this.getTableName(
+        storage.TABLE_MESSAGES
+      )} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.db.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
+      const list = new agent.MessageList().add(rows || [], "memory");
+      const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
+      return {
+        messages: messagesToReturn,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + rows.length < total
+      };
+    } catch (error) {
+      this.logger.error("Error getting messages:", error);
+      return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
     }
   }
   async saveMessages({
@@ -1629,6 +1772,56 @@ var PostgresStore = class extends storage.MastraStorage {
   async close() {
     this.pgp.end();
   }
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const conditions = [];
+    const queryParams = [];
+    let paramIndex = 1;
+    if (agentName) {
+      conditions.push(`agent_name = $${paramIndex++}`);
+      queryParams.push(agentName);
+    }
+    if (type === "test") {
+      conditions.push(`(test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL)`);
+    } else if (type === "live") {
+      conditions.push(`(test_info IS NULL OR test_info->>'testPath' IS NULL)`);
+    }
+    if (fromDate) {
+      conditions.push(`created_at >= $${paramIndex++}`);
+      queryParams.push(fromDate);
+    }
+    if (toDate) {
+      conditions.push(`created_at <= $${paramIndex++}`);
+      queryParams.push(toDate);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countQuery = `SELECT COUNT(*) FROM ${this.getTableName(storage.TABLE_EVALS)} ${whereClause}`;
+    const countResult = await this.db.one(countQuery, queryParams);
+    const total = parseInt(countResult.count, 10);
+    const currentOffset = page * perPage;
+    if (total === 0) {
+      return {
+        evals: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
+    }
+    const dataQuery = `SELECT * FROM ${this.getTableName(
+      storage.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,
+      perPage,
+      hasMore: currentOffset + (rows?.length ?? 0) < total
+    };
+  }
 };
 
 // src/vector/prompt.ts