@mastra/libsql 1.22.3-alpha.1 → 1.22.3-alpha.3

package/dist/index.js

@@ -4,6 +4,8 @@ import { AGENTS_SCHEMA, AGENT_VERSIONS_SCHEMA, AgentsStorage, BackgroundTasksSto
 import { parseFieldKey, parseSqlIdentifier } from "@mastra/core/utils";
 import { MastraVector, validateTopK, validateUpsertInput } from "@mastra/core/vector";
 import { BaseFilterTranslator } from "@mastra/core/vector/filter";
+import { realpath } from "fs/promises";
+import { basename, dirname, isAbsolute, join, resolve } from "path";
 import { MastraBase } from "@mastra/core/base";
 import { randomUUID } from "crypto";
 import { MessageList } from "@mastra/core/agent";
@@ -236,13 +238,13 @@ const FILTER_OPERATORS = {
 		sql: `NOT (${key})`,
 		needsValue: false
 	}),
-	$size: (key, paramIndex) => {
+	$size: (key, value) => {
 		const jsonPath = getJsonPath(key);
 		return {
 			sql: `(
     CASE
-      WHEN json_type(json_extract(metadata, ${jsonPath})) = 'array' THEN 
-        json_array_length(json_extract(metadata, ${jsonPath})) = $${paramIndex}
+      WHEN json_type(json_extract(metadata, ${jsonPath})) = 'array' THEN
+        json_array_length(json_extract(metadata, ${jsonPath})) = ?
       ELSE FALSE
     END
   )`,
@@ -384,6 +386,31 @@ const processOperator = (key, operator, operatorValue) => {
 	};
 };
 //#endregion
+//#region src/vector/write-lock.ts
+const databaseWriteChains = /* @__PURE__ */ new Map();
+async function getLocalFileDatabaseKey({ url, syncUrl, cwd }) {
+	if (!url.startsWith("file:") || url.includes(":memory:") || syncUrl) return;
+	const uriPath = url.slice(5).split(/[?#]/, 1)[0];
+	const decodedPath = decodeURIComponent(uriPath);
+	const absolutePath = isAbsolute(decodedPath) ? decodedPath : resolve(cwd, decodedPath);
+	try {
+		return await realpath(absolutePath);
+	} catch (error) {
+		if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw error;
+	}
+	return join(await realpath(dirname(absolutePath)), basename(absolutePath));
+}
+function withLocalFileDatabaseWriteLock(key, fn) {
+	if (!key) return fn();
+	const result = (databaseWriteChains.get(key) ?? Promise.resolve()).then(fn, fn);
+	const tail = result.then(() => void 0, () => void 0);
+	databaseWriteChains.set(key, tail);
+	tail.then(() => {
+		if (databaseWriteChains.get(key) === tail) databaseWriteChains.delete(key);
+	});
+	return result;
+}
+//#endregion
 //#region src/vector/index.ts
 var LibSQLVector = class extends MastraVector {
 	turso;
@@ -391,25 +418,57 @@ var LibSQLVector = class extends MastraVector {
 	initialBackoffMs;
 	overFetchMultiplier;
 	isMemoryDb;
-	vectorIndexes;
+	initialization;
+	databaseKey;
+	vectorIndexes = /* @__PURE__ */ new Set();
 	constructor({ url, authToken, syncUrl, syncInterval, maxRetries = 5, initialBackoffMs = 100, vectorTopKOverFetchMultiplier = 10, id }) {
 		super({ id });
+		this.isMemoryDb = url.includes(":memory:");
+		const isLocalDb = (url.startsWith("file:") || this.isMemoryDb) && !syncUrl;
+		const cwd = process.cwd();
 		this.turso = createClient({
 			url,
 			syncUrl,
 			authToken,
-			syncInterval
+			syncInterval,
+			...isLocalDb ? { timeout: 5e3 } : {}
 		});
 		this.maxRetries = maxRetries;
 		this.initialBackoffMs = initialBackoffMs;
 		if (!Number.isInteger(vectorTopKOverFetchMultiplier) || vectorTopKOverFetchMultiplier < 1) throw new Error("vectorTopKOverFetchMultiplier must be a positive integer");
 		this.overFetchMultiplier = vectorTopKOverFetchMultiplier;
-		this.isMemoryDb = url.includes(":memory:");
-		if (url.includes(`file:`) || this.isMemoryDb) {
-			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));
+		this.initialization = this.initialize({
+			url,
+			syncUrl,
+			cwd,
+			isLocalDb
+		});
+	}
+	async initialize({ url, syncUrl, cwd, isLocalDb }) {
+		if (isLocalDb) {
+			await this.applyLocalPragmas();
+			this.databaseKey = await getLocalFileDatabaseKey({
+				url,
+				syncUrl,
+				cwd
+			});
 		}
-		this.vectorIndexes = this.isMemoryDb ? Promise.resolve(/* @__PURE__ */ new Set()) : this.discoverVectorIndexes();
+		if (!this.isMemoryDb) this.vectorIndexes = await this.discoverVectorIndexes();
+	}
+	async applyLocalPragmas() {
+		for (const [label, sql] of [["journal_mode=WAL", "PRAGMA journal_mode=WAL;"], ["busy_timeout=5000", "PRAGMA busy_timeout = 5000;"]]) try {
+			await this.turso.execute(sql);
+			this.logger.debug(`LibSQLStore: PRAGMA ${label} set.`);
+		} catch (err) {
+			this.logger.warn(`LibSQLStore: Failed to set PRAGMA ${label}.`, err);
+		}
+	}
+	async ensureInitialized() {
+		await this.initialization;
+	}
+	async executeMutation(operation, isTransaction = false) {
+		await this.ensureInitialized();
+		return withLocalFileDatabaseWriteLock(this.databaseKey, () => this.executeWriteOperationWithRetry(operation, isTransaction));
 	}
 	/**
 	* Closes the underlying libsql client, releasing this vector store's OS file handles.
@@ -417,6 +476,7 @@ var LibSQLVector = class extends MastraVector {
 	* Safe to call more than once; subsequent calls are no-ops.
 	*/
 	async close() {
+		await this.ensureInitialized();
 		if (!this.turso.closed) this.turso.close();
 	}
 	async discoverVectorIndexes() {
@@ -452,8 +512,8 @@ var LibSQLVector = class extends MastraVector {
 	transformFilter(filter) {
 		return new LibSQLFilterTranslator().translate(filter);
 	}
-	async hasVectorIndex(parsedIndexName) {
-		return (await this.vectorIndexes).has(`${parsedIndexName}_vector_idx`);
+	hasVectorIndex(parsedIndexName) {
+		return this.vectorIndexes.has(`${parsedIndexName}_vector_idx`);
 	}
 	async queryWithIndex(parsedIndexName, vectorStr, topK, filter, includeVector, minScore) {
 		const { sql: filterQuery, values: filterValues } = buildFilterQuery(this.transformFilter(filter));
@@ -508,9 +568,10 @@ var LibSQLVector = class extends MastraVector {
 			details: { message: "queryVector must be an array of finite numbers" }
 		});
 		try {
+			await this.ensureInitialized();
 			const parsedIndexName = parseSqlIdentifier(indexName, "index name");
 			const vectorStr = `[${queryVector.join(",")}]`;
-			if (!this.isMemoryDb && await this.hasVectorIndex(parsedIndexName)) try {
+			if (!this.isMemoryDb && this.hasVectorIndex(parsedIndexName)) try {
 				const indexedResults = await this.queryWithIndex(parsedIndexName, vectorStr, topK, filter, includeVector, minScore);
 				if (!filter || indexedResults.length >= topK) return indexedResults;
 			} catch (err) {
@@ -551,9 +612,9 @@ var LibSQLVector = class extends MastraVector {
 			}, error);
 		}
 	}
-	upsert(args) {
+	async upsert(args) {
 		try {
-			return this.executeWriteOperationWithRetry(() => this.doUpsert(args), true);
+			return await this.executeMutation(() => this.doUpsert(args), true);
 		} catch (error) {
 			throw new MastraError({
 				id: createVectorErrorId("LIBSQL", "UPSERT", "FAILED"),
@@ -601,9 +662,9 @@ var LibSQLVector = class extends MastraVector {
 			throw error;
 		}
 	}
-	createIndex(args) {
+	async createIndex(args) {
 		try {
-			return this.executeWriteOperationWithRetry(() => this.doCreateIndex(args));
+			return await this.executeMutation(() => this.doCreateIndex(args));
 		} catch (error) {
 			throw new MastraError({
 				id: createVectorErrorId("LIBSQL", "CREATE_INDEX", "FAILED"),
@@ -637,11 +698,11 @@ var LibSQLVector = class extends MastraVector {
         `,
 			args: []
 		});
-		this.vectorIndexes.then((indexes) => indexes.add(`${parsedIndexName}_vector_idx`));
+		this.vectorIndexes.add(`${parsedIndexName}_vector_idx`);
 	}
-	deleteIndex(args) {
+	async deleteIndex(args) {
 		try {
-			return this.executeWriteOperationWithRetry(() => this.doDeleteIndex(args));
+			return await this.executeMutation(() => this.doDeleteIndex(args));
 		} catch (error) {
 			throw new MastraError({
 				id: createVectorErrorId("LIBSQL", "DELETE_INDEX", "FAILED"),
@@ -657,10 +718,11 @@ var LibSQLVector = class extends MastraVector {
 			sql: `DROP TABLE IF EXISTS ${parsedIndexName}`,
 			args: []
 		});
-		this.vectorIndexes.then((indexes) => indexes.delete(`${parsedIndexName}_vector_idx`));
+		this.vectorIndexes.delete(`${parsedIndexName}_vector_idx`);
 	}
 	async listIndexes() {
 		try {
+			await this.ensureInitialized();
 			return (await this.turso.execute({
 				sql: `
         SELECT name FROM sqlite_master 
@@ -685,6 +747,7 @@ var LibSQLVector = class extends MastraVector {
 	*/
 	async describeIndex({ indexName }) {
 		try {
+			await this.ensureInitialized();
 			const parsedIndexName = parseSqlIdentifier(indexName, "index name");
 			const tableInfo = await this.turso.execute({
 				sql: `
@@ -730,7 +793,7 @@ var LibSQLVector = class extends MastraVector {
 	* @throws Will throw an error if no updates are provided or if the update operation fails.
 	*/
 	updateVector(args) {
-		return this.executeWriteOperationWithRetry(() => this.doUpdateVector(args));
+		return this.executeMutation(() => this.doUpdateVector(args));
 	}
 	async doUpdateVector(params) {
 		const { indexName, update } = params;
@@ -835,9 +898,9 @@ var LibSQLVector = class extends MastraVector {
 	* @returns A promise that resolves when the deletion is complete.
 	* @throws Will throw an error if the deletion operation fails.
 	*/
-	deleteVector(args) {
+	async deleteVector(args) {
 		try {
-			return this.executeWriteOperationWithRetry(() => this.doDeleteVector(args));
+			return await this.executeMutation(() => this.doDeleteVector(args));
 		} catch (error) {
 			throw new MastraError({
 				id: createVectorErrorId("LIBSQL", "DELETE_VECTOR", "FAILED"),
@@ -858,7 +921,7 @@ var LibSQLVector = class extends MastraVector {
 		});
 	}
 	deleteVectors(args) {
-		return this.executeWriteOperationWithRetry(() => this.doDeleteVectors(args));
+		return this.executeMutation(() => this.doDeleteVectors(args));
 	}
 	async doDeleteVectors({ indexName, filter, ids }) {
 		const parsedIndexName = parseSqlIdentifier(indexName, "index name");
@@ -940,9 +1003,9 @@ var LibSQLVector = class extends MastraVector {
 			}, error);
 		}
 	}
-	truncateIndex(args) {
+	async truncateIndex(args) {
 		try {
-			return this.executeWriteOperationWithRetry(() => this._doTruncateIndex(args));
+			return await this.executeMutation(() => this._doTruncateIndex(args));
 		} catch (error) {
 			throw new MastraError({
 				id: createVectorErrorId("LIBSQL", "TRUNCATE_INDEX", "FAILED"),
@@ -2498,6 +2561,26 @@ var AgentsLibSQL = class extends AgentsStorage {
 			}, error);
 		}
 	}
+	async getVersions(ids) {
+		if (ids.length === 0) return [];
+		try {
+			return (await this.#db.selectMany({
+				tableName: TABLE_AGENT_VERSIONS,
+				whereClause: {
+					sql: `WHERE id IN (${ids.map(() => "?").join(", ")})`,
+					args: ids
+				}
+			}) ?? []).map((row) => this.parseVersionRow(row));
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createStorageErrorId("LIBSQL", "GET_VERSIONS", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { count: ids.length }
+			}, error);
+		}
+	}
 	async getVersionByNumber(agentId, versionNumber) {
 		try {
 			const rows = await this.#db.selectMany({
@@ -12241,6 +12324,24 @@ var SkillsLibSQL = class extends SkillsStorage {
 			}, error);
 		}
 	}
+	async getVersions(ids) {
+		if (ids.length === 0) return [];
+		try {
+			const placeholders = ids.map(() => "?").join(", ");
+			return ((await this.#client.execute({
+				sql: `SELECT ${buildSelectColumns(TABLE_SKILL_VERSIONS)} FROM "${TABLE_SKILL_VERSIONS}" WHERE id IN (${placeholders})`,
+				args: ids
+			})).rows ?? []).map((row) => this.#parseVersionRow(row));
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createStorageErrorId("LIBSQL", "GET_SKILL_VERSIONS", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { count: ids.length }
+			}, error);
+		}
+	}
 	async getVersionByNumber(skillId, versionNumber) {
 		try {
 			const row = (await this.#client.execute({