@mastra/couchbase 0.10.3 → 0.10.4-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/couchbase@0.10.3-alpha.0 build /home/runner/work/mastra/mastra/stores/couchbase
+> @mastra/couchbase@0.10.4-alpha.0 build /home/runner/work/mastra/mastra/stores/couchbase
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 6586ms
+TSC ⚡️ Build success in 7500ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/couchbase/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/couchbase/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 9396ms
+DTS ⚡️ Build success in 9034ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 10.84 KB
-ESM ⚡️ Build success in 610ms
-CJS dist/index.cjs 10.90 KB
-CJS ⚡️ Build success in 610ms
+CJS dist/index.cjs 14.55 KB
+CJS ⚡️ Build success in 690ms
+ESM dist/index.js 14.29 KB
+ESM ⚡️ Build success in 699ms

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @mastra/couchbase
 
+## 0.10.4-alpha.0
+
+### Patch Changes
+
+- 0e17048: Throw mastra errors in storage packages
+- Updated dependencies [d1baedb]
+- Updated dependencies [4d21bf2]
+- Updated dependencies [2097952]
+- Updated dependencies [4fb0cc2]
+- Updated dependencies [d2a7a31]
+- Updated dependencies [0e17048]
+  - @mastra/core@0.10.7-alpha.1
+
 ## 0.10.3
 
 ### Patch Changes

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var error = require('@mastra/core/error');
 var vector = require('@mastra/core/vector');
 var couchbase = require('couchbase');
 
