neon 8.11.1 → 8.11.2

package/dist/_chunks/feedback-CMayyTa8.js

@@ -0,0 +1,88 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { isNetworkError } from "../errors.js";
+import { writer } from "../writer.js";
+import { noPassthrough, single } from "../utils/flags.js";
+//#region src/commands/feedback.ts
+var feedback_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_FEEDBACK_URL: () => DEFAULT_FEEDBACK_URL,
+	MAX_FEEDBACK_LENGTH: () => MAX_FEEDBACK_LENGTH,
+	builder: () => builder,
+	command: () => command,
+	describe: () => describe,
+	handler: () => handler,
+	resolveFeedbackUrl: () => resolveFeedbackUrl
+});
+const DEFAULT_FEEDBACK_URL = "https://feedback.neon.tech/";
+/** The feedback service truncates longer messages, so the CLI rejects them instead. */
+const MAX_FEEDBACK_LENGTH = 1e4;
+const FEEDBACK_SOURCE = "neon_cli";
+const FEEDBACK_TIMEOUT_MS = 3e4;
+const command = "feedback";
+const describe = "Send feedback to Neon";
+const builder = (argv) => argv.usage("$0 feedback --message <feedback>").option("message", {
+	describe: "The feedback to send. Do not include passwords, API keys, or connection strings",
+	type: "string",
+	demandOption: true,
+	coerce: single("message", { required: true })
+}).option("url", {
+	describe: "Override the feedback URL",
+	type: "string",
+	hidden: true,
+	coerce: single("url")
+}).strict().check(noPassthrough("feedback")).check((args) => {
+	if ((typeof args.message === "string" ? args.message : "").trim().length > 1e4) throw new Error(`--message must be ${MAX_FEEDBACK_LENGTH.toLocaleString("en-US")} characters or fewer`);
+	return true;
+}).example("$0 feedback --message \"The branch docs were unclear\"", describe);
+function resolveFeedbackUrl(opts) {
+	const fromFlag = opts.url?.trim();
+	if (fromFlag) return fromFlag;
+	const fromEnv = opts.envUrl?.trim();
+	if (fromEnv) return fromEnv;
+	return DEFAULT_FEEDBACK_URL;
+}
+const handler = async (props) => {
+	await sendFeedback({
+		message: props.message.trim(),
+		url: resolveFeedbackUrl({
+			url: props.url,
+			envUrl: process.env.NEON_FEEDBACK_URL
+		})
+	});
+	if (props.output === "json" || props.output === "yaml") {
+		writer(props).end({ received: true }, { fields: ["received"] });
+		return;
+	}
+	writer(props).text("Feedback received. Thank you!\n");
+};
+function isTimeout(error) {
+	return error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+}
+async function feedbackErrorMessage(response) {
+	if (response.status === 429) return "Too many feedback requests. Wait a minute and try again.";
+	try {
+		const body = await response.json();
+		if (typeof body === "object" && body !== null && "error" in body && typeof body.error === "string" && body.error.trim() !== "") return body.error;
+	} catch {}
+	return `The Neon feedback service returned ${response.status}.`;
+}
+async function sendFeedback(opts) {
+	let response;
+	try {
+		response = await fetch(opts.url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				feedback: opts.message,
+				source: FEEDBACK_SOURCE
+			}),
+			signal: AbortSignal.timeout(FEEDBACK_TIMEOUT_MS)
+		});
+	} catch (error) {
+		if (isTimeout(error)) throw new Error("The Neon feedback service did not respond in time.");
+		if (isNetworkError(error)) throw new Error("Could not reach the Neon feedback service. Check your internet connection and try again.");
+		throw error;
+	}
+	if (!response.ok) throw new Error(await feedbackErrorMessage(response));
+}
+//#endregion
+export { describe as a, resolveFeedbackUrl as c, command as i, MAX_FEEDBACK_LENGTH as n, feedback_exports as o, builder as r, handler as s, DEFAULT_FEEDBACK_URL as t };

