db-player 0.0.0-stage → 0.4.1

package/dist/server/assets/store-Bb9KDsJx.js

@@ -0,0 +1,827 @@
+import { z } from "zod";
+import { createClient } from "@clickhouse/client";
+import mysql from "mysql2/promise";
+import mysqlCore from "mysql2";
+import { chmodSync, closeSync, mkdirSync, openSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+// src/lib/types.ts
+var DB_KINDS = ["mysql", "clickhouse"];
+var DB_KIND_INFO = {
+	mysql: {
+		label: "MySQL",
+		defaultPort: 3306
+	},
+	clickhouse: {
+		label: "ClickHouse",
+		defaultPort: 8123
+	}
+};
+var FOLDER_COLORS = {
+	gray: "#8a8a8a",
+	red: "#ef4444",
+	orange: "#f97316",
+	yellow: "#eab308",
+	green: "#22c55e",
+	teal: "#14b8a6",
+	blue: "#3b82f6",
+	purple: "#a855f7"
+};
+var FOLDER_COLOR_NAMES = Object.keys(FOLDER_COLORS);
+var folderInputSchema = z.object({
+	name: z.string().trim().min(1, "Name is required").max(60),
+	color: z.enum(FOLDER_COLOR_NAMES)
+});
+var connectionInputSchema = z.object({
+	folderId: z.string().nullable(),
+	name: z.string().trim().min(1, "Name is required").max(80),
+	kind: z.enum(DB_KINDS),
+	host: z.string().trim().min(1, "Host is required"),
+	port: z.number().int().min(1).max(65535),
+	user: z.string().trim().min(1, "User is required"),
+	password: z.string(),
+	database: z.string().trim().nullable(),
+	secure: z.boolean()
+});
+var tabIdSchema = z.custom((v) => typeof v === "string" && v.length > 0);
+var newTabTargetSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("sql"),
+	connectionId: z.string().min(1),
+	database: z.string().min(1).nullable()
+}), z.object({
+	kind: z.literal("table"),
+	connectionId: z.string().min(1),
+	database: z.string().min(1),
+	table: z.string().min(1)
+})]);
+// src/server/drivers/shared.ts
+function normalizeCell(value) {
+	if (value === null || value === void 0) return null;
+	if (Buffer.isBuffer(value)) return `0x${value.toString("hex")}`;
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "object") return JSON.parse(JSON.stringify(value));
+	return value;
+}
+function fingerprint(parts) {
+	return JSON.stringify(parts);
+}
+var SQL_SCHEMA_ROW_CAP = 3e4;
+/** Database and table names are user data, so they key prototype-free objects. */
+function groupColumns(rows) {
+	const schema = Object.create(null);
+	for (const r of rows) {
+		const tables = schema[String(r.db)] ??= Object.create(null);
+		(tables[String(r.tbl)] ??= []).push({
+			name: String(r.col),
+			type: String(r.type)
+		});
+	}
+	return schema;
+}
+// src/server/drivers/clickhouse.ts
+/** One client per database, because the HTTP interface picks the database per client. */
+var clients = /* @__PURE__ */ new Map();
+function getClient(conn, database = conn.database) {
+	const key = fingerprint([
+		conn.host,
+		conn.port,
+		conn.user,
+		conn.password,
+		conn.database,
+		conn.secure
+	]);
+	let entry = clients.get(conn.id);
+	if (entry?.key !== key) {
+		closeAll(entry);
+		entry = {
+			key,
+			byDatabase: /* @__PURE__ */ new Map()
+		};
+		clients.set(conn.id, entry);
+	}
+	const slot = database || "";
+	const cached = entry.byDatabase.get(slot);
+	if (cached) return cached;
+	const client = createClient({
+		url: `${conn.secure ? "https" : "http"}://${conn.host}:${conn.port}`,
+		username: conn.user,
+		password: conn.password,
+		database: database || void 0,
+		request_timeout: 3e4
+	});
+	entry.byDatabase.set(slot, client);
+	return client;
+}
+async function closeAll(entry) {
+	await Promise.all([...entry?.byDatabase.values() ?? []].map((client) => client.close().catch(() => {})));
+}
+var quote$1 = (name) => `\`${name.replaceAll("\\", "\\\\").replaceAll("`", "\\`")}\``;
+var qualified$1 = (ref) => `${quote$1(ref.database)}.${quote$1(ref.table)}`;
+var RETURNS_ROWS = /^[\s(]*(select|with|show|describe|desc|explain|exists|values)\b/i;
+async function fetchRows(client, query, query_params, settings) {
+	return await (await client.query({
+		query,
+		query_params,
+		format: "JSONCompact",
+		clickhouse_settings: settings
+	})).json();
+}
+async function objects(client, query, params) {
+	const { meta, data } = await fetchRows(client, query, params);
+	return data.map((row) => Object.fromEntries(row.map((v, i) => [meta[i]?.name ?? String(i), v])));
+}
+/** Parameter types cannot carry LowCardinality. */
+var paramType = (type) => type.replace(/LowCardinality\((.*)\)/, "$1");
+var Params = class {
+	n = 0;
+	values = {};
+	bind(value, type) {
+		const name = `p${this.n++}`;
+		this.values[name] = typeof value === "object" ? JSON.stringify(value) : value;
+		return `{${name}:${paramType(type)}}`;
+	}
+};
+async function columnTypes(client, ref) {
+	const rows = await objects(client, "SELECT name, type FROM system.columns WHERE database = {db:String} AND table = {t:String}", {
+		db: ref.database,
+		t: ref.table
+	});
+	return new Map(rows.map((r) => [String(r.name), String(r.type)]));
+}
+function condition(key, types, params) {
+	return Object.entries(key).map(([col, value]) => value === null ? `isNull(${quote$1(col)})` : `${quote$1(col)} = ${params.bind(value, types.get(col) ?? "String")}`).join(" AND ");
+}
+var MUTATION_SETTINGS = { mutations_sync: "2" };
+/** Level 2 refuses writes and DDL but still lets the client pass its own settings. */
+var READ_ONLY_SETTINGS = { readonly: "2" };
+var clickhouseDriver = {
+	async test(conn) {
+		const rows = await objects(getClient(conn), "SELECT version() AS v");
+		return { version: String(rows[0]?.v) };
+	},
+	async listDatabases(conn) {
+		return (await objects(getClient(conn), "SELECT name FROM system.databases ORDER BY name")).map((r) => String(r.name));
+	},
+	async listTables(conn, database) {
+		return (await objects(getClient(conn), "SELECT name, engine FROM system.tables WHERE database = {db:String} ORDER BY name", { db: database })).map((r) => ({
+			name: String(r.name),
+			isView: String(r.engine).endsWith("View")
+		}));
+	},
+	async describeTable(conn, ref) {
+		const client = getClient(conn);
+		const [cols, tables] = await Promise.all([objects(client, `SELECT name, type, default_expression, is_in_primary_key, is_in_sorting_key
+           FROM system.columns WHERE database = {db:String} AND table = {t:String} ORDER BY position`, {
+			db: ref.database,
+			t: ref.table
+		}), objects(client, "SELECT engine FROM system.tables WHERE database = {db:String} AND name = {t:String}", {
+			db: ref.database,
+			t: ref.table
+		})]);
+		const columns = cols.map((r) => ({
+			name: String(r.name),
+			type: String(r.type),
+			nullable: /Nullable\(/.test(String(r.type)),
+			isPrimaryKey: Number(r.is_in_primary_key) === 1 || Number(r.is_in_sorting_key) === 1,
+			default: r.default_expression ? String(r.default_expression) : null
+		}));
+		const keyColumns = columns.filter((c) => c.isPrimaryKey).map((c) => c.name);
+		const engine = String(tables[0]?.engine ?? "");
+		return {
+			columns,
+			keyColumns,
+			editBlockedReason: !engine.endsWith("MergeTree") ? `Engine ${engine || "unknown"} does not support row mutations. Editing is disabled.` : keyColumns.length === 0 ? "This table has no sorting key (ORDER BY tuple()), so rows cannot be addressed safely. Editing is disabled." : null
+		};
+	},
+	async sqlSchema(conn) {
+		const defaultDatabase = conn.database || "default";
+		return {
+			defaultDatabase,
+			schema: groupColumns(await objects(getClient(conn), `SELECT database AS db, table AS tbl, name AS col, type
+         FROM system.columns
+        WHERE database NOT IN ('system', 'INFORMATION_SCHEMA', 'information_schema')
+           OR database = {def:String}
+        ORDER BY database = {def:String} DESC, database, table, position
+        LIMIT ${SQL_SCHEMA_ROW_CAP}`, { def: defaultDatabase }))
+		};
+	},
+	async query(conn, sql, { database, limit, readOnly }) {
+		const client = getClient(conn, database ?? conn.database);
+		const text = sql.trim().replace(/;+\s*$/, "");
+		const started = performance.now();
+		if (!RETURNS_ROWS.test(text)) {
+			await client.command({
+				query: text,
+				clickhouse_settings: readOnly ? READ_ONLY_SETTINGS : MUTATION_SETTINGS
+			});
+			return {
+				columns: [],
+				rows: [],
+				rowCount: 0,
+				elapsedMs: Math.round(performance.now() - started),
+				truncated: false
+			};
+		}
+		const { meta, data } = await fetchRows(client, text, void 0, {
+			...readOnly ? READ_ONLY_SETTINGS : {},
+			max_result_rows: String(limit + 1),
+			result_overflow_mode: "break"
+		});
+		return {
+			columns: meta,
+			rows: data.slice(0, limit),
+			rowCount: Math.min(data.length, limit),
+			elapsedMs: Math.round(performance.now() - started),
+			truncated: data.length > limit
+		};
+	},
+	async selectRows(conn, ref, opts) {
+		const client = getClient(conn);
+		const started = performance.now();
+		const where = opts.where?.trim() ? ` WHERE ${opts.where}` : "";
+		const order = opts.orderBy ? ` ORDER BY ${quote$1(opts.orderBy.column)} ${opts.orderBy.direction === "desc" ? "DESC" : "ASC"}` : "";
+		const { meta, data } = await fetchRows(client, `SELECT * FROM ${qualified$1(ref)}${where}${order} LIMIT {limit:UInt32} OFFSET {offset:UInt64}`, {
+			limit: opts.limit,
+			offset: opts.offset
+		});
+		const counted = await objects(client, `SELECT count() AS n FROM ${qualified$1(ref)}${where}`);
+		return {
+			result: {
+				columns: meta,
+				rows: data,
+				rowCount: data.length,
+				elapsedMs: Math.round(performance.now() - started),
+				truncated: false
+			},
+			total: Number(counted[0]?.n ?? 0)
+		};
+	},
+	async updateRow(conn, ref, key, changes) {
+		const cols = Object.keys(changes);
+		if (cols.length === 0) return;
+		const client = getClient(conn);
+		const types = await columnTypes(client, ref);
+		const params = new Params();
+		const set = cols.map((c) => {
+			const v = changes[c];
+			return `${quote$1(c)} = ${v === null ? "NULL" : params.bind(v, types.get(c) ?? "String")}`;
+		}).join(", ");
+		const where = condition(key, types, params);
+		await client.command({
+			query: `ALTER TABLE ${qualified$1(ref)} UPDATE ${set} WHERE ${where}`,
+			query_params: params.values,
+			clickhouse_settings: MUTATION_SETTINGS
+		});
+	},
+	async insertRow(conn, ref, values) {
+		await getClient(conn).insert({
+			table: qualified$1(ref),
+			values: [values],
+			format: "JSONEachRow"
+		});
+	},
+	async deleteRows(conn, ref, keys) {
+		if (keys.length === 0) return;
+		const client = getClient(conn);
+		const types = await columnTypes(client, ref);
+		const params = new Params();
+		const where = keys.map((k) => `(${condition(k, types, params)})`).join(" OR ");
+		await client.command({
+			query: `ALTER TABLE ${qualified$1(ref)} DELETE WHERE ${where}`,
+			query_params: params.values,
+			clickhouse_settings: MUTATION_SETTINGS
+		});
+	},
+	async dispose(id) {
+		const cached = clients.get(id);
+		clients.delete(id);
+		await closeAll(cached);
+	}
+};
+// src/server/drivers/mysql.ts
+var pools = /* @__PURE__ */ new Map();
+function getPool(conn) {
+	const key = fingerprint([
+		conn.host,
+		conn.port,
+		conn.user,
+		conn.password,
+		conn.database,
+		conn.secure
+	]);
+	const cached = pools.get(conn.id);
+	if (cached?.key === key) return cached.pool;
+	cached?.pool.end().catch(() => {});
+	const pool = mysql.createPool({
+		host: conn.host,
+		port: conn.port,
+		user: conn.user,
+		password: conn.password,
+		database: conn.database || void 0,
+		ssl: conn.secure ? {} : void 0,
+		connectionLimit: 4,
+		connectTimeout: 8e3,
+		dateStrings: true,
+		supportBigNumbers: true,
+		bigNumberStrings: true
+	});
+	pools.set(conn.id, {
+		key,
+		pool
+	});
+	return pool;
+}
+var NO_MATCH = "No row matched the key. The row may have changed or been deleted.";
+var quote = (name) => `\`${name.replaceAll("`", "``")}\``;
+var qualified = (ref) => `${quote(ref.database)}.${quote(ref.table)}`;
+var typeNames = new Map(Object.entries(mysqlCore.Types).map(([name, id]) => [id, name]));
+function fieldType(field) {
+	const id = field.columnType;
+	return id !== void 0 && typeNames.get(id) || "UNKNOWN";
+}
+function whereKey(key) {
+	const params = [];
+	return {
+		sql: Object.entries(key).map(([col, value]) => {
+			if (value === null) return `${quote(col)} IS NULL`;
+			params.push(value);
+			return `${quote(col)} = ?`;
+		}).join(" AND "),
+		params
+	};
+}
+async function inTransaction$1(pool, fn) {
+	const c = await pool.getConnection();
+	try {
+		await c.beginTransaction();
+		const out = await fn(c);
+		await c.commit();
+		return out;
+	} catch (error) {
+		await c.rollback().catch(() => {});
+		throw error;
+	} finally {
+		c.release();
+	}
+}
+async function run(pool, sql, params, limit, session) {
+	const started = performance.now();
+	const conn = await pool.getConnection();
+	let overflowed = false;
+	try {
+		if (session?.use) await conn.query("USE ??", [session.use]);
+		if (session?.readOnly) {
+			await conn.query("SET SESSION TRANSACTION READ ONLY");
+			await conn.query("START TRANSACTION READ ONLY");
+		}
+		return {
+			...await new Promise((resolve, reject) => {
+				const rows = [];
+				let fields;
+				let affectedRows;
+				const finish = (truncated) => resolve({
+					columns: fields?.map((f) => ({
+						name: f.name,
+						type: fieldType(f)
+					})) ?? [],
+					rows,
+					rowCount: rows.length,
+					truncated,
+					...affectedRows === void 0 ? {} : { affectedRows }
+				});
+				const query = conn.connection.query({
+					sql,
+					values: params,
+					rowsAsArray: true
+				});
+				query.on("fields", (f) => {
+					fields = f;
+				});
+				query.on("result", (row) => {
+					if (!Array.isArray(row)) {
+						affectedRows = row.affectedRows;
+						return;
+					}
+					if (rows.length >= limit) {
+						overflowed = true;
+						conn.destroy();
+						finish(true);
+						return;
+					}
+					rows.push(row.map(normalizeCell));
+				});
+				query.on("error", reject);
+				query.on("end", () => finish(false));
+			}),
+			elapsedMs: Math.round(performance.now() - started)
+		};
+	} finally {
+		if (!overflowed) {
+			if (session?.discard) conn.destroy();
+			else conn.release();
+		}
+	}
+}
+async function rowsOf(pool, sql, params) {
+	const [rows] = await pool.query({
+		sql,
+		values: params
+	});
+	return rows;
+}
+// src/server/drivers/index.ts
+var drivers = {
+	mysql: {
+		async test(conn) {
+			const rows = await rowsOf(getPool(conn), "SELECT VERSION() AS v", []);
+			return { version: String(rows[0]?.v) };
+		},
+		async listDatabases(conn) {
+			return (await rowsOf(getPool(conn), "SELECT schema_name AS name FROM information_schema.schemata ORDER BY schema_name", [])).map((r) => String(r.name));
+		},
+		async listTables(conn, database) {
+			return (await rowsOf(getPool(conn), "SELECT table_name AS name, table_type AS type FROM information_schema.tables WHERE table_schema = ? ORDER BY table_name", [database])).map((r) => ({
+				name: String(r.name),
+				isView: r.type === "VIEW"
+			}));
+		},
+		async describeTable(conn, ref) {
+			const pool = getPool(conn);
+			const columns = (await rowsOf(pool, `SELECT column_name AS name, column_type AS type, is_nullable AS nullable,
+              column_key AS col_key, column_default AS dflt
+         FROM information_schema.columns
+        WHERE table_schema = ? AND table_name = ?
+        ORDER BY ordinal_position`, [ref.database, ref.table])).map((r) => ({
+				name: String(r.name),
+				type: String(r.type),
+				nullable: r.nullable === "YES",
+				isPrimaryKey: r.col_key === "PRI",
+				default: r.dflt === null || r.dflt === void 0 ? null : String(r.dflt)
+			}));
+			const tables = await rowsOf(pool, "SELECT table_type AS type FROM information_schema.tables WHERE table_schema = ? AND table_name = ?", [ref.database, ref.table]);
+			const keyColumns = columns.filter((c) => c.isPrimaryKey).map((c) => c.name);
+			return {
+				columns,
+				keyColumns,
+				editBlockedReason: tables[0]?.type === "VIEW" ? "Views are read-only." : keyColumns.length === 0 ? "This table has no primary key, so rows cannot be addressed safely. Editing is disabled." : null
+			};
+		},
+		async sqlSchema(conn) {
+			const rows = await rowsOf(getPool(conn), `SELECT table_schema AS db, table_name AS tbl, column_name AS col, column_type AS type
+         FROM information_schema.columns
+        WHERE table_schema NOT IN ('mysql', 'sys', 'performance_schema', 'information_schema')
+           OR table_schema = ?
+        ORDER BY table_schema = ? DESC, table_schema, table_name, ordinal_position
+        LIMIT ${SQL_SCHEMA_ROW_CAP}`, [conn.database ?? "", conn.database ?? ""]);
+			return {
+				defaultDatabase: conn.database || null,
+				schema: groupColumns(rows)
+			};
+		},
+		query(conn, sql, { database, limit, readOnly }) {
+			const use = database ?? (conn.database || void 0);
+			return run(getPool(conn), sql, void 0, limit, {
+				use,
+				discard: true,
+				readOnly
+			});
+		},
+		async selectRows(conn, ref, opts) {
+			const pool = getPool(conn);
+			const where = opts.where?.trim() ? ` WHERE ${opts.where}` : "";
+			const order = opts.orderBy ? ` ORDER BY ${quote(opts.orderBy.column)} ${opts.orderBy.direction === "desc" ? "DESC" : "ASC"}` : "";
+			const result = await run(pool, `SELECT * FROM ${qualified(ref)}${where}${order} LIMIT ? OFFSET ?`, [opts.limit, opts.offset], opts.limit);
+			const counted = await rowsOf(pool, `SELECT COUNT(*) AS n FROM ${qualified(ref)}${where}`, []);
+			return {
+				result,
+				total: Number(counted[0]?.n ?? 0)
+			};
+		},
+		async updateRow(conn, ref, key, changes) {
+			const cols = Object.keys(changes);
+			if (cols.length === 0) return;
+			const w = whereKey(key);
+			const sql = `UPDATE ${qualified(ref)} SET ${cols.map((c) => `${quote(c)} = ?`).join(", ")} WHERE ${w.sql} LIMIT 1`;
+			const [header] = await getPool(conn).query(sql, [...cols.map((c) => changes[c]), ...w.params]);
+			if (header.affectedRows === 0) throw new Error(NO_MATCH);
+		},
+		async insertRow(conn, ref, values) {
+			const cols = Object.keys(values);
+			const sql = cols.length === 0 ? `INSERT INTO ${qualified(ref)} () VALUES ()` : `INSERT INTO ${qualified(ref)} (${cols.map(quote).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`;
+			await getPool(conn).query(sql, cols.map((c) => values[c]));
+		},
+		async deleteRows(conn, ref, keys) {
+			await inTransaction$1(getPool(conn), async (c) => {
+				for (const key of keys) {
+					const w = whereKey(key);
+					const [header] = await c.query(`DELETE FROM ${qualified(ref)} WHERE ${w.sql} LIMIT 1`, w.params);
+					if (header.affectedRows === 0) throw new Error(NO_MATCH);
+				}
+			});
+		},
+		async dispose(id) {
+			const cached = pools.get(id);
+			pools.delete(id);
+			await cached?.pool.end().catch(() => {});
+		}
+	},
+	clickhouse: clickhouseDriver
+};
+// src/server/store.ts
+var db;
+function open() {
+	if (db) return db;
+	const file = resolve(process.env.DB_PLAYER_DATA ?? "data/db-player.sqlite");
+	const dir = dirname(file);
+	mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	chmodSync(dir, 448);
+	closeSync(openSync(file, "a", 384));
+	chmodSync(file, 384);
+	db = new DatabaseSync(file);
+	db.exec(`
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE IF NOT EXISTS folders (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      color TEXT NOT NULL,
+      position INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS connections (
+      id TEXT PRIMARY KEY,
+      folder_id TEXT REFERENCES folders(id) ON DELETE SET NULL,
+      name TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      host TEXT NOT NULL,
+      port INTEGER NOT NULL,
+      user TEXT NOT NULL,
+      password TEXT NOT NULL,
+      database TEXT,
+      secure INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE TABLE IF NOT EXISTS tabs (
+      id TEXT PRIMARY KEY,
+      kind TEXT NOT NULL,
+      connection_id TEXT NOT NULL,
+      database TEXT,
+      table_name TEXT,
+      serial INTEGER,
+      sql TEXT NOT NULL DEFAULT '',
+      position INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS workspace (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      active_tab_id TEXT
+    );
+    INSERT OR IGNORE INTO workspace (id, active_tab_id) VALUES (1, NULL);
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+	migrateWorkspaceRevision(db);
+	return db;
+}
+/**
+* `workspace.revision` counts every change to the tabs or the active tab, so a client can tell which
+* of two snapshots is newer. Triggers bump it, so no writer can forget and a new one is covered.
+*/
+function migrateWorkspaceRevision(d) {
+	if (!d.prepare("PRAGMA table_info(workspace)").all().some((c) => c.name === "revision")) d.exec("ALTER TABLE workspace ADD COLUMN revision INTEGER NOT NULL DEFAULT 0");
+	const bump = "UPDATE workspace SET revision = revision + 1 WHERE id = 1;";
+	d.exec(`
+    CREATE TRIGGER IF NOT EXISTS tabs_revision_insert AFTER INSERT ON tabs BEGIN ${bump} END;
+    CREATE TRIGGER IF NOT EXISTS tabs_revision_update AFTER UPDATE ON tabs BEGIN ${bump} END;
+    CREATE TRIGGER IF NOT EXISTS tabs_revision_delete AFTER DELETE ON tabs BEGIN ${bump} END;
+    CREATE TRIGGER IF NOT EXISTS workspace_revision_active
+      AFTER UPDATE OF active_tab_id ON workspace
+      BEGIN ${bump} END;
+  `);
+}
+var toFolder = (r) => ({
+	id: r.id,
+	name: r.name,
+	color: r.color,
+	position: r.position
+});
+var toConnection = (r) => ({
+	id: r.id,
+	folderId: r.folder_id,
+	name: r.name,
+	kind: r.kind,
+	host: r.host,
+	port: r.port,
+	user: r.user,
+	password: r.password,
+	database: r.database,
+	secure: r.secure === 1
+});
+function toSummary({ password, ...rest }) {
+	return {
+		...rest,
+		hasPassword: password.length > 0
+	};
+}
+function listFolders() {
+	return open().prepare("SELECT * FROM folders ORDER BY position, name").all().map(toFolder);
+}
+function createFolder(input) {
+	const d = open();
+	const next = d.prepare("SELECT COALESCE(MAX(position), -1) + 1 AS p FROM folders").get();
+	const id = crypto.randomUUID();
+	d.prepare("INSERT INTO folders (id, name, color, position) VALUES (?, ?, ?, ?)").run(id, input.name, input.color, next.p);
+	return {
+		id,
+		name: input.name,
+		color: input.color,
+		position: next.p
+	};
+}
+function updateFolder(id, input) {
+	open().prepare("UPDATE folders SET name = ?, color = ? WHERE id = ?").run(input.name, input.color, id);
+}
+function deleteFolder(id) {
+	open().prepare("DELETE FROM folders WHERE id = ?").run(id);
+}
+function listConnections() {
+	return open().prepare("SELECT * FROM connections ORDER BY name").all().map(toConnection);
+}
+function getConnection(id) {
+	const row = open().prepare("SELECT * FROM connections WHERE id = ?").get(id);
+	if (!row) throw new Error("Connection not found");
+	return toConnection(row);
+}
+function createConnection(input) {
+	const id = crypto.randomUUID();
+	open().prepare(`INSERT INTO connections (id, folder_id, name, kind, host, port, user, password, database, secure)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.folderId, input.name, input.kind, input.host, input.port, input.user, input.password, input.database || null, input.secure ? 1 : 0);
+	return getConnection(id);
+}
+function updateConnection(id, input) {
+	const current = getConnection(id);
+	const password = input.password === "" ? current.password : input.password;
+	open().prepare(`UPDATE connections SET folder_id = ?, name = ?, kind = ?, host = ?, port = ?, user = ?,
+       password = ?, database = ?, secure = ? WHERE id = ?`).run(input.folderId, input.name, input.kind, input.host, input.port, input.user, password, input.database || null, input.secure ? 1 : 0, id);
+	return getConnection(id);
+}
+function moveConnection(id, folderId) {
+	open().prepare("UPDATE connections SET folder_id = ? WHERE id = ?").run(folderId, id);
+}
+function deleteConnection(id) {
+	return inTransaction(() => {
+		const doomed = listTabs().filter((t) => t.target.connectionId === id).map((t) => t.id);
+		if (doomed.length > 0) removeTabs(doomed);
+		open().prepare("DELETE FROM connections WHERE id = ?").run(id);
+		return getWorkspace();
+	});
+}
+function inTransaction(fn) {
+	const d = open();
+	d.exec("BEGIN IMMEDIATE");
+	try {
+		const out = fn();
+		d.exec("COMMIT");
+		return out;
+	} catch (error) {
+		d.exec("ROLLBACK");
+		throw error;
+	}
+}
+function toTab(r) {
+	const target = r.kind === "table" ? {
+		kind: "table",
+		connectionId: r.connection_id,
+		database: r.database ?? "",
+		table: r.table_name ?? ""
+	} : {
+		kind: "sql",
+		connectionId: r.connection_id,
+		database: r.database,
+		serial: r.serial ?? 1
+	};
+	return {
+		id: r.id,
+		target,
+		sql: r.sql,
+		position: r.position
+	};
+}
+function listTabs() {
+	return open().prepare("SELECT * FROM tabs ORDER BY position").all().map(toTab);
+}
+function readActive() {
+	return open().prepare("SELECT active_tab_id AS id FROM workspace WHERE id = 1").get().id;
+}
+function readRevision() {
+	return open().prepare("SELECT revision FROM workspace WHERE id = 1").get().revision;
+}
+function writeActive(id) {
+	open().prepare("UPDATE workspace SET active_tab_id = ? WHERE id = 1").run(id);
+}
+function writeOrder(ids) {
+	const stmt = open().prepare("UPDATE tabs SET position = ? WHERE id = ?");
+	ids.forEach((id, i) => stmt.run(i, id));
+}
+function getWorkspace() {
+	const tabs = listTabs();
+	const active = readActive();
+	return {
+		tabs,
+		activeTabId: tabs.some((t) => t.id === active) ? active : tabs[0]?.id ?? null,
+		revision: readRevision()
+	};
+}
+var sameTable = (a, b) => a.kind === "table" && b.kind === "table" && a.connectionId === b.connectionId && a.database === b.database && a.table === b.table;
+/** Table tabs are identified by their table, so opening one twice focuses it. SQL tabs are always new. */
+function openTab(target, opts) {
+	return inTransaction(() => {
+		const tabs = listTabs();
+		const existing = tabs.find((t) => sameTable(t.target, target));
+		if (existing) {
+			writeActive(existing.id);
+			return {
+				workspace: getWorkspace(),
+				tabId: existing.id
+			};
+		}
+		const id = crypto.randomUUID();
+		let serial = null;
+		if (target.kind === "sql") {
+			const taken = new Set(tabs.flatMap((t) => t.target.kind === "sql" && t.target.connectionId === target.connectionId ? [t.target.serial] : []));
+			serial = 1;
+			while (taken.has(serial)) serial++;
+		}
+		const ids = tabs.map((t) => t.id);
+		const anchor = opts.after ?? readActive();
+		const anchorAt = anchor ? ids.indexOf(anchor) : -1;
+		ids.splice(anchorAt === -1 ? ids.length : anchorAt + 1, 0, id);
+		open().prepare(`INSERT INTO tabs (id, kind, connection_id, database, table_name, serial, sql, position)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, target.kind, target.connectionId, target.database, target.kind === "table" ? target.table : null, serial, target.kind === "sql" ? opts.sql : "", ids.indexOf(id));
+		writeOrder(ids);
+		writeActive(id);
+		return {
+			workspace: getWorkspace(),
+			tabId: id
+		};
+	});
+}
+/**
+* Removes the tabs. When the active one goes, `prefer` takes over if it survives, else the right
+* neighbour of the active tab, else the left.
+*/
+function removeTabs(doomed, prefer) {
+	const ordered = listTabs().map((t) => t.id);
+	const gone = new Set(doomed);
+	const active = getWorkspace().activeTabId;
+	const stmt = open().prepare("DELETE FROM tabs WHERE id = ?");
+	for (const id of gone) stmt.run(id);
+	const survivors = ordered.filter((id) => !gone.has(id));
+	writeOrder(survivors);
+	if (active && !gone.has(active)) return;
+	if (prefer && survivors.includes(prefer)) return writeActive(prefer);
+	const at = active ? ordered.indexOf(active) : -1;
+	const right = ordered.slice(at + 1).find((id) => !gone.has(id));
+	const left = ordered.slice(0, Math.max(at, 0)).reverse().find((id) => !gone.has(id));
+	writeActive(right ?? left ?? null);
+}
+function closeTabs(ids, prefer) {
+	return inTransaction(() => {
+		removeTabs(ids, prefer);
+		return getWorkspace();
+	});
+}
+function reorderTabs(ids) {
+	return inTransaction(() => {
+		const current = listTabs().map((t) => t.id);
+		if (ids.length !== current.length || !current.every((id) => ids.includes(id))) throw new Error("Tab order does not match the open tabs.");
+		writeOrder(ids);
+		return getWorkspace();
+	});
+}
+function setActiveTab(id) {
+	if (!listTabs().some((t) => t.id === id)) return;
+	writeActive(id);
+}
+function updateTabDraft(id, sql) {
+	open().prepare("UPDATE tabs SET sql = ? WHERE id = ? AND kind = 'sql'").run(sql, id);
+}
+function setTabDatabase(id, database) {
+	open().prepare("UPDATE tabs SET database = ? WHERE id = ? AND kind = 'sql'").run(database, id);
+}
+var MCP_TOKEN_KEY = "mcp_token";
+var newToken = () => Buffer.from(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32))).toString("base64url");
+/** Generated on first use. `INSERT OR IGNORE` keeps concurrent first callers on one token. */
+function getMcpToken() {
+	const d = open();
+	d.prepare("INSERT OR IGNORE INTO settings (key, value) VALUES (?, ?)").run(MCP_TOKEN_KEY, newToken());
+	return d.prepare("SELECT value FROM settings WHERE key = ?").get(MCP_TOKEN_KEY).value;
+}
+function regenerateMcpToken() {
+	const token = newToken();
+	open().prepare("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)").run(MCP_TOKEN_KEY, token);
+	return token;
+}
+export { DB_KIND_INFO as C, folderInputSchema as D, connectionInputSchema as E, newTabTargetSchema as O, DB_KINDS as S, FOLDER_COLOR_NAMES as T, toSummary as _, deleteFolder as a, updateTabDraft as b, getWorkspace as c, moveConnection as d, openTab as f, setTabDatabase as g, setActiveTab as h, deleteConnection as i, tabIdSchema as k, listConnections as l, reorderTabs as m, createConnection as n, getConnection as o, regenerateMcpToken as p, createFolder as r, getMcpToken as s, closeTabs as t, listFolders as u, updateConnection as v, FOLDER_COLORS as w, drivers as x, updateFolder as y };