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

package/dist/index.js

@@ -292,15 +292,16 @@ var StoreMemoryLance = 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];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
       throw new MastraError(
         {
           id: "STORAGE_LANCE_LIST_MESSAGES_INVALID_THREAD_ID",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : 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")
       );
     }
     const perPage = normalizePerPage(perPageInput, 40);
@@ -319,7 +320,8 @@ var StoreMemoryLance = class extends MemoryStorage {
       }
       const { field, direction } = this.parseOrderBy(orderBy, "ASC");
       const table = await this.client.openTable(TABLE_MESSAGES);
-      const conditions = [`thread_id = '${this.escapeSql(threadId)}'`];
+      const threadCondition = threadIds.length === 1 ? `thread_id = '${this.escapeSql(threadIds[0])}'` : `thread_id IN (${threadIds.map((t) => `'${this.escapeSql(t)}'`).join(", ")})`;
+      const conditions = [threadCondition];
       if (resourceId) {
         conditions.push(`\`resourceId\` = '${this.escapeSql(resourceId)}'`);
       }
@@ -359,9 +361,9 @@ var StoreMemoryLance = class extends MemoryStorage {
       }
       const messageIds = new Set(messages.map((m) => m.id));
       if (include && include.length > 0) {
-        const threadIds = [...new Set(include.map((item) => item.threadId || threadId))];
+        const threadIds2 = [...new Set(include.map((item) => item.threadId || threadId))];
         const allThreadMessages = [];
-        for (const tid of threadIds) {
+        for (const tid of threadIds2) {
           const threadQuery = table.query().where(`thread_id = '${tid}'`);
           let threadRecords = await threadQuery.toArray();
           allThreadMessages.push(...threadRecords);
@@ -407,7 +409,7 @@ var StoreMemoryLance = class extends MemoryStorage {
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            threadId,
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
             resourceId: resourceId ?? ""
           }
         },
@@ -1266,6 +1268,8 @@ var StoreScoresLance = class extends ScoresStorage {
           filteredScore[key] = JSON.stringify(filteredScore[key]);
         }
       }
+      filteredScore.createdAt = /* @__PURE__ */ new Date();
+      filteredScore.updatedAt = /* @__PURE__ */ new Date();
       filteredScore.id = id;
       await table.add([filteredScore], { mode: "append" });
       return { score };
@@ -1288,8 +1292,7 @@ var StoreScoresLance = class extends ScoresStorage {
       const query = table.query().where(`id = '${id}'`).limit(1);
       const records = await query.toArray();
       if (records.length === 0) return null;
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      return processResultWithTypeConversion(records[0], schema);
+      return await this.transformScoreRow(records[0]);
     } catch (error) {
       throw new MastraError(
         {
@@ -1303,6 +1306,22 @@ var StoreScoresLance = class extends ScoresStorage {
       );
     }
   }
+  /**
+   * LanceDB-specific score row transformation.
+   *
+   * Note: This implementation does NOT use coreTransformScoreRow because:
+   * 1. LanceDB stores schema information in the table itself (requires async fetch)
+   * 2. Uses processResultWithTypeConversion utility for LanceDB-specific type handling
+   */
+  async transformScoreRow(row) {
+    const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
+    const transformed = processResultWithTypeConversion(row, schema);
+    return {
+      ...transformed,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
   async listScoresByScorerId({
     scorerId,
     pagination,
@@ -1343,8 +1362,7 @@ var StoreScoresLance = class extends ScoresStorage {
         if (start > 0) query = query.offset(start);
       }
       const records = await query.toArray();
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      const scores = processResultWithTypeConversion(records, schema);
+      const scores = await Promise.all(records.map(async (record) => await this.transformScoreRow(record)));
       return {
         pagination: {
           page,
@@ -1385,8 +1403,7 @@ var StoreScoresLance = class extends ScoresStorage {
         if (start > 0) query = query.offset(start);
       }
       const records = await query.toArray();
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      const scores = processResultWithTypeConversion(records, schema);
+      const scores = await Promise.all(records.map(async (record) => await this.transformScoreRow(record)));
       return {
         pagination: {
           page,
@@ -1428,8 +1445,7 @@ var StoreScoresLance = class extends ScoresStorage {
         if (start > 0) query = query.offset(start);
       }
       const records = await query.toArray();
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      const scores = processResultWithTypeConversion(records, schema);
+      const scores = await Promise.all(records.map(async (record) => await this.transformScoreRow(record)));
       return {
         pagination: {
           page,
@@ -1471,8 +1487,7 @@ var StoreScoresLance = class extends ScoresStorage {
         if (start > 0) query = query.offset(start);
       }
       const records = await query.toArray();
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      const scores = processResultWithTypeConversion(records, schema);
+      const scores = await Promise.all(records.map(async (record) => await this.transformScoreRow(record)));
       return {
         pagination: {
           page,
@@ -2843,7 +2858,44 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
       );
     }
   }
-  async updateVector({ indexName, id, update }) {
+  async updateVector(params) {
+    const { indexName, update } = params;
+    if ("id" in params && "filter" in params && params.id && params.filter) {
+      throw new MastraError({
+        id: "STORAGE_LANCE_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "id and filter are mutually exclusive",
+        details: { indexName }
+      });
+    }
+    if (!("id" in params || "filter" in params) || !params.id && !params.filter) {
+      throw new MastraError({
+        id: "STORAGE_LANCE_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "Either id or filter must be provided",
+        details: { indexName }
+      });
+    }
+    if ("filter" in params && params.filter && Object.keys(params.filter).length === 0) {
+      throw new MastraError({
+        id: "STORAGE_LANCE_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "Cannot update with empty filter",
+        details: { indexName }
+      });
+    }
+    if (!update.vector && !update.metadata) {
+      throw new MastraError({
+        id: "STORAGE_LANCE_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "No updates provided",
+        details: { indexName }
+      });
+    }
     try {
       if (!this.lanceClient) {
         throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
@@ -2851,21 +2903,6 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
       if (!indexName) {
         throw new Error("indexName is required");
       }
-      if (!id) {
-        throw new Error("id is required");
-      }
-    } catch (err) {
-      throw new MastraError(
-        {
-          id: "STORAGE_LANCE_VECTOR_UPDATE_VECTOR_FAILED_INVALID_ARGS",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER,
-          details: { indexName, id }
-        },
-        err
-      );
-    }
-    try {
       const tables = await this.lanceClient.tableNames();
       for (const tableName of tables) {
         this.logger.debug("Checking table:" + tableName);
@@ -2875,39 +2912,66 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
           const hasColumn = schema.fields.some((field) => field.name === indexName);
           if (hasColumn) {
             this.logger.debug(`Found column ${indexName} in table ${tableName}`);
-            const existingRecord = await table.query().where(`id = '${id}'`).select(schema.fields.map((field) => field.name)).limit(1).toArray();
-            if (existingRecord.length === 0) {
-              throw new Error(`Record with id '${id}' not found in table ${tableName}`);
+            let whereClause;
+            if ("id" in params && params.id) {
+              whereClause = `id = '${params.id}'`;
+            } else if ("filter" in params && params.filter) {
+              const translator = new LanceFilterTranslator();
+              const processFilterKeys = (filter) => {
+                const processedFilter = {};
+                Object.entries(filter).forEach(([key, value]) => {
+                  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                    Object.entries(value).forEach(([nestedKey, nestedValue]) => {
+                      processedFilter[`metadata_${key}_${nestedKey}`] = nestedValue;
+                    });
+                  } else {
+                    processedFilter[`metadata_${key}`] = value;
+                  }
+                });
+                return processedFilter;
+              };
+              const prefixedFilter = processFilterKeys(params.filter);
+              whereClause = translator.translate(prefixedFilter) || "";
+              if (!whereClause) {
+                throw new Error("Failed to translate filter to SQL");
+              }
+            } else {
+              throw new Error("Either id or filter must be provided");
             }
-            const rowData = {
-              id
-            };
-            Object.entries(existingRecord[0]).forEach(([key, value]) => {
-              if (key !== "id" && key !== "_distance") {
-                if (key === indexName) {
-                  if (!update.vector) {
-                    if (Array.isArray(value)) {
-                      rowData[key] = [...value];
-                    } else if (typeof value === "object" && value !== null) {
-                      rowData[key] = Array.from(value);
+            const existingRecords = await table.query().where(whereClause).select(schema.fields.map((field) => field.name)).toArray();
+            if (existingRecords.length === 0) {
+              this.logger.info(`No records found matching criteria in table ${tableName}`);
+              return;
+            }
+            const updatedRecords = existingRecords.map((record) => {
+              const rowData = {};
+              Object.entries(record).forEach(([key, value]) => {
+                if (key !== "_distance") {
+                  if (key === indexName) {
+                    if (update.vector) {
+                      rowData[key] = update.vector;
                     } else {
-                      rowData[key] = value;
+                      if (Array.isArray(value)) {
+                        rowData[key] = [...value];
+                      } else if (typeof value === "object" && value !== null) {
+                        rowData[key] = Array.from(value);
+                      } else {
+                        rowData[key] = value;
+                      }
                     }
+                  } else {
+                    rowData[key] = value;
                   }
-                } else {
-                  rowData[key] = value;
                 }
+              });
+              if (update.metadata) {
+                Object.entries(update.metadata).forEach(([key, value]) => {
+                  rowData[`metadata_${key}`] = value;
+                });
               }
+              return rowData;
             });
-            if (update.vector) {
-              rowData[indexName] = update.vector;
-            }
-            if (update.metadata) {
-              Object.entries(update.metadata).forEach(([key, value]) => {
-                rowData[`metadata_${key}`] = value;
-              });
-            }
-            await table.add([rowData], { mode: "overwrite" });
+            await table.add(updatedRecords, { mode: "overwrite" });
             return;
           }
         } catch (err) {
@@ -2917,12 +2981,19 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
       }
       throw new Error(`No table found with column/index '${indexName}'`);
     } catch (error) {
+      if (error instanceof MastraError) throw error;
       throw new MastraError(
         {
           id: "STORAGE_LANCE_VECTOR_UPDATE_VECTOR_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, id, hasVector: !!update.vector, hasMetadata: !!update.metadata }
+          details: {
+            indexName,
+            ..."id" in params && params.id && { id: params.id },
+            ..."filter" in params && params.filter && { filter: JSON.stringify(params.filter) },
+            hasVector: !!update.vector,
+            hasMetadata: !!update.metadata
+          }
         },
         error
       );
@@ -2945,7 +3016,10 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
           id: "STORAGE_LANCE_VECTOR_DELETE_VECTOR_FAILED_INVALID_ARGS",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.USER,
-          details: { indexName, id }
+          details: {
+            indexName,
+            ...id && { id }
+          }
         },
         err
       );
@@ -2975,7 +3049,10 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
           id: "STORAGE_LANCE_VECTOR_DELETE_VECTOR_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, id }
+          details: {
+            indexName,
+            ...id && { id }
+          }
         },
         error
       );
@@ -3006,6 +3083,109 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
     });
     return result;
   }
+  async deleteVectors({ indexName, filter, ids }) {
+    if (ids && filter) {
+      throw new MastraError({
+        id: "STORAGE_LANCE_VECTOR_DELETE_VECTORS_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "ids and filter are mutually exclusive",
+        details: { indexName }
+      });
+    }
+    if (!ids && !filter) {
+      throw new MastraError({
+        id: "STORAGE_LANCE_VECTOR_DELETE_VECTORS_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "Either filter or ids must be provided",
+        details: { indexName }
+      });
+    }
+    if (ids && ids.length === 0) {
+      throw new MastraError({
+        id: "STORAGE_LANCE_VECTOR_DELETE_VECTORS_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "Cannot delete with empty ids array",
+        details: { indexName }
+      });
+    }
+    if (filter && Object.keys(filter).length === 0) {
+      throw new MastraError({
+        id: "STORAGE_LANCE_VECTOR_DELETE_VECTORS_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "Cannot delete with empty filter",
+        details: { indexName }
+      });
+    }
+    try {
+      if (!this.lanceClient) {
+        throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      }
+      if (!indexName) {
+        throw new Error("indexName is required");
+      }
+      const tables = await this.lanceClient.tableNames();
+      for (const tableName of tables) {
+        this.logger.debug("Checking table:" + tableName);
+        const table = await this.lanceClient.openTable(tableName);
+        try {
+          const schema = await table.schema();
+          const hasColumn = schema.fields.some((field) => field.name === indexName);
+          if (hasColumn) {
+            this.logger.debug(`Found column ${indexName} in table ${tableName}`);
+            if (ids) {
+              const idsConditions = ids.map((id) => `id = '${id}'`).join(" OR ");
+              await table.delete(idsConditions);
+            } else if (filter) {
+              const translator = new LanceFilterTranslator();
+              const processFilterKeys = (filter2) => {
+                const processedFilter = {};
+                Object.entries(filter2).forEach(([key, value]) => {
+                  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                    Object.entries(value).forEach(([nestedKey, nestedValue]) => {
+                      processedFilter[`metadata_${key}_${nestedKey}`] = nestedValue;
+                    });
+                  } else {
+                    processedFilter[`metadata_${key}`] = value;
+                  }
+                });
+                return processedFilter;
+              };
+              const prefixedFilter = processFilterKeys(filter);
+              const whereClause = translator.translate(prefixedFilter);
+              if (!whereClause) {
+                throw new Error("Failed to translate filter to SQL");
+              }
+              await table.delete(whereClause);
+            }
+            return;
+          }
+        } catch (err) {
+          this.logger.error(`Error checking schema for table ${tableName}:` + err);
+          continue;
+        }
+      }
+      throw new Error(`No table found with column/index '${indexName}'`);
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_DELETE_VECTORS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            ...filter && { filter: JSON.stringify(filter) },
+            ...ids && { idsCount: ids.length }
+          }
+        },
+        error
+      );
+    }
+  }
 };
 
 export { LanceStorage, LanceVectorStore };