@mastra/pg 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/index.js

@@ -5,7 +5,7 @@ import { Mutex } from 'async-mutex';
 import * as pg from 'pg';
 import xxhash from 'xxhash-wasm';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import { MastraStorage, StoreOperations, TABLE_SCHEMAS, TABLE_WORKFLOW_SNAPSHOT, TABLE_SPANS, TABLE_THREADS, TABLE_MESSAGES, TABLE_TRACES, TABLE_SCORERS, ScoresStorage, normalizePerPage, calculatePagination, WorkflowsStorage, MemoryStorage, TABLE_RESOURCES, ObservabilityStorage, safelyParseJSON } from '@mastra/core/storage';
+import { MastraStorage, StoreOperations, TABLE_SCHEMAS, TABLE_WORKFLOW_SNAPSHOT, TABLE_SPANS, TABLE_THREADS, TABLE_MESSAGES, TABLE_TRACES, TABLE_SCORERS, ScoresStorage, normalizePerPage, calculatePagination, WorkflowsStorage, MemoryStorage, TABLE_RESOURCES, ObservabilityStorage, transformScoreRow as transformScoreRow$1 } from '@mastra/core/storage';
 import pgPromise from 'pg-promise';
 import { MessageList } from '@mastra/core/agent';
 import { saveScorePayloadSchema } from '@mastra/core/evals';
