neon 3.0.0 → 3.1.1

package/dist/utils/point_in_time.js

@@ -1,56 +1,52 @@
-import { branchIdResolve } from "./enrichers.js";
 import { looksLikeLSN, looksLikeTimestamp } from "./formats.js";
-export class PointInTimeParseError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "PointInTimeParseError";
-    }
-}
-export const parsePITBranch = (input) => {
-    const splitIndex = input.lastIndexOf("@");
-    const sourceBranch = splitIndex === -1 ? input : input.slice(0, splitIndex);
-    const exactPIT = splitIndex === -1 ? null : input.slice(splitIndex + 1);
-    const result = {
-        branch: sourceBranch,
-        ...(exactPIT === null
-            ? { tag: "head" }
-            : looksLikeLSN(exactPIT)
-                ? { tag: "lsn", lsn: exactPIT }
-                : { tag: "timestamp", timestamp: exactPIT }),
-    };
-    if (result.tag === "timestamp") {
-        const timestamp = result.timestamp;
-        if (!looksLikeTimestamp(timestamp)) {
-            throw new PointInTimeParseError(`Invalid source branch format - ${input}`);
-        }
-        if (Date.parse(timestamp) > Date.now()) {
-            throw new PointInTimeParseError(`Timestamp can not be in future - ${input}`);
-        }
-    }
-    return result;
+import { branchIdResolve } from "./enrichers.js";
+//#region src/utils/point_in_time.ts
+var PointInTimeParseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PointInTimeParseError";
+	}
+};
+const parsePITBranch = (input) => {
+	const splitIndex = input.lastIndexOf("@");
+	const sourceBranch = splitIndex === -1 ? input : input.slice(0, splitIndex);
+	const exactPIT = splitIndex === -1 ? null : input.slice(splitIndex + 1);
+	const result = {
+		branch: sourceBranch,
+		...exactPIT === null ? { tag: "head" } : looksLikeLSN(exactPIT) ? {
+			tag: "lsn",
+			lsn: exactPIT
+		} : {
+			tag: "timestamp",
+			timestamp: exactPIT
+		}
+	};
+	if (result.tag === "timestamp") {
+		const timestamp = result.timestamp;
+		if (!looksLikeTimestamp(timestamp)) throw new PointInTimeParseError(`Invalid source branch format - ${input}`);
+		if (Date.parse(timestamp) > Date.now()) throw new PointInTimeParseError(`Timestamp can not be in future - ${input}`);
+	}
+	return result;
 };
