@rebasepro/server-postgres 0.23.0 → 0.24.1-canary.g19596ef

package/dist/cli-console-DGee3Zl7.js

@@ -0,0 +1,225 @@
+import { createRequire as __createRequire } from "module";
+__createRequire(import.meta.url);
+import { i as __toESM } from "./rolldown-runtime-V7rFbMRe.js";
+import { l as poolMaxCeiling } from "./connection-C938nR3E.js";
+import { t as openRebase } from "./open-rebase-CAjWpPjs.js";
+import { i as outError, n as describeFailure, r as out } from "./source-DB6xJv3p.js";
+import { n as require_arg } from "./cli-prompt-egtNKkZl.js";
+import { t as RELAYED_FLAGS } from "./cli-flags-DnPHXjRH.js";
+import { setLogOutput } from "@rebasepro/server";
+import path from "path";
+import fs from "fs";
+import tty from "node:tty";
+import { inspect } from "node:util";
+import { PassThrough } from "node:stream";
+import readline from "node:readline";
+import repl from "node:repl";
+//#region src/cli-console.ts
+var import_arg = /* @__PURE__ */ __toESM(require_arg(), 1);
+/**
+* The flags `rebase console` takes. `--history` is the CLI's own: where it
+* keeps the REPL's history (`.rebase/console_history` in the project).
+*/
+var CONSOLE_FLAGS = {
+	"--collections": String,
+	"-c": "--collections",
+	"--eval": String,
+	"-e": "--eval",
+	"--history": String
+};
+/** The constructor of `async function` — what `new Function` is for a body that awaits. */
+var AsyncFunction = Object.getPrototypeOf(async () => void 0).constructor;
+/**
+* Run `code` with `rebase` and `collections` in scope and resolve with its
+* value.
+*
+* Read as an expression first, so `rebase.dataAsAdmin.posts.find()` is its own
+* result; code that is not one expression runs as a function body, where
+* `await` works everywhere and `return` gives the result.
+*/
+async function evaluateInConsole(code, scope) {
+	let run;
+	try {
+		run = new AsyncFunction("rebase", "collections", `return (${code}\n);`);
+	} catch (error) {
+		if (!(error instanceof SyntaxError)) throw error;
+		run = new AsyncFunction("rebase", "collections", code);
+	}
+	return run(scope.rebase, scope.collections);
+}
+/** A result as JSON, the way `--eval` prints it: dates as ISO strings, bigints as strings. */
+function consoleJson(value) {
+	return JSON.stringify(value, (_key, item) => typeof item === "bigint" ? item.toString() : item, 2) ?? "undefined";
+}
+/** The host and database a URL names, for the banner — never its credentials. */
+function describeDatabase(databaseUrl) {
+	try {
+		const url = new URL(databaseUrl);
+		return `${url.hostname}${url.port ? `:${url.port}` : ""}${url.pathname}`;
+	} catch {
+		return "the configured database";
+	}
+}
+/**
+* `rebase console [--eval <code>] [--collections <dir>]`, from the driver
+* line `["console", …flags]`. Resolves with the exit code.
+*/
+async function consoleCommand(args, streams = {}) {
+	const flags = (0, import_arg.default)({
+		...RELAYED_FLAGS,
+		...CONSOLE_FLAGS
+	}, { argv: args.slice(1) });
+	if (flags["--help"]) {
+		out("Run `rebase console --help` for the options — this is the driver's own entry point.");
+		return 0;
+	}
+	const databaseUrl = flags["--database-url"] || process.env.DATABASE_URL;
+	if (!databaseUrl) {
+		outError("✗ No database to open: DATABASE_URL is not set. Set it in .env, or pass --database-url.");
+		return 1;
+	}
+	if (process.env.LOG_LEVEL === void 0) process.env.LOG_LEVEL = "warn";
+	setLogOutput("stderr");
+	try {
+		return await openAndRun({
+			databaseUrl,
+			collections: flags["--collections"],
+			eval: flags["--eval"],
+			history: flags["--history"]
+		}, streams);
+	} finally {
+		setLogOutput();
+	}
+}
+/** Open the project, run `--eval` or the REPL, and close it again. Resolves with the exit code. */
+async function openAndRun(options, streams) {
+	const { databaseUrl } = options;
+	const collectionsPath = path.resolve(options.collections || path.join("..", "config", "collections"));
+	const { loadCollections } = await import("./doctor-CUAAOFZm.js").then((n) => n.t);
+	const collections = fs.existsSync(collectionsPath) ? await loadCollections(collectionsPath) : [];
+	const ceiling = poolMaxCeiling();
+	const rebase = await openRebase({
+		databaseUrl,
+		collections,
+		...ceiling !== null ? { pool: { max: ceiling } } : {}
+	});
+	try {
+		const code = options.eval;
+		if (code !== void 0) try {
+			const result = await evaluateInConsole(code, {
+				rebase,
+				collections: rebase.collections
+			});
+			if (result !== void 0) out(consoleJson(result));
+			return 0;
+		} catch (error) {
+			outError(describeFailure(error));
+			return 1;
+		}
+		await startRepl({
+			rebase,
+			collections: rebase.collections
+		}, {
+			history: options.history,
+			database: describeDatabase(databaseUrl),
+			...streams
+		});
+		return 0;
+	} finally {
+		await rebase.close();
+	}
+}
+/** The interactive half: a Node REPL until `.exit`, Ctrl-D or the end of piped input. */
+async function startRepl(scope, options) {
+	out("");
+	out(`  rebase console — ${options.database}, ${scope.collections.length} collection(s)`);
+	out("  In scope: rebase (dataAsAdmin, sql, withAuth, close) and collections. Top-level await works.");
+	out("  Try: await rebase.dataAsAdmin.<collection>.find({ limit: 5 })");
+	out("");
+	const input = options.input ?? process.stdin;
+	const output = options.output ?? process.stdout;
+	const feed = input instanceof tty.ReadStream && input.isTTY ? void 0 : new PassThrough();
+	const colors = output instanceof tty.WriteStream && output.isTTY;
+	const server = repl.start({
+		prompt: "",
+		useGlobal: false,
+		...feed ? {
+			input: feed,
+			output,
+			terminal: false
+		} : {
+			input,
+			output
+		},
+		writer: (value) => inspect(value, {
+			colors,
+			depth: 6
+		})
+	});
+	server.context.rebase = scope.rebase;
+	server.context.collections = scope.collections;
+	server.setPrompt("rebase> ");
+	const history = options.history;
+	if (history) {
+		fs.mkdirSync(path.dirname(history), { recursive: true });
+		await new Promise((resolve) => {
+			server.setupHistory(history, (error) => {
+				if (error) outError(`  (history is off: ${error.message})`);
+				resolve();
+			});
+		});
+	}
+	const exited = new Promise((resolve) => server.once("exit", () => resolve()));
+	server.displayPrompt();
+	if (feed) await feedLineByLine(input, server, feed, exited);
+	await exited;
+}
+/**
+* Hand input that is not typed at a terminal to the REPL a line at a time,
+* each once the REPL has finished the one before.
+*
+* Typed, the REPL holds keystrokes back while a top-level `await` is pending.
+* Piped, every line arrives at once and each is evaluated as it arrives, so in
+* `const { data } = await …` followed by `data.map(…)` the second line read
+* `data` before the first had assigned it.
+*
+* The REPL is paused as each line reaches it, and it resumes its input when it
+* displays its prompt again: once the line's value has settled, its error has
+* been printed, or it needs the next line to complete it. That resumption is
+* when the next line goes in. Lines are written one per chunk, because a
+* chunk holding several is split and every line of it handed over at once.
+*/
+async function feedLineByLine(source, server, feed, exited) {
+	let evaluated;
+	const ready = () => {
+		const resolve = evaluated;
+		evaluated = void 0;
+		resolve?.();
+	};
+	server.prependListener("line", () => {
+		if (!server.editorMode) server.pause();
+	});
+	server.on("line", () => {
+		if (!server.editorMode) return;
+		server.resume();
+		ready();
+	});
+	server.on("resume", ready);
+	const closed = exited.then(() => "closed");
+	const lines = readline.createInterface({
+		input: source,
+		crlfDelay: Infinity
+	});
+	for await (const line of lines) {
+		const done = new Promise((resolve) => {
+			evaluated = () => resolve("done");
+		});
+		feed.write(`${line}\n`);
+		if (await Promise.race([done, closed]) === "closed") break;
+	}
+	feed.end();
+}
+//#endregion
+export { consoleCommand };
+
+//# sourceMappingURL=cli-console-DGee3Zl7.js.map

