void 0.1.6 → 0.7.0

package/dist/db-DsRoMcfN.mjs

@@ -0,0 +1,895 @@
+import { a as join, o as relative, r as extname, s as resolve } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { i as dim, n as cliTitle, s as import_picocolors } from "./output-BwlcIYSR.mjs";
+import { c as R, g as ge, y as ye } from "./dist-Dayj3gCK.mjs";
+import { r as readProjectConfig } from "./project-TqORyHn8.mjs";
+import { n as PlatformClient, s as getToken } from "./client-snXOjrp1.mjs";
+import { c as getDatabaseDialect, f as readConfig } from "./config-BIa9HwVX.mjs";
+import { n as detectFramework } from "./plugin-inference-oZ6Ybu2_.mjs";
+import { a as writeJournal, i as stripSqlExt, r as readJournal, t as collectMigrations } from "./collect-CjeZgz5D.mjs";
+import { n as listDrizzleArtifacts, r as validateMigrations, t as assertJournalCoherence } from "./validate-CaMavMxu.mjs";
+import { formatTimestamp } from "./gen-U0Ktr4Zd.mjs";
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { execFileSync } from "node:child_process";
+//#region src/cli/db.ts
+const drizzleKitBin = join(fileURLToPath(import.meta.resolve("drizzle-kit")), "..", "bin.cjs");
+const DEFAULT_SEED_FILES = [
+	"db/seed.ts",
+	"db/seed.mts",
+	"db/seed.js",
+	"db/seed.mjs",
+	"db/seed.sql"
+];
+const MODULE_SEED_EXTENSIONS = new Set([
+	".ts",
+	".mts",
+	".js",
+	".mjs"
+]);
+function getLocalD1PersistRoot(root) {
+	const detected = detectFramework(root);
+	return detected && (detected.class === "b" || detected.class === "c") ? join(root, ".wrangler", "state") : join(root, ".void");
+}
+function runDrizzleKit(root, args) {
+	execFileSync(process.execPath, [drizzleKitBin, ...args], {
+		cwd: root,
+		stdio: "inherit"
+	});
+}
+function getErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function readEnvLocal(root) {
+	const envPath = join(root, ".env.local");
+	if (!existsSync(envPath)) return {};
+	const content = readFileSync(envPath, "utf-8");
+	const vars = {};
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex === -1) continue;
+		const key = trimmed.slice(0, eqIndex).trim();
+		let value = trimmed.slice(eqIndex + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		vars[key] = value;
+	}
+	return vars;
+}
+function getPgUrl(root) {
+	const url = readEnvLocal(root).DATABASE_URL;
+	if (!url) throw new Error("DATABASE_URL not found in .env.local. Add it to connect to your PostgreSQL database.");
+	return url;
+}
+async function withPgClient(root, fn) {
+	const url = getPgUrl(root);
+	const { Client } = await import("pg");
+	const client = new Client({ connectionString: url });
+	await client.connect();
+	try {
+		return await fn(client);
+	} finally {
+		await client.end();
+	}
+}
+function validatePendingMigrations(migrations, appliedNames) {
+	const pending = migrations.filter((migration) => !appliedNames.has(migration.name));
+	if (pending.length === 0) return;
+	validateMigrations(pending);
+}
+async function runDbCommand(root, args) {
+	console.log();
+	ge(cliTitle("db"));
+	const dialect = getDatabaseDialect(readConfig(root));
+	if (args.action === "push") await runPush(root, dialect);
+	else if (args.action === "generate") await runGenerate(root, dialect);
+	else if (args.action === "status") await runStatus(root, dialect);
+	else if (args.action === "reset") await runReset(root, dialect);
+	else if (args.action === "seed") await runSeed(root, args.file, dialect);
+	else if (args.action === "execute") await runExecute(root, args.command, args.file, dialect);
+	else if (args.action === "migrate") await runMigrate(root, dialect, args.remote);
+	else if (args.action === "studio") await runStudio(root, dialect);
+	else if (args.action === "set-url") await runSetUrl(root);
+	else if (args.action === "rename-migrations") await runRenameMigrations(root, dialect);
+	else await runExport(root, args, dialect);
+}
+async function runPush(root, dialect) {
+	const { writeDrizzleConfig } = await import("./config-BzM9Dy7T.mjs").then((n) => n.t);
+	let configPath;
+	if (dialect === "postgresql") configPath = writeDrizzleConfig(root, getPgUrl(root), "postgresql");
+	else {
+		const { mkdirSync } = await import("node:fs");
+		const { dirname } = await import("node:path");
+		const { getMiniflareDatabasePath } = await import("./runner-6Ep3fNQu.mjs");
+		const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+		mkdirSync(dirname(dbPath), { recursive: true });
+		configPath = writeDrizzleConfig(root, dbPath);
+	}
+	try {
+		runDrizzleKit(root, [
+			"push",
+			"--config",
+			configPath
+		]);
+	} catch {
+		process.exit(1);
+	}
+	ye("Done.");
+}
+async function runGenerate(root, dialect) {
+	const { writeDrizzleConfig } = await import("./config-BzM9Dy7T.mjs").then((n) => n.t);
+	const configPath = dialect === "postgresql" ? writeDrizzleConfig(root, "postgresql://dummy", "postgresql") : writeDrizzleConfig(root, ":memory:");
+	try {
+		runDrizzleKit(root, [
+			"generate",
+			"--config",
+			configPath
+		]);
+	} catch {
+		process.exit(1);
+	}
+	ye("Done.");
+}
+async function runStatus(root, dialect) {
+	const migrationsDir = join(root, "db", "migrations");
+	const allMigrations = collectMigrations(migrationsDir);
+	try {
+		assertJournalCoherence(migrationsDir, allMigrations);
+	} catch (err) {
+		R.error(getErrorMessage(err));
+		process.exit(1);
+	}
+	if (allMigrations.length === 0) {
+		R.info("No migration files found in db/migrations/");
+		ye("Done.");
+		return;
+	}
+	let localApplied;
+	if (dialect === "postgresql") try {
+		localApplied = await withPgClient(root, async (client) => {
+			try {
+				return (await client.query("SELECT name FROM _void_migrations ORDER BY name")).rows;
+			} catch {
+				return [];
+			}
+		});
+	} catch {
+		localApplied = [];
+	}
+	else {
+		const { getMiniflareDatabasePath, getAppliedMigrations } = await import("./runner-6Ep3fNQu.mjs");
+		localApplied = await getAppliedMigrations(getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local"));
+	}
+	const localSet = new Set(localApplied.map((m) => m.name));
+	let remoteApplied = null;
+	const token = getToken(root);
+	const config = readProjectConfig(root);
+	if (token && config) try {
+		remoteApplied = (await new PlatformClient(token, { root }).getMigrationStatus(config.projectId)).applied;
+	} catch {}
+	const remoteSet = remoteApplied ? new Set(remoteApplied.map((m) => m.name)) : null;
+	const lines = [];
+	for (const migration of allMigrations) {
+		const localStatus = localSet.has(migration.name) ? import_picocolors.default.green("applied") : import_picocolors.default.yellow("pending");
+		let remotePart = "";
+		if (remoteSet !== null) remotePart = `  remote: ${remoteSet.has(migration.name) ? import_picocolors.default.green("applied") : import_picocolors.default.yellow("pending")}`;
+		lines.push(`  ${migration.name}  ${dim("local:")} ${localStatus}${remotePart}`);
+	}
+	R.info(lines.join("\n"));
+	const localPending = allMigrations.length - localSet.size;
+	const parts = [`${allMigrations.length} migration(s)`];
+	if (localPending > 0) parts.push(`${localPending} pending locally`);
+	if (remoteSet !== null) {
+		const remotePending = allMigrations.length - remoteSet.size;
+		if (remotePending > 0) parts.push(`${remotePending} pending remotely`);
+	}
+	ye(parts.join(", "));
+}
+async function resetDatabase(root, dialect) {
+	const migrationsDir = join(root, "db", "migrations");
+	const migrations = collectMigrations(migrationsDir);
+	try {
+		assertJournalCoherence(migrationsDir, migrations);
+	} catch (err) {
+		R.error(getErrorMessage(err));
+		process.exit(1);
+	}
+	if (dialect === "postgresql") {
+		await withPgClient(root, async (client) => {
+			const tables = await client.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public'");
+			for (const row of tables.rows) await client.query(`DROP TABLE IF EXISTS "${row.tablename}" CASCADE`);
+		});
+		if (migrations.length > 0) await withPgClient(root, async (client) => {
+			await client.query(`CREATE TABLE IF NOT EXISTS _void_migrations (name TEXT PRIMARY KEY, applied_at TEXT NOT NULL)`);
+			for (const m of migrations) {
+				await client.query("BEGIN");
+				try {
+					await client.query(m.sql);
+					await client.query("INSERT INTO _void_migrations (name, applied_at) VALUES ($1, $2)", [m.name, (/* @__PURE__ */ new Date()).toISOString()]);
+					await client.query("COMMIT");
+				} catch (err) {
+					await client.query("ROLLBACK");
+					throw err;
+				}
+			}
+		});
+		return migrations.length;
+	}
+	const { getMiniflareDatabasePath, runMigrations } = await import("./runner-6Ep3fNQu.mjs");
+	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	rmSync(dbPath, { force: true });
+	rmSync(dbPath + "-wal", { force: true });
+	rmSync(dbPath + "-shm", { force: true });
+	return (await runMigrations(migrationsDir, dbPath)).length;
+}
+async function runReset(root, dialect) {
+	const count = await resetDatabase(root, dialect);
+	R.success(`Database reset. Applied ${count} migration(s).`);
+	if (dialect !== "postgresql") R.info(dim("Restart your dev server if it's running."));
+	ye("Done.");
+}
+async function runSeed(root, file, dialect) {
+	const migrationCount = await resetDatabase(root, dialect);
+	R.step(`Reset database. Applied ${migrationCount} migration(s).`);
+	const seed = resolveSeedTarget(root, file);
+	if (seed.kind === "sql") {
+		const sql = readFileSync(seed.path, "utf-8");
+		if (dialect === "postgresql") {
+			await withPgClient(root, async (client) => {
+				await client.query(sql);
+			});
+			R.success(`Seeded from ${seed.displayPath}.`);
+			ye("Done.");
+			return;
+		}
+		const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-6Ep3fNQu.mjs");
+		const db = await openSqliteDatabase(getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local"));
+		try {
+			db.exec(sql);
+		} finally {
+			db.close();
+		}
+	} else await runSeedModule(root, seed.path, dialect);
+	R.success(`Seeded from ${seed.displayPath}.`);
+	R.info(dim("Restart your dev server if it's running."));
+	ye("Done.");
+}
+async function runExecute(root, command, file, dialect) {
+	if (dialect === "postgresql") {
+		const sql = file ? readFileSync(join(root, file), "utf-8") : command;
+		await withPgClient(root, async (client) => {
+			const result = await client.query(sql);
+			if (result.rows && result.rows.length > 0) printTable(result.rows);
+			else R.success("Executed successfully.");
+		});
+		ye("Done.");
+		return;
+	}
+	const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-6Ep3fNQu.mjs");
+	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	if (!existsSync(dbPath)) {
+		R.error("No local database found. Run `void dev` first.");
+		process.exit(1);
+	}
+	const sql = file ? readFileSync(join(root, file), "utf-8") : command;
+	const db = await openSqliteDatabase(dbPath);
+	try {
+		const trimmed = sql.trimStart();
+		if (/^SELECT\b/i.test(trimmed)) {
+			const rows = db.prepare(sql).all();
+			if (rows.length === 0) R.info("No rows returned.");
+			else printTable(rows);
+		} else {
+			db.exec(sql);
+			R.success("Executed successfully.");
+		}
+	} finally {
+		db.close();
+	}
+	ye("Done.");
+}
+function printTable(rows) {
+	const cols = Object.keys(rows[0]);
+	const widths = cols.map((col) => {
+		let max = col.length;
+		for (const row of rows) {
+			const len = String(row[col] ?? "NULL").length;
+			if (len > max) max = len;
+		}
+		return max;
+	});
+	const lines = [cols.map((col, i) => col.padEnd(widths[i])).join("  "), widths.map((w) => "─".repeat(w)).join("──")];
+	for (const row of rows) lines.push(cols.map((col, i) => String(row[col] ?? "NULL").padEnd(widths[i])).join("  "));
+	console.log(lines.join("\n"));
+}
+async function runMigrate(root, dialect, remote) {
+	const migrationsDir = join(root, "db", "migrations");
+	const rawMigrations = collectMigrations(migrationsDir);
+	try {
+		assertJournalCoherence(migrationsDir, rawMigrations);
+	} catch (err) {
+		R.error(getErrorMessage(err));
+		process.exit(1);
+	}
+	if (remote) {
+		const token = getToken(root);
+		if (!token) {
+			R.error("Not logged in. Run `void auth login` first.");
+			process.exit(1);
+		}
+		const config = readProjectConfig(root);
+		if (!config) {
+			R.error("No project linked. Run `void deploy` first or link a project.");
+			process.exit(1);
+		}
+		if (rawMigrations.length === 0) {
+			R.info("No migration files found in db/migrations/");
+			ye("Done.");
+			return;
+		}
+		const client = new PlatformClient(token, { root });
+		let remoteApplied;
+		try {
+			const status = await client.getMigrationStatus(config.projectId);
+			remoteApplied = new Set(status.applied.map((m) => m.name));
+		} catch (err) {
+			R.error(`db: Failed to fetch remote migration status: '${err instanceof Error ? err.message : String(err)}'.`);
+			process.exit(1);
+		}
+		const pendingMigrations = rawMigrations.filter((m) => !remoteApplied.has(m.name));
+		if (pendingMigrations.length === 0) {
+			R.info("Remote database is up to date.");
+			ye("Done.");
+			return;
+		}
+		try {
+			validateMigrations(pendingMigrations);
+		} catch (err) {
+			R.error(getErrorMessage(err));
+			process.exit(1);
+		}
+		const result = await client.applyRemoteMigrations(config.projectId, pendingMigrations);
+		if (!result.ok) {
+			R.error(result.error ? `db: Remote migration failed: '${result.error}'.` : "db: Remote migration failed.");
+			process.exit(1);
+		}
+		if (result.applied.length === 0) R.info("Remote database is up to date.");
+		else {
+			for (const name of result.applied) R.step(name);
+			R.success(`Applied ${result.applied.length} migration(s) to remote database.`);
+		}
+		ye("Done.");
+		return;
+	}
+	if (dialect === "postgresql") {
+		const { applyPgMigrations } = await import("./runner-pg-D0wWHYnr.mjs");
+		const applied = await withPgClient(root, async (client) => {
+			let existingRows = [];
+			try {
+				existingRows = (await client.query("SELECT name FROM _void_migrations")).rows;
+			} catch {
+				existingRows = [];
+			}
+			try {
+				validatePendingMigrations(rawMigrations, new Set(existingRows.map((row) => row.name)));
+			} catch (err) {
+				R.error(getErrorMessage(err));
+				process.exit(1);
+			}
+			return applyPgMigrations(client, rawMigrations);
+		});
+		if (applied.length === 0) R.info("All migrations are up to date.");
+		else {
+			for (const name of applied) R.step(name);
+			R.success(`Applied ${applied.length} migration(s).`);
+		}
+		ye("Done.");
+		return;
+	}
+	const { getMiniflareDatabasePath, getAppliedMigrations, runMigrations } = await import("./runner-6Ep3fNQu.mjs");
+	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	try {
+		const existingRows = await getAppliedMigrations(dbPath);
+		validatePendingMigrations(rawMigrations, new Set(existingRows.map((row) => row.name)));
+	} catch (err) {
+		R.error(getErrorMessage(err));
+		process.exit(1);
+	}
+	const applied = await runMigrations(migrationsDir, dbPath);
+	if (applied.length === 0) R.info("All migrations are up to date.");
+	else {
+		for (const name of applied) R.step(name);
+		R.success(`Applied ${applied.length} migration(s).`);
+		R.info(dim("Restart your dev server if it's running."));
+	}
+	ye("Done.");
+}
+async function runStudio(root, dialect) {
+	if (dialect === "postgresql") {
+		const { writeDrizzleConfig } = await import("./config-BzM9Dy7T.mjs").then((n) => n.t);
+		const configPath = writeDrizzleConfig(root, getPgUrl(root), "postgresql");
+		R.info("Opening Drizzle Studio...");
+		try {
+			runDrizzleKit(root, [
+				"studio",
+				"--config",
+				configPath
+			]);
+		} catch {
+			process.exit(1);
+		}
+		return;
+	}
+	const { writeDrizzleConfig } = await import("./config-BzM9Dy7T.mjs").then((n) => n.t);
+	const { getMiniflareDatabasePath } = await import("./runner-6Ep3fNQu.mjs");
+	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	if (!existsSync(dbPath)) {
+		R.error("No local database found. Run `void dev` first.");
+		process.exit(1);
+	}
+	const configPath = writeDrizzleConfig(root, dbPath);
+	R.info("Opening Drizzle Studio...");
+	try {
+		runDrizzleKit(root, [
+			"studio",
+			"--config",
+			configPath
+		]);
+	} catch {
+		process.exit(1);
+	}
+}
+async function runRenameMigrations(root, dialect) {
+	const migrationsDir = join(root, "db", "migrations");
+	if (!existsSync(migrationsDir)) {
+		R.info("No migrations directory found.");
+		ye("Done.");
+		return;
+	}
+	const currentMigrations = collectMigrations(migrationsDir);
+	try {
+		assertJournalCoherence(migrationsDir, currentMigrations);
+	} catch (err) {
+		R.error(getErrorMessage(err));
+		process.exit(1);
+	}
+	if (existsSync(join(migrationsDir, "migrations.js"))) {
+		R.error("This project uses Drizzle's bundled migration format (db/migrations/migrations.js).\n`void db rename-migrations` cannot rename migrations in bundled mode because\n`migrations.js` contains static imports of the SQL files by filename.\n\nDelete db/migrations/migrations.js and re-run `void db generate` to migrate away\nfrom bundled mode, then retry `void db rename-migrations`.");
+		process.exit(1);
+	}
+	const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql") && f !== "seed.sql").sort();
+	const oldStyleFiles = files.filter((f) => /^\d{1,4}_/.test(f));
+	if (oldStyleFiles.length === 0) {
+		R.info("No migrations with numeric prefixes found. Nothing to rename.");
+		ye("Done.");
+		return;
+	}
+	const timestampFiles = files.filter((f) => /^\d{14}_/.test(f));
+	const formatTs = formatTimestamp;
+	let baseTime;
+	if (timestampFiles.length > 0) {
+		const earliest = timestampFiles[0].slice(0, 14);
+		const y = +earliest.slice(0, 4), mo = +earliest.slice(4, 6) - 1, d = +earliest.slice(6, 8);
+		const h = +earliest.slice(8, 10), mi = +earliest.slice(10, 12), s = +earliest.slice(12, 14);
+		baseTime = new Date(Date.UTC(y, mo, d, h, mi, s - oldStyleFiles.length));
+	} else baseTime = /* @__PURE__ */ new Date(Date.now() - oldStyleFiles.length * 1e3);
+	const renames = [];
+	for (let i = 0; i < oldStyleFiles.length; i++) {
+		const oldName = oldStyleFiles[i];
+		const description = oldName.replace(/^\d+_/, "");
+		const newName = `${formatTs(new Date(baseTime.getTime() + i * 1e3))}_${description}`;
+		renames.push({
+			from: oldName,
+			to: newName
+		});
+	}
+	const journalPath = join(migrationsDir, "meta", "_journal.json");
+	const originalJournalBytes = existsSync(journalPath) ? readFileSync(journalPath) : null;
+	const metaDir = join(migrationsDir, "meta");
+	const snapshotPrefix = (tag) => tag.split("_")[0];
+	const snapshotPathFor = (tag) => join(metaDir, `${snapshotPrefix(tag)}_snapshot.json`);
+	const preRenameJournal = readJournal(migrationsDir);
+	const drizzleArtifacts = listDrizzleArtifacts(migrationsDir);
+	const isBareLegacyPlaceholder = preRenameJournal !== void 0 && preRenameJournal !== null && typeof preRenameJournal === "object" && Array.isArray(preRenameJournal.entries) && preRenameJournal.entries.length === 0 && drizzleArtifacts.length === 0;
+	if (originalJournalBytes !== null && !isBareLegacyPlaceholder) {
+		const missingSnapshots = [];
+		for (const { from } of renames) {
+			const fromTag = stripSqlExt(from);
+			if (!existsSync(snapshotPathFor(fromTag))) missingSnapshots.push(`meta/${snapshotPrefix(fromTag)}_snapshot.json`);
+		}
+		if (missingSnapshots.length > 0) {
+			R.error("db: Cannot rename migrations because one or more Drizzle snapshot files are missing:");
+			for (const p of missingSnapshots) R.error(`  - db/migrations/${p}`);
+			R.error("\nRestore the missing snapshot(s) from version control, or reset the migration directory with `void db generate`, then retry.");
+			process.exit(1);
+		}
+	}
+	const token = getToken(root);
+	const config = readProjectConfig(root);
+	let remoteRenamed = false;
+	if (config && !token) {
+		R.error("Project is linked but you are not logged in.\nRun `void auth login` first so remote migration records can be updated.");
+		process.exit(1);
+	}
+	if (token && config) try {
+		await new PlatformClient(token, { root }).renameMigrations(config.projectId, renames);
+		remoteRenamed = true;
+		R.info("Remote migration records updated.");
+	} catch (err) {
+		R.error("db: Failed to update remote migration records. No local changes were made.\nFix the connection and run `void db rename-migrations` again.");
+		R.error(String(err));
+		process.exit(1);
+	}
+	const reverseRemote = async () => {
+		if (!remoteRenamed || !token || !config) return;
+		try {
+			const client = new PlatformClient(token, { root });
+			const reversed = renames.map(({ from, to }) => ({
+				from: to,
+				to: from
+			}));
+			await client.renameMigrations(config.projectId, reversed);
+		} catch {
+			R.warn("db: Could not reverse remote rename. Run `void deploy` to sync remote records.");
+		}
+	};
+	let journalRewritten = false;
+	const restoreJournal = () => {
+		if (!journalRewritten || originalJournalBytes === null) return;
+		try {
+			writeFileSync(journalPath, originalJournalBytes);
+		} catch (err) {
+			R.warn("Could not restore db/migrations/meta/_journal.json after rollback. The journal may be in a partial state.\nRegenerate it with `void db generate`, or restore it from version control.");
+			R.warn(String(err));
+		}
+	};
+	const renamed = [];
+	const renamedSnapshots = [];
+	const reverseSnapshotRenames = () => {
+		for (const { from, to } of renamedSnapshots) try {
+			renameSync(to, from);
+		} catch (err) {
+			R.warn(`db: Could not reverse snapshot rename for '${from}'. The meta/ directory may be in a partial state.`);
+			R.warn(String(err));
+		}
+	};
+	try {
+		for (const { from, to } of renames) {
+			renameSync(join(migrationsDir, from), join(migrationsDir, to));
+			renamed.push({
+				from,
+				to
+			});
+			R.step(`${from} → ${to}`);
+			const fromTag = stripSqlExt(from);
+			const toTag = stripSqlExt(to);
+			const snapshotFrom = snapshotPathFor(fromTag);
+			const snapshotTo = snapshotPathFor(toTag);
+			if (existsSync(snapshotFrom)) {
+				renameSync(snapshotFrom, snapshotTo);
+				renamedSnapshots.push({
+					from: snapshotFrom,
+					to: snapshotTo
+				});
+			}
+		}
+	} catch (err) {
+		reverseSnapshotRenames();
+		for (const { from, to } of renamed) try {
+			renameSync(join(migrationsDir, to), join(migrationsDir, from));
+		} catch {}
+		restoreJournal();
+		await reverseRemote();
+		R.error("db: Failed to rename migration files. All changes have been reverted.");
+		R.error(String(err));
+		process.exit(1);
+	}
+	if (originalJournalBytes !== null) try {
+		const journal = readJournal(migrationsDir);
+		if (!journal) throw new Error("db: db/migrations/meta/_journal.json disappeared mid-run. File renames will be reverted.");
+		const renameMap = /* @__PURE__ */ new Map();
+		for (const { from, to } of renames) renameMap.set(stripSqlExt(from), stripSqlExt(to));
+		const updatedEntries = journal.entries.map((entry) => {
+			const next = renameMap.get(entry.tag);
+			return next ? {
+				...entry,
+				tag: next
+			} : entry;
+		});
+		journalRewritten = true;
+		writeJournal(migrationsDir, {
+			version: journal.version,
+			dialect: journal.dialect,
+			entries: updatedEntries
+		});
+	} catch (err) {
+		reverseSnapshotRenames();
+		for (const { from, to } of renames) try {
+			renameSync(join(migrationsDir, to), join(migrationsDir, from));
+		} catch {}
+		restoreJournal();
+		await reverseRemote();
+		R.error("db: Failed to update db/migrations/meta/_journal.json. File renames have been reverted.");
+		R.error(String(err));
+		process.exit(1);
+	}
+	if (dialect === "postgresql") try {
+		await withPgClient(root, async (client) => {
+			if ((await client.query(`SELECT 1 FROM information_schema.tables WHERE table_name = '_void_migrations' LIMIT 1`)).rows.length === 0) return;
+			await client.query("BEGIN");
+			try {
+				for (const { from, to } of renames) await client.query("UPDATE _void_migrations SET name = $1 WHERE name = $2", [to, from]);
+				await client.query("COMMIT");
+			} catch (err) {
+				await client.query("ROLLBACK");
+				throw err;
+			}
+		});
+	} catch (err) {
+		reverseSnapshotRenames();
+		for (const { from, to } of renames) try {
+			renameSync(join(migrationsDir, to), join(migrationsDir, from));
+		} catch {}
+		restoreJournal();
+		await reverseRemote();
+		R.error("db: Failed to update PostgreSQL tracking table. File renames have been reverted.\nFix the database connection and run `void db rename-migrations` again.");
+		R.error(String(err));
+		process.exit(1);
+	}
+	else {
+		const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-6Ep3fNQu.mjs");
+		const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+		if (existsSync(dbPath)) try {
+			const db = await openSqliteDatabase(dbPath);
+			try {
+				const hasNew = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='_void_migrations'").get();
+				const hasLegacy = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='_migrations'").get();
+				const tableName = hasNew ? "_void_migrations" : hasLegacy ? "_migrations" : null;
+				if (tableName) {
+					const updateStmt = db.prepare(`UPDATE ${tableName} SET name = ? WHERE name = ?`);
+					db.transaction(() => {
+						for (const { from, to } of renames) updateStmt.run(to, from);
+					})();
+				}
+			} finally {
+				db.close();
+			}
+		} catch (err) {
+			reverseSnapshotRenames();
+			for (const { from, to } of renames) try {
+				renameSync(join(migrationsDir, to), join(migrationsDir, from));
+			} catch {}
+			restoreJournal();
+			await reverseRemote();
+			R.error("db: Failed to update SQLite tracking table. File renames have been reverted.\nFix the database issue and run `void db rename-migrations` again.");
+			R.error(String(err));
+			process.exit(1);
+		}
+	}
+	R.success(`Renamed ${renames.length} migration(s) to timestamp format.`);
+	ye("Done.");
+}
+async function runExport(root, args, dialect) {
+	if (dialect === "postgresql") {
+		const parts = [];
+		await withPgClient(root, async (client) => {
+			let tables;
+			if (args.table) {
+				if ((await client.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename = $1", [args.table])).rows.length === 0) {
+					R.error(`db: Table '${args.table}' not found.`);
+					process.exit(1);
+				}
+				tables = [args.table];
+			} else tables = (await client.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename NOT LIKE '\\_%' ORDER BY tablename")).rows.map((row) => String(row.tablename));
+			for (const table of tables) {
+				if (!args.noSchema) {
+					const colDefs = (await client.query(`SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = $1 AND table_schema = 'public' ORDER BY ordinal_position`, [table])).rows.map((column) => {
+						let def = `  "${String(column.column_name)}" ${String(column.data_type)}`;
+						if (column.is_nullable === "NO") def += " NOT NULL";
+						if (column.column_default) def += ` DEFAULT ${String(column.column_default)}`;
+						return def;
+					});
+					parts.push(`CREATE TABLE "${table}" (\n${colDefs.join(",\n")}\n);`);
+				}
+				if (!args.noData) {
+					const rows = await client.query(`SELECT * FROM "${table}"`);
+					for (const row of rows.rows) {
+						const cols = Object.keys(row);
+						const vals = cols.map((c) => {
+							const v = row[c];
+							if (v === null) return "NULL";
+							if (typeof v === "number") return String(v);
+							return `'${String(v).replace(/'/g, "''")}'`;
+						});
+						parts.push(`INSERT INTO "${table}" (${cols.join(", ")}) VALUES (${vals.join(", ")});`);
+					}
+				}
+				parts.push("");
+			}
+		});
+		const output = parts.join("\n");
+		if (args.output) {
+			writeFileSync(join(root, args.output), output);
+			R.success(`Exported to ${args.output}`);
+			ye("Done.");
+		} else process.stdout.write(output);
+		return;
+	}
+	const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-6Ep3fNQu.mjs");
+	const dbPath = getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local");
+	if (!existsSync(dbPath)) {
+		R.error("No local database found. Run `void dev` first.");
+		process.exit(1);
+	}
+	const db = await openSqliteDatabase(dbPath, { readonly: true });
+	try {
+		let tables;
+		if (args.table) {
+			if (!db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(args.table)) {
+				R.error(`db: Table '${args.table}' not found.`);
+				process.exit(1);
+			}
+			tables = [args.table];
+		} else tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '\\_%' ESCAPE '\\' ORDER BY name").all().map((row) => String(row.name));
+		const parts = [];
+		for (const table of tables) {
+			if (!args.noSchema) {
+				const row = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name=?").get(table);
+				parts.push(row.sql + ";");
+			}
+			if (!args.noData) {
+				const rows = db.prepare(`SELECT * FROM "${table}"`).all();
+				for (const row of rows) {
+					const cols = Object.keys(row);
+					const vals = cols.map((c) => {
+						const v = row[c];
+						if (v === null) return "NULL";
+						if (typeof v === "number") return String(v);
+						return `'${String(v).replace(/'/g, "''")}'`;
+					});
+					parts.push(`INSERT INTO "${table}" (${cols.join(", ")}) VALUES (${vals.join(", ")});`);
+				}
+			}
+			parts.push("");
+		}
+		const output = parts.join("\n");
+		if (args.output) {
+			writeFileSync(join(root, args.output), output);
+			R.success(`Exported to ${args.output}`);
+			ye("Done.");
+		} else process.stdout.write(output);
+	} finally {
+		db.close();
+	}
+}
+async function runSetUrl(root) {
+	const { readConfig: readVoidConfig, getDatabaseDialect: getDialect } = await import("./config-BIa9HwVX.mjs").then((n) => n.n);
+	if (getDialect(readVoidConfig(root)) !== "postgresql") {
+		R.error("db: This command is only for PostgreSQL projects. Set \"database\": \"pg\" in void.json.");
+		process.exit(1);
+	}
+	const token = getToken(root);
+	if (!token) {
+		R.error("No auth token found. Run `void auth login` first.");
+		process.exit(1);
+	}
+	const projectConfig = readProjectConfig(root);
+	if (!projectConfig) {
+		R.error("No project linked. Run `void deploy` first or link a project.");
+		process.exit(1);
+	}
+	const { text: promptText, isCancel: isCancelCheck } = await import("./dist-Dayj3gCK.mjs").then((n) => n.p);
+	const connectionString = await promptText({
+		message: "Enter your PostgreSQL connection string:",
+		placeholder: "postgresql://user:pass@host:5432/dbname",
+		validate(value = "") {
+			if (!value.startsWith("postgres://") && !value.startsWith("postgresql://")) return "Connection string must start with \"postgres://\" or \"postgresql://\"";
+		}
+	});
+	if (isCancelCheck(connectionString)) process.exit(0);
+	await new PlatformClient(token, { root }).setDatabaseUrl(projectConfig.projectId, connectionString);
+	R.success("Database URL updated.");
+	ye("Done.");
+}
+function resolveSeedTarget(root, file) {
+	if (file) return toSeedTarget(root, resolve(root, file), file);
+	const defaults = DEFAULT_SEED_FILES.filter((candidate) => existsSync(join(root, candidate)));
+	if (defaults.length === 0) {
+		R.error(`db: No seed file found. Create one of: ${DEFAULT_SEED_FILES.join(", ")} or pass --file <path>.`);
+		process.exit(1);
+	}
+	if (defaults.length > 1) {
+		R.error(`db: Multiple default seed files found: ${defaults.join(", ")}. Use --file <path> to choose one.`);
+		process.exit(1);
+	}
+	const [seedPath] = defaults;
+	return toSeedTarget(root, join(root, seedPath), seedPath);
+}
+function toSeedTarget(root, seedPath, displayPath) {
+	if (!existsSync(seedPath)) {
+		R.error(`db: Seed file '${seedPath}' not found.`);
+		process.exit(1);
+	}
+	const ext = extname(seedPath);
+	const normalizedDisplay = (displayPath ?? relative(root, seedPath)).replaceAll("\\", "/");
+	if (ext === ".sql") return {
+		path: seedPath,
+		displayPath: normalizedDisplay,
+		kind: "sql"
+	};
+	if (MODULE_SEED_EXTENSIONS.has(ext)) return {
+		path: seedPath,
+		displayPath: normalizedDisplay,
+		kind: "module"
+	};
+	R.error(`db: Unsupported seed file '${normalizedDisplay}'. Use .sql, .ts, .mts, .js, or .mjs.`);
+	process.exit(1);
+}
+async function runSeedModule(root, seedPath, dialect) {
+	const seed = await loadSeedFunction(seedPath);
+	const schema = await loadSeedSchema(root);
+	if (dialect === "postgresql") {
+		const { drizzle } = await import("drizzle-orm/node-postgres");
+		await withPgClient(root, async (client) => {
+			const options = getDrizzleSchemaOptions(schema);
+			const drizzleClient = client;
+			await seed({
+				dialect,
+				db: options ? drizzle(drizzleClient, options) : drizzle(drizzleClient),
+				schema
+			});
+		});
+		return;
+	}
+	const { drizzle } = await import("drizzle-orm/better-sqlite3");
+	const { getMiniflareDatabasePath, openSqliteDatabase } = await import("./runner-6Ep3fNQu.mjs");
+	const sqlite = await openSqliteDatabase(getMiniflareDatabasePath(getLocalD1PersistRoot(root), "local"));
+	try {
+		const options = getDrizzleSchemaOptions(schema);
+		await seed({
+			dialect,
+			db: options ? drizzle(sqlite, options) : drizzle(sqlite),
+			schema
+		});
+	} finally {
+		sqlite.close();
+	}
+}
+async function loadSeedFunction(seedPath) {
+	const mod = await importLocalModule(seedPath);
+	const seed = typeof mod.default === "function" ? mod.default : typeof mod.seed === "function" ? mod.seed : void 0;
+	if (!seed) throw new Error(`db: Seed module '${seedPath}' must export a default function or a named "seed" function.`);
+	return seed;
+}
+async function loadSeedSchema(root) {
+	const { discoverSchema } = await import("./discover-B7FkXBLB.mjs").then((n) => n.n);
+	const location = discoverSchema(root);
+	if (!location) return {};
+	if (location.type === "file") {
+		const mod = await importLocalModule(location.path);
+		return Object.fromEntries(Object.entries(mod).filter(([name]) => name !== "default" && name !== "__esModule"));
+	}
+	const files = collectSchemaModuleFiles(location.path);
+	const parts = await Promise.all(files.map((file) => importLocalModule(file)));
+	return Object.assign({}, ...parts.map((mod) => Object.fromEntries(Object.entries(mod).filter(([name]) => name !== "default"))));
+}
+function collectSchemaModuleFiles(dir) {
+	const files = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...collectSchemaModuleFiles(fullPath));
+			continue;
+		}
+		if (MODULE_SEED_EXTENSIONS.has(extname(entry.name)) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".d.mts")) files.push(fullPath);
+	}
+	return files.sort();
+}
+async function importLocalModule(modulePath) {
+	return import(`${pathToFileURL(modulePath).href}?t=${Date.now()}`);
+}
+function getDrizzleSchemaOptions(schema) {
+	return Object.keys(schema).length > 0 ? { schema } : void 0;
+}
+//#endregion
+export { runDbCommand };