@rebasepro/server-postgres 0.25.0-canary.ge06257e → 0.25.1

package/dist/{rls-bootstrap-sql-Bd-hJk08.js → db-subcommands-BPoHCxJR.js}

@@ -1,8 +1,10 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { i as __toESM, n as __exportAll, r as __require, t as __commonJSMin } from "./rolldown-runtime-V7rFbMRe.js";
+import { a as __require, i as __exportAll, n as require_arg, o as __toESM, r as __commonJSMin } from "./cli-prompt-DXG0yk-h.js";
+import { et as redactConnectionPasswords } from "./cli-errors-DiA0XFIS.js";
 import { LEGACY_RLS_SCHEMA, REBASE_SCHEMA } from "@rebasepro/types";
 import { sqlRows } from "@rebasepro/common";
+import { suggestNearMiss } from "@rebasepro/utils";
 import process$1, { execArgv, execPath, hrtime, platform } from "node:process";
 import { constants } from "node:os";
 import tty from "node:tty";
@@ -6518,6 +6520,456 @@ async function dropLegacyAuthSchema(run, report) {
 	}
 }
 //#endregion
-export { rls_bootstrap_sql_exports as a, rlsRuntimeIsCurrent as i, RLS_BOOTSTRAP_STATEMENTS as n, execa as o, dropLegacyAuthSchema as r, RLS_BOOTSTRAP_SQL as t };
+//#region src/cli-flags.ts
+var import_arg = /* @__PURE__ */ __toESM(require_arg(), 1);
+/**
+* Flags that reach this process on a line it did not compose.
+*
+* `rebase db …` hands the driver the user's whole line: the CLI *reads*
+* `--database-url` and `--docker` to resolve the database and then relays them
+* verbatim, and `--debug` is what `bin/rebase.js` prints after every failure as
+* the thing to re-run with. Rejecting any of the three would make the driver
+* refuse commands the CLI documents.
+*/
+var RELAYED_FLAGS = {
+	"--database-url": String,
+	"--docker": Boolean,
+	"--debug": Boolean,
+	"--help": Boolean,
+	"-h": "--help"
+};
+/**
+* Parse a driver command's line — `["db", "<subcommand>", …]` — with the
+* relayed flags declared alongside the command's own.
+*
+* Every driver parser is permissive, and an undeclared flag in a permissive
+* parse is a positional. The positionals are what `db migrate` hands
+* `atlas migrate apply`, what `db generate` names its migration after and
+* which backup `db restore` restores, so a relayed flag left undeclared was
+* read as one of those: `rebase db migrate --docker` died on Atlas's
+* `unknown flag: --docker` after it had already written the auth schema.
+*/
+function parseDriverLine(spec, args) {
+	return (0, import_arg.default)({
+		...RELAYED_FLAGS,
+		...spec
+	}, {
+		argv: args.slice(2),
+		permissive: true
+	});
+}
+/** Keyed by `"<domain> <subcommand>"`, the way the user types it. */
+var DRIVER_FLAG_SPECS = {
+	"db push": {
+		"--collections": String,
+		"-c": "--collections",
+		"--dry-run": Boolean,
+		"--allow-destructive": Boolean,
+		"--yes": Boolean,
+		"-y": "--yes"
+	},
+	"db generate": {
+		"--collections": String,
+		"-c": "--collections"
+	},
+	"db migrate": {
+		"--baseline": String,
+		"--refuse-destructive": Boolean
+	},
+	"schema generate": {
+		"--collections": String,
+		"-c": "--collections",
+		"--output": String,
+		"-o": "--output",
+		"--out": "--output",
+		"--watch": Boolean,
+		"-w": "--watch"
+	},
+	"schema introspect": {
+		"--output": String,
+		"-o": "--output",
+		"--out": "--output",
+		"--collections": String,
+		"-c": "--collections",
+		"--force": Boolean,
+		"-f": "--force",
+		"--schema": String,
+		"--data-inference": Boolean,
+		"--no-data-inference": Boolean
+	},
+	"schema stale": {
+		"--collections": String,
+		"-c": "--collections",
+		"--output": String,
+		"-o": "--output",
+		"--out": "--output",
+		"--fix": Boolean
+	}
+};
+/**
+* The `--collections` path the user typed, or `null` if they typed none.
+*
+* Read once, at the entry point, because every command that takes it re-enters
+* the generators with the same line and each of them resolved it again — which
+* is how "Collections path not found" came to be printed four times before the
+* real output, and how a path that does not exist got as far as *writing* an
+* empty schema.
+*
+* Permissive, and it has to be: {@link assertKnownFlags} has already judged the
+* line, and `db push` carries flags the `--collections` spec does not name.
+*/
+function collectionsPathIn(args) {
+	try {
+		return (0, import_arg.default)({
+			"--collections": String,
+			"-c": "--collections"
+		}, {
+			argv: args.slice(2),
+			permissive: true
+		})["--collections"] ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Reject a flag the named command does not take.
+*
+* `args` is the driver's whole line — `["db", "push", …]` — so the flags are
+* read from `args.slice(2)`, past the two command words.
+*
+* Throws rather than exiting: `runPluginCommand`'s caller already turns a
+* thrown error into one red line and exit 1, and a thrown error is what the
+* tests can see.
+*/
+function assertKnownFlags(domain, subcommand, args) {
+	if (!subcommand) return;
+	const spec = DRIVER_FLAG_SPECS[`${domain} ${subcommand}`];
+	if (!spec) return;
+	const argv = resolveSwitchValues({
+		...RELAYED_FLAGS,
+		...spec
+	}, args.slice(2), `${domain} ${subcommand}`, domain);
+	try {
+		(0, import_arg.default)({
+			...RELAYED_FLAGS,
+			...spec
+		}, { argv });
+	} catch (err) {
+		const unknown = unknownFlagIn(err, args.slice(2));
+		if (unknown === null) throw err;
+		throw new Error(unknownOptionSentence(`${domain} ${subcommand}`, domain, unknown, spec));
+	}
+}
+/**
+* The sentence an undeclared flag is refused with, in the words the CLI's own
+* parser uses: "`rebase db push` has no option --dry-rn — did you mean
+* --dry-run? Nothing was run."
+*
+* `token` is the whole argument `arg` refused, which is not always a flag: one
+* argument holding a flag and its value, quoted together
+* (`"--from postgres://u:pw@h/db"`), is refused whole. That one is named as
+* what it is, and what it quotes is password-masked; no other part of an
+* argument is quoted at all.
+*
+* @param command the command as typed: `"db push"`.
+* @param help the command whose `--help` the sentence names.
+* @param spec the command's own flags; the relayed ones are offered too.
+*/
+function unknownOptionSentence(command, help, token, spec) {
+	const full = {
+		...RELAYED_FLAGS,
+		...spec
+	};
+	const name = token.split(/[=\s]/)[0];
+	const suggestion = closestWord(name, Object.keys(full).filter((flag) => flag.startsWith("--")));
+	const tail = ` Nothing was run. See \`rebase ${help} --help\`.`;
+	if (/\s/.test(token.trim())) {
+		const flag = name in full ? name : suggestion;
+		const how = flag ? ` Write them as two arguments, ${flag} <value>, or as ${flag}=<value>.` : " Write a flag and its value as two arguments.";
+		return `\`rebase ${command}\` has no option "${redactConnectionPasswords(token)}": that is a flag and a value in one argument, quoted together.${how}${tail}`;
+	}
+	const own = Object.keys(spec).filter((flag) => flag.startsWith("--"));
+	const takes = own.length > 0 ? `it takes ${own.join(", ")}` : "it takes no options of its own";
+	return `\`rebase ${command}\` has no option ${name}` + (suggestion ? ` — did you mean ${suggestion}?` : ` — ${takes}.`) + tail;
+}
+/** What a flag resolves to, through its alias (`"-y": "--yes"`). */
+function handlerOf(spec, flag) {
+	const declared = spec[flag];
+	return typeof declared === "string" ? spec[declared] : declared;
+}
+/** A flag that takes no value: on when given, off when left out. */
+function isSwitch(handler) {
+	return handler === Boolean || Array.isArray(handler) && handler[0] === Boolean;
+}
+/** The values a switch reads as on, and as off, after its `=`. */
+var SWITCH_ON = /^(?:true|1)$/i;
+var SWITCH_OFF = /^(?:false|0)$/i;
+/**
+* A line with every `--switch=value` resolved, before `arg` reads it: `=true`
+* or `=1` is the switch alone, `=false` or `=0` drops it, and any other value
+* is refused.
+*
+* `arg` drops the value of a flag that takes none and turns the flag on, so
+* `db push --dry-run=false` was a dry run and `--allow-destructive=false`
+* allowed the destructive statements it was typed to forbid. `=true` kept
+* working by the same accident, and scripts write it, so both readings a value
+* can have are honoured and nothing else is guessed at. Past `--` every word
+* is a positional, so nothing there is read.
+*
+* @param command the command as typed, for the message: `"db push"`.
+* @param help the command whose `--help` the message names.
+*/
+function resolveSwitchValues(spec, argv, command, help = command) {
+	const resolved = [];
+	for (let index = 0; index < argv.length; index += 1) {
+		const word = argv[index];
+		if (word === "--") {
+			resolved.push(...argv.slice(index));
+			break;
+		}
+		const flag = word.startsWith("--") && word.includes("=") ? word.slice(0, word.indexOf("=")) : null;
+		if (flag === null || !isSwitch(handlerOf(spec, flag))) {
+			resolved.push(word);
+			continue;
+		}
+		const value = word.slice(flag.length + 1);
+		if (SWITCH_ON.test(value)) resolved.push(flag);
+		else if (!SWITCH_OFF.test(value)) throw new Error(`\`rebase ${command}\` cannot read ${redactConnectionPasswords(word)}: ${flag} is a switch, and after its = it takes true or 1 to turn it on, false or 0 to turn it off. Nothing was run. See \`rebase ${help} --help\`.`);
+	}
+	return resolved;
+}
+/**
+* A driver command's line, `["<domain>", "<subcommand>", …]`, with its
+* switches' values resolved by {@link resolveSwitchValues} against the
+* command's spec: what `runPluginCommand` hands every parser after it, so a
+* permissive one never reads `--allow-destructive=false` as on. A command with
+* no spec here comes back as it was.
+*/
+function resolveDriverSwitches(domain, subcommand, args) {
+	const spec = subcommand ? DRIVER_FLAG_SPECS[`${domain} ${subcommand}`] : void 0;
+	if (!spec) return [...args];
+	return [...args.slice(0, 2), ...resolveSwitchValues({
+		...RELAYED_FLAGS,
+		...spec
+	}, args.slice(2), `${domain} ${subcommand}`, domain)];
+}
+/**
+* The argument `arg` refused as undeclared, whole, or `null` for any other
+* failure.
+*
+* arg's wording is `unknown or unexpected option: --targt-db`, naming the
+* argument up to its first `=`. An argument with a space in it is named past
+* the space too, so the match runs to the end of the message; and the word
+* in `argv` it came from is returned, `=` and all, so a refusal that quotes it
+* quotes what was typed.
+*/
+function unknownFlagIn(err, argv) {
+	if (!(err instanceof Error) || !("code" in err) || err.code !== "ARG_UNKNOWN_OPTION") return null;
+	const named = /option: ([\s\S]+)$/.exec(err.message)?.[1];
+	if (named === void 0) return null;
+	return argv.find((word) => word === named || word.startsWith(`${named}=`)) ?? named;
+}
+/**
+* The word in `known` that `typed` was probably meant to be: one edit away
+* (`--targt-db`), or two neighbouring letters swapped (`--clena`, `--froce`),
+* which `suggestNearMiss` counts as two edits and so never offers.
+*/
+function closestWord(typed, known) {
+	return suggestNearMiss(known, typed) ?? transposedFrom(known, typed);
+}
+function transposedFrom(known, typed) {
+	return known.find((candidate) => {
+		if (candidate.length !== typed.length || candidate === typed) return false;
+		const differ = [...candidate].flatMap((letter, index) => letter === typed[index] ? [] : [index]);
+		return differ.length === 2 && differ[1] === differ[0] + 1 && candidate[differ[0]] === typed[differ[1]] && candidate[differ[1]] === typed[differ[0]];
+	});
+}
+/**
+* Parse a command that owns its argument handling, refusing what it does not
+* declare.
+*
+* `db backup`, `db restore` and `db backups list` parsed permissively, so an
+* undeclared flag became a positional and was ignored: `db restore <dump>
+* --targt-db x --create-db --yes` dropped the misspelled target and restored
+* into the live database. A typo is refused here before anything runs, naming
+* the declared flag it is one edit from, or every flag the command takes when
+* none is that close.
+*
+* @param argv the words after the command, e.g. `rawArgs.slice(2)`.
+* @param command the command as typed, for the message: `"db restore"`.
+*/
+function parseCommandFlags(spec, argv, command) {
+	const full = {
+		...RELAYED_FLAGS,
+		...spec
+	};
+	try {
+		return (0, import_arg.default)(full, { argv: resolveSwitchValues(full, argv, command) });
+	} catch (err) {
+		const unknown = unknownFlagIn(err, argv);
+		if (unknown === null) throw err;
+		throw new Error(unknownOptionSentence(command, command, unknown, spec));
+	}
+}
+//#endregion
+//#region src/branch-argv.ts
+/**
+* Argument shapes for `rebase db branch`, with no runtime dependencies.
+*
+* Its own module for the same reason `schema/atlas-argv.ts` is: `cli.ts` pulls
+* in chalk, execa and the driver runtime, so a unit test that imports it cannot
+* run. Argv parsing is the part most worth testing and the part least in need
+* of any of that.
+*/
+/**
+* The flags each driver-side `db branch` action takes, besides the ones the CLI
+* relays on every line (`--database-url`, `--docker`, `--debug`).
+*
+* `switch` is absent: the CLI answers it before the driver is ever spawned.
+* An action not listed here is not checked, so the dispatch can say it does
+* not exist in its own words.
+*/
+var BRANCH_ACTION_FLAGS = {
+	create: {
+		"--from": String,
+		"--force": Boolean
+	},
+	list: {},
+	info: {},
+	delete: {
+		"--force": Boolean,
+		"--yes": Boolean,
+		"-y": "--yes"
+	},
+	prune: {
+		"--older-than": String,
+		"--include-dev-diff": Boolean,
+		"--yes": Boolean,
+		"-y": "--yes"
+	}
+};
+/**
+* Refuse a flag `action` does not take, naming the one it was probably meant
+* to be — the same sentence `db backup` and `db restore` say.
+*
+* Throws: the driver's entry turns a thrown error into one red line and exit 1,
+* and this runs before anything connects.
+*/
+function assertKnownBranchFlags(action, rest) {
+	const spec = BRANCH_ACTION_FLAGS[action];
+	if (!spec) return;
+	const full = {
+		...RELAYED_FLAGS,
+		...spec
+	};
+	const argv = resolveSwitchValues(full, rest, `db branch ${action}`, "db branch");
+	try {
+		(0, import_arg.default)(full, { argv });
+	} catch (error) {
+		const unknown = unknownFlagIn(error, rest);
+		if (unknown === null) throw error;
+		throw new Error(unknownOptionSentence(`db branch ${action}`, "db branch", unknown, spec));
+	}
+}
+/**
+* A `db branch` line, `["db", "branch", <action>, …]`, with its switches'
+* values resolved against the action's flags (see `resolveSwitchValues`):
+* what the branch dispatch reads, so `prune --yes=false` is not a yes. An
+* action the table does not list comes back as it was.
+*/
+function resolveBranchSwitches(rawArgs) {
+	const action = rawArgs[2];
+	const spec = action === void 0 ? void 0 : BRANCH_ACTION_FLAGS[action];
+	if (!spec) return [...rawArgs];
+	return [...rawArgs.slice(0, 3), ...resolveSwitchValues({
+		...RELAYED_FLAGS,
+		...spec
+	}, rawArgs.slice(3), `db branch ${action}`, "db branch")];
+}
+/**
+* Words on a `db branch` command line that no argument accounts for.
+*
+* `rebase db branch create alpha beta` created a branch called `alpha` and
+* threw `beta` away without a word. The shapes that produces are all quiet and
+* all wrong: an unquoted name (`create my feature` → `my`), a flag written
+* without its dashes (`create feat from main` → `feat`), a shell that split
+* something you thought was one token. In each case the command succeeds and
+* the branch is not the one asked for — and branch names are the thing you
+* later type to switch, delete, or point a deploy at.
+*
+* A flag the action does not take is refused outright, by throwing — see
+* {@link BRANCH_ACTION_FLAGS}. It was let through on the reasoning that a
+* subcommand added later might take flags this file had never heard of; what
+* that bought was every typo running without the flag it meant:
+* `prune --older-then 1d --yes` pruned by no age, `create x --froce` ran
+* without --force. A new action gets its line in the table. The value after a
+* flag that takes one is skipped: it is that flag's argument, not a stray word.
+*
+* @param words The command's own arguments: action, name, then the rest.
+*/
+function unexpectedBranchArgs(words) {
+	if (words[0]) assertKnownBranchFlags(words[0], words.slice(1));
+	const extras = [];
+	let seenName = false;
+	for (let index = 1; index < words.length; index += 1) {
+		const word = words[index];
+		if (word.startsWith("-")) {
+			if (TAKES_A_VALUE.has(word.split("=")[0])) index += 1;
+			continue;
+		}
+		if (!seenName) {
+			seenName = true;
+			continue;
+		}
+		extras.push(word);
+	}
+	return extras;
+}
+/**
+* Branch-line flags whose next word belongs to them.
+*
+* `--from` was the only one listed, and `--database-url` is the one that bit:
+* `rebase db branch list --database-url postgres://…` — which the CLI itself
+* appends when the checkout is on a branch, so `rebase.branches` is read in the
+* parent where it lives — answered `✗ Unexpected argument: postgres://…`. The
+* `=` form carries its value in the same word and needs no skip.
+*/
+var TAKES_A_VALUE = /* @__PURE__ */ new Set([
+	"--from",
+	"--older-than",
+	"--database-url"
+]);
+//#endregion
+//#region src/backup-argv.ts
+/**
+* @param rawArgs the driver's whole line, `["db", "backup", …]`.
+*/
+function backupActionOf(rawArgs) {
+	return rawArgs[2] === "list" ? "list" : "create";
+}
+//#endregion
+//#region src/db-subcommands.ts
+/**
+* The `db` subcommands this driver dispatches, with no runtime dependencies.
+*
+* Its own module so the dispatch in `cli.ts` can name them without loading
+* what judges their lines (`db-command-line.ts` reaches the backup module,
+* which `cli.ts` imports only when a backup command runs).
+*/
+var DRIVER_DB_SUBCOMMANDS = [
+	"push",
+	"generate",
+	"migrate",
+	"branch",
+	"backup",
+	"restore",
+	"backups"
+];
+/** Is `word` a `db` subcommand this driver answers? */
+function isDriverDbSubcommand(word) {
+	return DRIVER_DB_SUBCOMMANDS.some((subcommand) => subcommand === word);
+}
+//#endregion
+export { rlsRuntimeIsCurrent as _, resolveBranchSwitches as a, assertKnownFlags as c, parseCommandFlags as d, parseDriverLine as f, dropLegacyAuthSchema as g, RLS_BOOTSTRAP_STATEMENTS as h, assertKnownBranchFlags as i, closestWord as l, RLS_BOOTSTRAP_SQL as m, isDriverDbSubcommand as n, unexpectedBranchArgs as o, resolveDriverSwitches as p, backupActionOf as r, RELAYED_FLAGS as s, DRIVER_DB_SUBCOMMANDS as t, collectionsPathIn as u, rls_bootstrap_sql_exports as v, execa as y };
 
-//# sourceMappingURL=rls-bootstrap-sql-Bd-hJk08.js.map
+//# sourceMappingURL=db-subcommands-BPoHCxJR.js.map