package/dist/cli-console-DGee3Zl7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-console-DGee3Zl7.js","names":[],"sources":["../src/cli-console.ts"],"sourcesContent":["/**\n * `rebase console` — the driver's half.\n *\n * Loads the project's collections the way `rebase db push` does, opens the\n * database with {@link openRebase}, and either evaluates one piece of code\n * (`--eval`) or starts a Node REPL with `rebase` and `collections` in scope.\n * The `rebase` CLI resolves the database first (the managed one included) and\n * hands this process `DATABASE_URL`, exactly as it does for `db` commands.\n *\n * This is the boot side of `openRebase`: it is where the environment is read\n * — `DATABASE_URL`, and the `REBASE_DB_POOL_MAX` ceiling the managed\n * development database needs — and turned into explicit options.\n */\nimport arg from \"arg\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport readline from \"node:readline\";\nimport repl from \"node:repl\";\nimport { PassThrough } from \"node:stream\";\nimport tty from \"node:tty\";\nimport { inspect } from \"node:util\";\nimport { setLogOutput } from \"@rebasepro/server\";\nimport type { CollectionConfig } from \"@rebasepro/types\";\nimport { RELAYED_FLAGS } from \"./cli-flags\";\nimport { out, outError, describeFailure } from \"./cli-output\";\nimport { poolMaxCeiling } from \"./connection\";\nimport { openRebase, type OpenedRebase } from \"./open-rebase\";\n\n/**\n * The flags `rebase console` takes. `--history` is the CLI's own: where it\n * keeps the REPL's history (`.rebase/console_history` in the project).\n */\nexport const CONSOLE_FLAGS = {\n    \"--collections\": String,\n    \"-c\": \"--collections\",\n    \"--eval\": String,\n    \"-e\": \"--eval\",\n    \"--history\": String\n} satisfies arg.Spec;\n\n/** What the code the console runs can name. */\nexport interface ConsoleScope {\n    rebase: OpenedRebase;\n    collections: CollectionConfig[];\n}\n\ntype ScopedFunction = (rebase: OpenedRebase, collections: CollectionConfig[]) => Promise<unknown>;\ntype AsyncFunctionConstructor = new (...parameters: string[]) => ScopedFunction;\n\n/** The constructor of `async function` — what `new Function` is for a body that awaits. */\nconst AsyncFunction: AsyncFunctionConstructor = Object.getPrototypeOf(async () => undefined).constructor;\n\n/**\n * Run `code` with `rebase` and `collections` in scope and resolve with its\n * value.\n *\n * Read as an expression first, so `rebase.dataAsAdmin.posts.find()` is its own\n * result; code that is not one expression runs as a function body, where\n * `await` works everywhere and `return` gives the result.\n */\nexport async function evaluateInConsole(code: string, scope: ConsoleScope): Promise<unknown> {\n    let run: ScopedFunction;\n    try {\n        run = new AsyncFunction(\"rebase\", \"collections\", `return (${code}\\n);`);\n    } catch (error) {\n        if (!(error instanceof SyntaxError)) throw error;\n        run = new AsyncFunction(\"rebase\", \"collections\", code);\n    }\n    return run(scope.rebase, scope.collections);\n}\n\n/** A result as JSON, the way `--eval` prints it: dates as ISO strings, bigints as strings. */\nexport function consoleJson(value: unknown): string {\n    return JSON.stringify(value, (_key, item: unknown) => typeof item === \"bigint\" ? item.toString() : item, 2) ?? \"undefined\";\n}\n\n/** The host and database a URL names, for the banner — never its credentials. */\nfunction describeDatabase(databaseUrl: string): string {\n    try {\n        const url = new URL(databaseUrl);\n        return `${url.hostname}${url.port ? `:${url.port}` : \"\"}${url.pathname}`;\n    } catch {\n        return \"the configured database\";\n    }\n}\n\n/** Where the REPL reads and writes; the terminal unless a caller hands it streams. */\nexport interface ConsoleStreams {\n    input?: NodeJS.ReadableStream;\n    output?: NodeJS.WritableStream;\n}\n\n/**\n * `rebase console [--eval <code>] [--collections <dir>]`, from the driver\n * line `[\"console\", …flags]`. Resolves with the exit code.\n */\nexport async function consoleCommand(args: string[], streams: ConsoleStreams = {}): Promise<number> {\n    const flags = arg({ ...RELAYED_FLAGS, ...CONSOLE_FLAGS }, { argv: args.slice(1) });\n    if (flags[\"--help\"]) {\n        out(\"Run `rebase console --help` for the options — this is the driver's own entry point.\");\n        return 0;\n    }\n\n    const databaseUrl = flags[\"--database-url\"] || process.env.DATABASE_URL;\n    if (!databaseUrl) {\n        outError(\"✗ No database to open: DATABASE_URL is not set. Set it in .env, or pass --database-url.\");\n        return 1;\n    }\n\n    // The console's own lines are what the reader is here for; the driver's\n    // info-level boot notes are not, unless they asked for them.\n    if (process.env.LOG_LEVEL === undefined) process.env.LOG_LEVEL = \"warn\";\n\n    // And whatever level they asked for, a log line is never part of the\n    // answer: stdout holds the `--eval` result a pipe reads (`| jq .`) and the\n    // REPL's values. The scaffold's `.env` sets LOG_LEVEL=info, and under\n    // NODE_ENV=production warnings go to stdout too.\n    setLogOutput(\"stderr\");\n    try {\n        return await openAndRun({\n            databaseUrl,\n            collections: flags[\"--collections\"],\n            eval: flags[\"--eval\"],\n            history: flags[\"--history\"]\n        }, streams);\n    } finally {\n        setLogOutput();\n    }\n}\n\n/** Open the project, run `--eval` or the REPL, and close it again. Resolves with the exit code. */\nasync function openAndRun(\n    options: { databaseUrl: string; collections?: string; eval?: string; history?: string },\n    streams: ConsoleStreams\n): Promise<number> {\n    const { databaseUrl } = options;\n    const collectionsPath = path.resolve(options.collections || path.join(\"..\", \"config\", \"collections\"));\n    const { loadCollections } = await import(\"./schema/doctor\");\n    const collections = fs.existsSync(collectionsPath) ? await loadCollections(collectionsPath) : [];\n\n    const ceiling = poolMaxCeiling();\n    const rebase = await openRebase({\n        databaseUrl,\n        collections,\n        ...(ceiling !== null ? { pool: { max: ceiling } } : {})\n    });\n\n    try {\n        const code = options.eval;\n        if (code !== undefined) {\n            try {\n                const result = await evaluateInConsole(code, { rebase, collections: rebase.collections });\n                if (result !== undefined) out(consoleJson(result));\n                return 0;\n            } catch (error) {\n                outError(describeFailure(error));\n                return 1;\n            }\n        }\n\n        await startRepl({ rebase, collections: rebase.collections }, {\n            history: options.history,\n            database: describeDatabase(databaseUrl),\n            ...streams\n        });\n        return 0;\n    } finally {\n        await rebase.close();\n    }\n}\n\n/** The interactive half: a Node REPL until `.exit`, Ctrl-D or the end of piped input. */\nasync function startRepl(scope: ConsoleScope, options: { history?: string; database: string } & ConsoleStreams): Promise<void> {\n    out(\"\");\n    out(`  rebase console — ${options.database}, ${scope.collections.length} collection(s)`);\n    out(\"  In scope: rebase (dataAsAdmin, sql, withAuth, close) and collections. Top-level await works.\");\n    out(\"  Try: await rebase.dataAsAdmin.<collection>.find({ limit: 5 })\");\n    out(\"\");\n\n    const input = options.input ?? process.stdin;\n    const output = options.output ?? process.stdout;\n    // Typed at a terminal, the REPL reads it as one. Anything else — a pipe, a\n    // file, a stream handed in — reaches it a line at a time through `feed`\n    // (see `feedLineByLine`).\n    const feed = input instanceof tty.ReadStream && input.isTTY ? undefined : new PassThrough();\n    // Colours for a terminal only: piped to a file or another program, the\n    // escape codes are noise in the text.\n    const colors = output instanceof tty.WriteStream && output.isTTY;\n    // Started without a prompt, and given one once the scope is in place: a\n    // line that arrives with the first prompt must already see `rebase`.\n    const server = repl.start({\n        prompt: \"\",\n        useGlobal: false,\n        ...(feed ? { input: feed, output, terminal: false } : { input, output }),\n        writer: (value: unknown) => inspect(value, { colors, depth: 6 })\n    });\n    server.context.rebase = scope.rebase;\n    server.context.collections = scope.collections;\n    server.setPrompt(\"rebase> \");\n\n    const history = options.history;\n    if (history) {\n        fs.mkdirSync(path.dirname(history), { recursive: true });\n        await new Promise<void>((resolve) => {\n            server.setupHistory(history, (error) => {\n                if (error) outError(`  (history is off: ${error.message})`);\n                resolve();\n            });\n        });\n    }\n\n    const exited = new Promise<void>((resolve) => server.once(\"exit\", () => resolve()));\n    server.displayPrompt();\n    if (feed) await feedLineByLine(input, server, feed, exited);\n    await exited;\n}\n\n/**\n * Hand input that is not typed at a terminal to the REPL a line at a time,\n * each once the REPL has finished the one before.\n *\n * Typed, the REPL holds keystrokes back while a top-level `await` is pending.\n * Piped, every line arrives at once and each is evaluated as it arrives, so in\n * `const { data } = await …` followed by `data.map(…)` the second line read\n * `data` before the first had assigned it.\n *\n * The REPL is paused as each line reaches it, and it resumes its input when it\n * displays its prompt again: once the line's value has settled, its error has\n * been printed, or it needs the next line to complete it. That resumption is\n * when the next line goes in. Lines are written one per chunk, because a\n * chunk holding several is split and every line of it handed over at once.\n */\nasync function feedLineByLine(\n    source: NodeJS.ReadableStream,\n    server: repl.REPLServer,\n    feed: PassThrough,\n    exited: Promise<void>\n): Promise<void> {\n    let evaluated: (() => void) | undefined;\n    const ready = () => {\n        const resolve = evaluated;\n        evaluated = undefined;\n        resolve?.();\n    };\n    // Before the REPL's own handler, so a line it evaluates at once resumes\n    // after this pause rather than before it.\n    server.prependListener(\"line\", () => {\n        if (!server.editorMode) server.pause();\n    });\n    // `.editor` collects lines with no prompt until Ctrl-D: they go straight in.\n    server.on(\"line\", () => {\n        if (!server.editorMode) return;\n        server.resume();\n        ready();\n    });\n    server.on(\"resume\", ready);\n\n    const closed = exited.then(() => \"closed\" as const);\n    const lines = readline.createInterface({ input: source, crlfDelay: Infinity });\n    for await (const line of lines) {\n        const done = new Promise<\"done\">((resolve) => { evaluated = () => resolve(\"done\"); });\n        feed.write(`${line}\\n`);\n        // `.exit`: the rest of the input is not for this REPL.\n        if (await Promise.race([done, closed]) === \"closed\") break;\n    }\n    feed.end();\n}\n"],"mappings":"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"}

