@agilecustoms/envctl 0.24.0 → 0.25.0

package/dist/client/CliHelper.js

@@ -16,17 +16,17 @@ export class CliHelper {
             }]);
         return answer;
     }
-    ensureEnv(env) {
-        if (env) {
-            return env;
+    ensureEnv(key) {
+        if (key) {
+            return key;
         }
         const owner = this.configService.getOwner();
         if (!owner) {
-            throw new KnownException('--env argument is not provided\n'
+            throw new KnownException('--key 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');
+                + 'please call with --key argument or run \'envctl configure\' to configure owner');
         }
-        console.log(`Env name not provided, default to owner name ${owner}`);
+        console.log(`Key is not provided, default to owner name ${owner}`);
         return owner;
     }
     ensureOwner(owner) {

package/dist/client/TerraformAdapter.js

@@ -69,7 +69,7 @@ export class TerraformAdapter {
     tfArgs(env, cwd) {
         const varDefs = this.getVarDefs(cwd);
         const argVars = this.getArgVars(env.args);
-        const specialFields = { ...env, env: env.envName };
+        const specialFields = { ...env, env: env.key };
         const extraArgs = [];
         for (const name of ['env', 'owner', 'ephemeral']) {
             if (varDefs[name] && !argVars[name]) {

package/dist/commands/_keys.js

@@ -1,7 +1,7 @@
 export const _keys = {
     CWD: 'Working directory (default: current directory)',
-    ENV: 'Environment name (can be git hash). = key used to store env state (s3 key in case of AWS)',
     FORCE: 'Force deletion without confirmation',
+    KEY: 'Environment name/identifier - taken from remote stake key, must be unique for a given customer',
     KIND: 'Environment kind: complete project (default) or some slice such as tt-core + tt-web',
     OWNER: 'Environment owner (GH username)'
 };

package/dist/commands/createEphemeral.js

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

package/dist/commands/delete.js

@@ -6,13 +6,13 @@ export function deleteIt(program) {
     program
         .command('delete')
         .description('Delete a development environment')
-        .option('--env <env>', _keys.ENV)
+        .option('--key <key>', _keys.KEY)
         .option('--force', _keys.FORCE)
         .option('--cwd <cwd>', _keys.CWD)
         .action(wrap(handler));
 }
 async function handler(options) {
-    const { env, force, cwd } = options;
-    const envName = cliHelper.ensureEnv(env);
-    await envCtl.delete(envName, Boolean(force), cwd);
+    const { key, force, cwd } = options;
+    const theKey = cliHelper.ensureEnv(key);
+    await envCtl.delete(theKey, Boolean(force), cwd);
 }

package/dist/commands/deploy.js

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

package/dist/commands/destroy.js

@@ -8,7 +8,7 @@ export function destroy(program) {
         .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('--env <env>', _keys.ENV)
+        .option('--key <key>', _keys.KEY)
         .option('--force', _keys.FORCE)
         .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
@@ -16,7 +16,7 @@ export function destroy(program) {
         .action(wrap(handler));
 }
 async function handler(tfArgs, options) {
-    const { env, force, cwd } = options;
-    const envName = cliHelper.ensureEnv(env);
-    await envCtl.destroy(envName, tfArgs, Boolean(force), cwd);
+    const { key, force, cwd } = options;
+    const theKey = cliHelper.ensureEnv(key);
+    await envCtl.destroy(theKey, tfArgs, Boolean(force), cwd);
 }

package/dist/commands/init.js

@@ -6,12 +6,12 @@ export function init(program) {
     program
         .command('init')
         .description('Terraform init wrapper')
-        .option('--env <env>', _keys.ENV)
+        .option('--key <key>', _keys.KEY)
         .option('--cwd <cwd>', _keys.CWD)
         .action(wrap(handler));
 }
 async function handler(options) {
-    const { env, cwd } = options;
-    const envName = cliHelper.ensureEnv(env);
-    await envCtl.init(envName, cwd);
+    const { key, cwd } = options;
+    const theKey = cliHelper.ensureEnv(key);
+    await envCtl.init(theKey, cwd);
 }

package/dist/commands/plan.js

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

package/dist/commands/status.js

@@ -6,12 +6,12 @@ export function status(program) {
     program
         .command('status')
         .description('Get env status')
-        .option('--env <env>', _keys.ENV)
+        .option('--key <key>', _keys.KEY)
         .option('--cwd <cwd>', _keys.CWD)
         .action(wrap(handler));
 }
 async function handler(options) {
-    const { env, cwd } = options;
-    const envName = cliHelper.ensureEnv(env);
-    await envCtl.status(envName, cwd);
+    const { key, cwd } = options;
+    const theKey = cliHelper.ensureEnv(key);
+    await envCtl.status(theKey, cwd);
 }

package/dist/service/EnvCtl.js

@@ -9,11 +9,7 @@ export class EnvCtl {
         this.envApi = envApi;
         this.terraformAdapter = terraformAdapter;
     }
-    key(env) {
-        return env;
-    }
-    async status(envName, cwd) {
-        const key = this.key(envName);
+    async status(key, cwd) {
         console.log(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (env === null) {
@@ -27,14 +23,13 @@ export class EnvCtl {
         }
     }
     async tryGetEnv(input) {
-        let envName = input.envName;
+        let key = input.key;
         let owner = input.owner;
-        if (!envName) {
+        if (!key) {
             owner = this.cliHelper.ensureOwner(owner);
             console.log(`Env name not provided, default to owner name ${owner}`);
-            envName = owner;
+            key = owner;
         }
-        const key = this.key(envName);
         console.log(`Check if env ${key} already exists`);
         const env = await this.envApi.get(key);
         if (env) {
@@ -43,7 +38,7 @@ export class EnvCtl {
         else {
             console.log(`Env ${key} does not exist`);
         }
-        return { envName, anOwner: owner, key, env };
+        return { anOwner: owner, key, env };
     }
     checkInput(env, input, cwd) {
         if (input.owner && env.owner !== input.owner) {
@@ -63,15 +58,14 @@ export class EnvCtl {
         }
         throw new KnownException(`Env ${env.key} status is ${env.status}, can not run this command`);
     }
-    async init(envName, cwd) {
-        const key = this.key(envName);
+    async init(key, cwd) {
         await this.terraformAdapter.init(key, cwd, true);
     }
     async plan(input, tfArgs, cwd) {
-        const { envName, anOwner, key, env } = await this.tryGetEnv(input);
+        const { anOwner, key, env } = await this.tryGetEnv(input);
         if (env == null) {
             const owner = this.cliHelper.ensureOwner(anOwner);
-            await this.runPlan(key, envName, owner, tfArgs, undefined, cwd);
+            await this.runPlan(key, owner, tfArgs, undefined, cwd);
             return;
         }
         this.checkInput(env, input, cwd);
@@ -81,15 +75,14 @@ export class EnvCtl {
         if (env.status !== EnvStatus.Active) {
             throw new KnownException(`Env ${env.key} status is ${env.status}, can not run plan`);
         }
-        await this.runPlan(key, envName, owner, tfArgs, env.vars, cwd);
+        await this.runPlan(key, owner, tfArgs, env.vars, cwd);
     }
-    async runPlan(key, envName, owner, args, vars, cwd) {
-        const envTerraform = { envName, ephemeral: false, owner, args, vars };
+    async runPlan(key, owner, args, vars, cwd) {
+        const envTerraform = { key, ephemeral: false, owner, args, vars };
         await this.terraformAdapter.init(key, cwd);
         await this.terraformAdapter.plan(envTerraform, cwd);
     }
-    async createEphemeral(envName, owner) {
-        const key = this.key(envName);
+    async createEphemeral(key, owner) {
         const env = await this.envApi.get(key);
         if (env !== null) {
             throw new KnownException(`Env ${key} already exists`);
@@ -98,14 +91,14 @@ export class EnvCtl {
         return await this.envApi.createEphemeral(createEnv);
     }
     async deploy(input, tfArgs, cwd) {
-        const { envName, anOwner, key, env } = await this.tryGetEnv(input);
+        const { anOwner, key, env } = await this.tryGetEnv(input);
         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 createEnv = { key, owner, kind };
             const newEnv = await this.envApi.create(createEnv);
-            return await this.runDeploy(newEnv, envName, tfArgs, cwd);
+            return await this.runDeploy(newEnv, key, tfArgs, cwd);
         }
         this.checkInput(env, input, cwd);
         this.checkStatus(env);
@@ -124,13 +117,13 @@ export class EnvCtl {
             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);
+        await this.runDeploy(env, key, tfArgs, cwd);
     }
-    async runDeploy(env, envName, tfArgs, cwd) {
+    async runDeploy(env, key, tfArgs, cwd) {
         await this.terraformAdapter.init(env.key, cwd);
         console.log('Deploying resources');
         const { ephemeral, vars } = env;
-        const envTerraform = { envName, ephemeral, owner: env.owner || 'system', args: tfArgs, vars };
+        const envTerraform = { key, ephemeral, owner: env.owner || 'system', args: tfArgs, vars };
         const onDemandVars = {};
         try {
             await this.terraformAdapter.apply(envTerraform, onDemandVars, cwd);
@@ -146,8 +139,8 @@ export class EnvCtl {
         console.log('Activating env (to finish creation)');
         await this.envApi.activate(env);
     }
-    async delete(envName, force, cwd) {
-        const env = await this.get(envName);
+    async delete(key, force, cwd) {
+        const env = await this.get(key);
         if (!force) {
             this.checkStatus(env);
             if (env.status === EnvStatus.Init) {
@@ -174,8 +167,8 @@ export class EnvCtl {
         const message = await this.envApi.delete(env);
         console.log(message);
     }
-    async destroy(envName, tfArgs, force, cwd) {
-        const env = await this.get(envName);
+    async destroy(key, tfArgs, force, cwd) {
+        const env = await this.get(key);
         this.checkStatus(env);
         if (env.status === EnvStatus.Init) {
             console.log(`Env ${env.key} has no resources, nothing to destroy, call 'delete' command instead`);
@@ -196,7 +189,7 @@ export class EnvCtl {
             await this.envApi.lockForUpdate(env);
         }
         const { ephemeral, owner, vars } = env;
-        const envTerraform = { envName, ephemeral, owner: owner || 'system', args: tfArgs, vars };
+        const envTerraform = { key, ephemeral, owner: owner || 'system', args: tfArgs, vars };
         console.log('Destroying env resources');
         await this.terraformAdapter.init(env.key, cwd);
         await this.terraformAdapter.destroy(envTerraform, force, cwd);
@@ -206,8 +199,7 @@ export class EnvCtl {
         await this.envApi.delete(env);
         console.log('Please wait for ~15 sec before you can create env with same name');
     }
-    async get(envName) {
-        const key = this.key(envName);
+    async get(key) {
         console.log(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (!env) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
@@ -29,8 +29,9 @@
     "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-status": " tsc --sourceMap true && npm run run -- status  --cwd ../tt-core",
-    "run-init": "   tsc --sourceMap true && npm run run -- init    --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",