@rebasepro/cli 0.25.0 → 0.26.0

package/dist/{dev-C0pbMmhS.js → dev-DTqVMgB3.js}

@@ -1,14 +1,15 @@
-import { i as recordEvent } from "./telemetry-EMFRVRQi.js";
+import { i as recordEvent } from "./telemetry-CgwJPVMO.js";
 import { n as getPMCommands, t as detectPackageManager } from "./package-manager-DSEOwTqM.js";
-import { a as findBackendDir, g as resolveTsx, h as resolvePluginCliScript, l as getActiveBackendPlugin, n as dependenciesNotInstalled, o as findEnvFile, p as requireProjectRoot, s as findFrontendDir, v as validateTsxInstallation } from "./project-Wp2zoyeN.js";
-import { n as parseCommandArgs, r as wantsHelp, t as UsageError } from "./args-BX0YD14a.js";
-import { d as findBackendApp, f as formatAppAddress, g as resolveBackendPaths, l as cmsMountOf, p as loadManifest, v as staticAppAddress } from "./manifest-DRp0UVTj.js";
-import { n as getProjectPort } from "./dev-server-B1UYifZJ.js";
-import { i as ensureDevDatabase, o as probeTcp } from "./dev-preflight-unHpiYO1.js";
+import { C as switchOn, a as findBackendDir, b as UsageError, g as resolveTsx, h as resolvePluginCliScript, l as getActiveBackendPlugin, n as dependenciesNotInstalled, o as findEnvFile, p as requireProjectRoot, s as findFrontendDir, v as validateTsxInstallation, w as wantsHelp, x as parseCommandArgs } from "./project-CasK56vN.js";
+import { d as findBackendApp, f as formatAppAddress, g as resolveBackendPaths, l as cmsMountOf, p as loadManifest, v as staticAppAddress } from "./manifest-BtzDy7KQ.js";
+import { r as getProjectPort, t as DEV_BACKEND_URL_ENV } from "./dev-server-OJsUGZEB.js";
+import { collectionsDirArgs, resolveCollectionsDir, resolveConfigDir } from "./collections-dir-DlvDhime.js";
+import { t as Refusal } from "./refusal-ReeeGP8a.js";
+import { i as ensureDevDatabase, o as probeTcp } from "./dev-preflight-Cxv3TiD1.js";
 import { t as MANAGED_IDLE_TIMEOUT_MS } from "./constraints-CtiylsGf.js";
-import { a as resolveCliEntry, o as resolveSpawn } from "./daemon-CknkDjd6.js";
-import { DEV_DATABASE_KIND_ENV, i as lastDevDatabaseNotice, managedNotices, prepareDatabaseEnv, resolveProjectDatabase, s as recordLastDevDatabase } from "./prepare-DdnU70z8.js";
-import { runDriverDbCommand, runDriverSchemaCommand } from "./db-CRNpA5mH.js";
+import { a as resolveCliEntry, o as resolveSpawn } from "./daemon-Cp7oNXth.js";
+import { DEV_DATABASE_KIND_ENV, i as lastDevDatabaseNotice, managedNotices, prepareDatabaseEnv, resolveProjectDatabase, s as recordLastDevDatabase } from "./prepare-CTw9NEkh.js";
+import { runDriverDbCommand, runDriverSchemaCommand } from "./db-KzlqddGD.js";
 import { t as affectsSqlSchema } from "./collection-drift-BKj_BoMq.js";
 import chalk from "chalk";
 import fs from "fs";
@@ -20,6 +21,80 @@ import dotenv from "dotenv";
 import { DEFAULT_RESOURCE_KEY, parseEnvBoolean } from "@rebasepro/types";
 import { execa, execaCommandSync } from "execa";
 import { StringDecoder } from "string_decoder";
