@rebasepro/cli 0.24.0 → 0.24.1-canary.g56af4a4

package/dist/status-BR9oyi-y.js

@@ -0,0 +1,351 @@
+import { d as readEnvFile, i as failAsJson, p as requireProjectRoot } from "./project-Wp2zoyeN.js";
+import { n as parseCommandArgs, r as wantsHelp } from "./args-BnmsEXvu.js";
+import { d as findBackendApp, g as resolveBackendPaths, o as ManifestError, p as loadManifest } from "./manifest-DzlC60WX.js";
+import { c as withImplicitDefaults, n as deriveOptionsFor, o as readResourceGraphFile, r as deriveResourceGraph, s as serializeResourceGraph, t as RESOURCE_GRAPH_FILENAME } from "./derive-RPIsAVO4.js";
+import { i as findRunningDaemon, n as resolveDevDatabase, o as managedUrl, resolveActiveBranch, resolveComposeUrl } from "./prepare-Btn9Ewbn.js";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { DEFAULT_RESOURCE_KEY, envBasesForResource, resourceEnvSuffix, resourceToDataSource } from "@rebasepro/types";
+//#region src/resources/status.ts
+/**
+* What a project declared, what the environment binds it to, and whether the
+* two meet.
+*
+* ## Why this exists
+*
+* Every piece of this was already knowable and none of it was visible in one
+* place. `rebase resources` lists what you declared. The environment holds the
+* variables. The resolvers decide whether a source is usable. So the question a
+* developer actually has — *"why does uploading to `media` answer 501"* — could
+* only be answered by knowing the suffix rule, deriving the variable name by
+* hand, and checking it against a `.env` they had to find first.
+*
+* The answer is mechanical, so it should be printed rather than taught.
+*
+* ## Why it calls the resolvers instead of re-deciding
+*
+* The verdict comes from `resolveDataSources` and `resolveStorageBackend` — the
+* same functions that run at boot. A status view that decided for itself what
+* "configured" means would be a second implementation of the rule, and the
+* first time it disagreed it would be reassuring a developer about a deployment
+* that is about to refuse to start.
+*
+* The variable *names* come from each kind's `envBases`, and the verdicts from
+* the resolver `@rebasepro/server` registers per kind — one object per kind,
+* held to `envBases` by `resource-env-bases.test.ts`. A kind this view has
+* never heard of is judged by whatever resolver its package registered.
+*/
+/** Set, and not set to the empty string — which the resolvers treat as absent. */
+function isSet(env, name) {
+	const value = env[name];
+	return typeof value === "string" && value !== "";
+}
+/**
+* The bindings one declaration reads, in the order a reader should scan them.
+*
+* A `direct`-transport resource gets none: the browser reaches it with a
+* provider SDK and the backend binds nothing for it, so listing variables would
+* invite someone to set variables that are never read.
+*/
+function bindingsFor(declaration, env, accountScopedBases) {
+	if (declaration.transport !== "server") return [];
+	const suffix = resourceEnvSuffix(declaration.key);
+	const account = typeof declaration.options.account === "string" ? resourceEnvSuffix(declaration.options.account) : void 0;
+	return envBasesForResource(declaration).map((base) => {
+		const name = `${base}${suffix}`;
+		const binding = {
+			name,
+			set: isSet(env, name)
+		};
+		if (account !== void 0 && !binding.set && accountScopedBases.includes(base)) binding.fallback = {
+			name: `${base}${account}`,
+			set: isSet(env, `${base}${account}`)
+		};
+		return binding;
+	});
+}
+/**
+* The environment plus the managed database's URL, for the whole-set check.
+*
+* A copy: the bindings a reader sees are computed against the real `.env`, so
+* nothing here can make the view claim a variable is set that is not. This is
+* only what `resolveDataSources` is handed, and it is handed it so the check
+* judges the environment the runtime would actually get rather than throwing
+* "Data source "(default)" has no connection string" about a database that is
+* running and reachable.
+*/
+function withManagedUrls(env, graph, url) {
+	const filled = { ...env };
+	const keys = [DEFAULT_RESOURCE_KEY, ...graph.resources.filter((r) => r.kind === "database").map((r) => r.key)];
+	for (const key of keys) {
+		const name = `DATABASE_URL${resourceEnvSuffix(key)}`;
+		if (!isSet(filled, name)) filled[name] = url;
+	}
+	return filled;
+}
+/**
+* Resolve every declared resource against an environment.
+*
+* Each kind's verdict comes from the resolver `@rebasepro/server` registered
+* for it — the same one boot calls — so this view cannot say "ready" about a
+* binding boot would refuse. A kind with no resolver is reported as such
+* rather than skipped: a resource nobody shows is one nobody remembers to
+* configure, and a kind this runtime cannot bind is exactly what boot will
+* refuse by name.
+*
+* `resolveDataSources` is then run once over the whole set, so anything it
+* would refuse across sources (a driver package it cannot resolve for a custom
+* engine) is reported rather than missed by a view that only looked per row.
+*/
+function computeStatus(graph, env, resolvers) {
+	const resources = [];
+	const production = resolvers.production ?? false;
+	const managed = resolvers.managedDatabase;
+	/** Database rows the managed database answered for, so `blocked` can skip them. */
+	let managedCovered = 0;
+	for (const { declaration, implicit } of withImplicitDefaults(graph)) {
+		const resolver = resolvers.resolverFor(declaration.kind);
+		const bindings = bindingsFor(declaration, env, resolver?.accountScoped ?? []);
+		const base = {
+			kind: declaration.kind,
+			key: declaration.key,
+			engine: declaration.engine,
+			transport: declaration.transport,
+			...typeof declaration.options.account === "string" ? { account: declaration.options.account } : {},
+			implicit,
+			bindings,
+			...declaration.usedBy && declaration.usedBy.length > 0 ? { usedBy: declaration.usedBy } : {}
+		};
+		if (!resolver) {
+			resources.push({
+				...base,
+				state: "broken",
+				detail: `this runtime has no resolver for a "${declaration.kind}" — boot refuses it by name. Upgrade @rebasepro/server, or remove the declaration.`
+			});
+			continue;
+		}
+		if (managed && declaration.kind === "database" && bindings.every((b) => !b.set && !b.fallback?.set)) {
+			managedCovered += 1;
+			resources.push({
+				...base,
+				state: "ready",
+				detail: managed.url ? "the managed development database (PGlite), this project only" : "the managed development database (PGlite), this project only — not running; start it with `rebase dev`"
+			});
+			continue;
+		}
+		const verdict = resolver.resolve(declaration, env, {
+			production,
+			defaultBasePath: "uploads"
+		});
+		switch (verdict.state) {
+			case "ready":
+				resources.push({
+					...base,
+					state: "ready",
+					...verdict.standsIn ? { standsIn: verdict.standsIn } : {},
+					detail: verdict.detail ?? ""
+				});
+				break;
+			case "code":
+				resources.push({
+					...base,
+					state: "ready",
+					detail: verdict.detail ?? "needs no environment configuration"
+				});
+				break;
+			case "unbound":
+				resources.push({
+					...base,
+					state: "unconfigured",
+					detail: verdict.detail ?? "declared, not configured"
+				});
+				break;
+			case "blocked":
+				resources.push({
+					...base,
+					state: implicit || bindings.every((b) => !b.set && !b.fallback?.set) ? "unconfigured" : "broken",
+					detail: verdict.detail ?? "boot refuses this binding"
+				});
+				break;
+		}
+	}
+	let blocked;
+	const managedSetUnknown = managedCovered > 0 && !managed?.url;
+	if (resources.every((r) => r.state === "ready") && !managedSetUnknown) try {
+		resolvers.resolveDataSources(managed?.url ? withManagedUrls(env, graph, managed.url) : env, graph.resources.filter((r) => r.kind === "database").map(resourceToDataSource));
+	} catch (err) {
+		blocked = err instanceof Error ? err.message : String(err);
+	}
+	return {
+		resources,
+		...blocked !== void 0 ? { blocked } : {}
+	};
+}
+//#endregion
+//#region src/commands/status.ts
+/**
+* `rebase status` — what this project is, and whether it can reach its things.
+*
+* The model a developer has to hold is small and was nowhere visible:
+*
+*   rebase.json           where the code is, and who runs the server
+*   config/resources.ts   what the project needs
+*   the environment       how to reach each of them
+*
+* Everything else — `rebase.resources.json`, the bundle manifest — is a
+* generated copy of the middle one, for readers that cannot run the code. A
+* developer never writes them and should not have to think about them.
+*
+* This command prints the three together, resolved. It exists because the
+* question people actually arrive with — "why does uploading to `media` answer
+* 501" — was answerable only by knowing the `<BASE>__<KEY>` suffix rule,
+* deriving the variable name by hand, and checking it against a `.env` they had
+* to find first. Every step of that is mechanical, so it is printed instead.
+*/
+function usage() {
+	console.log(`
+${chalk.bold("rebase status")} — what this project declares, and whether it is configured
+
+${chalk.bold("Usage")}
+  rebase status                Show every resource and the variables it reads
+  rebase status --json         The same, as JSON
+
+${chalk.bold("Reads")}
+  rebase.json                  which apps exist, and who owns the server process
+  <config>/resources.ts        the databases, buckets, topics and queues declared
+  backend/crons, backend/functions   the crons and functions, by filename
+  .env                         whether each one's variables are set
+`);
+}
+var MARK = {
+	ready: chalk.green("✓"),
+	unconfigured: chalk.yellow("○"),
+	broken: chalk.red("✗")
+};
+function printResource(status) {
+	const name = status.key === "(default)" ? chalk.bold("(default)") : chalk.bold(status.key);
+	const tags = [chalk.gray(status.engine)];
+	if (status.transport !== "server") tags.push(chalk.yellow(status.transport));
+	if (status.account) tags.push(chalk.gray(`account:${status.account}`));
+	if (status.implicit) tags.push(chalk.gray("implicit"));
+	if (status.standsIn) tags.push(chalk.yellow(`local stand-in for ${status.standsIn}`));
+	console.log(`  ${MARK[status.state]} ${name}  ${tags.join(" · ")}`);
+	if (status.usedBy && status.usedBy.length > 0) console.log(`      ${chalk.gray("used by")} ${chalk.gray(status.usedBy.join(", "))}`);
+	let hiddenOptional = 0;
+	for (const binding of status.bindings) if (binding.set) console.log(`      ${chalk.green("✓")} ${chalk.gray(binding.name)}`);
+	else if (binding.fallback?.set) console.log(`      ${chalk.green("✓")} ${chalk.gray(binding.fallback.name)} ${chalk.gray(`(shared, for ${binding.name})`)}`);
+	else if (status.state === "ready") hiddenOptional += 1;
+	else {
+		const also = binding.fallback ? chalk.gray(` or ${binding.fallback.name}`) : "";
+		console.log(`      ${chalk.gray("·")} ${chalk.gray(binding.name)}${also} ${chalk.gray("not set")}`);
+	}
+	if (hiddenOptional > 0) console.log(chalk.gray(`      ${hiddenOptional} optional variable${hiddenOptional === 1 ? "" : "s"} not set`));
+	if (status.detail) {
+		const colour = status.state === "broken" ? chalk.red : status.state === "unconfigured" ? chalk.yellow : chalk.gray;
+		console.log(`      ${colour(`└ ${status.detail}`)}`);
+	}
+}
+async function statusCommand(rawArgs) {
+	if (wantsHelp(rawArgs)) return usage();
+	const { flags } = parseCommandArgs({
+		spec: { "--json": Boolean },
+		rawArgs,
+		commandWords: 1,
+		command: "status",
+		maxPositionals: 0
+	});
+	const projectRoot = requireProjectRoot();
+	const asJson = Boolean(flags["--json"]);
+	let backend;
+	try {
+		const found = findBackendApp(loadManifest(projectRoot).manifest);
+		if (!found) {
+			if (asJson) failAsJson("This project declares no backend app, so it declares no resources.", "no_backend_app", "Add a backend app to rebase.json, or run `rebase apps init`.");
+			console.error(chalk.red("This project declares no backend app, so it declares no resources."));
+			process.exitCode = 1;
+			return;
+		}
+		backend = found;
+	} catch (err) {
+		if (err instanceof ManifestError) {
+			if (asJson) failAsJson(err.message, "manifest_invalid", "Fix rebase.json, then run this again.", err.issues.map((issue) => ({
+				path: issue.path,
+				message: issue.message
+			})));
+			console.error(chalk.red(err.message));
+			for (const issue of err.issues) console.error(`  ${chalk.gray(issue.path)} ${issue.message}`);
+			process.exitCode = 1;
+			return;
+		}
+		throw err;
+	}
+	const { name: backendName, app: backendApp } = backend;
+	const paths = resolveBackendPaths(backendApp, projectRoot);
+	const { graph, issues } = await deriveResourceGraph(deriveOptionsFor(projectRoot, backendApp));
+	if (issues.length > 0) {
+		if (asJson) failAsJson(`${issues.length} problem(s) in the declared resources.`, "resource_declaration_invalid", "Fix the declarations the issues name, then run this again.", issues.map((issue) => ({
+			path: issue.path,
+			message: issue.message
+		})));
+		console.error(chalk.red(`\n✗ ${issues.length} problem(s) in the declared resources:\n`));
+		for (const issue of issues) console.error(`  ${chalk.bold(issue.path)}  ${issue.message}`);
+		console.error("");
+		process.exitCode = 1;
+		return;
+	}
+	const env = readEnvFile(projectRoot);
+	const production = env.NODE_ENV === "production";
+	const database = resolveDevDatabase({
+		env: {},
+		envFile: env,
+		branch: resolveActiveBranch(projectRoot, env),
+		composeUrl: resolveComposeUrl(projectRoot, env)
+	});
+	const daemon = database.kind === "managed" ? await findRunningDaemon(projectRoot) : null;
+	const managedDatabase = !production && database.kind === "managed" ? { url: daemon ? managedUrl(daemon.port) : null } : void 0;
+	const server = await import("@rebasepro/server");
+	const { resources, blocked } = computeStatus(graph, env, {
+		resolverFor: server.resourceResolver,
+		resolveDataSources: server.resolveDataSources,
+		production,
+		...managedDatabase ? { managedDatabase } : {}
+	});
+	if (asJson) {
+		console.log(JSON.stringify({
+			backend: backendName,
+			runtime: backendApp.runtime,
+			resources,
+			blocked
+		}, null, 2));
+		return;
+	}
+	const ownership = backendApp.runtime === "managed" ? "Rebase's runtime boots your bundle" : "this project builds its own image and entrypoint";
+	console.log("");
+	console.log(`  ${chalk.bold(backendName)}  ${chalk.gray("·")}  ${chalk.cyan(backendApp.runtime)}  ${chalk.gray(ownership)}`);
+	const resourcesFile = path.join(paths.config, "resources.ts");
+	const declaresAnything = fs.existsSync(path.join(projectRoot, resourcesFile));
+	console.log(`  ${chalk.gray("declared in")}  ${chalk.gray(resourcesFile)}${declaresAnything ? "" : chalk.gray("  (none — the defaults below are implicit)")}`);
+	console.log(`  ${chalk.gray("configured by")}  ${chalk.gray(".env")}`);
+	const kinds = [...new Set(resources.map((r) => r.kind))];
+	for (const kind of kinds) {
+		console.log("");
+		console.log(`  ${chalk.bold.underline(`${kind}s`)}`);
+		for (const status of resources.filter((r) => r.kind === kind)) printResource(status);
+	}
+	if (blocked) {
+		console.log("");
+		console.log(`  ${chalk.red("✗")} ${chalk.red(blocked)}`);
+	}
+	const committed = readResourceGraphFile(projectRoot);
+	if (committed !== serializeResourceGraph(graph) && !(committed === null && graph.resources.length === 0)) {
+		console.log("");
+		console.log(`  ${chalk.yellow("○")} ${RESOURCE_GRAPH_FILENAME} is ${committed === null ? "missing" : "stale"} — ${chalk.blue("rebase resources --write")}`);
+		console.log(chalk.gray("      a host reads it to decide what to provision before it runs anything"));
+	}
+	console.log("");
+}
+//#endregion
+export { statusCommand };
+
+//# sourceMappingURL=status-BR9oyi-y.js.map

