neonctl 1.12.0 → 1.14.0

package/commands/branches.js

@@ -1,7 +1,8 @@
 import { writer } from '../writer.js';
-import { branchCreateRequest, branchCreateRequestEndpointOptions, branchUpdateRequest, } from '../parameters.gen.js';
+import { branchCreateRequest, branchCreateRequestEndpointOptions, } from '../parameters.gen.js';
 import { commandFailHandler } from '../utils.js';
 import { retryOnLock } from '../api.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';
@@ -14,29 +15,23 @@ 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,
     ...Object.fromEntries(Object.entries(branchCreateRequestEndpointOptions).map(([key, value]) => [`endpoint.${key}`, { ...value, demandOption: false }])),
 }), async (args) => await create(args))
-    .command('update', 'Update a branch', (yargs) => yargs.options(branchUpdateRequest).option('branch.id', {
-    describe: 'Branch ID',
-    type: 'string',
-    demandOption: true,
+    .command('update <id|name>', 'Update a branch', (yargs) => yargs.options({
+    'branch.name': {
+        describe: 'Branch name',
+        type: 'string',
+        demandOption: true,
+    },
 }), async (args) => await update(args))
-    .command('delete', 'Delete a branch', (yargs) => yargs.option('branch.id', {
-    describe: 'Branch ID',
-    type: 'string',
-    demandOption: true,
-}), async (args) => await deleteBranch(args))
-    .command('get', 'Get a branch', (yargs) => yargs.option('branch.id', {
-    describe: 'Branch ID',
-    type: 'string',
-    demandOption: true,
-}), async (args) => await get(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;
 };
@@ -71,7 +66,8 @@ const create = async (props) => {
     out.end();
 };
 const update = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.updateProjectBranch(props.project.id, props.branch.id, {
+    const branchId = await branchIdFromProps(props);
+    const { data } = await retryOnLock(() => props.apiClient.updateProjectBranch(props.project.id, branchId, {
         branch: props.branch,
     }));
     writer(props).end(data.branch, {
@@ -79,13 +75,15 @@ const update = async (props) => {
     });
 };
 const deleteBranch = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranch(props.project.id, props.branch.id));
+    const branchId = await branchIdFromProps(props);
+    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranch(props.project.id, branchId));
     writer(props).end(data.branch, {
         fields: BRANCH_FIELDS,
     });
 };
 const get = async (props) => {
-    const { data } = await props.apiClient.getProjectBranch(props.project.id, props.branch.id);
+    const branchId = await branchIdFromProps(props);
+    const { data } = await props.apiClient.getProjectBranch(props.project.id, branchId);
     writer(props).end(data.branch, {
         fields: BRANCH_FIELDS,
     });

package/commands/branches.test.js

@@ -39,14 +39,13 @@ describe('branches', () => {
         },
     });
     testCliCommand({
-        name: 'delete',
+        name: 'delete by id',
         args: [
             'branches',
             'delete',
+            'br-sunny-branch-123456',
             '--project.id',
             'test',
-            '--branch.id',
-            'test_branch_id',
         ],
         expected: {
             snapshot: true,
@@ -57,10 +56,9 @@ describe('branches', () => {
         args: [
             'branches',
             'update',
+            'test_branch',
             '--project.id',
             'test',
-            '--branch.id',
-            'test_branch_id',
             '--branch.name',
             'new_test_branch',
         ],
@@ -69,15 +67,15 @@ describe('branches', () => {
         },
     });
     testCliCommand({
-        name: 'get',
-        args: [
-            'branches',
-            'get',
-            '--project.id',
-            'test',
-            '--branch.id',
-            'test_branch_id',
-        ],
+        name: 'get by id',
+        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'],
         expected: {
             snapshot: true,
         },

package/commands/connection_string.js

@@ -1,27 +1,27 @@
-export const command = 'connection-string';
+import { EndpointType } from '@neondatabase/api-client';
+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 [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,
-        },
-        'endpoint.id': {
-            type: 'string',
-            describe: 'Endpoint ID',
-            demandOption: true,
         },
         'role.name': {
             type: 'string',
             describe: 'Role name',
-            demandOption: true,
         },
         'database.name': {
             type: 'string',
             describe: 'Database name',
-            demandOption: true,
         },
         pooled: {
             type: 'boolean',
@@ -33,17 +33,50 @@ export const builder = (argv) => {
             describe: 'Use connection string for Prisma setup',
             default: false,
         },
-    });
+    })
+        .middleware(fillSingleProject);
 };
 export const handler = async (props) => {
-    const { data: { endpoint }, } = await props.apiClient.getProjectEndpoint(props.project.id, props.endpoint.id);
-    const { data: password } = await props.apiClient.getProjectBranchRolePassword(props.project.id, endpoint.branch_id, props.role.name);
+    const projectId = props.project.id;
+    const branchId = await branchIdFromProps(props);
+    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 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

@@ -5,10 +5,9 @@ describe('connection_string', () => {
         name: 'connection_string',
         args: [
             'connection-string',
+            'test_branch',
             '--project.id',
             'test',
-            '--endpoint.id',
-            'test_endpoint_id',
             '--database.name',
             'test_db',
             '--role.name',
@@ -22,10 +21,9 @@ describe('connection_string', () => {
         name: 'connection_string pooled',
         args: [
             'connection-string',
+            'test_branch',
             '--project.id',
             'test',
-            '--endpoint.id',
-            'test_endpoint_id',
             '--database.name',
             'test_db',
             '--role.name',
@@ -40,10 +38,9 @@ describe('connection_string', () => {
         name: 'connection_string prisma',
         args: [
             'connection-string',
+            'test_branch',
             '--project.id',
             'test',
-            '--endpoint.id',
-            'test_endpoint_id',
             '--database.name',
             'test_db',
             '--role.name',
@@ -58,10 +55,9 @@ describe('connection_string', () => {
         name: 'connection_string prisma pooled',
         args: [
             'connection-string',
+            'test_branch',
             '--project.id',
             'test',
-            '--endpoint.id',
-            'test_endpoint_id',
             '--database.name',
             'test_db',
             '--role.name',
@@ -73,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,4 +1,5 @@
 import { retryOnLock } from '../api.js';
+import { branchIdFromProps, fillSingleProject } from '../enrichers.js';
 import { databaseCreateRequest } from '../parameters.gen.js';
 import { commandFailHandler } from '../utils.js';
 import { writer } from '../writer.js';
@@ -14,34 +15,29 @@ export const builder = (argv) => argv
     'project.id': {
         describe: 'Project ID',
         type: 'string',
-        demandOption: true,
     },
-    'branch.id': {
-        describe: 'Branch ID',
+    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', 'Delete a database', (yargs) => yargs.options({
-    'database.name': {
-        describe: 'Database name',
-        type: 'string',
-        demandOption: true,
-    },
-}), async (args) => await deleteDb(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 { data } = await props.apiClient.listProjectBranchDatabases(props.project.id, props.branch.id);
+    const branchId = await branchIdFromProps(props);
+    const { data } = await props.apiClient.listProjectBranchDatabases(props.project.id, branchId);
     writer(props).end(data.databases, {
         fields: DATABASE_FIELDS,
     });
 };
 export const create = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.createProjectBranchDatabase(props.project.id, props.branch.id, {
+    const branchId = await branchIdFromProps(props);
+    const { data } = await retryOnLock(() => props.apiClient.createProjectBranchDatabase(props.project.id, branchId, {
         database: props.database,
     }));
     writer(props).end(data.database, {
@@ -49,7 +45,8 @@ export const create = async (props) => {
     });
 };
 export const deleteDb = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranchDatabase(props.project.id, props.branch.id, props.database.name));
+    const branchId = await branchIdFromProps(props);
+    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranchDatabase(props.project.id, branchId, props.database));
     writer(props).end(data.database, {
         fields: DATABASE_FIELDS,
     });

package/commands/databases.test.js

@@ -8,8 +8,8 @@ describe('databases', () => {
             'list',
             '--project.id',
             'test',
-            '--branch.id',
-            'test_branch_id',
+            '--branch',
+            'test_branch',
         ],
         expected: {
             snapshot: true,
@@ -22,8 +22,8 @@ describe('databases', () => {
             'create',
             '--project.id',
             'test',
-            '--branch.id',
-            'test_branch_id',
+            '--branch',
+            'test_branch',
             '--database.name',
             'test_db',
             '--database.owner_name',
@@ -38,12 +38,11 @@ describe('databases', () => {
         args: [
             'databases',
             'delete',
+            'test_db',
             '--project.id',
             'test',
-            '--branch.id',
-            'test_branch_id',
-            '--database.name',
-            'test_db',
+            '--branch',
+            'test_branch',
         ],
         expected: {
             snapshot: true,

package/commands/index.js

@@ -2,7 +2,6 @@ import * as auth from './auth.js';
 import * as projects from './projects.js';
 import * as users from './user.js';
 import * as branches from './branches.js';
-import * as endpoints from './endpoints.js';
 import * as databases from './databases.js';
 import * as roles from './roles.js';
 import * as operations from './operations.js';
@@ -12,7 +11,6 @@ export default [
     users,
     projects,
     branches,
-    endpoints,
     databases,
     roles,
     operations,

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/projects.js

@@ -16,31 +16,13 @@ export const builder = (argv) => {
         .command('create', 'Create a project', (yargs) => yargs.options(projectCreateRequest), async (args) => {
         await create(args);
     })
-        .command('update', 'Update a project', (yargs) => yargs
-        .option('project.id', {
-        describe: 'Project ID',
-        type: 'string',
-        demandOption: true,
-    })
-        .options(projectCreateRequest), async (args) => {
+        .command('update <id>', 'Update a project', (yargs) => yargs.options(projectCreateRequest), async (args) => {
         await update(args);
     })
-        .command('delete', 'Delete a project', (yargs) => yargs.options({
-        'project.id': {
-            describe: 'Project ID',
-            type: 'string',
-            demandOption: true,
-        },
-    }), async (args) => {
+        .command('delete <id>', 'Delete a project', (yargs) => yargs, async (args) => {
         await deleteProject(args);
     })
-        .command('get', 'Get a project', (yargs) => yargs.options({
-        'project.id': {
-            describe: 'Project ID',
-            type: 'string',
-            demandOption: true,
-        },
-    }), async (args) => {
+        .command('get <id>', 'Get a project', (yargs) => yargs, async (args) => {
         await get(args);
     });
 };
@@ -68,18 +50,18 @@ const create = async (props) => {
     writer(props).end(data.project, { fields: PROJECT_FIELDS });
 };
 const deleteProject = async (props) => {
-    const { data } = await props.apiClient.deleteProject(props.project.id);
+    const { data } = await props.apiClient.deleteProject(props.id);
     writer(props).end(data.project, {
         fields: PROJECT_FIELDS,
     });
 };
 const update = async (props) => {
-    const { data } = await props.apiClient.updateProject(props.project.id, {
+    const { data } = await props.apiClient.updateProject(props.id, {
         project: props.project,
     });
     writer(props).end(data.project, { fields: PROJECT_FIELDS });
 };
 const get = async (props) => {
-    const { data } = await props.apiClient.getProject(props.project.id);
+    const { data } = await props.apiClient.getProject(props.id);
     writer(props).end(data.project, { fields: PROJECT_FIELDS });
 };

package/commands/projects.test.js

@@ -17,28 +17,21 @@ describe('projects', () => {
     });
     testCliCommand({
         name: 'delete',
-        args: ['projects', 'delete', '--project.id', 'test'],
+        args: ['projects', 'delete', 'test'],
         expected: {
             snapshot: true,
         },
     });
     testCliCommand({
         name: 'update',
-        args: [
-            'projects',
-            'update',
-            '--project.id',
-            'test',
-            '--project.name',
-            'test_project',
-        ],
+        args: ['projects', 'update', 'test', '--project.name', 'test_project'],
         expected: {
             snapshot: true,
         },
     });
     testCliCommand({
         name: 'get',
-        args: ['projects', 'get', '--project.id', 'test'],
+        args: ['projects', 'get', 'test'],
         expected: {
             snapshot: true,
         },

package/commands/roles.js

@@ -1,4 +1,5 @@
 import { retryOnLock } from '../api.js';
+import { branchIdFromProps, fillSingleProject } from '../enrichers.js';
 import { roleCreateRequest } from '../parameters.gen.js';
 import { commandFailHandler } from '../utils.js';
 import { writer } from '../writer.js';
@@ -14,34 +15,29 @@ export const builder = (argv) => argv
     'project.id': {
         describe: 'Project ID',
         type: 'string',
-        demandOption: true,
     },
-    'branch.id': {
-        describe: 'Branch ID',
+    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', 'Delete a role', (yargs) => yargs.options({
-    'role.name': {
-        describe: 'Role name',
-        type: 'string',
-        demandOption: true,
-    },
-}), async (args) => await deleteRole(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 { data } = await props.apiClient.listProjectBranchRoles(props.project.id, props.branch.id);
+    const branchId = await branchIdFromProps(props);
+    const { data } = await props.apiClient.listProjectBranchRoles(props.project.id, branchId);
     writer(props).end(data.roles, {
         fields: ROLES_FIELDS,
     });
 };
 export const create = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.createProjectBranchRole(props.project.id, props.branch.id, {
+    const branchId = await branchIdFromProps(props);
+    const { data } = await retryOnLock(() => props.apiClient.createProjectBranchRole(props.project.id, branchId, {
         role: props.role,
     }));
     writer(props).end(data.role, {
@@ -49,7 +45,8 @@ export const create = async (props) => {
     });
 };
 export const deleteRole = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranchRole(props.project.id, props.branch.id, props.role.name));
+    const branchId = await branchIdFromProps(props);
+    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranchRole(props.project.id, branchId, props.role));
     writer(props).end(data.role, {
         fields: ROLES_FIELDS,
     });

package/commands/roles.test.js

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

package/enrichers.js

@@ -0,0 +1,48 @@
+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.\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.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

@@ -78,9 +78,13 @@ builder = builder
     default: !isCi(),
 })
     .middleware(analyticsMiddleware)
+    .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 {
@@ -90,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.12.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) => {
@@ -35,6 +35,8 @@ export const testCliCommand = ({ args, name, expected, }) => {
                 `http://localhost:${server.address().port}`,
                 '--api-key',
                 'test-key',
+                '--output',
+                'yaml',
                 ...args,
             ], {
                 stdio: 'pipe',
@@ -51,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/commands/endpoints.js

@@ -1,92 +0,0 @@
-import { retryOnLock } from '../api.js';
-import { endpointCreateRequest, endpointUpdateRequest, } from '../parameters.gen.js';
-import { commandFailHandler } from '../utils.js';
-import { writer } from '../writer.js';
-const ENDPOINT_FIELDS = [
-    'id',
-    'created_at',
-    'branch_id',
-    'type',
-    'current_state',
-];
-export const command = 'endpoints';
-export const describe = 'Manage endpoints';
-export const aliases = ['endpoint'];
-export const builder = (argv) => argv
-    .demandCommand(1, '')
-    .fail(commandFailHandler)
-    .usage('usage: $0 endpoints <sub-command> [options]')
-    .options({
-    'project.id': {
-        describe: 'Project ID',
-        type: 'string',
-        demandOption: true,
-    },
-})
-    .command('list', 'List endpoints', (yargs) => yargs.options({
-    'branch.id': {
-        describe: 'Branch ID',
-        type: 'string',
-        demandOption: false,
-    },
-}), async (args) => await list(args))
-    .command('create', 'Create an endpoint', (yargs) => yargs.options(endpointCreateRequest), async (args) => await create(args))
-    .command('update', 'Update an endpoint', (yargs) => yargs.options({
-    'endpoint.id': {
-        describe: 'Endpoint ID',
-        type: 'string',
-        demandOption: true,
-    },
-    ...endpointUpdateRequest,
-}), async (args) => await update(args))
-    .command('delete', 'Delete an endpoint', (yargs) => yargs.options({
-    'endpoint.id': {
-        describe: 'Endpoint ID',
-        type: 'string',
-        demandOption: true,
-    },
-}), async (args) => await deleteEndpoint(args))
-    .command('get', 'Get an endpoint', (yargs) => yargs.options({
-    'endpoint.id': {
-        describe: 'Endpoint ID',
-        type: 'string',
-        demandOption: true,
-    },
-}), async (args) => await getEndpoint(args));
-export const handler = async (args) => args;
-const list = async (props) => {
-    const { data } = props.branch?.id
-        ? await props.apiClient.listProjectBranchEndpoints(props.project.id, props.branch.id)
-        : await props.apiClient.listProjectEndpoints(props.project.id);
-    writer(props).end(data.endpoints, {
-        fields: ENDPOINT_FIELDS,
-    });
-};
-const create = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.createProjectEndpoint(props.project.id, {
-        endpoint: props.endpoint,
-    }));
-    writer(props).end(data.endpoint, {
-        fields: ENDPOINT_FIELDS,
-    });
-};
-const update = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.updateProjectEndpoint(props.project.id, props.endpoint.id, {
-        endpoint: props.endpoint,
-    }));
-    writer(props).end(data.endpoint, {
-        fields: ENDPOINT_FIELDS,
-    });
-};
-const deleteEndpoint = async (props) => {
-    const { data } = await retryOnLock(() => props.apiClient.deleteProjectEndpoint(props.project.id, props.endpoint.id));
-    writer(props).end(data.endpoint, {
-        fields: ENDPOINT_FIELDS,
-    });
-};
-const getEndpoint = async (props) => {
-    const { data } = await props.apiClient.getProjectEndpoint(props.project.id, props.endpoint.id);
-    writer(props).end(data.endpoint, {
-        fields: ENDPOINT_FIELDS,
-    });
-};

package/commands/endpoints.test.js

@@ -1,102 +0,0 @@
-import { describe, expect } from '@jest/globals';
-import { testCliCommand } from '../test_utils.js';
-describe('endpoints', () => {
-    testCliCommand({
-        name: 'list',
-        args: ['endpoints', 'list', '--project.id', 'test'],
-        expected: {
-            snapshot: true,
-        },
-    });
-    testCliCommand({
-        name: 'list with branch filter',
-        args: [
-            'endpoints',
-            'list',
-            '--project.id',
-            'test',
-            '--branch.id',
-            'test_branch_id',
-        ],
-        expected: {
-            snapshot: true,
-        },
-    });
-    testCliCommand({
-        name: 'create',
-        args: [
-            'endpoints',
-            'create',
-            '--project.id',
-            'test',
-            '--endpoint.branch_id',
-            'test_branch_id',
-            '--endpoint.type',
-            'read_only',
-        ],
-        expected: {
-            snapshot: true,
-        },
-    });
-    testCliCommand({
-        name: 'create with retry',
-        args: [
-            'endpoints',
-            'create',
-            '--project.id',
-            'test',
-            '--endpoint.branch_id',
-            'test_branch_with_retry',
-            '--endpoint.type',
-            'read_only',
-        ],
-        expected: {
-            stderr: expect.stringContaining('Resource is locked'),
-            snapshot: true,
-        },
-    });
-    testCliCommand({
-        name: 'delete',
-        args: [
-            'endpoints',
-            'delete',
-            '--project.id',
-            'test',
-            '--endpoint.id',
-            'test_endpoint_id',
-        ],
-        expected: {
-            snapshot: true,
-        },
-    });
-    testCliCommand({
-        name: 'update',
-        args: [
-            'endpoints',
-            'update',
-            '--project.id',
-            'test',
-            '--endpoint.id',
-            'test_endpoint_id',
-            '--endpoint.branch_id',
-            'test_branch_id',
-        ],
-        expected: {
-            snapshot: true,
-        },
-    });
-    testCliCommand({
-        name: 'get',
-        args: [
-            'endpoints',
-            'get',
-            '--project.id',
-            'test',
-            '--endpoint.id',
-            'test_endpoint_id',
-        ],
-        expected: {
-            snapshot: true,
-        },
-    });
-});