@mastra/couchbase 0.0.2 → 0.0.3-alpha.1

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/couchbase@0.0.2-alpha.1 build /home/runner/work/mastra/mastra/stores/couchbase
+> @mastra/couchbase@0.0.3-alpha.1 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.4.0
 TSC Build start
-TSC ⚡️ Build success in 5842ms
+TSC ⚡️ Build success in 8703ms
 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 9029ms
+DTS ⚡️ Build success in 10799ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 8.15 KB
-CJS ⚡️ Build success in 568ms
-ESM dist/index.js 8.09 KB
-ESM ⚡️ Build success in 569ms
+CJS dist/index.cjs 8.58 KB
+CJS ⚡️ Build success in 666ms
+ESM dist/index.js 8.52 KB
+ESM ⚡️ Build success in 667ms

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @mastra/couchbase
 
+## 0.0.3-alpha.1
+
+### Patch Changes
+
+- 9cd1a46: [MASTRA-3338] update naming scheme for embedding index based on vector store rules and added duplicate index checks
+- Updated dependencies [e450778]
+- Updated dependencies [8902157]
+- Updated dependencies [ca0dc88]
+- Updated dependencies [9cd1a46]
+- Updated dependencies [70dbf51]
+  - @mastra/core@0.9.3-alpha.1
+
+## 0.0.3-alpha.0
+
+### Patch Changes
+
+- Updated dependencies [526c570]
+- Updated dependencies [b5d2de0]
+- Updated dependencies [644f8ad]
+  - @mastra/core@0.9.3-alpha.0
+
 ## 0.0.2
 
 ### Patch Changes

package/dist/index.cjs

