neonctl 2.27.1 → 2.29.0

package/dist/test_utils/fixtures.js

@@ -1,77 +1,110 @@
-import { fork } from 'node:child_process';
-import { join } from 'node:path';
-import { expect, test as originalTest } from 'vitest';
-import strip from 'strip-ansi';
-import emocks from 'emocks';
-import express from 'express';
-import { log } from '../log';
+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({
     // eslint-disable-next-line no-empty-pattern
     runMockServer: async ({}, use) => {
-        let server;
+        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' }),
+            app.use("/", emocks(join(process.cwd(), "mocks", mockDir), {
+                "404": (_req, res) => res.status(404).send({ message: "Not Found" }),
             }));
-            await new Promise((resolve) => {
-                server = app.listen(0, () => {
-                    resolve();
-                    log.debug('Mock server listening at %d', server.address().port);
+            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;
         });
-        await new Promise((resolve, reject) => server.close((err) => {
-            if (err) {
-                reject(err instanceof Error ? err : new Error(String(err)));
-            }
-            else {
-                resolve();
-            }
-        }));
+        // `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 server = await runMockServer(options.mockDir || 'main');
-            let output = '';
-            let error = '';
-            const cp = fork(join(process.cwd(), './dist/index.js'), [
-                '--api-host',
-                `http://localhost:${server.address().port}`,
-                '--output',
-                options.output ?? (options.outputTable ? 'table' : 'yaml'),
-                '--api-key',
-                'test-key',
-                '--no-analytics',
+            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',
+                stdio: "pipe",
+                ...(options.cwd ? { cwd: options.cwd } : {}),
                 env: {
-                    PATH: `mocks/bin:${process.env.PATH}`,
+                    PATH: `${join(process.cwd(), "mocks/bin")}:${process.env.PATH}`,
                     ...(options.env ?? {}),
                 },
             });
             return new Promise((resolve, reject) => {
-                cp.stdout?.on('data', (data) => {
+                cp.stdout?.on("data", (data) => {
                     output += data.toString();
                 });
-                cp.stderr?.on('data', (data) => {
+                cp.stderr?.on("data", (data) => {
                     error += data.toString();
                     log.error(data.toString());
                 });
-                cp.on('error', (err) => {
+                cp.on("error", (err) => {
                     log.error(err);
                     throw err;
                 });
-                cp.on('close', (code) => {
+                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, ' ')
+                            expect(strip(error).replace(/\s+/g, " ").trim()).toEqual(typeof options.stderr === "string"
+                                ? options.stderr
+                                    .toString()
+                                    .replace(/\s+/g, " ")
                                 : options.stderr);
                         }
                         resolve();

package/dist/test_utils/oauth_server.js

@@ -1,9 +1,9 @@
-import { log } from '../log';
-import { OAuth2Server } from 'oauth2-mock-server';
+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);
+    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/utils/api_enums.js

@@ -0,0 +1,33 @@
+// 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/branch_notice.js

@@ -1,5 +1,5 @@
-import chalk from 'chalk';
-import { log } from '../log.js';
+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 —
@@ -14,9 +14,9 @@ import { log } from '../log.js';
  *   `→ Planning against branch main (br-…)`.
  */
 export const announceTargetBranch = (props, branch, verb) => {
-    if (props.output === 'json' || props.output === 'yaml') {
+    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);
+    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,10 +1,10 @@
-import { EndpointType } from '@neondatabase/api-client';
-import prompts from 'prompts';
-import { retryOnLock } from '../api.js';
-import { log } from '../log.js';
-import { isCi } from '../env.js';
+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');
+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.
@@ -12,13 +12,13 @@ const CREATE_BRANCH_CHOICE = Symbol('create-branch');
 const branchLabel = (branch) => {
     const labels = [];
     if (branch.default) {
-        labels.push('[default]');
+        labels.push("[default]");
     }
     if (branch.protected) {
-        labels.push('[protected]');
+        labels.push("[protected]");
     }
     labels.push(branch.name);
-    return labels.join(' ');
+    return labels.join(" ");
 };
 /**
  * Prompt the user to pick a branch from `branches`, with a "＋ Create a new branch…" option
@@ -36,11 +36,11 @@ export const pickBranchInteractively = async (branches, opts) => {
     const defaultBranchIndex = branches.findIndex((b) => b.default);
     const initial = defaultBranchIndex >= 0 ? defaultBranchIndex + 1 : 0;
     const { choice } = await prompts({
-        type: 'select',
-        name: 'choice',
+        type: "select",
+        name: "choice",
         message: opts.message,
         choices: [
-            { title: '＋ Create a new branch…', value: CREATE_BRANCH_CHOICE },
+            { title: "＋ Create a new branch…", value: CREATE_BRANCH_CHOICE },
             ...branches.map((b) => ({
                 title: `${branchLabel(b)} (${b.id})`,
                 value: b.id,
@@ -49,12 +49,12 @@ export const pickBranchInteractively = async (branches, opts) => {
         initial,
     });
     if (choice === undefined) {
-        throw new Error('Aborted: no branch selected.');
+        throw new Error("Aborted: no branch selected.");
     }
     if (choice === CREATE_BRANCH_CHOICE) {
-        return { kind: 'create', name: await promptNewBranchName(branches) };
+        return { kind: "create", name: await promptNewBranchName(branches) };
     }
-    return { kind: 'existing', branchId: choice };
+    return { kind: "existing", branchId: choice };
 };
 /**
  * Prompt for a new branch name, rejecting empty input and names already taken on the
@@ -63,21 +63,21 @@ export const pickBranchInteractively = async (branches, opts) => {
 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:',
+        type: "text",
+        name: "name",
+        message: "New branch name:",
         validate: (value) => {
             const trimmed = value.trim();
-            if (trimmed === '')
-                return 'Branch name cannot be empty.';
+            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.');
+    const trimmed = typeof name === "string" ? name.trim() : "";
+    if (trimmed === "") {
+        throw new Error("Aborted: no branch name provided.");
     }
     return trimmed;
 };
@@ -89,15 +89,15 @@ export const promptNewBranchName = async (branches) => {
 export const createBranch = async (apiClient, projectId, name, branches) => {
     const defaultBranch = branches.find((b) => b.default);
     if (!defaultBranch) {
-        throw new Error('No default branch found');
+        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.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);
+    log.info("Created branch %s (%s).", data.branch.name, data.branch.id);
     return data.branch.id;
 };

package/dist/utils/compute_units.js

@@ -6,20 +6,20 @@ export const getComputeUnits = (autoscaling) => {
             autoscaling_limit_max_cu: fixedSizeAutoscaling,
         };
     }
-    if (!autoscaling.includes('-')) {
+    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('-');
+    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');
+        throw new Error("Autoscaling min should be a number");
     }
     if (isNaN(maxAutoscaling)) {
-        throw new Error('Autoscaling max should be a number');
+        throw new Error("Autoscaling max should be a number");
     }
     return {
         autoscaling_limit_min_cu: minAutoscaling,

package/dist/utils/enrichers.js

@@ -1,5 +1,6 @@
-import { looksLikeBranchId } from './formats.js';
-import { isAxiosError } from 'axios';
+import { isNeonApiError, messageFromBody } from "../api.js";
+import { isConfigInit, isCurrentBranchProbe } from "../context.js";
+import { looksLikeBranchId } from "./formats.js";
 export const branchIdResolve = async ({ branch, apiClient, projectId, }) => {
     branch = branch.toString();
     if (looksLikeBranchId(branch)) {
@@ -12,12 +13,12 @@ export const branchIdResolve = async ({ branch, apiClient, projectId, }) => {
     if (!branchData) {
         throw new Error(`Branch ${branch} not found.\nAvailable branches: ${data.branches
             .map((b) => b.name)
-            .join(', ')}`);
+            .join(", ")}`);
     }
     return branchData.id;
 };
 const getBranchIdFromProps = async (props) => {
-    const branch = 'branch' in props && typeof props.branch === 'string'
+    const branch = "branch" in props && typeof props.branch === "string"
         ? props.branch
         : props.id;
     if (branch) {
@@ -34,14 +35,14 @@ const getBranchIdFromProps = async (props) => {
     if (defaultBranch) {
         return defaultBranch.id;
     }
-    throw new Error('No default branch found');
+    throw new Error("No default branch found");
 };
 export const branchIdFromProps = async (props) => {
     props.branchId = await getBranchIdFromProps(props);
     return props.branchId;
 };
 export const resolveBranchRef = async (props) => {
-    const branch = 'branch' in props && typeof props.branch === 'string'
+    const branch = "branch" in props && typeof props.branch === "string"
         ? props.branch
         : props.id;
     const { data } = await props.apiClient.listProjectBranches({
@@ -67,11 +68,11 @@ export const resolveBranchRef = async (props) => {
         }
         throw new Error(`Branch ${ref} not found.\nAvailable branches: ${branches
             .map((b) => b.name)
-            .join(', ')}`);
+            .join(", ")}`);
     }
     const defaultBranch = branches.find((b) => b.default);
     if (!defaultBranch) {
-        throw new Error('No default branch found');
+        throw new Error("No default branch found");
     }
     return {
         branchId: defaultBranch.id,
@@ -84,7 +85,7 @@ export const resolveSingleDatabase = async (props) => {
     const databases = data.databases;
     if (props.database !== undefined) {
         if (!databases.find((d) => d.name === props.database)) {
-            throw new Error(`Database not found: ${props.database}. Available databases on branch ${props.branchId}: ${databases.map((d) => d.name).join(', ')}`);
+            throw new Error(`Database not found: ${props.database}. Available databases on branch ${props.branchId}: ${databases.map((d) => d.name).join(", ")}`);
         }
         return props.database;
     }
@@ -94,9 +95,20 @@ export const resolveSingleDatabase = async (props) => {
     if (databases.length === 1) {
         return databases[0].name;
     }
-    throw new Error(`Multiple databases found for the branch, please provide one with the --database option: ${databases.map((d) => d.name).join(', ')}`);
+    throw new Error(`Multiple databases found for the branch, please provide one with the --database option: ${databases.map((d) => d.name).join(", ")}`);
 };
 export const fillSingleProject = async (props) => {
+    // The offline `--current-branch` probe needs no project at all and runs with no
+    // API client (auth was skipped), so resolving a single project here would both
+    // hit the network and dereference a null client. Skip it entirely.
+    if (isCurrentBranchProbe(props)) {
+        return props;
+    }
+    // `config init` is purely local (scaffold + npm install) and runs with no API
+    // client, so resolving a single project here would dereference a null client.
+    if (isConfigInit(props)) {
+        return props;
+    }
     if (props.projectId) {
         return { ...props, projectId: props.projectId };
     }
@@ -114,7 +126,7 @@ export const fillSingleProject = async (props) => {
             org_id: orgId,
         });
         if (data.projects.length === 0) {
-            throw new Error('No projects found');
+            throw new Error("No projects found");
         }
         if (data.projects.length > 1) {
             throw new Error(`Multiple projects found, please provide one with the --project-id option`);
@@ -126,10 +138,10 @@ export const fillSingleProject = async (props) => {
     }
     catch (error) {
         // If the API error is about missing org_id, provide a user-friendly message
-        if (isAxiosError(error) &&
-            error.response?.status === 400 &&
-            error.response?.data?.message?.includes('org_id is required')) {
-            throw new Error('Multiple projects found, please provide one with the --project-id option');
+        if (isNeonApiError(error) &&
+            error.status === 400 &&
+            messageFromBody(error.data)?.includes("org_id is required")) {
+            throw new Error("Multiple projects found, please provide one with the --project-id option");
         }
         throw error;
     }
@@ -140,7 +152,7 @@ export const fillSingleOrg = async (props) => {
     }
     const { data } = await props.apiClient.getCurrentUserOrganizations();
     if (data.organizations.length === 0) {
-        throw new Error('No organizations found');
+        throw new Error("No organizations found");
     }
     if (data.organizations.length > 1) {
         throw new Error(`Multiple organizations found, please provide one with the --org-id option`);

package/dist/utils/esbuild.js

@@ -1,11 +1,11 @@
-import { spawn } from 'node:child_process';
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { basename, join } from 'node:path';
-import which from 'which';
-const NOT_FOUND = 'esbuild not found. neonctl ships esbuild for most platforms; if you see ' +
-    'this, install esbuild and ensure it is on your PATH (e.g. `npm i -g ' +
-    'esbuild`), or set NEON_ESBUILD_PATH to an esbuild binary.';
+import { spawn } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import which from "which";
+const NOT_FOUND = "esbuild not found. neonctl ships esbuild for most platforms; if you see " +
+    "this, install esbuild and ensure it is on your PATH (e.g. `npm i -g " +
+    "esbuild`), or set NEON_ESBUILD_PATH to an esbuild binary.";
 // Prepended to the ESM bundle. Bundled dependencies are frequently CommonJS, but an ESM
 // output (`--format=esm`) has no `require` / `__filename` / `__dirname` in scope — so any
 // bundled CJS code that calls `require(...)` would fail at load with
@@ -39,7 +39,7 @@ const bundleViaModule = async (source, loadEsbuild) => {
     // to the binary path), so keeping this specifier invisible to the scanners is
     // what keeps esbuild out of the snapshot.
     // Do NOT "simplify" this back to import('esbuild').
-    const name = ['es', 'build'].join('');
+    const name = ["es", "build"].join("");
     let esbuild;
     try {
         esbuild = await loadEsbuild(name);
@@ -57,16 +57,16 @@ const bundleViaModule = async (source, loadEsbuild) => {
         // Emit `index.mjs` (not `out.js`): the Functions runtime imports the archive's entry
         // by the conventional `index.{js,mjs}` name, and `.mjs` makes Node treat the ESM
         // output as a module without needing a `package.json` type marker alongside it.
-        outfile: 'index.mjs',
+        outfile: "index.mjs",
         write: false,
         minify: true,
-        format: 'esm',
-        platform: 'node',
+        format: "esm",
+        platform: "node",
         // Bundle dependencies into the entry so the deployed archive is self-contained (the
         // Functions runtime has no node_modules). Node built-ins stay external on
         // platform:'node'. The banner re-creates require/__filename/__dirname for bundled CJS.
         banner: { js: ESM_CJS_INTEROP_BANNER },
-        logLevel: 'silent',
+        logLevel: "silent",
     })
         .catch((err) => {
         throw new Error(`Failed to bundle function from ${source}. ${message(err)}`.trim());
@@ -90,12 +90,12 @@ const resolveEsbuild = () => {
             return override;
         throw new Error(NOT_FOUND);
     }
-    const onPath = which.sync('esbuild', { nothrow: true });
+    const onPath = which.sync("esbuild", { nothrow: true });
     if (onPath)
         return onPath;
     // CWD-relative (not install-relative): helps the dev checkout where esbuild is
     // a devDependency. In `npm i -g` and pkg installs the PATH branch above wins.
-    const local = join(process.cwd(), 'node_modules', '.bin', 'esbuild');
+    const local = join(process.cwd(), "node_modules", ".bin", "esbuild");
     if (existsSync(local))
         return local;
     throw new Error(NOT_FOUND);
@@ -103,30 +103,30 @@ const resolveEsbuild = () => {
 const runEsbuild = (bin, args) => new Promise((resolve, reject) => {
     // stderr is captured (NOT inherited): with --log-level=error a success emits
     // nothing, and a failure's diagnostic is read out below. Never use 'inherit'.
-    const child = spawn(bin, args, { stdio: ['ignore', 'ignore', 'pipe'] });
-    let stderr = '';
-    child.stderr.on('data', (chunk) => {
+    const child = spawn(bin, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
         stderr += chunk.toString();
     });
-    child.on('error', reject);
-    child.on('close', (code) => {
+    child.on("error", reject);
+    child.on("close", (code) => {
         resolve({ code, stderr });
     });
 });
 const bundleViaBinary = async (source) => {
     const bin = resolveEsbuild();
-    const outDir = mkdtempSync(join(tmpdir(), 'neon-fn-bundle-'));
-    const outfile = join(outDir, 'index.mjs');
+    const outDir = mkdtempSync(join(tmpdir(), "neon-fn-bundle-"));
+    const outfile = join(outDir, "index.mjs");
     try {
         const { code, stderr } = await runEsbuild(bin, [
             source,
-            '--bundle',
+            "--bundle",
             `--outfile=${outfile}`,
-            '--minify',
-            '--format=esm',
-            '--platform=node',
+            "--minify",
+            "--format=esm",
+            "--platform=node",
             `--banner:js=${ESM_CJS_INTEROP_BANNER}`,
-            '--log-level=error',
+            "--log-level=error",
         ]);
         if (code !== 0) {
             throw new Error(`Failed to bundle function from ${source}. ${stderr.trim()}`.trim());
@@ -134,7 +134,7 @@ const bundleViaBinary = async (source) => {
         // No `--sourcemap`: the Functions runtime has no source-map support, so an uploaded
         // `index.mjs.map` is never consumed — emitting it only inflated the archive.
         return {
-            'index.mjs': new Uint8Array(readFileSync(outfile)),
+            "index.mjs": new Uint8Array(readFileSync(outfile)),
         };
     }
     finally {

package/dist/utils/formats.js

@@ -1,5 +1,5 @@
 const HAIKU_REGEX = /^[a-z0-9]+-[a-z0-9]+-[a-z0-9]+$/;
-export const looksLikeBranchId = (branch) => branch.startsWith('br-') && HAIKU_REGEX.test(branch.substring(3));
+export const looksLikeBranchId = (branch) => branch.startsWith("br-") && HAIKU_REGEX.test(branch.substring(3));
 const LSN_REGEX = /^[a-fA-F0-9]{1,8}\/[a-fA-F0-9]{1,8}$/;
 export const looksLikeLSN = (lsn) => LSN_REGEX.test(lsn);
 export const looksLikeTimestamp = (timestamp) => {

package/dist/utils/middlewares.js

@@ -5,16 +5,16 @@
  */
 export const fillInArgs = (args, currentArgs = args, acc = []) => {
     Object.entries(currentArgs).forEach(([k, v]) => {
-        if (k === '_' || k === '--') {
+        if (k === "_" || k === "--") {
             return;
         }
         // check if the value is an Object
-        if (typeof v === 'object' && v !== null) {
+        if (typeof v === "object" && v !== null) {
             fillInArgs(args, v, [...acc, k]);
         }
         else if (acc.length > 0) {
             // if it's not an object, and we have a path, fill it in
-            args[acc.join('.') + '.' + k] = v;
+            args[acc.join(".") + "." + k] = v;
         }
     });
 };