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

package/dist/index.js

@@ -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) {
@@ -633,11 +718,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 +758,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 +1320,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 +1358,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 +1419,8 @@ var PgVector = class extends MastraVector {
           category: ErrorCategory.THIRD_PARTY,
           details: {
             indexName,
-            id
+            ...id && { id },
+            ...filter && { filter: JSON.stringify(filter) }
           }
         },
         error
@@ -1295,6 +1467,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;