@mastra/vectorize 0.10.2-alpha.1 → 0.10.3-alpha.0

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var error = require('@mastra/core/error');
 var vector = require('@mastra/core/vector');
 var Cloudflare = require('cloudflare');
 var filter = require('@mastra/core/vector/filter');
@@ -86,17 +87,29 @@ var CloudflareVector = class extends vector.MastraVector {
         metadata: metadata?.[index]
       })
     ).join("\n");
-    await this.client.vectorize.indexes.upsert(
-      indexName,
-      {
-        account_id: this.accountId,
-        body: ndjson
-      },
-      {
-        __binaryRequest: true
-      }
-    );
-    return generatedIds;
+    try {
+      await this.client.vectorize.indexes.upsert(
+        indexName,
+        {
+          account_id: this.accountId,
+          body: ndjson
+        },
+        {
+          __binaryRequest: true
+        }
+      );
+      return generatedIds;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, vectorCount: vectors?.length }
+        },
+        error$1
+      );
+    }
   }
   transformFilter(filter) {
     const translator = new VectorizeFilterTranslator();
@@ -112,13 +125,21 @@ var CloudflareVector = class extends vector.MastraVector {
         },
         name: indexName
       });
-    } catch (error) {
-      const message = error?.errors?.[0]?.message || error?.message;
-      if (error.status === 409 || typeof message === "string" && (message.toLowerCase().includes("already exists") || message.toLowerCase().includes("duplicate"))) {
+    } catch (error$1) {
+      const message = error$1?.errors?.[0]?.message || error$1?.message;
+      if (error$1.status === 409 || typeof message === "string" && (message.toLowerCase().includes("already exists") || message.toLowerCase().includes("duplicate"))) {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
-      throw error;
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_CREATE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, dimension, metric }
+        },
+        error$1
+      );
     }
   }
   async query({
@@ -128,29 +149,52 @@ var CloudflareVector = class extends vector.MastraVector {
     filter,
     includeVector = false
   }) {
-    const translatedFilter = this.transformFilter(filter) ?? {};
-    const response = await this.client.vectorize.indexes.query(indexName, {
-      account_id: this.accountId,
-      vector: queryVector,
-      returnValues: includeVector,
-      returnMetadata: "all",
-      topK,
-      filter: translatedFilter
-    });
-    return response?.matches?.map((match) => {
-      return {
-        id: match.id,
-        metadata: match.metadata,
-        score: match.score,
-        vector: match.values
-      };
-    }) || [];
+    try {
+      const translatedFilter = this.transformFilter(filter) ?? {};
+      const response = await this.client.vectorize.indexes.query(indexName, {
+        account_id: this.accountId,
+        vector: queryVector,
+        returnValues: includeVector,
+        returnMetadata: "all",
+        topK,
+        filter: translatedFilter
+      });
+      return response?.matches?.map((match) => {
+        return {
+          id: match.id,
+          metadata: match.metadata,
+          score: match.score,
+          vector: match.values
+        };
+      }) || [];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, topK }
+        },
+        error$1
+      );
+    }
   }
   async listIndexes() {
-    const res = await this.client.vectorize.indexes.list({
-      account_id: this.accountId
-    });
-    return res?.result?.map((index) => index.name) || [];
+    try {
+      const res = await this.client.vectorize.indexes.list({
+        account_id: this.accountId
+      });
+      return res?.result?.map((index) => index.name) || [];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -159,43 +203,103 @@ var CloudflareVector = class extends vector.MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName }) {
-    const index = await this.client.vectorize.indexes.get(indexName, {
-      account_id: this.accountId
-    });
-    const described = await this.client.vectorize.indexes.info(indexName, {
-      account_id: this.accountId
-    });
-    return {
-      dimension: described?.dimensions,
-      // Since vector_count is not available in the response,
-      // we might need a separate API call to get the count if needed
-      count: described?.vectorCount || 0,
-      metric: index?.config?.metric
-    };
+    try {
+      const index = await this.client.vectorize.indexes.get(indexName, {
+        account_id: this.accountId
+      });
+      const described = await this.client.vectorize.indexes.info(indexName, {
+        account_id: this.accountId
+      });
+      return {
+        dimension: described?.dimensions,
+        // Since vector_count is not available in the response,
+        // we might need a separate API call to get the count if needed
+        count: described?.vectorCount || 0,
+        metric: index?.config?.metric
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
   }
   async deleteIndex({ indexName }) {
-    await this.client.vectorize.indexes.delete(indexName, {
-      account_id: this.accountId
-    });
+    try {
+      await this.client.vectorize.indexes.delete(indexName, {
+        account_id: this.accountId
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
   }
   async createMetadataIndex(indexName, propertyName, indexType) {
-    await this.client.vectorize.indexes.metadataIndex.create(indexName, {
-      account_id: this.accountId,
-      propertyName,
-      indexType
-    });
+    try {
+      await this.client.vectorize.indexes.metadataIndex.create(indexName, {
+        account_id: this.accountId,
+        propertyName,
+        indexType
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_CREATE_METADATA_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, propertyName, indexType }
+        },
+        error$1
+      );
+    }
   }
   async deleteMetadataIndex(indexName, propertyName) {
-    await this.client.vectorize.indexes.metadataIndex.delete(indexName, {
-      account_id: this.accountId,
-      propertyName
-    });
+    try {
+      await this.client.vectorize.indexes.metadataIndex.delete(indexName, {
+        account_id: this.accountId,
+        propertyName
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_DELETE_METADATA_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, propertyName }
+        },
+        error$1
+      );
+    }
   }
   async listMetadataIndexes(indexName) {
-    const res = await this.client.vectorize.indexes.metadataIndex.list(indexName, {
-      account_id: this.accountId
-    });
-    return res?.metadataIndexes ?? [];
+    try {
+      const res = await this.client.vectorize.indexes.metadataIndex.list(indexName, {
+        account_id: this.accountId
+      });
+      return res?.metadataIndexes ?? [];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_LIST_METADATA_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
@@ -208,10 +312,16 @@ var CloudflareVector = class extends vector.MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }) {
+    if (!update.vector && !update.metadata) {
+      throw new error.MastraError({
+        id: "STORAGE_VECTORIZE_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "No update data provided",
+        details: { indexName, id }
+      });
+    }
     try {
-      if (!update.vector && !update.metadata) {
-        throw new Error("No update data provided");
-      }
       const updatePayload = {
         };
       if (update.vector) {
@@ -221,8 +331,16 @@ var CloudflareVector = class extends vector.MastraVector {
         updatePayload.metadata = [update.metadata];
       }
       await this.upsert({ indexName, vectors: updatePayload.vectors, metadata: updatePayload.metadata });
-    } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -238,8 +356,16 @@ var CloudflareVector = class extends vector.MastraVector {
         ids: [id],
         account_id: this.accountId
       });
-    } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_DELETE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error$1
+      );
     }
   }
 };

