neonctl 1.13.0 → 1.15.0

package/api.js

@@ -1,7 +1,15 @@
 import { createApiClient } from '@neondatabase/api-client';
 import { isAxiosError } from 'axios';
 import { log } from './log.js';
-export const getApiClient = ({ apiKey, apiHost }) => createApiClient({ apiKey, baseURL: apiHost, timeout: 10000 });
+import pkg from './pkg.js';
+export const getApiClient = ({ apiKey, apiHost }) => createApiClient({
+    apiKey,
+    baseURL: apiHost,
+    timeout: 10000,
+    headers: {
+        'User-Agent': `neonctl v${pkg.version}`,
+    },
+});
 const RETRY_COUNT = 5;
 const RETRY_DELAY = 3000;
 export const retryOnLock = async (fn) => {

package/auth.js

@@ -23,7 +23,7 @@ custom.setHttpOptionsDefaults({
     timeout: SERVER_TIMEOUT,
 });
 export const refreshToken = async ({ oauthHost, clientId }, tokenSet) => {
-    log.info('Discovering oauth server');
+    log.debug('Discovering oauth server');
     const issuer = await Issuer.discover(oauthHost);
     const neonOAuthClient = new issuer.Client({
         token_endpoint_auth_method: 'none',
@@ -33,7 +33,7 @@ export const refreshToken = async ({ oauthHost, clientId }, tokenSet) => {
     return await neonOAuthClient.refresh(tokenSet);
 };
 export const auth = async ({ oauthHost, clientId }) => {
-    log.info('Discovering oauth server');
+    log.debug('Discovering oauth server');
     const issuer = await Issuer.discover(oauthHost);
     //
     // Start HTTP server and wait till /callback is hit
@@ -64,7 +64,7 @@ export const auth = async ({ oauthHost, clientId }) => {
                 response.end();
                 return;
             }
-            log.info(`Callback received: ${request.url}`);
+            log.debug(`Callback received: ${request.url}`);
             const params = neonOAuthClient.callbackParams(request);
             const tokenSet = await neonOAuthClient.callback(REDIRECT_URI(listen_port), params, {
                 code_verifier: codeVerifier,

package/commands/auth.js

@@ -7,6 +7,7 @@ import { getApiClient } from '../api.js';
 import { isCi } from '../env.js';
 const CREDENTIALS_FILE = 'credentials.json';
 export const command = 'auth';
+export const aliases = ['login'];
 export const describe = 'Authenticate';
 export const builder = (yargs) => yargs;
 export const handler = async (args) => {
@@ -52,7 +53,7 @@ export const ensureAuth = async (props) => {
             const tokenSetContents = await JSON.parse(readFileSync(credentialsPath, 'utf8'));
             const tokenSet = new TokenSet(tokenSetContents);
             if (tokenSet.expired()) {
-                log.info('using refresh token to update access token');
+                log.debug('using refresh token to update access token');
                 const refreshedTokenSet = await refreshToken({
                     oauthHost: props.oauthHost,
                     clientId: props.clientId,

package/commands/branches.js

@@ -1,8 +1,10 @@
+import { EndpointType } from '@neondatabase/api-client';
 import { writer } from '../writer.js';
-import { branchCreateRequest, branchCreateRequestEndpointOptions, } from '../parameters.gen.js';
-import { commandFailHandler } from '../utils.js';
+import { branchCreateRequest } from '../parameters.gen.js';
+import { commandFailHandler } from '../utils/middlewares.js';
 import { retryOnLock } from '../api.js';
-import { branchIdFromProps } from '../enrichers.js';
+import { branchIdFromProps, fillSingleProject } from '../utils/enrichers.js';
+import { looksLikeBranchId, looksLikeLSN, looksLikeTimestamp, } from '../utils/formats.js';
 const BRANCH_FIELDS = ['id', 'name', 'created_at', 'updated_at'];
 export const command = 'branches';
 export const describe = 'Manage branches';
@@ -12,39 +14,88 @@ export const builder = (argv) => argv
     .fail(commandFailHandler)
     .usage('usage: $0 branches <sub-command> [options]')
     .options({
-    'project.id': {
+    '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,
-    ...Object.fromEntries(Object.entries(branchCreateRequestEndpointOptions).map(([key, value]) => [`endpoint.${key}`, { ...value, demandOption: false }])),
-}), async (args) => await create(args))
-    .command('update <id|name>', 'Update a branch', (yargs) => yargs.options({
-    'branch.name': {
-        describe: 'Branch name',
+    name: branchCreateRequest['branch.name'],
+    parent: {
+        describe: 'Parent branch name or id or timestamp or LSN. Defaults to the primary branch',
         type: 'string',
-        demandOption: true,
     },
-}), async (args) => await update(args))
+    endpoint: {
+        describe: 'Create a branch with or without an endpoint. By default branch is created with a read-write endpoint. To create a branch without endpoint use --no-endpoint',
+        type: 'boolean',
+        default: true,
+    },
+    readonly: {
+        describe: 'Create a read-only branch',
+        type: 'boolean',
+        implies: 'endpoint',
+    },
+}), async (args) => await create(args))
+    .command('rename <id|name> <new-name>', 'Rename a branch', (yargs) => yargs, async (args) => await rename(args))
     .command('delete <id|name>', 'Delete a branch', (yargs) => yargs, async (args) => await deleteBranch(args))
     .command('get <id|name>', 'Get a branch', (yargs) => yargs, async (args) => await get(args));
 export const handler = (args) => {
     return args;
 };
 const list = async (props) => {
-    const { data } = await props.apiClient.listProjectBranches(props.project.id);
+    const { data } = await props.apiClient.listProjectBranches(props.projectId);
     writer(props).end(data.branches, {
         fields: BRANCH_FIELDS,
     });
 };
 const create = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.createProjectBranch(props.project.id, {
-        branch: props.branch,
-        endpoints: props.endpoint ? [props.endpoint] : undefined,
+    const parentProps = await (() => {
+        if (!props.parent) {
+            return props.apiClient
+                .listProjectBranches(props.projectId)
+                .then(({ data }) => {
+                const branch = data.branches.find((b) => b.primary);
+                if (!branch) {
+                    throw new Error('No primary branch found');
+                }
+                return { parent_id: branch.id };
+            });
+        }
+        if (looksLikeLSN(props.parent)) {
+            return { parent_lsn: props.parent };
+        }
+        if (looksLikeTimestamp(props.parent)) {
+            return { parent_timestamp: props.parent };
+        }
+        if (looksLikeBranchId(props.parent)) {
+            return { parent_id: props.parent };
+        }
+        return props.apiClient
+            .listProjectBranches(props.projectId)
+            .then(({ data }) => {
+            const branch = data.branches.find((b) => b.name === props.parent);
+            if (!branch) {
+                throw new Error(`Branch ${props.parent} not found`);
+            }
+            return { parent_id: branch.id };
+        });
+    })();
+    const { data } = await retryOnLock(() => props.apiClient.createProjectBranch(props.projectId, {
+        branch: {
+            name: props.name,
+            ...parentProps,
+        },
+        endpoints: props.endpoint
+            ? [
+                {
+                    type: props.readonly
+                        ? EndpointType.ReadOnly
+                        : EndpointType.ReadWrite,
+                },
+            ]
+            : [],
     }));
     const out = writer(props);
     out.write(data.branch, {
@@ -65,10 +116,12 @@ const create = async (props) => {
     }
     out.end();
 };
-const update = async (props) => {
+const rename = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const { data } = await retryOnLock(() => props.apiClient.updateProjectBranch(props.project.id, branchId, {
-        branch: props.branch,
+    const { data } = await retryOnLock(() => props.apiClient.updateProjectBranch(props.projectId, branchId, {
+        branch: {
+            name: props.newName,
+        },
     }));
     writer(props).end(data.branch, {
         fields: BRANCH_FIELDS,
@@ -76,14 +129,14 @@ const update = async (props) => {
 };
 const deleteBranch = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranch(props.project.id, branchId));
+    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranch(props.projectId, branchId));
     writer(props).end(data.branch, {
         fields: BRANCH_FIELDS,
     });
 };
 const get = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const { data } = await props.apiClient.getProjectBranch(props.project.id, branchId);
+    const { data } = await props.apiClient.getProjectBranch(props.projectId, branchId);
     writer(props).end(data.branch, {
         fields: BRANCH_FIELDS,
     });

package/commands/branches.test.js

@@ -3,22 +3,35 @@ import { testCliCommand } from '../test_utils.js';
 describe('branches', () => {
     testCliCommand({
         name: 'list',
-        args: ['branches', 'list', '--project.id', 'test'],
+        args: ['branches', 'list', '--project-id', 'test'],
         expected: {
             snapshot: true,
         },
     });
     testCliCommand({
-        name: 'create with endpoint',
+        name: 'create by default with r/w endpoint',
         args: [
             'branches',
             'create',
-            '--project.id',
+            '--project-id',
             'test',
-            '--branch.name',
+            '--name',
             'test_branch',
-            '--endpoint.type',
-            'read_only',
+        ],
+        expected: {
+            snapshot: true,
+        },
+    });
+    testCliCommand({
+        name: 'create with readonly endpoint',
+        args: [
+            'branches',
+            'create',
+            '--project-id',
+            'test',
+            '--name',
+            'test_branch',
+            '--readonly',
         ],
         expected: {
             snapshot: true,
@@ -29,10 +42,59 @@ describe('branches', () => {
         args: [
             'branches',
             'create',
-            '--project.id',
+            '--project-id',
             'test',
-            '--branch.name',
+            '--name',
             'test_branch',
+            '--no-endpoint',
+        ],
+        expected: {
+            snapshot: true,
+        },
+    });
+    testCliCommand({
+        name: 'create with parent by name',
+        args: [
+            'branches',
+            'create',
+            '--project-id',
+            'test',
+            '--name',
+            'test_branch_with_parent_name',
+            '--parent',
+            'main',
+        ],
+        expected: {
+            snapshot: true,
+        },
+    });
+    testCliCommand({
+        name: 'create with parent by lsn',
+        args: [
+            'branches',
+            'create',
+            '--project-id',
+            'test',
+            '--name',
+            'test_branch_with_parent_lsn',
+            '--parent',
+            '0/123ABC',
+        ],
+        expected: {
+            snapshot: true,
+        },
+    });
+    testCliCommand({
+        name: 'create with parent by timestamp',
+        args: [
+            'branches',
+            'create',
+            '--project-id',
+            'test',
+            '--name',
+            'test_branch_with_parent_timestamp',
+            '--parent',
+            '2021-01-01T00:00:00.000Z',
         ],
         expected: {
             snapshot: true,
@@ -44,7 +106,7 @@ describe('branches', () => {
             'branches',
             'delete',
             'br-sunny-branch-123456',
-            '--project.id',
+            '--project-id',
             'test',
         ],
         expected: {
@@ -52,15 +114,14 @@ describe('branches', () => {
         },
     });
     testCliCommand({
-        name: 'update',
+        name: 'rename',
         args: [
             'branches',
-            'update',
+            'rename',
             'test_branch',
-            '--project.id',
-            'test',
-            '--branch.name',
             'new_test_branch',
+            '--project-id',
+            'test',
         ],
         expected: {
             snapshot: true,
@@ -68,14 +129,14 @@ describe('branches', () => {
     });
     testCliCommand({
         name: 'get by id',
-        args: ['branches', 'get', 'br-sunny-branch-123456', '--project.id', 'test'],
+        args: ['branches', 'get', 'br-sunny-branch-123456', '--project-id', 'test'],
         expected: {
             snapshot: true,
         },
     });
     testCliCommand({
         name: 'get by name',
-        args: ['branches', 'get', 'test_branch', '--project.id', 'test'],
+        args: ['branches', 'get', 'test_branch', '--project-id', 'test'],
         expected: {
             snapshot: true,
         },

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 '../utils/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({
-        'project.id': {
+    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': {
+        'role-name': {
             type: 'string',
             describe: 'Role name',
-            demandOption: true,
         },
-        'database.name': {
+        'database-name': {
             type: 'string',
             describe: 'Database name',
-            demandOption: true,
         },
         pooled: {
             type: 'boolean',
@@ -30,22 +33,61 @@ export const builder = (argv) => {
             describe: 'Use connection string for Prisma setup',
             default: false,
         },
-    });
+        'endpoint-type': {
+            type: 'string',
+            choices: Object.values(EndpointType),
+            describe: 'Endpoint type',
+        },
+    })
+        .middleware(fillSingleProject);
 };
 export const handler = async (props) => {
+    const projectId = props.projectId;
     const branchId = await branchIdFromProps(props);
-    const { data: { endpoints }, } = await props.apiClient.listProjectBranchEndpoints(props.project.id, branchId);
-    const endpoint = endpoints.find((e) => e.type === EndpointType.ReadWrite);
+    const { data: { endpoints }, } = await props.apiClient.listProjectBranchEndpoints(projectId, branchId);
+    const matchEndpointType = props.endpointType ?? EndpointType.ReadWrite;
+    let endpoint = endpoints.find((e) => e.type === matchEndpointType);
+    if (!endpoint && props.endpointType == null) {
+        endpoint = endpoints[0];
+    }
     if (!endpoint) {
-        throw new Error(`No endpoint found for the branch: ${branchId}`);
+        throw new Error(`No ${props.endpointType ?? ''} 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.roleName ||
+        (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.databaseName ||
+        (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
+                .map((d) => d.name)
+                .join(', ')}`);
+        }));
+    const { data: password } = await props.apiClient.getProjectBranchRolePassword(props.projectId, 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

@@ -6,11 +6,11 @@ describe('connection_string', () => {
         args: [
             'connection-string',
             'test_branch',
-            '--project.id',
+            '--project-id',
             'test',
-            '--database.name',
+            '--database-name',
             'test_db',
-            '--role.name',
+            '--role-name',
             'test_role',
         ],
         expected: {
@@ -22,11 +22,11 @@ describe('connection_string', () => {
         args: [
             'connection-string',
             'test_branch',
-            '--project.id',
+            '--project-id',
             'test',
-            '--database.name',
+            '--database-name',
             'test_db',
-            '--role.name',
+            '--role-name',
             'test_role',
             '--pooled',
         ],
@@ -39,11 +39,11 @@ describe('connection_string', () => {
         args: [
             'connection-string',
             'test_branch',
-            '--project.id',
+            '--project-id',
             'test',
-            '--database.name',
+            '--database-name',
             'test_db',
-            '--role.name',
+            '--role-name',
             'test_role',
             '--prisma',
         ],
@@ -56,11 +56,11 @@ describe('connection_string', () => {
         args: [
             'connection-string',
             'test_branch',
-            '--project.id',
+            '--project-id',
             'test',
-            '--database.name',
+            '--database-name',
             'test_db',
-            '--role.name',
+            '--role-name',
             'test_role',
             '--prisma',
             '--pooled',
@@ -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,7 +1,6 @@
 import { retryOnLock } from '../api.js';
-import { branchIdFromProps } from '../enrichers.js';
-import { databaseCreateRequest } from '../parameters.gen.js';
-import { commandFailHandler } from '../utils.js';
+import { branchIdFromProps, fillSingleProject } from '../utils/enrichers.js';
+import { commandFailHandler } from '../utils/middlewares.js';
 import { writer } from '../writer.js';
 const DATABASE_FIELDS = ['name', 'owner_name', 'created_at'];
 export const command = 'databases';
@@ -12,34 +11,63 @@ export const builder = (argv) => argv
     .fail(commandFailHandler)
     .usage('usage: $0 databases <sub-command> [options]')
     .options({
-    'project.id': {
+    '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('create', 'Create a database', (yargs) => yargs.options({
+    name: {
+        describe: 'Database name',
+        type: 'string',
+        demandOption: true,
+    },
+    'owner-name': {
+        describe: 'Owner name',
+        type: 'string',
+    },
+}), async (args) => await create(args))
     .command('delete <database>', 'Delete a database', (yargs) => yargs, async (args) => await deleteDb(args));
 export const handler = (args) => {
     return args;
 };
 export const list = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const { data } = await props.apiClient.listProjectBranchDatabases(props.project.id, branchId);
+    const { data } = await props.apiClient.listProjectBranchDatabases(props.projectId, branchId);
     writer(props).end(data.databases, {
         fields: DATABASE_FIELDS,
     });
 };
 export const create = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const { data } = await retryOnLock(() => props.apiClient.createProjectBranchDatabase(props.project.id, branchId, {
-        database: props.database,
+    const owner = props.ownerName ??
+        (await props.apiClient
+            .listProjectBranchRoles(props.projectId, branchId)
+            .then(({ data }) => {
+            if (data.roles.length === 0) {
+                throw new Error(`No roles found in branch ${branchId}`);
+            }
+            if (data.roles.length > 1) {
+                throw new Error(`More than one role found in branch ${branchId}. Please specify the owner name. Roles: ${data.roles
+                    .map((r) => r.name)
+                    .join(', ')}`);
+            }
+            return data.roles[0].name;
+        }));
+    if (!owner) {
+        throw new Error('No owner found');
+    }
+    const { data } = await retryOnLock(() => props.apiClient.createProjectBranchDatabase(props.projectId, branchId, {
+        database: {
+            name: props.name,
+            owner_name: owner,
+        },
     }));
     writer(props).end(data.database, {
         fields: DATABASE_FIELDS,
@@ -47,7 +75,7 @@ export const create = async (props) => {
 };
 export const deleteDb = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranchDatabase(props.project.id, branchId, props.database));
+    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranchDatabase(props.projectId, branchId, props.database));
     writer(props).end(data.database, {
         fields: DATABASE_FIELDS,
     });

package/commands/databases.test.js

@@ -6,7 +6,7 @@ describe('databases', () => {
         args: [
             'databases',
             'list',
-            '--project.id',
+            '--project-id',
             'test',
             '--branch',
             'test_branch',
@@ -20,13 +20,13 @@ describe('databases', () => {
         args: [
             'databases',
             'create',
-            '--project.id',
+            '--project-id',
             'test',
             '--branch',
             'test_branch',
-            '--database.name',
+            '--name',
             'test_db',
-            '--database.owner_name',
+            '--owner-name',
             'test_owner',
         ],
         expected: {
@@ -39,7 +39,7 @@ describe('databases', () => {
             'databases',
             'delete',
             'test_db',
-            '--project.id',
+            '--project-id',
             'test',
             '--branch',
             'test_branch',

package/commands/operations.js

@@ -1,4 +1,5 @@
-import { commandFailHandler } from '../utils.js';
+import { fillSingleProject } from '../utils/enrichers.js';
+import { commandFailHandler } from '../utils/middlewares.js';
 import { writer } from '../writer.js';
 const OPERATIONS_FIELDS = ['id', 'action', 'status', 'created_at'];
 export const command = 'operations';
@@ -9,19 +10,19 @@ export const builder = (argv) => argv
     .fail(commandFailHandler)
     .usage('usage: $0 operations <sub-command> [options]')
     .options({
-    'project.id': {
+    '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;
 };
 export const list = async (props) => {
     const { data } = await props.apiClient.listProjectOperations({
-        projectId: props.project.id,
+        projectId: props.projectId,
         limit: props.limit,
     });
     writer(props).end(data.operations, {

package/commands/operations.test.js

@@ -3,7 +3,7 @@ import { testCliCommand } from '../test_utils.js';
 describe('operations', () => {
     testCliCommand({
         name: 'list',
-        args: ['operations', 'list', '--project.id', 'test'],
+        args: ['operations', 'list', '--project-id', 'test'],
         expected: {
             snapshot: true,
         },

package/commands/projects.js

@@ -1,7 +1,14 @@
 import { projectCreateRequest } from '../parameters.gen.js';
-import { commandFailHandler } from '../utils.js';
+import { commandFailHandler } from '../utils/middlewares.js';
 import { writer } from '../writer.js';
 const PROJECT_FIELDS = ['id', 'name', 'region_id', 'created_at'];
+const REGIONS = [
+    'aws-us-west-2',
+    'aws-ap-southeast-1',
+    'aws-eu-central-1',
+    'aws-us-east-2',
+    'aws-us-east-1',
+];
 export const command = 'projects';
 export const describe = 'Manage projects';
 export const aliases = ['project'];
@@ -13,10 +20,24 @@ export const builder = (argv) => {
         .command('list', 'List projects', (yargs) => yargs, async (args) => {
         await list(args);
     })
-        .command('create', 'Create a project', (yargs) => yargs.options(projectCreateRequest), async (args) => {
+        .command('create', 'Create a project', (yargs) => yargs.options({
+        name: {
+            describe: projectCreateRequest['project.name'].description,
+            type: 'string',
+        },
+        'region-id': {
+            describe: `The region ID. Possible values: ${REGIONS.join(', ')}`,
+            type: 'string',
+        },
+    }), async (args) => {
         await create(args);
     })
-        .command('update <id>', 'Update a project', (yargs) => yargs.options(projectCreateRequest), async (args) => {
+        .command('update <id>', 'Update a project', (yargs) => yargs.options({
+        name: {
+            describe: projectCreateRequest['project.name'].description,
+            type: 'string',
+        },
+    }), async (args) => {
         await update(args);
     })
         .command('delete <id>', 'Delete a project', (yargs) => yargs, async (args) => {
@@ -34,20 +55,20 @@ const list = async (props) => {
     writer(props).end(data.projects, { fields: PROJECT_FIELDS });
 };
 const create = async (props) => {
-    if (props.project == null) {
-        props.project = {};
-        const inquirer = await import('inquirer');
-        const answers = await inquirer.default.prompt([
-            { name: 'name', message: 'Project name (optional)', type: 'input' },
-        ]);
-        if (answers.name) {
-            props.project = answers;
-        }
+    const project = {};
+    if (props.name) {
+        project.name = props.name;
+    }
+    if (props.regionId) {
+        project.region_id = props.regionId;
     }
     const { data } = await props.apiClient.createProject({
-        project: props.project,
+        project,
     });
-    writer(props).end(data.project, { fields: PROJECT_FIELDS });
+    const out = writer(props);
+    out.write(data.project, { fields: PROJECT_FIELDS });
+    out.write(data.connection_uris, { fields: ['connection_uri'] });
+    out.end();
 };
 const deleteProject = async (props) => {
     const { data } = await props.apiClient.deleteProject(props.id);
@@ -57,7 +78,9 @@ const deleteProject = async (props) => {
 };
 const update = async (props) => {
     const { data } = await props.apiClient.updateProject(props.id, {
-        project: props.project,
+        project: {
+            name: props.name,
+        },
     });
     writer(props).end(data.project, { fields: PROJECT_FIELDS });
 };

package/commands/projects.test.js

@@ -10,7 +10,7 @@ describe('projects', () => {
     });
     testCliCommand({
         name: 'create',
-        args: ['projects', 'create', '--project.name', 'test_project'],
+        args: ['projects', 'create', '--name', 'test_project'],
         expected: {
             snapshot: true,
         },
@@ -24,7 +24,7 @@ describe('projects', () => {
     });
     testCliCommand({
         name: 'update',
-        args: ['projects', 'update', 'test', '--project.name', 'test_project'],
+        args: ['projects', 'update', 'test', '--name', 'test_project'],
         expected: {
             snapshot: true,
         },

package/commands/roles.js

@@ -1,7 +1,6 @@
 import { retryOnLock } from '../api.js';
-import { branchIdFromProps } from '../enrichers.js';
-import { roleCreateRequest } from '../parameters.gen.js';
-import { commandFailHandler } from '../utils.js';
+import { branchIdFromProps, fillSingleProject } from '../utils/enrichers.js';
+import { commandFailHandler } from '../utils/middlewares.js';
 import { writer } from '../writer.js';
 const ROLES_FIELDS = ['name', 'created_at'];
 export const command = 'roles';
@@ -12,34 +11,41 @@ export const builder = (argv) => argv
     .fail(commandFailHandler)
     .usage('usage: $0 roles <sub-command> [options]')
     .options({
-    'project.id': {
+    '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('create', 'Create a role', (yargs) => yargs.options({
+    name: {
+        describe: 'Role name',
+        type: 'string',
+        demandOption: true,
+    },
+}), async (args) => await create(args))
     .command('delete <role>', 'Delete a role', (yargs) => yargs, async (args) => await deleteRole(args));
 export const handler = (args) => {
     return args;
 };
 export const list = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const { data } = await props.apiClient.listProjectBranchRoles(props.project.id, branchId);
+    const { data } = await props.apiClient.listProjectBranchRoles(props.projectId, branchId);
     writer(props).end(data.roles, {
         fields: ROLES_FIELDS,
     });
 };
 export const create = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const { data } = await retryOnLock(() => props.apiClient.createProjectBranchRole(props.project.id, branchId, {
-        role: props.role,
+    const { data } = await retryOnLock(() => props.apiClient.createProjectBranchRole(props.projectId, branchId, {
+        role: {
+            name: props.name,
+        },
     }));
     writer(props).end(data.role, {
         fields: ROLES_FIELDS,
@@ -47,7 +53,7 @@ export const create = async (props) => {
 };
 export const deleteRole = async (props) => {
     const branchId = await branchIdFromProps(props);
-    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranchRole(props.project.id, branchId, props.role));
+    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranchRole(props.projectId, branchId, props.role));
     writer(props).end(data.role, {
         fields: ROLES_FIELDS,
     });

package/commands/roles.test.js

@@ -3,7 +3,7 @@ import { testCliCommand } from '../test_utils.js';
 describe('roles', () => {
     testCliCommand({
         name: 'list',
-        args: ['roles', 'list', '--project.id', 'test', '--branch', 'test_branch'],
+        args: ['roles', 'list', '--project-id', 'test', '--branch', 'test_branch'],
         expected: {
             snapshot: true,
         },
@@ -13,11 +13,11 @@ describe('roles', () => {
         args: [
             'roles',
             'create',
-            '--project.id',
+            '--project-id',
             'test',
             '--branch',
             'test_branch',
-            '--role.name',
+            '--name',
             'test_role',
         ],
         expected: {
@@ -30,7 +30,7 @@ describe('roles', () => {
             'roles',
             'delete',
             'test_role',
-            '--project.id',
+            '--project-id',
             'test',
             '--branch',
             'test_branch',

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

@@ -16,7 +16,7 @@ import { ensureAuth } from './commands/auth.js';
 import { defaultDir, ensureConfigDir } from './config.js';
 import { log } from './log.js';
 import { defaultClientID } from './auth.js';
-import { fillInArgs } from './utils.js';
+import { fillInArgs } from './utils/middlewares.js';
 import pkg from './pkg.js';
 import commands from './commands/index.js';
 import { analyticsMiddleware } from './analytics.js';
@@ -29,6 +29,7 @@ builder = builder
     .help()
     .option('output', {
     alias: 'o',
+    group: 'Global options:',
     describe: 'Set output format',
     type: 'string',
     choices: ['json', 'yaml', 'table'],
@@ -42,6 +43,7 @@ builder = builder
     // Setup config directory
     .option('config-dir', {
     describe: 'Path to config directory',
+    group: 'Global options:',
     type: 'string',
     default: defaultDir,
 })
@@ -60,6 +62,7 @@ builder = builder
 })
     .option('api-key', {
     describe: 'API key',
+    group: 'Global options:',
     type: 'string',
     default: process.env.NEON_API_KEY ?? '',
 })
@@ -74,14 +77,22 @@ builder = builder
     .strictCommands()
     .option('analytics', {
     describe: 'Manage analytics. Example: --no-analytics, --analytics false',
+    group: 'Global options:',
     type: 'boolean',
     default: !isCi(),
 })
     .middleware(analyticsMiddleware)
+    .group('version', 'Global options:')
+    .alias('version', 'v')
+    .group('help', 'Global options:')
+    .alias('help', 'h')
     .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 +102,7 @@ builder = builder
     else {
         log.error(msg || err?.message);
     }
+    err?.stack && log.debug('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 = {
+    debug: (...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.15.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) {

package/utils/enrichers.js

@@ -0,0 +1,48 @@
+import { looksLikeBranchId } from './formats.js';
+export const branchIdResolve = async ({ branch, apiClient, projectId, }) => {
+    if (looksLikeBranchId(branch)) {
+        return branch;
+    }
+    const { data } = await apiClient.listProjectBranches(projectId);
+    const branchData = data.branches.find((b) => b.name === branch);
+    if (!branchData) {
+        throw new Error(`Branch ${branch} not found.\nAvailable branches: ${data.branches
+            .map((b) => b.name)
+            .join(', ')}`);
+    }
+    return branchData.id;
+};
+export const branchIdFromProps = async (props) => {
+    const branch = 'branch' in props && typeof props.branch === 'string'
+        ? props.branch
+        : props.id;
+    if (branch) {
+        return await branchIdResolve({
+            branch,
+            apiClient: props.apiClient,
+            projectId: props.projectId,
+        });
+    }
+    const { data } = await props.apiClient.listProjectBranches(props.projectId);
+    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.projectId) {
+        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,
+        projectId: data.projects[0].id,
+    };
+};

package/utils/formats.js

@@ -0,0 +1,5 @@
+const HAIKU_REGEX = /^[a-z]+-[a-z]+-\d{6}$/;
+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) => !isNaN(Date.parse(timestamp));

package/enrichers.js

@@ -1,19 +0,0 @@
-const HAIKU_REGEX = /^[a-z]+-[a-z]+-\d{6}$/;
-export const branchIdResolve = async ({ branch, apiClient, projectId, }) => {
-    if (branch.startsWith('br-') && HAIKU_REGEX.test(branch.substring(3))) {
-        return branch;
-    }
-    const { data } = await apiClient.listProjectBranches(projectId);
-    const branchData = data.branches.find((b) => b.name === branch);
-    if (!branchData) {
-        throw new Error(`Branch ${branch} not found`);
-    }
-    return branchData.id;
-};
-export const branchIdFromProps = async (props) => branchIdResolve({
-    branch: 'branch' in props && typeof props.branch === 'string'
-        ? props.branch
-        : props.id,
-    apiClient: props.apiClient,
-    projectId: props.project.id,
-});