@rebasepro/cli 0.10.1-canary.ff9ccd6 → 0.10.1-canary.g4db1bb1

package/dist/bundle.d.ts

@@ -80,6 +80,27 @@ export declare function normalizeEsmSpecifiers(outDir: string): {
     rewritten: number;
     unresolved: string[];
 };
+/**
+ * A hand-written server entrypoint that a bundle does not use.
+ *
+ * `rebase dev` runs `backend/src/index.ts` whenever a project has one, so for
+ * the whole of local development that file *is* the server and every route
+ * written in it works. A bundle has no entrypoint of its own: the runtime boots
+ * the bundle and mounts what the manifest points at — the config package,
+ * functions, crons and the schema. The file is not compiled, not shipped, and
+ * never imported.
+ *
+ * Nothing said so. A project with custom routes in its entrypoint built clean,
+ * deployed green, and answered 404 on every one of them, with the file still
+ * sitting in the repository looking exactly like the server.
+ *
+ * A project that means to keep its own entrypoint declares the app as
+ * `"type": "custom"`, which builds the repository's Dockerfile instead — which
+ * is what {@link synthesizeManifest} already infers for a manifest-less repo
+ * carrying one. The warning names that route rather than implying the file is
+ * a mistake.
+ */
+export declare function findUnusedServerEntry(projectRoot: string, functionsDir: string): string | undefined;
 /**
  * Compile and assemble a bundle.
  */

package/dist/commands/cloud/deploy.d.ts

@@ -1,2 +1,50 @@
+/** A project row, reduced to what says how it deploys (camel or snake columns). */
+export interface DeployProjectRow {
+    runtimeMode?: string;
+    runtime_mode?: string;
+    gitRepoUrl?: string;
+    git_repo_url?: string;
+    gitBranch?: string;
+    git_branch?: string;
+}
+/** A deployment row, reduced to what says what it was built from. */
+export interface DeploySourceRow {
+    id?: string | number;
+    status?: string;
+    createdAt?: string | Date;
+    created_at?: string | Date;
+    sourceRef?: string;
+    source_ref?: string;
+    bundleId?: string;
+    bundle_id?: string;
+}
+export interface BareDeployPlan {
+    /**
+     * Whether the project runs the platform runtime — in which case any source
+     * build here ejects it back onto a container image.
+     */
+    managed: boolean;
+    /**
+     * `git` — the control plane will clone the configured repository.
+     * `snapshot` — it will rebuild the newest uploaded source archive.
+     * `none` — it holds neither, and will refuse.
+     */
+    source: "git" | "snapshot" | "none";
+    /** Lines describing the build, printed before it is triggered. */
+    lines: string[];
+}
+/** Rough age of a timestamp, for "…uploaded 6d ago". Undefined if unreadable. */
+export declare function timeAgo(value: string | Date | undefined, now: Date): string | undefined;
+/**
+ * Whether this project runs on the managed runtime.
+ *
+ * `runtimeMode` on the project row is the authority — the control plane writes
+ * it. The bundle-id fallback covers a control plane that does not return the
+ * field: a successful deploy that served a bundle only happens on the managed
+ * path.
+ */
+export declare function isManagedProject(project: DeployProjectRow | undefined, latest: DeploySourceRow | undefined): boolean;
+/** What a `deploy` with nothing attached will build, in the words to print. */
+export declare function planBareDeploy(project: DeployProjectRow | undefined, latest: DeploySourceRow | undefined, now: Date): BareDeployPlan;
 export declare function deployCommand(rawArgs: string[], projectRef: string): Promise<void>;
 export declare function logsCommand(rawArgs: string[], projectRef: string): Promise<void>;

package/dist/commands/generate_sdk.d.ts

@@ -23,6 +23,19 @@ interface GenerateSDKArgs {
     token?: string;
     help?: boolean;
 }
