@rebasepro/cli 0.25.0 → 0.26.0

package/dist/utils/dev-preflight.d.ts

@@ -101,13 +101,33 @@ export declare function probeTcp(host: string, port: number, timeoutMs?: number)
  * forward. {@link waitForQueryable} is the check that a query will work.
  */
 export declare function waitForPort(host: string, port: number, timeoutMs?: number, intervalMs?: number): Promise<boolean>;
-/** Whether a database answered a query, and if not, the last reason it gave. */
+/**
+ * Whether a database answered a query, and if not, the last reason it gave —
+ * and, for a database closed to new connections, its name.
+ */
 export type QueryReadiness = {
     ready: true;
 } | {
     ready: false;
     error: string;
+    closedDatabase?: string;
 };
+/** What opening a closed database again did, and what to say about it. */
+export interface ClosedDatabaseHeal {
+    /** It accepts connections again. */
+    reopened: boolean;
+    /** The driver's own lines about it (`reopenedDatabasesNotice`). */
+    notice: string[];
+}
+/**
+ * The database a connection was refused by because it is closed to new
+ * connections (`ALLOW_CONNECTIONS false`), or null.
+ *
+ * The driver's `closedDatabaseName`, for the error a bare `pg` connect gives:
+ * the sentence is matched, not SQLSTATE 55000, which also covers failures that
+ * have nothing to do with connecting.
+ */
+export declare function closedDatabaseName(error: unknown): string | null;
 /**
  * Poll until `SELECT 1` succeeds on this connection string, or the bound runs out.
  *
@@ -118,10 +138,21 @@ export type QueryReadiness = {
  * three. Every error is retried: a reset, "the database system is starting up"
  * and a refused connection all mean "not yet", and the bound is what turns
  * "not yet" into an answer.
+ *
+ * Except one, which is not "not yet": a database closed to new connections
+ * (`closedDatabaseName`), which is what a `rebase db branch create --force`
+ * killed mid-copy leaves its source as. Waiting cannot open it, and it was
+ * waited on for the whole minute. It is opened again with the driver's
+ * `reopenClosedDatabases`, once, and then either answers or the wait ends at
+ * once, naming it.
  */
 export declare function waitForQueryable(databaseUrl: string, options?: {
     timeoutMs?: number;
     intervalMs?: number;
+    /** Opens a closed database again. The driver's `reopenClosedDatabases` by default; injected for tests. */
+    reopenClosed?: (databaseUrl: string) => Promise<ClosedDatabaseHeal>;
+    /** Where the driver's lines about a database it opened go. */
+    onNotice?: (line: string) => void;
 }): Promise<QueryReadiness>;
 /**
  * What a failed schema push printed, as lines to show.
@@ -204,6 +235,8 @@ export interface EnsureDevDatabaseOptions {
     startDatabase?: (projectRoot: string) => Promise<void>;
     /** How long a started database has to answer `SELECT 1`. Defaults to 60s. */
     readyTimeoutMs?: number;
+    /** Opens a database closed to new connections again; see `waitForQueryable`. Injected for tests. */
+    reopenClosed?: (databaseUrl: string) => Promise<ClosedDatabaseHeal>;
     /**
      * Who answers on the compose port. Asks Docker by default; injected for the
      * same reason `startDatabase` is.

package/dist/utils/dev-server.d.ts

@@ -1,3 +1,14 @@
+/**
+ * The address `rebase dev` is starting its backend on, handed to the
+ * `generate-sdk` child it runs.
+ *
+ * Dev regenerates the SDK at boot, beside the database start and before the
+ * backend binds — so before the backend writes `.rebase/state.json`, which is
+ * where `generate-sdk` otherwise reads the address for the README's example.
+ * Dev knows the port it hands the backend, and the child's environment is the
+ * only channel between them.
+ */
+export declare const DEV_BACKEND_URL_ENV = "REBASE_DEV_BACKEND_URL";
 /**
  * The port `rebase dev` derives from the project root path.
  * Range: 3001–3999 (avoids privileged ports and common services).

package/dist/utils/path-flags.d.ts

@@ -1,7 +1,7 @@
 /** The rule, as every help page and error states it. */
 export declare const COLLECTIONS_PATH_RULE = "relative paths are resolved from where you run the command";
 /** The `--collections` line of a help page. */
-export declare const COLLECTIONS_FLAG_HELP = "Collections directory (default: config/collections); relative paths are resolved from where you run the command";
+export declare const COLLECTIONS_FLAG_HELP = "Collections directory (default: config/collections, or <config>/collections when rebase.json moves the backend's config); relative paths are resolved from where you run the command";
 /**
  * What a refusal over a missing `--collections` path spared, by what the command
  * would have done with it. Only a schema writer drops tables; a console or a
@@ -11,6 +11,7 @@ declare const MISSING_COLLECTIONS_CONSEQUENCE: {
     readonly schema: readonly ["Nothing was generated and nothing was applied — a schema generated from a", "directory that is not there is an empty one, and applying it would drop", "every table it does not describe."];
     readonly console: readonly ["Nothing was started — a console over a directory that is not there would", "load none of this project's collections."];
     readonly doctor: readonly ["Nothing was checked — a directory that is not there has no collections, so", "every collection check would pass over it."];
+    readonly verify: readonly ["Nothing was verified — a directory that is not there has no collections, so", "every step would pass over it and report 0 errors."];
 };
 /** What a command does with its `--collections` path. */
 export type CollectionsPathUse = keyof typeof MISSING_COLLECTIONS_CONSEQUENCE;

package/dist/utils/project.d.ts

@@ -158,7 +158,11 @@ export interface JsonFailureIssue {
  * failure mode of not doing it is an unparseable stream.
  */
 export declare function failAsJson(message: string, code: string, hint?: string, issues?: JsonFailureIssue[]): never;
-/** Did the command line ask for machine-readable output? */
+/**
+ * Did the command line ask for machine-readable output? Read as the parser
+ * reads a switch: `--json`, `--json=true` and `--json=1` ask for it,
+ * `--json=false` and `--json=0` do not.
+ */
 export declare function wantsJsonOutput(argv?: readonly string[]): boolean;
 /**
  * Require the project root or exit with a helpful error.

package/dist/utils/tool-stdio.d.ts

@@ -4,7 +4,7 @@
  *
  * Inherited, so its output streams as it happens. With `quietStdout` its stdout
  * goes to stderr instead, for a command whose own stdout carries a result:
- * `rebase cloud deploy` in JSON mode — every piped run — owes stdout exactly one
+ * `rebase cloud deploy --json` owes stdout exactly one
  * JSON value, and a `vite v6 building…` line in front of it is a result no
  * parser can read. The tool's output still reaches the person watching.
  */

package/dist/utils/unknown-command.d.ts

@@ -17,6 +17,10 @@ export declare function suggestCommand(typed: string, known: readonly string[]):
  * `family` is empty for the top level: `rebase --help`, not `rebase  --help`.
  * `families` are the command families below this level, by name, whose
  * commands a word may be one of.
+ *
+ * The typed word is repeated with any connection-string password masked: a URL
+ * pasted where the command goes (`rebase db "postgres://u:pw@h/db"`) is a
+ * word like any other here, and this line lands in terminals and CI logs.
  */
 export declare function unknownCommandMessage(typed: string | undefined, known: readonly string[], family?: string, families?: Readonly<Record<string, readonly string[]>>): string;
 /**