package/dist/status-BR9oyi-y.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-BR9oyi-y.js","names":[],"sources":["../src/resources/status.ts","../src/commands/status.ts"],"sourcesContent":["/**\n * What a project declared, what the environment binds it to, and whether the\n * two meet.\n *\n * ## Why this exists\n *\n * Every piece of this was already knowable and none of it was visible in one\n * place. `rebase resources` lists what you declared. The environment holds the\n * variables. The resolvers decide whether a source is usable. So the question a\n * developer actually has — *\"why does uploading to `media` answer 501\"* — could\n * only be answered by knowing the suffix rule, deriving the variable name by\n * hand, and checking it against a `.env` they had to find first.\n *\n * The answer is mechanical, so it should be printed rather than taught.\n *\n * ## Why it calls the resolvers instead of re-deciding\n *\n * The verdict comes from `resolveDataSources` and `resolveStorageBackend` — the\n * same functions that run at boot. A status view that decided for itself what\n * \"configured\" means would be a second implementation of the rule, and the\n * first time it disagreed it would be reassuring a developer about a deployment\n * that is about to refuse to start.\n *\n * The variable *names* come from each kind's `envBases`, and the verdicts from\n * the resolver `@rebasepro/server` registers per kind — one object per kind,\n * held to `envBases` by `resource-env-bases.test.ts`. A kind this view has\n * never heard of is judged by whatever resolver its package registered.\n */\nimport { withImplicitDefaults } from \"./derive\";\nimport {\n    DEFAULT_RESOURCE_KEY,\n    envBasesForResource,\n    resourceEnvSuffix,\n    resourceToDataSource,\n    type ResourceDeclaration,\n    type ResourceGraph\n} from \"@rebasepro/types\";\n\n/** One environment variable a resource reads, and whether it is there. */\nexport interface ResourceBinding {\n    /** The variable this resource reads, suffix included. */\n    name: string;\n    set: boolean;\n    /**\n     * The account-scoped name consulted when `name` is unset.\n     *\n     * Only provider-level bindings have one, and only when the resource named\n     * an `account`. Shown because a developer looking at an unset\n     * `S3_ACCESS_KEY_ID__MEDIA` needs to know it is not the whole story.\n     */\n    fallback?: { name: string; set: boolean };\n}\n\n/** Whether a declared resource can actually be reached. */\nexport type ResourceState =\n    /** Bound and usable. */\n    | \"ready\"\n    /** Nothing set for it. Legal for a bucket, fatal for a database. */\n    | \"unconfigured\"\n    /** Set, and set wrongly. The deployment refuses to start. */\n    | \"broken\";\n\nexport interface ResourceStatus {\n    kind: string;\n    key: string;\n    engine: string;\n    transport: string;\n    /** Present when this resource shares another's credentials. */\n    account?: string;\n    /** True for a resource nobody declared, which exists anyway. */\n    implicit: boolean;\n    bindings: ResourceBinding[];\n    state: ResourceState;\n    /** What this means, in the terms the developer will meet it in. */\n    detail: string;\n    /** Set when a local directory stands in for this engine, in development. */\n    standsIn?: string;\n    /** What in the project reaches this resource, from the graph. */\n    usedBy?: readonly string[];\n}\n\nexport type EnvBag = Record<string, string | undefined>;\n\n/** Set, and not set to the empty string — which the resolvers treat as absent. */\nfunction isSet(env: EnvBag, name: string): boolean {\n    const value = env[name];\n    return typeof value === \"string\" && value !== \"\";\n}\n\n/**\n * The bindings one declaration reads, in the order a reader should scan them.\n *\n * A `direct`-transport resource gets none: the browser reaches it with a\n * provider SDK and the backend binds nothing for it, so listing variables would\n * invite someone to set variables that are never read.\n */\nexport function bindingsFor(\n    declaration: ResourceDeclaration,\n    env: EnvBag,\n    accountScopedBases: readonly string[]\n): ResourceBinding[] {\n    if (declaration.transport !== \"server\") return [];\n\n    const suffix = resourceEnvSuffix(declaration.key);\n    const account = typeof declaration.options.account === \"string\"\n        ? resourceEnvSuffix(declaration.options.account)\n        : undefined;\n\n    return envBasesForResource(declaration).map((base) => {\n        const name = `${base}${suffix}`;\n        const binding: ResourceBinding = { name, set: isSet(env, name) };\n\n        // Only the provider-level bindings fall back, and only for a resource\n        // that named an account. The bucket name never does — it is what\n        // distinguishes one source from another.\n        if (account !== undefined && !binding.set && accountScopedBases.includes(base)) {\n            binding.fallback = { name: `${base}${account}`, set: isSet(env, `${base}${account}`) };\n        }\n        return binding;\n    });\n}\n\n/**\n * What the managed development database covers, when a project is on it.\n *\n * `rebase init` leaves `DATABASE_URL` commented out on purpose and the managed\n * PGlite fills the vacuum — the documented first-run state. Judging that state\n * by the environment alone produced `○ (default) postgres · DATABASE_URL not\n * set` and the remedy \"set DATABASE_URL\", at the same moment `rebase db url`\n * was printing a working connection string for the same project and\n * `rebase dev` was serving from it. The status view was reading the one place\n * the answer deliberately is not.\n *\n * Resolved by the caller, because deciding it needs the project's `.env`, its\n * branch pointer and its compose file, and this module stays free of all three.\n */\nexport interface ManagedDatabaseStatus {\n    /**\n     * The daemon's connection string, or null when it is not running.\n     *\n     * Null is not an error: the managed database exists per project and starts\n     * on demand. It only means there is nothing to run the whole-set check\n     * against, and the row says so rather than implying a misconfiguration.\n     */\n    url: string | null;\n}\n\n/**\n * The resolver-side of status, as `@rebasepro/server` registers it per kind.\n *\n * Passed in rather than imported so this module stays testable without a\n * server, and so a kind registered by a plugin is judged by the resolver the\n * plugin brought with it rather than by a switch here.\n */\nexport interface StatusResolvers {\n    /** `resourceResolver(kind)` from `@rebasepro/server`. */\n    resolverFor: (kind: string) => {\n        accountScoped?: readonly string[];\n        resolve: (\n            declaration: ResourceDeclaration,\n            env: EnvBag,\n            context: { production: boolean; defaultBasePath: string }\n        ) => { state: \"ready\" | \"unbound\" | \"blocked\" | \"code\"; detail?: string; standsIn?: string };\n    } | undefined;\n    /** `resolveDataSources` from `@rebasepro/server`, for the whole-set check. */\n    resolveDataSources: (env: EnvBag, definitions: unknown) => unknown;\n    /** Whether the process being judged is production. Status judges for development by default. */\n    production?: boolean;\n    /**\n     * Set when this project runs on the managed development database.\n     *\n     * Absent for a project that named its own connection string, and absent in\n     * production — where an unset `DATABASE_URL` is the failure it has always\n     * been.\n     */\n    managedDatabase?: ManagedDatabaseStatus;\n}\n\n/**\n * The environment plus the managed database's URL, for the whole-set check.\n *\n * A copy: the bindings a reader sees are computed against the real `.env`, so\n * nothing here can make the view claim a variable is set that is not. This is\n * only what `resolveDataSources` is handed, and it is handed it so the check\n * judges the environment the runtime would actually get rather than throwing\n * \"Data source \"(default)\" has no connection string\" about a database that is\n * running and reachable.\n */\nfunction withManagedUrls(env: EnvBag, graph: ResourceGraph, url: string): EnvBag {\n    const filled: EnvBag = { ...env };\n    const keys = [\n        DEFAULT_RESOURCE_KEY,\n        ...graph.resources.filter(r => r.kind === \"database\").map(r => r.key)\n    ];\n    for (const key of keys) {\n        const name = `DATABASE_URL${resourceEnvSuffix(key)}`;\n        if (!isSet(filled, name)) filled[name] = url;\n    }\n\n    return filled;\n}\n\n/**\n * Resolve every declared resource against an environment.\n *\n * Each kind's verdict comes from the resolver `@rebasepro/server` registered\n * for it — the same one boot calls — so this view cannot say \"ready\" about a\n * binding boot would refuse. A kind with no resolver is reported as such\n * rather than skipped: a resource nobody shows is one nobody remembers to\n * configure, and a kind this runtime cannot bind is exactly what boot will\n * refuse by name.\n *\n * `resolveDataSources` is then run once over the whole set, so anything it\n * would refuse across sources (a driver package it cannot resolve for a custom\n * engine) is reported rather than missed by a view that only looked per row.\n */\nexport function computeStatus(\n    graph: ResourceGraph,\n    env: EnvBag,\n    resolvers: StatusResolvers\n): { resources: ResourceStatus[]; blocked?: string } {\n    const resources: ResourceStatus[] = [];\n    const production = resolvers.production ?? false;\n    const managed = resolvers.managedDatabase;\n    /** Database rows the managed database answered for, so `blocked` can skip them. */\n    let managedCovered = 0;\n\n    for (const { declaration, implicit } of withImplicitDefaults(graph)) {\n        const resolver = resolvers.resolverFor(declaration.kind);\n        const bindings = bindingsFor(declaration, env, resolver?.accountScoped ?? []);\n        const base: Omit<ResourceStatus, \"state\" | \"detail\"> = {\n            kind: declaration.kind,\n            key: declaration.key,\n            engine: declaration.engine,\n            transport: declaration.transport,\n            ...(typeof declaration.options.account === \"string\"\n                ? { account: declaration.options.account }\n                : {}),\n            implicit,\n            bindings,\n            ...(declaration.usedBy && declaration.usedBy.length > 0 ? { usedBy: declaration.usedBy } : {})\n        };\n\n        if (!resolver) {\n            resources.push({\n                ...base,\n                state: \"broken\",\n                detail: `this runtime has no resolver for a \"${declaration.kind}\" — boot refuses it by name. ` +\n                    \"Upgrade @rebasepro/server, or remove the declaration.\"\n            });\n            continue;\n        }\n\n        // Answered before the resolver, because the resolver reads the\n        // environment and the whole point of the managed database is that the\n        // environment is deliberately empty. Only for a database nobody bound:\n        // a developer who set `DATABASE_URL__ANALYTICS` to a warehouse of their\n        // own has said which database that is, and the managed one fills a\n        // vacuum, never a choice.\n        if (managed && declaration.kind === \"database\" && bindings.every(b => !b.set && !b.fallback?.set)) {\n            managedCovered += 1;\n            resources.push({\n                ...base,\n                state: \"ready\",\n                detail: managed.url\n                    ? \"the managed development database (PGlite), this project only\"\n                    : \"the managed development database (PGlite), this project only — \"\n                        + \"not running; start it with `rebase dev`\"\n            });\n            continue;\n        }\n\n        const verdict = resolver.resolve(declaration, env, { production, defaultBasePath: \"uploads\" });\n        switch (verdict.state) {\n            case \"ready\":\n                resources.push({\n                    ...base,\n                    state: \"ready\",\n                    ...(verdict.standsIn ? { standsIn: verdict.standsIn } : {}),\n                    detail: verdict.detail ?? \"\"\n                });\n                break;\n            case \"code\":\n                resources.push({ ...base, state: \"ready\", detail: verdict.detail ?? \"needs no environment configuration\" });\n                break;\n            case \"unbound\":\n                resources.push({ ...base, state: \"unconfigured\", detail: verdict.detail ?? \"declared, not configured\" });\n                break;\n            case \"blocked\":\n                resources.push({\n                    ...base,\n                    // A database the environment names nothing for is the\n                    // ordinary first-run state, and reads as unconfigured; a\n                    // binding that is set and set wrongly is broken.\n                    state: implicit || bindings.every(b => !b.set && !b.fallback?.set) ? \"unconfigured\" : \"broken\",\n                    detail: verdict.detail ?? \"boot refuses this binding\"\n                });\n                break;\n        }\n    }\n\n    // Only asked when every row already looks fine. Its failures overlap with\n    // the per-resource ones, and a banner repeating a line printed two rows\n    // above teaches nothing — what it is here for is the failure no row models,\n    // such as a custom engine whose driver package cannot be resolved.\n    let blocked: string | undefined;\n    // Not run when the managed database answered for a row and is not running:\n    // there is no connection string to check the set against, and inventing one\n    // to keep the check formally \"run\" is how a green tick gets printed for\n    // work nobody did. The row says the daemon is down; that is the finding.\n    const managedSetUnknown = managedCovered > 0 && !managed?.url;\n    if (resources.every(r => r.state === \"ready\") && !managedSetUnknown) {\n        try {\n            resolvers.resolveDataSources(\n                // The managed URL for the rows it answered for, so the whole-set\n                // check judges the same environment the runtime would get.\n                managed?.url ? withManagedUrls(env, graph, managed.url) : env,\n                graph.resources.filter(r => r.kind === \"database\").map(resourceToDataSource)\n            );\n        } catch (err) {\n            blocked = err instanceof Error ? err.message : String(err);\n        }\n    }\n\n    return { resources, ...(blocked !== undefined ? { blocked } : {}) };\n}\n","/**\n * `rebase status` — what this project is, and whether it can reach its things.\n *\n * The model a developer has to hold is small and was nowhere visible:\n *\n *   rebase.json           where the code is, and who runs the server\n *   config/resources.ts   what the project needs\n *   the environment       how to reach each of them\n *\n * Everything else — `rebase.resources.json`, the bundle manifest — is a\n * generated copy of the middle one, for readers that cannot run the code. A\n * developer never writes them and should not have to think about them.\n *\n * This command prints the three together, resolved. It exists because the\n * question people actually arrive with — \"why does uploading to `media` answer\n * 501\" — was answerable only by knowing the `<BASE>__<KEY>` suffix rule,\n * deriving the variable name by hand, and checking it against a `.env` they had\n * to find first. Every step of that is mechanical, so it is printed instead.\n */\nimport chalk from \"chalk\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport { parseCommandArgs, wantsHelp } from \"../utils/args\";\nimport { failAsJson, readEnvFile, requireProjectRoot } from \"../utils/project\";\nimport { findBackendApp, loadManifest, ManifestError, resolveBackendPaths } from \"../manifest\";\nimport { deriveOptionsFor, deriveResourceGraph, RESOURCE_GRAPH_FILENAME, readResourceGraphFile, serializeResourceGraph } from \"../resources/derive\";\nimport { computeStatus, type ResourceStatus } from \"../resources/status\";\nimport { findRunningDaemon, managedUrl } from \"../dev-db/daemon\";\nimport { resolveActiveBranch, resolveComposeUrl } from \"../dev-db/prepare\";\nimport { resolveDevDatabase } from \"../dev-db/resolve\";\nimport type { RebaseBackendAppConfig } from \"@rebasepro/types\";\n\nfunction usage(): void {\n    console.log(`\n${chalk.bold(\"rebase status\")} — what this project declares, and whether it is configured\n\n${chalk.bold(\"Usage\")}\n  rebase status                Show every resource and the variables it reads\n  rebase status --json         The same, as JSON\n\n${chalk.bold(\"Reads\")}\n  rebase.json                  which apps exist, and who owns the server process\n  <config>/resources.ts        the databases, buckets, topics and queues declared\n  backend/crons, backend/functions   the crons and functions, by filename\n  .env                         whether each one's variables are set\n`);\n}\n\nconst MARK = {\n    ready: chalk.green(\"✓\"),\n    unconfigured: chalk.yellow(\"○\"),\n    broken: chalk.red(\"✗\")\n} as const;\n\nfunction printResource(status: ResourceStatus): void {\n    const name = status.key === \"(default)\" ? chalk.bold(\"(default)\") : chalk.bold(status.key);\n    const tags = [chalk.gray(status.engine)];\n    if (status.transport !== \"server\") tags.push(chalk.yellow(status.transport));\n    if (status.account) tags.push(chalk.gray(`account:${status.account}`));\n    if (status.implicit) tags.push(chalk.gray(\"implicit\"));\n    // A stand-in is not a binding. It is shown in yellow beside a green tick:\n    // uploads work here, and the same declaration answers 501 in production\n    // until the variable is set.\n    if (status.standsIn) tags.push(chalk.yellow(`local stand-in for ${status.standsIn}`));\n\n    console.log(`  ${MARK[status.state]} ${name}  ${tags.join(\" · \")}`);\n    if (status.usedBy && status.usedBy.length > 0) {\n        console.log(`      ${chalk.gray(\"used by\")} ${chalk.gray(status.usedBy.join(\", \"))}`);\n    }\n\n    let hiddenOptional = 0;\n    for (const binding of status.bindings) {\n        if (binding.set) {\n            console.log(`      ${chalk.green(\"✓\")} ${chalk.gray(binding.name)}`);\n        } else if (binding.fallback?.set) {\n            // Not a gap: the account form is the variable this bucket is\n            // actually reading, and showing only the unset per-key name would\n            // send someone to set the one they were deliberately avoiding.\n            console.log(`      ${chalk.green(\"✓\")} ${chalk.gray(binding.fallback.name)} ${chalk.gray(`(shared, for ${binding.name})`)}`);\n        } else if (status.state === \"ready\") {\n            // It resolved without this one, so this one is optional — which is\n            // the resolver's answer, not a second table of required names kept\n            // here. Listing seven unset optionals under a working database is\n            // how a status view teaches people to skim past the line that\n            // matters.\n            hiddenOptional += 1;\n        } else {\n            const also = binding.fallback ? chalk.gray(` or ${binding.fallback.name}`) : \"\";\n            console.log(`      ${chalk.gray(\"·\")} ${chalk.gray(binding.name)}${also} ${chalk.gray(\"not set\")}`);\n        }\n    }\n    if (hiddenOptional > 0) {\n        console.log(chalk.gray(`      ${hiddenOptional} optional variable${hiddenOptional === 1 ? \"\" : \"s\"} not set`));\n    }\n\n    if (status.detail) {\n        const colour = status.state === \"broken\" ? chalk.red : status.state === \"unconfigured\" ? chalk.yellow : chalk.gray;\n        console.log(`      ${colour(`└ ${status.detail}`)}`);\n    }\n}\n\nexport async function statusCommand(rawArgs: string[]): Promise<void> {\n    if (wantsHelp(rawArgs)) return usage();\n\n    const { flags } = parseCommandArgs({\n        spec: { \"--json\": Boolean },\n        rawArgs,\n        commandWords: 1,\n        command: \"status\",\n        maxPositionals: 0\n    });\n\n    const projectRoot = requireProjectRoot();\n\n    // Every exit below has a `--json` arm, because `--json` means stdout holds\n    // one JSON object on *every* exit of the command. It used to mean that for\n    // the one failure `requireProjectRoot` owns and nothing else, so a caller\n    // parsing stdout got an envelope outside a project and an empty stream\n    // inside a broken one — the case it actually has to handle.\n    const asJson = Boolean(flags[\"--json\"]);\n\n    let backend: { name: string; app: RebaseBackendAppConfig };\n    try {\n        const loaded = loadManifest(projectRoot);\n        const found = findBackendApp(loaded.manifest);\n        if (!found) {\n            if (asJson) {\n                failAsJson(\n                    \"This project declares no backend app, so it declares no resources.\",\n                    \"no_backend_app\",\n                    \"Add a backend app to rebase.json, or run `rebase apps init`.\"\n                );\n            }\n            console.error(chalk.red(\"This project declares no backend app, so it declares no resources.\"));\n            process.exitCode = 1;\n            return;\n        }\n        backend = found;\n    } catch (err) {\n        if (err instanceof ManifestError) {\n            if (asJson) {\n                failAsJson(err.message, \"manifest_invalid\", \"Fix rebase.json, then run this again.\",\n                    err.issues.map(issue => ({ path: issue.path, message: issue.message })));\n            }\n            console.error(chalk.red(err.message));\n            for (const issue of err.issues) console.error(`  ${chalk.gray(issue.path)} ${issue.message}`);\n            process.exitCode = 1;\n            return;\n        }\n        throw err;\n    }\n\n    const { name: backendName, app: backendApp } = backend;\n    const paths = resolveBackendPaths(backendApp, projectRoot);\n\n    const { graph, issues } = await deriveResourceGraph(deriveOptionsFor(projectRoot, backendApp));\n    if (issues.length > 0) {\n        if (asJson) {\n            failAsJson(\n                `${issues.length} problem(s) in the declared resources.`,\n                \"resource_declaration_invalid\",\n                \"Fix the declarations the issues name, then run this again.\",\n                issues.map(issue => ({ path: issue.path, message: issue.message }))\n            );\n        }\n        console.error(chalk.red(`\\n✗ ${issues.length} problem(s) in the declared resources:\\n`));\n        for (const issue of issues) console.error(`  ${chalk.bold(issue.path)}  ${issue.message}`);\n        console.error(\"\");\n        process.exitCode = 1;\n        return;\n    }\n\n    // The project's own `.env`, not this process's environment: `rebase status`\n    // is asking what a deployment of THIS repository would do, and the shell a\n    // developer happens to be standing in is not that.\n    const env = readEnvFile(projectRoot);\n\n    // Which database this project is on, decided by the same ordered rule\n    // `rebase dev` and `rebase db url` use — and read from the same `.env`, not\n    // from this shell, for the reason above.\n    //\n    // Nothing is started. `status` is a question, and a question that boots a\n    // 180 MB Postgres to answer itself is a different command. So a managed\n    // database that is not running is reported as exactly that, rather than as\n    // a project with no database — which is what this view used to say while\n    // `rebase db url` printed a working connection string for it.\n    const production = env.NODE_ENV === \"production\";\n    const database = resolveDevDatabase({\n        env: {},\n        envFile: env,\n        branch: resolveActiveBranch(projectRoot, env),\n        composeUrl: resolveComposeUrl(projectRoot, env)\n    });\n    const daemon = database.kind === \"managed\" ? await findRunningDaemon(projectRoot) : null;\n    const managedDatabase = !production && database.kind === \"managed\"\n        ? { url: daemon ? managedUrl(daemon.port) : null }\n        : undefined;\n\n    const server = await import(\"@rebasepro/server\");\n    const { resources, blocked } = computeStatus(graph, env, {\n        resolverFor: server.resourceResolver as never,\n        resolveDataSources: server.resolveDataSources as never,\n        // Judged as production when the .env says so; a stand-in local\n        // directory for an unbound bucket is only ever offered to development.\n        production,\n        ...(managedDatabase ? { managedDatabase } : {})\n    });\n\n    if (asJson) {\n        console.log(JSON.stringify({ backend: backendName, runtime: backendApp.runtime, resources, blocked }, null, 2));\n        return;\n    }\n\n    const ownership = backendApp.runtime === \"managed\"\n        ? \"Rebase's runtime boots your bundle\"\n        : \"this project builds its own image and entrypoint\";\n\n    console.log(\"\");\n    console.log(`  ${chalk.bold(backendName)}  ${chalk.gray(\"·\")}  ${chalk.cyan(backendApp.runtime)}  ${chalk.gray(ownership)}`);\n    // Named whether or not it exists, and said plainly when it does not. A\n    // project with no `resources.ts` is legal — it has one default database and\n    // one default bucket — but \"declared in <a file you do not have>\" reads as\n    // a broken install rather than as the default it is.\n    const resourcesFile = path.join(paths.config, \"resources.ts\");\n    const declaresAnything = fs.existsSync(path.join(projectRoot, resourcesFile));\n    console.log(`  ${chalk.gray(\"declared in\")}  ${chalk.gray(resourcesFile)}${\n        declaresAnything ? \"\" : chalk.gray(\"  (none — the defaults below are implicit)\")}`);\n    console.log(`  ${chalk.gray(\"configured by\")}  ${chalk.gray(\".env\")}`);\n\n    const kinds = [...new Set(resources.map(r => r.kind))];\n    for (const kind of kinds) {\n        console.log(\"\");\n        console.log(`  ${chalk.bold.underline(`${kind}s`)}`);\n        for (const status of resources.filter(r => r.kind === kind)) printResource(status);\n    }\n\n    if (blocked) {\n        console.log(\"\");\n        console.log(`  ${chalk.red(\"✗\")} ${chalk.red(blocked)}`);\n    }\n\n    // Only worth a line when it is wrong. A generated file that matches its\n    // declarations is not news, and a status view that reports its own\n    // bookkeeping as an item trains people to skim past the items that matter.\n    const committed = readResourceGraphFile(projectRoot);\n    const expected = serializeResourceGraph(graph);\n    if (committed !== expected && !(committed === null && graph.resources.length === 0)) {\n        console.log(\"\");\n        console.log(`  ${chalk.yellow(\"○\")} ${RESOURCE_GRAPH_FILENAME} is ${committed === null ? \"missing\" : \"stale\"} — ${chalk.blue(\"rebase resources --write\")}`);\n        console.log(chalk.gray(\"      a host reads it to decide what to provision before it runs anything\"));\n    }\n\n    console.log(\"\");\n}\n"],"mappings":"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"}