@@ -126,12 +126,20 @@ var createBasicOperator = (symbol) => {
   };
 };
 var createNumericOperator = (symbol) => {
-  return (key, paramIndex) => {
+  return (key, paramIndex, value) => {
     const jsonPathKey = parseJsonPathKey(key);
-    return {
-      sql: `(metadata#>>'{${jsonPathKey}}')::numeric ${symbol} $${paramIndex}`,
-      needsValue: true
-    };
+    const isNumeric = typeof value === "number" || typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "";
+    if (isNumeric) {
+      return {
+        sql: `(metadata#>>'{${jsonPathKey}}')::numeric ${symbol} $${paramIndex}::numeric`,
+        needsValue: true
+      };
+    } else {
+      return {
+        sql: `metadata#>>'{${jsonPathKey}}' ${symbol} $${paramIndex}::text`,
+        needsValue: true
+      };
+    }
   };
 };
 function buildElemMatchConditions(value, paramIndex) {
@@ -312,6 +320,83 @@ var parseJsonPathKey = (key) => {
 function escapeLikePattern(str) {
   return str.replace(/([%_\\])/g, "\\$1");
 }
+function buildDeleteFilterQuery(filter) {
+  const values = [];
+  function buildCondition(key, value, parentPath) {
+    if (["$and", "$or", "$not", "$nor"].includes(key)) {
+      return handleLogicalOperator(key, value);
+    }
+    if (!value || typeof value !== "object") {
+      values.push(value);
+      return `metadata#>>'{${parseJsonPathKey(key)}}' = $${values.length}`;
+    }
+    const [[operator, operatorValue] = []] = Object.entries(value);
+    if (operator === "$not") {
+      const entries = Object.entries(operatorValue);
+      const conditions2 = entries.map(([nestedOp, nestedValue]) => {
+        if (!FILTER_OPERATORS[nestedOp]) {
+          throw new Error(`Invalid operator in $not condition: ${nestedOp}`);
+        }
+        const operatorFn2 = FILTER_OPERATORS[nestedOp];
+        const operatorResult2 = operatorFn2(key, values.length + 1, nestedValue);
+        if (operatorResult2.needsValue) {
+          values.push(nestedValue);
+        }
+        return operatorResult2.sql;
+      }).join(" AND ");
+      return `NOT (${conditions2})`;
+    }
+    const operatorFn = FILTER_OPERATORS[operator];
+    const operatorResult = operatorFn(key, values.length + 1, operatorValue);
+    if (operatorResult.needsValue) {
+      const transformedValue = operatorResult.transformValue ? operatorResult.transformValue() : operatorValue;
+      if (Array.isArray(transformedValue) && operator === "$elemMatch") {
+        values.push(...transformedValue);
+      } else {
+        values.push(transformedValue);
+      }
+    }
+    return operatorResult.sql;
+  }
+  function handleLogicalOperator(key, value, parentPath) {
+    if (key === "$not") {
+      const entries = Object.entries(value);
+      const conditions3 = entries.map(([fieldKey, fieldValue]) => buildCondition(fieldKey, fieldValue)).join(" AND ");
+      return `NOT (${conditions3})`;
+    }
+    if (!value || value.length === 0) {
+      switch (key) {
+        case "$and":
+        case "$nor":
+          return "true";
+        // Empty $and/$nor match everything
+        case "$or":
+          return "false";
+        // Empty $or matches nothing
+        default:
+          return "true";
+      }
+    }
+    const joinOperator = key === "$or" || key === "$nor" ? "OR" : "AND";
+    const conditions2 = value.map((f) => {
+      const entries = Object.entries(f || {});
+      if (entries.length === 0) return "";
+      const [firstKey, firstValue] = entries[0] || [];
+      if (["$and", "$or", "$not", "$nor"].includes(firstKey)) {
+        return buildCondition(firstKey, firstValue);
+      }
+      return entries.map(([k, v]) => buildCondition(k, v)).join(` ${joinOperator} `);
+    });
+    const joined = conditions2.join(` ${joinOperator} `);
+    const operatorFn = FILTER_OPERATORS[key];
+    return operatorFn(joined, 0, value).sql;
+  }
+  if (!filter) {
+    return { sql: "", values };
+  }
+  const conditions = Object.entries(filter).map(([key, value]) => buildCondition(key, value)).filter(Boolean).join(" AND ");
+  return { sql: conditions ? `WHERE ${conditions}` : "", values };
+}
 function buildFilterQuery(filter, minScore, topK) {
   const values = [minScore, topK];
   function buildCondition(key, value, parentPath) {
@@ -511,9 +596,6 @@ var PgVector = class extends MastraVector {
       if (this.vectorExtensionSchema === "pg_catalog") {
         return "vector";
       }
-      if (this.vectorExtensionSchema === (this.schema || "public")) {
-        return "vector";
-      }
       const validatedSchema = parseSqlIdentifier(this.vectorExtensionSchema, "vector extension schema");
       return `${validatedSchema}.vector`;
     }
@@ -633,11 +715,31 @@ var PgVector = class extends MastraVector {
       client.release();
     }
   }
-  async upsert({ indexName, vectors, metadata, ids }) {
+  async upsert({
+    indexName,
+    vectors,
+    metadata,
+    ids,
+    deleteFilter
+  }) {
     const { tableName } = this.getTableName(indexName);
     const client = await this.pool.connect();
     try {
       await client.query("BEGIN");
+      if (deleteFilter) {
+        this.logger?.debug(`Deleting vectors matching filter before upsert`, { indexName, deleteFilter });
+        const translatedFilter = this.transformFilter(deleteFilter);
+        const { sql: filterQuery, values: filterValues } = buildDeleteFilterQuery(translatedFilter);
+        const whereClause = filterQuery.trim().replace(/^WHERE\s+/i, "");
+        if (whereClause) {
+          const deleteQuery = `DELETE FROM ${tableName} WHERE ${whereClause}`;
+          const result = await client.query(deleteQuery, filterValues);
+          this.logger?.debug(`Deleted ${result.rowCount || 0} vectors before upsert`, {
+            indexName,
+            deletedCount: result.rowCount || 0
+          });
+        }
+      }
       const vectorIds = ids || vectors.map(() => crypto.randomUUID());
       const vectorType = this.getVectorTypeName();
       for (let i = 0; i < vectors.length; i++) {
@@ -653,6 +755,11 @@ var PgVector = class extends MastraVector {
         await client.query(query, [vectorIds[i], `[${vectors[i]?.join(",")}]`, JSON.stringify(metadata?.[i] || {})]);
       }
       await client.query("COMMIT");
+      this.logger?.debug(`Upserted ${vectors.length} vectors to ${indexName}`, {
+        indexName,
+        vectorCount: vectors.length,
+        hadDeleteFilter: !!deleteFilter
+      });
       return vectorIds;
     } catch (error) {
       await client.query("ROLLBACK");
@@ -1210,17 +1317,36 @@ var PgVector = class extends MastraVector {
    * @returns A promise that resolves when the update is complete.
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
-  async updateVector({ indexName, id, update }) {
+  async updateVector({ indexName, id, filter, update }) {
     let client;
     try {
       if (!update.vector && !update.metadata) {
         throw new Error("No updates provided");
       }
+      if (!id && !filter) {
+        throw new MastraError({
+          id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_MISSING_PARAMS",
+          text: "Either id or filter must be provided",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.USER,
+          details: { indexName }
+        });
+      }
+      if (id && filter) {
+        throw new MastraError({
+          id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_CONFLICTING_PARAMS",
+          text: "Cannot provide both id and filter - they are mutually exclusive",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.USER,
+          details: { indexName }
+        });
+      }
       client = await this.pool.connect();
-      let updateParts = [];
-      let values = [id];
-      let valueIndex = 2;
+      const { tableName } = this.getTableName(indexName);
       const vectorType = this.getVectorTypeName();
+      let updateParts = [];
+      let values = [];
+      let valueIndex = 1;
       if (update.vector) {
         updateParts.push(`embedding = $${valueIndex}::${vectorType}`);
         values.push(`[${update.vector.join(",")}]`);
@@ -1229,18 +1355,60 @@ var PgVector = class extends MastraVector {
       if (update.metadata) {
         updateParts.push(`metadata = $${valueIndex}::jsonb`);
         values.push(JSON.stringify(update.metadata));
+        valueIndex++;
       }
       if (updateParts.length === 0) {
         return;
       }
-      const { tableName } = this.getTableName(indexName);
+      let whereClause;
+      let whereValues;
+      if (id) {
+        whereClause = `vector_id = $${valueIndex}`;
+        whereValues = [id];
+      } else {
+        if (!filter || Object.keys(filter).length === 0) {
+          throw new MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_EMPTY_FILTER",
+            text: "Cannot update with empty filter",
+            domain: ErrorDomain.MASTRA_VECTOR,
+            category: ErrorCategory.USER,
+            details: { indexName }
+          });
+        }
+        const translatedFilter = this.transformFilter(filter);
+        const { sql: filterQuery, values: filterValues } = buildDeleteFilterQuery(translatedFilter);
+        whereClause = filterQuery.trim().replace(/^WHERE\s+/i, "");
+        if (!whereClause) {
+          throw new MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_INVALID_FILTER",
+            text: "Filter produced empty WHERE clause",
+            domain: ErrorDomain.MASTRA_VECTOR,
+            category: ErrorCategory.USER,
+            details: { indexName, filter: JSON.stringify(filter) }
+          });
+        }
+        whereClause = whereClause.replace(/\$(\d+)/g, (match, num) => {
+          const newIndex = parseInt(num) + valueIndex - 1;
+          return `$${newIndex}`;
+        });
+        whereValues = filterValues;
+      }
       const query = `
         UPDATE ${tableName}
         SET ${updateParts.join(", ")}
-        WHERE vector_id = $1
+        WHERE ${whereClause}
       `;
-      await client.query(query, values);
+      const result = await client.query(query, [...values, ...whereValues]);
+      this.logger?.info(`Updated ${result.rowCount || 0} vectors in ${indexName}`, {
+        indexName,
+        id: id ? id : void 0,
+        filter: filter ? filter : void 0,
+        updatedCount: result.rowCount || 0
+      });
     } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
       const mastraError = new MastraError(
         {
           id: "MASTRA_STORAGE_PG_VECTOR_UPDATE_VECTOR_FAILED",
@@ -1248,7 +1416,8 @@ var PgVector = class extends MastraVector {
           category: ErrorCategory.THIRD_PARTY,
           details: {
             indexName,
-            id
+            ...id && { id },
+            ...filter && { filter: JSON.stringify(filter) }
           }
         },
         error
@@ -1295,6 +1464,106 @@ var PgVector = class extends MastraVector {
       client?.release();
     }
   }
+  /**
+   * Delete vectors matching a metadata filter.
+   * @param indexName - The name of the index containing the vectors.
+   * @param filter - The filter to match vectors for deletion.
+   * @returns A promise that resolves when the deletion is complete.
+   * @throws Will throw an error if the deletion operation fails.
+   */
+  async deleteVectors({ indexName, filter, ids }) {
+    let client;
+    try {
+      client = await this.pool.connect();
+      const { tableName } = this.getTableName(indexName);
+      if (!filter && !ids) {
+        throw new MastraError({
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_MISSING_PARAMS",
+          text: "Either filter or ids must be provided",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.USER,
+          details: { indexName }
+        });
+      }
+      if (filter && ids) {
+        throw new MastraError({
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_CONFLICTING_PARAMS",
+          text: "Cannot provide both filter and ids - they are mutually exclusive",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.USER,
+          details: { indexName }
+        });
+      }
+      let query;
+      let values;
+      if (ids) {
+        if (ids.length === 0) {
+          throw new MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_DELETE_EMPTY_IDS",
+            text: "Cannot delete with empty ids array",
+            domain: ErrorDomain.MASTRA_VECTOR,
+            category: ErrorCategory.USER,
+            details: { indexName }
+          });
+        }
+        const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
+        query = `DELETE FROM ${tableName} WHERE vector_id IN (${placeholders})`;
+        values = ids;
+      } else {
+        if (!filter || Object.keys(filter).length === 0) {
+          throw new MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_DELETE_EMPTY_FILTER",
+            text: "Cannot delete with empty filter. Use deleteIndex to delete all vectors.",
+            domain: ErrorDomain.MASTRA_VECTOR,
+            category: ErrorCategory.USER,
+            details: { indexName }
+          });
+        }
+        const translatedFilter = this.transformFilter(filter);
+        const { sql: filterQuery, values: filterValues } = buildDeleteFilterQuery(translatedFilter);
+        const whereClause = filterQuery.trim().replace(/^WHERE\s+/i, "");
+        if (!whereClause) {
+          throw new MastraError({
+            id: "MASTRA_STORAGE_PG_VECTOR_DELETE_INVALID_FILTER",
+            text: "Filter produced empty WHERE clause",
+            domain: ErrorDomain.MASTRA_VECTOR,
+            category: ErrorCategory.USER,
+            details: { indexName, filter: JSON.stringify(filter) }
+          });
+        }
+        query = `DELETE FROM ${tableName} WHERE ${whereClause}`;
+        values = filterValues;
+      }
+      const result = await client.query(query, values);
+      this.logger?.info(`Deleted ${result.rowCount || 0} vectors from ${indexName}`, {
+        indexName,
+        filter: filter ? filter : void 0,
+        ids: ids ? ids : void 0,
+        deletedCount: result.rowCount || 0
+      });
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_PG_VECTOR_DELETE_VECTORS_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            ...filter && { filter: JSON.stringify(filter) },
+            ...ids && { idsCount: ids.length }
+          }
+        },
+        error
+      );
+      this.logger?.trackException(mastraError);
+      throw mastraError;
+    } finally {
+      client?.release();
+    }
+  }
 };
 function getSchemaName(schema) {
   return schema ? `"${parseSqlIdentifier(schema, "schema name")}"` : void 0;
@@ -1616,6 +1885,20 @@ var MemoryPG = class extends MemoryStorage {
       const threadTableName = getTableName({ indexName: TABLE_THREADS, schemaName: getSchemaName(this.schema) });
       await this.client.tx(async (t) => {
         await t.none(`DELETE FROM ${tableName} WHERE thread_id = $1`, [threadId]);
+        const schemaName = this.schema || "public";
+        const vectorTables = await t.manyOrNone(
+          `
+          SELECT tablename 
+          FROM pg_tables 
+          WHERE schemaname = $1 
+          AND (tablename = 'memory_messages' OR tablename LIKE 'memory_messages_%')
+        `,
+          [schemaName]
+        );
+        for (const { tablename } of vectorTables) {
+          const vectorTableName = getTableName({ indexName: tablename, schemaName: getSchemaName(this.schema) });
+          await t.none(`DELETE FROM ${vectorTableName} WHERE metadata->>'thread_id' = $1`, [threadId]);
+        }
         await t.none(`DELETE FROM ${threadTableName} WHERE id = $1`, [threadId]);
       });
     } catch (error) {
@@ -1632,28 +1915,26 @@ var MemoryPG = class extends MemoryStorage {
       );
     }
   }
-  async _getIncludedMessages({
-    threadId,
-    include
-  }) {
-    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-    if (!include) return null;
+  async _getIncludedMessages({ include }) {
+    if (!include || include.length === 0) return null;
     const unionQueries = [];
     const params = [];
     let paramIdx = 1;
     const tableName = getTableName({ indexName: TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
     for (const inc of include) {
       const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      const searchId = inc.threadId || threadId;
       unionQueries.push(
         `
             SELECT * FROM (
-              WITH ordered_messages AS (
+              WITH target_thread AS (
+                SELECT thread_id FROM ${tableName} WHERE id = $${paramIdx}
+              ),
+              ordered_messages AS (
                 SELECT 
                   *,
                   ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
                 FROM ${tableName}
-                WHERE thread_id = $${paramIdx}
+                WHERE thread_id = (SELECT thread_id FROM target_thread)
               )
               SELECT
                 m.id,
@@ -1665,24 +1946,24 @@ var MemoryPG = class extends MemoryStorage {
                 m.thread_id AS "threadId",
                 m."resourceId"
               FROM ordered_messages m
-              WHERE m.id = $${paramIdx + 1}
+              WHERE m.id = $${paramIdx}
               OR EXISTS (
                 SELECT 1 FROM ordered_messages target
-                WHERE target.id = $${paramIdx + 1}
+                WHERE target.id = $${paramIdx}
                 AND (
                   -- Get previous messages (messages that come BEFORE the target)
-                  (m.row_num < target.row_num AND m.row_num >= target.row_num - $${paramIdx + 2})
+                  (m.row_num < target.row_num AND m.row_num >= target.row_num - $${paramIdx + 1})
                   OR
                   -- Get next messages (messages that come AFTER the target)
-                  (m.row_num > target.row_num AND m.row_num <= target.row_num + $${paramIdx + 3})
+                  (m.row_num > target.row_num AND m.row_num <= target.row_num + $${paramIdx + 2})
                 )
               )
             ) AS query_${paramIdx}
             `
         // Keep ASC for final sorting after fetching context
       );
-      params.push(searchId, id, withPreviousMessages, withNextMessages);
-      paramIdx += 4;
+      params.push(id, withPreviousMessages, withNextMessages);
+      paramIdx += 3;
     }
     const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
     const includedRows = await this.client.manyOrNone(finalQuery, params);
@@ -1746,15 +2027,18 @@ var MemoryPG = class extends MemoryStorage {
   }
   async listMessages(args) {
     const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    if (!threadId.trim()) {
+    const threadIds = (Array.isArray(threadId) ? threadId : [threadId]).filter(
+      (id) => typeof id === "string"
+    );
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
       throw new MastraError(
         {
           id: "STORAGE_PG_LIST_MESSAGES_INVALID_THREAD_ID",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { threadId: Array.isArray(threadId) ? String(threadId) : String(threadId) }
         },
-        new Error("threadId must be a non-empty string")
+        new Error("threadId must be a non-empty string or array of non-empty strings")
       );
     }
     if (page < 0) {
@@ -1764,7 +2048,7 @@ var MemoryPG = class extends MemoryStorage {
         category: ErrorCategory.USER,
         text: "Page number must be non-negative",
         details: {
-          threadId,
+          threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
           page
         }
       });
@@ -1776,9 +2060,10 @@ var MemoryPG = class extends MemoryStorage {
       const orderByStatement = `ORDER BY "${field}" ${direction}`;
       const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
       const tableName = getTableName({ indexName: TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
-      const conditions = [`thread_id = $1`];
-      const queryParams = [threadId];
-      let paramIndex = 2;
+      const threadPlaceholders = threadIds.map((_, i) => `$${i + 1}`).join(", ");
+      const conditions = [`thread_id IN (${threadPlaceholders})`];
+      const queryParams = [...threadIds];
+      let paramIndex = threadIds.length + 1;
       if (resourceId) {
         conditions.push(`"resourceId" = $${paramIndex++}`);
         queryParams.push(resourceId);
@@ -1810,7 +2095,7 @@ var MemoryPG = class extends MemoryStorage {
       }
       const messageIds = new Set(messages.map((m) => m.id));
       if (include && include.length > 0) {
-        const includeMessages = await this._getIncludedMessages({ threadId, include });
+        const includeMessages = await this._getIncludedMessages({ include });
         if (includeMessages) {
           for (const includeMsg of includeMessages) {
             if (!messageIds.has(includeMsg.id)) {
@@ -1837,7 +2122,10 @@ var MemoryPG = class extends MemoryStorage {
         }
         return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
       });
-      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const threadIdSet = new Set(threadIds);
+      const returnedThreadMessageIds = new Set(
+        finalMessages.filter((m) => m.threadId && threadIdSet.has(m.threadId)).map((m) => m.id)
+      );
       const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
       const hasMore = perPageInput !== false && !allThreadMessagesReturned && offset + perPage < total;
       return {
@@ -1854,7 +2142,7 @@ var MemoryPG = class extends MemoryStorage {
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            threadId,
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
             resourceId: resourceId ?? ""
           }
         },
@@ -3309,20 +3597,12 @@ var StoreOperationsPG = class extends StoreOperations {
   }
 };
 function transformScoreRow(row) {
-  return {
-    ...row,
-    input: safelyParseJSON(row.input),
-    scorer: safelyParseJSON(row.scorer),
-    preprocessStepResult: safelyParseJSON(row.preprocessStepResult),
-    analyzeStepResult: safelyParseJSON(row.analyzeStepResult),
-    metadata: safelyParseJSON(row.metadata),
-    output: safelyParseJSON(row.output),
-    additionalContext: safelyParseJSON(row.additionalContext),
-    requestContext: safelyParseJSON(row.requestContext),
-    entity: safelyParseJSON(row.entity),
-    createdAt: row.createdAtZ || row.createdAt,
-    updatedAt: row.updatedAtZ || row.updatedAt
-  };
+  return transformScoreRow$1(row, {
+    preferredTimestampFields: {
+      createdAt: "createdAtZ",
+      updatedAt: "updatedAtZ"
+    }
+  });
 }
 var ScoresPG = class extends ScoresStorage {
   client;
@@ -3469,8 +3749,6 @@ var ScoresPG = class extends ScoresStorage {
           scorer: scorer ? JSON.stringify(scorer) : null,
           preprocessStepResult: preprocessStepResult ? JSON.stringify(preprocessStepResult) : null,
           analyzeStepResult: analyzeStepResult ? JSON.stringify(analyzeStepResult) : null,
-          metadata: metadata ? JSON.stringify(metadata) : null,
-          additionalContext: additionalContext ? JSON.stringify(additionalContext) : null,
           requestContext: requestContext ? JSON.stringify(requestContext) : null,
           entity: entity ? JSON.stringify(entity) : null,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),