neonctl 2.37.1 → 2.38.1

package/dist/storage_api.js

@@ -1,147 +0,0 @@
-// Typed client helpers for the branch object-storage (bucket/object) API.
-//
-// These endpoints are part of the Neon object-storage surface (the "Buckets"
-// tag in the public API). They are not yet exposed as typed methods on
-// `@neon/sdk`, so the request/response types and the thin call helpers live
-// here. They are implemented on top of the API client's low-level `request()`
-// method, which reuses the exact same authentication, base URL, headers and
-// retry behaviour as every other neonctl command. When the SDK gains these
-// methods, the call sites in `src/commands/bucket.ts` can switch over with no
-// behavioural change.
-const bucketsPath = (projectId, branchId) => `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/buckets`;
-const bucketPath = (projectId, branchId, bucketName) => `${bucketsPath(projectId, branchId)}/${encodeURIComponent(bucketName)}`;
-/**
- * Create a bucket on a branch.
- *
- * @request POST /projects/{project_id}/branches/{branch_id}/buckets
- */
-export const createProjectBranchBucket = (apiClient, { projectId, branchId, name, accessLevel, }) => {
-    const body = { name };
-    // Omit access_level entirely so the server default (`private`) applies.
-    if (accessLevel !== undefined) {
-        body.access_level = accessLevel;
-    }
-    return apiClient.request({
-        path: bucketsPath(projectId, branchId),
-        method: "POST",
-        body,
-        format: "json",
-        secure: true,
-    });
-};
-/**
- * List the buckets on a branch.
- *
- * @request GET /projects/{project_id}/branches/{branch_id}/buckets
- */
-export const listProjectBranchBuckets = (apiClient, { projectId, branchId }) => apiClient.request({
-    path: bucketsPath(projectId, branchId),
-    method: "GET",
-    format: "json",
-    secure: true,
-});
-/**
- * Delete a bucket from a branch.
- *
- * @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}
- */
-export const deleteProjectBranchBucket = (apiClient, { projectId, branchId, bucketName, }) => apiClient.request({
-    path: bucketPath(projectId, branchId, bucketName),
-    method: "DELETE",
-    secure: true,
-});
-/**
- * List objects (and collapsed folders) in a bucket on a branch.
- *
- * @request GET /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects
- */
-export const listProjectBranchBucketObjects = (apiClient, { projectId, branchId, bucketName, ...query }) => apiClient.request({
-    path: `${bucketPath(projectId, branchId, bucketName)}/objects`,
-    method: "GET",
-    query,
-    format: "json",
-    secure: true,
-});
-/**
- * Download an object's raw bytes from a bucket on a branch.
- *
- * The server returns the body as `application/octet-stream` with a
- * `Content-Disposition: attachment` header; the helper requests the body as a
- * stream (`responseType: 'stream'`), so `.data` is a Node `Readable` the caller
- * can pipe straight to disk without buffering the whole object in memory. The
- * response headers are returned alongside so the caller can derive a filename
- * from `Content-Disposition`.
- *
- * The object key may contain `/`; it is percent-encoded into a single path
- * segment so nested keys are routed to the `{object_key}` parameter.
- *
- * @request GET /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}/download
- */
-export const getProjectBranchBucketObject = (apiClient, { projectId, branchId, bucketName, objectKey, }) => apiClient.request({
-    path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}/download`,
-    method: "GET",
-    format: "stream",
-    secure: true,
-});
-/**
- * Delete an object from a bucket on a branch.
- *
- * The object key may contain `/`; it is percent-encoded into a single path
- * segment so nested keys are routed to the `{object_key}` parameter.
- *
- * @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}
- */
-export const deleteProjectBranchBucketObject = (apiClient, { projectId, branchId, bucketName, objectKey, }) => apiClient.request({
-    path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}`,
-    method: "DELETE",
-    secure: true,
-});
-/**
- * Delete every object under a key prefix (folder) in a bucket on a branch.
- *
- * `prefix` must be non-empty and end with `/`; every object on this branch
- * whose key starts with the prefix is soft-deleted in a single call.
- *
- * @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects-by-prefix
- */
-export const deleteProjectBranchBucketObjectsByPrefix = (apiClient, { projectId, branchId, bucketName, prefix, }) => apiClient.request({
-    path: `${bucketPath(projectId, branchId, bucketName)}/objects-by-prefix`,
-    method: "DELETE",
-    query: { prefix },
-    format: "json",
-    secure: true,
-});
-/**
- * Request a presigned PUT URL for uploading an object to a bucket on a branch.
- *
- * Returns the URL, the headers that must accompany the PUT for the signature to
- * verify, and the expiry. The actual upload (a `PUT` to the returned `url` with
- * the returned `headers` and the file stream) is performed by the caller, NOT
- * through this api-client, since it targets the branch S3 data-plane endpoint
- * rather than the console API. No SigV4 or credential handling happens here.
- *
- * The object key may contain `/`; it is percent-encoded into a single path
- * segment so nested keys are routed to the `{object_key}` parameter.
- *
- * This targets the unified presign endpoint, passing `operation: "upload"` to
- * request a presigned PUT. (The same endpoint also serves `download`, but that
- * path is API-only and has no neonctl command.)
- *
- * @request POST /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}/presign
- */
-export const presignUpload = (apiClient, { projectId, branchId, bucketName, objectKey, contentType, expiresInSeconds, }) => {
-    const body = { operation: "upload" };
-    if (contentType !== undefined) {
-        body.content_type = contentType;
-    }
-    if (expiresInSeconds !== undefined) {
-        body.expires_in_seconds = expiresInSeconds;
-    }
-    return apiClient.request({
-        path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}/presign`,
-        method: "POST",
-        body,
-        format: "json",
-        secure: true,
-    });
-};

package/dist/test_utils/fixtures.js

@@ -1,121 +0,0 @@
-import { fork } from "node:child_process";
-import { createServer } from "node:http";
-import { join } from "node:path";
-import emocks from "emocks";
-import express from "express";
-import strip from "strip-ansi";
-import { expect, test as originalTest } from "vitest";
-import { log } from "../log";
-/**
- * Reserve a localhost port and close its listener, returning a URL that is guaranteed to
- * refuse connections right now. Lets a test drive the CLI into a real `ECONNREFUSED`
- * (the same shape a network blip produces) deterministically and fast.
- */
-const reserveClosedPort = () => new Promise((resolve, reject) => {
-    const probe = createServer();
-    probe.on("error", reject);
-    probe.listen(0, "127.0.0.1", () => {
-        const { port } = probe.address();
-        probe.close((err) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve(`http://127.0.0.1:${port}`);
-            }
-        });
-    });
-});
-export const test = originalTest.extend({
-    runMockServer: async ({}, use) => {
-        let startedServer;
-        await use(async (mockDir) => {
-            const app = express();
-            app.use(express.json());
-            app.use("/", emocks(join(process.cwd(), "mocks", mockDir), {
-                "404": (_req, res) => res.status(404).send({ message: "Not Found" }),
-            }));
-            const server = await new Promise((resolve) => {
-                const s = app.listen(0, () => {
-                    log.debug("Mock server listening at %d", s.address().port);
-                    resolve(s);
-                });
-            });
-            startedServer = server;
-            return server;
-        });
-        // `unreachableHost` tests never start the server, so only close it when it ran.
-        const server = startedServer;
-        if (server) {
-            await new Promise((resolve, reject) => {
-                server.close((err) => {
-                    if (err) {
-                        reject(err instanceof Error ? err : new Error(String(err)));
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-            });
-        }
-    },
-    testCliCommand: async ({ runMockServer }, use) => {
-        await use(async (args, options = {}) => {
-            const apiHost = options.unreachableHost
-                ? await reserveClosedPort()
-                : `http://localhost:${(await runMockServer(options.mockDir || "main")).address().port}`;
-            let output = "";
-            let error = "";
-            const cp = fork(join(process.cwd(), "./dist/index.js"), [
-                "--api-host",
-                apiHost,
-                "--output",
-                options.output ?? (options.outputTable ? "table" : "yaml"),
-                "--api-key",
-                "test-key",
-                "--no-analytics",
-                ...args,
-            ], {
-                stdio: "pipe",
-                ...(options.cwd ? { cwd: options.cwd } : {}),
-                env: {
-                    PATH: `${join(process.cwd(), "mocks/bin")}:${process.env.PATH}`,
-                    ...(options.env ?? {}),
-                },
-            });
-            return new Promise((resolve, reject) => {
-                cp.stdout?.on("data", (data) => {
-                    output += data.toString();
-                });
-                cp.stderr?.on("data", (data) => {
-                    error += data.toString();
-                    log.error(data.toString());
-                });
-                cp.on("error", (err) => {
-                    log.error(err);
-                    throw err;
-                });
-                cp.on("close", (code) => {
-                    try {
-                        expect(code).toBe(options?.code ?? 0);
-                        expect(output).toMatchSnapshot();
-                        if (options.stderr !== undefined) {
-                            expect(strip(error).replace(/\s+/g, " ").trim()).toEqual(typeof options.stderr === "string"
-                                ? options.stderr
-                                    .toString()
-                                    .replace(/\s+/g, " ")
-                                : options.stderr);
-                        }
-                        resolve();
-                    }
-                    catch (err) {
-                        reject(err instanceof Error ? err : new Error(String(err)));
-                    }
-                });
-            }).catch((err) => {
-                log.error(err);
-                throw err;
-            });
-        });
-    },
-});

package/dist/test_utils/oauth_server.js

@@ -1,9 +0,0 @@
-import { OAuth2Server } from "oauth2-mock-server";
-import { log } from "../log";
-export const startOauthServer = async () => {
-    const server = new OAuth2Server();
-    await server.issuer.keys.generate("RS256");
-    await server.start(0, "localhost");
-    log.debug("Started OAuth server on port %d", server.address().port);
-    return server;
-};

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/ai_gateway_notice.js

@@ -1,180 +0,0 @@
-import { log } from "../log.js";
-/**
- * Friendly guidance shown when a branch enables the AI Gateway (`preview.aiGateway`).
- *
- * The gateway is credential-gated, not provisioned: enabling it always mints a working
- * branch credential, so `apply` / `checkout` / `env pull` succeed regardless of plan. The
- * two things that *do* gate the gateway happen at serving time and are invisible in the
- * provisioning result, so we surface them as a courtesy notice instead:
- *
- *  - **Free plan** — credentials provision, but the gateway does not *serve* model requests.
- *    The account needs to upgrade to a paid plan.
- *  - **Reduced model set** — on a paid plan, an account still ramping up on the beta gets a
- *    trimmed model catalog (flagship models are listed but `enabled: false` on `/v1/models`).
- *    They can request access to more models.
- *
- * This is deliberately phrased for the user: it never mentions account "verification" or any
- * other internal gating mechanism.
- */
-/**
- * `BillingSubscriptionType` values that mean the account is on a Free plan (the gateway
- * won't serve requests). Everything else — `launch`, `scale`, `business`, the `*_v3`
- * variants, marketplace plans — is treated as paid.
- */
-const FREE_SUBSCRIPTION_TYPES = new Set(["free_v2", "free_v3"]);
-/**
- * The Neon Console billing page to upgrade a Free-plan account so the gateway can serve. It's
- * org-scoped when the project belongs to an org; projects on a personal account (which is
- * where Free plans usually live) have no org id, so we fall back to the account-level page.
- */
-export const aiGatewayUpgradeUrl = (orgId) => orgId
-    ? `https://console.neon.tech/app/${orgId}/billing`
-    : "https://console.neon.tech/app/billing";
-/**
- * The branch's AI Gateway page in the Neon Console — where a paid user with a reduced model
- * set requests access to more models. It's branch-scoped, so it's built from the linked
- * project and branch ids.
- */
-export const aiGatewayModelsUrl = (projectId, branchId) => `https://console.neon.tech/app/projects/${projectId}/branches/${branchId}/ai-gateway`;
-export const isFreePlan = (subscriptionType) => subscriptionType !== undefined &&
-    FREE_SUBSCRIPTION_TYPES.has(subscriptionType);
-/**
- * Whether the model catalog includes at least one flagship model enabled. Flagship models
- * (Anthropic Opus, OpenAI Codex / `*-pro`) are the first to be held back for an account still
- * ramping up on the beta, so their total absence from a non-empty enabled set is the signal
- * that the account has a reduced model set. Matched by id substring so it survives model
- * version bumps (e.g. `claude-opus-4-8`).
- */
-export const hasFlagshipModels = (modelIds) => modelIds.some((id) => id.includes("opus") || id.includes("codex") || id.endsWith("-pro"));
-/**
- * The message shown when a `neon.ts` that enables the AI Gateway is applied on a Free plan.
- * Provisioning is refused up front (see {@link assertAiGatewayProvisionable}) because the
- * gateway won't serve model requests until the account is on a paid plan. `upgradeUrl` is the
- * org-scoped Console billing page (see {@link aiGatewayUpgradeUrl}).
- */
-export const freePlanBlockMessage = (upgradeUrl) => "This neon.ts enables the AI Gateway, which isn't available on the Free plan — the " +
-    "gateway won't serve model requests. Upgrade to a paid plan and re-run, or remove " +
-    `\`preview.aiGateway\` from neon.ts. Upgrade here: ${upgradeUrl}`;
-/**
- * Build the AI Gateway courtesy notice for an account's plan and (optionally) its live model
- * catalog, or `null` when nothing needs saying.
- *
- * `modelIds` is `undefined` when the catalog wasn't probed (e.g. a dry-run `plan`, or a probe
- * that failed); in that case only the plan-based (Free) notice can be produced — never a
- * false "reduced models" warning. `upgradeUrl` is the org-scoped Console billing page
- * (Free notice); `moreModelsUrl` is the branch's Console AI Gateway page
- * (see {@link aiGatewayModelsUrl}), shown when the catalog is reduced.
- */
-export const buildAiGatewayNotice = ({ subscriptionType, modelIds, upgradeUrl, moreModelsUrl, }) => {
-    if (isFreePlan(subscriptionType)) {
-        return {
-            level: "warning",
-            message: "AI Gateway is enabled, but the gateway does not serve model requests on the " +
-                `Free plan. Upgrade to a paid plan to start making requests: ${upgradeUrl}`,
-        };
-    }
-    if (modelIds !== undefined &&
-        modelIds.length > 0 &&
-        !hasFlagshipModels(modelIds)) {
-        return {
-            level: "warning",
-            message: "AI Gateway is in public beta and not every model is enabled for your account " +
-                "yet, so some models are missing from the catalog. Request access to more " +
-                `models here: ${moreModelsUrl}`,
-        };
-    }
-    return null;
-};
-const isRecord = (value) => typeof value === "object" && value !== null;
-/**
- * Pull the `id`s of enabled models out of an OpenAI-compatible
- * `{ object: "list", data: [{ id, enabled, ... }] }` body. The gateway lists every model in
- * the catalog but marks ones the account can't serve yet with `enabled: false`; only the
- * enabled set is used to detect a reduced catalog.
- */
-export const extractEnabledModelIds = (body) => {
-    if (!isRecord(body) || !Array.isArray(body.data))
-        return null;
-    const ids = [];
-    for (const entry of body.data) {
-        if (isRecord(entry) &&
-            typeof entry.id === "string" &&
-            entry.enabled === true) {
-            ids.push(entry.id);
-        }
-    }
-    return ids;
-};
-/**
- * `GET {baseUrl}/v1/models` → the enabled model ids, or `null` if the catalog can't be read
- * (network / HTTP / parse failure). Returning `null` keeps the notice silent rather than
- * risking a false "reduced models" warning. `/v1/models` is served only on the unified
- * dialect (the `/openai/v1` Responses dialect returns 404).
- */
-export const fetchGatewayModelIds = async (baseUrl, token) => {
-    try {
-        const res = await fetch(`${baseUrl.replace(/\/+$/, "")}/v1/models`, {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        if (!res.ok)
-            return null;
-        return extractEnabledModelIds(await res.json());
-    }
-    catch {
-        return null;
-    }
-};
-/**
- * Refuse to provision the AI Gateway on a Free plan. Called before the `neon.ts` lifecycle
- * commands provision a branch (`config apply` / `deploy`, `checkout`), so a Free-plan user
- * gets a clear "upgrade first" error instead of a credential that can't serve requests.
- *
- * Best-effort on the plan lookup: if the plan can't be determined (network / API failure) we
- * do NOT block, so a transient error never wrongly refuses a paid user's deploy. Only a
- * positively-identified Free plan throws.
- */
-export const assertAiGatewayProvisionable = async (params) => {
-    let subscriptionType;
-    let orgId;
-    try {
-        const { data } = await params.apiClient.getProject(params.projectId);
-        subscriptionType = data.project.owner?.subscription_type;
-        orgId = data.project.org_id ?? undefined;
-    }
-    catch {
-        return; // Can't determine the plan — don't block.
-    }
-    if (isFreePlan(subscriptionType)) {
-        throw new Error(freePlanBlockMessage(aiGatewayUpgradeUrl(orgId)));
-    }
-};
-/**
- * Resolve the account's plan (and, when gateway credentials are on hand, its live model
- * catalog) and print the AI Gateway courtesy notice — used by the `neon.ts` lifecycle and
- * `env pull` whenever a branch has the gateway enabled.
- *
- * Pass `gateway` (base URL + token) to enable the reduced-model-set check; omit it (e.g. a
- * dry-run `plan`) to get only the Free-plan notice. This is best-effort: any failure while
- * fetching the plan or catalog is swallowed so it can never break the underlying command.
- */
-export const warnAiGateway = async (params) => {
-    try {
-        const { data } = await params.apiClient.getProject(params.projectId);
-        const subscriptionType = data.project.owner?.subscription_type;
-        const orgId = data.project.org_id ?? undefined;
-        const modelIds = params.gateway
-            ? ((await fetchGatewayModelIds(params.gateway.baseUrl, params.gateway.token)) ?? undefined)
-            : undefined;
-        const notice = buildAiGatewayNotice({
-            subscriptionType,
-            modelIds,
-            upgradeUrl: aiGatewayUpgradeUrl(orgId),
-            moreModelsUrl: aiGatewayModelsUrl(params.projectId, params.branchId),
-        });
-        if (notice)
-            log.warning(notice.message);
-    }
-    catch {
-        // A courtesy notice must never break the command that triggered it.
-    }
-};

package/dist/utils/api_enums.js

@@ -1,33 +0,0 @@
-// Runtime enum-like constants for Neon API string unions.
-//
-// `@neondatabase/api-client` generated TypeScript `enum`s (real runtime objects)
-// for fields like the compute endpoint type. `@neon/sdk` instead models these as
-// plain string-literal union *types*, which have no runtime value — so code that
-// read `EndpointType.ReadWrite` or `Object.values(EndpointType)` no longer works.
-//
-// These `as const` objects restore that runtime surface, and each is paired with
-// a same-named type whose union is identical to the corresponding `@neon/sdk`
-// type, so values stay assignable in both directions.
-export const EndpointType = {
-    ReadOnly: "read_only",
-    ReadWrite: "read_write",
-};
-export const NeonAuthOauthProviderId = {
-    Google: "google",
-    Github: "github",
-    Microsoft: "microsoft",
-    Vercel: "vercel",
-};
-export const NeonAuthOauthProviderType = {
-    Standard: "standard",
-    Shared: "shared",
-};
-export const NeonAuthSupportedAuthProvider = {
-    Mock: "mock",
-    Stack: "stack",
-    BetterAuth: "better_auth",
-};
-export const NeonAuthEmailVerificationMethod = {
-    Link: "link",
-    Otp: "otp",
-};

package/dist/utils/auth.js

@@ -1,5 +0,0 @@
-export const extendTokenSet = (tokenSet) => {
-    const exp = new Date();
-    exp.setSeconds(exp.getSeconds() + (tokenSet.expires_in ?? 0));
-    return { ...tokenSet, expires_at: exp.getTime() };
-};

package/dist/utils/branch_notice.js

@@ -1,22 +0,0 @@
-import chalk from "chalk";
-import { log } from "../log.js";
-/**
- * Print a one-line "this command is targeting <branch>" notice to **stderr** so
- * the user can sanity-check they're acting on the branch they think they are —
- * before a `status` / `plan` / `apply` / `env pull` does its work. This is the
- * cheap guardrail that catches "I planned against the wrong branch" / "I pulled
- * env from the wrong branch" before it bites.
- *
- * - Skipped for machine-readable output (`--output json|yaml`) so it never has
- *   to be reasoned about by a script; it's stderr-only regardless, keeping
- *   `--output table` stdout clean for piping too.
- * - `verb` is the leading phrase, e.g. `'Planning against branch'` →
- *   `→ Planning against branch main (br-…)`.
- */
-export const announceTargetBranch = (props, branch, verb) => {
-    if (props.output === "json" || props.output === "yaml") {
-        return;
-    }
-    const suffix = branch.usedDefault ? chalk.dim(" · project default") : "";
-    log.info("%s %s %s %s%s", chalk.dim("→"), verb, chalk.cyan.bold(branch.branchName), chalk.dim(`(${branch.branchId})`), suffix);
-};

package/dist/utils/branch_picker.js

@@ -1,103 +0,0 @@
-import prompts from "prompts";
-import { retryOnLock } from "../api.js";
-import { isCi } from "../env.js";
-import { log } from "../log.js";
-import { EndpointType } from "./api_enums.js";
-/** Sentinel `value` for the "create a new branch" choice (no branch id can collide). */
-const CREATE_BRANCH_CHOICE = Symbol("create-branch");
-/**
- * Render a branch's display name with the same word labels as `neonctl branch list`
- * (`[default]`, `[protected]`) instead of symbols, so the picker reads clearly.
- */
-const branchLabel = (branch) => {
-    const labels = [];
-    if (branch.default) {
-        labels.push("[default]");
-    }
-    if (branch.protected) {
-        labels.push("[protected]");
-    }
-    labels.push(branch.name);
-    return labels.join(" ");
-};
-/**
- * Prompt the user to pick a branch from `branches`, with a "＋ Create a new branch…" option
- * pinned to the top (mirroring the project/org pickers). The default selection is the
- * project's default branch (the create option sits at index 0, so the default index is
- * offset by one).
- *
- * Throws `opts.nonInteractiveMessage` when there is no TTY (or in CI): the caller knows the
- * right guidance for its command, so the message is supplied rather than hard-coded here.
- */
-export const pickBranchInteractively = async (branches, opts) => {
-    if (isCi() || !process.stdout.isTTY) {
-        throw new Error(opts.nonInteractiveMessage);
-    }
-    const defaultBranchIndex = branches.findIndex((b) => b.default);
-    const initial = defaultBranchIndex >= 0 ? defaultBranchIndex + 1 : 0;
-    const { choice } = await prompts({
-        type: "select",
-        name: "choice",
-        message: opts.message,
-        choices: [
-            { title: "＋ Create a new branch…", value: CREATE_BRANCH_CHOICE },
-            ...branches.map((b) => ({
-                title: `${branchLabel(b)} (${b.id})`,
-                value: b.id,
-            })),
-        ],
-        initial,
-    });
-    if (choice === undefined) {
-        throw new Error("Aborted: no branch selected.");
-    }
-    if (choice === CREATE_BRANCH_CHOICE) {
-        return { kind: "create", name: await promptNewBranchName(branches) };
-    }
-    return { kind: "existing", branchId: choice };
-};
-/**
- * Prompt for a new branch name, rejecting empty input and names already taken on the
- * project (so we never silently select a different, pre-existing branch).
- */
-export const promptNewBranchName = async (branches) => {
-    const existing = new Set(branches.map((b) => b.name));
-    const { name } = await prompts({
-        type: "text",
-        name: "name",
-        message: "New branch name:",
-        validate: (value) => {
-            const trimmed = value.trim();
-            if (trimmed === "")
-                return "Branch name cannot be empty.";
-            if (existing.has(trimmed))
-                return `A branch named "${trimmed}" already exists.`;
-            return true;
-        },
-    });
-    const trimmed = typeof name === "string" ? name.trim() : "";
-    if (trimmed === "") {
-        throw new Error("Aborted: no branch name provided.");
-    }
-    return trimmed;
-};
-/**
- * Create a branch with the same defaults as `neonctl branch create --name <name>`:
- * branched from the project's default branch with a read-write compute endpoint. Returns
- * the new branch id.
- */
-export const createBranch = async (apiClient, projectId, name, branches) => {
-    const defaultBranch = branches.find((b) => b.default);
-    if (!defaultBranch) {
-        throw new Error("No default branch found");
-    }
-    const { data } = await retryOnLock(() => apiClient.createProjectBranch(projectId, {
-        branch: { name, parent_id: defaultBranch.id },
-        endpoints: [{ type: EndpointType.ReadWrite }],
-    }));
-    if (defaultBranch.protected) {
-        log.warning("The parent branch is protected; a unique role password has been generated for the new branch.");
-    }
-    log.info("Created branch %s (%s).", data.branch.name, data.branch.id);
-    return data.branch.id;
-};

package/dist/utils/compute_units.js

@@ -1,28 +0,0 @@
-export const getComputeUnits = (autoscaling) => {
-    const fixedSizeAutoscaling = Number(autoscaling);
-    if (!isNaN(fixedSizeAutoscaling)) {
-        return {
-            autoscaling_limit_min_cu: fixedSizeAutoscaling,
-            autoscaling_limit_max_cu: fixedSizeAutoscaling,
-        };
-    }
-    if (!autoscaling.includes("-")) {
-        throw new Error('Autoscaling should be either fixed size (e.g. 2) or min and max sizes delimited with a dash (e.g. "0.5-1")');
-    }
-    const [min, max] = autoscaling.split("-");
-    if (!min || !max) {
-        throw new Error('Autoscaling should be either fixed size (e.g. 2) or min and max sizes delimited with a dash (e.g. "0.5-1")');
-    }
-    const minAutoscaling = Number(min);
-    const maxAutoscaling = Number(max);
-    if (isNaN(minAutoscaling)) {
-        throw new Error("Autoscaling min should be a number");
-    }
-    if (isNaN(maxAutoscaling)) {
-        throw new Error("Autoscaling max should be a number");
-    }
-    return {
-        autoscaling_limit_min_cu: minAutoscaling,
-        autoscaling_limit_max_cu: maxAutoscaling,
-    };
-};