+//#region src/utils/boot-retry.ts
+/**
+* A backend boot that lost its database part-way, which booting again fixes.
+*
+* `rebase db branch create --force` closes the database it copies: it ends
+* every connection to it and refuses new ones until the copy is done. A
+* backend booting at that moment failed with `Failed to start the Rebase
+* runtime … terminating connection due to administrator command (57P01)`, and
+* `rebase dev` then said "Fix the error above; the watcher restarts it on the
+* next change", about an error nobody could fix and that the next boot would
+* not have. The same holds for a database that is restarting.
+*
+* This reads the backend's output and says when a failed boot is worth another
+* try, and after how long: a few tries, each waiting twice as long as the one
+* before, and none once the backend has failed for a reason of its own.
+*/
+/** The sentence that starts a boot failure, as `reportBootFailure` in `@rebasepro/server` writes it. */
+var BOOT_FAILED = /Failed to start the Rebase runtime/;
+/**
+* Why a boot failed that a later boot does not, by what PostgreSQL said:
+* the server ended the connection (57P01 `pg_terminate_backend`, 57P02, 57P03
+* a server starting or stopping), or the database is closed to new
+* connections (55000, what a forced branch create does while it copies).
+* A connection the server ended while it sat idle is reported by `pg` on the
+* next query, in its own words and with no code: "Client has encountered a
+* connection error and is not queryable".
+*/
+var PASSING_CAUSES = [
+	/terminating connection due to administrator command/i,
+	/Client has encountered a connection error and is not queryable/i,
+	/\(57P0[123]\)/,
+	/is not currently accepting connections/i,
+	/the database system is (?:starting up|shutting down|in recovery mode)/i
+];
+var BootRetry = class {
+	maxAttempts;
+	firstDelayMs;
+	failing = false;
+	planned = false;
+	attempts = 0;
+	constructor(maxAttempts = 3, firstDelayMs = 1e3) {
+		this.maxAttempts = maxAttempts;
+		this.firstDelayMs = firstDelayMs;
+	}
+	/**
+	* Read one line of the backend's output, colour removed. Returns a plan
+	* the first time a failing boot names a passing cause, and null otherwise,
+	* including once the tries are spent.
+	*/
+	line(text) {
+		if (BOOT_FAILED.test(text)) {
+			this.failing = true;
+			this.planned = false;
+		}
+		if (!this.failing || this.planned) return null;
+		if (!PASSING_CAUSES.some((cause) => cause.test(text))) return null;
+		this.planned = true;
+		if (this.attempts >= this.maxAttempts) return null;
+		this.attempts += 1;
+		return {
+			attempt: this.attempts,
+			of: this.maxAttempts,
+			delayMs: this.firstDelayMs * 2 ** (this.attempts - 1),
+			reason: text.trim()
+		};
+	}
+	/** The backend is serving: a later failure is a new one, with every try left. */
+	up() {
+		this.failing = false;
+		this.planned = false;
+		this.attempts = 0;
+	}
+};
+//#endregion
 //#region src/commands/dev.ts
 /**
 * CLI command: rebase dev
@@ -225,12 +300,53 @@ function devRuntimeEnv(projectRoot) {
 */
 function devWatchIncludes(projectRoot, paths) {
 	const dirs = [paths.REBASE_DEV_FUNCTIONS, paths.REBASE_DEV_CRONS].filter((entry) => Boolean(entry)).map((entry) => path.resolve(projectRoot, entry));
-	dirs.push(path.join(projectRoot, "config"));
+	dirs.push(path.join(projectRoot, resolveConfigDir(projectRoot)));
 	return dirs;
 }
 /** Where dev watches the collections it regenerates the schema and SDK from. */
 function devCollectionsDir(projectRoot) {
-	return path.join(projectRoot, "config", "collections");
+	return resolveCollectionsDir(projectRoot);
+}
+/**
+* Call `onAppear` once, when `target` exists, and return what stops waiting.
+*
+* Watches the nearest directory above `target` that exists (no higher than
+* `root`), and follows the path down as each part of it appears — `fs.watch`
+* cannot watch a directory that is not there yet. A headless project has no
+* `config/collections` until `rebase schema introspect` writes one, and dev
+* watched it only when it was there at start: the backend kept serving the
+* API it derived from the database, and edits to the new files did nothing,
+* until dev was restarted by hand.
+*/
+function whenDirectoryAppears(target, root, onAppear) {
+	let watcher = null;
+	let watching = null;
+	let done = false;
+	const stop = () => {
+		done = true;
+		watcher?.close();
+		watcher = null;
+	};
+	const arm = () => {
+		if (done) return;
+		if (fs.existsSync(target)) {
+			stop();
+			onAppear();
+			return;
+		}
+		let dir = path.dirname(target);
+		while (!fs.existsSync(dir) && dir !== root && path.dirname(dir) !== dir) dir = path.dirname(dir);
+		if (dir === watching || !fs.existsSync(dir)) return;
+		watcher?.close();
+		watching = dir;
+		try {
+			watcher = fs.watch(dir, () => arm());
+		} catch {
+			watcher = null;
+		}
+	};
+	arm();
+	return stop;
 }
 /**
 * The file dev writes to restart the backend, or `null` when tsx would not see it.
@@ -323,7 +439,7 @@ async function declaredAdditionalDatabases(projectRoot) {
 	try {
 		const backend = findBackendApp(loadManifest(projectRoot).manifest);
 		if (!backend) return [];
-		const { deriveResourceGraph, deriveOptionsFor } = await import("./derive-CsoFGAnK.js").then((n) => n.i);
+		const { deriveResourceGraph, deriveOptionsFor } = await import("./derive-ae9UOoOB.js").then((n) => n.i);
 		const { graph } = await deriveResourceGraph({
 			...deriveOptionsFor(projectRoot, backend.app),
 			cronsDir: void 0,
@@ -666,7 +782,7 @@ function readEnvVar(projectRoot, name) {
 * mode serves whatever the database already has.
 */
 function projectHasCollections(projectRoot) {
-	const collectionsDir = path.join(projectRoot, "config", "collections");
+	const collectionsDir = devCollectionsDir(projectRoot);
 	return fs.existsSync(collectionsDir) && fs.readdirSync(collectionsDir).some((name) => /\.(ts|js|mts|mjs)$/.test(name) && !name.startsWith("index."));
 }
 /**
@@ -763,9 +879,13 @@ function needsStaleSchemaPreflight(generation) {
 * hand, so it is captured, and on failure only the lines that say what went
 * wrong are shown — not the stack under them. Like the schema, a failure never
 * stops `dev`.
+*
+* `backendPort` is where the backend is, or is about to be: the README's
+* example names it. The first run is before the backend binds, so it is told
+* rather than left to read `.rebase/state.json`.
 */
