@rebasepro/cli 0.16.0 → 0.16.1-canary.g0d7af95

package/dist/dev-db/state.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The managed database's state file, and the rules for trusting it.
+ *
+ * The daemon outlives the command that started it — `rebase db push` in one
+ * terminal and `rebase dev` in another have to reach the *same* PGlite, because
+ * two processes opening one data directory would corrupt it. So the daemon
+ * records where it is, and every command reads that record.
+ *
+ * A record on disk is a claim, not a fact. The process it names may have been
+ * killed, the machine may have rebooted and handed the pid to something else,
+ * and the port may now belong to a stranger. {@link readState} therefore only
+ * parses; deciding whether a record is live is {@link isDaemonAlive}'s job, and
+ * it asks the daemon rather than the operating system.
+ */
+/** Everything under here is generated and gitignored. */
+export declare const DEV_DB_DIR = ".rebase";
+/** PGlite's own data directory. Deleting it is what `--reset` means. */
+export declare const DATA_DIR_NAME = "pgdata";
+/** The record the daemon writes once it is accepting connections. */
+export declare const STATE_FILE_NAME = "pglite.json";
+/**
+ * Held by whoever is currently starting a daemon.
+ *
+ * Without it, `rebase dev` and `rebase db push` started in the same second both
+ * see no state file, both spawn, and two processes open one PGlite data
+ * directory — the exact corruption the single-daemon design exists to prevent.
+ * Observed as `ENOTEMPTY` during cleanup, which is the harmless way for it to
+ * show up; the harmful way is a damaged database.
+ */
+export declare const START_LOCK_NAME = "starting.lock";
+export interface DaemonState {
+    /** TCP port the socket server is listening on, chosen when it started. */
+    port: number;
+    /** The daemon process. Used only as a fast negative check. */
+    pid: number;
+    /** Absolute path of the PGlite data directory this daemon has open. */
+    dataDir: string;
+    /** ISO timestamp, for diagnostics. */
+    startedAt: string;
+    /**
+     * A random token the daemon also answers with over the wire, on
+     * {@link identityPort}.
+     *
+     * Without it, "is the daemon alive?" degrades to "is something listening on
+     * that port?", which is a different question and answers yes for whatever
+     * process happened to take the port after a reboot. Rebase would then send
+     * migrations to a stranger.
+     */
+    token: string;
+    /** Loopback port that answers the identity check. */
+    identityPort: number;
+}
+export declare function devDbDir(projectRoot: string): string;
+export declare function dataDir(projectRoot: string): string;
+export declare function stateFile(projectRoot: string): string;
+export declare function startLockFile(projectRoot: string): string;
+/**
+ * Take the start lock, or report that somebody else holds it.
+ *
+ * `wx` is the whole mechanism: create-if-absent is a single atomic syscall, so
+ * exactly one of two racing processes can succeed no matter how close together
+ * they arrive.
+ *
+ * A lock older than `staleAfterMs` is broken rather than waited on — the holder
+ * may have been killed between creating it and starting anything, and a
+ * developer should never have to know this file exists in order to unstick
+ * their project.
+ */
+export declare function acquireStartLock(projectRoot: string, staleAfterMs: number): boolean;
+export declare function releaseStartLock(projectRoot: string): void;
+/**
+ * Parse the record, or `null` for anything that is not one.
+ *
+ * Every failure is the same answer — absent — because every failure has the
+ * same remedy: start a daemon. A corrupt state file is not worth an error
+ * message to a user who never wrote it.
+ */
+export declare function readState(projectRoot: string): DaemonState | null;
+export declare function writeState(projectRoot: string, state: DaemonState): void;
+export declare function clearState(projectRoot: string): void;
+/** Is *some* process with this pid running? A fast, cheap negative check. */
+export declare function pidRunning(pid: number): boolean;
+/** Can a TCP connection be opened to this port on loopback? */
+export declare function portAccepting(port: number, timeoutMs?: number): Promise<boolean>;
+/**
+ * Ask a port for a free one, then hand back the number.
+ *
+ * Deliberately not the probe `rebase init` uses: that one has a documented
+ * failure where a port is free to probe and unusable to publish. This binds on
+ * loopback only, which is also where the daemon listens, so a port that binds
+ * here binds there.
+ */
+export declare function findFreePort(): Promise<number>;

package/dist/function-portability.d.ts

@@ -0,0 +1,45 @@
+/** What a single finding is about. */
+export type PortabilityIssueKind = "node-builtin" | "node-only-package" | "module-scope-env" | "root-barrel-import" | "unknown-package";
+export interface PortabilityIssue {
+    kind: PortabilityIssueKind;
+    /** 1-based line in the function file. */
+    line: number;
+    /** One sentence, already phrased for a terminal. */
+    message: string;
+    /**
+     * Whether this is a problem *today*, on Node, rather than only a constraint
+     * on where the function could run. Exactly one kind is:
+     * `module-scope-env`, which is a latent crash on any host where a variable
+     * happens to be unset at import time, and takes every other function in the
+     * same directory down with it — the loader reports a file that throws on
+     * import as simply "skipped".
+     */
+    actionable: boolean;
+}
+export interface FunctionPortability {
+    /** Function name — the filename without extension, as it mounts. */
+    name: string;
+    /** Path relative to the project root. */
+    file: string;
+    /** Empty when the function depends on nothing host-specific. */
+    issues: PortabilityIssue[];
+    /** True when `issues` contains nothing that pins it to Node. */
+    portable: boolean;
+}
+/** Analyse one function file's source. Exported for testing. */
+export declare function analyseFunctionSource(source: string, name: string, file: string): FunctionPortability;
+/**
+ * Analyse every function in a directory.
+ *
+ * @param functionsDir Absolute path to the functions directory.
+ * @param projectRoot  For rendering paths people recognise.
+ */
+export declare function analyseFunctionsDirectory(functionsDir: string, projectRoot: string): FunctionPortability[];
+/**
+ * The lines to print after a build, or nothing at all.
+ *
+ * Silent when every function is portable and nothing is actionable, because a
+ * report that always prints is a report nobody reads. Actionable findings are
+ * always shown; the rest collapse to a single count with a pointer.
+ */
+export declare function summarisePortability(results: FunctionPortability[]): string[];

package/dist/index.d.ts

@@ -1,17 +1,17 @@
-export * from "./cli";
-export * from "./commands/init";
-export * from "./commands/schema";
-export * from "./commands/db";
-export * from "./commands/dev";
-export * from "./commands/build";
-export * from "./commands/eject";
-export * from "./commands/start";
-export * from "./commands/auth";
-export * from "./commands/doctor";
-export * from "./commands/generate_sdk";
-export * from "./commands/cloud";
-export * from "./commands/apps";
-export * from "./utils/project";
-export * from "./utils/package-manager";
-export * from "./manifest";
-export * from "./bundle";
+export * from "./cli.js";
+export * from "./commands/init.js";
+export * from "./commands/schema.js";
+export * from "./commands/db.js";
+export * from "./commands/dev.js";
+export * from "./commands/build.js";
+export * from "./commands/eject.js";
+export * from "./commands/start.js";
+export * from "./commands/auth.js";
+export * from "./commands/doctor.js";
+export * from "./commands/generate_sdk.js";
+export * from "./commands/cloud/index.js";
+export * from "./commands/apps.js";
+export * from "./utils/project.js";
+export * from "./utils/package-manager.js";
+export * from "./manifest.js";
+export * from "./bundle.js";