@mastra/turso 0.1.2 → 0.1.3-alpha.0

package/dist/index.cjs

@@ -1,350 +1,334 @@
-'use strict';
-
-var libsql = require('@mastra/libsql');
-var detectLibc = require('detect-libc');
-
-// src/index.ts
-
-// src/client.ts
-var ROLLBACK = /* @__PURE__ */ Symbol("turso-transaction-rollback");
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _mastra_libsql = require("@mastra/libsql");
+let detect_libc = require("detect-libc");
+//#region src/client.ts
+const ROLLBACK = Symbol("turso-transaction-rollback");
 var TursoSqliteError = class extends Error {
-  code;
-  rawCode;
-  constructor(error, code) {
-    super(error.message, { cause: error });
-    this.name = "TursoSqliteError";
-    this.code = code;
-    const rawCode = error.rawCode;
-    if (typeof rawCode === "number") this.rawCode = rawCode;
-  }
+	code;
+	rawCode;
+	constructor(error, code) {
+		super(error.message, { cause: error });
+		this.name = "TursoSqliteError";
+		this.code = code;
+		const rawCode = error.rawCode;
+		if (typeof rawCode === "number") this.rawCode = rawCode;
+	}
 };
 function normalizeError(error) {
-  if (!(error instanceof Error)) return error;
-  const code = error.code;
-  if (typeof code === "string" && code.startsWith("SQLITE_")) return error;
-  const message = error.message.toLowerCase();
-  if (message.includes("unique constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_UNIQUE");
-  if (message.includes("primary key constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_PRIMARYKEY");
-  if (message.includes("not null constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_NOTNULL");
-  if (message.includes("foreign key constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_FOREIGNKEY");
-  if (message.includes("check constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_CHECK");
-  if (message.includes("database is locked") || message.includes("database is busy")) {
-    return new TursoSqliteError(error, "SQLITE_BUSY");
-  }
-  return error;
+	if (!(error instanceof Error)) return error;
+	const code = error.code;
+	if (typeof code === "string" && code.startsWith("SQLITE_")) return error;
+	const message = error.message.toLowerCase();
+	if (message.includes("unique constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_UNIQUE");
+	if (message.includes("primary key constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_PRIMARYKEY");
+	if (message.includes("not null constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_NOTNULL");
+	if (message.includes("foreign key constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_FOREIGNKEY");
+	if (message.includes("check constraint")) return new TursoSqliteError(error, "SQLITE_CONSTRAINT_CHECK");
+	if (message.includes("database is locked") || message.includes("database is busy")) return new TursoSqliteError(error, "SQLITE_BUSY");
+	return error;
 }
 function deferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((resolvePromise, rejectPromise) => {
-    resolve = resolvePromise;
-    reject = rejectPromise;
-  });
-  return { promise, resolve, reject };
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((resolvePromise, rejectPromise) => {
+			resolve = resolvePromise;
+			reject = rejectPromise;
+		}),
+		resolve,
+		reject
+	};
 }
 var AsyncMutex = class {
-  #tail = Promise.resolve();
-  async acquire() {
-    const previous = this.#tail;
-    const next = deferred();
-    this.#tail = previous.then(
-      () => next.promise,
-      () => next.promise
-    );
-    await previous;
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      next.resolve();
-    };
-  }
+	#tail = Promise.resolve();
+	async acquire() {
+		const previous = this.#tail;
+		const next = deferred();
+		this.#tail = previous.then(() => next.promise, () => next.promise);
+		await previous;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			next.resolve();
+		};
+	}
 };
 function normalizeInput(value) {
-  if (typeof value === "boolean") return value ? 1 : 0;
-  if (value instanceof Date) return value.toISOString();
-  if (value instanceof ArrayBuffer) return new Uint8Array(value);
-  return value;
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	return value;
 }
 function normalizeArgs(args) {
-  if (!args) return void 0;
-  if (Array.isArray(args)) return args.map(normalizeInput);
-  return Object.fromEntries(Object.entries(args).map(([key, value]) => [key, normalizeInput(value)]));
+	if (!args) return void 0;
+	if (Array.isArray(args)) return args.map(normalizeInput);
+	return Object.fromEntries(Object.entries(args).map(([key, value]) => [key, normalizeInput(value)]));
 }
 function normalizeStatement(statement) {
-  const args = normalizeArgs(statement.args);
-  if (!Array.isArray(args) || !statement.sql.toLowerCase().includes("jsonb(?)")) {
-    return { sql: statement.sql, ...args ? { args } : {} };
-  }
-  let argumentIndex = 0;
-  const normalizedArgs = [];
-  const sql = statement.sql.replace(/jsonb\(\?\)|\?/gi, (token) => {
-    const value = args[argumentIndex++];
-    if (token.toLowerCase() === "jsonb(?)" && value === null) return "NULL";
-    normalizedArgs.push(value);
-    return token;
-  });
-  return { sql, args: normalizedArgs };
+	const args = normalizeArgs(statement.args);
+	if (!Array.isArray(args) || !statement.sql.toLowerCase().includes("jsonb(?)")) return {
+		sql: statement.sql,
+		...args ? { args } : {}
+	};
+	let argumentIndex = 0;
+	const normalizedArgs = [];
+	return {
+		sql: statement.sql.replace(/jsonb\(\?\)|\?/gi, (token) => {
+			const value = args[argumentIndex++];
+			if (token.toLowerCase() === "jsonb(?)" && value === null) return "NULL";
+			normalizedArgs.push(value);
+			return token;
+		}),
+		args: normalizedArgs
+	};
 }
 function toNativeStatement(statement) {
-  return typeof statement === "string" ? statement : normalizeStatement(statement);
+	return typeof statement === "string" ? statement : normalizeStatement(statement);
 }
 function normalizeValue(value) {
-  if (typeof value === "bigint") {
-    return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(value) : value;
-  }
-  if (value instanceof Uint8Array) return Uint8Array.from(value).buffer;
-  if (value === null || typeof value === "string" || typeof value === "number" || value instanceof ArrayBuffer) {
-    return value;
-  }
-  throw new TypeError(`Unsupported Turso result value: ${typeof value}`);
+	if (typeof value === "bigint") return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(value) : value;
+	if (value instanceof Uint8Array) return Uint8Array.from(value).buffer;
+	if (value === null || typeof value === "string" || typeof value === "number" || value instanceof ArrayBuffer) return value;
+	throw new TypeError(`Unsupported Turso result value: ${typeof value}`);
 }
 function normalizeResult(result) {
-  const rows = result.rows.map((row) => {
-    if (Array.isArray(row)) {
-      return Object.fromEntries(result.columns.map((column, index) => [column, normalizeValue(row[index])]));
-    }
-    return Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeValue(value)]));
-  });
-  return {
-    columns: result.columns,
-    columnTypes: result.columnTypes,
-    rows,
-    rowsAffected: result.rowsAffected
-  };
+	const rows = result.rows.map((row) => {
+		if (Array.isArray(row)) return Object.fromEntries(result.columns.map((column, index) => [column, normalizeValue(row[index])]));
+		return Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeValue(value)]));
+	});
+	return {
+		columns: result.columns,
+		columnTypes: result.columnTypes,
+		rows,
+		rowsAffected: result.rowsAffected
+	};
 }
 var TursoSqliteClient = class {
-  protocol = "turso";
-  #mutex = new AsyncMutex();
-  #readiness;
-  #state = "open";
-  #closePromise;
-  #activeRollback;
-  constructor(config) {
-    this.#readiness = this.#connect(config);
-    void this.#readiness.catch(() => void 0);
-  }
-  get closed() {
-    return this.#state !== "open";
-  }
-  async execute(statement) {
-    return this.#runExclusive(async (db) => normalizeResult((await db.batch([toNativeStatement(statement)]))[0]));
-  }
-  async batch(statements, mode) {
-    return this.#runExclusive(async (db) => {
-      const results = await db.batch(statements.map(toNativeStatement), mode);
-      return results.map(normalizeResult);
-    });
-  }
-  async transaction(mode = "write") {
-    this.#assertOpen();
-    const release = await this.#mutex.acquire();
-    try {
-      this.#assertOpen();
-      const db = await this.#readiness;
-      this.#assertOpen();
-      const entered = deferred();
-      const decision = deferred();
-      let transactionClosed = false;
-      let operationTail = Promise.resolve();
-      let completion;
-      let runner;
-      const execute = (statement) => {
-        if (transactionClosed) return Promise.reject(new Error("Turso transaction is closed."));
-        const operation = operationTail.then(async () => {
-          try {
-            return normalizeResult((await db.batch([toNativeStatement(statement)]))[0]);
-          } catch (error) {
-            throw normalizeError(error);
-          }
-        });
-        operationTail = operation.then(
-          () => void 0,
-          () => void 0
-        );
-        return operation;
-      };
-      const finish = (outcome) => {
-        if (completion) return completion;
-        transactionClosed = true;
-        completion = (async () => {
-          await operationTail;
-          decision.resolve(outcome);
-          try {
-            await runner;
-          } catch (error) {
-            if (outcome !== "rollback" || error !== ROLLBACK) throw error;
-          }
-        })();
-        return completion;
-      };
-      const transaction = {
-        execute,
-        commit: () => finish("commit"),
-        rollback: () => finish("rollback"),
-        close: () => finish("rollback"),
-        get closed() {
-          return transactionClosed;
-        }
-      };
-      const rollback = () => finish("rollback");
-      this.#activeRollback = rollback;
-      const nativeTransaction = db.transaction(async () => {
-        entered.resolve();
-        if (await decision.promise === "rollback") throw ROLLBACK;
-      });
-      const nativeRunner = mode === "write" ? nativeTransaction.immediate() : nativeTransaction.deferred();
-      runner = nativeRunner.catch((error) => {
-        throw normalizeError(error);
-      });
-      runner.then(
-        () => {
-          if (this.#activeRollback === rollback) this.#activeRollback = void 0;
-          release();
-        },
-        (error) => {
-          entered.reject(error);
-          if (this.#activeRollback === rollback) this.#activeRollback = void 0;
-          release();
-        }
-      );
-      await entered.promise;
-      if (this.#state !== "open") {
-        await rollback();
-        throw new Error("Turso client is closed.");
-      }
-      return transaction;
-    } catch (error) {
-      release();
-      throw error;
-    }
-  }
-  close() {
-    this.#closePromise ??= this.#close();
-    return this.#closePromise;
-  }
-  async #connect(config) {
-    const { connect } = await import('@tursodatabase/database');
-    const db = await connect(config.path, {
-      ...config.readonly === void 0 ? {} : { readonly: config.readonly },
-      ...config.fileMustExist === void 0 ? {} : { fileMustExist: config.fileMustExist },
-      ...config.timeout === void 0 ? {} : { timeout: config.timeout },
-      ...config.defaultQueryTimeout === void 0 ? {} : { defaultQueryTimeout: config.defaultQueryTimeout },
-      ...config.tracing === void 0 ? {} : { tracing: config.tracing },
-      ...config.experimental === void 0 ? {} : { experimental: config.experimental }
-    });
-    db.defaultSafeIntegers(true);
-    return db;
-  }
-  async #runExclusive(operation) {
-    this.#assertOpen();
-    const release = await this.#mutex.acquire();
-    try {
-      this.#assertOpen();
-      const db = await this.#readiness;
-      this.#assertOpen();
-      try {
-        return await operation(db);
-      } catch (error) {
-        throw normalizeError(error);
-      }
-    } finally {
-      release();
-    }
-  }
-  async #close() {
-    if (this.#state === "closed") return;
-    this.#state = "closing";
-    await this.#activeRollback?.();
-    const release = await this.#mutex.acquire();
-    try {
-      const db = await this.#readiness.catch(() => void 0);
-      await db?.close();
-    } finally {
-      this.#state = "closed";
-      release();
-    }
-  }
-  #assertOpen() {
-    if (this.#state !== "open") throw new Error("Turso client is closed.");
-  }
+	protocol = "turso";
+	#mutex = new AsyncMutex();
+	#readiness;
+	#state = "open";
+	#closePromise;
+	#activeRollback;
+	constructor(config) {
+		this.#readiness = this.#connect(config);
+		this.#readiness.catch(() => void 0);
+	}
+	get closed() {
+		return this.#state !== "open";
+	}
+	async execute(statement) {
+		return this.#runExclusive(async (db) => normalizeResult((await db.batch([toNativeStatement(statement)]))[0]));
+	}
+	async batch(statements, mode) {
+		return this.#runExclusive(async (db) => {
+			return (await db.batch(statements.map(toNativeStatement), mode)).map(normalizeResult);
+		});
+	}
+	async transaction(mode = "write") {
+		this.#assertOpen();
+		const release = await this.#mutex.acquire();
+		try {
+			this.#assertOpen();
+			const db = await this.#readiness;
+			this.#assertOpen();
+			const entered = deferred();
+			const decision = deferred();
+			let transactionClosed = false;
+			let operationTail = Promise.resolve();
+			let completion;
+			let runner;
+			const execute = (statement) => {
+				if (transactionClosed) return Promise.reject(/* @__PURE__ */ new Error("Turso transaction is closed."));
+				const operation = operationTail.then(async () => {
+					try {
+						return normalizeResult((await db.batch([toNativeStatement(statement)]))[0]);
+					} catch (error) {
+						throw normalizeError(error);
+					}
+				});
+				operationTail = operation.then(() => void 0, () => void 0);
+				return operation;
+			};
+			const finish = (outcome) => {
+				if (completion) return completion;
+				transactionClosed = true;
+				completion = (async () => {
+					await operationTail;
+					decision.resolve(outcome);
+					try {
+						await runner;
+					} catch (error) {
+						if (outcome !== "rollback" || error !== ROLLBACK) throw error;
+					}
+				})();
+				return completion;
+			};
+			const transaction = {
+				execute,
+				commit: () => finish("commit"),
+				rollback: () => finish("rollback"),
+				close: () => finish("rollback"),
+				get closed() {
+					return transactionClosed;
+				}
+			};
+			const rollback = () => finish("rollback");
+			this.#activeRollback = rollback;
+			const nativeTransaction = db.transaction(async () => {
+				entered.resolve();
+				if (await decision.promise === "rollback") throw ROLLBACK;
+			});
+			runner = (mode === "write" ? nativeTransaction.immediate() : nativeTransaction.deferred()).catch((error) => {
+				throw normalizeError(error);
+			});
+			runner.then(() => {
+				if (this.#activeRollback === rollback) this.#activeRollback = void 0;
+				release();
+			}, (error) => {
+				entered.reject(error);
+				if (this.#activeRollback === rollback) this.#activeRollback = void 0;
+				release();
+			});
+			await entered.promise;
+			if (this.#state !== "open") {
+				await rollback();
+				throw new Error("Turso client is closed.");
+			}
+			return transaction;
+		} catch (error) {
+			release();
+			throw error;
+		}
+	}
+	close() {
+		this.#closePromise ??= this.#close();
+		return this.#closePromise;
+	}
+	async #connect(config) {
+		const { connect } = await import("@tursodatabase/database");
+		const db = await connect(config.path, {
+			...config.readonly === void 0 ? {} : { readonly: config.readonly },
+			...config.fileMustExist === void 0 ? {} : { fileMustExist: config.fileMustExist },
+			...config.timeout === void 0 ? {} : { timeout: config.timeout },
+			...config.defaultQueryTimeout === void 0 ? {} : { defaultQueryTimeout: config.defaultQueryTimeout },
+			...config.tracing === void 0 ? {} : { tracing: config.tracing },
+			...config.experimental === void 0 ? {} : { experimental: config.experimental }
+		});
+		db.defaultSafeIntegers(true);
+		return db;
+	}
+	async #runExclusive(operation) {
+		this.#assertOpen();
+		const release = await this.#mutex.acquire();
+		try {
+			this.#assertOpen();
+			const db = await this.#readiness;
+			this.#assertOpen();
+			try {
+				return await operation(db);
+			} catch (error) {
+				throw normalizeError(error);
+			}
+		} finally {
+			release();
+		}
+	}
+	async #close() {
+		if (this.#state === "closed") return;
+		this.#state = "closing";
+		await this.#activeRollback?.();
+		const release = await this.#mutex.acquire();
+		try {
+			await (await this.#readiness.catch(() => void 0))?.close();
+		} finally {
+			this.#state = "closed";
+			release();
+		}
+	}
+	#assertOpen() {
+		if (this.#state !== "open") throw new Error("Turso client is closed.");
+	}
 };