-async function regenerateSdk(projectRoot) {
-	if (!projectHasCollections(projectRoot)) return;
+async function regenerateSdk(projectRoot, backendPort) {
+	if (!projectHasCollections(projectRoot)) return "skipped";
 	const entry = resolveCliEntry();
 	const { execPath, prefixArgs } = resolveSpawn(entry);
 	try {
@@ -775,16 +895,43 @@ async function regenerateSdk(projectRoot) {
 			"generate-sdk"
 		], {
 			cwd: projectRoot,
-			all: true
+			all: true,
+			...backendPort !== null ? { env: { [DEV_BACKEND_URL_ENV]: `http://localhost:${backendPort}` } } : {}
 		});
+		return "generated";
 	} catch (error) {
 		const cause = (typeof error === "object" && error !== null && "all" in error && typeof error.all === "string" ? error.all : "").split("\n").filter((line) => line.trim() && !/^\s+at /.test(line)).slice(-6);
 		console.log(`  ${chalk.yellow("⚠")} ${chalk.gray("Could not regenerate the SDK types in generated/sdk.")}`);
 		if (cause.length > 0) console.log(chalk.gray(cause.map((line) => `    ${line.trim()}`).join("\n")));
 		console.log(`  ${chalk.gray(`Run ${chalk.cyan("rebase generate-sdk")} to see why.`)}`);
+		return "failed";
 	}
 }
 /**
+* What dev prints once a collection edit's regeneration is done.
+*
+* The green "regenerated" box only when neither half failed. It used to be
+* printed unconditionally, right under "⚠ Could not regenerate the database
+* schema … nothing was applied" — and then the backend refused to boot over
+* the same collection error, so the success line was the one wrong thing on
+* the screen.
+*/
+function collectionChangeSummary(schema, sdk) {
+	const failed = [schema === "failed" && "the database schema", sdk === "failed" && "the SDK types"].filter((part) => Boolean(part));
+	if (failed.length > 0) return [
+		chalk.yellow(`  ⚠ Not regenerated: ${failed.join(" and ")} — fix the error above and save again.`),
+		chalk.gray("    The backend restarts and reports the same problem until it is fixed."),
+		""
+	];
+	return [
+		chalk.green("  ✓ Schema and SDK types regenerated. The backend restarts and boot"),
+		chalk.green("    creates what is missing — a new collection, a new property."),
+		chalk.gray("    For what boot leaves alone — a renamed column, a narrowed type,"),
+		chalk.gray(`    a removed field — run ${chalk.cyan("rebase db push")}.`),
+		""
+	];
+}
+/**
 * One variable's value out of `.env` text, or undefined when it has none.
 *
 * The obvious `\s*(.+?)\s*$` does not do this, because `\s` matches a newline
@@ -982,7 +1129,7 @@ async function devCommand(rawArgs) {
 		printDevHelp();
 		return;
 	}
-	if (rawArgs.includes("--generate") || rawArgs.includes("-g")) throw new UsageError("`rebase dev --generate` is gone: dev now regenerates the schema and the SDK types on every start and every collection save. Drop the flag.");
+	if (switchOn(rawArgs, "--generate") || rawArgs.includes("-g")) throw new UsageError("`rebase dev --generate` is gone: dev now regenerates the schema and the SDK types on every start and every collection save. Drop the flag.");
 	const { flags: args } = parseCommandArgs({
 		spec: DEV_FLAGS,
 		rawArgs,
@@ -1009,7 +1156,7 @@ async function devCommand(rawArgs) {
 	const { port: startPort, source: startPortSource } = resolveStartPort(projectRoot, args["--port"]);
 	const portIsPinned = args["--port"] !== void 0;
 	const pinnedFrontendPort = process.env.REBASE_FRONTEND_PORT;
-	if (pinnedFrontendPort && !/^\d+$/.test(pinnedFrontendPort)) throw new Error(`REBASE_FRONTEND_PORT must be a number, got ${JSON.stringify(pinnedFrontendPort)}.`);
+	if (pinnedFrontendPort && !/^\d+$/.test(pinnedFrontendPort)) throw new Refusal(`REBASE_FRONTEND_PORT must be a number, got ${JSON.stringify(pinnedFrontendPort)}.`);
 	const frontendPort = pinnedFrontendPort ? Number(pinnedFrontendPort) : getProjectFrontendPort(projectRoot);
 	if (!frontendOnly) {
 		const refusal = await pinnedPortRefusal(startPort, portIsPinned);
@@ -1046,6 +1193,15 @@ async function devCommand(rawArgs) {
 	* which is the failure the flag exists to produce.
 	*/
 	let prepared = null;
