@agilecustoms/envctl 0.13.1 → 0.14.0

package/dist/client/AwsCredsHelper.js

@@ -0,0 +1,34 @@
+import { fromEnv, fromNodeProviderChain } from '@aws-sdk/credential-providers';
+import { CredentialsProviderError } from '@smithy/property-provider';
+import { KnownException } from '../exceptions.js';
+export class AwsCredsHelper {
+    creds;
+    async ensureCredentials() {
+        await this.getCredentials();
+    }
+    async getCredentials() {
+        if (!this.creds) {
+            console.log('Fetching AWS credentials...');
+            this.creds = await this._getCredentials();
+        }
+        return this.creds;
+    }
+    async _getCredentials() {
+        let identityProvider;
+        if (process.env.CI) {
+            identityProvider = fromEnv();
+        }
+        else {
+            identityProvider = fromNodeProviderChain();
+        }
+        try {
+            return await identityProvider();
+        }
+        catch (error) {
+            if (error instanceof CredentialsProviderError) {
+                throw new KnownException(error.message, { cause: error });
+            }
+            throw new Error('Unknown error fetching credentials:', { cause: error });
+        }
+    }
+}

package/dist/client/CliHelper.js

@@ -0,0 +1,104 @@
+import path from 'path';
+import inquirer from 'inquirer';
+import { KnownException } from '../exceptions.js';
+import { EnvSize, EnvType } from '../model/index.js';
+import { ConfigService } from '../service/index.js';
+export class CliHelper {
+    configService;
+    constructor(configService) {
+        this.configService = configService;
+    }
+    async promptYesNo(message, defaultValue = false) {
+        const { answer } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'answer',
+                message,
+                default: defaultValue,
+            }]);
+        return answer;
+    }
+    ensureEnv(env) {
+        if (env) {
+            return env;
+        }
+        const owner = this.configService.getOwner();
+        if (!owner) {
+            throw new KnownException('--env argument is not provided\n'
+                + 'default to owner from local configuration, but it is not configured\n'
+                + 'please call with --env argument or run \'envctl configure\' to configure owner');
+        }
+        console.log(`Env name not provided, default to owner name ${owner}`);
+        return owner;
+    }
+    ensureOwner(owner) {
+        if (!owner) {
+            owner = this.configService.getOwner();
+            if (!owner) {
+                throw new KnownException('when called without --owner option, first call \'envctl configure\'');
+            }
+            console.log(`Owner not provided, default to configured owner ${owner}`);
+        }
+        return owner;
+    }
+    async parseEnvInput(input, envName, owner, cwd) {
+        owner = this.ensureOwner(owner);
+        const { size } = input;
+        let { type, kind } = input;
+        kind = ensureKind(kind, cwd);
+        let envSize;
+        if (size) {
+            envSize = ensureEnumValue(EnvSize, size, 'size');
+        }
+        else {
+            const answer = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'size',
+                    message: 'Environment size:',
+                    choices: Object.values(EnvSize),
+                    default: EnvSize.Small,
+                }]);
+            envSize = answer.size;
+        }
+        if (!type) {
+            type = EnvType.Dev;
+            console.log(`Default environment type: ${EnvType.Dev}`);
+        }
+        const envType = ensureEnumValue(EnvType, type || EnvType.Dev, 'type');
+        return {
+            project: input.project,
+            env: envName,
+            owner,
+            size: envSize,
+            type: envType,
+            kind
+        };
+    }
+}
+function ensureKind(kind, cwd) {
+    if (kind) {
+        return kind;
+    }
+    kind = getDirName(cwd);
+    console.log(`Inferred kind from directory name: ${kind}`);
+    return kind;
+}
+function getDirName(cwd) {
+    cwd = resolveCwd(cwd);
+    return path.basename(cwd);
+}
+function resolveCwd(cwd) {
+    if (!cwd) {
+        return process.cwd();
+    }
+    if (path.isAbsolute(cwd)) {
+        return cwd;
+    }
+    return path.resolve(process.cwd(), cwd);
+}
+function ensureEnumValue(enumObj, value, name) {
+    const values = Object.values(enumObj);
+    if (!values.includes(value)) {
+        throw new KnownException(`Invalid ${name}: "${value}". Must be one of: ${values.join(', ')}`);
+    }
+    return value;
+}

package/dist/client/EnvApiClient.js

@@ -1,4 +1,5 @@
 import { KnownException, NotFoundException } from '../exceptions.js';
+import { EnvStatus } from '../model/index.js';
 import { HttpClient } from './HttpClient.js';
 export class EnvApiClient {
     httpClient;
@@ -24,31 +25,35 @@ export class EnvApiClient {
                 'Content-Type': 'application/json'
             }
         });
-        return res.token;
+        const token = res.token;
+        return { ...env, token, status: EnvStatus.Creating };
     }