@@ -59,86 +59,95 @@ var CouchbaseVector = class extends vector.MastraVector {
     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,
-      type: "fulltext-index",
-      params: {
-        doc_config: {
-          docid_prefix_delim: "",
-          docid_regexp: "",
-          mode: "scope.collection.type_field",
-          type_field: "type"
-        },
-        mapping: {
-          default_analyzer: "standard",
-          default_datetime_parser: "dateTimeOptional",
-          default_field: "_all",
-          default_mapping: {
-            dynamic: true,
-            enabled: false
+    try {
+      await this.scope.searchIndexes().upsertIndex({
+        name: indexName,
+        sourceName: this.bucketName,
+        type: "fulltext-index",
+        params: {
+          doc_config: {
+            docid_prefix_delim: "",
+            docid_regexp: "",
+            mode: "scope.collection.type_field",
+            type_field: "type"
           },
-          default_type: "_default",
-          docvalues_dynamic: true,
-          // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
-          index_dynamic: true,
-          store_dynamic: true,
-          // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
-          type_field: "_type",
-          types: {
-            [`${this.scopeName}.${this.collectionName}`]: {
+          mapping: {
+            default_analyzer: "standard",
+            default_datetime_parser: "dateTimeOptional",
+            default_field: "_all",
+            default_mapping: {
               dynamic: true,
-              enabled: true,
-              properties: {
-                embedding: {
-                  enabled: true,
-                  fields: [
-                    {
-                      dims: dimension,
-                      index: true,
-                      name: "embedding",
-                      similarity: DISTANCE_MAPPING[metric],
-                      type: "vector",
-                      vector_index_optimized_for: "recall",
-                      store: true,
-                      // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
-                      docvalues: true,
-                      // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
-                      include_term_vectors: true
-                      // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
-                    }
-                  ]
-                },
-                content: {
-                  enabled: true,
-                  fields: [
-                    {
-                      index: true,
-                      name: "content",
-                      store: true,
-                      type: "text"
-                    }
-                  ]
+              enabled: false
+            },
+            default_type: "_default",
+            docvalues_dynamic: true,
+            // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
+            index_dynamic: true,
+            store_dynamic: true,
+            // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
+            type_field: "_type",
+            types: {
+              [`${this.scopeName}.${this.collectionName}`]: {
+                dynamic: true,
+                enabled: true,
+                properties: {
+                  embedding: {
+                    enabled: true,
+                    fields: [
+                      {
+                        dims: dimension,
+                        index: true,
+                        name: "embedding",
+                        similarity: DISTANCE_MAPPING[metric],
+                        type: "vector",
+                        vector_index_optimized_for: "recall",
+                        store: true,
+                        // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
+                        docvalues: true,
+                        // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
+                        include_term_vectors: true
+                        // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
+                      }
+                    ]
+                  },
+                  content: {
+                    enabled: true,
+                    fields: [
+                      {
+                        index: true,
+                        name: "content",
+                        store: true,
+                        type: "text"
+                      }
+                    ]
+                  }
                 }
               }
             }
+          },
+          store: {
+            indexType: "scorch",
+            segmentVersion: 16
           }
         },
-        store: {
-          indexType: "scorch",
-          segmentVersion: 16
+        sourceUuid: "",
+        sourceParams: {},
+        sourceType: "gocbcore",
+        planParams: {
+          maxPartitionsPerPIndex: 64,
+          indexPartitions: 16,
+          numReplicas: 0
         }
-      },
-      sourceUuid: "",
-      sourceParams: {},
-      sourceType: "gocbcore",
-      planParams: {
-        maxPartitionsPerPIndex: 64,
-        indexPartitions: 16,
-        numReplicas: 0
+      });
+      this.vector_dimension = dimension;
+    } catch (error) {
+      const message = error?.message || error?.toString();
+      if (message && message.toLowerCase().includes("index exists")) {
+        await this.validateExistingIndex(indexName, dimension, metric);
+        return;
       }
-    });
-    this.vector_dimension = dimension;
+      throw error;
+    }
   }
   async upsert(params) {
     const { vectors, metadata, ids } = params;

package/dist/index.js

@@ -57,86 +57,95 @@ var CouchbaseVector = class extends MastraVector {
     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,
-      type: "fulltext-index",
-      params: {
-        doc_config: {
-          docid_prefix_delim: "",
-          docid_regexp: "",
-          mode: "scope.collection.type_field",
-          type_field: "type"
-        },
-        mapping: {
-          default_analyzer: "standard",
-          default_datetime_parser: "dateTimeOptional",
-          default_field: "_all",
-          default_mapping: {
-            dynamic: true,
-            enabled: false
+    try {
+      await this.scope.searchIndexes().upsertIndex({
+        name: indexName,
+        sourceName: this.bucketName,
+        type: "fulltext-index",
+        params: {
+          doc_config: {
+            docid_prefix_delim: "",
+            docid_regexp: "",
+            mode: "scope.collection.type_field",
+            type_field: "type"
           },
-          default_type: "_default",
-          docvalues_dynamic: true,
-          // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
-          index_dynamic: true,
-          store_dynamic: true,
-          // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
-          type_field: "_type",
-          types: {
-            [`${this.scopeName}.${this.collectionName}`]: {
+          mapping: {
+            default_analyzer: "standard",
+            default_datetime_parser: "dateTimeOptional",
+            default_field: "_all",
+            default_mapping: {
               dynamic: true,
-              enabled: true,
-              properties: {
-                embedding: {
-                  enabled: true,
-                  fields: [
-                    {
-                      dims: dimension,
-                      index: true,
-                      name: "embedding",
-                      similarity: DISTANCE_MAPPING[metric],
-                      type: "vector",
-                      vector_index_optimized_for: "recall",
-                      store: true,
-                      // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
-                      docvalues: true,
-                      // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
-                      include_term_vectors: true
-                      // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
-                    }
-                  ]
-                },
-                content: {
-                  enabled: true,
-                  fields: [
-                    {
-                      index: true,
-                      name: "content",
-                      store: true,
-                      type: "text"
-                    }
-                  ]
+              enabled: false
+            },
+            default_type: "_default",
+            docvalues_dynamic: true,
+            // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
+            index_dynamic: true,
+            store_dynamic: true,
+            // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
+            type_field: "_type",
+            types: {
+              [`${this.scopeName}.${this.collectionName}`]: {
+                dynamic: true,
+                enabled: true,
+                properties: {
+                  embedding: {
+                    enabled: true,
+                    fields: [
+                      {
+                        dims: dimension,
+                        index: true,
+                        name: "embedding",
+                        similarity: DISTANCE_MAPPING[metric],
+                        type: "vector",
+                        vector_index_optimized_for: "recall",
+                        store: true,
+                        // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
+                        docvalues: true,
+                        // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
+                        include_term_vectors: true
+                        // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
+                      }
+                    ]
+                  },
+                  content: {
+                    enabled: true,
+                    fields: [
+                      {
+                        index: true,
+                        name: "content",
+                        store: true,
+                        type: "text"
+                      }
+                    ]
+                  }
                 }
               }
             }
+          },
+          store: {
+            indexType: "scorch",
+            segmentVersion: 16
           }
         },
-        store: {
-          indexType: "scorch",
-          segmentVersion: 16
+        sourceUuid: "",
+        sourceParams: {},
+        sourceType: "gocbcore",
+        planParams: {
+          maxPartitionsPerPIndex: 64,
+          indexPartitions: 16,
+          numReplicas: 0
         }
-      },
-      sourceUuid: "",
-      sourceParams: {},
-      sourceType: "gocbcore",
-      planParams: {
-        maxPartitionsPerPIndex: 64,
-        indexPartitions: 16,
-        numReplicas: 0
+      });
+      this.vector_dimension = dimension;
+    } catch (error) {
+      const message = error?.message || error?.toString();
+      if (message && message.toLowerCase().includes("index exists")) {
+        await this.validateExistingIndex(indexName, dimension, metric);
+        return;
       }
-    });
-    this.vector_dimension = dimension;
+      throw error;
+    }
   }
   async upsert(params) {
     const { vectors, metadata, ids } = params;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/couchbase",
-  "version": "0.0.2",
+  "version": "0.0.3-alpha.1",
   "description": "Couchbase vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
   },
   "dependencies": {
     "couchbase": "^4.4.5",
-    "@mastra/core": "^0.9.2"
+    "@mastra/core": "^0.9.3-alpha.1"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",

package/src/vector/index.integration.test.ts

@@ -3,10 +3,11 @@
 // The tests will automatically start and configure the required Couchbase container.
 
 import { execSync } from 'child_process';
+import { randomUUID } from 'crypto';
 import axios from 'axios';
 import type { Cluster, Bucket, Scope, Collection } from 'couchbase';
 import { connect } from 'couchbase';
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
 import { CouchbaseVector, DISTANCE_MAPPING } from './index';
 
 const containerName = 'mastra_couchbase_testing';
@@ -431,6 +432,66 @@ describe('Integration Testing CouchbaseVector', async () => {
         }),
       ).rejects.toThrow('No vectors provided');
     }, 50000);
+
+    it('should handle non-existent index queries', async () => {
+      await expect(
+        couchbase_client.query({ indexName: 'non-existent-index', queryVector: [1, 2, 3] }),
+      ).rejects.toThrow();
+    }, 50000);
+
+    it('should handle duplicate index creation gracefully', async () => {
+      const duplicateIndexName = `duplicate-test-${randomUUID()}`;
+      const dimension = 768;
+      const infoSpy = vi.spyOn(couchbase_client['logger'], 'info');
+      const warnSpy = vi.spyOn(couchbase_client['logger'], 'warn');
+
+      try {
+        // Create index first time
+        await couchbase_client.createIndex({
+          indexName: duplicateIndexName,
+          dimension,
+          metric: 'cosine',
+        });
+
+        // Try to create with same dimensions - should not throw
+        await expect(
+          couchbase_client.createIndex({
+            indexName: duplicateIndexName,
+            dimension,
+            metric: 'cosine',
+          }),
+        ).resolves.not.toThrow();
+
+        expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining('already exists with'));
+
+        // Try to create with same dimensions and different metric - should not throw
+        await expect(
+          couchbase_client.createIndex({
+            indexName: duplicateIndexName,
+            dimension,
+            metric: 'euclidean',
+          }),
+        ).resolves.not.toThrow();
+
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Attempted to create index with metric'));
+
+        // Try to create with different dimensions - should throw
+        await expect(
+          couchbase_client.createIndex({
+            indexName: duplicateIndexName,
+            dimension: dimension + 1,
+            metric: 'cosine',
+          }),
+        ).rejects.toThrow(
+          `Index "${duplicateIndexName}" already exists with ${dimension} dimensions, but ${dimension + 1} dimensions were requested`,
+        );
+      } finally {
+        infoSpy.mockRestore();
+        warnSpy.mockRestore();
+        // Cleanup
+        await couchbase_client.deleteIndex(duplicateIndexName);
+      }
+    }, 50000);
   });
 
   describe('Vector Dimension Tracking', () => {

package/src/vector/index.ts

@@ -84,81 +84,92 @@ export class CouchbaseVector extends MastraVector {
       throw new Error('Dimension must be a positive integer');
     }
 
-    await this.scope.searchIndexes().upsertIndex({
-      name: indexName,
-      sourceName: this.bucketName,
-      type: 'fulltext-index',
-      params: {
-        doc_config: {
-          docid_prefix_delim: '',
-          docid_regexp: '',
-          mode: 'scope.collection.type_field',
-          type_field: 'type',
-        },
-        mapping: {
-          default_analyzer: 'standard',
-          default_datetime_parser: 'dateTimeOptional',
-          default_field: '_all',
-          default_mapping: {
-            dynamic: true,
-            enabled: false,
+    try {
+      await this.scope.searchIndexes().upsertIndex({
+        name: indexName,
+        sourceName: this.bucketName,
+        type: 'fulltext-index',
+        params: {
+          doc_config: {
+            docid_prefix_delim: '',
+            docid_regexp: '',
+            mode: 'scope.collection.type_field',
+            type_field: 'type',
           },
-          default_type: '_default',
-          docvalues_dynamic: true, // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
-          index_dynamic: true,
-          store_dynamic: true, // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
-          type_field: '_type',
-          types: {
-            [`${this.scopeName}.${this.collectionName}`]: {
+          mapping: {
+            default_analyzer: 'standard',
+            default_datetime_parser: 'dateTimeOptional',
+            default_field: '_all',
+            default_mapping: {
               dynamic: true,
-              enabled: true,
-              properties: {
-                embedding: {
-                  enabled: true,
-                  fields: [
-                    {
-                      dims: dimension,
-                      index: true,
-                      name: 'embedding',
-                      similarity: DISTANCE_MAPPING[metric],
-                      type: 'vector',
-                      vector_index_optimized_for: 'recall',
-                      store: true, // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
-                      docvalues: true, // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
-                      include_term_vectors: true, // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
-                    },
-                  ],
-                },
-                content: {
-                  enabled: true,
-                  fields: [
-                    {
-                      index: true,
-                      name: 'content',
-                      store: true,
-                      type: 'text',
-                    },
-                  ],
+              enabled: false,
+            },
+            default_type: '_default',
+            docvalues_dynamic: true, // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
+            index_dynamic: true,
+            store_dynamic: true, // [Doc](https://docs.couchbase.com/server/current/search/search-index-params.html#params) mentions this attribute is required for vector search to return the indexed field
+            type_field: '_type',
+            types: {
+              [`${this.scopeName}.${this.collectionName}`]: {
+                dynamic: true,
+                enabled: true,
+                properties: {
+                  embedding: {
+                    enabled: true,
+                    fields: [
+                      {
+                        dims: dimension,
+                        index: true,
+                        name: 'embedding',
+                        similarity: DISTANCE_MAPPING[metric],
+                        type: 'vector',
+                        vector_index_optimized_for: 'recall',
+                        store: true, // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
+                        docvalues: true, // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
+                        include_term_vectors: true, // CHANGED due to https://docs.couchbase.com/server/current/search/search-index-params.html#fields
+                      },
+                    ],
+                  },
+                  content: {
+                    enabled: true,
+                    fields: [
+                      {
+                        index: true,
+                        name: 'content',
+                        store: true,
+                        type: 'text',
+                      },
+                    ],
+                  },
                 },
               },
             },
           },
+          store: {
+            indexType: 'scorch',
+            segmentVersion: 16,
+          },
         },
-        store: {
-          indexType: 'scorch',
-          segmentVersion: 16,
+        sourceUuid: '',
+        sourceParams: {},
+        sourceType: 'gocbcore',
+        planParams: {
+          maxPartitionsPerPIndex: 64,
+          indexPartitions: 16,
+          numReplicas: 0,
         },
-      },
-      sourceUuid: '',
-      sourceParams: {},
-      sourceType: 'gocbcore',
-      planParams: {
-        maxPartitionsPerPIndex: 64,
-        indexPartitions: 16,
-        numReplicas: 0,
-      },
-    });
-    this.vector_dimension = dimension;
+      });
+      this.vector_dimension = dimension;
+    } catch (error: any) {
+      // Check for 'already exists' error (Couchbase may throw a 400 or 409, or have a message)
+      const message = error?.message || error?.toString();
+      if (message && message.toLowerCase().includes('index exists')) {
+        // Fetch index info and check dimension
+        await this.validateExistingIndex(indexName, dimension, metric);
+        return;
+      }
+      throw error;
+    }
   }
 
   async upsert(params: UpsertVectorParams): Promise<string[]> {