@statewalker/webrun-files-sqlite 0.10.2 → 0.11.0

package/dist/cjs/index.cjs

@@ -1,4 +1,19 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region ../../node_modules/.pnpm/@statewalker+db-sqlite@0.1.0/node_modules/@statewalker/db-sqlite/dist/index.mjs
+/** Key under which a SQLite Db carries its transaction hook. Shared across bundles via Symbol.for. */
+const SQLITE_TRANSACTION = Symbol.for("@statewalker/db-sqlite:transaction");
+const NO_HOOK = "inTransaction: this Db has no SQLite transaction hook. It is not a @statewalker/db-sqlite* Db, or it wraps one (a wrapper object loses the hook - pass the driver's Db itself), or it is the handle of a running transaction (nesting is not supported).";
+/**
+* Run `cb` in one SQLite transaction: every statement issued through `tx` commits together, or
+* none does if `cb` throws. Other calls on `db` wait until the transaction ends. `cb` must not do
+* external I/O and must be idempotent: a Durable Object may run it more than once.
+*/
+function inTransaction(db, cb) {
+	const hook = db[SQLITE_TRANSACTION];
+	if (typeof hook !== "function") return Promise.reject(/* @__PURE__ */ new Error(NO_HOOK));
+	return hook(cb);
+}
+//#endregion
 //#region ../webrun-files/dist/esm/index.js
 /**
 * The order every `FilesApi.list()` yields: paths compared by Unicode code
@@ -38,15 +53,31 @@ function normalizePath(filePath) {
 }
 //#endregion
 //#region src/bytes.ts
-/** Blobs arrive as Uint8Array (node:sqlite), ArrayBuffer (Durable Objects) or number[] (D1). */
+/** BLOBs arrive as Uint8Array from every @statewalker/db-sqlite driver; SQLAR may hold TEXT. */
 function toBytes(value) {
 	if (value instanceof Uint8Array) return value;
-	if (value instanceof ArrayBuffer) return new Uint8Array(value);
-	if (Array.isArray(value)) return Uint8Array.from(value);
 	if (typeof value === "string") return new TextEncoder().encode(value);
 	return /* @__PURE__ */ new Uint8Array(0);
 }
 //#endregion