package/dist/_chunks/functions-Q0zuvtnk.js

@@ -0,0 +1,464 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { log } from "../log.js";
+import { isNeonApiError, retryOnLock } from "../api.js";
+import { getCliName } from "../utils/cli_name.js";
+import { deleteCustomDomain, listCustomDomains, registerCustomDomain } from "../custom_domains_api.js";
+import { createDeployment, deleteFunction, getFunction, listFunctions } from "../functions_api.js";
+import { writer } from "../writer.js";
+import { branchIdFromProps, fillSingleProject } from "../utils/enrichers.js";
+import { bundleEntry } from "../utils/esbuild.js";
+import { FUNCTION_SLUG_HELP, FUNCTION_SLUG_PATTERN } from "../utils/function_slug.js";
+import { zipBundle } from "../utils/zip.js";
+import { DEPLOY_COMMANDS_EPILOGUE } from "../commands/deploy_help.js";
+import { handleNew, listTemplates } from "../commands/functions_new.js";
+import { statSync } from "node:fs";
+import { dirname } from "node:path";
+import { FUNCTION_SOURCE_ENTRIES } from "@neon/config";
+import { bundleAsIs, describeNativeFinding, findUndeclaredNativePackages, resolveEsbuildEntry, zipFunctionBundle } from "@neon/config-runtime";
+//#region src/commands/functions.ts
+var functions_exports = /* @__PURE__ */ __exportAll({
+	aliases: () => aliases,
+	builder: () => builder,
+	command: () => command,
+	deploymentPollDelay: () => deploymentPollDelay,
+	describe: () => describe,
+	handler: () => handler
+});
+const FUNCTION_FIELDS = [
+	"slug",
+	"name",
+	"invocation_url",
+	"created_at"
+];
+const FUNCTIONS_LIST_LIMIT = 100;
+const CUSTOM_DOMAINS_LIST_LIMIT = 100;
+const CUSTOM_DOMAIN_FIELDS = [
+	"domain",
+	"entity_type",
+	"entity_id",
+	"cname_target"
+];
+const LIST_TABLE_FIELDS = [
+	"slug",
+	"name",
+	"status",
+	"URL",
+	"created_at"
+];
+const DEPLOY_RESULT_FIELDS = [
+	"id",
+	"status",
+	"invocation_url",
+	"runtime",
+	"memory_mib",
+	"created_at"
+];
+const DEPLOYMENT_TABLE_FIELDS = [
+	"deployment_id",
+	"status",
+	"runtime",
+	"memory",
+	"created_at"
+];
+const deploymentTableView = (dep) => ({
+	deployment_id: dep.id,
+	status: dep.status,
+	runtime: dep.runtime,
+	memory: `${dep.memory_mib} MiB`,
+	created_at: dep.created_at
+});
+const FUNCTION_TABLE_FIELDS = [
+	"slug",
+	"name",
+	"URL",
+	"created_at"
+];
+const writeDeploymentErrorSection = (out, dep) => {
+	if (dep.status === "failed" && dep.error) out.write({ reason: dep.error }, {
+		fields: ["reason"],
+		title: "Deployment error"
+	});
+};
+const POLL_INTERVAL_OVERRIDE_MS = Number(process.env.NEON_FUNCTIONS_POLL_INTERVAL_MS) || void 0;
+const FIRST_POLL_DELAY_MS = 200;
+const POLL_INTERVAL_MS = 2e3;
+/**
+* Delay before poll `attempt` (zero-based). A small function's deployment is usually done
+* within a few hundred milliseconds of the POST, so the first check comes soon and longer
+* builds back off to the steady interval.
+*/
+const deploymentPollDelay = (attempt, override = POLL_INTERVAL_OVERRIDE_MS) => override ?? Math.min(FIRST_POLL_DELAY_MS * 2 ** attempt, POLL_INTERVAL_MS);
+const POLL_TIMEOUT_MS = Number(process.env.NEON_FUNCTIONS_POLL_TIMEOUT_MS) || 6e5;
+const command = "functions";
+const describe = "Manage Neon Functions";
+const aliases = ["function"];
+const builder = (argv) => argv.usage("$0 function <sub-command> [options]").options({
+	"project-id": {
+		describe: "Project ID",
+		type: "string"
+	},
+	branch: {
+		describe: "Branch ID or name",
+		type: "string"
+	}
+}).middleware(fillSingleProject).command("new [template]", "Create a function from a Function Registry template", (yargs) => yargs.strict().positional("template", {
+	describe: "Template ID. Omit it in a terminal to pick one; `neon functions templates list` shows them all.",
+	type: "string"
+}).options({
+	"project-id": { hidden: true },
+	branch: { hidden: true },
+	slug: {
+		describe: "Function slug, also used as the directory name. A separate template keeps its own slugs and uses this only for the directory. Defaults to the template ID",
+		type: "string"
+	},
+	operation: {
+		describe: "Operation to include (repeatable). Without it, a TTY asks and anything else uses the recommended operations.",
+		type: "string",
+		array: true
+	},
+	"all-operations": {
+		describe: "Include every operation. Conflicts with --operation.",
+		type: "boolean"
+	},
+	yes: {
+		alias: ["y", "default"],
+		describe: "Skip prompts: use the recommended operations and install dependencies",
+		type: "boolean"
+	},
+	dir: {
+		describe: "Destination directory (defaults to functions/<slug> next to neon.ts)",
+		type: "string"
+	},
+	force: {
+		describe: "Overwrite differing files and keep an existing neon.ts declaration",
+		type: "boolean"
+	},
+	install: {
+		describe: "Install the template's dependencies, plus @neon/config and @neon/env when neon.ts is created. A TTY asks when omitted, --yes installs, and anything else leaves the install command in Next.",
+		type: "boolean"
+	},
+	"add-to-config": {
+		describe: "Declare the function in neon.ts, creating it when missing. On by default; use --no-add-to-config to skip.",
+		type: "boolean"
+	},
+	config: {
+		describe: "Path to the neon.ts to edit (defaults to the neon.ts next to .neon, or in cwd without one; created there when missing)",
+		type: "string"
+	}
+}), (args) => handleNew(args)).command("templates", "Browse Function Registry templates", (yargs) => yargs.command("list", "List function templates", (yargs) => yargs.strict().options({
+	"project-id": { hidden: true },
+	branch: { hidden: true }
+}), (args) => listTemplates(args))).command("deploy <slug>", "Deploy a function from a local directory", (yargs) => yargs.positional("slug", {
+	describe: "Function slug (1-20 lowercase letters and digits)",
+	type: "string",
+	demandOption: true
+}).options({
+	src: {
+		describe: "Function source: a directory containing index.ts, index.js, or index.mjs (first file match is the entry), or a path to the entry file",
+		type: "string"
+	},
+	path: {
+		type: "string",
+		hidden: true
+	},
+	entry: {
+		type: "string",
+		hidden: true
+	},
+	runtime: {
+		describe: "Function runtime",
+		type: "string",
+		choices: ["nodejs24"]
+	},
+	env: {
+		describe: "Environment variable as KEY=VALUE (repeatable)",
+		type: "string",
+		array: true
+	},
+	wait: {
+		describe: "Wait for the deployment to finish building",
+		type: "boolean",
+		default: true
+	},
+	bundle: {
+		describe: "Bundle --src with esbuild. Use --no-bundle to zip a prebuilt directory (root must contain index.mjs or index.js) or a file of that name.",
+		type: "boolean",
+		default: true
+	}
+}).epilogue(DEPLOY_COMMANDS_EPILOGUE), (args) => deploy(args)).command("list", "List functions on the branch", (yargs) => yargs, (args) => list(args)).command("get <slug>", "Show a function's details", (yargs) => yargs.positional("slug", {
+	describe: "Function slug",
+	type: "string",
+	demandOption: true
+}).options({ "list-env-variables": {
+	describe: "List the environment variable names of the active deployment",
+	type: "boolean",
+	alias: "E",
+	default: false
+} }), (args) => get(args)).command("delete <slug>", "Delete a function on the branch", (yargs) => yargs.positional("slug", {
+	describe: "Function slug",
+	type: "string",
+	demandOption: true
+}), (args) => deleteFn(args)).command(["domains", "domain"], "Manage custom domains on the branch (beta)", (yargs) => yargs.command("list", "List custom domains on the branch", (yargs) => yargs, (args) => listDomains(args)).command("register <domain>", "Point a domain you already own at a function on the branch", (yargs) => yargs.positional("domain", {
+	describe: "Domain you already own (for example docs.example.com)",
+	type: "string",
+	demandOption: true
+}).options({ slug: {
+	describe: "Function slug this domain should point at",
+	type: "string",
+	demandOption: true
+} }), (args) => registerDomain(args)).command("delete <domain>", "Delete a custom domain from the branch", (yargs) => yargs.positional("domain", {
+	describe: "Custom domain",
+	type: "string",
+	demandOption: true
+}), (args) => deleteDomain(args)));
+const handler = (args) => {
+	return args;
+};
+const parseEnv = (entries) => {
+	if (!entries || entries.length === 0) return void 0;
+	const map = {};
+	for (const entry of entries) {
+		const eq = entry.indexOf("=");
+		if (eq <= 0) throw new Error(`Invalid --env value "${entry}". Expected KEY=VALUE.`);
+		map[entry.slice(0, eq)] = entry.slice(eq + 1);
+	}
+	return JSON.stringify(map);
+};
+const statusHint = (slug, projectId, branchId) => `Check status with: ${getCliName()} function get ${slug} --project-id ${projectId} --branch ${branchId}`;
+const emitDeployResult = (props, deployment, fn) => {
+	if (props.output === "json" || props.output === "yaml") {
+		writer(props).write({
+			...deployment,
+			invocation_url: fn?.invocation_url
+		}, { fields: DEPLOY_RESULT_FIELDS }).end();
+		return;
+	}
+	const out = writer(props).write({
+		URL: fn?.invocation_url,
+		...deploymentTableView(deployment)
+	}, {
+		fields: ["URL", ...DEPLOYMENT_TABLE_FIELDS],
+		title: `Function ${props.slug}`
+	});
+	writeDeploymentErrorSection(out, deployment);
+	out.end();
+};
+const isTransient = (err) => isNeonApiError(err) && (err.status === void 0 || err.status === 404 || err.status >= 500);
+const deploy = async (props) => {
+	if (props.path !== void 0 || props.entry !== void 0) throw new Error(`--path and --entry were removed. Use --src <dir>; the entry point is discovered as ${FUNCTION_SOURCE_ENTRIES.join(", ")} in that directory.`);
+	if (!(props.src !== void 0 || props.env !== void 0 || props.runtime !== void 0 || props.bundle === false)) throw new Error(`Provide at least one option to deploy, e.g. --src, --env, or --no-bundle. See: ${getCliName()} function deploy --help.`);
+	if (!FUNCTION_SLUG_PATTERN.test(props.slug)) throw new Error(`Invalid function slug "${props.slug}". ${FUNCTION_SLUG_HELP}`);
+	const src = props.src ?? ".";
+	const runtime = props.runtime ?? "nodejs24";
+	const environment = parseEnv(props.env);
+	if (statSync(src, { throwIfNoEntry: false }) === void 0) throw new Error(`--src path not found: ${src}.`);
+	let zip;
+	if (!props.bundle) zip = await zipFunctionBundle(props.slug, await bundleAsIs({
+		slug: props.slug,
+		name: props.slug,
+		source: src,
+		env: {},
+		runtime: "nodejs24",
+		bundler: "none"
+	}, { via: "no-bundle" }));
+	else {
+		const source = await resolveEsbuildEntry(src);
+		const bundled = await bundleEntry(source);
+		for (const warning of bundled.warnings) log.warning(warning);
+		for (const finding of findUndeclaredNativePackages({
+			metafile: bundled.metafile,
+			declared: [],
+			projectDir: dirname(source)
+		})) log.warning(describeNativeFinding(props.slug, finding));
+		zip = zipBundle(bundled.files);
+	}
+	const branchId = await branchIdFromProps(props);
+	let before;
+	try {
+		before = (await getFunction(props.apiClient, props.projectId, branchId, props.slug)).current_deployment?.id;
+	} catch (err) {
+		if (!(isNeonApiError(err) && err.status === 404)) throw err;
+	}
+	await retryOnLock(() => createDeployment(props.apiClient, props.projectId, branchId, props.slug, {
+		zip,
+		runtime,
+		environment
+	}));
+	log.info(`Function deployment triggered for function ${props.slug}.`);
+	let interrupted = false;
+	const onSignal = () => {
+		interrupted = true;
+	};
+	process.once("SIGINT", onSignal);
+	process.once("SIGTERM", onSignal);
+	let resolved;
+	let resolvedFn;
+	const deadline = Date.now() + POLL_TIMEOUT_MS;
+	let attempt = 0;
+	try {
+		while (!interrupted && Date.now() < deadline) {
+			await new Promise((r) => setTimeout(r, deploymentPollDelay(attempt)));
+			attempt += 1;
+			if (interrupted) break;
+			let fn;
+			try {
+				fn = await getFunction(props.apiClient, props.projectId, branchId, props.slug);
+			} catch (err) {
+				if (isTransient(err)) continue;
+				throw err;
+			}
+			const dep = fn.current_deployment;
+			if (dep !== void 0 && (before === void 0 || dep.id > before) && dep) {
+				resolved = dep;
+				resolvedFn = fn;
+				if (!props.wait) break;
+				if (dep.status === "completed" || dep.status === "failed") break;
+			}
+		}
+	} finally {
+		process.removeListener("SIGINT", onSignal);
+		process.removeListener("SIGTERM", onSignal);
+	}
+	if (interrupted) {
+		log.info(statusHint(props.slug, props.projectId, branchId));
+		if (resolved) emitDeployResult(props, resolved, resolvedFn);
+		return;
+	}
+	if (resolved === void 0) {
+		log.info(statusHint(props.slug, props.projectId, branchId));
+		throw new Error(`Timed out waiting for the deployment of ${props.slug} to start. It may still be in progress.`);
+	}
+	emitDeployResult(props, resolved, resolvedFn);
+	if (!props.wait) {
+		log.info(statusHint(props.slug, props.projectId, branchId));
+		return;
+	}
+	if (resolved.status === "completed") {
+		if (props.output === "json" || props.output === "yaml") log.info(`Function deployment ${props.slug}/${resolved.id} completed.`);
+		return;
+	}
+	if (resolved.status === "failed") throw new Error(`Function deployment ${props.slug}/${resolved.id} failed.`);
+	log.info(statusHint(props.slug, props.projectId, branchId));
+	throw new Error(`Timed out waiting for function deployment ${props.slug}/${resolved.id} to finish. It may still be building.`);
+};
+const get = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	const fn = await getFunction(props.apiClient, props.projectId, branchId, props.slug);
+	if (props.output === "json" || props.output === "yaml") {
+		writer(props).end(fn, { fields: FUNCTION_FIELDS });
+		return;
+	}
+	const out = writer(props).write({
+		...fn,
+		URL: fn.invocation_url
+	}, {
+		fields: FUNCTION_TABLE_FIELDS,
+		title: "Function"
+	});
+	const current = fn.current_deployment;
+	const active = fn.active_deployment;
+	if (current && active && current.id === active.id) {
+		out.write(deploymentTableView(current), {
+			fields: DEPLOYMENT_TABLE_FIELDS,
+			title: "Deployment (current, active)"
+		});
+		writeDeploymentErrorSection(out, current);
+	} else {
+		if (current) {
+			out.write(deploymentTableView(current), {
+				fields: DEPLOYMENT_TABLE_FIELDS,
+				title: "Current deployment"
+			});
+			writeDeploymentErrorSection(out, current);
+		}
+		if (active) out.write(deploymentTableView(active), {
+			fields: DEPLOYMENT_TABLE_FIELDS,
+			title: "Active deployment"
+		});
+	}
+	if (props.listEnvVariables) out.write((fn.active_deployment?.environment ?? []).map((name) => ({ name })), {
+		fields: ["name"],
+		title: "Environment",
+		emptyMessage: "No environment variables on the active deployment."
+	});
+	out.end();
+};
+const deleteFn = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	try {
+		await retryOnLock(() => deleteFunction(props.apiClient, props.projectId, branchId, props.slug));
+	} catch (err) {
+		if (isNeonApiError(err) && err.status === 404) throw new Error(`Function "${props.slug}" not found on branch ${branchId}.`);
+		throw err;
+	}
+	log.info(`Function ${props.slug} deleted from branch ${branchId}`);
+};
+const list = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	const functions = [];
+	let cursor;
+	for (;;) {
+		const page = await listFunctions(props.apiClient, props.projectId, branchId, {
+			cursor,
+			limit: FUNCTIONS_LIST_LIMIT
+		});
+		functions.push(...page.functions);
+		log.debug("Got %d functions, next cursor: %s", page.functions.length, page.next);
+		if (!page.next || page.next === cursor) break;
+		cursor = page.next;
+	}
+	if (props.output === "json" || props.output === "yaml") {
+		writer(props).end(functions, { fields: FUNCTION_FIELDS });
+		return;
+	}
+	writer(props).end(functions.map((fn) => ({
+		...fn,
+		status: fn.current_deployment?.status ?? "",
+		URL: fn.invocation_url
+	})), {
+		fields: LIST_TABLE_FIELDS,
+		emptyMessage: "No functions found on this branch."
+	});
+};
+const listDomains = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	const domains = [];
+	let cursor;
+	for (;;) {
+		const page = await listCustomDomains(props.apiClient, props.projectId, branchId, {
+			cursor,
+			limit: CUSTOM_DOMAINS_LIST_LIMIT
+		});
+		domains.push(...page.custom_domains);
+		if (!page.next || page.next === cursor) break;
+		cursor = page.next;
+	}
+	writer(props).end(domains, {
+		fields: CUSTOM_DOMAIN_FIELDS,
+		emptyMessage: "No custom domains found on this branch."
+	});
+};
+const registerDomain = async (props) => {
+	if (!FUNCTION_SLUG_PATTERN.test(props.slug)) throw new Error(`Invalid function slug "${props.slug}". ${FUNCTION_SLUG_HELP}`);
+	const branchId = await branchIdFromProps(props);
+	const registered = await retryOnLock(() => registerCustomDomain(props.apiClient, props.projectId, branchId, {
+		domain: props.domain,
+		entity_type: "function",
+		entity_id: props.slug
+	}));
+	writer(props).end(registered, { fields: CUSTOM_DOMAIN_FIELDS });
+	if (registered.cname_target) log.info(`CNAME ${registered.domain} to ${registered.cname_target}`);
+	else log.info(`No CNAME target for ${registered.domain}; this region has no custom-domains front door.`);
+};
+const deleteDomain = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	try {
+		await retryOnLock(() => deleteCustomDomain(props.apiClient, props.projectId, branchId, props.domain));
+	} catch (err) {
+		if (isNeonApiError(err) && err.status === 404) throw new Error(`Custom domain "${props.domain}" not found on branch ${branchId}.`);
+		throw err;
+	}
+	log.info(`Custom domain ${props.domain} deleted from branch ${branchId}`);
+};
+//#endregion
+export { describe as a, deploymentPollDelay as i, builder as n, functions_exports as o, command as r, handler as s, aliases as t };