@saasqlite/client 0.0.1

package/dist/index.js

@@ -0,0 +1,861 @@
+import { createConnection } from "node:net";
+//#region src/errors.ts
+var SaaSQLiteError = class extends Error {
+	code;
+	details;
+	queryId;
+	sqliteCode;
+	cause;
+	constructor(code, message, options) {
+		super(message);
+		this.name = "SaaSQLiteError";
+		this.code = code;
+		this.details = options?.details;
+		this.queryId = options?.queryId;
+		this.sqliteCode = options?.sqliteCode || code;
+		this.cause = options?.cause;
+	}
+	toJSON() {
+		return {
+			code: this.code,
+			message: this.message,
+			details: this.details,
+			queryId: this.queryId,
+			sqliteCode: this.sqliteCode
+		};
+	}
+};
+//#endregion
+//#region src/params.ts
+function resolveParams(sql, params) {
+	if (!params) return {
+		sql,
+		positionalParams: []
+	};
+	if (Array.isArray(params)) return {
+		sql,
+		positionalParams: params
+	};
+	const paramObj = params;
+	const values = /* @__PURE__ */ new Map();
+	const positionalParams = [];
+	for (const [key, value] of Object.entries(paramObj)) {
+		const normalized = key.replace(/^[:@$]/, "");
+		values.set(normalized.toLowerCase(), value);
+	}
+	let result = sql;
+	result = result.replace(/@([A-Za-z_]\w*)/g, (_, name) => {
+		const val = values.get(name.toLowerCase());
+		if (val === void 0) throw new SaaSQLiteError("SQLITE_RANGE", `No value supplied for param binding @${name}`);
+		positionalParams.push(val);
+		return "?";
+	});
+	result = result.replace(/:(?![.0-9])([A-Za-z_]\w*)/g, (_, name) => {
+		const val = values.get(name.toLowerCase());
+		if (val === void 0) throw new SaaSQLiteError("SQLITE_RANGE", `No value supplied for param binding :${name}`);
+		positionalParams.push(val);
+		return "?";
+	});
+	result = result.replace(/\$([A-Za-z_]\w*)/g, (_, name) => {
+		const val = values.get(name.toLowerCase());
+		if (val === void 0) throw new SaaSQLiteError("SQLITE_RANGE", `No value supplied for param binding $${name}`);
+		positionalParams.push(val);
+		return "?";
+	});
+	return {
+		sql: result,
+		positionalParams
+	};
+}
+function countParameters(sql) {
+	let count = 0;
+	let i = 0;
+	while (i < sql.length) {
+		const ch = sql[i];
+		if (ch === "?") {
+			if (i + 1 < sql.length && /\d/.test(sql[i + 1])) {
+				i += 2;
+				continue;
+			}
+			count++;
+			i++;
+			continue;
+		}
+		if (ch === "@") {
+			if (i + 1 < sql.length && /[A-Za-z_]/.test(sql[i + 1])) {
+				i += 2;
+				while (i < sql.length && /\w/.test(sql[i])) i++;
+				continue;
+			}
+			i++;
+			continue;
+		}
+		if (ch === ":" && i + 1 < sql.length && /[A-Za-z_]/.test(sql[i + 1])) {
+			i += 2;
+			while (i < sql.length && /\w/.test(sql[i])) i++;
+			continue;
+		}
+		if (ch === "$" && i + 1 < sql.length && /[A-Za-z_]/.test(sql[i + 1])) {
+			i += 2;
+			while (i < sql.length && /\w/.test(sql[i])) i++;
+			continue;
+		}
+		i++;
+	}
+	return count;
+}
+//#endregion
+//#region src/statement.ts
+function isReaderSQL(sql) {
+	const trimmed = sql.trim().toUpperCase();
+	return trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || trimmed.startsWith("WITH");
+}
+function isReadonlySQL(sql) {
+	const trimmed = sql.trim().toUpperCase();
+	if (trimmed.startsWith("SELECT")) return true;
+	if (trimmed.startsWith("PRAGMA")) return !trimmed.includes("=") && !trimmed.includes("CHECKPOINT");
+	return false;
+}
+function applyRowMode(row, columns, mode) {
+	switch (mode) {
+		case "pluck": return row[columns[0]];
+		case "raw": return columns.map((c) => row[c]);
+		case "expand":
+			const expanded = {};
+			for (const col of columns) {
+				const parts = col.includes(".") ? col.split(".") : [null, col];
+				const table = parts[0];
+				const name = parts[1];
+				expanded[table ? `${table}.${name}` : `$${name}`] = row[col];
+			}
+			return expanded;
+		default: return row;
+	}
+}
+var Statement = class {
+	source;
+	reader;
+	readonly;
+	_busy = false;
+	_changes = 0;
+	_pluck = false;
+	_raw = false;
+	_expand = false;
+	_boundParams = null;
+	constructor(sql, transport, timeoutMs) {
+		this.sql = sql;
+		this.transport = transport;
+		this.timeoutMs = timeoutMs;
+		this.source = sql;
+		this.reader = isReaderSQL(sql);
+		this.readonly = isReadonlySQL(sql);
+	}
+	get busy() {
+		return this._busy;
+	}
+	get changes() {
+		return this._changes;
+	}
+	pluck(enable = true) {
+		this._pluck = enable;
+		this._raw = false;
+		this._expand = false;
+		return this;
+	}
+	raw(enable = true) {
+		this._raw = enable;
+		this._pluck = false;
+		this._expand = false;
+		return this;
+	}
+	expand(enable = true) {
+		this._expand = enable;
+		this._pluck = false;
+		this._raw = false;
+		return this;
+	}
+	get rowMode() {
+		if (this._pluck) return "pluck";
+		if (this._raw) return "raw";
+		if (this._expand) return "expand";
+		return "normal";
+	}
+	bind(...params) {
+		if (this._boundParams !== null) throw new SaaSQLiteError("SQLITE_MISUSE", "Cannot bind parameters to an already bound statement");
+		this._boundParams = params;
+		return this;
+	}
+	columns() {
+		if (!this.reader) throw new SaaSQLiteError("SQLITE_MISUSE", "Cannot call columns() on a statement that does not return data");
+		return [];
+	}
+	async get(...params) {
+		const rows = await this.all(...params);
+		return rows.length > 0 ? rows[0] : void 0;
+	}
+	async all(...params) {
+		const { sql, positionalParams } = this.resolveParams(params);
+		const result = await this.executeRequest({
+			sql,
+			params: positionalParams
+		});
+		if (result.resultType === "select") {
+			const mode = this.rowMode;
+			if (mode === "normal") return result.rows;
+			return result.rows.map((row) => applyRowMode(row, result.columns, mode));
+		}
+		return [];
+	}
+	async run(...params) {
+		const { sql, positionalParams } = this.resolveParams(params);
+		const result = await this.executeRequest({
+			sql,
+			params: positionalParams
+		});
+		if (result.resultType === "run") {
+			this._changes = result.rowsAffected;
+			return {
+				changes: result.rowsAffected,
+				lastInsertRowid: result.lastInsertRowid || null
+			};
+		}
+		return {
+			changes: 0,
+			lastInsertRowid: null
+		};
+	}
+	async *iterate(...params) {
+		const rows = await this.all(...params);
+		for (const row of rows) yield row;
+	}
+	resolveParams(params) {
+		if (this._boundParams !== null) {
+			if (params.length > 0) throw new SaaSQLiteError("SQLITE_MISUSE", "Cannot supply parameters to a bound statement");
+			return {
+				sql: this.sql,
+				positionalParams: this._boundParams
+			};
+		}
+		if (params.length === 1 && !Array.isArray(params[0]) && typeof params[0] === "object" && params[0] !== null) {
+			const resolved = resolveParams(this.sql, params[0]);
+			return {
+				sql: resolved.sql,
+				positionalParams: resolved.positionalParams
+			};
+		}
+		return {
+			sql: this.sql,
+			positionalParams: params
+		};
+	}
+	async executeRequest(statement) {
+		this._busy = true;
+		try {
+			return await this.transport.query(statement.sql, statement.params ?? []);
+		} catch (error) {
+			if (error instanceof SaaSQLiteError) throw error;
+			if (error instanceof Error && error.name === "AbortError") throw new SaaSQLiteError("SQLITE_BUSY", `Query timed out after ${this.timeoutMs}ms`);
+			throw new SaaSQLiteError("SQLITE_ERROR", error instanceof Error ? error.message : "Unknown error occurred");
+		} finally {
+			this._busy = false;
+		}
+	}
+};
+//#endregion
+//#region src/transaction.ts
+var Transaction = class {
+	constructor(db) {
+		this.db = db;
+	}
+	prepare(sql) {
+		return this.db.prepare(sql);
+	}
+	async exec(sql) {
+		await this.db.exec(sql);
+		return this;
+	}
+	async run(sql, ...params) {
+		return this.db.run(sql, params);
+	}
+	async get(sql, ...params) {
+		return this.db.get(sql, params);
+	}
+	async all(sql, ...params) {
+		return this.db.all(sql, params);
+	}
+};
+//#endregion
+//#region src/transport.ts
+var HttpTransport = class {
+	baseUrl;
+	token;
+	timeoutMs;
+	closed = false;
+	constructor(opts) {
+		this.baseUrl = opts.url.replace(/\/+$/, "");
+		this.token = opts.token;
+		this.timeoutMs = opts.timeoutMs ?? 5e3;
+	}
+	async request(path, body) {
+		if (this.closed) throw new SaaSQLiteError("SQLITE_MISUSE", "HttpTransport is closed.");
+		const url = `${this.baseUrl}${path}`;
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+		try {
+			const res = await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"Authorization": `Bearer ${this.token}`
+				},
+				body: JSON.stringify(body),
+				signal: controller.signal
+			});
+			const data = await res.json();
+			if (!res.ok) {
+				const err = data.error || {};
+				throw new SaaSQLiteError(err.code || "HTTP_ERROR", err.message || `HTTP ${res.status}: ${res.statusText}`);
+			}
+			return data;
+		} catch (error) {
+			if (error instanceof SaaSQLiteError) throw error;
+			if (error.name === "AbortError") throw new SaaSQLiteError("QUERY_TIMEOUT", `Request timed out after ${this.timeoutMs}ms`);
+			throw new SaaSQLiteError("CONNECTION_ERROR", error.message || "Failed to connect to gateway");
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async query(sql, params) {
+		const response = await this.request("/v1/query", {
+			sql,
+			params
+		});
+		if ("columns" in response && response.columns !== void 0) return {
+			resultType: "select",
+			columns: response.columns,
+			rows: response.rows || []
+		};
+		return {
+			resultType: "run",
+			rowsAffected: response.rowsAffected ?? 0,
+			lastInsertRowid: response.lastInsertRowid ?? 0
+		};
+	}
+	async batch(statements) {
+		return (await this.request("/v1/batch", { statements: statements.map((s) => ({
+			sql: s.sql,
+			params: s.params || []
+		})) })).results;
+	}
+	async close() {
+		this.closed = true;
+	}
+};
+//#endregion
+//#region src/protocol.ts
+const CMD_QUERY = 0;
+const CMD_BATCH = 1;
+const CMD_HEALTH = 2;
+const STATUS_OK = 0;
+const STATUS_ERR = 1;
+const RESULT_SELECT = 0;
+const RESULT_RUN = 1;
+const VAL_NULL = 0;
+const VAL_INT64 = 1;
+const VAL_FLOAT64 = 2;
+const VAL_TEXT = 3;
+const VAL_BLOB = 4;
+var Reader = class {
+	buf = Buffer.alloc(0);
+	async read(s, n) {
+		while (this.buf.length < n) {
+			const chunk = await new Promise((res, rej) => {
+				s.once("error", rej);
+				s.once("close", () => rej(new SaaSQLiteError("CONNECTION_ERROR", "Socket closed during read")));
+				s.once("data", (d) => res(d));
+			});
+			this.buf = Buffer.concat([this.buf, chunk]);
+		}
+		const r = this.buf.slice(0, n);
+		this.buf = this.buf.slice(n);
+		return r;
+	}
+};
+function w32(b, o, v) {
+	b[o] = v & 255;
+	b[o + 1] = v >> 8 & 255;
+	b[o + 2] = v >> 16 & 255;
+	b[o + 3] = v >> 24 & 255;
+}
+function r32(b, o) {
+	return b[o] | b[o + 1] << 8 | b[o + 2] << 16 | b[o + 3] << 24;
+}
+function w64(b, o, v) {
+	let u = BigInt(v) & 18446744073709551615n;
+	for (let i = 0; i < 8; i++) {
+		b[o + i] = Number(u & 255n);
+		u >>= 8n;
+	}
+}
+function r64(b, o) {
+	let u = 0n;
+	for (let i = 7; i >= 0; i--) u = u << 8n | BigInt(b[o + i]);
+	if (u & 1n << 63n) u -= 1n << 64n;
+	return Number(u);
+}
+function wF64(b, o, v) {
+	const d = Buffer.alloc(8);
+	d.writeDoubleLE(v, 0);
+	d.copy(b, o, 0, 8);
+}
+function rF64(b, o) {
+	return b.slice(o, o + 8).readDoubleLE(0);
+}
+function encParam(p) {
+	if (p == null) return Buffer.from([0]);
+	if (typeof p === "boolean") {
+		const b = Buffer.alloc(13);
+		b[0] = 1;
+		w32(b, 1, 0);
+		w64(b, 5, p ? 1 : 0);
+		return b;
+	}
+	if (typeof p === "number") {
+		const b = Buffer.alloc(13);
+		if (Number.isInteger(p)) {
+			b[0] = 1;
+			w32(b, 1, 0);
+			w64(b, 5, p);
+		} else {
+			b[0] = 2;
+			w32(b, 1, 0);
+			wF64(b, 5, p);
+		}
+		return b;
+	}
+	if (typeof p === "string") {
+		const t = Buffer.from(p, "utf-8");
+		const b = Buffer.alloc(5 + t.length);
+		b[0] = 3;
+		w32(b, 1, t.length);
+		t.copy(b, 5);
+		return b;
+	}
+	if (p instanceof Uint8Array) {
+		const bl = Buffer.from(p);
+		const b = Buffer.alloc(5 + bl.length);
+		b[0] = 4;
+		w32(b, 1, bl.length);
+		bl.copy(b, 5);
+		return b;
+	}
+	throw new SaaSQLiteError("INVALID_PARAM", `Unsupported param type: ${typeof p}`);
+}
+function encQuery(sql, params) {
+	const sb = Buffer.from(sql, "utf-8");
+	const pb = params.map(encParam);
+	const pl = pb.reduce((s, b) => s + b.length, 0);
+	const b = Buffer.alloc(5 + sb.length + 4 + pl);
+	let o = 0;
+	b[o++] = 0;
+	w32(b, o, sb.length);
+	o += 4;
+	sb.copy(b, o);
+	o += sb.length;
+	w32(b, o, params.length);
+	o += 4;
+	for (const p of pb) {
+		p.copy(b, o);
+		o += p.length;
+	}
+	return b;
+}
+function encBatch(stmts) {
+	const sbs = stmts.map((stmt) => {
+		const sb = Buffer.from(stmt.sql, "utf-8");
+		const ps = stmt.params || [];
+		const pb = ps.map(encParam);
+		const pl = pb.reduce((s, b) => s + b.length, 0);
+		const b = Buffer.alloc(4 + sb.length + 4 + pl);
+		let o = 0;
+		w32(b, o, sb.length);
+		o += 4;
+		sb.copy(b, o);
+		o += sb.length;
+		w32(b, o, ps.length);
+		o += 4;
+		for (const p of pb) {
+			p.copy(b, o);
+			o += p.length;
+		}
+		return b;
+	});
+	const sl = sbs.reduce((s, b) => s + b.length, 0);
+	const b = Buffer.alloc(5 + sl);
+	let o = 0;
+	b[o++] = 1;
+	w32(b, o, stmts.length);
+	o += 4;
+	for (const s of sbs) {
+		s.copy(b, o);
+		o += s.length;
+	}
+	return b;
+}
+function encHealth() {
+	return Buffer.from([2]);
+}
+async function readVal(r, s) {
+	const vt = (await r.read(s, 1))[0];
+	if (vt === 0) return null;
+	if (vt === 1) {
+		await r.read(s, 4);
+		return r64(await r.read(s, 8), 0);
+	}
+	if (vt === 2) {
+		await r.read(s, 4);
+		return rF64(await r.read(s, 8), 0);
+	}
+	if (vt === 3) {
+		const l = r32(await r.read(s, 4), 0);
+		return (await r.read(s, l)).toString("utf-8");
+	}
+	if (vt === 4) {
+		const l = r32(await r.read(s, 4), 0);
+		return await r.read(s, l);
+	}
+	throw new SaaSQLiteError("PROTOCOL_ERROR", `Unknown value type: ${vt}`);
+}
+async function readSelect(r, s) {
+	const cc = r32(await r.read(s, 4), 0);
+	const cols = [];
+	for (let i = 0; i < cc; i++) {
+		const cl = r32(await r.read(s, 4), 0);
+		cols.push((await r.read(s, cl)).toString("utf-8"));
+	}
+	const rc = r32(await r.read(s, 4), 0);
+	const rows = [];
+	for (let i = 0; i < rc; i++) {
+		const row = {};
+		for (let j = 0; j < cc; j++) row[cols[j]] = await readVal(r, s);
+		rows.push(row);
+	}
+	return {
+		columns: cols,
+		rows
+	};
+}
+async function readRun(r, s) {
+	return {
+		rowsAffected: r32(await r.read(s, 4), 0),
+		lastInsertRowid: r64(await r.read(s, 8), 0)
+	};
+}
+async function checkStatus(r, s) {
+	if ((await r.read(s, 1))[0] === 1) {
+		const ml = r32(await r.read(s, 4), 0);
+		throw new SaaSQLiteError("SQLITE_ERROR", (await r.read(s, ml)).toString("utf-8"));
+	}
+}
+//#endregion
+//#region src/socket-transport.ts
+var SocketTransport = class {
+	sockPath;
+	password;
+	timeoutMs;
+	closed = false;
+	constructor(opts) {
+		this.sockPath = opts.sock;
+		this.password = opts.password;
+		this.timeoutMs = opts.timeoutMs ?? 5e3;
+	}
+	async withSocket(fn) {
+		if (this.closed) throw new SaaSQLiteError("SQLITE_MISUSE", "SocketTransport is closed.");
+		return new Promise((resolve, reject) => {
+			const sock = createConnection(this.sockPath);
+			let settled = false;
+			const timer = setTimeout(() => {
+				if (!settled) {
+					settled = true;
+					sock.destroy();
+					reject(new SaaSQLiteError("QUERY_TIMEOUT", `Timed out after ${this.timeoutMs}ms`));
+				}
+			}, this.timeoutMs);
+			sock.once("connect", () => {
+				sock.write(`Bearer ${this.password}\n`);
+				fn(sock, new Reader()).then((res) => {
+					if (!settled) {
+						settled = true;
+						clearTimeout(timer);
+						sock.destroy();
+						resolve(res);
+					}
+				}).catch((err) => {
+					if (!settled) {
+						settled = true;
+						clearTimeout(timer);
+						sock.destroy();
+						reject(err);
+					}
+				});
+			});
+			sock.once("error", (err) => {
+				if (!settled) {
+					settled = true;
+					clearTimeout(timer);
+					reject(new SaaSQLiteError("CONNECTION_ERROR", err.message));
+				}
+			});
+		});
+	}
+	async query(sql, params) {
+		return this.withSocket(async (s, r) => {
+			s.write(encQuery(sql, params));
+			await checkStatus(r, s);
+			if ((await r.read(s, 1))[0] === 0) {
+				const sel = await readSelect(r, s);
+				return {
+					resultType: "select",
+					columns: sel.columns,
+					rows: sel.rows
+				};
+			} else {
+				const run = await readRun(r, s);
+				return {
+					resultType: "run",
+					rowsAffected: run.rowsAffected,
+					lastInsertRowid: run.lastInsertRowid
+				};
+			}
+		});
+	}
+	async batch(statements) {
+		return this.withSocket(async (s, r) => {
+			s.write(encBatch(statements));
+			await checkStatus(r, s);
+			await r.read(s, 1);
+			const count = r32(await r.read(s, 4), 0);
+			const results = [];
+			for (let i = 0; i < count; i++) {
+				if ((await r.read(s, 1))[0] === 1) {
+					const ml = r32(await r.read(s, 4), 0);
+					const msg = (await r.read(s, ml)).toString("utf-8");
+					results.push({
+						code: "SQLITE_ERROR",
+						message: msg
+					});
+					continue;
+				}
+				if ((await r.read(s, 1))[0] === 0) {
+					const sel = await readSelect(r, s);
+					results.push({
+						type: "select",
+						result: {
+							columns: sel.columns,
+							rows: sel.rows
+						}
+					});
+				} else {
+					const rn = await readRun(r, s);
+					results.push({
+						type: "run",
+						result: {
+							rowsAffected: rn.rowsAffected,
+							lastInsertRowid: rn.lastInsertRowid,
+							durationMs: 0
+						}
+					});
+				}
+			}
+			return results;
+		});
+	}
+	async close() {
+		this.closed = true;
+	}
+};
+//#endregion
+//#region src/client.ts
+/**
+* Default SaaSQLite gateway (remote cloud endpoint).
+*/
+const DEFAULT_GATEWAY_URL = "https://api.saasqlite.com";
+function isHttpUrl(value) {
+	return /^https?:\/\//i.test(value);
+}
+function envGatewayUrl() {
+	if (typeof process === "undefined" || !process.env) return void 0;
+	const v = process.env.SAASQLITE_GATEWAY_URL;
+	return v && v.trim() ? v : void 0;
+}
+/**
+* Resolve the gateway base URL for a public-API constructor call.
+* Precedence: full http(s) URL passed as databaseId > options.gatewayUrl
+* > $SAASQLITE_GATEWAY_URL > DEFAULT_GATEWAY_URL.
+*/
+function resolveGatewayUrl(databaseId, opts = {}) {
+	if (isHttpUrl(databaseId)) return databaseId;
+	if (opts.gatewayUrl && opts.gatewayUrl.trim()) return opts.gatewayUrl;
+	return envGatewayUrl() ?? "https://api.saasqlite.com";
+}
+var SaaSQLite = class {
+	_transport;
+	_timeoutMs;
+	_closed = false;
+	_txDepth = 0;
+	get open() {
+		return !this._closed;
+	}
+	name;
+	constructor(first, second, third) {
+		if (typeof first === "string") {
+			const apiKey = typeof second === "string" ? second : "";
+			const opts = third ?? {};
+			const timeoutMs = opts.timeoutMs ?? 5e3;
+			this._timeoutMs = timeoutMs;
+			if (!isHttpUrl(first) && !first.trim()) throw new SaaSQLiteError("SQLITE_MISUSE", "databaseId must be a non-empty string (or a full http(s) gateway URL)");
+			this._transport = new HttpTransport({
+				url: resolveGatewayUrl(first, opts),
+				token: apiKey,
+				timeoutMs: this._timeoutMs
+			});
+			this.name = first;
+		} else {
+			this._timeoutMs = first.timeoutMs ?? 5e3;
+			if ("sock" in first) {
+				this._transport = new SocketTransport({
+					sock: first.sock,
+					password: first.password,
+					timeoutMs: this._timeoutMs
+				});
+				this.name = first.sock;
+			} else {
+				this._transport = new HttpTransport({
+					url: first.url,
+					token: first.token,
+					timeoutMs: this._timeoutMs
+				});
+				this.name = first.url;
+			}
+		}
+	}
+	async exec(sql) {
+		this.assertOpen();
+		try {
+			await this._transport.query(sql, []);
+		} catch (error) {
+			if (error instanceof SaaSQLiteError) throw error;
+			throw new SaaSQLiteError("SQLITE_ERROR", error instanceof Error ? error.message : "Unknown error occurred");
+		}
+		return this;
+	}
+	prepare(sql) {
+		this.assertOpen();
+		if (!sql || !sql.trim()) throw new SaaSQLiteError("SQLITE_MISUSE", "Cannot prepare empty SQL");
+		return new Statement(sql, this._transport, this._timeoutMs);
+	}
+	async pragma(sql, options) {
+		this.assertOpen();
+		if (typeof sql !== "string") throw new SaaSQLiteError("SQLITE_MISUSE", "pragma() requires a string argument");
+		if (sql.toUpperCase().startsWith("PRAGMA")) throw new SaaSQLiteError("SQLITE_ERROR", "PRAGMA keyword should not be included in pragma() call");
+		const pragmaSql = `PRAGMA ${sql}`;
+		const result = await this._transport.query(pragmaSql, []);
+		if (result.resultType !== "select") return [];
+		if (options?.simple) return result.rows.length > 0 ? Object.values(result.rows[0])[0] : void 0;
+		return result.rows;
+	}
+	async transaction(fn) {
+		this.assertOpen();
+		if (typeof fn !== "function") throw new SaaSQLiteError("SQLITE_MISUSE", "transaction() requires a function argument");
+		const isNested = this._txDepth > 0;
+		const savepointName = `sp_${this._txDepth}`;
+		this._txDepth++;
+		try {
+			if (isNested) await this.exec(`SAVEPOINT ${savepointName}`);
+			else await this.exec("BEGIN IMMEDIATE");
+			const result = await fn(new Transaction(this));
+			if (isNested) await this.exec(`RELEASE SAVEPOINT ${savepointName}`);
+			else await this.exec("COMMIT");
+			return result;
+		} catch (err) {
+			if (isNested) await this.exec(`ROLLBACK TO SAVEPOINT ${savepointName}`).catch(() => {});
+			else await this.exec("ROLLBACK").catch(() => {});
+			throw err;
+		} finally {
+			this._txDepth--;
+		}
+	}
+	async query(sql, params) {
+		this.assertOpen();
+		const stmt = this.prepare(sql);
+		if (!params) return stmt.all();
+		return Array.isArray(params) ? stmt.all(...params) : stmt.all(params);
+	}
+	async get(sql, params) {
+		this.assertOpen();
+		const stmt = this.prepare(sql);
+		if (!params) return stmt.get();
+		return Array.isArray(params) ? stmt.get(...params) : stmt.get(params);
+	}
+	async all(sql, params) {
+		this.assertOpen();
+		const stmt = this.prepare(sql);
+		if (!params) return stmt.all();
+		return Array.isArray(params) ? stmt.all(...params) : stmt.all(params);
+	}
+	async run(sql, params) {
+		this.assertOpen();
+		const stmt = this.prepare(sql);
+		if (!params) return stmt.run();
+		return Array.isArray(params) ? stmt.run(...params) : stmt.run(params);
+	}
+	async batch(statements) {
+		this.assertOpen();
+		try {
+			return await this._transport.batch(statements);
+		} catch (error) {
+			if (error instanceof SaaSQLiteError) throw error;
+			throw new SaaSQLiteError("SQLITE_ERROR", error instanceof Error ? error.message : "Unknown error occurred");
+		}
+	}
+	async close() {
+		this._closed = true;
+		await this._transport.close();
+	}
+	function(_name, ..._args) {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "User-defined functions are not supported in SaaSQLite");
+	}
+	aggregate(_name, ..._args) {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "Custom aggregates are not supported in SaaSQLite");
+	}
+	table(_name, ..._args) {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "Virtual tables are not supported in SaaSQLite");
+	}
+	loadExtension(_path) {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "Loading extensions is not supported in SaaSQLite");
+	}
+	backup(_destination) {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "Backup is not supported via SDK. Use the dashboard or API.");
+	}
+	serialize() {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "Serialize is not supported in SaaSQLite");
+	}
+	checkpoint() {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "Checkpoint is not supported via SDK");
+	}
+	defaultSafeIntegers(_enabled) {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "defaultSafeIntegers is not supported in SaaSQLite");
+	}
+	unsafeMode(_enabled) {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "unsafeMode is not supported in SaaSQLite");
+	}
+	verbose(_fn) {
+		throw new SaaSQLiteError("NOT_SUPPORTED", "verbose is not supported in SaaSQLite");
+	}
+	assertOpen() {
+		if (this._closed) throw new SaaSQLiteError("SQLITE_MISUSE", "SaaSQLite connection is closed");
+	}
+};
+SaaSQLite.SqliteError = SaaSQLiteError;
+//#endregion
+export { CMD_BATCH, CMD_HEALTH, CMD_QUERY, DEFAULT_GATEWAY_URL, HttpTransport, RESULT_RUN, RESULT_SELECT, Reader, STATUS_ERR, STATUS_OK, SaaSQLite, SaaSQLiteError, SocketTransport, Statement, Transaction, VAL_BLOB, VAL_FLOAT64, VAL_INT64, VAL_NULL, VAL_TEXT, checkStatus, countParameters, encBatch, encHealth, encParam, encQuery, r32, r64, rF64, readRun, readSelect, readVal, resolveGatewayUrl, resolveParams, w32, w64, wF64 };