+//#region src/run-statements.ts
+/**
+* Runs the statements in order on a transaction's Db and returns, per
+* statement, the rows it changed — zero exactly when it changed nothing. The
+* count is SQLite's `changes()` on the same connection, so index writes are
+* not counted. Call it only inside `inTransaction`; it does nothing but SQL,
+* so a retried transaction callback is safe.
+*/
+async function runStatements(tx, statements) {
+	const counts = [];
+	for (const { sql, params = [] } of statements) {
+		await tx.query(sql, params);
+		const [row] = await tx.query("SELECT changes() AS n");
+		counts.push(Number(row.n));
+	}
+	return counts;
+}
+//#endregion
 //#region src/blocks/byte-reader.ts
 /**
 * Pull bytes from a chunk source in bounded pieces.
@@ -353,33 +384,33 @@ async function* iterate(stream) {
 //#endregion
 //#region src/blocks/sqlite-files-api.ts
 const MiB = 1048576;
-/** Rows on Durable Objects and D1 are capped at 2 MB; leave room for deflate's worst case. */
+/** Rows on Durable Objects are capped at 2 MB; leave room for deflate's worst case. */
 const MAX_BLOCK_SIZE_LIMIT = 1.5 * MiB;
 const LIST_PAGE = 256;
 /**
 * A FilesApi over three SQLite tables: paths point at immutable contents, and
 * a content is a sequence of bounded, optionally compressed blocks. Reads and
 * writes stream one block at a time, so no file is ever held whole and no row
-* outgrows the 2 MB limit of Durable Objects and D1.
+* outgrows the 2 MB row limit of Durable Objects.
 *
 * Streaming happens outside transactions; every step that changes what a path
 * shows is one transaction, so an interruption leaves at most an unreferenced
 * content, which {@link sweep} removes.
 */
 var SqliteFilesApi = class {
-	#sql;
+	#db;
 	#codec;
 	#blockSize;
 	#paths;
 	#files;
 	#blocks;
 	#prefix;
-	constructor(sql, opts = {}) {
+	constructor(db, opts = {}) {
 		const prefix = opts.tablePrefix ?? "fs_";
 		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(prefix)) throw new Error(`SqliteFilesApi: tablePrefix must be a plain SQL identifier, got ${prefix}`);
 		this.#blockSize = opts.blockSize ?? MiB;
 		if (!Number.isInteger(this.#blockSize) || this.#blockSize < 1 || this.#blockSize > MAX_BLOCK_SIZE_LIMIT) throw new Error(`SqliteFilesApi: blockSize must be an integer from 1 to ${MAX_BLOCK_SIZE_LIMIT}, got ${this.#blockSize}`);
-		this.#sql = sql;
+		this.#db = db;
 		this.#codec = opts.compression === void 0 ? availableWebCodec() : opts.compression;
 		this.#prefix = prefix;
 		this.#paths = `${prefix}paths`;
@@ -412,7 +443,7 @@ var SqliteFilesApi = class {
 			`CREATE INDEX IF NOT EXISTS ${this.#prefix}paths_fid ON ${this.#paths}(fid)`,
 			`CREATE INDEX IF NOT EXISTS ${this.#prefix}files_hash ON ${this.#files}(hash, size)`
 		];
-		for (const statement of statements) await this.#sql.run(statement);
+		for (const statement of statements) await this.#db.query(statement);
 	}
 	async *read(path, options = {}) {
 		options.signal?.throwIfAborted();
@@ -456,8 +487,12 @@ var SqliteFilesApi = class {
 	async write(path, content) {
 		const name = normalizePath(path);
 		const compression = this.#codec?.name ?? "none";
-		const fid = (await this.#sql.all(`INSERT INTO ${this.#files}(size, compression, block_size, hash, updated)
-       VALUES (NULL, ?, ?, NULL, ?) RETURNING fid`, compression, this.#blockSize, Date.now()))[0].fid;
+		const fid = await inTransaction(this.#db, async (tx) => (await tx.query(`INSERT INTO ${this.#files}(size, compression, block_size, hash, updated)
+             VALUES (NULL, ?, ?, NULL, ?) RETURNING fid`, [
+			compression,
+			this.#blockSize,
+			Date.now()
+		]))[0].fid);
 		const limit = this.#blockSize;
 		const reader = new ByteReader(content);
 		const hash = new Sha256();
@@ -478,7 +513,7 @@ var SqliteFilesApi = class {
 					}
 				};
 				const block = await collectBlock(this.#codec ? this.#codec.compress(pieces()) : pieces());
-				const [alive] = await this.#sql.transaction([{
+				const [alive] = await this.#transaction([{
 					sql: `UPDATE ${this.#files} SET updated = ? WHERE fid = ? AND size IS NULL`,
 					params: [Date.now(), fid]
 				}, {
@@ -495,14 +530,14 @@ var SqliteFilesApi = class {
 				size += raw;
 			}
 			const previous = await this.#entry(name);
-			const [finished] = await this.#sql.transaction(this.#finishWrite(name, fid, size, hash.digestHex(), compression, previous?.fid ?? null));
+			const [finished] = await this.#transaction(this.#finishWrite(name, fid, size, hash.digestHex(), compression, previous?.fid ?? null));
 			if (finished === 0) throw sweptDuringWrite(name);
 		} catch (error) {
 			try {
 				await reader.close();
 			} catch {}
 			try {
-				await this.#sql.transaction([{
+				await this.#transaction([{
 					sql: `DELETE FROM ${this.#files} WHERE fid = ? AND size IS NULL`,
 					params: [fid]
 				}, ...this.#deleteBlocksOfMissing(fid)]);
@@ -567,7 +602,7 @@ var SqliteFilesApi = class {
 	}
 	async mkdir(path) {
 		const now = Date.now();
-		for (const dir of ancestorsAndSelf$1(normalizePath(path))) await this.#sql.run(`INSERT INTO ${this.#paths}(path, fid, mtime) VALUES (?, NULL, ?) ON CONFLICT(path) DO NOTHING`, dir, now);
+		for (const dir of ancestorsAndSelf$1(normalizePath(path))) await this.#db.query(`INSERT INTO ${this.#paths}(path, fid, mtime) VALUES (?, NULL, ?) ON CONFLICT(path) DO NOTHING`, [dir, now]);
 	}
 	async stats(path) {
 		const name = normalizePath(path);
@@ -588,10 +623,10 @@ var SqliteFilesApi = class {
 		for (;;) {
 			const params = [...range.params, cursor];
 			if (!options.recursive) params.push(prefixLength + 1);
-			const rows = await this.#sql.all(`SELECT p.path, p.fid, p.mtime, f.size, f.compression, f.block_size
+			const rows = await this.#db.query(`SELECT p.path, p.fid, p.mtime, f.size, f.compression, f.block_size
          FROM ${this.#paths} p LEFT JOIN ${this.#files} f ON f.fid = p.fid
          WHERE ${range.where} AND p.path > ? ${directOnly}
-         ORDER BY p.path LIMIT ${LIST_PAGE}`, ...params);
+         ORDER BY p.path LIMIT ${LIST_PAGE}`, params);
 			for (const row of rows) {
 				const stats = toStats$1(row);
 				if (stats) yield {
@@ -605,7 +640,7 @@ var SqliteFilesApi = class {
 		}
 	}
 	async remove(path) {
-		const counts = await this.#sql.transaction(this.#removeTree(normalizePath(path)));
+		const counts = await this.#transaction(this.#removeTree(normalizePath(path)));
 		return counts[counts.length - 1] > 0;
 	}
 	/**
@@ -695,7 +730,7 @@ var SqliteFilesApi = class {
 				]
 			}
 		];
-		const counts = await this.#sql.transaction(statements);
+		const counts = await this.#transaction(statements);
 		return counts[counts.length - 1] > 0;
 	}
 	/**
@@ -714,7 +749,7 @@ var SqliteFilesApi = class {
 		const eligible = `f.updated < ? AND NOT EXISTS (
       SELECT 1 FROM ${this.#paths} p WHERE p.fid = f.fid
     )`;
-		const [, contents] = await this.#sql.transaction([{
+		const [, contents] = await this.#transaction([{
 			sql: `DELETE FROM ${this.#blocks} WHERE fid IN (SELECT f.fid FROM ${this.#files} f WHERE ${eligible})`,
 			params: [cutoff]
 		}, {
@@ -723,10 +758,14 @@ var SqliteFilesApi = class {
 		}]);
 		return contents;
 	}
+	/** The statements as one transaction; per statement, the rows it changed. */
+	#transaction(statements) {
+		return inTransaction(this.#db, (tx) => runStatements(tx, statements));
+	}
 	async #entry(name) {
-		return (await this.#sql.all(`SELECT p.fid, p.mtime, f.size, f.compression, f.block_size
+		return (await this.#db.query(`SELECT p.fid, p.mtime, f.size, f.compression, f.block_size
        FROM ${this.#paths} p LEFT JOIN ${this.#files} f ON f.fid = p.fid
-       WHERE p.path = ?`, name))[0];
+       WHERE p.path = ?`, [name]))[0];
 	}
 	#decoder(name, compression) {
 		if (compression === "none") return null;
@@ -738,7 +777,7 @@ var SqliteFilesApi = class {
 		throw new Error(`sqlite-files: ${name} is compressed with ${compression}, and no codec reads it`);
 	}
 	async #block(fid, shift) {
-		return (await this.#sql.all(`SELECT shift, block FROM ${this.#blocks} WHERE fid = ? AND shift = ?`, fid, shift))[0];
+		return (await this.#db.query(`SELECT shift, block FROM ${this.#blocks} WHERE fid = ? AND shift = ?`, [fid, shift]))[0];
 	}
 	/** A subquery selecting the content `fid` while it is still pending. */
 	#pending(fid) {
@@ -872,79 +911,6 @@ async function pipe(bytes, transform) {
 	return new Uint8Array(await new Response(stream).arrayBuffer());
 }
 //#endregion
-//#region src/drivers.ts
-/** node:sqlite — local development, tests and any Node deployment. */
-var NodeSqlDriver = class {
-	#db;
-	constructor(db) {
-		this.#db = db;
-	}
-	all(sql, ...params) {
-		return this.#db.prepare(sql).all(...params);
-	}
-	run(sql, ...params) {
-		this.#db.prepare(sql).run(...params);
-	}
-	/** Synchronous from BEGIN to COMMIT, so no other call can interleave on the connection. */
-	transaction(statements) {
-		this.#db.exec("BEGIN IMMEDIATE");
-		try {
-			const counts = statements.map(({ sql, params = [] }) => Number(this.#db.prepare(sql).run(...params).changes));
-			this.#db.exec("COMMIT");
-			return counts;
-		} catch (error) {
-			this.#db.exec("ROLLBACK");
-			throw error;
-		}
-	}
-};
-/**
-* Durable Object SQLite storage: pass `ctx.storage`. Synchronous; BLOBs come
-* back as ArrayBuffer. Transactions use `transactionSync`, since `sql.exec`
-* rejects `BEGIN`.
-*/
-var DoSqlDriver = class {
-	#storage;
-	constructor(storage) {
-		this.#storage = storage;
-	}
-	all(sql, ...params) {
-		return this.#storage.sql.exec(sql, ...params).toArray();
-	}
-	run(sql, ...params) {
-		this.#storage.sql.exec(sql, ...params).toArray();
-	}
-	/**
-	* Counts come from SQLite's `changes()` on the same connection, not from the
-	* cursor's `rowsWritten`, which also counts every index row a write touches.
-	*/
-	transaction(statements) {
-		return this.#storage.transactionSync(() => statements.map(({ sql, params = [] }) => {
-			this.#storage.sql.exec(sql, ...params).toArray();
-			const [row] = this.#storage.sql.exec("SELECT changes() AS n").toArray();
-			return row.n;
-		}));
-	}
-};
-/** Cloudflare D1. Asynchronous; BLOBs come back as number[]; transactions are `batch()`. */
-var D1SqlDriver = class {
-	#db;
-	constructor(db) {
-		this.#db = db;
-	}
-	async all(sql, ...params) {
-		const { results } = await this.#db.prepare(sql).bind(...params).all();
-		return results;
-	}
-	async run(sql, ...params) {
-		await this.#db.prepare(sql).bind(...params).run();
-	}
-	async transaction(statements) {
-		if (statements.length === 0) return [];
-		return (await this.#db.batch(statements.map(({ sql, params = [] }) => this.#db.prepare(sql).bind(...params)))).map((result) => result.meta.changes);
-	}
-};
-//#endregion
 //#region src/sqlar-files-api.ts
 /**
 * The table, verbatim from the SQLite Archive specification. Five columns,
@@ -971,22 +937,22 @@ const MAX_SYMLINK_HOPS = 8;
 * missing path — and {@link symlink} / {@link readlink} expose the link itself.
 */
 var SqlarFilesApi = class {
-	#sql;
+	#db;
 	#codec;
-	constructor(sql, opts = {}) {
-		this.#sql = sql;
+	constructor(db, opts = {}) {
+		this.#db = db;
 		this.#codec = opts.codec ?? defaultCodec();
 	}
 	/** Creates the table if it is missing. Await it before any other call. */
 	async init() {
-		await this.#sql.run(SCHEMA);
+		await this.#db.query(SCHEMA);
 	}
 	/** A missing path or a directory yields nothing; a file yields one chunk. */
 	async *read(path, options = {}) {
 		options.signal?.throwIfAborted();
 		const resolved = await this.#resolve(toName(path));
 		if (resolved?.stats.kind !== "file") return;
-		const rows = await this.#sql.all("SELECT data FROM sqlar WHERE name = ?", resolved.name);
+		const rows = await this.#db.query("SELECT data FROM sqlar WHERE name = ?", [resolved.name]);
 		const content = await this.#content(resolved.name, resolved.stats.size, toBytes(rows[0]?.data));
 		options.signal?.throwIfAborted();
 		const start = options.start ?? 0;
@@ -1051,7 +1017,7 @@ var SqlarFilesApi = class {
 		if (resolved?.stats.kind !== "directory") return;
 		const base = resolved.name;
 		const range = descendants(base);
-		const rows = await this.#sql.all(`SELECT ${ROW_COLUMNS} FROM sqlar WHERE ${range.where} ORDER BY name`, ...range.params);
+		const rows = await this.#db.query(`SELECT ${ROW_COLUMNS} FROM sqlar WHERE ${range.where} ORDER BY name`, range.params);
 		const prefixLength = base === "" ? 0 : base.length + 1;
 		const seen = /* @__PURE__ */ new Set();
 		for (const row of rows) {
@@ -1081,8 +1047,8 @@ var SqlarFilesApi = class {
 	}
 	async remove(path) {
 		const range = selfAndDescendants(toName(path));
-		if ((await this.#sql.all(`SELECT 1 FROM sqlar WHERE ${range.where} LIMIT 1`, ...range.params)).length === 0) return false;
-		await this.#sql.run(`DELETE FROM sqlar WHERE ${range.where}`, ...range.params);
+		if ((await this.#db.query(`SELECT 1 FROM sqlar WHERE ${range.where} LIMIT 1`, range.params)).length === 0) return false;
+		await this.#db.query(`DELETE FROM sqlar WHERE ${range.where}`, range.params);
 		return true;
 	}
 	/**
@@ -1093,7 +1059,7 @@ var SqlarFilesApi = class {
 		const from = toName(source);
 		const to = toName(target);
 		const range = selfAndDescendants(from);
-		const rows = await this.#sql.all(`SELECT name, mode, sz, typeof(data) AS dtype, data FROM sqlar WHERE ${range.where}`, ...range.params);
+		const rows = await this.#db.query(`SELECT name, mode, sz, typeof(data) AS dtype, data FROM sqlar WHERE ${range.where}`, range.params);
 		if (rows.length === 0) return false;
 		await this.mkdir(parentName(to));
 		for (const row of rows) {
@@ -1147,16 +1113,22 @@ var SqlarFilesApi = class {
 		}
 	}
 	async #row(name) {
-		return (await this.#sql.all(`SELECT ${ROW_COLUMNS} FROM sqlar WHERE name = ?`, name))[0];
+		return (await this.#db.query(`SELECT ${ROW_COLUMNS} FROM sqlar WHERE name = ?`, [name]))[0];
 	}
 	async #hasDescendants(name) {
 		const range = descendants(name);
-		return (await this.#sql.all(`SELECT 1 FROM sqlar WHERE ${range.where} LIMIT 1`, ...range.params)).length > 0;
+		return (await this.#db.query(`SELECT 1 FROM sqlar WHERE ${range.where} LIMIT 1`, range.params)).length > 0;
 	}
 	async #put(name, mode, sz, data) {
-		await this.#sql.run(`INSERT INTO sqlar (name, mode, mtime, sz, data) VALUES (?, ?, ?, ?, ?)
+		await this.#db.query(`INSERT INTO sqlar (name, mode, mtime, sz, data) VALUES (?, ?, ?, ?, ?)
        ON CONFLICT(name) DO UPDATE SET
-         mode = excluded.mode, mtime = excluded.mtime, sz = excluded.sz, data = excluded.data`, name, mode, Math.floor(Date.now() / 1e3), sz, data);
+         mode = excluded.mode, mtime = excluded.mtime, sz = excluded.sz, data = excluded.data`, [
+			name,
+			mode,
+			Math.floor(Date.now() / 1e3),
+			sz,
+			data
+		]);
 	}
 };
 const ROW_COLUMNS = "name, mode, mtime, sz, typeof(data) AS dtype, CASE WHEN sz = -1 THEN data END AS target";
@@ -1251,9 +1223,6 @@ async function concat(content) {
 	return out;
 }
 //#endregion
-exports.D1SqlDriver = D1SqlDriver;
-exports.DoSqlDriver = DoSqlDriver;
-exports.NodeSqlDriver = NodeSqlDriver;
 exports.SqlarFilesApi = SqlarFilesApi;
 exports.SqliteFilesApi = SqliteFilesApi;
 exports.defaultCodec = defaultCodec;