@@ -21,26 +22,45 @@ var CouchbaseVector = class extends vector.MastraVector {
   vector_dimension;
   constructor({ connectionString, username, password, bucketName, scopeName, collectionName }) {
     super();
-    const baseClusterPromise = couchbase.connect(connectionString, {
-      username,
-      password,
-      configProfile: "wanDevelopment"
-    });
-    const telemetry = this.__getTelemetry();
-    this.clusterPromise = telemetry?.traceClass(baseClusterPromise, {
-      spanNamePrefix: "couchbase-vector",
-      attributes: {
-        "vector.type": "couchbase"
-      }
-    }) ?? baseClusterPromise;
-    this.cluster = null;
-    this.bucketName = bucketName;
-    this.collectionName = collectionName;
-    this.scopeName = scopeName;
-    this.collection = null;
-    this.bucket = null;
-    this.scope = null;
-    this.vector_dimension = null;
+    try {
+      const baseClusterPromise = couchbase.connect(connectionString, {
+        username,
+        password,
+        configProfile: "wanDevelopment"
+      });
+      const telemetry = this.__getTelemetry();
+      this.clusterPromise = telemetry?.traceClass(baseClusterPromise, {
+        spanNamePrefix: "couchbase-vector",
+        attributes: {
+          "vector.type": "couchbase"
+        }
+      }) ?? baseClusterPromise;
+      this.cluster = null;
+      this.bucketName = bucketName;
+      this.collectionName = collectionName;
+      this.scopeName = scopeName;
+      this.collection = null;
+      this.bucket = null;
+      this.scope = null;
+      this.vector_dimension = null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_INITIALIZE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            connectionString,
+            username,
+            password,
+            bucketName,
+            scopeName,
+            collectionName
+          }
+        },
+        error$1
+      );
+    }
   }
   async getCollection() {
     if (!this.cluster) {
@@ -54,11 +74,11 @@ var CouchbaseVector = class extends vector.MastraVector {
     return this.collection;
   }
   async createIndex({ indexName, dimension, metric = "dotproduct" }) {
-    await this.getCollection();
-    if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
-    }
     try {
+      await this.getCollection();
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
       await this.scope.searchIndexes().upsertIndex({
         name: indexName,
         sourceName: this.bucketName,
@@ -139,84 +159,135 @@ var CouchbaseVector = class extends vector.MastraVector {
         }
       });
       this.vector_dimension = dimension;
-    } catch (error) {
-      const message = error?.message || error?.toString();
+    } catch (error$1) {
+      const message = error$1?.message || error$1?.toString();
       if (message && message.toLowerCase().includes("index exists")) {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
-      throw error;
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_CREATE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            dimension,
+            metric
+          }
+        },
+        error$1
+      );
     }
   }
   async upsert({ vectors, metadata, ids }) {
-    await this.getCollection();
-    if (!vectors || vectors.length === 0) {
-      throw new Error("No vectors provided");
-    }
-    if (this.vector_dimension) {
-      for (const vector of vectors) {
-        if (!vector || this.vector_dimension !== vector.length) {
-          throw new Error("Vector dimension mismatch");
+    try {
+      await this.getCollection();
+      if (!vectors || vectors.length === 0) {
+        throw new Error("No vectors provided");
+      }
+      if (this.vector_dimension) {
+        for (const vector of vectors) {
+          if (!vector || this.vector_dimension !== vector.length) {
+            throw new Error("Vector dimension mismatch");
+          }
         }
       }
-    }
-    const pointIds = ids || vectors.map(() => crypto.randomUUID());
-    const records = vectors.map((vector, i) => {
-      const metadataObj = metadata?.[i] || {};
-      const record = {
-        embedding: vector,
-        metadata: metadataObj
-      };
-      if (metadataObj.text) {
-        record.content = metadataObj.text;
+      const pointIds = ids || vectors.map(() => crypto.randomUUID());
+      const records = vectors.map((vector, i) => {
+        const metadataObj = metadata?.[i] || {};
+        const record = {
+          embedding: vector,
+          metadata: metadataObj
+        };
+        if (metadataObj.text) {
+          record.content = metadataObj.text;
+        }
+        return record;
+      });
+      const allPromises = [];
+      for (let i = 0; i < records.length; i++) {
+        allPromises.push(this.collection.upsert(pointIds[i], records[i]));
       }
-      return record;
-    });
-    const allPromises = [];
-    for (let i = 0; i < records.length; i++) {
-      allPromises.push(this.collection.upsert(pointIds[i], records[i]));
+      await Promise.all(allPromises);
+      return pointIds;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
     }
-    await Promise.all(allPromises);
-    return pointIds;
   }
   async query({ indexName, queryVector, topK = 10, includeVector = false }) {
-    await this.getCollection();
-    const index_stats = await this.describeIndex({ indexName });
-    if (queryVector.length !== index_stats.dimension) {
-      throw new Error(`Query vector dimension mismatch. Expected ${index_stats.dimension}, got ${queryVector.length}`);
-    }
-    let request = couchbase.SearchRequest.create(
-      couchbase.VectorSearch.fromVectorQuery(couchbase.VectorQuery.create("embedding", queryVector).numCandidates(topK))
-    );
-    const results = await this.scope.search(indexName, request, {
-      fields: ["*"]
-    });
-    if (includeVector) {
-      throw new Error("Including vectors in search results is not yet supported by the Couchbase vector store");
-    }
-    const output = [];
-    for (const match of results.rows) {
-      const cleanedMetadata = {};
-      const fields = match.fields || {};
-      for (const key in fields) {
-        if (Object.prototype.hasOwnProperty.call(fields, key)) {
-          const newKey = key.startsWith("metadata.") ? key.substring("metadata.".length) : key;
-          cleanedMetadata[newKey] = fields[key];
-        }
+    try {
+      await this.getCollection();
+      const index_stats = await this.describeIndex({ indexName });
+      if (queryVector.length !== index_stats.dimension) {
+        throw new Error(
+          `Query vector dimension mismatch. Expected ${index_stats.dimension}, got ${queryVector.length}`
+        );
       }
-      output.push({
-        id: match.id,
-        score: match.score || 0,
-        metadata: cleanedMetadata
-        // Use the cleaned metadata object
+      let request = couchbase.SearchRequest.create(
+        couchbase.VectorSearch.fromVectorQuery(couchbase.VectorQuery.create("embedding", queryVector).numCandidates(topK))
+      );
+      const results = await this.scope.search(indexName, request, {
+        fields: ["*"]
       });
+      if (includeVector) {
+        throw new Error("Including vectors in search results is not yet supported by the Couchbase vector store");
+      }
+      const output = [];
+      for (const match of results.rows) {
+        const cleanedMetadata = {};
+        const fields = match.fields || {};
+        for (const key in fields) {
+          if (Object.prototype.hasOwnProperty.call(fields, key)) {
+            const newKey = key.startsWith("metadata.") ? key.substring("metadata.".length) : key;
+            cleanedMetadata[newKey] = fields[key];
+          }
+        }
+        output.push({
+          id: match.id,
+          score: match.score || 0,
+          metadata: cleanedMetadata
+          // Use the cleaned metadata object
+        });
+      }
+      return output;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            topK
+          }
+        },
+        error$1
+      );
     }
-    return output;
   }
   async listIndexes() {
-    await this.getCollection();
-    const indexes = await this.scope.searchIndexes().getAllIndexes();
-    return indexes?.map((index) => index.name) || [];
+    try {
+      await this.getCollection();
+      const indexes = await this.scope.searchIndexes().getAllIndexes();
+      return indexes?.map((index) => index.name) || [];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -225,29 +296,60 @@ var CouchbaseVector = class extends vector.MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName }) {
-    await this.getCollection();
-    if (!(await this.listIndexes()).includes(indexName)) {
-      throw new Error(`Index ${indexName} does not exist`);
+    try {
+      await this.getCollection();
+      if (!(await this.listIndexes()).includes(indexName)) {
+        throw new Error(`Index ${indexName} does not exist`);
+      }
+      const index = await this.scope.searchIndexes().getIndex(indexName);
+      const dimensions = index.params.mapping?.types?.[`${this.scopeName}.${this.collectionName}`]?.properties?.embedding?.fields?.[0]?.dims;
+      const count = -1;
+      const metric = index.params.mapping?.types?.[`${this.scopeName}.${this.collectionName}`]?.properties?.embedding?.fields?.[0]?.similarity;
+      return {
+        dimension: dimensions,
+        count,
+        metric: Object.keys(DISTANCE_MAPPING).find(
+          (key) => DISTANCE_MAPPING[key] === metric
+        )
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
     }
-    const index = await this.scope.searchIndexes().getIndex(indexName);
-    const dimensions = index.params.mapping?.types?.[`${this.scopeName}.${this.collectionName}`]?.properties?.embedding?.fields?.[0]?.dims;
-    const count = -1;
-    const metric = index.params.mapping?.types?.[`${this.scopeName}.${this.collectionName}`]?.properties?.embedding?.fields?.[0]?.similarity;
-    return {
-      dimension: dimensions,
-      count,
-      metric: Object.keys(DISTANCE_MAPPING).find(
-        (key) => DISTANCE_MAPPING[key] === metric
-      )
-    };
   }
   async deleteIndex({ indexName }) {
-    await this.getCollection();
-    if (!(await this.listIndexes()).includes(indexName)) {
-      throw new Error(`Index ${indexName} does not exist`);
+    try {
+      await this.getCollection();
+      if (!(await this.listIndexes()).includes(indexName)) {
+        throw new Error(`Index ${indexName} does not exist`);
+      }
+      await this.scope.searchIndexes().dropIndex(indexName);
+      this.vector_dimension = null;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
     }
-    await this.scope.searchIndexes().dropIndex(indexName);
-    this.vector_dimension = null;
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
@@ -260,25 +362,41 @@ var CouchbaseVector = class extends vector.MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ id, update }) {
-    if (!update.vector && !update.metadata) {
-      throw new Error("No updates provided");
-    }
-    if (update.vector && this.vector_dimension && update.vector.length !== this.vector_dimension) {
-      throw new Error("Vector dimension mismatch");
-    }
-    const collection = await this.getCollection();
     try {
-      await collection.get(id);
-    } catch (err) {
-      if (err.code === 13 || err.message?.includes("document not found")) {
-        throw new Error(`Vector with id ${id} does not exist`);
+      if (!update.vector && !update.metadata) {
+        throw new Error("No updates provided");
+      }
+      if (update.vector && this.vector_dimension && update.vector.length !== this.vector_dimension) {
+        throw new Error("Vector dimension mismatch");
+      }
+      const collection = await this.getCollection();
+      try {
+        await collection.get(id);
+      } catch (err) {
+        if (err.code === 13 || err.message?.includes("document not found")) {
+          throw new Error(`Vector with id ${id} does not exist`);
+        }
+        throw err;
       }
-      throw err;
+      const specs = [];
+      if (update.vector) specs.push(couchbase.MutateInSpec.replace("embedding", update.vector));
+      if (update.metadata) specs.push(couchbase.MutateInSpec.replace("metadata", update.metadata));
+      await collection.mutateIn(id, specs);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_UPDATE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            id,
+            hasVectorUpdate: !!update.vector,
+            hasMetadataUpdate: !!update.metadata
+          }
+        },
+        error$1
+      );
     }
-    const specs = [];
-    if (update.vector) specs.push(couchbase.MutateInSpec.replace("embedding", update.vector));
-    if (update.metadata) specs.push(couchbase.MutateInSpec.replace("metadata", update.metadata));
-    await collection.mutateIn(id, specs);
   }
   /**
    * Deletes a vector by its ID.
@@ -288,22 +406,47 @@ var CouchbaseVector = class extends vector.MastraVector {
    * @throws Will throw an error if the deletion operation fails.
    */
   async deleteVector({ id }) {
-    const collection = await this.getCollection();
     try {
-      await collection.get(id);
-    } catch (err) {
-      if (err.code === 13 || err.message?.includes("document not found")) {
-        throw new Error(`Vector with id ${id} does not exist`);
+      const collection = await this.getCollection();
+      try {
+        await collection.get(id);
+      } catch (err) {
+        if (err.code === 13 || err.message?.includes("document not found")) {
+          throw new Error(`Vector with id ${id} does not exist`);
+        }
+        throw err;
       }
-      throw err;
+      await collection.remove(id);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_DELETE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            id
+          }
+        },
+        error$1
+      );
     }
-    await collection.remove(id);
   }
   async disconnect() {
-    if (!this.cluster) {
-      return;
+    try {
+      if (!this.cluster) {
+        return;
+      }
+      await this.cluster.close();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "COUCHBASE_VECTOR_DISCONNECT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
     }
-    await this.cluster.close();
   }
 };