neonctl 2.23.1 → 2.24.1

package/psql/print/aligned.js

@@ -16,28 +16,28 @@ import { formatNumericLocale } from './units.js';
 // East-Asian wide / fullwidth ranges from Unicode Standard Annex #11.
 // Trimmed to the ranges psql's `ucs_wcwidth` considers width 2.
 const WIDE_RANGES = [
-    [0x1100, 0x115f],
-    [0x2329, 0x232a],
-    [0x2e80, 0x303e],
-    [0x3041, 0x33ff],
-    [0x3400, 0x4dbf],
-    [0x4e00, 0x9fff],
-    [0xa000, 0xa4cf],
-    [0xac00, 0xd7a3],
-    [0xf900, 0xfaff],
-    [0xfe10, 0xfe19],
-    [0xfe30, 0xfe6f],
-    [0xff00, 0xff60],
-    [0xffe0, 0xffe6],
-    [0x1f300, 0x1f64f],
-    [0x1f900, 0x1f9ff],
-    [0x20000, 0x2fffd],
+    [0x1100, 0x115f], // Hangul Jamo
+    [0x2329, 0x232a], // Angle brackets
+    [0x2e80, 0x303e], // CJK Radicals, Kangxi, ...
+    [0x3041, 0x33ff], // Hiragana, Katakana, Bopomofo, etc.
+    [0x3400, 0x4dbf], // CJK Unified Ideographs Extension A
+    [0x4e00, 0x9fff], // CJK Unified Ideographs
+    [0xa000, 0xa4cf], // Yi Syllables
+    [0xac00, 0xd7a3], // Hangul Syllables
+    [0xf900, 0xfaff], // CJK Compatibility Ideographs
+    [0xfe10, 0xfe19], // Vertical forms
+    [0xfe30, 0xfe6f], // CJK Compatibility Forms, Small Form Variants
+    [0xff00, 0xff60], // Fullwidth Forms
+    [0xffe0, 0xffe6], // Fullwidth signs
+    [0x1f300, 0x1f64f], // Misc Symbols & Pictographs, Emoticons
+    [0x1f900, 0x1f9ff], // Supplemental Symbols & Pictographs
+    [0x20000, 0x2fffd], // CJK Extension B..F
     [0x30000, 0x3fffd], // CJK Extension G
 ];
 // Combining marks: width 0. From Unicode general categories Mn/Me/Cf
 // and the zero-width controls upstream treats as width 0.
 const ZERO_RANGES = [
-    [0x0300, 0x036f],
+    [0x0300, 0x036f], // Combining Diacritical Marks
     [0x0483, 0x0489],
     [0x0591, 0x05bd],
     [0x05bf, 0x05bf],
@@ -190,7 +190,7 @@ const ZERO_RANGES = [
     [0x1cf8, 0x1cf9],
     [0x1dc0, 0x1df9],
     [0x1dfb, 0x1dff],
-    [0x200b, 0x200f],
+    [0x200b, 0x200f], // zero-width space, ZWNJ, ZWJ, LRM, RLM
     [0x202a, 0x202e],
     [0x2060, 0x206f],
     [0x20d0, 0x20f0],
@@ -233,9 +233,9 @@ const ZERO_RANGES = [
     [0xabe8, 0xabe8],
     [0xabed, 0xabed],
     [0xfb1e, 0xfb1e],
-    [0xfe00, 0xfe0f],
-    [0xfe20, 0xfe2f],
-    [0xfeff, 0xfeff],
+    [0xfe00, 0xfe0f], // variation selectors
+    [0xfe20, 0xfe2f], // combining half-marks
+    [0xfeff, 0xfeff], // BOM
     [0xfff9, 0xfffb],
     [0x101fd, 0x101fd],
     [0x102e0, 0x102e0],
@@ -342,15 +342,15 @@ export const padToWidth = (text, width, alignment) => {
 // divergences — we previously right-aligned interval & pg_lsn and omitted
 // xid & cid).
 const RIGHT_ALIGNED_OIDS = new Set([
-    20,
-    21,
-    23,
-    26,
-    28,
-    29,
-    700,
-    701,
-    790,
+    20, // int8
+    21, // int2
+    23, // int4
+    26, // oid
+    28, // xid
+    29, // cid
+    700, // float4
+    701, // float8
+    790, // money (cash)
     1700, // numeric
 ]);
 const isRightAlignedField = (oid) => RIGHT_ALIGNED_OIDS.has(oid);

package/psql/print/json.js

@@ -22,11 +22,11 @@
 // PostgreSQL type OIDs for the numeric family that map cleanly to
 // JSON numbers. NUMERIC is included but guarded by isFinite().
 const NUMERIC_TYPE_OIDS = new Set([
-    21,
-    23,
-    20,
-    700,
-    701,
+    21, // INT2
+    23, // INT4
+    20, // INT8
+    700, // FLOAT4
+    701, // FLOAT8
     1700, // NUMERIC
 ]);
 export const jsonPrinter = {

package/psql/scanner/sql.js

@@ -142,10 +142,10 @@ const cloneState = (s) => ({
 // blocks, dollar-quoted bodies). Identifier letters are stored lower-cased.
 // ---------------------------------------------------------------------------
 const KEYWORD_PREFIX_LETTERS = new Set([
-    'c',
-    'f',
-    'p',
-    'o',
+    'c', // create
+    'f', // function
+    'p', // procedure
+    'o', // or
     'r', // replace
 ]);
 const PREFIX_MATCHES_CREATE_FN_OR_PROC = (letters) => {

package/storage_api.js

@@ -0,0 +1,114 @@
+// 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 the
+// published `@neondatabase/api-client` package, so the request/response types
+// and the thin call helpers live here. They are implemented on top of the
+// api-client's public `request()` method, which means they reuse the exact
+// same authentication, base URL, headers and retry behaviour as every other
+// neonctl command. When the generated client 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,
+});

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 });