+//#endregion
+//#region src/support.ts
 function detectLinuxLibc() {
-  const family = detectLibc.familySync();
-  if (family === detectLibc.GLIBC) return "glibc";
-  if (family === detectLibc.MUSL) return "musl";
-  return "unknown";
+	const family = (0, detect_libc.familySync)();
+	if (family === detect_libc.GLIBC) return "glibc";
+	if (family === detect_libc.MUSL) return "musl";
+	return "unknown";
 }
 function getTursoDatabaseSupport(options = {}) {
-  const platform = options.platform ?? process.platform;
-  const arch = options.arch ?? process.arch;
-  if (platform === "darwin" && arch === "arm64") return { supported: true, platform, arch };
-  if (platform === "win32" && arch === "x64") return { supported: true, platform, arch };
-  if (platform === "linux") {
-    const linuxLibc = options.linuxLibc ?? detectLinuxLibc();
-    const supported = (arch === "x64" || arch === "arm64") && linuxLibc === "glibc";
-    return {
-      supported,
-      platform,
-      arch,
-      linuxLibc,
-      ...supported ? {} : { reason: `Turso Database requires Linux x64 or arm64 with glibc; detected ${arch}/${linuxLibc}.` }
-    };
-  }
-  return {
-    supported: false,
-    platform,
-    arch,
-    reason: `Turso Database does not provide a native binding for ${platform}/${arch}.`
-  };
+	const platform = options.platform ?? process.platform;
+	const arch = options.arch ?? process.arch;
+	if (platform === "darwin" && arch === "arm64") return {
+		supported: true,
+		platform,
+		arch
+	};
+	if (platform === "win32" && arch === "x64") return {
+		supported: true,
+		platform,
+		arch
+	};
+	if (platform === "linux") {
+		const linuxLibc = options.linuxLibc ?? detectLinuxLibc();
+		const supported = (arch === "x64" || arch === "arm64") && linuxLibc === "glibc";
+		return {
+			supported,
+			platform,
+			arch,
+			linuxLibc,
+			...supported ? {} : { reason: `Turso Database requires Linux x64 or arm64 with glibc; detected ${arch}/${linuxLibc}.` }
+		};
+	}
+	return {
+		supported: false,
+		platform,
+		arch,
+		reason: `Turso Database does not provide a native binding for ${platform}/${arch}.`
+	};
 }