package/dist/index.js

@@ -1,3 +1,4 @@
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import Cloudflare from 'cloudflare';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
@@ -80,17 +81,29 @@ var CloudflareVector = class extends MastraVector {
         metadata: metadata?.[index]
       })
     ).join("\n");
-    await this.client.vectorize.indexes.upsert(
-      indexName,
-      {
-        account_id: this.accountId,
-        body: ndjson
-      },
-      {
-        __binaryRequest: true
-      }
-    );
-    return generatedIds;
+    try {
+      await this.client.vectorize.indexes.upsert(
+        indexName,
+        {
+          account_id: this.accountId,
+          body: ndjson
+        },
+        {
+          __binaryRequest: true
+        }
+      );
+      return generatedIds;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_UPSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, vectorCount: vectors?.length }
+        },
+        error
+      );
+    }
   }
   transformFilter(filter) {
     const translator = new VectorizeFilterTranslator();
@@ -112,7 +125,15 @@ var CloudflareVector = class extends MastraVector {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_CREATE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, dimension, metric }
+        },
+        error
+      );
     }
   }
   async query({
@@ -122,29 +143,52 @@ var CloudflareVector = class extends MastraVector {
     filter,
     includeVector = false
   }) {
-    const translatedFilter = this.transformFilter(filter) ?? {};
-    const response = await this.client.vectorize.indexes.query(indexName, {
-      account_id: this.accountId,
-      vector: queryVector,
-      returnValues: includeVector,
-      returnMetadata: "all",
-      topK,
-      filter: translatedFilter
-    });
-    return response?.matches?.map((match) => {
-      return {
-        id: match.id,
-        metadata: match.metadata,
-        score: match.score,
-        vector: match.values
-      };
-    }) || [];
+    try {
+      const translatedFilter = this.transformFilter(filter) ?? {};
+      const response = await this.client.vectorize.indexes.query(indexName, {
+        account_id: this.accountId,
+        vector: queryVector,
+        returnValues: includeVector,
+        returnMetadata: "all",
+        topK,
+        filter: translatedFilter
+      });
+      return response?.matches?.map((match) => {
+        return {
+          id: match.id,
+          metadata: match.metadata,
+          score: match.score,
+          vector: match.values
+        };
+      }) || [];
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_QUERY_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, topK }
+        },
+        error
+      );
+    }
   }
   async listIndexes() {
-    const res = await this.client.vectorize.indexes.list({
-      account_id: this.accountId
-    });
-    return res?.result?.map((index) => index.name) || [];
+    try {
+      const res = await this.client.vectorize.indexes.list({
+        account_id: this.accountId
+      });
+      return res?.result?.map((index) => index.name) || [];
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_LIST_INDEXES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -153,43 +197,103 @@ var CloudflareVector = class extends MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName }) {
-    const index = await this.client.vectorize.indexes.get(indexName, {
-      account_id: this.accountId
-    });
-    const described = await this.client.vectorize.indexes.info(indexName, {
-      account_id: this.accountId
-    });
-    return {
-      dimension: described?.dimensions,
-      // Since vector_count is not available in the response,
-      // we might need a separate API call to get the count if needed
-      count: described?.vectorCount || 0,
-      metric: index?.config?.metric
-    };
+    try {
+      const index = await this.client.vectorize.indexes.get(indexName, {
+        account_id: this.accountId
+      });
+      const described = await this.client.vectorize.indexes.info(indexName, {
+        account_id: this.accountId
+      });
+      return {
+        dimension: described?.dimensions,
+        // Since vector_count is not available in the response,
+        // we might need a separate API call to get the count if needed
+        count: described?.vectorCount || 0,
+        metric: index?.config?.metric
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   async deleteIndex({ indexName }) {
-    await this.client.vectorize.indexes.delete(indexName, {
-      account_id: this.accountId
-    });
+    try {
+      await this.client.vectorize.indexes.delete(indexName, {
+        account_id: this.accountId
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_DELETE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   async createMetadataIndex(indexName, propertyName, indexType) {
-    await this.client.vectorize.indexes.metadataIndex.create(indexName, {
-      account_id: this.accountId,
-      propertyName,
-      indexType
-    });
+    try {
+      await this.client.vectorize.indexes.metadataIndex.create(indexName, {
+        account_id: this.accountId,
+        propertyName,
+        indexType
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_CREATE_METADATA_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, propertyName, indexType }
+        },
+        error
+      );
+    }
   }
   async deleteMetadataIndex(indexName, propertyName) {
-    await this.client.vectorize.indexes.metadataIndex.delete(indexName, {
-      account_id: this.accountId,
-      propertyName
-    });
+    try {
+      await this.client.vectorize.indexes.metadataIndex.delete(indexName, {
+        account_id: this.accountId,
+        propertyName
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_DELETE_METADATA_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, propertyName }
+        },
+        error
+      );
+    }
   }
   async listMetadataIndexes(indexName) {
-    const res = await this.client.vectorize.indexes.metadataIndex.list(indexName, {
-      account_id: this.accountId
-    });
-    return res?.metadataIndexes ?? [];
+    try {
+      const res = await this.client.vectorize.indexes.metadataIndex.list(indexName, {
+        account_id: this.accountId
+      });
+      return res?.metadataIndexes ?? [];
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_LIST_METADATA_INDEXES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
@@ -202,10 +306,16 @@ var CloudflareVector = class extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }) {
+    if (!update.vector && !update.metadata) {
+      throw new MastraError({
+        id: "STORAGE_VECTORIZE_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "No update data provided",
+        details: { indexName, id }
+      });
+    }
     try {
-      if (!update.vector && !update.metadata) {
-        throw new Error("No update data provided");
-      }
       const updatePayload = {
         };
       if (update.vector) {
@@ -216,7 +326,15 @@ var CloudflareVector = class extends MastraVector {
       }
       await this.upsert({ indexName, vectors: updatePayload.vectors, metadata: updatePayload.metadata });
     } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
   /**
@@ -233,7 +351,15 @@ var CloudflareVector = class extends MastraVector {
         account_id: this.accountId
       });
     } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_VECTORIZE_VECTOR_DELETE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/vectorize",
-  "version": "0.10.2-alpha.1",
+  "version": "0.10.3-alpha.0",
   "description": "Cloudflare Vectorize store provider for Mastra",
   "type": "module",
   "files": [
@@ -27,14 +27,14 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.8",
-    "@types/node": "^20.17.57",
+    "@types/node": "^20.19.0",
     "dotenv": "^16.5.0",
     "eslint": "^9.28.0",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.2.2",
-    "@internal/lint": "0.0.10",
-    "@mastra/core": "0.10.4-alpha.3"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
+    "@internal/lint": "0.0.13",
+    "@mastra/core": "0.10.7-alpha.1"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"