neonctl 2.28.0 → 2.29.0

package/dist/utils/api_enums.js

@@ -9,25 +9,25 @@
 // 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',
+    ReadOnly: "read_only",
+    ReadWrite: "read_write",
 };
 export const NeonAuthOauthProviderId = {
-    Google: 'google',
-    Github: 'github',
-    Microsoft: 'microsoft',
-    Vercel: 'vercel',
+    Google: "google",
+    Github: "github",
+    Microsoft: "microsoft",
+    Vercel: "vercel",
 };
 export const NeonAuthOauthProviderType = {
-    Standard: 'standard',
-    Shared: 'shared',
+    Standard: "standard",
+    Shared: "shared",
 };
 export const NeonAuthSupportedAuthProvider = {
-    Mock: 'mock',
-    Stack: 'stack',
-    BetterAuth: 'better_auth',
+    Mock: "mock",
+    Stack: "stack",
+    BetterAuth: "better_auth",
 };
 export const NeonAuthEmailVerificationMethod = {
-    Link: 'link',
-    Otp: 'otp',
+    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 './api_enums.js';
-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,6 +1,6 @@
-import { isCurrentBranchProbe } from '../context.js';
-import { looksLikeBranchId } from './formats.js';
-import { isNeonApiError, messageFromBody } from '../api.js';
+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)) {
@@ -13,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) {
@@ -35,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({
@@ -68,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,
@@ -85,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;
     }
@@ -95,7 +95,7 @@ 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
@@ -104,6 +104,11 @@ export const fillSingleProject = async (props) => {
     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 };
     }
@@ -121,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`);
@@ -135,8 +140,8 @@ export const fillSingleProject = async (props) => {
         // If the API error is about missing org_id, provide a user-friendly message
         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');
+            messageFromBody(error.data)?.includes("org_id is required")) {
+            throw new Error("Multiple projects found, please provide one with the --project-id option");
         }
         throw error;
     }
@@ -147,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;
         }
     });
 };

package/dist/utils/package_manager.js

@@ -0,0 +1,68 @@
+import { spawn } from "node:child_process";
+import which from "which";
+import { log } from "../log.js";
+// npm first so it's the default/preselected choice; the rest follow in rough
+// popularity order.
+export const PACKAGE_MANAGERS = [
+    "npm",
+    "pnpm",
+    "yarn",
+    "bun",
+];
+/**
+ * The package manager the CLI was invoked through, read from the
+ * `npm_config_user_agent` npm sets for `npm exec`/`npx`, `pnpm dlx`, `yarn
+ * dlx`, and `bunx` (so `pnpm dlx neonctl …` installs with pnpm). Returns
+ * undefined when there's nothing to infer from — e.g. a globally-installed
+ * `neon`/`neonctl` — so the caller can ask (or fall back) instead of silently
+ * assuming npm.
+ */
+export const detectPackageManager = () => {
+    const ua = process.env.npm_config_user_agent ?? "";
+    if (ua.startsWith("pnpm"))
+        return "pnpm";
+    if (ua.startsWith("yarn"))
+        return "yarn";
+    if (ua.startsWith("bun"))
+        return "bun";
+    if (ua.startsWith("npm"))
+        return "npm";
+    return undefined;
+};
+/** The package managers actually on PATH, in {@link PACKAGE_MANAGERS} order. */
+export const installedPackageManagers = () => PACKAGE_MANAGERS.filter((pm) => which.sync(pm, { nothrow: true }) !== null);
+/**
+ * Pick a package manager without prompting: the one the CLI was invoked through,
+ * else the first one installed, else npm. Used by non-interactive flows (e.g.
+ * `config init`) where there's no scaffold prompt to hang a picker off.
+ */
+export const resolvePackageManager = () => detectPackageManager() ?? installedPackageManagers()[0] ?? "npm";
+/**
+ * The argv that adds `packages` as runtime dependencies with `pm`. npm spells it
+ * `install`; pnpm/yarn/bun use `add`.
+ */
+export const addDependenciesArgs = (pm, packages) => (pm === "npm" ? ["install", ...packages] : ["add", ...packages]);
+/**
+ * Run a command inheriting our stdio so the user sees install / link output
+ * live and can answer any prompts the child raises. Resolves to whether it
+ * exited cleanly; a non-zero exit is reported but never throws — the caller
+ * decides whether to treat it as fatal.
+ */
+export const runCommand = (cmd, args, cwd) => new Promise((resolvePromise) => {
+    // npm/pnpm/yarn ship as .cmd shims on Windows, which need a shell to run.
+    const child = spawn(cmd, args, {
+        cwd,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+    });
+    child.on("error", (err) => {
+        log.warning("Could not run `%s %s`: %s", cmd, args.join(" "), err instanceof Error ? err.message : String(err));
+        resolvePromise(false);
+    });
+    child.on("close", (code) => {
+        if (code !== 0) {
+            log.warning("`%s %s` exited with code %d.", cmd, args.join(" "), code);
+        }
+        resolvePromise(code === 0);
+    });
+});

package/dist/utils/point_in_time.js

@@ -1,24 +1,24 @@
-import { looksLikeLSN, looksLikeTimestamp } from './formats.js';
-import { branchIdResolve } from './enrichers.js';
+import { branchIdResolve } from "./enrichers.js";
+import { looksLikeLSN, looksLikeTimestamp } from "./formats.js";
 export class PointInTimeParseError extends Error {
     constructor(message) {
         super(message);
-        this.name = 'PointInTimeParseError';
+        this.name = "PointInTimeParseError";
     }
 }
 export const parsePITBranch = (input) => {
-    const splitIndex = input.lastIndexOf('@');
+    const splitIndex = input.lastIndexOf("@");
     const sourceBranch = splitIndex === -1 ? input : input.slice(0, splitIndex);
     const exactPIT = splitIndex === -1 ? null : input.slice(splitIndex + 1);
     const result = {
         branch: sourceBranch,
         ...(exactPIT === null
-            ? { tag: 'head' }
+            ? { tag: "head" }
             : looksLikeLSN(exactPIT)
-                ? { tag: 'lsn', lsn: exactPIT }
-                : { tag: 'timestamp', timestamp: exactPIT }),
+                ? { tag: "lsn", lsn: exactPIT }
+                : { tag: "timestamp", timestamp: exactPIT }),
     };
-    if (result.tag === 'timestamp') {
+    if (result.tag === "timestamp") {
         const timestamp = result.timestamp;
         if (!looksLikeTimestamp(timestamp)) {
             throw new PointInTimeParseError(`Invalid source branch format - ${input}`);
@@ -31,15 +31,15 @@ export const parsePITBranch = (input) => {
 };
 export const parsePointInTime = async ({ pointInTime, targetBranchId, projectId, api, }) => {
     const parsedPIT = parsePITBranch(pointInTime);
-    let branchId = '';
-    if (parsedPIT.branch === '^self') {
+    let branchId = "";
+    if (parsedPIT.branch === "^self") {
         branchId = targetBranchId;
     }
-    else if (parsedPIT.branch === '^parent') {
+    else if (parsedPIT.branch === "^parent") {
         const { data } = await api.getProjectBranch(projectId, targetBranchId);
         const { parent_id: parentId } = data.branch;
         if (parentId == null) {
-            throw new PointInTimeParseError('Branch has no parent');
+            throw new PointInTimeParseError("Branch has no parent");
         }
         branchId = parentId;
     }