neonctl 1.3.0 → 1.4.0

package/commands/projects.js

@@ -1,20 +1,13 @@
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
 import { projectCreateRequest } from '../parameters.gen.js';
-import { writeOut } from '../writer.js';
+import { commandFailHandler } from '../utils.js';
+import { writer } from '../writer.js';
 const PROJECT_FIELDS = ['id', 'name', 'region_id', 'created_at'];
 export const command = 'projects [command]';
 export const describe = 'Manage projects';
 export const builder = (argv) => {
     return argv
         .demandCommand(1, '')
-        .fail((_msg, _err, yyargs) => {
-        const y = yargs(hideBin(process.argv));
-        if (y.argv._.length === 1) {
-            yyargs.showHelp();
-            process.exit(1);
-        }
-    })
+        .fail(commandFailHandler)
         .usage('usage: $0 projects <cmd> [args]')
         .command('list', 'List projects', (yargs) => yargs, async (args) => {
         await list(args);
@@ -39,15 +32,23 @@ export const builder = (argv) => {
         },
     }), async (args) => {
         await deleteProject(args);
+    })
+        .command('get', 'Get a project', (yargs) => yargs.options({
+        'project.id': {
+            describe: 'Project ID',
+            type: 'string',
+            demandOption: true,
+        },
+    }), async (args) => {
+        await get(args);
     });
 };
 export const handler = (args) => {
     return args;
 };
 const list = async (props) => {
-    writeOut(props)((await props.apiClient.listProjects({})).data.projects, {
-        fields: PROJECT_FIELDS,
-    });
+    const { data } = await props.apiClient.listProjects({});
+    writer(props).end(data.projects, { fields: PROJECT_FIELDS });
 };
 const create = async (props) => {
     if (props.project == null) {
@@ -60,17 +61,24 @@ const create = async (props) => {
             props.project = answers;
         }
     }
-    writeOut(props)((await props.apiClient.createProject({
+    const { data } = await props.apiClient.createProject({
         project: props.project,
-    })).data.project, { fields: PROJECT_FIELDS });
+    });
+    writer(props).end(data.project, { fields: PROJECT_FIELDS });
 };
 const deleteProject = async (props) => {
-    writeOut(props)((await props.apiClient.deleteProject(props.project.id)).data.project, {
+    const { data } = await props.apiClient.deleteProject(props.project.id);
+    writer(props).end(data.project, {
         fields: PROJECT_FIELDS,
     });
 };
 const update = async (props) => {
-    writeOut(props)((await props.apiClient.updateProject(props.project.id, {
+    const { data } = await props.apiClient.updateProject(props.project.id, {
         project: props.project,
-    })).data.project, { fields: PROJECT_FIELDS });
+    });
+    writer(props).end(data.project, { fields: PROJECT_FIELDS });
+};
+const get = async (props) => {
+    const { data } = await props.apiClient.getProject(props.project.id);
+    writer(props).end(data.project, { fields: PROJECT_FIELDS });
 };

package/commands/projects.test.js

@@ -0,0 +1,46 @@
+import { describe } from '@jest/globals';
+import { testCliCommand } from '../test_utils.js';
+describe('projects', () => {
+    testCliCommand({
+        name: 'list',
+        args: ['projects', 'list'],
+        expected: {
+            snapshot: true,
+        },
+    });
+    testCliCommand({
+        name: 'create',
+        args: ['projects', 'create', '--project.name', 'test_project'],
+        expected: {
+            snapshot: true,
+        },
+    });
+    testCliCommand({
+        name: 'delete',
+        args: ['projects', 'delete', '--project.id', 'test'],
+        expected: {
+            snapshot: true,
+        },
+    });
+    testCliCommand({
+        name: 'update',
+        args: [
+            'projects',
+            'update',
+            '--project.id',
+            'test',
+            '--project.name',
+            'test_project',
+        ],
+        expected: {
+            snapshot: true,
+        },
+    });
+    testCliCommand({
+        name: 'get',
+        args: ['projects', 'get', '--project.id', 'test'],
+        expected: {
+            snapshot: true,
+        },
+    });
+});

package/commands/users.js

@@ -1,4 +1,4 @@
-import { writeOut } from '../writer.js';
+import { writer } from '../writer.js';
 export const command = 'me';
 export const describe = 'Show current user';
 export const builder = (yargs) => yargs;
@@ -6,7 +6,8 @@ export const handler = async (args) => {
     await me(args);
 };
 const me = async (props) => {
-    writeOut(props)((await props.apiClient.getCurrentUserInfo()).data, {
+    const { data } = await props.apiClient.getCurrentUserInfo();
+    writer(props).end(data, {
         fields: ['login', 'email', 'name', 'projects_limit'],
     });
 };

package/config.js

@@ -1,9 +1,10 @@
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { existsSync, mkdirSync } from 'node:fs';
+import { isCi } from './env.js';
 export const defaultDir = join(homedir(), process.env.XDG_CONFIG_HOME || '.config', 'neonctl');
 export const ensureConfigDir = async ({ 'config-dir': configDir, }) => {
-    if (!existsSync(configDir)) {
+    if (!existsSync(configDir) && !isCi()) {
         mkdirSync(configDir);
     }
 };

package/env.js

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

package/index.js

@@ -2,7 +2,18 @@ import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { fileURLToPath } from 'node:url';
 import { readFileSync } from 'node:fs';
-import 'axios-debug-log';
+import axiosDebug from 'axios-debug-log';
+axiosDebug({
+    request(debug, config) {
+        debug(`${config.method?.toUpperCase()} ${config.url}`);
+    },
+    response(debug, response) {
+        debug(`${response.status} ${response.statusText}`);
+    },
+    error(debug, error) {
+        debug(error);
+    },
+});
 import { ensureAuth } from './commands/auth.js';
 import { defaultDir, ensureConfigDir } from './config.js';
 import { log } from './log.js';

package/package.json

@@ -5,7 +5,7 @@
     "url": "git@github.com:neondatabase/neonctl.git"
   },
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "CLI tool for NeonDB Cloud management",
   "main": "index.js",
   "author": "NeonDB",
@@ -19,19 +19,25 @@
   },
   "devDependencies": {
     "@apidevtools/swagger-parser": "^10.1.0",
+    "@jest/globals": "^29.5.0",
     "@semantic-release/exec": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@types/cli-table": "^0.3.0",
+    "@types/express": "^4.17.17",
     "@types/inquirer": "^9.0.3",
     "@types/node": "^18.7.13",
     "@types/yargs": "^17.0.24",
     "@typescript-eslint/eslint-plugin": "^5.34.0",
     "@typescript-eslint/parser": "^5.34.0",
+    "emocks": "^3.0.1",
     "eslint": "^8.22.0",
+    "express": "^4.18.2",
     "husky": "^8.0.1",
+    "jest": "^29.5.0",
     "lint-staged": "^13.0.3",
     "prettier": "^2.7.1",
     "semantic-release": "^21.0.2",
+    "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
     "typescript": "^4.7.4"
   },
@@ -54,10 +60,11 @@
   "scripts": {
     "watch": "tsc --watch",
     "lint": "tsc --noEmit && eslint src --ext .ts",
-    "build": "npm run generateParams && npm run clean && tsc && cp src/*.html dist/ && cp package.json ./dist",
+    "build": "npm run generateParams && npm run clean && tsc && cp src/*.html package.json README.md ./dist",
     "clean": "rm -rf dist",
     "generateParams": "ts-node --esm generateOptionsFromSpec.ts",
-    "start": "node src/index.js"
+    "start": "node src/index.js",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest"
   },
   "lint-staged": {
     "*.ts": [

package/parameters.gen.js

@@ -3,98 +3,221 @@ export const projectCreateRequest = {
     'project.settings.quota.active_time_seconds': {
         type: "number",
         description: "The total amount of wall-clock time allowed to be spent by project's compute endpoints.\n",
+        demandOption: false,
     },
     'project.settings.quota.compute_time_seconds': {
         type: "number",
         description: "The total amount of CPU seconds allowed to be spent by project's compute endpoints.\n",
+        demandOption: false,
     },
     'project.settings.quota.written_data_bytes': {
         type: "number",
         description: "Total amount of data written to all project's branches.\n",
+        demandOption: false,
     },
     'project.settings.quota.data_transfer_bytes': {
         type: "number",
         description: "Total amount of data transferred from all project's branches using proxy.\n",
+        demandOption: false,
     },
     'project.settings.quota.logical_size_bytes': {
         type: "number",
         description: "Limit on the logical size of every project's branch.\n",
+        demandOption: false,
     },
     'project.name': {
         type: "string",
         description: "The project name",
+        demandOption: false,
     },
     'project.branch.name': {
         type: "string",
         description: "The branch name. If not specified, the default branch name will be used.\n",
+        demandOption: false,
     },
     'project.branch.role_name': {
         type: "string",
         description: "The role name. If not specified, the default role name will be used.\n",
+        demandOption: false,
     },
     'project.branch.database_name': {
         type: "string",
         description: "The database name. If not specified, the default database name will be used.\n",
+        demandOption: false,
     },
     'project.provisioner': {
         type: "string",
         description: "The Neon compute provisioner.\n",
+        demandOption: false,
         choices: ["k8s-pod", "k8s-neonvm", "docker"],
     },
     'project.region_id': {
         type: "string",
         description: "The region identifier. See [the documentation](https://neon.tech/docs/introduction/regions) for the list of supported regions.\n",
+        demandOption: false,
     },
     'project.pg_version': {
         type: "number",
         description: "The major PostgreSQL version number. Currently supported version are `14` and `15`.",
+        demandOption: false,
     },
     'project.store_passwords': {
         type: "boolean",
         description: "Whether or not passwords are stored for roles in the Neon project. Storing passwords facilitates access to Neon features that require authorization.\n",
+        demandOption: false,
     },
     'project.history_retention_seconds': {
         type: "number",
         description: "The number of seconds to retain PITR backup history for this project. Defaults to 7 days\n",
+        demandOption: false,
     },
 };
 export const branchCreateRequest = {
     'branch.parent_id': {
         type: "string",
         description: "The `branch_id` of the parent branch\n",
+        demandOption: false,
     },
     'branch.name': {
         type: "string",
         description: "The branch name\n",
+        demandOption: false,
     },
     'branch.parent_lsn': {
         type: "string",
         description: "A Log Sequence Number (LSN) on the parent branch. The branch will be created with data from this LSN.\n",
+        demandOption: false,
     },
     'branch.parent_timestamp': {
         type: "string",
         description: "A timestamp identifying a point in time on the parent branch. The branch will be created with data starting from this point in time.\n",
+        demandOption: false,
     },
 };
 export const branchCreateRequestEndpointOptions = {
     'type': {
         type: "string",
         description: "The compute endpoint type. Either `read_write` or `read_only`.\nThe `read_only` compute endpoint type is not yet supported.\n",
+        demandOption: true,
         choices: ["read_only", "read_write"],
     },
     'provisioner': {
         type: "string",
         description: "The Neon compute provisioner.\n",
+        demandOption: false,
         choices: ["k8s-pod", "k8s-neonvm", "docker"],
     },
     'suspend_timeout_seconds': {
         type: "number",
         description: "Duration of inactivity in seconds after which endpoint will be\nautomatically suspended. Value `0` means use global default,\n`-1` means never suspend. Maximum value is 1 week in seconds.\n",
+        demandOption: false,
     },
 };
 export const branchUpdateRequest = {
     'branch.name': {
         type: "string",
         description: undefined,
+        demandOption: false,
+    },
+};
+export const endpointCreateRequest = {
+    'endpoint.branch_id': {
+        type: "string",
+        description: "The ID of the branch the compute endpoint will be associated with\n",
+        demandOption: true,
+    },
+    'endpoint.region_id': {
+        type: "string",
+        description: "The region where the compute endpoint will be created. Only the project's `region_id` is permitted.\n",
+        demandOption: false,
+    },
+    'endpoint.type': {
+        type: "string",
+        description: "The compute endpoint type. Either `read_write` or `read_only`.\nThe `read_only` compute endpoint type is not yet supported.\n",
+        demandOption: true,
+        choices: ["read_only", "read_write"],
+    },
+    'endpoint.provisioner': {
+        type: "string",
+        description: "The Neon compute provisioner.\n",
+        demandOption: false,
+        choices: ["k8s-pod", "k8s-neonvm", "docker"],
+    },
+    'endpoint.pooler_enabled': {
+        type: "boolean",
+        description: "Whether to enable connection pooling for the compute endpoint\n",
+        demandOption: false,
+    },
+    'endpoint.pooler_mode': {
+        type: "string",
+        description: "The connection pooler mode. Neon supports PgBouncer in `transaction` mode only.\n",
+        demandOption: false,
+        choices: ["transaction"],
+    },
+    'endpoint.disabled': {
+        type: "boolean",
+        description: "Whether to restrict connections to the compute endpoint\n",
+        demandOption: false,
+    },
+    'endpoint.passwordless_access': {
+        type: "boolean",
+        description: "NOT YET IMPLEMENTED. Whether to permit passwordless access to the compute endpoint.\n",
+        demandOption: false,
+    },
+    'endpoint.suspend_timeout_seconds': {
+        type: "number",
+        description: "Duration of inactivity in seconds after which endpoint will be\nautomatically suspended. Value `0` means use global default,\n`-1` means never suspend. Maximum value is 1 week in seconds.\n",
+        demandOption: false,
+    },
+};
+export const endpointUpdateRequest = {
+    'endpoint.branch_id': {
+        type: "string",
+        description: "The destination branch ID. The destination branch must not have an exsiting read-write endpoint.\n",
+        demandOption: false,
+    },
+    'endpoint.provisioner': {
+        type: "string",
+        description: "The Neon compute provisioner.\n",
+        demandOption: false,
+        choices: ["k8s-pod", "k8s-neonvm", "docker"],
+    },
+    'endpoint.pooler_enabled': {
+        type: "boolean",
+        description: "Whether to enable connection pooling for the compute endpoint\n",
+        demandOption: false,
+    },
+    'endpoint.pooler_mode': {
+        type: "string",
+        description: "The connection pooler mode. Neon supports PgBouncer in `transaction` mode only.\n",
+        demandOption: false,
+        choices: ["transaction"],
+    },
+    'endpoint.disabled': {
+        type: "boolean",
+        description: "Whether to restrict connections to the compute endpoint\n",
+        demandOption: false,
+    },
+    'endpoint.passwordless_access': {
+        type: "boolean",
+        description: "NOT YET IMPLEMENTED. Whether to permit passwordless access to the compute endpoint.\n",
+        demandOption: false,
+    },
+    'endpoint.suspend_timeout_seconds': {
+        type: "number",
+        description: "Duration of inactivity in seconds after which endpoint will be\nautomatically suspended. Value `0` means use global default,\n`-1` means never suspend. Maximum value is 1 week in seconds.\n",
+        demandOption: false,
+    },
+};
+export const databaseCreateRequest = {
+    'database.name': {
+        type: "string",
+        description: "The name of the datbase\n",
+        demandOption: true,
+    },
+    'database.owner_name': {
+        type: "string",
+        description: "The name of the role that owns the database\n",
+        demandOption: true,
     },
 };

package/test_utils.js

@@ -0,0 +1,75 @@
+/* eslint-disable no-console */
+import { test, expect, describe, beforeAll, afterAll } from '@jest/globals';
+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 app = express();
+    app.use(express.json());
+    app.use('/', emocks(join(process.cwd(), 'mocks')));
+    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, }) => {
+    let server;
+    describe(name, () => {
+        beforeAll(async () => {
+            server = await runMockServer();
+        });
+        afterAll(async () => {
+            return new Promise((resolve) => {
+                server.close(() => {
+                    resolve();
+                });
+            });
+        });
+        test('test', async () => {
+            let output = '';
+            let error = '';
+            const cp = fork(join(process.cwd(), './dist/index.js'), [
+                '--api-host',
+                `http://localhost:${server.address().port}`,
+                '--api-key',
+                'test-key',
+                ...args,
+            ], {
+                stdio: 'pipe',
+            });
+            return new Promise((resolve, reject) => {
+                cp.stdout?.on('data', (data) => {
+                    output += data.toString();
+                });
+                cp.stderr?.on('data', (data) => {
+                    error += data.toString();
+                });
+                cp.on('error', (err) => {
+                    throw err;
+                });
+                cp.on('close', (code) => {
+                    if (error) {
+                        console.log(error);
+                    }
+                    try {
+                        expect(code).toBe(0);
+                        if (code === 0 && expected) {
+                            if ('snapshot' in expected) {
+                                expect(output).toMatchSnapshot();
+                            }
+                            else if ('output' in expected) {
+                                expect(output).toEqual(expected.output);
+                            }
+                        }
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                });
+            });
+        });
+    });
+};

package/utils.js

@@ -1,3 +1,5 @@
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
 /**
  * This middleware is needed to fill in the args for nested objects,
  * so that required arguments would work
@@ -18,3 +20,10 @@ export const fillInArgs = (args, currentArgs = args, acc = []) => {
         }
     });
 };
+export const commandFailHandler = async (_msg, _err, yyargs) => {
+    const argv = yargs(hideBin(process.argv));
+    if (argv.argv._.length === 1) {
+        yyargs.showHelp();
+        process.exit(1);
+    }
+};

package/writer.js

@@ -1,62 +1,71 @@
 import YAML from 'yaml';
 import Table from 'cli-table';
 import chalk from 'chalk';
-// Allow PIPE to finish reading before the end of the output.
-process.stdout.on('error', function (err) {
-    if (err.code == 'EPIPE') {
-        process.exit(0);
-    }
-});
+import { isCi } from './env.js';
 /**
  *
  * Parses the output format, takes data and writes the output to stdout.
  *
  * @example
- * // to output single data
  * const { data } = await props.apiClient.listProjectBranches(props.project.id);
- * writeOut(props)(data, { fields: ['id', 'name', 'created_at'] })
+ * // to output single data
+ * writer(props).end(data, { fields: ['id', 'name', 'created_at'] })
  * // to output multiple data
- * writeOut(props)({
- *  branches: {
- *   data,
- *  config: { fields: ['id', 'name', 'created_at'] }
- * },
- * endpoints: {
- *  data,
- *  config: { fields: ['id', 'created_at'] }
- * }
- * })
+ * writer(props)
+ *   .write(data, { fields: ['id', 'name', 'created_at'], title: 'branches' })
+ *   .write(data, { fields: ['id', 'created_at'], title: 'endpoints' })
+ *   .end()
  */
-export const writeOut = (props) => (arg1, arg2) => {
-    if (props.output == 'yaml') {
-        process.stdout.write(YAML.stringify(arg2 === undefined
-            ? Object.fromEntries(Object.entries(arg1).map(([k, v]) => [k, v.data]))
-            : arg1, null, 2));
-        return;
-    }
-    if (props.output == 'json') {
-        process.stdout.write(JSON.stringify(arg2 === undefined
-            ? Object.fromEntries(Object.entries(arg1).map(([k, v]) => [k, v.data]))
-            : arg1, null, 2));
-        return;
-    }
-    const options = arg2 === undefined ? arg1 : { '': { data: arg1, config: arg2 } };
-    Object.entries(options).forEach(([key, { data, config }]) => {
-        const arrayData = Array.isArray(data) ? data : [data];
-        const table = new Table({
-            style: {
-                head: ['green'],
-            },
-            head: config.fields.map((field) => field
-                .split('_')
-                .map((word) => word[0].toUpperCase() + word.slice(1))
-                .join(' ')),
-        });
-        arrayData.forEach((item) => {
-            table.push(config.fields.map((field) => item[field] ?? ''));
-        });
-        process.stdout.write(chalk.bold(key) + '\n');
-        process.stdout.write(table.toString());
-        process.stdout.write('\n');
-    });
+export const writer = (props) => {
+    const out = props.out ?? process.stdout;
+    const chunks = [];
+    return {
+        write(data, config) {
+            chunks.push({ data, config });
+            return this;
+        },
+        end: (...args) => {
+            if (args.length === 2) {
+                chunks.push({ data: args[0], config: args[1] });
+            }
+            if (props.output == 'yaml') {
+                out.write(YAML.stringify(chunks.length === 1
+                    ? chunks[0].data
+                    : Object.fromEntries(chunks.map(({ config, data }, idx) => [
+                        config.title ?? idx,
+                        data,
+                    ])), null, 2));
+                return;
+            }
+            if (props.output == 'json') {
+                out.write(JSON.stringify(chunks.length === 1
+                    ? chunks[0].data
+                    : Object.fromEntries(chunks.map(({ config, data }, idx) => [
+                        config.title ?? idx,
+                        data,
+                    ])), null, 2));
+                return;
+            }
+            chunks.forEach(({ data, config }) => {
+                const arrayData = Array.isArray(data) ? data : [data];
+                const table = new Table({
+                    style: {
+                        head: ['green'],
+                    },
+                    head: config.fields.map((field) => field
+                        .split('_')
+                        .map((word) => word[0].toUpperCase() + word.slice(1))
+                        .join(' ')),
+                });
+                arrayData.forEach((item) => {
+                    table.push(config.fields.map((field) => item[field] ?? ''));
+                });
+                if (config.title) {
+                    out.write((isCi() ? config.title : chalk.bold(config.title)) + '\n');
+                }
+                out.write(table.toString());
+                out.write('\n');
+            });
+        },
+    };
 };