neonctl 1.13.0 → 1.14.0

package/commands/branches.js

@@ -2,7 +2,7 @@ import { writer } from '../writer.js';
 import { branchCreateRequest, branchCreateRequestEndpointOptions, } from '../parameters.gen.js';
 import { commandFailHandler } from '../utils.js';
 import { retryOnLock } from '../api.js';
-import { branchIdFromProps } from '../enrichers.js';
+import { branchIdFromProps, fillSingleProject } from '../enrichers.js';
 const BRANCH_FIELDS = ['id', 'name', 'created_at', 'updated_at'];
 export const command = 'branches';
 export const describe = 'Manage branches';
@@ -15,9 +15,9 @@ export const builder = (argv) => argv
     'project.id': {
         describe: 'Project ID',
         type: 'string',
-        demandOption: true,
     },
 })
+    .middleware(fillSingleProject)
     .command('list', 'List branches', (yargs) => yargs, async (args) => await list(args))
     .command('create', 'Create a branch', (yargs) => yargs.options({
     ...branchCreateRequest,

package/commands/connection_string.js

@@ -1,24 +1,27 @@
 import { EndpointType } from '@neondatabase/api-client';
-import { branchIdFromProps } from '../enrichers.js';
-export const command = 'connection-string <branch>';
+import { branchIdFromProps, fillSingleProject } from '../enrichers.js';
+export const command = 'connection-string [branch]';
 export const aliases = ['cs'];
 export const describe = 'Get connection string';
 export const builder = (argv) => {
-    return argv.usage('usage: $0 connection-string <branch> [options]').options({
+    return argv
+        .usage('usage: $0 connection-string [branch] [options]')
+        .positional('branch', {
+        describe: 'Branch name or id. If ommited will use the primary branch',
+        type: 'string',
+    })
+        .options({
         'project.id': {
             type: 'string',
             describe: 'Project ID',
-            demandOption: true,
         },
         'role.name': {
             type: 'string',
             describe: 'Role name',
-            demandOption: true,
         },
         'database.name': {
             type: 'string',
             describe: 'Database name',
-            demandOption: true,
         },
         pooled: {
             type: 'boolean',
@@ -30,22 +33,50 @@ export const builder = (argv) => {
             describe: 'Use connection string for Prisma setup',
             default: false,
         },
-    });
+    })
+        .middleware(fillSingleProject);
 };
 export const handler = async (props) => {
+    const projectId = props.project.id;
     const branchId = await branchIdFromProps(props);
-    const { data: { endpoints }, } = await props.apiClient.listProjectBranchEndpoints(props.project.id, branchId);
+    const { data: { endpoints }, } = await props.apiClient.listProjectBranchEndpoints(projectId, branchId);
     const endpoint = endpoints.find((e) => e.type === EndpointType.ReadWrite);
     if (!endpoint) {
         throw new Error(`No endpoint found for the branch: ${branchId}`);
     }
-    const { data: password } = await props.apiClient.getProjectBranchRolePassword(props.project.id, endpoint.branch_id, props.role.name);
+    const role = props.role?.name ||
+        (await props.apiClient
+            .listProjectBranchRoles(projectId, branchId)
+            .then(({ data }) => {
+            if (data.roles.length === 0) {
+                throw new Error(`No roles found for the branch: ${branchId}`);
+            }
+            if (data.roles.length === 1) {
+                return data.roles[0].name;
+            }
+            throw new Error(`Multiple roles found for the branch, please provide one with the --role.name option: ${data.roles
+                .map((r) => r.name)
+                .join(', ')}`);
+        }));
+    const database = props.database?.name ||
+        (await props.apiClient
+            .listProjectBranchDatabases(projectId, branchId)
+            .then(({ data }) => {
+            if (data.databases.length === 0) {
+                throw new Error(`No databases found for the branch: ${branchId}`);
+            }
+            if (data.databases.length === 1) {
+                return data.databases[0].name;
+            }
+            throw new Error(`Multiple databases found for the branch, please provide one with the --database.name option: ${data.databases}`);
+        }));
+    const { data: password } = await props.apiClient.getProjectBranchRolePassword(props.project.id, endpoint.branch_id, role);
     const host = props.pooled
         ? endpoint.host.replace(endpoint.id, `${endpoint.id}-pooler`)
         : endpoint.host;
     const connectionString = new URL(`postgres://${host}`);
-    connectionString.pathname = props.database.name;
-    connectionString.username = props.role.name;
+    connectionString.pathname = database;
+    connectionString.username = role;
     connectionString.password = password.password;
     if (props.prisma) {
         connectionString.searchParams.set('connect_timeout', '30');

package/commands/connection_string.test.js

@@ -69,4 +69,12 @@ describe('connection_string', () => {
             snapshot: true,
         },
     });
+    testCliCommand({
+        name: 'connection_string without any args should pass',
+        args: ['connection-string'],
+        mockDir: 'single_project',
+        expected: {
+            snapshot: true,
+        },
+    });
 });

package/commands/databases.js

@@ -1,5 +1,5 @@
 import { retryOnLock } from '../api.js';
-import { branchIdFromProps } from '../enrichers.js';
+import { branchIdFromProps, fillSingleProject } from '../enrichers.js';
 import { databaseCreateRequest } from '../parameters.gen.js';
 import { commandFailHandler } from '../utils.js';
 import { writer } from '../writer.js';
@@ -15,14 +15,13 @@ export const builder = (argv) => argv
     'project.id': {
         describe: 'Project ID',
         type: 'string',
-        demandOption: true,
     },
     branch: {
         describe: 'Branch ID or name',
         type: 'string',
-        demandOption: true,
     },
 })
+    .middleware(fillSingleProject)
     .command('list', 'List databases', (yargs) => yargs, async (args) => await list(args))
     .command('create', 'Create a database', (yargs) => yargs.options(databaseCreateRequest), async (args) => await create(args))
     .command('delete <database>', 'Delete a database', (yargs) => yargs, async (args) => await deleteDb(args));

package/commands/operations.js

@@ -1,3 +1,4 @@
+import { fillSingleProject } from '../enrichers.js';
 import { commandFailHandler } from '../utils.js';
 import { writer } from '../writer.js';
 const OPERATIONS_FIELDS = ['id', 'action', 'status', 'created_at'];
@@ -12,9 +13,9 @@ export const builder = (argv) => argv
     'project.id': {
         describe: 'Project ID',
         type: 'string',
-        demandOption: true,
     },
 })
