@coffre/cli 0.1.13 → 0.1.14

package/dist/migrate-ERNNgYO0.js

@@ -0,0 +1,163 @@
+import { a as openTerminal, c as release, d as style, i as listed, t as Cancelled } from "./tty-BDa14JX2.js";
+import { n as migrateDatabase, r as migrationStatus, t as readDatabaseUrl } from "./database-url-CJ9yqoi_.js";
+import { n as StepFailed, r as Steps, t as cliVersion } from "./version-CPk6zTTK.js";
+import { parseArgs } from "node:util";
+//#region src/migrate.ts
+/** Where the owner's connection string comes from, when not from a hidden prompt. */
+const URL_VARIABLE = "COFFRE_MIGRATE_DATABASE_URL";
+var MigrateError = class extends Error {};
+/** The migrations a database that has applied `applied` of `known` still lacks. */
+function pendingOf(state) {
+	return state.migrations.known.slice(state.migrations.applied);
+}
+/**
+* Why this CLI may not migrate an instance that runs `deployed`: it would
+* apply its own migrations, not the instance's. Null when they agree.
+*/
+function versionProblem(cli, deployed, origin) {
+	if (cli === deployed) return null;
+	return newer(deployed, cli) ? `${origin} runs coffre ${deployed}, and this CLI is ${cli}: run \`coffre update\` (to ${deployed}), then \`coffre migrate\` again` : `${origin} runs coffre ${deployed}, and this CLI is ${cli}, whose migrations it does not know yet: deploy ${cli} first, or migrate with the CLI it runs, \`npx @coffre/cli@${deployed} migrate\``;
+}
+/** Whether version `a` comes after `b`, by their numbers. */
+function newer(a, b) {
+	const parts = (version) => version.split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0);
+	const [x, y] = [parts(a), parts(b)];
+	for (let i = 0; i < Math.max(x.length, y.length); i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) > (y[i] ?? 0);
+	return false;
+}
+/**
+* A migration's refusal, as Postgres raised it: the migration's own sentence,
+* not the SQL around it. `0001_remove_syncs` refuses while syncs remain.
+*/
+function migrationFailure(error) {
+	for (let cause = error; cause instanceof Error; cause = cause.cause) {
+		const code = cause.code;
+		if (typeof code === "string" && /^[0-9A-Z]{5}$/.test(code)) return `${cause.message}. Nothing was changed: the migrations run in one transaction.`;
+	}
+	return error instanceof Error ? error.message : String(error);
+}
+/** `connect` reaches the instance: the current one, or the one `--url` names, with your session there. */
+async function migrate(args, connect) {
+	const secrets = [];
+	const clean = (error) => redact(error instanceof Error ? error.message : String(error), secrets);
+	let options;
+	try {
+		options = parseOptions(args);
+	} catch (error) {
+		return fail(process.stderr, clean(error));
+	}
+	const { yes } = options;
+	const instance = connect(options.url);
+	const terminal = openTerminal();
+	const out = terminal?.out ?? process.stderr;
+	const s = style(out);
+	try {
+		const me = await instance.me();
+		if (me.instance === null) throw new MigrateError(`${instance.origin} tells only its owners and root admins its version, and you are signed in as ${me.principal.id}: ask one of them to run coffre migrate`);
+		const problem = versionProblem(cliVersion(), me.instance.version, instance.origin);
+		if (problem !== null) throw new MigrateError(problem);
+		const pending = pendingOf(me.instance);
+		if (pending.length === 0) {
+			out.write(`${s.green("✓")} ${instance.origin}'s database is up to date, at coffre ${me.instance.version}'s schema\n`);
+			return;
+		}
+		if (!yes && terminal === null) throw new MigrateError("nothing here to confirm on: run coffre migrate on a terminal, or pass --yes to apply without asking");
+		if (s.ansi) out.write(`\n  ${s.bold("coffre migrate")}  ${s.dim(`${instance.origin}, coffre ${me.instance.version}`)}\n\n`);
+		out.write(`  ${count(pending.length, "migration")} to apply: ${listed(pending, "and")}\n\n`);
+		const { url, secrets: typed } = await readDatabaseUrl(out, s, {
+			variable: URL_VARIABLE,
+			question: "The database owner's connection string",
+			hint: "Hidden as you type. The login that owns coffre's tables, direct: not a runtime login, not Hyperdrive.",
+			command: "coffre migrate"
+		});
+		secrets.push(...typed);
+		await run(url, instance, pending, out, () => terminal?.keys ?? null, yes, clean);
+	} catch (error) {
+		if (error instanceof Cancelled) return fail(out, "cancelled; nothing was changed", 130);
+		if (!(error instanceof StepFailed)) return fail(out, clean(error));
+		process.exit(1);
+	} finally {
+		if (terminal !== null) release(terminal.keys);
+	}
+}
+/**
+* The steps: read the database's history and hold it to what the instance
+* reported, so that a URL to another database stops here; show what will be
+* applied and ask; apply it; then ask the instance what it now sees.
+*/
+async function run(url, instance, pending, out, keys, yes, clean) {
+	const where = `${url.hostname}${decodeURIComponent(url.pathname)}`;
+	const steps = new Steps(out, [
+		`Read ${where}'s migrations`,
+		`Apply ${listed(pending, "and")}`,
+		`Check ${instance.origin} sees them`
+	], keys, clean);
+	try {
+		await steps.run(0, async () => {
+			const status = await migrationStatus(url.href);
+			if (status.pending.join() !== pending.join()) throw new MigrateError(`${where} lacks ${status.pending.length === 0 ? "no migration" : listed(status.pending, "and")}, but ${instance.origin} reports ${listed(pending, "and")} pending: is this its database? Nothing was changed`);
+			return {
+				text: `${where} has ${count(status.applied.length, "migration")} applied, the last ${status.applied.at(-1) ?? "none"}`,
+				details: []
+			};
+		});
+		await steps.run(1, async (step) => {
+			if (!yes && !await step.ask(`Apply ${count(pending.length, "migration")} to ${where}?`)) throw new Cancelled();
+			step.note(`Applying ${listed(pending, "and")}`);
+			try {
+				await migrateDatabase(url.href, (plan) => {
+					if (plan.pending.join() !== pending.join()) throw new MigrateError(`another migration ran meanwhile: ${where} now lacks ${listed(plan.pending, "and") || "nothing"}`);
+				});
+			} catch (error) {
+				throw new MigrateError(migrationFailure(error));
+			}
+			return `Applied ${listed(pending, "and")}, and reasserted the database's privileges`;
+		});
+		await steps.run(2, async () => {
+			const after = (await instance.me()).instance;
+			const left = after === null ? pending : pendingOf(after);
+			if (left.length > 0) throw new MigrateError(`${instance.origin} still reports ${listed(left, "and")} pending: is the URL its database's?`);
+			const ready = await instance.ready();
+			if (!ready.ok) throw new MigrateError(`${instance.origin} sees the new schema, but is not ready: ` + (ready.heartbeatAgeSeconds === null ? "it has no audit heartbeat yet" : !ready.checkpointed ? "no checkpoint signed by the vault covers its last heartbeat" : `its last heartbeat is ${Math.round(ready.heartbeatAgeSeconds)}s old`) + ". The migration is applied; see /readyz");
+			return `${instance.origin} sees the new schema, and is ready`;
+		});
+	} finally {
+		steps.end();
+	}
+}
+function parseOptions(args) {
+	try {
+		const { values } = parseArgs({
+			args,
+			options: {
+				yes: {
+					type: "boolean",
+					default: false
+				},
+				url: { type: "string" }
+			},
+			strict: true
+		});
+		if (values.url !== void 0 && /^postgres(ql)?:/i.test(values.url)) throw new Error("a database URL");
+		return {
+			yes: values.yes,
+			url: values.url
+		};
+	} catch {
+		const leaked = args.some((arg) => /postgres(ql)?:|@/i.test(arg));
+		throw new MigrateError(`coffre migrate takes only --yes and --url. It reads the database owner's connection string from a hidden prompt, ${URL_VARIABLE} or stdin, never from the command line, where the shell's history and other users can read it.` + (leaked ? " One of the arguments looks like one: change that password, which is in your shell history now." : ""));
+	}
+}
+function count(n, word) {
+	return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function redact(text, secrets) {
+	return secrets.filter((secret) => secret.length > 0).reduce((shown, secret) => shown.split(secret).join("…"), text);
+}
+function fail(out, message, code = 1) {
+	const s = style(out);
+	out.write(`${s.red("✗")} ${message}\n`);
+	process.exit(code);
+}
+//#endregion
+export { migrate };