-
-// src/index.ts
-var TursoStore = class extends libsql.LibSQLStore {
-  #closePromise;
-  constructor(config) {
-    if (!config.id || typeof config.id !== "string" || config.id.trim() === "") {
-      throw new Error("TursoStore: id must be provided and cannot be empty.");
-    }
-    let client;
-    if ("client" in config && config.client) {
-      client = config.client;
-    } else {
-      if (!config.path || typeof config.path !== "string" || config.path.trim() === "") {
-        throw new Error("TursoStore: path must be provided and cannot be empty.");
-      }
-      const support = getTursoDatabaseSupport();
-      if (!support.supported) {
-        throw new Error(support.reason ?? `Turso Database is not supported on ${support.platform}/${support.arch}.`);
-      }
-      const clientConfig = {
-        path: config.path,
-        ...config.readonly === void 0 ? {} : { readonly: config.readonly },
-        ...config.fileMustExist === void 0 ? {} : { fileMustExist: config.fileMustExist },
-        ...config.timeout === void 0 ? {} : { timeout: config.timeout },
-        ...config.defaultQueryTimeout === void 0 ? {} : { defaultQueryTimeout: config.defaultQueryTimeout },
-        ...config.tracing === void 0 ? {} : { tracing: config.tracing },
-        ...config.experimental === void 0 ? {} : { experimental: config.experimental }
-      };
-      client = new TursoSqliteClient(clientConfig);
-    }
-    super({
-      id: config.id,
-      client,
-      ...config.maxRetries === void 0 ? {} : { maxRetries: config.maxRetries },
-      ...config.initialBackoffMs === void 0 ? {} : { initialBackoffMs: config.initialBackoffMs },
-      ...config.disableInit === void 0 ? {} : { disableInit: config.disableInit },
-      ...config.retention === void 0 ? {} : { retention: config.retention }
-    });
-    this.name = "TursoStore";
-  }
-  close() {
-    this.#closePromise ??= super.close();
-    return this.#closePromise;
-  }
+//#endregion
+//#region src/index.ts
+var TursoStore = class extends _mastra_libsql.LibSQLStore {
+	#closePromise;
+	constructor(config) {
+		if (!config.id || typeof config.id !== "string" || config.id.trim() === "") throw new Error("TursoStore: id must be provided and cannot be empty.");
+		let client;
+		if ("client" in config && config.client) client = config.client;
+		else {
+			if (!config.path || typeof config.path !== "string" || config.path.trim() === "") throw new Error("TursoStore: path must be provided and cannot be empty.");
+			const support = getTursoDatabaseSupport();
+			if (!support.supported) throw new Error(support.reason ?? `Turso Database is not supported on ${support.platform}/${support.arch}.`);
+			client = new TursoSqliteClient({
+				path: config.path,
+				...config.readonly === void 0 ? {} : { readonly: config.readonly },
+				...config.fileMustExist === void 0 ? {} : { fileMustExist: config.fileMustExist },
+				...config.timeout === void 0 ? {} : { timeout: config.timeout },
+				...config.defaultQueryTimeout === void 0 ? {} : { defaultQueryTimeout: config.defaultQueryTimeout },
+				...config.tracing === void 0 ? {} : { tracing: config.tracing },
+				...config.experimental === void 0 ? {} : { experimental: config.experimental }
+			});
+		}
+		super({
+			id: config.id,
+			client,
+			...config.maxRetries === void 0 ? {} : { maxRetries: config.maxRetries },
+			...config.initialBackoffMs === void 0 ? {} : { initialBackoffMs: config.initialBackoffMs },
+			...config.disableInit === void 0 ? {} : { disableInit: config.disableInit },
+			...config.retention === void 0 ? {} : { retention: config.retention }
+		});
+		this.name = "TursoStore";
+	}
+	close() {
+		this.#closePromise ??= super.close();
+		return this.#closePromise;
+	}
 };
-
+//#endregion
 exports.TursoStore = TursoStore;
 exports.getTursoDatabaseSupport = getTursoDatabaseSupport;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map