-export const parsePointInTime = async ({ pointInTime, targetBranchId, projectId, api, }) => {
-    const parsedPIT = parsePITBranch(pointInTime);
-    let branchId = "";
-    if (parsedPIT.branch === "^self") {
-        branchId = targetBranchId;
-    }
-    else if (parsedPIT.branch === "^parent") {
-        const { data } = await api.getProjectBranch(projectId, targetBranchId);
-        const { parent_id: parentId } = data.branch;
-        if (parentId == null) {
-            throw new PointInTimeParseError("Branch has no parent");
-        }
-        branchId = parentId;
-    }
-    else {
-        branchId = await branchIdResolve({
-            branch: parsedPIT.branch,
-            projectId,
-            apiClient: api,
-        });
-    }
-    // @ts-expect-error extracting pit from parsedPIT
-    delete parsedPIT.branch;
-    return { ...parsedPIT, branchId };
+const parsePointInTime = async ({ pointInTime, targetBranchId, projectId, api }) => {
+	const parsedPIT = parsePITBranch(pointInTime);
+	let branchId = "";
+	if (parsedPIT.branch === "^self") branchId = targetBranchId;
+	else if (parsedPIT.branch === "^parent") {
+		const { data } = await api.getProjectBranch(projectId, targetBranchId);
+		const { parent_id: parentId } = data.branch;
+		if (parentId == null) throw new PointInTimeParseError("Branch has no parent");
+		branchId = parentId;
+	} else branchId = await branchIdResolve({
+		branch: parsedPIT.branch,
+		projectId,
+		apiClient: api
+	});
+	delete parsedPIT.branch;
+	return {
+		...parsedPIT,
+		branchId
+	};
 };
+//#endregion
+export { PointInTimeParseError, parsePITBranch, parsePointInTime };

package/dist/utils/psql.js

@@ -1,120 +1,103 @@
-import { spawn } from "child_process";
-import which from "which";
-import { closeAnalytics, trackEvent } from "../analytics.js";
 import { log } from "../log.js";
+import { closeAnalytics, trackEvent } from "../analytics.js";
+import which from "which";
+import { spawn } from "child_process";
+//#region src/utils/psql.ts
 const FALLBACK_ENV = "NEONCTL_PSQL_FALLBACK";
 /** Max time we wait for the analytics flush before handing off to psql. */
-const ANALYTICS_FLUSH_TIMEOUT_MS = 3000;
+const ANALYTICS_FLUSH_TIMEOUT_MS = 3e3;
 /**
- * Decide which psql implementation will run, and why. The PATH probe is
- * skipped when TS is forced (flag or env) — we don't need it and it'd be a
- * wasted lookup — so `nativeAvailable` is `null` ("not checked") in those
- * cases rather than a misleading `false`.
- */
+* Decide which psql implementation will run, and why. The PATH probe is
+* skipped when TS is forced (flag or env) — we don't need it and it'd be a
+* wasted lookup — so `nativeAvailable` is `null` ("not checked") in those
+* cases rather than a misleading `false`.
+*/
 const planPsql = async (opts) => {
-    if (opts.mode === "ts") {
-        return {
-            implementation: "ts",
-            reason: "forced_flag",
-            nativeAvailable: null,
-            nativePath: null,
-        };
-    }
-    if (process.env[FALLBACK_ENV] === "1") {
-        return {
-            implementation: "ts",
-            reason: "forced_env",
-            nativeAvailable: null,
-            nativePath: null,
-        };
-    }
-    const nativePath = await which("psql", { nothrow: true });
-    const nativeAvailable = nativePath !== null;
-    if (opts.mode === "native") {
-        return {
-            implementation: "native",
-            reason: "forced_native",
-            nativeAvailable,
-            nativePath,
-        };
-    }
-    // 'auto' (or unset): strict fallback — prefer native, TS only if missing.
-    return nativeAvailable
-        ? {
-            implementation: "native",
-            reason: "native_available",
-            nativeAvailable,
-            nativePath,
-        }
-        : {
-            implementation: "ts",
-            reason: "fallback_no_native",
-            nativeAvailable,
-            nativePath,
-        };
+	if (opts.mode === "ts") return {
+		implementation: "ts",
+		reason: "forced_flag",
+		nativeAvailable: null,
+		nativePath: null
+	};
+	if (process.env[FALLBACK_ENV] === "1") return {
+		implementation: "ts",
+		reason: "forced_env",
+		nativeAvailable: null,
+		nativePath: null
+	};
+	const nativePath = await which("psql", { nothrow: true });
+	const nativeAvailable = nativePath !== null;
+	if (opts.mode === "native") return {
+		implementation: "native",
+		reason: "forced_native",
+		nativeAvailable,
+		nativePath
+	};
+	return nativeAvailable ? {
+		implementation: "native",
+		reason: "native_available",
+		nativeAvailable,
+		nativePath
+	} : {
+		implementation: "ts",
+		reason: "fallback_no_native",
+		nativeAvailable,
+		nativePath
+	};
 };
 /**
- * Record which psql implementation is about to run, then flush analytics.
- *
- * Both exec paths below call `process.exit()`, which short-circuits the
- * main loop's `closeAnalytics()` — so without flushing here the event (and
- * any earlier queued events, e.g. `CLI Started`) would be dropped. The
- * flush is bounded by {@link ANALYTICS_FLUSH_TIMEOUT_MS} so a slow or
- * unreachable analytics endpoint can't stall the psql launch. No-ops when
- * analytics is disabled (`--analytics false`), since the client is absent.
- */
+* Record which psql implementation is about to run, then flush analytics.
+*
+* Both exec paths below call `process.exit()`, which short-circuits the
+* main loop's `closeAnalytics()` — so without flushing here the event (and
+* any earlier queued events, e.g. `CLI Started`) would be dropped. The
+* flush is bounded by {@link ANALYTICS_FLUSH_TIMEOUT_MS} so a slow or
+* unreachable analytics endpoint can't stall the psql launch. No-ops when
+* analytics is disabled (`--analytics false`), since the client is absent.
+*/
 const reportPsqlInvocation = async (plan) => {
-    trackEvent("psql_invoked", {
-        implementation: plan.implementation,
-        reason: plan.reason,
-        nativeAvailable: plan.nativeAvailable,
-    });
-    await closeAnalytics({ timeout: ANALYTICS_FLUSH_TIMEOUT_MS });
+	trackEvent("psql_invoked", {
+		implementation: plan.implementation,
+		reason: plan.reason,
+		nativeAvailable: plan.nativeAvailable
+	});
+	await closeAnalytics({ timeout: ANALYTICS_FLUSH_TIMEOUT_MS });
 };
 const execNative = async (binary, connection_uri, args) => {
-    log.info("Connecting to the database using psql...");
-    const child = spawn(binary, [connection_uri, ...args], {
-        stdio: "inherit",
-    });
-    for (const signame of ["SIGINT", "SIGTERM"]) {
-        process.on(signame, (code) => {
-            if (!child.killed && code !== null) {
-                child.kill(code);
-            }
-        });
-    }
-    return new Promise((_, reject) => {
-        child.on("exit", (code) => {
-            process.exit(code === null ? 1 : code);
-        });
-        child.on("error", reject);
-    });
+	log.info("Connecting to the database using psql...");
+	const child = spawn(binary, [connection_uri, ...args], { stdio: "inherit" });
+	for (const signame of ["SIGINT", "SIGTERM"]) process.on(signame, (code) => {
+		if (!child.killed && code !== null) child.kill(code);
+	});
+	return new Promise((_, reject) => {
+		child.on("exit", (code) => {
+			process.exit(code === null ? 1 : code);
+		});
+		child.on("error", reject);
+	});
 };
 const execTs = async (connection_uri, args) => {
-    log.info("Connecting to the database using embedded psql (TypeScript)...");
-    const { runPsql } = await import("../psql/index.js");
-    const code = await runPsql([connection_uri, ...args], {
-        stdin: process.stdin,
-        stdout: process.stdout,
-        stderr: process.stderr,
-    });
-    process.exit(code);
+	log.info("Connecting to the database using embedded psql (TypeScript)...");
+	const { runPsql } = await import("../psql/index.js");
+	const code = await runPsql([connection_uri, ...args], {
+		stdin: process.stdin,
+		stdout: process.stdout,
+		stderr: process.stderr
+	});
+	process.exit(code);
 };
