@agilecustoms/envctl 0.19.1 → 0.20.0

package/dist/client/EnvApiClient.js

@@ -17,16 +17,15 @@ export class EnvApiClient {
             throw error;
         }
     }
+    async createEphemeral(env) {
+        const res = await this.httpClient.post('/ci/env-ephemeral', env);
+        const token = res.token;
+        return { ...env, token, ephemeral: true, status: EnvStatus.Init };
+    }
     async create(env) {
-        const res = await this.httpClient.fetch('/ci/env', {
-            method: 'POST',
-            body: JSON.stringify(env),
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        });
+        const res = await this.httpClient.post('/ci/env', env);
         const token = res.token;
-        return { ...env, token, status: EnvStatus.Creating };
+        return { ...env, token, ephemeral: false, status: EnvStatus.Deploying };
     }
     async activate(env) {
         await this.httpClient.fetch(`/ci/env/${env.key}/activate`, {
@@ -35,10 +34,10 @@ export class EnvApiClient {
         env.status = EnvStatus.Active;
     }
     async lockForUpdate(env) {
-        await this.httpClient.fetch(`/ci/env/${env.key}/lock-for-update`, {
+        const res = await this.httpClient.fetch(`/ci/env/${env.key}/lock-for-update`, {
             method: 'POST'
         });
-        env.status = EnvStatus.Updating;
+        env.status = res.status;
     }
     async delete(env) {
         let result;

package/dist/client/HttpClient.js

@@ -6,6 +6,16 @@ export class HttpClient {
     constructor(awsCredsHelper) {
         this.awsCredsHelper = awsCredsHelper;
     }
+    async post(path, body, options = {}) {
+        return await this.fetch(path, {
+            method: 'POST',
+            body: JSON.stringify(body),
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            ...options
+        });
+    }
     async fetch(path, options = {}) {
         const awsCreds = await this.awsCredsHelper.getCredentials();
         const requestOptions = {

package/dist/commands/{apiCreateEphemeral.js → createEphemeral.js}

@@ -2,13 +2,13 @@ import { Command } from 'commander';
 import { envCtl } from '../container.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function apiCreateEphemeral(program) {
+export function createEphemeral(program) {
     program
-        .command('api-create-ephemeral')
+        .command('create-ephemeral')
         .description('Create bare env w/o resources. Used in CI as first step just to pre-generate token for extension')
         .option('--project <project>', _keys.PROJECT)
         .requiredOption('--env <env>', _keys.ENV)
-        .requiredOption('--owner <owner>', _keys.OWNER)
+        .option('--owner <owner>', _keys.OWNER)
         .requiredOption('--size <size>', _keys.SIZE)
         .requiredOption('--type <type>', _keys.TYPE)
         .action(wrap(handler));

package/dist/commands/index.js

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

package/dist/index.js

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

package/dist/model/EnvStatus.js

@@ -1,6 +1,7 @@
 export var EnvStatus;
 (function (EnvStatus) {
-    EnvStatus["Creating"] = "CREATING";
+    EnvStatus["Init"] = "INIT";
+    EnvStatus["Deploying"] = "DEPLOYING";
     EnvStatus["Active"] = "ACTIVE";
     EnvStatus["Updating"] = "UPDATING";
     EnvStatus["Deleting"] = "DELETING";

package/dist/service/EnvCtl.js

@@ -1,6 +1,5 @@
 import { KnownException, TerraformInitRequired } from '../exceptions.js';
-import { EnvType, EnvSize } from '../model/index.js';
-import { EnvSizeAvgTime, EnvStatus } from '../model/index.js';
+import { EnvSize, EnvSizeAvgTime, EnvStatus, EnvType } from '../model/index.js';
 export class EnvCtl {
     cliHelper;
     envApi;
@@ -46,7 +45,7 @@ export class EnvCtl {
         }
         return { envName, owner, key, env };
     }
-    checkInput(envName, env, input, cwd) {
+    checkInput(env, input, cwd) {
         if (input.owner && env.owner !== input.owner) {
             throw new KnownException(`Can not change env owner ${env.owner} -> ${input.owner}`);
         }
@@ -60,21 +59,16 @@ export class EnvCtl {
         if ((input.kind || env.kind) && kind !== env.kind) {
             throw new KnownException(`Can not change env kind ${env.kind} -> ${kind}`);
         }
-        const { owner, size, type } = env;
-        return {
-            project: input.project, env: envName,
-            owner, size, type, kind,
-        };
     }
-    checkStatus(env, availableStatuses = [EnvStatus.Active, EnvStatus.Creating, EnvStatus.Updating]) {
+    checkStatus(env, availableStatuses = [EnvStatus.Init, EnvStatus.Deploying, EnvStatus.Active, 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 ${env.key} status is DELETING, please wait (~${time} min)`);
         }
-        throw new KnownException(`Env status is ${env.status}, can not run this command`);
+        throw new KnownException(`Env ${env.key} status is ${env.status}, can not run this command`);
     }
     async init(project, envName, cwd) {
         const key = this.key(project, envName);
@@ -89,8 +83,9 @@ export class EnvCtl {
             await this.terraformAdapter.plan(envTerraform, tfArgs, cwd);
             return;
         }
-        const envInput = this.checkInput(envName, env, input, cwd);
-        const envTerraform = { ...envInput, ephemeral: false };
+        this.checkInput(env, input, cwd);
+        const envOwner = env.owner;
+        const envTerraform = { ...env, env: envName, owner: envOwner, ephemeral: false };
         this.checkStatus(env);
         await this.promptUnlock(env);
         if (env.status !== EnvStatus.Active) {
@@ -104,8 +99,8 @@ export class EnvCtl {
         if (env !== null) {
             throw new KnownException(`Env ${key} already exists`);
         }
-        const createEnv = { key, ephemeral: true, owner, size, type };
-        const newEnv = await this.envApi.create(createEnv);
+        const createEnv = { key, owner, size, type };
+        const newEnv = await this.envApi.createEphemeral(createEnv);
         return newEnv.token;
     }
     async deploy(input, tfArgs, cwd) {
@@ -114,13 +109,16 @@ export class EnvCtl {
             const envInput = await this.cliHelper.parseEnvInput(input, envName, owner, 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 createEnv = { key, 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, cwd);
+        this.checkInput(env, input, cwd);
         this.checkStatus(env);
-        if (env.status == EnvStatus.Updating) {
+        if (env.status === EnvStatus.Init) {
+            await this.envApi.lockForUpdate(env);
+        }
+        else if (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) {
@@ -137,7 +135,7 @@ export class EnvCtl {
     async runDeploy(env, envName, tfArgs, cwd) {
         console.log('Deploying resources');
         const { owner, size, type, ephemeral } = env;
-        const envTf = { owner, size, type, ephemeral, env: envName };
+        const envTf = { owner: owner || 'system', size, type, ephemeral, env: envName };
         try {
             await this.terraformAdapter.apply(envTf, tfArgs, cwd);
         }
@@ -156,9 +154,14 @@ export class EnvCtl {
     async delete(project, envName, force, cwd) {
         const env = await this.get(project, envName);
         this.checkStatus(env);
+        if (env.status === EnvStatus.Init) {
+            await this.envApi.delete(env);
+            console.log(`Env ${env.key} is deleted`);
+            return;
+        }
         if (force) {
             console.log('Force deletion');
-            if (env.status !== EnvStatus.Active) {
+            if (env.status === EnvStatus.Deploying || env.status === EnvStatus.Updating) {
                 console.log(`Env status is ${env.status}, will unlock it`);
                 await this.envApi.activate(env);
             }
@@ -180,32 +183,38 @@ export class EnvCtl {
             }
             console.log('Deleting env');
         }
-        const statusMessage = await this.envApi.delete(env);
-        console.log(statusMessage);
+        await this.envApi.delete(env);
+        console.log(`Env ${env.key} is scheduled for deletion`);
     }
     async destroy(project, envName, tfArgs, force, cwd) {
         const env = await this.get(project, envName);
         this.checkStatus(env);
+        if (env.status === EnvStatus.Init) {
+            console.log(`Env ${env.key} has no resources, nothing to destroy, call 'delete' command instead`);
+            return;
+        }
         if (!force) {
             const kind = this.cliHelper.ensureKind(undefined, 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`);
             }
-            await this.promptUnlock(env, [EnvStatus.Creating]);
+            await this.promptUnlock(env, [EnvStatus.Deploying]);
+            if (env.status === EnvStatus.Deploying) {
+                return;
+            }
         }
         if (env.status === EnvStatus.Active) {
             console.log('Lock env to run destroy');
             await this.envApi.lockForUpdate(env);
         }
         const { owner, size, type, ephemeral } = env;
-        const tfEnv = { owner, size, type, ephemeral, env: envName };
+        const tfEnv = { owner: owner || 'system', size, type, ephemeral, env: envName };
         console.log('Destroying env resources');
         await this.terraformAdapter.destroy(tfEnv, tfArgs, force, 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(`Schedule env ${env.key} metadata deletion`);
+        await this.envApi.delete(env);
         console.log('Please wait for ~15 sec before you can create env with same name');
     }
     async get(project, envName) {
@@ -217,13 +226,12 @@ export class EnvCtl {
         }
         return env;
     }
-    async promptUnlock(env, statuses = [EnvStatus.Creating, EnvStatus.Updating]) {
+    async promptUnlock(env, statuses = [EnvStatus.Deploying, 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;
             }
         }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.19.1",
+  "version": "0.20.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
@@ -33,12 +33,12 @@
     "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-api-create-ephemeral": "tsc --sourceMap true && npm run run -- api-create-ephemeral --env test --owner laxa1986 --size min --type dev",
-    "run-api-status": " tsc --sourceMap true && npm run run -- status  --env test",
-    "run-api-init": "   tsc --sourceMap true && npm run run -- init    --env test --cwd ../tt-gitops",
-    "run-api-deploy": " tsc --sourceMap true && npm run run -- deploy  --env test --cwd ../tt-gitops -var-file=versions.tfvars",
-    "run-api-delete": " tsc --sourceMap true && npm run run -- delete  --env test --cwd ../tt-gitops --force",
-    "run-api-destroy": "tsc --sourceMap true && npm run run -- destroy --env test --cwd ../tt-gitops --force -var-file=versions.tfvars"
+    "run-ephemeral-create": " tsc --sourceMap true && npm run run -- create-ephemeral --env test --size min --type dev",
+    "run-ephemeral-status": " tsc --sourceMap true && npm run run -- status  --env test",
+    "run-ephemeral-init": "   tsc --sourceMap true && npm run run -- init    --env test --cwd ../tt-gitops",
+    "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"
   },
   "dependencies": {
     "@aws-sdk/client-sts": "^3.716.0",