+	/**
+	* The backend port the SDK README was last generated for: the one the
+	* backend is told at boot, then each one it announces it bound.
+	*/
+	let sdkBackendPort = startsBackend ? startPort : null;
+	const regenerateSdkFor = (port) => {
+		sdkBackendPort = port;
+		return regenerateSdk(projectRoot, port);
+	};
 	if (!frontendOnly) {
 		const resolved = args["--docker"] ? resolveProjectDatabase(projectRoot, {
 			flagUrl,
@@ -1054,7 +1210,7 @@ async function devCommand(rawArgs) {
 		}) : null;
 		const dockerUrl = resolved?.kind === "docker" ? resolved.url ?? void 0 : void 0;
 		({schemaGeneration, database: prepared} = await overlapDevStartup({
-			generate: async () => (await Promise.all([ensureGeneratedSchema(projectRoot), regenerateSdk(projectRoot)]))[0],
+			generate: async () => (await Promise.all([ensureGeneratedSchema(projectRoot), regenerateSdkFor(sdkBackendPort)]))[0],
 			preflight: () => runDatabasePreflight({
 				projectRoot,
 				disabled: noDb || flagUrl !== null,
@@ -1292,16 +1448,22 @@ async function devCommand(rawArgs) {
 		try {
 			const activePlugin = getActiveBackendPlugin(backendDir);
 			const pluginCli = activePlugin ? resolvePluginCliScript(backendDir, activePlugin) : null;
-			if (pluginCli && needsStaleSchemaPreflight(schemaGeneration)) await execa(tsxBin, [
-				pluginCli,
-				"schema",
-				"stale",
-				"--fix"
-			], {
-				cwd: backendDir,
-				stdio: "inherit",
-				env
-			});
+			if (pluginCli && needsStaleSchemaPreflight(schemaGeneration)) {
+				const staleArgs = [
+					"schema",
+					"stale",
+					"--fix"
+				];
+				await execa(tsxBin, [
+					pluginCli,
+					...staleArgs,
+					...collectionsDirArgs(projectRoot, staleArgs)
+				], {
+					cwd: backendDir,
+					stdio: "inherit",
+					env
+				});
+			}
 		} catch {}
 		const ejectedEntry = path.join(backendDir, "src", "index.ts");
 		const usesStockRuntime = !fs.existsSync(ejectedEntry);
@@ -1345,13 +1507,12 @@ async function devCommand(rawArgs) {
 			}
 		};
 		const collectionsDir = devCollectionsDir(projectRoot);
-		if (fs.existsSync(collectionsDir)) {
+		{
 			let debounce = null;
 			let sqlSchemaAffected = false;
 			let changed = "";
-			fs.watch(collectionsDir, { recursive: true }, (_eventType, filename) => {
-				if (!filename || filename.startsWith(".") || filename.endsWith(".tmp")) return;
-				sqlSchemaAffected = sqlSchemaAffected || affectsSqlSchema(collectionsDir, filename);
+			const collectionsChanged = (filename, affectsSchema) => {
+				sqlSchemaAffected = sqlSchemaAffected || affectsSchema;
 				changed = filename;
 				if (debounce) clearTimeout(debounce);
 				debounce = setTimeout(() => {
@@ -1359,7 +1520,7 @@ async function devCommand(rawArgs) {
 					sqlSchemaAffected = false;
 					(async () => {
 						if (!regenerateSchema) {
-							await regenerateSdk(projectRoot);
+							await regenerateSdkFor(resolvedBackendPort ?? startPort);
 							restartBackend();
 							return;
 						}
@@ -1372,17 +1533,22 @@ async function devCommand(rawArgs) {
 							chalk.yellow("  └──────────────────────────────────────────────────────────────┘")
 						].join("\n"));
 						const schemaBefore = generatedSchemaStamp();
-						await Promise.all([ensureGeneratedSchema(projectRoot), regenerateSdk(projectRoot)]);
-						if (!(usesStockRuntime && generatedSchemaStamp() !== schemaBefore)) restartBackend();
-						console.log([
-							chalk.green("  ✓ Schema and SDK types regenerated. The backend restarts and boot"),
-							chalk.green("    creates what is missing — a new collection, a new property."),
-							chalk.gray("    For what boot leaves alone — a renamed column, a narrowed type,"),
-							chalk.gray(`    a removed field — run ${chalk.cyan("rebase db push")}.`),
-							""
-						].join("\n"));
+						const [schemaResult, sdkResult] = await Promise.all([ensureGeneratedSchema(projectRoot), regenerateSdkFor(resolvedBackendPort ?? startPort)]);
+						if (!(usesStockRuntime && schemaBefore !== null && generatedSchemaStamp() !== schemaBefore)) restartBackend();
+						console.log(collectionChangeSummary(schemaResult, sdkResult).join("\n"));
 					})();
 				}, 500);
+			};
+			const watchCollections = () => {
+				fs.watch(collectionsDir, { recursive: true }, (_eventType, filename) => {
+					if (!filename || filename.startsWith(".") || filename.endsWith(".tmp")) return;
+					collectionsChanged(filename, affectsSqlSchema(collectionsDir, filename));
+				});
+			};
+			if (fs.existsSync(collectionsDir)) watchCollections();
+			else whenDirectoryAppears(collectionsDir, projectRoot, () => {
+				watchCollections();
+				collectionsChanged(`${path.basename(collectionsDir)}/`, true);
 			});
 		}
 		if (!backendOnly && frontendDir && await frontendCanStartWithBackend({
@@ -1415,6 +1581,23 @@ async function devCommand(rawArgs) {
 		* after the entry crashes, so nothing exits to contradict it.
 		*/
 		let backendAnnounced = false;
+		/**
+		* A boot that lost its database part-way is booted again, a few
+		* times, instead of waiting for a file change. See utils/boot-retry.ts:
+		* a `rebase db branch create --force` that lands while the backend
+		* boots ends its connections, and nothing in the project is wrong.
+		*/
+		const bootRetry = new BootRetry();
+		const retryPassingBootFailure = (line) => {
+			if (!usableTrigger || shuttingDown) return;
+			const plan = bootRetry.line(stripAnsi(line));
+			if (!plan) return;
+			setTimeout(() => {
+				if (shuttingDown || backendAnnounced) return;
+				console.log(chalk.gray(`  ↻ The backend lost its database while it was starting; starting it again (${plan.attempt} of ${plan.of}).`));
+				restartBackend();
+			}, plan.delayMs).unref?.();
+		};
 		/** The verdict, printed once per failure rather than once per line. */
 		let backendDownReported = false;
 		const reportBackendDown = (headline) => {
@@ -1537,6 +1720,7 @@ async function devCommand(rawArgs) {
 			console.log(`${chalk.cyan.bold("[backend]")}  ${line}`);
 			noticeWatcherRestart(line);
 			noticePortMoved(line);
+			retryPassingBootFailure(line);
 			const cleanLine = stripAnsi(line);
 			const swaggerMatch = cleanLine.match(/Swagger UI available.*"path":"([^"]+)"/);
 			if (swaggerMatch) swaggerPath = swaggerMatch[1];
@@ -1545,6 +1729,7 @@ async function devCommand(rawArgs) {
 				backendAnnounced = true;
 				backendDownReported = false;
 				missedProbes = 0;
+				bootRetry.up();
 				if (backendOnly) process.exitCode = 0;
 				disarmReadyDeadline();
 				resolvedBackendPort = parseInt(serverMatch[1], 10);
@@ -1561,6 +1746,7 @@ async function devCommand(rawArgs) {
 				fs.writeFileSync(urlFile, `http://localhost:${resolvedBackendPort}`, "utf-8");
 				const portFile = path.join(projectRoot, DEV_PORT_FILENAME);
 				fs.writeFileSync(portFile, devPortFileContents(resolvedBackendPort, startPort), "utf-8");
+				if (sdkBackendPort !== null && sdkBackendPort !== resolvedBackendPort) regenerateSdkFor(resolvedBackendPort);
 			}
 		});
 		/** Whether we've already shown a corrupted-modules recovery hint. */
@@ -1569,6 +1755,7 @@ async function devCommand(rawArgs) {
 			console.log(`${chalk.cyan.bold("[backend]")}  ${line}`);
 			noticeWatcherRestart(line);
 			noticePortMoved(line);
+			retryPassingBootFailure(line);
 			if (!corruptedModulesWarned) {
 				const cleanLine = stripAnsi(line);
 				if (cleanLine.includes("Cannot find module") && cleanLine.includes("node_modules/.pnpm/")) {
@@ -1690,4 +1877,4 @@ ${chalk.green.bold("Description")}
 //#endregion
 export { devCommand };
 
-//# sourceMappingURL=dev-C0pbMmhS.js.map
+//# sourceMappingURL=dev-DTqVMgB3.js.map