-export const psql = async (connection_uri, args = [], opts = {}) => {
-    const plan = await planPsql(opts);
-    await reportPsqlInvocation(plan);
-    if (plan.implementation === "ts") {
-        if (plan.reason === "fallback_no_native") {
-            log.info("psql binary not found on PATH; falling back to embedded TypeScript psql");
-        }
-        return execTs(connection_uri, args);
-    }
-    // implementation === 'native'
-    if (plan.nativePath === null) {
-        // Only reachable when native was explicitly requested (mode: 'native')
-        // but no binary is on PATH.
-        log.error(`psql is not available in the PATH`);
-        process.exit(1);
-    }
-    return execNative(plan.nativePath, connection_uri, args);
+const psql = async (connection_uri, args = [], opts = {}) => {
+	const plan = await planPsql(opts);
+	await reportPsqlInvocation(plan);
+	if (plan.implementation === "ts") {
+		if (plan.reason === "fallback_no_native") log.info("psql binary not found on PATH; falling back to embedded TypeScript psql");
+		return execTs(connection_uri, args);
+	}
+	if (plan.nativePath === null) {
+		log.error(`psql is not available in the PATH`);
+		process.exit(1);
+	}
+	return execNative(plan.nativePath, connection_uri, args);
 };
+//#endregion
+export { psql };

package/dist/utils/service_picker.js

@@ -1,64 +1,61 @@
-import prompts from "prompts";
 import { CONFIG_INIT_SERVICES } from "../config_template.js";
+import prompts from "prompts";
+//#region src/utils/service_picker.ts
 /**
- * The picker's rows, in {@link CONFIG_INIT_SERVICES} order. Titles use the product names from
- * the CLI's README ("Managed Better Auth", "Object Storage") rather than the `neon.ts` field
- * names, since this is the list a user reads before they've seen a policy.
- */
+* The picker's rows, in {@link CONFIG_INIT_SERVICES} order. Titles use the product names from
+* the CLI's README ("Managed Better Auth", "Object Storage") rather than the `neon.ts` field
+* names, since this is the list a user reads before they've seen a policy.
+*/
 const CHOICES = [
-    {
-        value: "auth",
-        title: "Managed Better Auth",
-        description: "Authentication with users and sessions stored in Postgres.",
-    },
-    {
-        value: "functions",
-        title: "Functions",
-        description: "Long-running, without timeouts, and closer to your database.",
-    },
-    {
-        value: "object-storage",
-        title: "Object Storage",
-        description: "S3-compatible blob storage that branches with your projects.",
-    },
-    {
-        value: "ai-gateway",
-        title: "AI Gateway",
-        description: "All models, one API, one bill. Powered by Databricks. Not available on the Neon free plan.",
-    },
+	{
+		value: "auth",
+		title: "Managed Better Auth",
+		description: "Authentication with users and sessions stored in Postgres."
+	},
+	{
+		value: "functions",
+		title: "Functions",
+		description: "Long-running, without timeouts, and closer to your database."
+	},
+	{
+		value: "object-storage",
+		title: "Object Storage",
+		description: "S3-compatible blob storage that branches with your projects."
+	},
+	{
+		value: "ai-gateway",
+		title: "AI Gateway",
+		description: "All models, one API, one bill. Powered by Databricks. Not available on the Neon free plan."
+	}
 ];
 /**
- * Ask which services the scaffolded `neon.ts` should declare. Selecting nothing is a real
- * answer — it yields the bare starter policy — so an empty list returns empty rather than
- * re-prompting. Aborting (Ctrl-C) exits 1, matching the prompts in `link`.
- *
- * Callers guard the TTY themselves (see `initCmd`); this function assumes it may prompt.
- */
-export const pickServicesInteractively = async () => {
-    const { services } = await prompts({
-        onState: (state) => {
-            if (state.aborted) {
-                // Restore the cursor prompts hid, then exit — otherwise the terminal is
-                // left without one for the rest of the session.
-                process.stdout.write("\x1B[?25h");
-                process.stdout.write("\n");
-                process.exit(1);
-            }
-        },
-        type: "multiselect",
-        name: "services",
-        message: "Which Neon services should neon.ts declare? (space to toggle, enter to confirm)",
-        instructions: false,
-        choices: CHOICES.map((choice) => ({
-            value: choice.value,
-            title: choice.title,
-            description: choice.description,
-        })),
-    });
-    if (!Array.isArray(services)) {
-        throw new Error("Aborted: no services selected.");
-    }
-    // Order canonically rather than by selection order so the rendered neon.ts is
-    // independent of the order the rows were toggled in.
-    return CONFIG_INIT_SERVICES.filter((service) => services.includes(service));
+* Ask which services the scaffolded `neon.ts` should declare. Selecting nothing is a real
+* answer — it yields the bare starter policy — so an empty list returns empty rather than
+* re-prompting. Aborting (Ctrl-C) exits 1, matching the prompts in `link`.
+*
+* Callers guard the TTY themselves (see `initCmd`); this function assumes it may prompt.
+*/
+const pickServicesInteractively = async () => {
+	const { services } = await prompts({
+		onState: (state) => {
+			if (state.aborted) {
+				process.stdout.write("\x1B[?25h");
+				process.stdout.write("\n");
+				process.exit(1);
+			}
+		},
+		type: "multiselect",
+		name: "services",
+		message: "Which Neon services should neon.ts declare? (space to toggle, enter to confirm)",
+		instructions: false,
+		choices: CHOICES.map((choice) => ({
+			value: choice.value,
+			title: choice.title,
+			description: choice.description
+		}))
+	});
+	if (!Array.isArray(services)) throw new Error("Aborted: no services selected.");
+	return CONFIG_INIT_SERVICES.filter((service) => services.includes(service));
 };
+//#endregion
+export { pickServicesInteractively };

package/dist/utils/string.js

@@ -1,5 +1,5 @@
-export const toSnakeCase = (str) => str
-    .split(" ")
-    .map((word) => word.toLowerCase())
-    .join("_");
-export const isObject = (value) => value != null && value === Object(value);
+//#region src/utils/string.ts
+const toSnakeCase = (str) => str.split(" ").map((word) => word.toLowerCase()).join("_");
+const isObject = (value) => value != null && value === Object(value);
+//#endregion
+export { isObject, toSnakeCase };

package/dist/utils/ui.js

@@ -1,59 +1,42 @@
-// returns the next string if matches the given matcher,
-// otherwise returns null
-// consumes the line from the lines array
-export const consumeNextMatching = (lines, matcher) => {
-    while (lines.length > 0) {
-        const line = lines.shift().trim();
-        if (line === "") {
-            continue;
-        }
-        if (matcher.test(line)) {
-            return line;
-        }
-        return null;
-    }
-    return null;
+//#region src/utils/ui.ts
+const consumeNextMatching = (lines, matcher) => {
+	while (lines.length > 0) {
+		const line = lines.shift().trim();
+		if (line === "") continue;
+		if (matcher.test(line)) return line;
+		return null;
+	}
+	return null;
 };
-// returns strings if next non-empty line matches the given matcher,
-// otherwise returns empty array
-// consumes the lines from the lines array
-export const consumeBlockIfMatches = (lines, matcher) => {
-    const result = [];
-    if (lines.length === 0) {
-        return result;
-    }
-    let line = lines.shift();
-    while (line.trim() === "") {
-        line = lines.shift();
-    }
-    if (!matcher.test(line)) {
-        lines.unshift(line);
-        return result;
-    }
-    result.push(line);
-    while (lines.length > 0) {
-        line = lines.shift();
-        if (line.trim() === "") {
-            break;
-        }
-        result.push(line);
-    }
-    return result;
+const consumeBlockIfMatches = (lines, matcher) => {
+	const result = [];
+	if (lines.length === 0) return result;
+	let line = lines.shift();
+	while (line.trim() === "") line = lines.shift();
+	if (!matcher.test(line)) {
+		lines.unshift(line);
+		return result;
+	}
+	result.push(line);
+	while (lines.length > 0) {
+		line = lines.shift();
+		if (line.trim() === "") break;
+		result.push(line);
+	}
+	return result;
 };
-export const splitColumns = (line) => {
-    const result = line.trim().split(/\s{2,}/);
-    result[1] = result[1] ?? "";
-    if (result.length > 2) {
-        result[1] = result.slice(1).join(" ");
-    }
-    return result;
+const splitColumns = (line) => {
+	const result = line.trim().split(/\s{2,}/);
+	result[1] = result[1] ?? "";
+	if (result.length > 2) result[1] = result.slice(1).join(" ");
+	return result;
 };
-export const drawPointer = (width) => {
-    const result = [];
-    result.push("└");
-    for (let i = 0; i < width - 4; i++) {
-        result.push("─");
-    }
-    result.push(">");
-    return result.join("");
+const drawPointer = (width) => {
+	const result = [];
+	result.push("└");
+	for (let i = 0; i < width - 4; i++) result.push("─");
+	result.push(">");
+	return result.join("");
 };
+//#endregion
+export { consumeBlockIfMatches, consumeNextMatching, drawPointer, splitColumns };

package/dist/utils/write_sync.js

@@ -1,39 +1,30 @@
 import { writeSync } from "node:fs";
+//#region src/utils/write_sync.ts
 /**
- * Write `text` to a file descriptor and do not return until all of it is out.
- *
- * `process.stdout.write` is asynchronous when stdout is a pipe — which it is whenever the
- * caller is an agent or a script capturing output — so a `process.exit()` on the next line
- * discards whatever has not been flushed. The caller sees an exit code and empty stdout.
- *
- * Use this for any final message that is followed by `process.exit`.
- */
-export function writeAllSync(fd, text) {
-    let buffer = Buffer.from(text, "utf8");
-    while (buffer.length > 0) {
-        try {
-            buffer = buffer.subarray(writeSync(fd, buffer));
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === "EAGAIN") {
-                // Wait for the reader rather than spinning on it. A pipe nobody is draining
-                // would otherwise burn a core until it is; failure output is small enough
-                // that this should never be reached, which is the reason to bound it rather
-                // than assume so.
-                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
-                continue;
-            }
-            // The reader closed the pipe (`neon … | head`). There is nobody left to tell,
-            // and this is the last thing the process does, so stop rather than throw.
-            if (code === "EPIPE")
-                return;
-            // Anything else means the write did not happen and the caller is about to exit
-            // as though it had. Swallowing it turns a lost payload into an apparent success.
-            throw err;
-        }
-    }
+* Write `text` to a file descriptor and do not return until all of it is out.
+*
+* `process.stdout.write` is asynchronous when stdout is a pipe — which it is whenever the
+* caller is an agent or a script capturing output — so a `process.exit()` on the next line
+* discards whatever has not been flushed. The caller sees an exit code and empty stdout.
+*
+* Use this for any final message that is followed by `process.exit`.
+*/
+function writeAllSync(fd, text) {
+	let buffer = Buffer.from(text, "utf8");
+	while (buffer.length > 0) try {
+		buffer = buffer.subarray(writeSync(fd, buffer));
+	} catch (err) {
+		const code = err.code;
+		if (code === "EAGAIN") {
+			Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+			continue;
+		}
+		if (code === "EPIPE") return;
+		throw err;
+	}
 }
 /** File descriptors, named so call sites read as the stream they mean. */
-export const STDOUT_FD = 1;
-export const STDERR_FD = 2;
+const STDOUT_FD = 1;
+const STDERR_FD = 2;
+//#endregion
+export { STDERR_FD, STDOUT_FD, writeAllSync };

package/dist/utils/zip.js

@@ -1,4 +1,5 @@
 import { zipSync } from "fflate";
-// Zip the esbuild output (index.mjs) into the archive the Functions deploy endpoint
-// expects. Compression level 6 matches the previous bundler.
-export const zipBundle = (entries) => zipSync(entries, { level: 6 });
+//#region src/utils/zip.ts
+const zipBundle = (entries) => zipSync(entries, { level: 6 });
+//#endregion
+export { zipBundle };