@rebasepro/cli 0.19.1-canary.g5a92fa9 → 0.19.1-canary.g9b6d85f

package/dist/commands/db.d.ts

@@ -112,6 +112,36 @@ export declare function refuseAtlasOnManagedDatabase(rawArgs: string[], kind: st
  * cover. It does now.
  */
 export declare function refuseBranchOnManagedDatabase(rawArgs: string[], kind: string): void;
+/**
+ * The one place this CLI spawns the driver's own CLI.
+ *
+ * There were three, each with its own copy of "tsx for a `.ts` entry, `node`
+ * otherwise". That rule was right only while the driver shipped `src/`; once it
+ * shipped `dist/cli.js` all three quietly switched to plain `node`, and the
+ * driver loads the PROJECT's TypeScript in process:
+ *
+ *   - `schema stale` reads the collections, could not resolve `./authors` onto
+ *     `authors.ts`, and answered "⏭ Not checked" while exiting 0;
+ *   - `db push` does the same in `ensureAuthTables`, so `rebase.users` was never
+ *     created and the push died at "Applying RLS policies" with
+ *     `relation "rebase.users" does not exist` — on a virgin database, which is
+ *     the documented bring-your-own-Postgres first run.
+ *
+ * Two were fixed and the third was missed, because three copies of a decision
+ * are three chances to miss one. There is one now, and a gate holds it at one.
+ *
+ * tsx whenever it is installed — a devDependency of every scaffold, for exactly
+ * this reason. Without it a `.ts` entry cannot run at all; a built entry still
+ * runs, and the subcommands that never touch the project's TypeScript still work.
+ */
+export declare function spawnDriverCli(resolved: {
+    projectRoot: string;
+    backendDir: string;
+    pluginCli: string;
+    env: Record<string, string>;
+}, childArgs: string[], options?: {
+    quiet?: boolean;
+}): Promise<void>;
 /**
  * Run a `schema` subcommand through the active driver's CLI.
  *

package/dist/index.es.js

@@ -2452,6 +2452,19 @@ async function configureEnvFile(targetDirectory, databaseUrl) {
 				`# DATABASE_URL=postgresql://rebase_app:${dbPassword}@127.0.0.1:${dbPort}/rebase?options=-c%20search_path%3Dpublic&sslmode=disable`,
 				`DATABASE_PASSWORD=${dbPassword}`
 			].join("\n"));
+			const envExampleReference = path.join(targetDirectory, ".env.example");
+			if (fs.existsSync(envExampleReference)) {
+				let exampleContent = fs.readFileSync(envExampleReference, "utf-8");
+				exampleContent = exampleContent.replace(/^DATABASE_URL=postgresql:\/\/[^\n]*$/m, [
+					"# Commented out on purpose — that is what selects the managed database.",
+					"# To use the docker-compose Postgres this project ships instead:",
+					"#   docker compose up -d db, then uncomment the line below in .env",
+					"#   (with DATABASE_PASSWORD from that file, not the placeholder here).",
+					`# DATABASE_URL=postgresql://rebase_app:changeme@127.0.0.1:${dbPort}/rebase?options=-c%20search_path%3Dpublic&sslmode=disable`
+				].join("\n"));
+				exampleContent = exampleContent.replaceAll("@localhost:5432/rebase", `@127.0.0.1:${dbPort}/rebase`);
+				fs.writeFileSync(envExampleReference, exampleContent, "utf-8");
+			}
 			const dockerComposePath = path.join(targetDirectory, "docker-compose.yml");
 			if (fs.existsSync(dockerComposePath)) {
 				let dockerComposeContent = fs.readFileSync(dockerComposePath, "utf-8");
@@ -2844,62 +2857,6 @@ function reportSpawnFailure(error) {
 	if (message) console.error(chalk.red(`✗ ${message}`));
 }
 //#endregion
-//#region src/utils/command-words.ts
-/**
-* The words that name a command, with the flags taken back out.
-*
-* `rawArgs` is the whole of `process.argv`, and reading the command's words at
-* fixed indices off it assumes nothing precedes them. Something routinely does:
-* `--debug` is what `bin/rebase.js` prints after every failure as the thing to
-* re-run with, so it is the single most likely token to appear before a command
-* word, and it shifted every index by one.
-*
-* What that cost is not a bad error message. `rebase db branch switch feature`
-* writes a per-checkout pointer that the CLI owns; the driver, running as a
-* child process, cannot persist it and does not try. The dispatch found
-* `switch` by position, so `rebase --debug db branch switch feature` missed the
-* CLI's branch and handed the line to the driver — which reported success and
-* left the checkout on the main database. Every subsequent `dev`, `push` and
-* `backup` then ran against the wrong database, believing it was the branch,
-* which is the exact failure branching exists to prevent.
-*
-* The words are anchored on the command name rather than taken from position
-* zero, because a flag written in the space form (`--database-url <url>`) leaves
-* its value behind as a bare token and no parser at this level knows which
-* flags take values. Anchoring survives that: the value would have to be the
-* literal command name to fool it.
-*
-* Returns `[]` when the command name is not on the line at all.
-*/
-function commandWords(rawArgs, command) {
-	const words = rawArgs.slice(2).filter((token) => !token.startsWith("-"));
-	const start = words.indexOf(command);
-	return start === -1 ? [] : words.slice(start);
-}
-/**
-* The line to hand a spawned driver, starting at the command word.
-*
-* The same defect one layer down, and it does not degrade gracefully: the
-* driver reads its domain from `args[0]`, so `rebase --debug db push` spawned
-* it with `["--debug", "db", "push"]` and it answered "Unknown domain command:
-* --debug" — for a flag the CLI itself tells you to add after any failure.
-*
-* Tokens written *before* the command word are moved after it rather than
-* dropped. Dropping them would be the same class of bug in the other direction:
-* `rebase --database-url postgres://… db push` would silently lose the flag that
-* says which database to touch. Appending keeps each flag next to its value, and
-* `arg` reads flags wherever they appear.
-*
-* Falls back to `rawArgs.slice(2)` when the command word is not on the line,
-* which is what an internally synthesised argv looks like.
-*/
-function argsFromCommand(rawArgs, command) {
-	const tail = rawArgs.slice(2);
-	const start = tail.findIndex((token) => token === command);
-	if (start <= 0) return [...tail];
-	return [...tail.slice(start), ...tail.slice(0, start)];
-}
-//#endregion
 //#region src/utils/unknown-command.ts
 /**
 * What every command family says when it does not recognise a subcommand.
@@ -2994,6 +2951,62 @@ function unknownCommand(typed, known, family = "") {
 	process.exit(1);
 }
 //#endregion
+//#region src/utils/command-words.ts
+/**
+* The words that name a command, with the flags taken back out.
+*
+* `rawArgs` is the whole of `process.argv`, and reading the command's words at
+* fixed indices off it assumes nothing precedes them. Something routinely does:
+* `--debug` is what `bin/rebase.js` prints after every failure as the thing to
+* re-run with, so it is the single most likely token to appear before a command
+* word, and it shifted every index by one.
+*
+* What that cost is not a bad error message. `rebase db branch switch feature`
+* writes a per-checkout pointer that the CLI owns; the driver, running as a
+* child process, cannot persist it and does not try. The dispatch found
+* `switch` by position, so `rebase --debug db branch switch feature` missed the
+* CLI's branch and handed the line to the driver — which reported success and
+* left the checkout on the main database. Every subsequent `dev`, `push` and
+* `backup` then ran against the wrong database, believing it was the branch,
+* which is the exact failure branching exists to prevent.
+*
+* The words are anchored on the command name rather than taken from position
+* zero, because a flag written in the space form (`--database-url <url>`) leaves
+* its value behind as a bare token and no parser at this level knows which
+* flags take values. Anchoring survives that: the value would have to be the
+* literal command name to fool it.
+*
+* Returns `[]` when the command name is not on the line at all.
+*/
+function commandWords(rawArgs, command) {
+	const words = rawArgs.slice(2).filter((token) => !token.startsWith("-"));
+	const start = words.indexOf(command);
+	return start === -1 ? [] : words.slice(start);
+}
+/**
+* The line to hand a spawned driver, starting at the command word.
+*
+* The same defect one layer down, and it does not degrade gracefully: the
+* driver reads its domain from `args[0]`, so `rebase --debug db push` spawned
+* it with `["--debug", "db", "push"]` and it answered "Unknown domain command:
+* --debug" — for a flag the CLI itself tells you to add after any failure.
+*
+* Tokens written *before* the command word are moved after it rather than
+* dropped. Dropping them would be the same class of bug in the other direction:
+* `rebase --database-url postgres://… db push` would silently lose the flag that
+* says which database to touch. Appending keeps each flag next to its value, and
+* `arg` reads flags wherever they appear.
+*
+* Falls back to `rawArgs.slice(2)` when the command word is not on the line,
+* which is what an internally synthesised argv looks like.
+*/
+function argsFromCommand(rawArgs, command) {
+	const tail = rawArgs.slice(2);
+	const start = tail.findIndex((token) => token === command);
+	if (start <= 0) return [...tail];
+	return [...tail.slice(start), ...tail.slice(0, start)];
+}
+//#endregion
 //#region src/dev-db/prepare.ts
 /**
 * The one place a command asks "which database, and how do I reach it?".
@@ -3179,122 +3192,6 @@ function managedNotices(prepared) {
 	return lines;
 }
 //#endregion
-//#region src/commands/schema.ts
-/**
-* CLI command: rebase schema <action>
-*/
-async function schemaCommand(subcommand, rawArgs) {
-	if (!subcommand || subcommand === "--help" || wantsHelp(rawArgs)) {
-		printSchemaHelp(subcommand === "--help" ? void 0 : subcommand);
-		return;
-	}
-	if (!SCHEMA_ACTION_HELP[subcommand]) unknownCommand(subcommand, Object.keys(SCHEMA_ACTION_HELP), "schema");
-	const projectRoot = requireProjectRoot();
-	recordEvent("cli.schema", { subcommand: subcommand ?? "none" }, { projectRoot });
-	const backendDir = requireBackendDir(projectRoot);
-	const activePlugin = getActiveBackendPlugin(backendDir);
-	if (!activePlugin) {
-		console.error(chalk.red("✗ Could not detect an active database plugin."));
-		console.error(chalk.gray("  Make sure a package like @rebasepro/server-postgres is installed in backend/package.json."));
-		process.exit(1);
-	}
-	const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
-	if (!pluginCli) exitDependenciesNotInstalled(projectRoot);
-	const envFile = findEnvFile(projectRoot);
-	const env = { ...process.env };
-	if (envFile) env.DOTENV_CONFIG_PATH = envFile;
-	env[DEV_DATABASE_KIND_ENV] = devDatabaseKind(projectRoot) ?? "";
-	try {
-		/**
-		* tsx, whether the driver CLI is source or built.
-		*
-		* This chose the interpreter from the file extension — tsx for a `.ts`
-		* entry, `node` for a built one — which was right only for as long as
-		* the driver shipped `src/`. Once it shipped `dist/cli.js`, the built
-		* CLI ran under plain `node`, and some of its subcommands load the
-		* PROJECT's collections in process. `schema stale` does: on the stock
-		* scaffold, whose collections import each other, Node could not resolve
-		* `./authors` onto `authors.ts` and the command reported "⏭ Not
-		* checked" — answering "is the generated schema stale?" with nothing,
-		* and exiting 0.
-		*
-		* The same rule lives in `execDriverCli` (commands/db.ts). Two copies of
-		* one decision is how they came to disagree; this one is kept because
-		* `schema` deliberately does NOT resolve a database, and `execDriverCli`
-		* is reached through a path that does.
-		*/
-		const tsxBin = resolveTsx(projectRoot);
-		if (!tsxBin && pluginCli.endsWith(".ts")) exitDependenciesNotInstalled(projectRoot);
-		await execa(tsxBin ?? "node", [pluginCli, ...argsFromCommand(rawArgs, "schema")], {
-			cwd: backendDir,
-			stdio: "inherit",
-			env
-		});
-	} catch (error) {
-		reportSpawnFailure(error);
-		process.exit(1);
-	}
-}
-/** One page per subcommand, so `rebase schema <action> --help` says something. */
-var SCHEMA_ACTION_HELP = {
-	generate: {
-		usage: "rebase schema generate [--collections <dir>] [--output <file>] [--watch]",
-		summary: "Generate the Drizzle schema from the collection definitions.",
-		notes: ["--watch regenerates on every change to a collection file."]
-	},
-	introspect: {
-		usage: "rebase schema introspect [--collections <dir>] [--output <dir>] [--schema <name>] [--force]",
-		summary: "Read an existing database and write Rebase collection definitions from it.",
-		notes: ["--force overwrites collection files that are already there."]
-	},
-	stale: {
-		usage: "rebase schema stale [--collections <dir>] [--output <file>] [--fix]",
-		summary: "Report generated schema files that no longer match the collections.",
-		notes: ["--fix regenerates them instead of only reporting."]
-	}
-};
-function printSchemaHelp(action) {
-	const entry = action ? SCHEMA_ACTION_HELP[action] : void 0;
-	if (entry) {
-		console.log(`
-${chalk.bold(`rebase schema ${action}`)}
-
-  ${entry.summary}
-
-${chalk.green.bold("Usage")}
-  ${chalk.blue(entry.usage)}
-${entry.notes?.length ? `\n${chalk.green.bold("Notes")}\n${entry.notes.map((n) => `  ${chalk.gray(`• ${n}`)}`).join("\n")}\n` : ""}
-${chalk.gray("Run `rebase schema --help` for every subcommand.")}
-`);
-		return;
-	}
-	console.log(`
-${chalk.bold("rebase schema")} — Schema management commands
-
-${chalk.green.bold("Usage")}
-  rebase schema ${chalk.blue("<command>")} [options]
-
-${chalk.green.bold("Commands")}
-  ${chalk.gray("(Commands are provided by your active database driver plugin)")}
-  ${chalk.blue.bold("generate")}    Generate Schema from collection definitions
-  ${chalk.blue.bold("introspect")}  Introspect an existing database to generate collection definitions
-  ${chalk.blue.bold("stale")}       Report generated schema files that no longer match the collections
-
-${chalk.green.bold("generate Options")}
-  ${chalk.blue("--collections, -c")}  Path to collections directory
-  ${chalk.blue("--output, -o")}       Output path for generated schema
-  ${chalk.blue("--watch, -w")}        Watch for changes and regenerate automatically
-
-${chalk.green.bold("introspect Options")}
-  ${chalk.blue("--output, -o")}       Output directory for generated collection files
-  ${chalk.blue("--schema")}           Postgres schema to read (default: public)
-  ${chalk.blue("--force, -f")}        Overwrite collection files that already exist
-
-${chalk.green.bold("stale Options")}
-  ${chalk.blue("--fix")}              Regenerate the stale files instead of only reporting them
-`);
-}
-//#endregion
 //#region src/commands/db.ts
 /**
 * CLI command: rebase db <action>
@@ -3588,42 +3485,41 @@ async function resolveDriverCli() {
 		env
 	};
 }
-/** Run the resolved driver CLI with the given child arguments. */
-async function execDriverCli(resolved, childArgs, options = {}) {
+/**
+* The one place this CLI spawns the driver's own CLI.
+*
+* There were three, each with its own copy of "tsx for a `.ts` entry, `node`
+* otherwise". That rule was right only while the driver shipped `src/`; once it
+* shipped `dist/cli.js` all three quietly switched to plain `node`, and the
+* driver loads the PROJECT's TypeScript in process:
+*
+*   - `schema stale` reads the collections, could not resolve `./authors` onto
+*     `authors.ts`, and answered "⏭ Not checked" while exiting 0;
+*   - `db push` does the same in `ensureAuthTables`, so `rebase.users` was never
+*     created and the push died at "Applying RLS policies" with
+*     `relation "rebase.users" does not exist` — on a virgin database, which is
+*     the documented bring-your-own-Postgres first run.
+*
+* Two were fixed and the third was missed, because three copies of a decision
+* are three chances to miss one. There is one now, and a gate holds it at one.
+*
+* tsx whenever it is installed — a devDependency of every scaffold, for exactly
+* this reason. Without it a `.ts` entry cannot run at all; a built entry still
+* runs, and the subcommands that never touch the project's TypeScript still work.
+*/
+async function spawnDriverCli(resolved, childArgs, options = {}) {
 	const { projectRoot, backendDir, pluginCli, env } = resolved;
 	const stdio = options.quiet ? "pipe" : "inherit";
-	/**
-	* tsx, whether the driver CLI is source or built.
-	*
-	* It used to be tsx only for a `.ts` entry, which happened to be right for
-	* as long as the driver shipped `src/`. Once it shipped `dist/cli.js`
-	* instead, this ran the built CLI under plain `node` — and some of its
-	* subcommands load the PROJECT's collections in process. `schema stale`
-	* does, so on every scaffold whose collections import each other (the stock
-	* one does) it failed to resolve them and reported "⏭ Not checked": a
-	* command that answers "is the generated schema stale?" with nothing at all,
-	* exiting 0, on the default project.
-	*
-	* Node cannot load a `.ts` file, and cannot resolve `./authors` or
-	* `./authors.js` onto `authors.ts`. tsx does both. It is a devDependency of
-	* every scaffold for exactly this reason.
-	*/
 	const tsxBin = resolveTsx(projectRoot);
-	if (tsxBin) {
-		await execa(tsxBin, [pluginCli, ...childArgs], {
-			cwd: backendDir,
-			stdio,
-			env
-		});
-		return;
-	}
-	if (pluginCli.endsWith(".ts")) throw new Error(dependenciesNotInstalled(projectRoot));
-	await execa("node", [pluginCli, ...childArgs], {
+	if (!tsxBin && pluginCli.endsWith(".ts")) throw new Error(dependenciesNotInstalled(projectRoot));
+	await execa(tsxBin ?? "node", [pluginCli, ...childArgs], {
 		cwd: backendDir,
 		stdio,
 		env
 	});
 }
+/** @deprecated Use {@link spawnDriverCli}. Kept as the internal name callers use. */
+var execDriverCli = spawnDriverCli;
 /**
 * Run a `schema` subcommand through the active driver's CLI.
 *
@@ -3666,21 +3562,12 @@ async function runDriverDbCommand(rawArgs, options = {}) {
 	if (!options.quiet) for (const line of managedNotices(prepared)) console.log(chalk.gray(`  ${line}`));
 	refuseAtlasOnManagedDatabase(rawArgs, prepared.database.kind);
 	const childArgs = absolutizeLocalPathArgs(argsFromCommand(rawArgs, "db"), process.cwd());
-	if (pluginCli.endsWith(".ts")) {
-		const tsxBin = resolveTsx(projectRoot);
-		if (!tsxBin) throw new Error(dependenciesNotInstalled(projectRoot));
-		await execa(tsxBin, [pluginCli, ...childArgs], {
-			cwd: backendDir,
-			stdio: "inherit",
-			env
-		});
-		return;
-	}
-	await execa("node", [pluginCli, ...childArgs], {
-		cwd: backendDir,
-		stdio: "inherit",
+	await spawnDriverCli({
+		projectRoot,
+		backendDir,
+		pluginCli,
 		env
-	});
+	}, childArgs, options);
 }
 async function dbCommand$1(subcommand, rawArgs) {
 	if (!subcommand || subcommand === "--help" || rawArgs.includes("--help") || rawArgs.includes("-h")) {
@@ -4348,6 +4235,103 @@ function dbExamples(kind) {
 `;
 }
 //#endregion
+//#region src/commands/schema.ts
+/**
+* CLI command: rebase schema <action>
+*/
+async function schemaCommand(subcommand, rawArgs) {
+	if (!subcommand || subcommand === "--help" || wantsHelp(rawArgs)) {
+		printSchemaHelp(subcommand === "--help" ? void 0 : subcommand);
+		return;
+	}
+	if (!SCHEMA_ACTION_HELP[subcommand]) unknownCommand(subcommand, Object.keys(SCHEMA_ACTION_HELP), "schema");
+	const projectRoot = requireProjectRoot();
+	recordEvent("cli.schema", { subcommand: subcommand ?? "none" }, { projectRoot });
+	const backendDir = requireBackendDir(projectRoot);
+	const activePlugin = getActiveBackendPlugin(backendDir);
+	if (!activePlugin) {
+		console.error(chalk.red("✗ Could not detect an active database plugin."));
+		console.error(chalk.gray("  Make sure a package like @rebasepro/server-postgres is installed in backend/package.json."));
+		process.exit(1);
+	}
+	const pluginCli = resolvePluginCliScript(backendDir, activePlugin);
+	if (!pluginCli) exitDependenciesNotInstalled(projectRoot);
+	const envFile = findEnvFile(projectRoot);
+	const env = { ...process.env };
+	if (envFile) env.DOTENV_CONFIG_PATH = envFile;
+	env[DEV_DATABASE_KIND_ENV] = devDatabaseKind(projectRoot) ?? "";
+	try {
+		await spawnDriverCli({
+			projectRoot,
+			backendDir,
+			pluginCli,
+			env
+		}, argsFromCommand(rawArgs, "schema"));
+	} catch (error) {
+		reportSpawnFailure(error);
+		process.exit(1);
+	}
+}
+/** One page per subcommand, so `rebase schema <action> --help` says something. */
+var SCHEMA_ACTION_HELP = {
+	generate: {
+		usage: "rebase schema generate [--collections <dir>] [--output <file>] [--watch]",
+		summary: "Generate the Drizzle schema from the collection definitions.",
+		notes: ["--watch regenerates on every change to a collection file."]
+	},
+	introspect: {
+		usage: "rebase schema introspect [--collections <dir>] [--output <dir>] [--schema <name>] [--force]",
+		summary: "Read an existing database and write Rebase collection definitions from it.",
+		notes: ["--force overwrites collection files that are already there."]
+	},
+	stale: {
+		usage: "rebase schema stale [--collections <dir>] [--output <file>] [--fix]",
+		summary: "Report generated schema files that no longer match the collections.",
+		notes: ["--fix regenerates them instead of only reporting."]
+	}
+};
+function printSchemaHelp(action) {
+	const entry = action ? SCHEMA_ACTION_HELP[action] : void 0;
+	if (entry) {
+		console.log(`
+${chalk.bold(`rebase schema ${action}`)}
+
+  ${entry.summary}
+
+${chalk.green.bold("Usage")}
+  ${chalk.blue(entry.usage)}
+${entry.notes?.length ? `\n${chalk.green.bold("Notes")}\n${entry.notes.map((n) => `  ${chalk.gray(`• ${n}`)}`).join("\n")}\n` : ""}
+${chalk.gray("Run `rebase schema --help` for every subcommand.")}
+`);
+		return;
+	}
+	console.log(`
+${chalk.bold("rebase schema")} — Schema management commands
+
+${chalk.green.bold("Usage")}
+  rebase schema ${chalk.blue("<command>")} [options]
+
+${chalk.green.bold("Commands")}
+  ${chalk.gray("(Commands are provided by your active database driver plugin)")}
+  ${chalk.blue.bold("generate")}    Generate Schema from collection definitions
+  ${chalk.blue.bold("introspect")}  Introspect an existing database to generate collection definitions
+  ${chalk.blue.bold("stale")}       Report generated schema files that no longer match the collections
+
+${chalk.green.bold("generate Options")}
+  ${chalk.blue("--collections, -c")}  Path to collections directory
+  ${chalk.blue("--output, -o")}       Output path for generated schema
+  ${chalk.blue("--watch, -w")}        Watch for changes and regenerate automatically
+
+${chalk.green.bold("introspect Options")}
+  ${chalk.blue("--output, -o")}       Output directory for generated collection files
+  ${chalk.blue("--schema")}           Postgres schema to read (default: public)
+  ${chalk.blue("--force, -f")}        Overwrite collection files that already exist
+
+${chalk.green.bold("stale Options")}
+  ${chalk.blue("--fix")}              Regenerate the stale files instead of only reporting them
+`);
+}
+//#endregion
 //#region src/manifest.ts
 /**
 * Loading, validating and synthesizing `rebase.json`.