-    async activate(key) {
-        await this.httpClient.fetch(`/ci/env/${key}/activate`, {
+    async activate(env) {
+        await this.httpClient.fetch(`/ci/env/${env.key}/activate`, {
             method: 'POST'
         });
+        env.status = EnvStatus.Active;
     }
-    async lockForUpdate(key) {
-        await this.httpClient.fetch(`/ci/env/${key}/lock-for-update`, {
+    async lockForUpdate(env) {
+        await this.httpClient.fetch(`/ci/env/${env.key}/lock-for-update`, {
             method: 'POST'
         });
+        env.status = EnvStatus.Updating;
     }
-    async delete(key) {
+    async delete(env) {
         let result;
         try {
-            result = await this.httpClient.fetch(`/ci/env/${key}`, {
+            result = await this.httpClient.fetch(`/ci/env/${env.key}`, {
                 method: 'DELETE'
             });
         }
         catch (error) {
             if (error instanceof NotFoundException) {
-                throw new KnownException(`Environment ${key} is not found`);
+                throw new KnownException(`Environment ${env.key} is not found`);
             }
             throw error;
         }
+        env.status = EnvStatus.Deleting;
         return result.statusText;
     }
 }

package/dist/client/HttpClient.js

@@ -1,14 +1,13 @@
-import { fromEnv, fromNodeProviderChain } from '@aws-sdk/credential-providers';
-import { CredentialsProviderError } from '@smithy/property-provider';
 import aws4 from 'aws4';
-import { BusinessException, HttpException, KnownException, NotFoundException } from '../exceptions.js';
+import { BusinessException, HttpException, NotFoundException } from '../exceptions.js';
 const HOST = 'env-api.maintenance.agilecustoms.com';
 export class HttpClient {
-    creds = undefined;
+    awsCredsHelper;
+    constructor(awsCredsHelper) {
+        this.awsCredsHelper = awsCredsHelper;
+    }
     async fetch(path, options = {}) {
-        if (!this.creds) {
-            this.creds = await this.getCredentials();
-        }
+        const awsCreds = await this.awsCredsHelper.getCredentials();
         const requestOptions = {
             method: options.method,
             body: options.body,
@@ -17,7 +16,7 @@ export class HttpClient {
             service: 'execute-api',
             path,
         };
-        const signedOptions = aws4.sign(requestOptions, this.creds);
+        const signedOptions = aws4.sign(requestOptions, awsCreds);
         const signedHeaders = signedOptions.headers;
         const url = `https://${HOST}${path}`;
         options.headers = signedHeaders;
@@ -53,22 +52,4 @@ export class HttpClient {
         }
         throw new HttpException(response.status, await response.text());
     }
-    async getCredentials() {
-        let identityProvider;
-        if (process.env.CI) {
-            identityProvider = fromEnv();
-        }
-        else {
-            identityProvider = fromNodeProviderChain();
-        }
-        try {
-            return await identityProvider();
-        }
-        catch (error) {
-            if (error instanceof CredentialsProviderError) {
-                throw new KnownException(error.message, { cause: error });
-            }
-            throw new Error('Error fetching credentials:', { cause: error });
-        }
-    }
 }

package/dist/client/TerraformAdapter.js

@@ -1,5 +1,4 @@
-import { promptYesNo } from '../commands/utils.js';
-import { ExitException, KnownException, ProcessException } from '../exceptions.js';
+import { AbortedException, KnownException, ProcessException } from '../exceptions.js';
 const MAX_ATTEMPTS = 2;
 const RETRYABLE_ERRORS = [
     'ConcurrentModificationException',
@@ -7,8 +6,10 @@ const RETRYABLE_ERRORS = [
 ];
 export class TerraformAdapter {
     processRunner;
-    constructor(processRunner) {
+    cliHelper;
+    constructor(processRunner, cliHelper) {
         this.processRunner = processRunner;
+        this.cliHelper = cliHelper;
     }
     printTime() {
         const now = new Date();
@@ -41,17 +42,17 @@ export class TerraformAdapter {
             throw new KnownException('Can not find terraform files. Command needs to be run in a directory with terraform files');
         }
     }
-    tfArgs(envDto, tfArgs) {
+    tfArgs(env, tfArgs) {
         return [
-            `-var=env=${envDto.env}`,
-            `-var=owner=${envDto.owner}`,
-            `-var=env_size=${envDto.size}`,
-            `-var=env_type=${envDto.type}`,
+            `-var=env=${env.env}`,
+            `-var=owner=${env.owner}`,
+            `-var=env_size=${env.size}`,
+            `-var=env_type=${env.type}`,
             ...tfArgs
         ];
     }
-    async plan(envDto, tfArgs, cwd, attemptNo = 1) {
-        const args = this.tfArgs(envDto, tfArgs);
+    async plan(env, tfArgs, cwd, attemptNo = 1) {
+        const args = this.tfArgs(env, tfArgs);
         console.log('Running: terraform plan -auto-approve', ...args);
         try {
             await this.processRunner.run('terraform', ['plan', ...args], cwd);
@@ -60,21 +61,21 @@ export class TerraformAdapter {
             if (error instanceof ProcessException) {
                 if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
                     console.warn(`Retrying terraform plan due to error: ${error.message}`);
-                    return this.plan(envDto, tfArgs, cwd, attemptNo + 1);
+                    return this.plan(env, tfArgs, cwd, attemptNo + 1);
                 }
-                const lockId = this.lockId(attemptNo, error);
+                const lockId = this.lockId(error, attemptNo);
                 if (lockId) {
                     await this.promptUnlock(lockId, cwd);
                     console.info('State unlocked, retrying terraform plan');
-                    return this.plan(envDto, tfArgs, cwd, attemptNo + 1);
+                    return this.plan(env, tfArgs, cwd, attemptNo + 1);
                 }
                 throw new KnownException(`terraform plan failed with code ${error.code}:\n${error.message}`, { cause: error });
             }
             throw error;
         }
     }
-    async deploy(envDto, tfArgs, cwd, attemptNo = 1) {
-        const args = this.tfArgs(envDto, tfArgs);
+    async apply(env, tfArgs, cwd, attemptNo = 1) {
+        const args = this.tfArgs(env, tfArgs);
         console.log('Running: terraform apply -auto-approve', ...args);
         this.printTime();
         try {
@@ -85,20 +86,48 @@ export class TerraformAdapter {
             if (error instanceof ProcessException) {
                 if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
                     console.warn(`Retrying terraform apply due to error: ${error.message}`);
-                    return this.deploy(envDto, tfArgs, cwd, attemptNo + 1);
+                    return this.apply(env, tfArgs, cwd, attemptNo + 1);
                 }
-                const lockId = this.lockId(attemptNo, error);
+                const lockId = this.lockId(error, attemptNo);
                 if (lockId) {
                     await this.promptUnlock(lockId, cwd);
                     console.info('State unlocked, retrying terraform apply');
-                    return this.deploy(envDto, tfArgs, cwd, attemptNo + 1);
+                    return this.apply(env, tfArgs, cwd, attemptNo + 1);
                 }
                 throw new KnownException(`terraform apply failed with code ${error.code}:\n${error.message}`, { cause: error });
             }
             throw error;
         }
     }
-    lockId(attemptNo, error) {
+    async destroy(env, tfArgs, cwd, attemptNo = 1) {
+        let wrongDir = false;
+        const scanner = (line) => {
+            if (line.includes('Either you have not created any objects yet or the existing objects were')) {
+                wrongDir = true;
+            }
+        };
+        const args = this.tfArgs(env, tfArgs);
+        console.log('Running: terraform destroy -auto-approve');
+        try {
+            await this.processRunner.run('terraform', ['destroy', '-auto-approve', ...args], cwd, scanner);
+        }
+        catch (error) {
+            if (error instanceof ProcessException) {
+                const lockId = this.lockId(error, attemptNo);
+                if (lockId) {
+                    await this.promptUnlock(lockId, cwd);
+                    console.info('State unlocked, retrying terraform destroy');
+                    return this.destroy(env, tfArgs, cwd, attemptNo + 1);
+                }
+                throw new KnownException(`terraform destroy failed with code ${error.code}:\n${error.message}`, { cause: error });
+            }
+            throw error;
+        }
+        if (wrongDir) {
+            throw new KnownException('Can not find terraform files. Command needs to be run in a directory with terraform files');
+        }
+    }
+    lockId(error, attemptNo = 1) {
         if (attemptNo < MAX_ATTEMPTS && error.message.includes('Error acquiring the state lock')) {
             const match = error.message.match(/ID:\s+([a-f0-9-]{36})/i);
             if (match) {
@@ -108,11 +137,11 @@ export class TerraformAdapter {
         }
     }
     async promptUnlock(id, cwd) {
-        const answerYes = await promptYesNo('Terraform state is locked. Most often due to previously interrupted process.\n'
+        const answerYes = await this.cliHelper.promptYesNo('Terraform state is locked. Most often due to previously interrupted process.\n'
             + 'Rarely (main lock intention) is when another process actively work with the state to avoid inconsistent modification.\n'
             + 'Do you want to force unlock?: ');
         if (!answerYes) {
-            throw new ExitException();
+            throw new AbortedException();
         }
         console.log('Force unlocking state');
         await this.processRunner.run('terraform', ['force-unlock', '-force', id], cwd);

package/dist/client/index.js

@@ -1,3 +1,4 @@
+export { CliHelper } from './CliHelper.js';
 export { EnvApiClient } from './EnvApiClient.js';
 export { HttpClient } from './HttpClient.js';
 export { TerraformAdapter } from './TerraformAdapter.js';

package/dist/commands/{keys.js → _keys.js}

@@ -1,4 +1,4 @@
-export const KEYS = {
+export const _keys = {
     CWD: 'Working directory (default: current directory)',
     ENV: 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)',
     KIND: 'Environment kind: complete project (default) or some slice such as tt-core + tt-web',

package/dist/commands/{utils.js → _utils.js}

@@ -1,6 +1,5 @@
 import { ExitPromptError } from '@inquirer/core';
-import inquirer from 'inquirer';
-import { BusinessException, ExitException, KnownException } from '../exceptions.js';
+import { BusinessException, AbortedException, KnownException } from '../exceptions.js';
 export function wrap(callable) {
     return async (...args) => {
         let result;
@@ -11,7 +10,7 @@ export function wrap(callable) {
             if (error instanceof KnownException || error instanceof BusinessException) {
                 console.error(error.message);
             }
-            else if (error instanceof ExitException || error instanceof ExitPromptError) {
+            else if (error instanceof AbortedException || error instanceof ExitPromptError) {
             }
             else {
                 console.error('Unknown error:', error);
@@ -23,12 +22,3 @@ export function wrap(callable) {
         }
     };
 }
-export async function promptYesNo(message, defaultValue = false) {
-    const { answer } = await inquirer.prompt([{
-            type: 'confirm',
-            name: 'answer',
-            message,
-            default: defaultValue,
-        }]);
-    return answer;
-}

package/dist/commands/configure.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
 import { configService } from '../container.js';
-import { wrap } from './utils.js';
+import { wrap } from './_utils.js';
 export function configure(program) {
     program
         .command('configure')

package/dist/commands/delete.js

@@ -1,18 +1,17 @@
 import { Command } from 'commander';
-import { envCtl } from '../container.js';
-import { KEYS } from './keys.js';
-import { wrap } from './utils.js';
-import { ensureEnv } from './validation.js';
+import { cliHelper, envCtl } from '../container.js';
+import { _keys } from './_keys.js';
+import { wrap } from './_utils.js';
 export function deleteIt(program) {
     program
         .command('delete')
         .description('Delete a development environment')
-        .option('--env <env>', KEYS.ENV)
-        .option('--project <project>', KEYS.PROJECT)
+        .option('--project <project>', _keys.PROJECT)
+        .option('--env <env>', _keys.ENV)
         .action(wrap(handler));
 }
 async function handler(options) {
-    let { env, project } = options;
-    env = ensureEnv(env);
-    await envCtl.delete(project, env);
+    const { project, env } = options;
+    const envName = cliHelper.ensureEnv(env);
+    await envCtl.delete(project, envName);
 }

package/dist/commands/deploy.js

@@ -1,59 +1,24 @@
 import { Command } from 'commander';
-import inquirer from 'inquirer';
-import { configService, envCtl } from '../container.js';
-import { KnownException } from '../exceptions.js';
-import { EnvType } from '../model/index.js';
-import { EnvSize } from '../model/index.js';
-import { KEYS } from './keys.js';
-import { wrap } from './utils.js';
-import { ensureEnumValue, ensureKind } from './validation.js';
+import { awsCredsHelper, envCtl } from '../container.js';
+import { _keys } from './_keys.js';
+import { wrap } from './_utils.js';
 export function deploy(program) {
     program
         .command('deploy')
         .description('Create new or update existing dev environment')
-        .option('--project <project>', KEYS.PROJECT)
-        .option('--env <env>', KEYS.ENV)
-        .option('--owner <owner>', KEYS.OWNER)
-        .option('--size <size>', KEYS.SIZE)
-        .option('--type <type>', KEYS.TYPE, EnvType.Dev)
-        .option('--kind <kind>', KEYS.KIND)
-        .option('--cwd <cwd>', KEYS.CWD)
+        .option('--project <project>', _keys.PROJECT)
+        .option('--env <env>', _keys.ENV)
+        .option('--owner <owner>', _keys.OWNER)
+        .option('--size <size>', _keys.SIZE)
+        .option('--type <type>', _keys.TYPE)
+        .option('--kind <kind>', _keys.KIND)
+        .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
         .argument('[args...]')
         .action(wrap(handler));
 }
 async function handler(tfArgs, options) {
-    const envDto = await parseEnvDto(options);
-    await envCtl.deploy(envDto, tfArgs, options.cwd);
-}
-export async function parseEnvDto(options) {
-    let { project, env, owner, size, type, kind, cwd } = options;
-    if (!owner) {
-        owner = configService.getOwner();
-        if (!owner) {
-            throw new KnownException('when called without --owner option, first call \'envctl configure\'');
-        }
-        console.log(`Owner not provided, default to configured owner ${owner}`);
-    }
-    if (!env) {
-        console.log(`Env name not provided, default to owner name ${owner}`);
-        env = owner;
-    }
-    kind = ensureKind(kind, cwd);
-    let envSize;
-    if (size) {
-        envSize = ensureEnumValue(EnvSize, size, 'size');
-    }
-    else {
-        const answer = await inquirer.prompt([{
-                type: 'list',
-                name: 'size',
-                message: 'Environment size:',
-                choices: Object.values(EnvSize),
-                default: EnvSize.Small,
-            }]);
-        envSize = answer.size;
-    }
-    const envType = ensureEnumValue(EnvType, type, 'type');
-    return { project, env, owner, size: envSize, type: envType, kind };
+    await awsCredsHelper.ensureCredentials();
+    const { cwd, ...envDto } = options;
+    await envCtl.deploy(envDto, tfArgs, cwd);
 }

package/dist/commands/destroy.js

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+import { cliHelper, envCtl } from '../container.js';
+import { _keys } from './_keys.js';
+import { wrap } from './_utils.js';
+export function destroy(program) {
+    program
+        .command('destroy')
+        .description('Destroy environment resources. This is thin wrapper for terraform destroy.'
+        + ' Unlike "delete" command (which just schedule deletion) this command deletes resources synchronously.'
+        + ' Main use case - test deletion process, basically that you have enough permissions to delete resources')
+        .option('--project <project>', _keys.PROJECT)
+        .option('--env <env>', _keys.ENV)
+        .option('--cwd <cwd>', _keys.CWD)
+        .allowUnknownOption(true)
+        .argument('[args...]')
+        .action(wrap(handler));
+}
+async function handler(tfArgs, options) {
+    const { project, env, cwd } = options;
+    const envName = cliHelper.ensureEnv(env);
+    await envCtl.destroy(project, envName, tfArgs, cwd);
+}

package/dist/commands/index.js

@@ -1,5 +1,6 @@
 export { configure } from './configure.js';
-export { deploy } from './deploy.js';
 export { deleteIt } from './delete.js';
+export { deploy } from './deploy.js';
+export { destroy } from './destroy.js';
 export { plan } from './plan.js';
 export { status } from './status.js';

package/dist/commands/plan.js

@@ -1,24 +1,24 @@
 import { Command } from 'commander';
-import { envCtl } from '../container.js';
-import { EnvType } from '../model/index.js';
-import { parseEnvDto } from './deploy.js';
-import { KEYS } from './keys.js';
-import { wrap } from './utils.js';
+import { awsCredsHelper, envCtl } from '../container.js';
+import { _keys } from './_keys.js';
+import { wrap } from './_utils.js';
 export function plan(program) {
     program
         .command('plan')
         .description('High level wrapper for terraform plan. Compliments deploy command: if you plan to deploy env with envctl deploy,'
         + ' then it is recommended to do plan with envctl plan to guarantee consistent behavior')
-        .option('--env <env>', KEYS.ENV)
-        .option('--owner <owner>', KEYS.OWNER)
-        .option('--size <size>', KEYS.SIZE)
-        .option('--type <type>', KEYS.TYPE, EnvType.Dev)
-        .option('--cwd <cwd>', KEYS.CWD)
+        .option('--project <project>', _keys.PROJECT)
+        .option('--env <env>', _keys.ENV)
+        .option('--owner <owner>', _keys.OWNER)
+        .option('--size <size>', _keys.SIZE)
+        .option('--type <type>', _keys.TYPE)
+        .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
         .argument('[args...]')
         .action(wrap(handler));
 }
 async function handler(tfArgs, options) {
-    const envDto = await parseEnvDto(options);
-    await envCtl.plan(envDto, tfArgs, options.cwd);
+    await awsCredsHelper.ensureCredentials();
+    const { cwd, ...envDto } = options;
+    await envCtl.plan(envDto, tfArgs, cwd);
 }

package/dist/commands/status.js

@@ -1,18 +1,17 @@
 import { Command } from 'commander';
-import { envCtl } from '../container.js';
-import { KEYS } from './keys.js';
-import { wrap } from './utils.js';
-import { ensureEnv } from './validation.js';
+import { cliHelper, envCtl } from '../container.js';
+import { _keys } from './_keys.js';
+import { wrap } from './_utils.js';
 export function status(program) {
     program
         .command('status')
         .description('Get env status')
-        .option('--env <env>', KEYS.ENV)
-        .option('--project <project>', KEYS.PROJECT)
+        .option('--project <project>', _keys.PROJECT)
+        .option('--env <env>', _keys.ENV)
         .action(wrap(handler));
 }
 async function handler(options) {
-    let { env, project } = options;
-    env = ensureEnv(env);
-    await envCtl.status(project, env);
+    const { project, env } = options;
+    const envName = cliHelper.ensureEnv(env);
+    await envCtl.status(project, envName);
 }

package/dist/container.js

@@ -1,10 +1,13 @@
-import { EnvApiClient, HttpClient, TerraformAdapter } from './client/index.js';
+import { AwsCredsHelper } from './client/AwsCredsHelper.js';
+import { CliHelper, EnvApiClient, HttpClient, TerraformAdapter } from './client/index.js';
 import { ProcessRunner } from './client/ProcessRunner.js';
 import { ConfigService, EnvCtl } from './service/index.js';
 const configService = new ConfigService();
-const httpClient = new HttpClient();
+const cliHelper = new CliHelper(configService);
+const awsCredsHelper = new AwsCredsHelper();
+const httpClient = new HttpClient(awsCredsHelper);
 const envApiClient = new EnvApiClient(httpClient);
 const processRunner = new ProcessRunner();
-const terraformAdapter = new TerraformAdapter(processRunner);
-const envCtl = new EnvCtl(envApiClient, terraformAdapter);
-export { configService, envCtl };
+const terraformAdapter = new TerraformAdapter(processRunner, cliHelper);
+const envCtl = new EnvCtl(cliHelper, envApiClient, terraformAdapter);
+export { awsCredsHelper, cliHelper, configService, envCtl };

package/dist/exceptions.js

@@ -4,10 +4,10 @@ export class KnownException extends Error {
         this.name = 'KnownException';
     }
 }
-export class ExitException extends Error {
+export class AbortedException extends Error {
     constructor() {
         super();
-        this.name = 'ExitException';
+        this.name = 'AbortedException';
     }
 }
 export class HttpException extends Error {

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from 'module';
 import { Command } from 'commander';
 import updateNotifier from 'update-notifier';
-import { configure, deleteIt, deploy, plan, status } from './commands/index.js';
+import { configure, deleteIt, deploy, destroy, plan, status } from './commands/index.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
@@ -12,8 +12,9 @@ program
     .description('CLI to manage environments')
     .version(pkg.version);
 configure(program);
-deploy(program);
 deleteIt(program);
+deploy(program);
+destroy(program);
 plan(program);
 status(program);
 program.parse(process.argv);

package/dist/service/EnvCtl.js

@@ -1,10 +1,11 @@
-import { promptYesNo } from '../commands/utils.js';
 import { KnownException } from '../exceptions.js';
 import { EnvSizeAvgTime, EnvStatus } from '../model/index.js';
 export class EnvCtl {
+    cliHelper;
     envApi;
     terraformAdapter;
-    constructor(envApi, terraformAdapter) {
+    constructor(cliHelper, envApi, terraformAdapter) {
+        this.cliHelper = cliHelper;
         this.envApi = envApi;
         this.terraformAdapter = terraformAdapter;
     }
@@ -21,95 +22,159 @@ export class EnvCtl {
         }
         console.log(`Env ${key} status: ${env.status}`);
     }
-    async plan(envDto, tfArgs, cwd) {
-        const key = this.key(envDto.project, envDto.env);
-        console.log(`Check if env ${key} already exists`);
-        const env = await this.envApi.get(key);
-        if (env !== null) {
-            this.checkEnv(env, envDto);
+    async tryGetEnv(input) {
+        let envName = input.env;
+        let owner = input.owner;
+        if (!envName) {
+            owner = this.cliHelper.ensureOwner(owner);
+            console.log(`Env name not provided, default to owner name ${owner}`);
+            envName = owner;
         }
-        await this.terraformAdapter.init(key, cwd);
-        await this.terraformAdapter.plan(envDto, tfArgs, cwd);
-    }
-    async deploy(envDto, tfArgs, cwd) {
-        const key = this.key(envDto.project, envDto.env);
+        const key = this.key(input.project, envName);
         console.log(`Check if env ${key} already exists`);
         const env = await this.envApi.get(key);
-        if (env === null) {
-            console.log(`Env ${key} does not exist, creating it`);
-            await this.terraformAdapter.init(key, cwd);
-            console.log('Creating env tracking record in DynamoDB');
-            const { owner, size, type, kind } = envDto;
-            const createEnv = { key, ephemeral: false, owner, size, type, kind };
-            await this.envApi.create(createEnv);
-            return await this.runDeploy(key, envDto, tfArgs, cwd);
-        }
-        this.checkEnv(env, envDto);
-        switch (env.status) {
-            case EnvStatus.Creating:
-            case EnvStatus.Updating: {
-                const answerYes = await promptYesNo(`Env status is ${env.status}, likely to be an error from a previous run\n`
-                    + 'Do you want to proceed with deployment?');
-                if (answerYes) {
-                    await this.runDeploy(key, envDto, tfArgs, cwd);
-                }
-                break;
-            }
-            case EnvStatus.Active: {
-                console.log('Env status is ACTIVE\nWill lock for update and run terraform apply (to update resources)');
-                await this.envApi.lockForUpdate(key);
-                await this.runDeploy(key, envDto, tfArgs, cwd);
-            }
+        if (env) {
+            console.log(`Found ${key} env`);
+        }
+        else {
+            console.log(`Env ${key} does not exist`);
         }
+        return { envName, owner, key, env };
     }
-    checkEnv(env, envDto) {
+    checkInput(envName, env, input) {
         if (env.ephemeral) {
             throw new KnownException(`Attempted to convert ephemeral env to non-ephemeral`);
         }
-        if (env.owner !== envDto.owner) {
-            throw new KnownException(`Can not change env owner ${env.owner} -> ${envDto.owner}`);
+        if (input.owner && env.owner !== input.owner) {
+            throw new KnownException(`Can not change env owner ${env.owner} -> ${input.owner}`);
         }
-        if (env.size !== envDto.size) {
-            throw new KnownException(`Can not change env size ${env.size} -> ${envDto.size}`);
+        if (input.size && env.size !== input.size) {
+            throw new KnownException(`Can not change env size ${env.size} -> ${input.size}`);
         }
-        if (env.type !== envDto.type) {
-            throw new KnownException(`Can not change env type ${env.type} -> ${envDto.type}`);
+        if (input.type && env.type !== input.type) {
+            throw new KnownException(`Can not change env type ${env.type} -> ${input.type}`);
         }
-        if (env.kind !== envDto.kind) {
-            throw new KnownException(`Can not change env kind ${env.kind} -> ${envDto.kind}`);
+        if (input.kind && env.kind !== input.kind) {
+            throw new KnownException(`Can not change env kind ${env.kind} -> ${input.kind}`);
+        }
+        const { owner, size, type, kind } = env;
+        return {
+            project: input.project, env: envName,
+            owner, size, type, kind,
+        };
+    }
+    checkStatus(env, availableStatuses = [EnvStatus.Active, EnvStatus.Creating, EnvStatus.Updating]) {
+        if (availableStatuses.includes(env.status)) {
+            return;
         }
         if (env.status === EnvStatus.Deleting) {
             const time = EnvSizeAvgTime[env.size];
             throw new KnownException(`Env status is DELETING, please wait (~${time} min)`);
         }
+        throw new KnownException(`Env status is ${env.status}, can not run this command`);
+    }
+    async plan(input, tfArgs, cwd) {
+        const { envName, owner, key, env } = await this.tryGetEnv(input);
+        if (env == null) {
+            const envInput = await this.cliHelper.parseEnvInput(input, envName, owner, cwd);
+            await this.terraformAdapter.init(key, cwd);
+            await this.terraformAdapter.plan(envInput, tfArgs, cwd);
+            return;
+        }
+        const envInput = this.checkInput(envName, env, input);
+        this.checkStatus(env);
+        await this.promptUnlock(env);
+        if (env.status !== EnvStatus.Active) {
+            throw new KnownException(`Env ${env.key} status is ${env.status}, can not run plan`);
+        }
+        await this.terraformAdapter.plan(envInput, tfArgs, cwd);
+    }
+    async deploy(input, tfArgs, cwd) {
+        const { envName, owner, key, env } = await this.tryGetEnv(input);
+        if (env === null) {
+            const envInput = await this.cliHelper.parseEnvInput(input, envName, owner, cwd);
+            await this.terraformAdapter.init(key, cwd);
+            console.log('Creating env tracking record in DynamoDB');
+            const { size, type, kind } = envInput;
+            const createEnv = { key, ephemeral: false, owner: envInput.owner, size, type, kind };
+            const newEnv = await this.envApi.create(createEnv);
+            return await this.runDeploy(newEnv, envName, tfArgs, cwd);
+        }
+        this.checkInput(envName, env, input);
+        this.checkStatus(env);
+        if (env.status == EnvStatus.Creating || env.status == EnvStatus.Updating) {
+            const answerYes = await this.cliHelper.promptYesNo(`Env status is ${env.status}, likely to be an error from a previous run\n`
+                + 'Do you want to proceed with deployment?');
+            if (!answerYes) {
+                console.log('Aborting deployment');
+                return;
+            }
+        }
+        if (env.status === EnvStatus.Active) {
+            console.log('Env status is ACTIVE\nWill lock for update and run terraform apply (to update resources)');
+            await this.envApi.lockForUpdate(env);
+        }
+        await this.runDeploy(env, envName, tfArgs, cwd);
     }
-    async runDeploy(key, envDto, tfArgs, cwd) {
+    async runDeploy(env, envName, tfArgs, cwd) {
         console.log('Deploying resources');
-        await this.terraformAdapter.deploy(envDto, tfArgs, cwd);
+        const { owner, size, type } = env;
+        const envTf = { owner, size, type, env: envName };
+        await this.terraformAdapter.apply(envTf, tfArgs, cwd);
         console.log('Activating env (to finish creation)');
-        await this.envApi.activate(key);
+        await this.envApi.activate(env);
         console.log('Lock env to run db evolution');
-        await this.envApi.lockForUpdate(key);
+        await this.envApi.lockForUpdate(env);
         console.log('Unlock env after db evolution');
-        await this.envApi.activate(key);
+        await this.envApi.activate(env);
     }
     async delete(project, envName) {
+        const env = await this.get(project, envName);
+        this.checkStatus(env);
+        await this.promptUnlock(env);
+        if (env.status !== EnvStatus.Active) {
+            throw new KnownException(`Env ${env.key} status is ${env.status}, can not delete`);
+        }
+        console.log('Deleting env');
+        const statusMessage = await this.envApi.delete(env);
+        console.log(statusMessage);
+    }
+    async destroy(project, envName, tfArgs, cwd) {
+        const env = await this.get(project, envName);
+        this.checkStatus(env);
+        await this.promptUnlock(env, [EnvStatus.Creating]);
+        if (env.status === EnvStatus.Active) {
+            console.log('Lock env to run destroy');
+            await this.envApi.lockForUpdate(env);
+        }
+        const { owner, size, type } = env;
+        const tfEnv = { owner, size, type, env: envName };
+        console.log('Destroying env resources');
+        await this.terraformAdapter.destroy(tfEnv, tfArgs, cwd);
+        console.log('Unlock env');
+        await this.envApi.activate(env);
+        console.log('Schedule env metadata deletion');
+        const statusMessage = await this.envApi.delete(env);
+        console.log(statusMessage);
+        console.log('Please wait for ~1 min before you can create env with same name');
+    }
+    async get(project, envName) {
         const key = this.key(project, envName);
-        console.log(`Retrieve env`);
+        console.log(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
-        if (env === null) {
+        if (!env) {
             throw new KnownException(`Environment ${key} does not exist`);
         }
-        if (env.status === EnvStatus.Creating) {
-            const answerYes = await promptYesNo('Environment is still being created.\nDo you want to delete it?');
-            if (!answerYes) {
-                throw new KnownException('Aborting env deletion');
+        return env;
+    }
+    async promptUnlock(env, statuses = [EnvStatus.Creating, EnvStatus.Updating]) {
+        if (statuses.includes(env.status)) {
+            const answerYes = await this.cliHelper.promptYesNo(`Env status is ${env.status}, likely to be an error from a previous run\n`
+                + 'Do you want to unlock it?');
+            if (answerYes) {
+                await this.envApi.activate(env);
+                env.status = EnvStatus.Active;
             }
-            console.log('Activate (unlock) env (so it can be deleted)');
-            await this.envApi.activate(key);
         }
-        console.log('Deleting env');
-        const statusMessage = await this.envApi.delete(key);
-        console.log(statusMessage);
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
@@ -30,7 +30,8 @@
     "run-status": "tsc --sourceMap true && npm run run -- status",
     "run-plan": "tsc --sourceMap true && npm run run -- plan --size min --cwd ../tt-core",
     "run-deploy": "tsc --sourceMap true && npm run run -- deploy --size min --cwd ../tt-core",
-    "run-delete": "tsc --sourceMap true && npm run run -- delete"
+    "run-delete": "tsc --sourceMap true && npm run run -- delete",
+    "run-destroy": "tsc --sourceMap true && npm run run -- destroy --cwd ../tt-core"
   },
   "dependencies": {
     "@aws-sdk/client-sts": "^3.716.0",

package/dist/commands/validation.js

@@ -1,44 +0,0 @@
-import path from 'path';
-import { configService } from '../container.js';
-import { KnownException } from '../exceptions.js';
-export function ensureKind(kind, cwd) {
-    if (kind) {
-        return kind;
-    }
-    kind = getDirName(cwd);
-    console.log(`Inferred kind from directory name: ${kind}`);
-    return kind;
-}
-function getDirName(cwd) {
-    cwd = resolveCwd(cwd);
-    return path.basename(cwd);
-}
-function resolveCwd(cwd) {
-    if (!cwd) {
-        return process.cwd();
-    }
-    if (path.isAbsolute(cwd)) {
-        return cwd;
-    }
-    return path.resolve(process.cwd(), cwd);
-}
-export function ensureEnumValue(enumObj, value, name) {
-    const values = Object.values(enumObj);
-    if (!values.includes(value)) {
-        throw new KnownException(`Invalid ${name}: "${value}". Must be one of: ${values.join(', ')}`);
-    }
-    return value;
-}
-export function ensureEnv(env) {
-    if (env) {
-        return env;
-    }
-    const owner = configService.getOwner();
-    if (!owner) {
-        throw new KnownException('--env argument is not provided\n'
-            + 'default to owner from local configuration, but it is not configured\n'
-            + 'please call with --env argument or run \'envctl configure\' to configure owner');
-    }
-    console.log(`Env name not provided, default to owner name ${owner}`);
-    return owner;
-}