neonctl 2.24.2 → 2.25.0

package/commands/functions.js

@@ -21,6 +21,23 @@ const DEPLOYMENT_FIELDS = [
     'memory_mib',
     'created_at',
 ];
+// Deploy emits the resolved deployment plus the function's invocation_url, so a
+// successful `functions deploy` tells the user exactly where to call the function.
+const DEPLOY_RESULT_FIELDS = [
+    'id',
+    'status',
+    'invocation_url',
+    'runtime',
+    'memory_mib',
+    'created_at',
+];
+// In table mode a failed build's reason gets its own "deployment error"
+// section after the deployment table; json/yaml carry the raw `error` field.
+const writeDeploymentErrorSection = (out, dep) => {
+    if (dep.status === 'failed' && dep.error) {
+        out.write({ reason: dep.error }, { fields: ['reason'], title: 'deployment error' });
+    }
+};
 const SLUG_PATTERN = /^[a-z0-9]{1,20}$/;
 const SLUG_HELP = 'Use 1-20 lowercase letters and digits (no hyphens or other characters).';
 // Overridable so tests can poll fast; defaults to 2s in real use.
@@ -77,10 +94,19 @@ export const builder = (argv) => argv
     },
 }), (args) => deploy(args))
     .command('list', 'List functions on the branch', (yargs) => yargs, (args) => list(args))
-    .command('get <slug>', "Show a function's details", (yargs) => yargs.positional('slug', {
+    .command('get <slug>', "Show a function's details", (yargs) => yargs
+    .positional('slug', {
     describe: 'Function slug',
     type: 'string',
     demandOption: true,
+})
+    .options({
+    'list-env-variables': {
+        describe: 'List the environment variable names of the active deployment',
+        type: 'boolean',
+        alias: 'E',
+        default: false,
+    },
 }), (args) => get(args))
     .command('delete <slug>', 'Delete a function on the branch', (yargs) => yargs.positional('slug', {
     describe: 'Function slug',
@@ -104,6 +130,15 @@ const parseEnv = (entries) => {
     return JSON.stringify(map);
 };
 const statusHint = (slug, projectId, branchId) => `Check status with: neonctl functions get ${slug} --project-id ${projectId} --branch ${branchId}`;
+// Emit the resolved deployment together with the function's invocation_url, so the
+// deploy output shows where the function is reachable (not just the deployment id).
+const emitDeployResult = (props, deployment, fn) => {
+    const out = writer(props).write({ ...deployment, invocation_url: fn?.invocation_url }, { fields: DEPLOY_RESULT_FIELDS });
+    if (props.output !== 'json' && props.output !== 'yaml') {
+        writeDeploymentErrorSection(out, deployment);
+    }
+    out.end();
+};
 // A poll error worth retrying: a network error (no HTTP response), a 5xx, or a
 // 404 from eventual consistency. Anything else (e.g. 401/403) is surfaced.
 const isTransient = (err) => isAxiosError(err) &&
@@ -165,6 +200,9 @@ const deploy = async (props) => {
     // any version if there was none). --no-wait stops there; --wait stops at a
     // terminal status. Bounded by POLL_TIMEOUT_MS so it never hangs.
     let resolved;
+    // The function carries the invocation_url; keep the whole record (not just its
+    // active_deployment) so we can surface that URL on success.
+    let resolvedFn;
     const deadline = Date.now() + POLL_TIMEOUT_MS;
     try {
         while (!interrupted && Date.now() < deadline) {
@@ -173,18 +211,20 @@ const deploy = async (props) => {
                 break;
             // The deploy already succeeded server-side; tolerate transient poll
             // failures and retry on the next interval. Surface anything else.
-            let dep;
+            let fn;
             try {
-                dep = (await getFunction(props.apiClient, props.projectId, branchId, props.slug)).active_deployment;
+                fn = await getFunction(props.apiClient, props.projectId, branchId, props.slug);
             }
             catch (err) {
                 if (isTransient(err))
                     continue;
                 throw err;
             }
+            const dep = fn.active_deployment;
             const isNew = dep !== undefined && (before === undefined || dep.id > before);
             if (isNew && dep) {
                 resolved = dep;
+                resolvedFn = fn;
                 if (!props.wait)
                     break;
                 if (dep.status === 'completed' || dep.status === 'failed')
@@ -199,14 +239,14 @@ const deploy = async (props) => {
     if (interrupted) {
         log.info(statusHint(props.slug, props.projectId, branchId));
         if (resolved)
-            writer(props).end(resolved, { fields: DEPLOYMENT_FIELDS });
+            emitDeployResult(props, resolved, resolvedFn);
         return;
     }
     if (resolved === undefined) {
         log.info(statusHint(props.slug, props.projectId, branchId));
         throw new Error(`Timed out waiting for the deployment of ${props.slug} to start. It may still be in progress.`);
     }
-    writer(props).end(resolved, { fields: DEPLOYMENT_FIELDS });
+    emitDeployResult(props, resolved, resolvedFn);
     if (!props.wait) {
         log.info(statusHint(props.slug, props.projectId, branchId));
         return;
@@ -238,6 +278,14 @@ const get = async (props) => {
             fields: DEPLOYMENT_FIELDS,
             title: 'active deployment',
         });
+        writeDeploymentErrorSection(out, fn.active_deployment);
+    }
+    if (props.listEnvVariables) {
+        out.write((fn.active_deployment?.environment ?? []).map((name) => ({ name })), {
+            fields: ['name'],
+            title: 'environment',
+            emptyMessage: 'No environment variables on the active deployment.',
+        });
     }
     out.end();
 };

package/commands/index.js

@@ -22,6 +22,7 @@ import * as config from './config.js';
 import * as deploy from './deploy.js';
 import * as env from './env.js';
 import * as bucket from './bucket.js';
+import * as bootstrap from './bootstrap.js';
 export default [
     auth,
     users,
@@ -47,4 +48,5 @@ export default [
     deploy,
     env,
     bucket,
+    bootstrap,
 ];