package/dist/cli-console.d.ts

@@ -0,0 +1,39 @@
+import type { CollectionConfig } from "@rebasepro/types";
+import { type OpenedRebase } from "./open-rebase.js";
+/**
+ * The flags `rebase console` takes. `--history` is the CLI's own: where it
+ * keeps the REPL's history (`.rebase/console_history` in the project).
+ */
+export declare const CONSOLE_FLAGS: {
+    "--collections": StringConstructor;
+    "-c": string;
+    "--eval": StringConstructor;
+    "-e": string;
+    "--history": StringConstructor;
+};
+/** What the code the console runs can name. */
+export interface ConsoleScope {
+    rebase: OpenedRebase;
+    collections: CollectionConfig[];
+}
+/**
+ * Run `code` with `rebase` and `collections` in scope and resolve with its
+ * value.
+ *
+ * Read as an expression first, so `rebase.dataAsAdmin.posts.find()` is its own
+ * result; code that is not one expression runs as a function body, where
+ * `await` works everywhere and `return` gives the result.
+ */
+export declare function evaluateInConsole(code: string, scope: ConsoleScope): Promise<unknown>;
+/** A result as JSON, the way `--eval` prints it: dates as ISO strings, bigints as strings. */
+export declare function consoleJson(value: unknown): string;
+/** Where the REPL reads and writes; the terminal unless a caller hands it streams. */
+export interface ConsoleStreams {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+/**
+ * `rebase console [--eval <code>] [--collections <dir>]`, from the driver
+ * line `["console", …flags]`. Resolves with the exit code.
+ */
+export declare function consoleCommand(args: string[], streams?: ConsoleStreams): Promise<number>;