@mastra/libsql 0.10.0 → 0.10.1-alpha.1

package/dist/index.cjs

@@ -484,11 +484,15 @@ var processOperator = (key, operator, operatorValue) => {
 // src/vector/index.ts
 var LibSQLVector = class extends vector.MastraVector {
   turso;
+  maxRetries;
+  initialBackoffMs;
   constructor({
     connectionUrl,
     authToken,
     syncUrl,
-    syncInterval
+    syncInterval,
+    maxRetries = 5,
+    initialBackoffMs = 100
   }) {
     super();
     this.turso = client.createClient({
@@ -497,12 +501,40 @@ var LibSQLVector = class extends vector.MastraVector {
       authToken,
       syncInterval
     });
+    this.maxRetries = maxRetries;
+    this.initialBackoffMs = initialBackoffMs;
     if (connectionUrl.includes(`file:`) || connectionUrl.includes(`:memory:`)) {
-      void this.turso.execute({
-        sql: "PRAGMA journal_mode=WAL;",
-        args: {}
-      });
+      this.turso.execute("PRAGMA journal_mode=WAL;").then(() => this.logger.debug("LibSQLStore: PRAGMA journal_mode=WAL set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA journal_mode=WAL.", err));
+      this.turso.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout=5000.", err));
+    }
+  }
+  async executeWriteOperationWithRetry(operation, isTransaction = false) {
+    let attempts = 0;
+    let backoff = this.initialBackoffMs;
+    while (attempts < this.maxRetries) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (error.code === "SQLITE_BUSY" || error.message && error.message.toLowerCase().includes("database is locked")) {
+          attempts++;
+          if (attempts >= this.maxRetries) {
+            this.logger.error(
+              `LibSQLVector: Operation failed after ${this.maxRetries} attempts due to: ${error.message}`,
+              error
+            );
+            throw error;
+          }
+          this.logger.warn(
+            `LibSQLVector: Attempt ${attempts} failed due to ${isTransaction ? "transaction " : ""}database lock. Retrying in ${backoff}ms...`
+          );
+          await new Promise((resolve) => setTimeout(resolve, backoff));
+          backoff *= 2;
+        } else {
+          throw error;
+        }
+      }
     }
+    throw new Error("LibSQLVector: Max retries reached, but no error was re-thrown from the loop.");
   }
   transformFilter(filter) {
     const translator = new LibSQLFilterTranslator();
@@ -530,20 +562,20 @@ var LibSQLVector = class extends vector.MastraVector {
       filterValues.push(minScore);
       filterValues.push(topK);
       const query = `
-        WITH vector_scores AS (
-          SELECT
-            vector_id as id,
-            (1-vector_distance_cos(embedding, '${vectorStr}')) as score,
-            metadata
-            ${includeVector ? ", vector_extract(embedding) as embedding" : ""}
-          FROM ${parsedIndexName}
-          ${filterQuery}
-        )
-        SELECT *
-        FROM vector_scores
-        WHERE score > ?
-        ORDER BY score DESC
-        LIMIT ?`;
+      WITH vector_scores AS (
+        SELECT
+          vector_id as id,
+          (1-vector_distance_cos(embedding, '${vectorStr}')) as score,
+          metadata
+          ${includeVector ? ", vector_extract(embedding) as embedding" : ""}
+        FROM ${parsedIndexName}
+        ${filterQuery}
+      )
+      SELECT *
+      FROM vector_scores
+      WHERE score > ?
+      ORDER BY score DESC
+      LIMIT ?`;
       const result = await this.turso.execute({
         sql: query,
         args: filterValues
@@ -557,22 +589,24 @@ var LibSQLVector = class extends vector.MastraVector {
     } finally {
     }
   }
-  async upsert({ indexName, vectors, metadata, ids }) {
+  upsert(args) {
+    return this.executeWriteOperationWithRetry(() => this.doUpsert(args), true);
+  }
+  async doUpsert({ indexName, vectors, metadata, ids }) {
     const tx = await this.turso.transaction("write");
     try {
       const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
       const vectorIds = ids || vectors.map(() => crypto.randomUUID());
       for (let i = 0; i < vectors.length; i++) {
         const query = `
-          INSERT INTO ${parsedIndexName} (vector_id, embedding, metadata)
-          VALUES (?, vector32(?), ?)
-          ON CONFLICT(vector_id) DO UPDATE SET
-            embedding = vector32(?),
-            metadata = ?
-        `;
+            INSERT INTO ${parsedIndexName} (vector_id, embedding, metadata)
+            VALUES (?, vector32(?), ?)
+            ON CONFLICT(vector_id) DO UPDATE SET
+              embedding = vector32(?),
+              metadata = ?
+          `;
         await tx.execute({
           sql: query,
-          // @ts-ignore
           args: [
             vectorIds[i],
             JSON.stringify(vectors[i]),
@@ -598,48 +632,42 @@ var LibSQLVector = class extends vector.MastraVector {
       throw error;
     }
   }
-  async createIndex({ indexName, dimension }) {
-    try {
-      if (!Number.isInteger(dimension) || dimension <= 0) {
-        throw new Error("Dimension must be a positive integer");
-      }
-      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
-      await this.turso.execute({
-        sql: `
-        CREATE TABLE IF NOT EXISTS ${parsedIndexName} (
-          id SERIAL PRIMARY KEY,
-          vector_id TEXT UNIQUE NOT NULL,
-          embedding F32_BLOB(${dimension}),
-          metadata TEXT DEFAULT '{}'
-        );
-      `,
-        args: []
-      });
-      await this.turso.execute({
-        sql: `
-        CREATE INDEX IF NOT EXISTS ${parsedIndexName}_vector_idx
-        ON ${parsedIndexName} (libsql_vector_idx(embedding))
-      `,
-        args: []
-      });
-    } catch (error) {
-      console.error("Failed to create vector table:", error);
-      throw error;
-    } finally {
-    }
+  createIndex(args) {
+    return this.executeWriteOperationWithRetry(() => this.doCreateIndex(args));
   }
-  async deleteIndex({ indexName }) {
-    try {
-      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
-      await this.turso.execute({
-        sql: `DROP TABLE IF EXISTS ${parsedIndexName}`,
-        args: []
-      });
-    } catch (error) {
-      console.error("Failed to delete vector table:", error);
-      throw new Error(`Failed to delete vector table: ${error.message}`);
-    } finally {
+  async doCreateIndex({ indexName, dimension }) {
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+      throw new Error("Dimension must be a positive integer");
     }
+    const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+    await this.turso.execute({
+      sql: `
+          CREATE TABLE IF NOT EXISTS ${parsedIndexName} (
+            id SERIAL PRIMARY KEY,
+            vector_id TEXT UNIQUE NOT NULL,
+            embedding F32_BLOB(${dimension}),
+            metadata TEXT DEFAULT '{}'
+          );
+        `,
+      args: []
+    });
+    await this.turso.execute({
+      sql: `
+          CREATE INDEX IF NOT EXISTS ${parsedIndexName}_vector_idx
+          ON ${parsedIndexName} (libsql_vector_idx(embedding))
+        `,
+      args: []
+    });
+  }
+  deleteIndex(args) {
+    return this.executeWriteOperationWithRetry(() => this.doDeleteIndex(args));
+  }
+  async doDeleteIndex({ indexName }) {
+    const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+    await this.turso.execute({
+      sql: `DROP TABLE IF EXISTS ${parsedIndexName}`,
+      args: []
+    });
   }
   async listIndexes() {
     try {
@@ -709,35 +737,34 @@ var LibSQLVector = class extends vector.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 }) {
-    try {
-      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
-      const updates = [];
-      const args = [];
-      if (update.vector) {
-        updates.push("embedding = vector32(?)");
-        args.push(JSON.stringify(update.vector));
-      }
-      if (update.metadata) {
-        updates.push("metadata = ?");
-        args.push(JSON.stringify(update.metadata));
-      }
-      if (updates.length === 0) {
-        throw new Error("No updates provided");
-      }
-      args.push(id);
-      const query = `
+  updateVector(args) {
+    return this.executeWriteOperationWithRetry(() => this.doUpdateVector(args));
+  }
+  async doUpdateVector({ indexName, id, update }) {
+    const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+    const updates = [];
+    const args = [];
+    if (update.vector) {
+      updates.push("embedding = vector32(?)");
+      args.push(JSON.stringify(update.vector));
+    }
+    if (update.metadata) {
+      updates.push("metadata = ?");
+      args.push(JSON.stringify(update.metadata));
+    }
+    if (updates.length === 0) {
+      throw new Error("No updates provided");
+    }
+    args.push(id);
+    const query = `
         UPDATE ${parsedIndexName}
         SET ${updates.join(", ")}
         WHERE vector_id = ?;
       `;
-      await this.turso.execute({
-        sql: query,
-        args
-      });
-    } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index: ${indexName}: ${error.message}`);
-    }
+    await this.turso.execute({
+      sql: query,
+      args
+    });
   }
   /**
    * Deletes a vector by its ID.
@@ -746,18 +773,20 @@ var LibSQLVector = class extends vector.MastraVector {
    * @returns A promise that resolves when the deletion is complete.
    * @throws Will throw an error if the deletion operation fails.
    */
-  async deleteVector({ indexName, id }) {
-    try {
-      const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
-      await this.turso.execute({
-        sql: `DELETE FROM ${parsedIndexName} WHERE vector_id = ?`,
-        args: [id]
-      });
-    } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index: ${indexName}: ${error.message}`);
-    }
+  deleteVector(args) {
+    return this.executeWriteOperationWithRetry(() => this.doDeleteVector(args));
+  }
+  async doDeleteVector({ indexName, id }) {
+    const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+    await this.turso.execute({
+      sql: `DELETE FROM ${parsedIndexName} WHERE vector_id = ?`,
+      args: [id]
+    });
+  }
+  truncateIndex(args) {
+    return this.executeWriteOperationWithRetry(() => this._doTruncateIndex(args));
   }
-  async truncateIndex({ indexName }) {
+  async _doTruncateIndex({ indexName }) {
     await this.turso.execute({
       sql: `DELETE FROM ${utils.parseSqlIdentifier(indexName, "index name")}`,
       args: []
@@ -773,12 +802,20 @@ function safelyParseJSON(jsonString) {
 }
 var LibSQLStore = class extends storage.MastraStorage {
   client;
+  maxRetries;
+  initialBackoffMs;
   constructor(config) {
     super({ name: `LibSQLStore` });
+    this.maxRetries = config.maxRetries ?? 5;
+    this.initialBackoffMs = config.initialBackoffMs ?? 100;
     if (config.url.endsWith(":memory:")) {
       this.shouldCacheInit = false;
     }
     this.client = client.createClient(config);
+    if (config.url.startsWith("file:") || config.url.includes(":memory:")) {
+      this.client.execute("PRAGMA journal_mode=WAL;").then(() => this.logger.debug("LibSQLStore: PRAGMA journal_mode=WAL set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA journal_mode=WAL.", err));
+      this.client.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout.", err));
+    }
   }
   getCreateTableSQL(tableName, schema) {
     const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
@@ -841,28 +878,53 @@ var LibSQLStore = class extends storage.MastraStorage {
       args: values
     };
   }
-  async insert({ tableName, record }) {
-    try {
-      await this.client.execute(
-        this.prepareStatement({
-          tableName,
-          record
-        })
-      );
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
+  async executeWriteOperationWithRetry(operationFn, operationDescription) {
+    let retries = 0;
+    while (true) {
+      try {
+        return await operationFn();
+      } catch (error) {
+        if (error.message && (error.message.includes("SQLITE_BUSY") || error.message.includes("database is locked")) && retries < this.maxRetries) {
+          retries++;
+          const backoffTime = this.initialBackoffMs * Math.pow(2, retries - 1);
+          this.logger.warn(
+            `LibSQLStore: Encountered SQLITE_BUSY during ${operationDescription}. Retrying (${retries}/${this.maxRetries}) in ${backoffTime}ms...`
+          );
+          await new Promise((resolve) => setTimeout(resolve, backoffTime));
+        } else {
+          this.logger.error(`LibSQLStore: Error during ${operationDescription} after ${retries} retries: ${error}`);
+          throw error;
+        }
+      }
     }
   }
-  async batchInsert({ tableName, records }) {
+  insert(args) {
+    return this.executeWriteOperationWithRetry(() => this.doInsert(args), `insert into table ${args.tableName}`);
+  }
+  async doInsert({
+    tableName,
+    record
+  }) {
+    await this.client.execute(
+      this.prepareStatement({
+        tableName,
+        record
+      })
+    );
+  }
+  batchInsert(args) {
+    return this.executeWriteOperationWithRetry(
+      () => this.doBatchInsert(args),
+      `batch insert into table ${args.tableName}`
+    );
+  }
+  async doBatchInsert({
+    tableName,
+    records
+  }) {
     if (records.length === 0) return;
-    try {
-      const batchStatements = records.map((r) => this.prepareStatement({ tableName, record: r }));
-      await this.client.batch(batchStatements, "write");
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
-    }
+    const batchStatements = records.map((r) => this.prepareStatement({ tableName, record: r }));
+    await this.client.batch(batchStatements, "write");
   }
   async load({ tableName, keys }) {
     const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
@@ -963,14 +1025,15 @@ var LibSQLStore = class extends storage.MastraStorage {
       content = JSON.parse(row.content);
     } catch {
     }
-    return {
+    const result = {
       id: row.id,
       content,
       role: row.role,
-      type: row.type,
       createdAt: new Date(row.createdAt),
       threadId: row.thread_id
     };
+    if (row.type && row.type !== `v2`) result.type = row.type;
+    return result;
   }
   async getMessages({ threadId, selectBy }) {
     try {
@@ -1058,7 +1121,7 @@ var LibSQLStore = class extends storage.MastraStorage {
             threadId,
             typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
             message.role,
-            message.type,
+            message.type || "v2",
             time instanceof Date ? time.toISOString() : time
           ]
         };
@@ -1290,8 +1353,8 @@ var LibSQLStore = class extends storage.MastraStorage {
       runId: row.run_id,
       snapshot: parsedSnapshot,
       resourceId: row.resourceId,
-      createdAt: new Date(row.created_at),
-      updatedAt: new Date(row.updated_at)
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
     };
   }
 };

package/dist/index.d.cts

@@ -1,4 +1,5 @@
 export { LIBSQL_PROMPT } from './_tsup-dts-rollup.cjs';
+export { LibSQLVectorConfig } from './_tsup-dts-rollup.cjs';
 export { LibSQLVector } from './_tsup-dts-rollup.cjs';
 export { LibSQLConfig } from './_tsup-dts-rollup.cjs';
 export { LibSQLStore } from './_tsup-dts-rollup.cjs';

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { LIBSQL_PROMPT } from './_tsup-dts-rollup.js';
+export { LibSQLVectorConfig } from './_tsup-dts-rollup.js';
 export { LibSQLVector } from './_tsup-dts-rollup.js';
 export { LibSQLConfig } from './_tsup-dts-rollup.js';
 export { LibSQLStore } from './_tsup-dts-rollup.js';