neonctl 2.27.1 → 2.29.0

package/dist/dev/env.js

@@ -1,7 +1,7 @@
-import { loadConfigFromFile, } from '@neondatabase/config';
-import { plan, pullConfig, } from '@neondatabase/config-runtime';
-import { fetchEnv, toEntries } from '@neondatabase/env';
-import { log } from '../log.js';
+import { loadConfigFromFile } from "@neon/config";
+import { plan, pullConfig } from "@neon/config-runtime";
+import { fetchEnv, toEntries } from "@neon/env";
+import { log } from "../log.js";
 /** The API-targeting options every runtime call forwards from the context. */
 const apiOptions = (ctx) => ({
     ...(ctx.apiKey ? { apiKey: ctx.apiKey } : {}),
@@ -19,7 +19,7 @@ const apiOptions = (ctx) => ({
 export class DevEnvMismatchError extends Error {
     constructor() {
         super(...arguments);
-        this.name = 'DevEnvMismatchError';
+        this.name = "DevEnvMismatchError";
     }
 }
 /**
@@ -30,7 +30,7 @@ export class DevEnvMismatchError extends Error {
 export class MissingBranchContextError extends Error {
     constructor() {
         super(...arguments);
-        this.name = 'MissingBranchContextError';
+        this.name = "MissingBranchContextError";
     }
 }
 /**
@@ -56,9 +56,9 @@ export const resolveNeonEnvVars = async (ctx) => {
     const config = await loadNeonConfig(ctx.cwd);
     if (config) {
         if (!ctx.projectId || !ctx.branchId) {
-            throw new MissingBranchContextError('Found a neon.ts but could not resolve the project/branch. ' +
-                'Run `neonctl link` and `neonctl checkout <branch>`, or pass ' +
-                '--project-id / --branch.');
+            throw new MissingBranchContextError("Found a neon.ts but could not resolve the project/branch. " +
+                "Run `neonctl link` and `neonctl checkout <branch>`, or pass " +
+                "--project-id / --branch.");
         }
         // Resolve env from the policy with its `preview.functions` removed. Functions carry no
         // branch-level secrets — their env comes from the local `neon.ts` `functions.<slug>.env`,
@@ -82,8 +82,8 @@ export const resolveNeonEnvVars = async (ctx) => {
         // tuning closure), so it feeds straight into fetchEnv — no wrapping needed.
         return await fetchAndProject(pulled.config, ctx);
     }
-    throw new MissingBranchContextError('No project/branch context found. Link a branch (`neonctl link` / ' +
-        '`neonctl checkout`) or pass --project-id and --branch.');
+    throw new MissingBranchContextError("No project/branch context found. Link a branch (`neonctl link` / " +
+        "`neonctl checkout`) or pass --project-id and --branch.");
 };
 /**
  * `neon dev`'s env resolver: {@link resolveNeonEnvVars} with graceful degradation.
@@ -104,17 +104,17 @@ export const resolveDevEnv = async (ctx) => {
         if (err instanceof DevEnvMismatchError)
             throw err;
         if (err instanceof MissingBranchContextError) {
-            log.debug('dev: %s; skipping env injection', err.message);
+            log.debug("dev: %s; skipping env injection", err.message);
             return {
                 vars: {},
                 skipped: {
-                    reason: 'no linked Neon branch — run `neonctl link`, then ' +
-                        '`neonctl checkout <branch>`, to inject DATABASE_URL and friends',
+                    reason: "no linked Neon branch — run `neonctl link`, then " +
+                        "`neonctl checkout <branch>`, to inject DATABASE_URL and friends",
                 },
             };
         }
         const detail = err instanceof Error ? err.message : String(err);
-        log.debug('dev: env resolution failed: %s', detail);
+        log.debug("dev: env resolution failed: %s", detail);
         return {
             vars: {},
             skipped: {
@@ -159,11 +159,11 @@ const assertPolicyMatchesBranch = async (config, ctx) => {
     const missing = result.applied.filter(isMissingResource);
     if (missing.length === 0)
         return;
-    const names = missing.map((change) => change.identifier).join(', ');
+    const names = missing.map((change) => change.identifier).join(", ");
     throw new DevEnvMismatchError(`Your neon.ts declares ${names} for branch ${ctx.branchId}, but the branch ` +
-        'does not have it yet, so the matching env vars cannot be injected. ' +
-        'Provision it first with `neonctl deploy` (or `neonctl config apply`), ' +
-        'then re-run `neonctl dev`.');
+        "does not have it yet, so the matching env vars cannot be injected. " +
+        "Provision it first with `neonctl deploy` (or `neonctl config apply`), " +
+        "then re-run `neonctl dev`.");
 };
 /**
  * A planned change that provisions a branch-level resource the branch lacks: a
@@ -171,9 +171,9 @@ const assertPolicyMatchesBranch = async (config, ctx) => {
  * setting drift (`update`) and `noop`s are ignored — they don't block local dev
  * — and functions are excluded (see {@link assertPolicyMatchesBranch}).
  */
-const isMissingResource = (change) => change.kind === 'service' &&
-    change.action === 'create' &&
-    !change.identifier.startsWith('function:');
+const isMissingResource = (change) => change.kind === "service" &&
+    change.action === "create" &&
+    !change.identifier.startsWith("function:");
 const fetchAndProject = async (config, ctx) => {
     const env = await fetchEnv(config, {
         projectId: ctx.projectId,
@@ -191,17 +191,17 @@ const fetchAndProject = async (config, ctx) => {
 /**
  * Substrings that mark a module-resolution failure while loading `neon.ts` —
  * almost always because the project's dependencies aren't installed yet (the
- * config imports `@neondatabase/config` & friends). Deliberately specific:
+ * config imports `@neon/config` & friends). Deliberately specific:
  * the generic "…or a missing dependency…" hint the loader always appends is
  * NOT in here, so a real syntax/runtime error doesn't get mislabeled.
  */
 const MISSING_DEPENDENCY_HINTS = [
-    'cannot find module',
-    'cannot find package',
-    'err_module_not_found',
-    'failed to resolve',
-    'could not resolve',
-    'module not found',
+    "cannot find module",
+    "cannot find package",
+    "err_module_not_found",
+    "failed to resolve",
+    "could not resolve",
+    "module not found",
 ];
 /** Flatten an error and its `cause` chain to one lowercased string for matching. */
 const errorChainText = (err) => {
@@ -211,7 +211,7 @@ const errorChainText = (err) => {
         parts.push(current.message);
         current = current.cause;
     }
-    return parts.join('\n').toLowerCase();
+    return parts.join("\n").toLowerCase();
 };
 const looksLikeMissingDependency = (err) => {
     const text = errorChainText(err);
@@ -230,9 +230,9 @@ const loadNeonConfig = async (cwd) => {
         // A neon.ts that imports a package which isn't installed fails here with a
         // cryptic "Cannot find module …". Turn that into the actionable thing to do.
         if (looksLikeMissingDependency(err)) {
-            throw new Error('Could not load neon.ts: a package it imports is not installed. ' +
-                'Did you run `npm install`? Install your dependencies ' +
-                '(npm / pnpm / yarn / bun), then try again.\n' +
+            throw new Error("Could not load neon.ts: a package it imports is not installed. " +
+                "Did you run `npm install`? Install your dependencies " +
+                "(npm / pnpm / yarn / bun), then try again.\n" +
                 `Original error: ${message}`);
         }
         throw err;

package/dist/dev/functions.js

@@ -1,6 +1,6 @@
-import { dirname, isAbsolute, resolve } from 'node:path';
-import { existsSync } from 'node:fs';
-import { loadConfigFromFile, resolveConfig, } from '@neondatabase/config';
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { loadConfigFromFile, resolveConfig, } from "@neon/config";
 /**
  * Load `neon.ts` (if any) and resolve the list of functions it declares into
  * {@link PlannedFunction}s for `neon dev` to serve. Returns `null` when there is no
@@ -16,7 +16,7 @@ export const resolveFunctionsFromConfig = async (cwd, branchName) => {
         return null;
     const { config, configDir, configPath } = loaded;
     const resolved = resolveConfig(config, {
-        name: branchName ?? 'local',
+        name: branchName ?? "local",
         exists: branchName !== undefined,
     });
     const functions = resolved.preview?.functions ?? [];

package/dist/dev/inputs.js

@@ -1,4 +1,4 @@
-import { resolve } from 'node:path';
+import { resolve } from "node:path";
 const defaultDeps = {
     isPackaged: () => process.pkg !== undefined,
     loadEsbuild: (name) => import(name),
@@ -25,7 +25,7 @@ export const resolveWatchInputs = async (source, deps = defaultDeps) => {
     // 'esbuild', for the same reason as src/utils/esbuild.ts: rollup and
     // @yao-pkg/pkg statically scan for literal import()/require() and would pull
     // esbuild's native Go binary into the bundle/snapshot. Keep it invisible.
-    const name = ['es', 'build'].join('');
+    const name = ["es", "build"].join("");
     let esbuild;
     try {
         esbuild = await deps.loadEsbuild(name);
@@ -42,10 +42,10 @@ export const resolveWatchInputs = async (source, deps = defaultDeps) => {
             bundle: true,
             write: false,
             metafile: true,
-            format: 'esm',
-            platform: 'node',
-            packages: 'external',
-            logLevel: 'silent',
+            format: "esm",
+            platform: "node",
+            packages: "external",
+            logLevel: "silent",
         });
         metafile = result.metafile;
     }

package/dist/dev/runtime.js

@@ -1,12 +1,12 @@
-import { createServer } from 'node:http';
-import { pathToFileURL } from 'node:url';
-import { resolve } from 'node:path';
-import { getRequestListener } from '@hono/node-server';
-const isFunction = (value) => typeof value === 'function';
-const hasFetchMethod = (value) => typeof value === 'object' &&
+import { createServer } from "node:http";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { getRequestListener } from "@hono/node-server";
+const isFunction = (value) => typeof value === "function";
+const hasFetchMethod = (value) => typeof value === "object" &&
     value !== null &&
-    'fetch' in value &&
-    typeof value.fetch === 'function';
+    "fetch" in value &&
+    typeof value.fetch === "function";
 /**
  * Resolve the user's exported handler to a single fetch callback.
  *
@@ -23,9 +23,9 @@ export const resolveFetchHandler = (mod) => {
     if (isFunction(defaultExport)) {
         return defaultExport;
     }
-    throw new Error('No request handler found in the source module. Export one of:\n' +
-        '  export default { fetch(req) { /* ... */ } }\n' +
-        '  export default function (req) { /* ... */ }');
+    throw new Error("No request handler found in the source module. Export one of:\n" +
+        "  export default { fetch(req) { /* ... */ } }\n" +
+        "  export default function (req) { /* ... */ }");
 };
 /**
  * Wrap a fetch handler so user errors become a 500 response (with the message
@@ -41,18 +41,18 @@ export const withErrorBoundary = (handler) => {
             process.stderr.write(`Request handler threw an error:\n${message}\n`);
             return new Response(`Internal Server Error\n\n${message}`, {
                 status: 500,
-                headers: { 'content-type': 'text/plain; charset=utf-8' },
+                headers: { "content-type": "text/plain; charset=utf-8" },
             });
         }
     };
 };
-const isAddressInUse = (err) => typeof err === 'object' &&
+const isAddressInUse = (err) => typeof err === "object" &&
     err !== null &&
-    err.code === 'EADDRINUSE';
+    err.code === "EADDRINUSE";
 const DEFAULT_SEARCH_BASE = 8787;
 const MAX_SEARCH_STEPS = 100;
 const bindPort = async (server, selection, hostname) => {
-    if (selection.mode === 'explicit') {
+    if (selection.mode === "explicit") {
         return listen(server, selection.port, hostname);
     }
     for (let step = 0; step < MAX_SEARCH_STEPS; step++) {
@@ -68,15 +68,15 @@ const bindPort = async (server, selection, hostname) => {
 };
 const listen = (server, port, hostname) => new Promise((resolveListen, rejectListen) => {
     const onError = (err) => {
-        server.off('listening', onListening);
+        server.off("listening", onListening);
         rejectListen(err);
     };
     const onListening = () => {
-        server.off('error', onError);
+        server.off("error", onError);
         resolveListen(server.address().port);
     };
-    server.once('error', onError);
-    server.once('listening', onListening);
+    server.once("error", onError);
+    server.once("listening", onListening);
     server.listen(port, hostname);
 });
 /**
@@ -106,16 +106,16 @@ export const startRuntime = async ({ source, port, hostname, }) => {
  */
 export const portSelectionFromEnv = (env) => {
     const explicit = env.NEON_DEV_PORT;
-    if (explicit !== undefined && explicit !== '') {
-        return { mode: 'explicit', port: parsePort(explicit, 'NEON_DEV_PORT') };
+    if (explicit !== undefined && explicit !== "") {
+        return { mode: "explicit", port: parsePort(explicit, "NEON_DEV_PORT") };
     }
     const injected = env.PORT;
-    if (injected !== undefined && injected !== '') {
-        return { mode: 'explicit', port: parsePort(injected, 'PORT') };
+    if (injected !== undefined && injected !== "") {
+        return { mode: "explicit", port: parsePort(injected, "PORT") };
     }
     const base = Number(env.NEON_DEV_PORT_BASE ?? DEFAULT_SEARCH_BASE);
     return {
-        mode: 'search',
+        mode: "search",
         from: Number.isInteger(base) ? base : DEFAULT_SEARCH_BASE,
     };
 };
@@ -135,7 +135,7 @@ const isDirectExecution = () => {
 if (isDirectExecution()) {
     const source = process.env.NEON_DEV_SOURCE ?? process.argv[2];
     if (!source) {
-        process.stderr.write('neon-dev runtime: missing source path\n');
+        process.stderr.write("neon-dev runtime: missing source path\n");
         process.exit(1);
     }
     startRuntime({ source, port: portSelectionFromEnv(process.env) }).catch((err) => {

package/dist/env.js

@@ -1,5 +1,5 @@
 export const isCi = () => {
-    return process.env.CI !== 'false' && Boolean(process.env.CI);
+    return process.env.CI !== "false" && Boolean(process.env.CI);
 };
 export const isDebug = () => {
     return Boolean(process.env.DEBUG);
@@ -7,27 +7,27 @@ export const isDebug = () => {
 export const getGithubEnvVars = (env) => {
     const vars = [
         // github action info
-        'GITHUB_ACTION_PATH',
+        "GITHUB_ACTION_PATH",
         // source github repository
-        'GITHUB_REPOSITORY',
+        "GITHUB_REPOSITORY",
         // environment info
-        'GITHUB_RUN_ID',
-        'GITHUB_RUN_NUMBER',
-        'GITHUB_SERVER_URL',
-        'GITHUB_WORKFLOW_REF',
-        'RUNNER_ARCH',
-        'RUNNER_ENVIRONMENT',
-        'RUNNER_OS',
+        "GITHUB_RUN_ID",
+        "GITHUB_RUN_NUMBER",
+        "GITHUB_SERVER_URL",
+        "GITHUB_WORKFLOW_REF",
+        "RUNNER_ARCH",
+        "RUNNER_ENVIRONMENT",
+        "RUNNER_OS",
     ];
     const map = new Map();
     vars.forEach((v) => {
         let value = env[v];
-        if (value === undefined || value === '') {
+        if (value === undefined || value === "") {
             return;
         }
-        if (v === 'GITHUB_ACTION_PATH') {
-            value = value.includes('actions/')
-                ? value.replace(/^.*actions\/(.+)$/, '$1')
+        if (v === "GITHUB_ACTION_PATH") {
+            value = value.includes("actions/")
+                ? value.replace(/^.*actions\/(.+)$/, "$1")
                 : value;
         }
         map.set(v, value);

package/dist/env_file.js

@@ -1,5 +1,5 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 /**
  * Default dotenv file `env pull` writes to: `.env` when one already exists in the working
  * directory (update where secrets already live), otherwise `.env.local` — matching the
@@ -8,9 +8,9 @@ import { join } from 'node:path';
 export const resolveEnvFilePath = (cwd, file) => {
     if (file)
         return join(cwd, file);
-    if (existsSync(join(cwd, '.env')))
-        return join(cwd, '.env');
-    return join(cwd, '.env.local');
+    if (existsSync(join(cwd, ".env")))
+        return join(cwd, ".env");
+    return join(cwd, ".env.local");
 };
 /**
  * Merge `updates` into the dotenv content at `path`, preserving every other line
@@ -20,7 +20,7 @@ export const resolveEnvFilePath = (cwd, file) => {
  * `updates` is removed. Returns the keys written and the (managed) keys removed.
  */
 export const mergeEnvFile = (path, updates, options = {}) => {
-    const original = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const original = existsSync(path) ? readFileSync(path, "utf8") : "";
     const { content, written, removed } = mergeEnvContent(original, updates, options);
     writeFileSync(path, content);
     return { written, removed };
@@ -40,7 +40,7 @@ export const mergeEnvContent = (original, updates, options = {}) => {
     }
     const remaining = new Set(keys);
     const removed = [];
-    const lines = original === '' ? [] : original.split('\n');
+    const lines = original === "" ? [] : original.split("\n");
     // Walk the file: drop stale owned lines, update existing keys in place (so their position
     // and any surrounding comments are preserved), and pass everything else through untouched.
     const updatedLines = [];
@@ -62,10 +62,10 @@ export const mergeEnvContent = (original, updates, options = {}) => {
         .filter((key) => remaining.has(key))
         .map((key) => formatLine(key, updates[key]));
     const body = trimTrailingBlank(updatedLines);
-    const content = [...body, ...appended].join('\n');
+    const content = [...body, ...appended].join("\n");
     return {
         // A dotenv file ends with a trailing newline.
-        content: content === '' ? '' : `${content}\n`,
+        content: content === "" ? "" : `${content}\n`,
         written: keys,
         removed,
     };
@@ -82,7 +82,7 @@ export const readEnvFile = (path) => {
         throw new Error(`Env file not found: ${path}`);
     }
     const out = {};
-    for (const line of readFileSync(path, 'utf8').split('\n')) {
+    for (const line of readFileSync(path, "utf8").split("\n")) {
         const parsed = parseAssignment(line);
         if (parsed)
             out[parsed.key] = parsed.value;
@@ -130,7 +130,7 @@ const parseAssignment = (line) => {
 /** Strip matching surrounding quotes and unescape `\"` / `\\` inside double quotes. */
 const unquote = (value) => {
     if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
-        return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+        return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
     }
     if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
         return value.slice(1, -1);
@@ -147,13 +147,13 @@ const formatLine = (key, value) => {
     const needsQuotes = /[\s#"'=]/.test(value);
     if (!needsQuotes)
         return `${key}=${value}`;
-    const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
     return `${key}="${escaped}"`;
 };
 /** Drop trailing blank lines so we don't accumulate them across repeated merges. */
 const trimTrailingBlank = (lines) => {
     const out = [...lines];
-    while (out.length > 0 && out[out.length - 1]?.trim() === '')
+    while (out.length > 0 && out[out.length - 1]?.trim() === "")
         out.pop();
     return out;
 };

package/dist/errors.js

@@ -1,11 +1,11 @@
 const ERROR_MATCHERS = [
-    [/^Unknown command: (.*)$/, 'UNKNOWN_COMMAND'],
-    [/^Missing required argument: (.*)$/, 'MISSING_ARGUMENT'],
-    [/^Failed to open web browser. (.*)$/, 'AUTH_BROWSER_FAILED'],
+    [/^Unknown command: (.*)$/, "UNKNOWN_COMMAND"],
+    [/^Missing required argument: (.*)$/, "MISSING_ARGUMENT"],
+    [/^Failed to open web browser. (.*)$/, "AUTH_BROWSER_FAILED"],
 ];
 export const matchErrorCode = (message) => {
     if (!message) {
-        return 'UNKNOWN_ERROR';
+        return "UNKNOWN_ERROR";
     }
     for (const [matcher, code] of ERROR_MATCHERS) {
         const match = message.match(matcher);
@@ -13,5 +13,68 @@ export const matchErrorCode = (message) => {
             return code;
         }
     }
-    return 'UNKNOWN_ERROR';
+    return "UNKNOWN_ERROR";
+};
+/**
+ * The single, human-readable line shown when the CLI couldn't reach the Neon API because
+ * of a connection-level failure (DNS, refused/reset connection, offline). It replaces the
+ * cryptic `fetch failed` / empty axios message a network blip otherwise surfaces (see
+ * {@link isNetworkError}), pointing at the two things the user can actually check.
+ */
+export const NETWORK_ERROR_MESSAGE = "Could not reach the Neon API. Please check your internet connection and try again. " +
+    "If your connection is fine and this keeps happening, check https://neonstatus.com for ongoing incidents.";
+/**
+ * Node-level socket/DNS error codes that mean the request never reached the server — a
+ * genuine connectivity problem rather than an API response we should surface. Deliberately
+ * excludes `ECONNABORTED` (axios' timeout), which the CLI already reports as a timeout.
+ */
+const NETWORK_ERROR_CODES = new Set([
+    "ECONNREFUSED",
+    "ECONNRESET",
+    "ETIMEDOUT",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EHOSTDOWN",
+    "ENETDOWN",
+]);
+/**
+ * Message fragments that mark a connection-level failure across our two transports: the
+ * `@neon/sdk` / global `fetch` path (used by `env pull` / `config` / `deploy`, and `link`'s
+ * bundled env pull) throws a bare `TypeError: fetch failed` / "Failed to fetch", while the
+ * axios `api-client` path throws an `AxiosError` whose message is "Network Error".
+ */
+const NETWORK_ERROR_MESSAGE_PATTERN = /fetch failed|failed to fetch|network error/i;
+const readErrorCode = (value) => {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const code = value.code;
+    return typeof code === "string" ? code : undefined;
+};
+/**
+ * Whether `err` is a connection-level failure (the network blip the user sees as a cryptic
+ * `fetch failed`, or no message at all on the axios path) rather than an actual API response.
+ *
+ * A Node `fetch` failure is a bare `TypeError: fetch failed` whose underlying `cause` carries
+ * the real socket `code` (e.g. `ECONNREFUSED`, `ENOTFOUND`, `EAI_AGAIN`), so we walk the
+ * `cause` chain checking both the code and the message. This is what lets the CLI swap the
+ * confusing default for {@link NETWORK_ERROR_MESSAGE}. It matches only failures where no
+ * response was ever received, so it never masks a real 4xx/5xx the user needs to see.
+ */
+export const isNetworkError = (err) => {
+    let current = err;
+    for (let depth = 0; depth < 6 && current !== null && current !== undefined; depth++) {
+        const code = readErrorCode(current);
+        if (code !== undefined && NETWORK_ERROR_CODES.has(code)) {
+            return true;
+        }
+        if (current instanceof Error &&
+            NETWORK_ERROR_MESSAGE_PATTERN.test(current.message)) {
+            return true;
+        }
+        current = current.cause;
+    }
+    return false;
 };

package/dist/functions_api.js

@@ -1,42 +1,42 @@
-import { ContentType } from '@neondatabase/api-client';
+import { ContentType } from "./api.js";
 const functionsPath = (projectId, branchId) => `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/functions`;
 export const listFunctions = async (apiClient, projectId, branchId, { cursor, limit } = {}) => {
     const { data } = await apiClient.request({
         path: functionsPath(projectId, branchId),
-        method: 'GET',
+        method: "GET",
         query: { cursor, limit },
         secure: true,
-        format: 'json',
+        format: "json",
     });
     return { functions: data.functions ?? [], next: data.pagination?.next };
 };
 export const getFunction = async (apiClient, projectId, branchId, slug) => {
     const { data } = await apiClient.request({
         path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}`,
-        method: 'GET',
+        method: "GET",
         secure: true,
-        format: 'json',
+        format: "json",
     });
     return data.function;
 };
 export const deleteFunction = async (apiClient, projectId, branchId, slug) => {
     await apiClient.request({
         path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}`,
-        method: 'DELETE',
+        method: "DELETE",
         secure: true,
     });
 };
 export const createDeployment = async (apiClient, projectId, branchId, slug, params) => {
     const form = new FormData();
-    form.append('zip', new Blob([params.zip]), 'bundle.zip');
-    form.append('runtime', params.runtime);
+    form.append("zip", new Blob([params.zip]), "bundle.zip");
+    form.append("runtime", params.runtime);
     if (params.environment)
-        form.append('environment', params.environment);
+        form.append("environment", params.environment);
     // The deploy POST returns an operation the CLI cannot poll; the body is
     // ignored. We only need the request to succeed.
     await apiClient.request({
         path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}/deployments`,
-        method: 'POST',
+        method: "POST",
         type: ContentType.FormData,
         body: form,
         secure: true,