@agilecustoms/envctl 0.26.0 → 0.27.1

package/README.md

@@ -7,8 +7,8 @@
 
 ```shell
 terraform init -backend-config=key=laxa1986
-# TODO: remove --env in next minor release
-envctl deploy --env laxa1986 -var-file=versions.tfvars -var="log_level=debug"
+envctl deploy -var-file=versions.tfvars -var="log_level=debug"
+envctl delete
 ```
 
 ## setup/update

package/dist/backend/S3Backend.js

@@ -0,0 +1,8 @@
+export class S3Backend {
+    getType() {
+        return 's3';
+    }
+    getKey(config) {
+        return config['key'];
+    }
+}

package/dist/backend/TerraformBackend.js

@@ -0,0 +1 @@
+export {};

package/dist/client/CliHelper.js

@@ -1,12 +1,7 @@
 import path from 'path';
 import inquirer from 'inquirer';
-import { KnownException } from '../exceptions.js';
-import { ConfigService } from '../service/index.js';
 export class CliHelper {
-    configService;
-    constructor(configService) {
-        this.configService = configService;
-    }
+    constructor() { }
     async promptYesNo(message, defaultValue = false) {
         const { answer } = await inquirer.prompt([{
                 type: 'confirm',
@@ -16,34 +11,8 @@ export class CliHelper {
             }]);
         return answer;
     }
-    ensureEnv(key) {
-        if (key) {
-            return key;
-        }
-        const owner = this.configService.getOwner();
-        if (!owner) {
-            throw new KnownException('--key argument is not provided\n'
-                + 'default to owner from local configuration, but it is not configured\n'
-                + 'please call with --key argument or run \'envctl configure\' to configure owner');
-        }
-        console.log(`Key is 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;
-    }
-    ensureKind(kind, cwd) {
-        if (kind) {
-            return kind;
-        }
-        kind = getDirName(cwd);
+    getKind(cwd) {
+        const kind = getDirName(cwd);
         console.log(`Inferred kind from directory name: ${kind}`);
         return kind;
     }

package/dist/client/ProcessRunner.js

@@ -1,14 +1,7 @@
 import { spawn } from 'child_process';
-import path from 'path';
 import * as readline from 'readline';
-import { fileURLToPath } from 'url';
 import { ProcessException } from '../exceptions.js';
 export class ProcessRunner {
-    async runScript(script, args = [], cwd, scanner) {
-        const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const scriptPath = path.join(__dirname, `../../scripts/${script}`);
-        await this.run(scriptPath, args, cwd, scanner);
-    }
     async run(command, args, cwd, out_scanner, in_scanner) {
         const spawnOptions = {
             stdio: ['pipe', 'pipe', 'pipe'],

package/dist/client/TerraformAdapter.js

@@ -10,9 +10,48 @@ const RETRYABLE_ERRORS = [
 export class TerraformAdapter {
     processRunner;
     cliHelper;
-    constructor(processRunner, cliHelper) {
+    backends;
+    constructor(processRunner, cliHelper, backends) {
         this.processRunner = processRunner;
         this.cliHelper = cliHelper;
+        this.backends = backends.reduce((acc, backend) => {
+            acc.set(backend.getType(), backend);
+            return acc;
+        }, new Map());
+    }
+    getKey(cwd) {
+        const dir = cwd ?? process.cwd();
+        const statePath = path.join(dir, '.terraform', 'terraform.tfstate');
+        if (!fs.existsSync(statePath)) {
+            throw new KnownException(`Terraform state file not found at: ${statePath}`);
+        }
+        let content;
+        try {
+            content = fs.readFileSync(statePath, 'utf8');
+        }
+        catch (err) {
+            throw new KnownException(`Failed to read terraform state file: ${statePath}`, { cause: err });
+        }
+        let tfstate;
+        try {
+            tfstate = JSON.parse(content);
+        }
+        catch (err) {
+            throw new KnownException(`Failed to parse terraform state file: ${statePath}`, { cause: err });
+        }
+        const backendJson = tfstate.backend;
+        const type = backendJson?.type;
+        const backend = this.backends.get(type);
+        if (backend === undefined) {
+            const supportedBackends = Array.from(this.backends.keys()).join(',');
+            throw new KnownException(`Unsupported terraform backend type: ${type}. Supported types: ${supportedBackends}`);
+        }
+        const config = backendJson?.config;
+        const key = backend.getKey(config);
+        if (!key) {
+            throw new KnownException(`Terraform backend config does not contain 'key' attribute`);
+        }
+        return key;
     }
     printTime() {
         const now = new Date();

package/dist/commands/createEphemeral.js

@@ -6,12 +6,11 @@ export function createEphemeral(program) {
     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('--owner <owner>', _keys.OWNER)
+        .option('--cwd <cwd>', _keys.CWD)
         .action(wrap(handler));
 }
 async function handler(options) {
-    const { key, owner } = options;
-    const token = await envCtl.createEphemeral(key, owner);
+    const { cwd } = options;
+    const token = await envCtl.createEphemeral(cwd);
     console.log(token);
 }

package/dist/commands/delete.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { cliHelper, envCtl } from '../container.js';
+import { envCtl } from '../container.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
 export function deleteIt(program) {
@@ -13,6 +13,5 @@ export function deleteIt(program) {
 }
 async function handler(options) {
     const { key, force, cwd } = options;
-    const theKey = cliHelper.ensureEnv(key);
-    await envCtl.delete(theKey, Boolean(force), cwd);
+    await envCtl.delete(Boolean(force), key, cwd);
 }

package/dist/commands/deploy.js

@@ -6,9 +6,6 @@ export function deploy(program) {
     program
         .command('deploy')
         .description('Create new or update existing dev environment')
-        .option('--key <key>', _keys.KEY)
-        .option('--owner <owner>', _keys.OWNER)
-        .option('--kind <kind>', _keys.KIND)
         .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
         .argument('[args...]')
@@ -16,6 +13,6 @@ export function deploy(program) {
 }
 async function handler(tfArgs, options) {
     await awsCredsHelper.ensureCredentials();
-    const { cwd, ...envDto } = options;
-    await envCtl.deploy(envDto, tfArgs, cwd);
+    const { cwd } = options;
+    await envCtl.deploy(tfArgs, cwd);
 }

package/dist/commands/destroy.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { cliHelper, envCtl } from '../container.js';
+import { envCtl } from '../container.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
 export function destroy(program) {
@@ -7,8 +7,8 @@ export function destroy(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.'
+        + ' Unlike "delete" command, this command doesn\'t have --key option, it can only delete env after key you provided during terraform init.'
         + ' Main use case - test deletion process, basically that you have enough permissions to delete resources')
-        .option('--key <key>', _keys.KEY)
         .option('--force', _keys.FORCE)
         .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
@@ -16,7 +16,6 @@ export function destroy(program) {
         .action(wrap(handler));
 }
 async function handler(tfArgs, options) {
-    const { key, force, cwd } = options;
-    const theKey = cliHelper.ensureEnv(key);
-    await envCtl.destroy(theKey, tfArgs, Boolean(force), cwd);
+    const { force, cwd } = options;
+    await envCtl.destroy(tfArgs, Boolean(force), cwd);
 }

package/dist/commands/plan.js

@@ -7,8 +7,6 @@ export function plan(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('--key <key>', _keys.KEY)
-        .option('--owner <owner>', _keys.OWNER)
         .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
         .argument('[args...]')
@@ -16,6 +14,6 @@ export function plan(program) {
 }
 async function handler(tfArgs, options) {
     await awsCredsHelper.ensureCredentials();
-    const { cwd, ...envDto } = options;
-    await envCtl.plan(envDto, tfArgs, cwd);
+    const { cwd } = options;
+    await envCtl.plan(tfArgs, cwd);
 }

package/dist/commands/status.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { cliHelper, envCtl } from '../container.js';
+import { envCtl } from '../container.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
 export function status(program) {
@@ -12,6 +12,5 @@ export function status(program) {
 }
 async function handler(options) {
     const { key, cwd } = options;
-    const theKey = cliHelper.ensureEnv(key);
-    await envCtl.status(theKey, cwd);
+    await envCtl.status(key, cwd);
 }

package/dist/container.js

@@ -1,13 +1,17 @@
+import { S3Backend } from './backend/S3Backend.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 cliHelper = new CliHelper();
 const configService = new ConfigService();
-const cliHelper = new CliHelper(configService);
 const awsCredsHelper = new AwsCredsHelper();
+const backends = [
+    new S3Backend()
+];
 const httpClient = new HttpClient(awsCredsHelper);
 const envApiClient = new EnvApiClient(httpClient);
 const processRunner = new ProcessRunner();
-const terraformAdapter = new TerraformAdapter(processRunner, cliHelper);
-const envCtl = new EnvCtl(cliHelper, envApiClient, terraformAdapter);
-export { awsCredsHelper, cliHelper, configService, envCtl };
+const terraformAdapter = new TerraformAdapter(processRunner, cliHelper, backends);
+const envCtl = new EnvCtl(cliHelper, envApiClient, terraformAdapter, configService);
+export { awsCredsHelper, configService, envCtl };

package/dist/service/ConfigService.js

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import path from 'path';
+import { KnownException } from '../exceptions.js';
 const CONFIG_PATH = path.join(os.homedir(), '.envctl', 'config.json');
 export class ConfigService {
     config;
@@ -23,6 +24,10 @@ export class ConfigService {
         return this.config;
     }
     getOwner() {
-        return this.loadConfig()?.owner;
+        const owner = this.loadConfig()?.owner;
+        if (!owner) {
+            throw new KnownException('please first set owner via calling \'envctl configure\'');
+        }
+        return owner;
     }
 }

package/dist/service/EnvCtl.js

@@ -4,32 +4,37 @@ export class EnvCtl {
     cliHelper;
     envApi;
     terraformAdapter;
-    constructor(cliHelper, envApi, terraformAdapter) {
+    configService;
+    constructor(cliHelper, envApi, terraformAdapter, configService) {
         this.cliHelper = cliHelper;
         this.envApi = envApi;
         this.terraformAdapter = terraformAdapter;
+        this.configService = configService;
+    }
+    getKey(key, cwd) {
+        if (!key) {
+            console.log('Key is not provided, inferring from .terraform/terraform.tfstate file');
+            key = this.terraformAdapter.getKey(cwd);
+        }
+        return key;
     }
     async status(key, cwd) {
+        key = this.getKey(key, cwd);
         console.log(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (env === null) {
             console.log(`Env ${key} does not exist`);
             return;
         }
-        const kind = env.kind ? this.cliHelper.ensureKind(undefined, cwd) : undefined;
         console.log(`Env ${key} status: ${env.status}`);
-        if (env.kind && env.kind !== kind) {
-            console.warn(`Env ${key} kind (dir-name): ${env.kind} - looks like this env was deployed from a different directory`);
+        if (env.kind) {
+            const kind = this.cliHelper.getKind(cwd);
+            if (env.kind !== kind) {
+                console.warn(`Env ${key} kind (dir-name): ${env.kind} - looks like this env was deployed from a different directory`);
+            }
         }
     }
-    async tryGetEnv(input) {
-        let key = input.key;
-        let owner = input.owner;
-        if (!key) {
-            owner = this.cliHelper.ensureOwner(owner);
-            console.log(`Env name not provided, default to owner name ${owner}`);
-            key = owner;
-        }
+    async tryGetEnv(key) {
         console.log(`Check if env ${key} already exists`);
         const env = await this.envApi.get(key);
         if (env) {
@@ -38,15 +43,19 @@ export class EnvCtl {
         else {
             console.log(`Env ${key} does not exist`);
         }
-        return { anOwner: owner, key, env };
+        return env;
     }
-    checkInput(env, input, cwd) {
-        if (input.owner && env.owner !== input.owner) {
-            throw new KnownException(`Can not change env owner ${env.owner} -> ${input.owner}`);
+    checkInput(env, owner, cwd) {
+        if (env.ephemeral)
+            return;
+        if (env.owner !== owner) {
+            throw new KnownException(`Can not change env owner ${env.owner} -> ${owner}`);
         }
-        const kind = this.cliHelper.ensureKind(input.kind, cwd);
-        if ((input.kind || env.kind) && kind !== env.kind) {
-            throw new KnownException(`Can not change env kind ${env.kind} -> ${kind}`);
+        if (env.kind) {
+            const kind = this.cliHelper.getKind(cwd);
+            if (kind !== env.kind) {
+                throw new KnownException(`Can not change env kind ${env.kind} -> ${kind}`);
+            }
         }
     }
     checkStatus(env, availableStatuses = [EnvStatus.Init, EnvStatus.Deploying, EnvStatus.Active, EnvStatus.Updating]) {
@@ -58,15 +67,16 @@ export class EnvCtl {
         }
         throw new KnownException(`Env ${env.key} status is ${env.status}, can not run this command`);
     }
-    async plan(input, tfArgs, cwd) {
-        const { anOwner, key, env } = await this.tryGetEnv(input);
+    async plan(tfArgs, cwd) {
+        const key = this.terraformAdapter.getKey(cwd);
+        const owner = this.configService.getOwner();
+        const env = await this.tryGetEnv(key);
         if (env == null) {
-            const owner = this.cliHelper.ensureOwner(anOwner);
-            await this.runPlan(key, owner, tfArgs, undefined, cwd);
+            const vars = undefined;
+            await this.runPlan(key, owner, tfArgs, vars, cwd);
             return;
         }
-        this.checkInput(env, input, cwd);
-        const owner = env.owner;
+        this.checkInput(env, owner, cwd);
         this.checkStatus(env);
         await this.promptUnlock(env);
         if (env.status !== EnvStatus.Active) {
@@ -78,25 +88,27 @@ export class EnvCtl {
         const envTerraform = { key, ephemeral: false, owner, args, vars };
         await this.terraformAdapter.plan(envTerraform, cwd);
     }
-    async createEphemeral(key, owner) {
+    async createEphemeral(cwd) {
+        const key = this.terraformAdapter.getKey(cwd);
         const env = await this.envApi.get(key);
         if (env !== null) {
             throw new KnownException(`Env ${key} already exists`);
         }
-        const createEnv = { key, owner };
+        const createEnv = { key };
         return await this.envApi.createEphemeral(createEnv);
     }
-    async deploy(input, tfArgs, cwd) {
-        const { anOwner, key, env } = await this.tryGetEnv(input);
+    async deploy(tfArgs, cwd) {
+        const key = this.terraformAdapter.getKey(cwd);
+        const owner = this.configService.getOwner();
+        const env = await this.tryGetEnv(key);
         if (env === null) {
-            const owner = this.cliHelper.ensureOwner(anOwner);
-            const kind = this.cliHelper.ensureKind(input.kind, cwd);
-            console.log('Creating env tracking record in DynamoDB');
+            const kind = this.cliHelper.getKind(cwd);
+            console.log('Creating env metadata');
             const createEnv = { key, owner, kind };
             const newEnv = await this.envApi.create(createEnv);
             return await this.runDeploy(newEnv, key, tfArgs, cwd);
         }
-        this.checkInput(env, input, cwd);
+        this.checkInput(env, owner, cwd);
         this.checkStatus(env);
         if (env.status === EnvStatus.Init) {
             await this.envApi.lockForUpdate(env);
@@ -134,7 +146,8 @@ export class EnvCtl {
         console.log('Activating env (to finish creation)');
         await this.envApi.activate(env);
     }
-    async delete(key, force, cwd) {
+    async delete(force, key, cwd) {
+        key = this.getKey(key, cwd);
         const env = await this.get(key);
         if (!force) {
             this.checkStatus(env);
@@ -143,7 +156,7 @@ export class EnvCtl {
                 console.log(`Env ${env.key} is deleted`);
                 return;
             }
-            const kind = this.cliHelper.ensureKind(undefined, cwd);
+            const kind = this.cliHelper.getKind(cwd);
             if (env.kind && env.kind !== kind) {
                 const answerYes = await this.cliHelper.promptYesNo(`Env ${env.key} kind (dir-name): ${env.kind}\n`
                     + 'You\'re deleting env deployed from different dir\n'
@@ -162,7 +175,8 @@ export class EnvCtl {
         const message = await this.envApi.delete(env);
         console.log(message);
     }
-    async destroy(key, tfArgs, force, cwd) {
+    async destroy(tfArgs, force, cwd) {
+        const key = this.terraformAdapter.getKey(cwd);
         const env = await this.get(key);
         this.checkStatus(env);
         if (env.status === EnvStatus.Init) {
@@ -170,7 +184,7 @@ export class EnvCtl {
             return;
         }
         if (!force) {
-            const kind = this.cliHelper.ensureKind(undefined, cwd);
+            const kind = this.cliHelper.getKind(cwd);
             if (env.kind && env.kind !== kind) {
                 throw new KnownException(`Env ${env.key} kind (dir-name): ${env.kind} - make sure you run destroy from the same directory`);
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.26.0",
+  "version": "0.27.1",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
@@ -29,19 +29,19 @@
     "run-version": "  tsc --sourceMap true && npm run run -- --version",
     "run-configure": "tsc --sourceMap true && npm run run -- configure",
     "~": "",
-    "run-init": "cd ../tt-core && terraform init -backend-config=key=laxa1986 -upgrade",
+    "run-init": "cd ../tt-core && terraform init -upgrade -backend-config=key=laxa1986",
     "run-status": " tsc --sourceMap true && npm run run -- status  --cwd ../tt-core",
     "run-plan": "   tsc --sourceMap true && npm run run -- plan    --cwd ../tt-core",
     "run-deploy": " tsc --sourceMap true && npm run run -- deploy  --cwd ../tt-core -var=\"env_size=min\"",
     "run-delete": " tsc --sourceMap true && npm run run -- delete  --cwd ../tt-core",
     "run-destroy": "tsc --sourceMap true && npm run run -- destroy --cwd ../tt-core",
     "-": "",
-    "run-ephemeral-init": "cd ../tt-gitops && terraform init -backend-config=key=test",
-    "run-ephemeral-create": " tsc --sourceMap true && npm run run -- create-ephemeral --env test",
-    "run-ephemeral-status": " tsc --sourceMap true && npm run run -- status  --env test",
-    "run-ephemeral-deploy": " tsc --sourceMap true && npm run run -- deploy  --env test --cwd ../tt-gitops -var-file=versions.tfvars",
-    "run-ephemeral-delete": " tsc --sourceMap true && npm run run -- delete  --env test --cwd ../tt-gitops --force",
-    "run-ephemeral-destroy": "tsc --sourceMap true && npm run run -- destroy --env test --cwd ../tt-gitops --force -var-file=versions.tfvars"
+    "run-ephemeral-init": "cd ../tt-gitops && terraform init -upgrade -backend-config=key=test -reconfigure",
+    "run-ephemeral-create": " tsc --sourceMap true && npm run run -- create-ephemeral --cwd ../tt-gitops",
+    "run-ephemeral-status": " tsc --sourceMap true && npm run run -- status --key test",
+    "run-ephemeral-deploy": " tsc --sourceMap true && npm run run -- deploy  --cwd ../tt-gitops -var-file=versions.tfvars",
+    "run-ephemeral-delete": " tsc --sourceMap true && npm run run -- delete  --cwd ../tt-gitops --force",
+    "run-ephemeral-destroy": "tsc --sourceMap true && npm run run -- destroy --cwd ../tt-gitops --force -var-file=versions.tfvars"
   },
   "dependencies": {
     "@aws-sdk/client-sts": "^3.716.0",

package/scripts/get-acc-alias.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# TF state is stored in S3 in format: {company}-{acc-alias}-tf-state/{key}
-# (for non ephemeral environments the {key} typically has form of {project-code}-{env-name} like tt-dev)
-# Retrieve AWS account information
-acc_id=$(aws sts get-caller-identity --query "Account" --output text)
-aws organizations list-tags-for-resource --resource-id "$acc_id" --query "Tags[?Key=='Alias'].Value" --output text