@agilecustoms/envctl 1.8.0 → 1.10.0

package/dist/client/HttpClient.js

@@ -5,7 +5,12 @@ export function toUrl(path) {
     return `https://${HOST}/env-api${path}`;
 }
 export class HttpClient {
-    constructor() { }
+    version;
+    commandId;
+    constructor(version, commandId) {
+        this.version = version;
+        this.commandId = commandId;
+    }
     async post(path, body, options = {}) {
         options.method = 'POST';
         if (body) {
@@ -20,10 +25,16 @@ export class HttpClient {
     }
     async fetch(path, options = {}) {
         const url = toUrl(path);
-        if (!options.method) {
-            options.method = 'GET';
-        }
-        logger.debug(`--> ${options.method} ${url} ${JSON.stringify(options)}`);
+        const headers = new Headers(options.headers);
+        headers.set('x-command-id', this.commandId);
+        headers.set('x-client-version', this.version);
+        const req = {
+            ...options,
+            method: options.method ?? 'GET',
+            headers,
+        };
+        const reqJson = JSON.stringify({ ...req, headers: Object.fromEntries(headers.entries()) });
+        logger.debug(`--> ${req.method} ${url} ${reqJson}`);
         let response;
         try {
             response = await fetch(url, options);

package/dist/commands/configure.js

@@ -1,24 +1,23 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
-import { configService } from '../container.js';
+import { ConfigService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function configure(program) {
+export function configure(program, configService) {
     program
         .command('configure')
         .description('Configure user settings on your local machine')
         .option('-v, --verbose', _keys.VERBOSE)
-        .action(wrap(handler));
-}
-async function handler() {
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'userName',
-            message: 'userName is required to deploy any env\n'
-                + '(prefer GitHub username)\n'
-                + 'userName:',
-        },
-    ]);
-    configService.saveConfig({ userName: answers.userName });
+        .action(wrap(async () => {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'userName',
+                message: 'userName is required to deploy any env\n'
+                    + '(prefer GitHub username)\n'
+                    + 'userName:',
+            },
+        ]);
+        configService.saveConfig({ userName: answers.userName });
+    }));
 }

package/dist/commands/createEphemeral.js

@@ -1,17 +1,16 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function createEphemeral(program) {
+export function createEphemeral(program, envService) {
     program
         .command('create-ephemeral')
         .description('Create bare env w/o resources. Used in CI as first step just to pre-generate token for extension')
         .requiredOption('--key <key>', _keys.KEY)
         .option('-v, --verbose', _keys.VERBOSE)
-        .action(wrap(handler));
-}
-async function handler(options) {
-    const { key } = options;
-    const token = await envService.createEphemeral(key);
-    console.log(token);
+        .action(wrap(async (options) => {
+        const { key } = options;
+        const token = await envService.createEphemeral(key);
+        console.log(token);
+    }));
 }

package/dist/commands/delete.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function deleteIt(program) {
+export function deleteIt(program, envService) {
     program
         .command('delete')
         .description('Delete a development environment')
@@ -10,11 +10,10 @@ export function deleteIt(program) {
         .option('--force', _keys.FORCE)
         .option('--cwd <cwd>', _keys.CWD)
         .option('-v, --verbose', _keys.VERBOSE)
-        .action(wrap(handler));
-}
-async function handler(options) {
-    const { key, force, cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.delete(Boolean(force), key);
+        .action(wrap(async (options) => {
+        const { key, force, cwd } = options;
+        if (cwd)
+            process.chdir(cwd);
+        await envService.delete(Boolean(force), key);
+    }));
 }

package/dist/commands/deploy.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function deploy(program) {
+export function deploy(program, envService) {
     program
         .command('deploy')
         .description('Create new or update existing environment')
@@ -10,11 +10,10 @@ export function deploy(program) {
         .option('-v, --verbose', _keys.VERBOSE)
         .allowUnknownOption(true)
         .argument('[args...]')
-        .action(wrap(handler));
-}
-async function handler(tfArgs, options) {
-    const { cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.deploy(tfArgs);
+        .action(wrap(async (tfArgs, options) => {
+        const { cwd } = options;
+        if (cwd)
+            process.chdir(cwd);
+        await envService.deploy(tfArgs);
+    }));
 }

package/dist/commands/destroy.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function destroy(program) {
+export function destroy(program, envService) {
     program
         .command('destroy')
         .description('Destroy environment resources. This is thin wrapper for terraform destroy.'
@@ -14,11 +14,10 @@ export function destroy(program) {
         .option('-v, --verbose', _keys.VERBOSE)
         .allowUnknownOption(true)
         .argument('[args...]')
-        .action(wrap(handler));
-}
-async function handler(tfArgs, options) {
-    const { force, cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.destroy(tfArgs, Boolean(force));
+        .action(wrap(async (tfArgs, options) => {
+        const { force, cwd } = options;
+        if (cwd)
+            process.chdir(cwd);
+        await envService.destroy(tfArgs, Boolean(force));
+    }));
 }

package/dist/commands/logs.js

@@ -1,19 +1,17 @@
 import { Command } from 'commander';
-import { logService } from '../container.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function logs(program) {
+export function logs(program, logService) {
     program
         .command('logs')
         .description('Get most recent env destroy logs')
         .option('--key <key>', _keys.KEY)
         .option('--cwd <cwd>', _keys.CWD)
         .option('-v, --verbose', _keys.VERBOSE)
-        .action(wrap(handler));
-}
-async function handler(options) {
-    const { key, cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await logService.getLogs(key);
+        .action(wrap(async (options) => {
+        const { key, cwd } = options;
+        if (cwd)
+            process.chdir(cwd);
+        await logService.getLogs(key);
+    }));
 }

package/dist/commands/plan.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function plan(program) {
+export function plan(program, envService) {
     program
         .command('plan')
         .description('High level wrapper for terraform plan. Compliments deploy command: if you plan to deploy env with envctl deploy,'
@@ -11,11 +11,10 @@ export function plan(program) {
         .option('-v, --verbose', _keys.VERBOSE)
         .allowUnknownOption(true)
         .argument('[args...]')
-        .action(wrap(handler));
-}
-async function handler(tfArgs, options) {
-    const { cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.plan(tfArgs);
+        .action(wrap(async (tfArgs, options) => {
+        const { cwd } = options;
+        if (cwd)
+            process.chdir(cwd);
+        await envService.plan(tfArgs);
+    }));
 }

package/dist/commands/status.js

@@ -1,19 +1,18 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function status(program) {
+export function status(program, envService) {
     program
         .command('status')
         .description('Get env status')
         .option('--key <key>', _keys.KEY)
         .option('--cwd <cwd>', _keys.CWD)
         .option('-v, --verbose', _keys.VERBOSE)
-        .action(wrap(handler));
-}
-async function handler(options) {
-    const { key, cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.status(key);
+        .action(wrap(async (options) => {
+        const { key, cwd } = options;
+        if (cwd)
+            process.chdir(cwd);
+        await envService.status(key);
+    }));
 }

package/dist/container.js

@@ -1,18 +1,20 @@
+import { randomUUID } from 'node:crypto';
 import { S3Backend } from './backend/S3Backend.js';
 import { Cli } from './client/Cli.js';
 import { EnvApiClient, HttpClient } from './client/index.js';
 import { ConfigService, EnvService, TerraformAdapter } from './service/index.js';
 import { LocalStateService } from './service/LocalStateService.js';
 import { LogService } from './service/LogService.js';
-const cli = new Cli();
-const configService = new ConfigService();
-const backends = [
-    new S3Backend()
-];
-const httpClient = new HttpClient();
-const envApiClient = new EnvApiClient(httpClient);
-const localStateService = new LocalStateService();
-const terraformAdapter = new TerraformAdapter(Date.now, cli, localStateService, backends);
-const envService = new EnvService(cli, envApiClient, terraformAdapter);
-const logService = new LogService(cli, envApiClient, terraformAdapter);
-export { configService, envService, logService };
+export function buildContainer(appVersion) {
+    const cli = new Cli();
+    const configService = new ConfigService();
+    const backends = [new S3Backend()];
+    const commandId = randomUUID();
+    const httpClient = new HttpClient(appVersion, commandId);
+    const envApiClient = new EnvApiClient(httpClient);
+    const localStateService = new LocalStateService();
+    const terraformAdapter = new TerraformAdapter(Date.now, cli, localStateService, backends);
+    const envService = new EnvService(cli, envApiClient, terraformAdapter);
+    const logService = new LogService(cli, envApiClient, terraformAdapter);
+    return { configService, envService, logService };
+}

package/dist/index.js

@@ -3,20 +3,19 @@ import { createRequire } from 'module';
 import { Command } from 'commander';
 import updateNotifier from 'update-notifier';
 import { configure, createEphemeral, deleteIt, deploy, destroy, logs, plan, status } from './commands/index.js';
+import { buildContainer } from './container.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
+const { configService, envService, logService } = buildContainer(pkg.version);
 const program = new Command();
-program
-    .name('envctl')
-    .description('CLI to manage environments')
-    .version(pkg.version);
-configure(program);
-createEphemeral(program);
-deleteIt(program);
-deploy(program);
-destroy(program);
-logs(program);
-plan(program);
-status(program);
+program.name('envctl').description('CLI to manage environments').version(pkg.version);
+configure(program, configService);
+createEphemeral(program, envService);
+deleteIt(program, envService);
+deploy(program, envService);
+destroy(program, envService);
+logs(program, logService);
+plan(program, envService);
+status(program, envService);
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilecustoms/envctl",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "node.js CLI client for manage environments",
   "keywords": [
     "terraform wrapper",