@mastra/libsql 1.27.1-alpha.0 → 1.27.1

package/dist/index.js

@@ -500,7 +500,7 @@ const createNumericOperator = (symbol) => {
 			sql: `CAST(json_extract(metadata, ${jsonPath}) AS NUMERIC) ${symbol} ?`,
 			needsValue: true
 		};
-		else return {
+		return {
 			sql: `CAST(json_extract(metadata, ${jsonPath}) AS TEXT) ${symbol} ?`,
 			needsValue: true
 		};
@@ -527,7 +527,8 @@ function buildElemMatchConditions(value) {
 				sql: sql.replace(pattern, `json_extract(elem.value, '$.${jsonPath}')`),
 				values
 			};
-		} else return {
+		}
+		return {
 			sql: `json_extract(elem.value, '$.${parseJsonPathKey(field)}') = ?`,
 			values: [fieldValue]
 		};
@@ -2058,6 +2059,41 @@ var LibSQLDB = class extends MastraBase {
 		});
 	}
 	/**
+	* Updates multiple records in one write batch, with the same retry behavior as
+	* {@link batchUpdate}. Returns, in input order, whether each update changed a row,
+	* so callers can put extra conditions in `keys` (for example `{ endedAt: null }`).
+	*/
+	async batchUpdateReportingChanges({ tableName, updates }) {
+		return this.executeWriteOperationWithRetry(async () => {
+			const changed = updates.map(() => false);
+			const statements = [];
+			const statementIndexes = [];
+			for (const [index, { keys, data }] of updates.entries()) {
+				const filteredData = await this.filterRecordToKnownColumns(tableName, data);
+				if (Object.keys(filteredData).length === 0) continue;
+				statements.push(prepareUpdateStatement({
+					tableName,
+					updates: filteredData,
+					keys
+				}));
+				statementIndexes.push(index);
+			}
+			if (statements.length === 0) return changed;
+			(await withClientWriteLock(this.client, () => this.client.batch(statements, "write"))).forEach((result, i) => {
+				const index = statementIndexes[i];
+				if (index !== void 0) changed[index] = result.rowsAffected > 0;
+			});
+			return changed;
+		}, `batch update in table ${tableName}`).catch((error) => {
+			throw new MastraError({
+				id: createStorageErrorId("LIBSQL", "BATCH_UPDATE_REPORTING_CHANGES", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		});
+	}
+	/**
 	* Internal batch delete implementation without retry logic.
 	* Each record can be deleted based on single or composite keys.
 	*/
@@ -2190,7 +2226,7 @@ var LibSQLDB = class extends MastraBase {
 	* @returns The total count of matching records
 	*/
 	async selectTotalCount({ tableName, whereClause }) {
-		const statement = `SELECT COUNT(*) as count FROM ${parseSqlIdentifier(tableName, "table name")} ${whereClause ? `${whereClause.sql}` : ""}`;
+		const statement = `SELECT COUNT(*) as count FROM ${parseSqlIdentifier(tableName, "table name")} ${whereClause ? whereClause.sql : ""}`;
 		const result = await this.client.execute({
 			sql: statement,
 			args: whereClause?.args ?? []
@@ -12562,24 +12598,27 @@ var ObservabilityLibSQL = class ObservabilityLibSQL extends ObservabilityStorage
 			}, error);
 		}
 	}
-	async batchUpdateSpans(args) {
+	#toSpanUpdates(records) {
 		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return records.map((record) => {
+			const data = { ...record.updates };
+			if (data.endedAt instanceof Date) data.endedAt = data.endedAt.toISOString();
+			if (data.startedAt instanceof Date) data.startedAt = data.startedAt.toISOString();
+			data.updatedAt = now;
+			return {
+				keys: {
+					spanId: record.spanId,
+					traceId: record.traceId
+				},
+				data
+			};
+		});
+	}
+	async batchUpdateSpans(args) {
 		try {
 			return this.#db.batchUpdate({
 				tableName: TABLE_SPANS,
-				updates: args.records.map((record) => {
-					const data = { ...record.updates };
-					if (data.endedAt instanceof Date) data.endedAt = data.endedAt.toISOString();
-					if (data.startedAt instanceof Date) data.startedAt = data.startedAt.toISOString();
-					data.updatedAt = now;
-					return {
-						keys: {
-							spanId: record.spanId,
-							traceId: record.traceId
-						},
-						data
-					};
-				})
+				updates: this.#toSpanUpdates(args.records)
 			});
 		} catch (error) {
 			throw new MastraError({
@@ -12589,6 +12628,30 @@ var ObservabilityLibSQL = class ObservabilityLibSQL extends ObservabilityStorage
 			}, error);
 		}
 	}
+	async batchUpdateUnendedSpans(args) {
+		try {
+			const changed = await this.#db.batchUpdateReportingChanges({
+				tableName: TABLE_SPANS,
+				updates: this.#toSpanUpdates(args.records).map((update) => ({
+					...update,
+					keys: {
+						...update.keys,
+						endedAt: null
+					}
+				}))
+			});
+			return { updated: args.records.filter((_, index) => changed[index]).map(({ traceId, spanId }) => ({
+				traceId,
+				spanId
+			})) };
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("LIBSQL", "BATCH_UPDATE_UNENDED_SPANS", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER
+			}, error);
+		}
+	}
 	async batchDeleteTraces(args) {
 		this.assertUnscopedBatchDeleteTraces(args);
 		try {
@@ -15277,6 +15340,9 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends WorkflowsStorage {
 	supportsConcurrentUpdates() {
 		return true;
 	}
+	supportsGuardedSnapshotWrites() {
+		return true;
+	}
 	parseWorkflowRun(row) {
 		let parsedSnapshot = row.snapshot;
 		if (typeof parsedSnapshot === "string") try {
@@ -15550,7 +15616,7 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends WorkflowsStorage {
 			}
 		}), "updateWorkflowState");
 	}
-	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt, fence }) {
+	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, createdAt, updatedAt, fence, expectedStatus }) {
 		const now = /* @__PURE__ */ new Date();
 		const createdAtValue = (createdAt ?? now).toISOString();
 		const updatedAtValue = (updatedAt ?? now).toISOString();
@@ -15558,21 +15624,30 @@ var WorkflowsLibSQL = class WorkflowsLibSQL extends WorkflowsStorage {
 			workflowName,
 			runId
 		});
