neonctl 2.24.0 → 2.24.1

package/utils/branch_picker.js

@@ -0,0 +1,88 @@
+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';
+/** Sentinel `value` for the "create a new branch" choice (no branch id can collide). */
+const CREATE_BRANCH_CHOICE = Symbol('create-branch');
+/**
+ * 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: `${b.default ? '✱ ' : ''}${b.name} (${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/utils/esbuild.js

@@ -48,7 +48,10 @@ const bundleViaModule = async (source, loadEsbuild) => {
         .build({
         entryPoints: [source],
         bundle: true,
-        outfile: 'out.js',
+        // 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',
         write: false,
         sourcemap: true,
         minify: true,
@@ -61,7 +64,7 @@ const bundleViaModule = async (source, loadEsbuild) => {
         throw new Error(`Failed to bundle function from ${source}. ${message(err)}`.trim());
     });
     const files = result.outputFiles ?? [];
-    // write:false with one entry always yields out.js + out.js.map; an empty set
+    // write:false with one entry always yields index.mjs + index.mjs.map; an empty set
     // means the API contract changed under us — fail loud rather than ship an
     // empty archive.
     if (files.length === 0) {
@@ -105,7 +108,7 @@ const runEsbuild = (bin, args) => new Promise((resolve, reject) => {
 const bundleViaBinary = async (source) => {
     const bin = resolveEsbuild();
     const outDir = mkdtempSync(join(tmpdir(), 'neon-fn-bundle-'));
-    const outfile = join(outDir, 'out.js');
+    const outfile = join(outDir, 'index.mjs');
     try {
         const { code, stderr } = await runEsbuild(bin, [
             source,
@@ -122,8 +125,8 @@ const bundleViaBinary = async (source) => {
             throw new Error(`Failed to bundle function from ${source}. ${stderr.trim()}`.trim());
         }
         return {
-            'out.js': new Uint8Array(readFileSync(outfile)),
-            'out.js.map': new Uint8Array(readFileSync(`${outfile}.map`)),
+            'index.mjs': new Uint8Array(readFileSync(outfile)),
+            'index.mjs.map': new Uint8Array(readFileSync(`${outfile}.map`)),
         };
     }
     finally {

package/utils/zip.js

@@ -1,4 +1,4 @@
 import { zipSync } from 'fflate';
-// Zip the esbuild output (out.js + out.js.map) into the archive the Functions
+// Zip the esbuild output (index.mjs + index.mjs.map) into the archive the Functions
 // deploy endpoint expects. Compression level 6 matches the previous bundler.
 export const zipBundle = (entries) => zipSync(entries, { level: 6 });