+/**
+ * The base URL to show in the printed usage example.
+ *
+ * `rebase dev` binds a port derived from the project path, not 3001, and writes
+ * the one it actually got to `.rebase/state.json`. Printing a hardcoded
+ * `localhost:3001` sent people to a port nothing was listening on — or, with
+ * several projects on one machine, to a different project's backend. Prefer the
+ * port this project last ran on; fall back to the literal only when the project
+ * has never been started.
+ */
+export declare function resolveExampleBaseUrl(cwd: string): string;
+/** Whether a slug can be written as `rebase.data.<slug>` rather than a lookup. */
+export declare function isIdentifierLike(slug: string): boolean;
 /**
  * Main entry point for the generate-sdk command.
  */

package/dist/index.es.js

@@ -1695,6 +1695,29 @@ function mayUseAmbientKey(target, cwd) {
 		return false;
 	}
 }
+/**
+* The base URL to show in the printed usage example.
+*
+* `rebase dev` binds a port derived from the project path, not 3001, and writes
+* the one it actually got to `.rebase/state.json`. Printing a hardcoded
+* `localhost:3001` sent people to a port nothing was listening on — or, with
+* several projects on one machine, to a different project's backend. Prefer the
+* port this project last ran on; fall back to the literal only when the project
+* has never been started.
+*/
+function resolveExampleBaseUrl(cwd) {
+	const projectRoot = findProjectRoot(cwd) ?? cwd;
+	try {
+		const state = JSON.parse(fs.readFileSync(path.join(projectRoot, ".rebase", "state.json"), "utf-8"));
+		if (typeof state.baseUrl === "string" && state.baseUrl) return state.baseUrl;
+		if (typeof state.port === "number") return `http://localhost:${state.port}`;
+	} catch {}
+	return "http://localhost:3001";
+}
+/** Whether a slug can be written as `rebase.data.<slug>` rather than a lookup. */
+function isIdentifierLike(slug) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(slug);
+}
 /** Resolve `--from` into a base URL, following the link file when asked. */
 function resolveSchemaSource(from, cwd) {
 	if (from !== "link") {
@@ -1790,16 +1813,20 @@ export const GENERATED_AT = ${JSON.stringify((/* @__PURE__ */ new Date()).toISOS
 	console.log("");
 	console.log(chalk.green.bold("  ✓ SDK generated successfully!"));
 	console.log("");
+	const typesImport = `./${path.relative(cwd, path.join(resolvedOutput, "database.types"))}`;
+	const exampleSlug = collections[0]?.slug || "my_collection";
 	console.log(chalk.gray("  Usage:"));
 	console.log(chalk.gray("    import { createRebaseClient } from '@rebasepro/client';"));
-	console.log(chalk.gray(`    import type { Database } from './${path.relative(cwd, path.join(resolvedOutput, "database.types"))}';`));
+	console.log(chalk.gray(`    import { collectionsDictionary, type Database } from '${typesImport}';`));
 	console.log("");
 	console.log(chalk.gray("    const rebase = createRebaseClient<Database>({"));
-	console.log(chalk.gray("        baseUrl: 'http://localhost:3001',"));
+	console.log(chalk.gray(`        baseUrl: '${resolveExampleBaseUrl(cwd)}',`));
+	console.log(chalk.gray("        collections: collectionsDictionary,"));
 	console.log(chalk.gray("        // token: 'your-jwt-token',"));
 	console.log(chalk.gray("    });"));
 	console.log("");
-	console.log(chalk.gray(`    const { data } = await rebase.collection('${collections[0]?.slug || "my_collection"}').find();`));
+	console.log(chalk.gray(`    const { data } = await rebase.data.collection('${exampleSlug}').find();`));
+	if (isIdentifierLike(exampleSlug)) console.log(chalk.gray(`    // …or in property style: rebase.data.${exampleSlug}.find()`));
 	console.log("");
 }
 //#endregion
@@ -3288,6 +3315,30 @@ async function regenerateSchema(projectRoot, configDir, options) {
 	}
 }
 /**
+* A hand-written server entrypoint that a bundle does not use.
+*
+* `rebase dev` runs `backend/src/index.ts` whenever a project has one, so for
+* the whole of local development that file *is* the server and every route
+* written in it works. A bundle has no entrypoint of its own: the runtime boots
+* the bundle and mounts what the manifest points at — the config package,
+* functions, crons and the schema. The file is not compiled, not shipped, and
+* never imported.
+*
+* Nothing said so. A project with custom routes in its entrypoint built clean,
+* deployed green, and answered 404 on every one of them, with the file still
+* sitting in the repository looking exactly like the server.
+*
+* A project that means to keep its own entrypoint declares the app as
+* `"type": "custom"`, which builds the repository's Dockerfile instead — which
+* is what {@link synthesizeManifest} already infers for a manifest-less repo
+* carrying one. The warning names that route rather than implying the file is
+* a mistake.
+*/
+function findUnusedServerEntry(projectRoot, functionsDir) {
+	const found = [path.join("backend", "src", "index.ts"), path.join(path.dirname(functionsDir), "src", "index.ts")].find((candidate) => fs.existsSync(path.join(projectRoot, candidate)));
+	return found ? found.split(path.sep).join("/") : void 0;
+}
+/**
 * Compile and assemble a bundle.
 */
 async function buildBundle(options) {
@@ -3304,6 +3355,19 @@ async function buildBundle(options) {
 	if (fs.existsSync(path.join(projectRoot, paths.schema))) includes.push(paths.schema);
 	if (includes.length === 0) throw new Error(`Nothing to build for app "${appName}". Expected a config directory at "${paths.config}" or functions at "${paths.functions}".`);
 	if (paths.mode === "cms" && options.skipSchema !== true) await regenerateSchema(projectRoot, paths.config, options);
+	const unusedEntry = findUnusedServerEntry(projectRoot, paths.functions);
+	if (unusedEntry) {
+		const parts = [
+			...paths.mode === "cms" ? [`${paths.config}/`] : [],
+			`${paths.functions}/`,
+			"the schema"
+		];
+		const compiled = `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
+		console.log(chalk.yellow(`  ⚠ ${unusedEntry} is not the bundle's entry point — it is not compiled or shipped.`));
+		console.log(chalk.dim(`      The runtime boots the bundle itself and mounts ${compiled}.`));
+		console.log(chalk.dim(`      Routes defined there will not exist once deployed: move them to ${paths.functions}/,`));
+		console.log(chalk.dim(`      or declare this app as "type": "custom" in rebase.json to keep your own entrypoint.`));
+	}
 	log(options, chalk.dim(`  compiling ${includes.length} source group(s) → ${path.relative(projectRoot, outDir)}/`));
 	cleanOutDir(projectRoot, outDir);
 	const tsconfigPath = await writeBundleTsconfig(projectRoot, outDir, includes, options.skipTypeCheck === true);
@@ -5311,6 +5375,12 @@ async function uploadBundle(url, token, projectId, tarPath) {
 * `deploy` triggers the control-plane `deploy` function, then tails the build
 * logs from the deployment record until it succeeds or fails. `logs` shows the
 * latest build log, or runtime logs with `--runtime`.
+*
+* There are three deploys behind the one verb, and which one runs depends on the
+* flags: `--bundle` builds and uploads a managed bundle, `--source .` uploads
+* this directory as a build context, and the bare form uploads nothing and asks
+* the control plane to rebuild what it already holds. That last one is the
+* dangerous one — see `planBareDeploy`.
 */
 var POLL_INTERVAL_MS = 1500;
 var POLL_TIMEOUT_MS = 900 * 1e3;
@@ -5433,6 +5503,7 @@ async function deployBundle(opts) {
 			appName: backend.name,
 			app: backend.app,
 			runtimeRange: loaded.manifest.runtime,
+			skipTypeCheck: opts.skipTypeCheck,
 			log: (m) => console.log(chalk.gray(m))
 		})).outDir;
 		try {
@@ -5496,6 +5567,89 @@ async function deployBundle(opts) {
 		reportError(e, "Managed deploy failed to start");
 	}
 }
+function pick(row, ...keys) {
+	for (const key of keys) {
+		const raw = row?.[key];
+		if (typeof raw === "string" && raw.trim() !== "") return raw.trim();
+	}
+}
+/** Rough age of a timestamp, for "…uploaded 6d ago". Undefined if unreadable. */
+function timeAgo(value, now) {
+	if (value === void 0) return void 0;
+	const then = value instanceof Date ? value.getTime() : new Date(value).getTime();
+	if (Number.isNaN(then)) return void 0;
+	const ms = now.getTime() - then;
+	if (ms < 0) return void 0;
+	const minutes = Math.floor(ms / 6e4);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+/**
+* Whether this project runs on the managed runtime.
+*
+* `runtimeMode` on the project row is the authority — the control plane writes
+* it. The bundle-id fallback covers a control plane that does not return the
+* field: a successful deploy that served a bundle only happens on the managed
+* path.
+*/
+function isManagedProject(project, latest) {
+	if (pick(project, "runtimeMode", "runtime_mode") === "managed") return true;
+	return latest?.status === "success" && pick(latest, "bundleId", "bundle_id") !== void 0;
+}
+/** What a `deploy` with nothing attached will build, in the words to print. */
+function planBareDeploy(project, latest, now) {
+	const projectRow = project;
+	const deploymentRow = latest;
+	const managed = isManagedProject(project, latest);
+	const repo = pick(projectRow, "gitRepoUrl", "git_repo_url");
+	if (repo) {
+		const branch = pick(projectRow, "gitBranch", "git_branch");
+		return {
+			managed,
+			source: "git",
+			lines: [`Building from git: ${repo}${branch ? ` (${branch})` : ""}.`]
+		};
+	}
+	if (pick(deploymentRow, "sourceRef", "source_ref")) {
+		const age = timeAgo(latest?.createdAt ?? latest?.created_at, now);
+		return {
+			managed,
+			source: "snapshot",
+			lines: [`Rebuilding the stored source archive${latest?.id !== void 0 ? ` from deployment ${latest.id}` : ""}${age ? `, uploaded ${age}` : ""}.`, "This directory is NOT uploaded — pass `--source .` to build what is on disk."]
+		};
+	}
+	return {
+		managed,
+		source: "none",
+		lines: ["This project has no git repository configured and no stored source archive to rebuild.", "Upload this directory with `--source .`, or set a repository URL in the project settings."]
+	};
+}
+/** The one sentence that says a source build undoes `runtimeMode: managed`. */
+function ejectWarning(projectRef) {
+	return `⚠ ${projectRef} runs on the managed runtime — a source build ejects it to a custom container.`;
+}
+/**
+* Read the two rows the preflight needs.
+*
+* Best effort by construction: a preflight that cannot read is a preflight that
+* says nothing, never a deploy that fails. The managed refusal rides on the same
+* read, so an unreadable project falls through to the old behaviour rather than
+* blocking a deploy on a lookup.
+*/
+async function readDeployContext(client, projectId) {
+	try {
+		const [project, latest] = await Promise.all([client.data.collection("projects").findById(projectId), latestDeployment(client, projectId)]);
+		return {
+			project,
+			latest
+		};
+	} catch {
+		return {};
+	}
+}
 async function deployCommand(rawArgs, projectRef) {
 	const args = arg({
 		"--no-follow": Boolean,
@@ -5503,6 +5657,8 @@ async function deployCommand(rawArgs, projectRef) {
 		"--message": String,
 		"--bundle": Boolean,
 		"--bundle-dir": String,
+		"--skip-type-check": Boolean,
+		"--force": Boolean,
 		"-m": "--message"
 	}, {
 		argv: rawArgs.slice(2),
@@ -5518,10 +5674,25 @@ async function deployCommand(rawArgs, projectRef) {
 			projectId,
 			projectRef,
 			bundleDir: args["--bundle-dir"],
-			message: args["--message"]
+			message: args["--message"],
+			skipTypeCheck: args["--skip-type-check"] === true
 		});
 		return;
 	}
+	const { project, latest } = await readDeployContext(client, projectId);
+	const plan = planBareDeploy(project, latest, /* @__PURE__ */ new Date());
+	if (!args["--source"]) {
+		if (plan.managed && args["--force"] !== true) fail(`${projectRef} runs on the managed runtime, and a plain \`rebase cloud deploy\` builds a container image instead — ejecting it from managed, from source the control plane already holds rather than this directory.`, "Redeploy it with `rebase cloud deploy --bundle`. To eject on purpose, pass `--source .` to build this directory, or `--force` to build what the control plane holds.", "managed_project");
+		if (!isJsonMode()) {
+			console.log("");
+			if (plan.managed) console.log(chalk.yellow(`  ${ejectWarning(projectRef)}`));
+			for (const line of plan.lines) console.log(chalk.gray(`  ${line}`));
+		}
+	} else if (plan.managed && !isJsonMode()) {
+		console.log("");
+		console.log(chalk.yellow(`  ${ejectWarning(projectRef)}`));
+		console.log(chalk.gray("    Use `rebase cloud deploy --bundle` to stay on managed."));
+	}
 	let source;
 	if (args["--source"]) {
 		const tarPath = await createSourceTarball(args["--source"]);
@@ -8733,7 +8904,7 @@ ${chalk.green.bold("Projects")}
   ${chalk.blue.bold("projects delete")} ${chalk.gray("[id]")}    Delete a project
 
 ${chalk.green.bold("Deploy & observe")}
-  ${chalk.blue.bold("deploy")} ${chalk.gray("[--source .] [-m msg]")}  Deploy the linked project + stream build logs
+  ${chalk.blue.bold("deploy")} ${chalk.gray("[--bundle|--source .]")}   Deploy the linked project + stream build logs
   ${chalk.blue.bold("logs")} ${chalk.gray("[--runtime] [-f]")}   Show build (or runtime) logs
   ${chalk.blue.bold("deployments list")} ${chalk.gray("[--limit N|--all]")}  Deployment history ${chalk.gray("(status, duration, trigger)")}
   ${chalk.blue.bold("rollback")} ${chalk.gray("[id] [-y]")}       Roll back to a successful deploy
@@ -9139,6 +9310,6 @@ ${chalk.gray("Documentation: https://rebase.pro/docs")}
 `);
 }
 //#endregion
-export { CURRENT_RUNTIME_RANGE, DEFAULT_BUNDLE_DIR, DEFAULT_CONFIG_DIR, DEFAULT_CRONS_DIR, DEFAULT_FUNCTIONS_DIR, DEFAULT_SCHEMA_FILE, MANIFEST_FILENAME, ManifestError, appsCommand, assessManagedCompatibility, authCommand, buildBundle, buildCommand, buildInitQuestions, buildStaticBundle, buildableApps, cloudCommand, collectDeclaredDependencies, configureEnvFile, createRebaseApp, dbCommand, detectNativeDependencies, detectPackageManager, detectStorageAuthorize, devCommand, doctorCommand, entry, findBackendApp, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, foldStaticIntoBundle, formatCdTarget, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isPnpmAvailable, loadManifest, manifestExists, manifestPath, normalizeEsmSpecifiers, pnpmAvailabilityFromProbe, printInitHelp, requireBackendDir, requireProjectRoot, resetPnpmAvailabilityCache, resolveBackendPaths, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, synthesizeManifest, validateManifest, validateProjectName, validateTsxInstallation, writeManifest };
+export { CURRENT_RUNTIME_RANGE, DEFAULT_BUNDLE_DIR, DEFAULT_CONFIG_DIR, DEFAULT_CRONS_DIR, DEFAULT_FUNCTIONS_DIR, DEFAULT_SCHEMA_FILE, MANIFEST_FILENAME, ManifestError, appsCommand, assessManagedCompatibility, authCommand, buildBundle, buildCommand, buildInitQuestions, buildStaticBundle, buildableApps, cloudCommand, collectDeclaredDependencies, configureEnvFile, createRebaseApp, dbCommand, detectNativeDependencies, detectPackageManager, detectStorageAuthorize, devCommand, doctorCommand, entry, findBackendApp, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, findUnusedServerEntry, foldStaticIntoBundle, formatCdTarget, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isIdentifierLike, isPnpmAvailable, loadManifest, manifestExists, manifestPath, normalizeEsmSpecifiers, pnpmAvailabilityFromProbe, printInitHelp, requireBackendDir, requireProjectRoot, resetPnpmAvailabilityCache, resolveBackendPaths, resolveExampleBaseUrl, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, synthesizeManifest, validateManifest, validateProjectName, validateTsxInstallation, writeManifest };
 
 //# sourceMappingURL=index.es.js.map