+		const expected = expectedStatus === void 0 ? [] : Array.isArray(expectedStatus) ? expectedStatus : [expectedStatus];
+		const guard = expectedStatus === void 0 ? "" : expected.length ? ` WHERE json_extract(${TABLE_WORKFLOW_SNAPSHOT}.snapshot, '$.status') IN (${expected.map(() => "?").join(", ")})` : " WHERE 0";
 		const check = this.#runFenceCheck(fence, runId, "persistWorkflowSnapshot");
-		await this.executeWithRetry(() => withRunFence(this.#client, check, (writer) => writer.execute({
+		return (await this.executeWithRetry(() => withRunFence(this.#client, check, (writer) => writer.execute({
 			sql: `INSERT INTO ${TABLE_WORKFLOW_SNAPSHOT} (workflow_name, run_id, resourceId, snapshot, createdAt, updatedAt)
                 VALUES (?, ?, ?, jsonb(?), ?, ?)
                 ON CONFLICT(workflow_name, run_id)
-                DO UPDATE SET resourceId = COALESCE(excluded.resourceId, ${TABLE_WORKFLOW_SNAPSHOT}.resourceId), snapshot = excluded.snapshot, updatedAt = excluded.updatedAt`,
+                DO UPDATE SET resourceId = COALESCE(excluded.resourceId, ${TABLE_WORKFLOW_SNAPSHOT}.resourceId), snapshot = excluded.snapshot, updatedAt = excluded.updatedAt${guard}`,
 			args: [
 				workflowName,
 				runId,
 				resourceId ?? null,
 				safeStringify(snapshot),
 				createdAtValue,
-				updatedAtValue
+				updatedAtValue,
+				...expected
 			]
-		})), "persistWorkflowSnapshot");
+		})), "persistWorkflowSnapshot")).rowsAffected > 0;
+	}
+	async loadWorkflowRunStatus({ workflowName, runId }) {
+		return (await this.#client.execute({
+			sql: `SELECT json_extract(snapshot, '$.status') AS status FROM ${TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
+			args: [workflowName, runId]
+		})).rows?.[0]?.status ?? null;
 	}
 	async loadWorkflowSnapshot({ workflowName, runId }) {
 		this.logger.debug("Loading workflow snapshot", {