+    .middleware(fillSingleProject)
     .command('list', 'List operations', (yargs) => yargs, async (args) => await list(args));
 export const handler = (args) => {
     return args;

package/commands/roles.js

@@ -1,5 +1,5 @@
 import { retryOnLock } from '../api.js';
-import { branchIdFromProps } from '../enrichers.js';
+import { branchIdFromProps, fillSingleProject } from '../enrichers.js';
 import { roleCreateRequest } from '../parameters.gen.js';
 import { commandFailHandler } from '../utils.js';
 import { writer } from '../writer.js';
@@ -15,14 +15,13 @@ export const builder = (argv) => argv
     'project.id': {
         describe: 'Project ID',
         type: 'string',
-        demandOption: true,
     },
     branch: {
         describe: 'Branch ID or name',
         type: 'string',
-        demandOption: true,
     },
 })
+    .middleware(fillSingleProject)
     .command('list', 'List roles', (yargs) => yargs, async (args) => await list(args))
     .command('create', 'Create a role', (yargs) => yargs.options(roleCreateRequest), async (args) => await create(args))
     .command('delete <role>', 'Delete a role', (yargs) => yargs, async (args) => await deleteRole(args));

package/enrichers.js

@@ -6,14 +6,43 @@ export const branchIdResolve = async ({ branch, apiClient, projectId, }) => {
     const { data } = await apiClient.listProjectBranches(projectId);
     const branchData = data.branches.find((b) => b.name === branch);
     if (!branchData) {
-        throw new Error(`Branch ${branch} not found`);
+        throw new Error(`Branch ${branch} not found.\nAvailable branches: ${data.branches
+            .map((b) => b.name)
+            .join(', ')}`);
     }
     return branchData.id;
 };
-export const branchIdFromProps = async (props) => branchIdResolve({
-    branch: 'branch' in props && typeof props.branch === 'string'
+export const branchIdFromProps = async (props) => {
+    const branch = 'branch' in props && typeof props.branch === 'string'
         ? props.branch
-        : props.id,
-    apiClient: props.apiClient,
-    projectId: props.project.id,
-});
+        : props.id;
+    if (branch) {
+        return await branchIdResolve({
+            branch,
+            apiClient: props.apiClient,
+            projectId: props.project.id,
+        });
+    }
+    const { data } = await props.apiClient.listProjectBranches(props.project.id);
+    const primaryBranch = data.branches.find((b) => b.primary);
+    if (primaryBranch) {
+        return primaryBranch.id;
+    }
+    throw new Error('No primary branch found');
+};
+export const fillSingleProject = async (props) => {
+    if (props.project) {
+        return props;
+    }
+    const { data } = await props.apiClient.listProjects({});
+    if (data.projects.length === 0) {
+        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`);
+    }
+    return {
+        ...props,
+        project: { id: data.projects[0].id },
+    };
+};

package/env.js

@@ -1,3 +1,6 @@
 export const isCi = () => {
     return process.env.CI !== 'false' && Boolean(process.env.CI);
 };
+export const isDebug = () => {
+    return Boolean(process.env.DEBUG);
+};

package/index.js

@@ -81,7 +81,10 @@ builder = builder
     .completion()
     .fail(async (msg, err) => {
     if (isAxiosError(err)) {
-        if (err.response?.status === 401) {
+        if (err.code === 'ECONNABORTED') {
+            log.error('Request timed out');
+        }
+        else if (err.response?.status === 401) {
             log.error('Authentication failed, please run `neonctl auth`');
         }
         else {
@@ -91,6 +94,7 @@ builder = builder
     else {
         log.error(msg || err?.message);
     }
+    err.stack && log.degug('Stack: %s', err.stack);
     process.exit(1);
 });
 (async () => {

package/log.js

@@ -1,5 +1,11 @@
 import { format } from 'node:util';
+import { isDebug } from './env.js';
 export const log = {
+    degug: (...args) => {
+        if (isDebug()) {
+            process.stderr.write(`DEBUG: ${format(...args)}\n`);
+        }
+    },
     info: (...args) => {
         process.stderr.write(`INFO: ${format(...args)}\n`);
     },

package/package.json

@@ -5,7 +5,7 @@
     "url": "git@github.com:neondatabase/neonctl.git"
   },
   "type": "module",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "CLI tool for NeonDB Cloud management",
   "main": "index.js",
   "author": "NeonDB",

package/test_utils.js

@@ -4,21 +4,21 @@ import emocks from 'emocks';
 import express from 'express';
 import { fork } from 'node:child_process';
 import { join } from 'node:path';
-const runMockServer = async () => new Promise((resolve) => {
+const runMockServer = async (mockDir) => new Promise((resolve) => {
     const app = express();
     app.use(express.json());
-    app.use('/', emocks(join(process.cwd(), 'mocks')));
+    app.use('/', emocks(join(process.cwd(), 'mocks', mockDir)));
     const server = app.listen(0);
     server.on('listening', () => {
         console.log(`Mock server listening at ${server.address().port}`);
     });
     resolve(server);
 });
-export const testCliCommand = ({ args, name, expected, }) => {
+export const testCliCommand = ({ args, name, expected, mockDir = 'main', }) => {
     let server;
     describe(name, () => {
         beforeAll(async () => {
-            server = await runMockServer();
+            server = await runMockServer(mockDir);
         });
         afterAll(async () => {
             return new Promise((resolve) => {
@@ -53,6 +53,9 @@ export const testCliCommand = ({ args, name, expected, }) => {
                 });
                 cp.on('close', (code) => {
                     try {
+                        if (code !== 0 && error) {
+                            console.error(error);
+                        }
                         expect(code).toBe(0);
                         if (code === 0 && expected) {
                             if (expected.snapshot) {