@agilecustoms/envctl 1.25.1 → 1.26.0

package/dist/client/EnvApiClient.js

@@ -1,7 +1,7 @@
-import { BusinessException, KnownException, NotFoundException } from '../exceptions.js';
+import { KnownException, NotFoundException, UnauthorizedException } from '../exceptions.js';
 import { logger } from '../logger.js';
 import { EnvStatus } from '../model/index.js';
-import { toLocalTime } from '../util.js';
+import { format, toDate } from '../util.js';
 import { HttpClient } from './HttpClient.js';
 export class EnvApiClient {
     httpClient;
@@ -12,8 +12,9 @@ export class EnvApiClient {
         return await fetch(url);
     }
     async get(key) {
+        logger.info(`Retrieve environment ${key}`);
         try {
-            return await this.httpClient.fetch(`/ci/env/${key}`);
+            return await this.httpClient.fetch(`/env/${key}`);
         }
         catch (error) {
             if (error instanceof NotFoundException) {
@@ -28,37 +29,20 @@ export class EnvApiClient {
             result = await this.httpClient.post('/ci/env-ephemeral', env);
         }
         catch (error) {
-            if (error instanceof BusinessException) {
-                throw new KnownException(`Failed to create ephemeral environment: ${error.message}`);
+            if (error instanceof UnauthorizedException) {
+                throw new KnownException(`Developers are no authorized to create ephemeral environment\nPlease create dedicated CI user (with its own API key) per each pipeline`);
             }
             throw error;
         }
         return this.httpClient.getUrl(`/public/env/${env.key}/extend?token=${result.token}`);
     }
     async create(env) {
-        let result;
-        try {
-            result = await this.httpClient.post('/ci/env', env);
-        }
-        catch (error) {
-            if (error instanceof BusinessException) {
-                throw new KnownException(`Failed to create environment: ${error.message}`);
-            }
-            throw error;
-        }
-        logger.debug(`Env ${env.key} created with TTL ${toLocalTime(result.ttl)}`);
+        const result = await this.httpClient.post('/env', env);
+        logger.debug(`Environment ${env.key} created, will expire at ${format(toDate(result.ttl))}`);
         return { ...env, ephemeral: false, status: EnvStatus.Deploying, ttl: result.ttl };
     }
     async activate(env) {
-        try {
-            await this.httpClient.post(`/ci/env/${env.key}/activate`);
-        }
-        catch (error) {
-            if (error instanceof BusinessException) {
-                throw new KnownException(`Failed to activate environment ${env.key}: ${error.message}`);
-            }
-            throw error;
-        }
+        await this.httpClient.post(`/env/${env.key}/activate`);
         env.status = EnvStatus.Active;
     }
     async lockForUpdate(env) {
@@ -67,23 +51,14 @@ export class EnvApiClient {
             stateFile: env.stateFile,
             lockFile: env.lockFile
         };
-        let result;
-        try {
-            result = await this.httpClient.post(`/ci/env/${env.key}/lock-for-update`, body);
-        }
-        catch (error) {
-            if (error instanceof BusinessException) {
-                throw new KnownException(`Failed to lock environment ${env.key} for update: ${error.message}`);
-            }
-            throw error;
-        }
+        const result = await this.httpClient.post(`/env/${env.key}/lock-for-update`, body);
         env.status = result.status;
     }
     async delete(key, force = false) {
         logger.info('Sending delete command');
         let result;
         try {
-            result = await this.httpClient.fetch(`/ci/env/${key}?force=${force}`, {
+            result = await this.httpClient.fetch(`/env/${key}?force=${force}`, {
                 method: 'DELETE'
             });
         }
@@ -98,7 +73,7 @@ export class EnvApiClient {
     async getLogs(key) {
         let result;
         try {
-            result = await this.httpClient.fetch(`/ci/env/${key}/logs`);
+            result = await this.httpClient.fetch(`/env/${key}/logs`);
         }
         catch (error) {
             if (error instanceof NotFoundException) {

package/dist/client/HttpClient.js

@@ -1,4 +1,4 @@
-import { BusinessException, HttpException, KnownException, NotFoundException } from '../exceptions.js';
+import { HttpException, KnownException, NotFoundException, UnauthorizedException } from '../exceptions.js';
 import { logger } from '../logger.js';
 import { DEFAULT_HOST } from '../service/ConfigService.js';
 import { ConfigService } from '../service/index.js';
@@ -63,6 +63,7 @@ export class HttpClient {
             }
             throw new Error('Error (network?) making the request:', { cause: error });
         }
+        logger.debug(`response status: ${response.status}, text: ${response.statusText}`);
         const contentType = response.headers?.get('Content-Type') || '';
         let body = await response.text();
         if (contentType.includes('application/json')) {
@@ -79,11 +80,17 @@ export class HttpClient {
         if (response.ok) {
             return body;
         }
+        if (response.status === 401) {
+            throw new KnownException('API key is not recognized');
+        }
+        if (response.status === 403) {
+            throw new UnauthorizedException(JSON.stringify(body));
+        }
         if (response.status === 404) {
             throw new NotFoundException(body);
         }
         if (response.status === 422) {
-            throw new BusinessException(body.message);
+            throw new KnownException(body.message);
         }
         if (response.status === 426) {
             throw new KnownException(body.message);

package/dist/exceptions.js

@@ -16,10 +16,10 @@ export class HttpException extends Error {
         this.name = 'HttpException';
     }
 }
-export class BusinessException extends HttpException {
+export class UnauthorizedException extends HttpException {
     constructor(message) {
         super(message);
-        this.name = 'BusinessException';
+        this.name = 'UnauthorizedException';
     }
 }
 export class NotFoundException extends HttpException {

package/dist/logger.js

@@ -22,7 +22,13 @@ export class Logger {
         this.log('error', msg);
     }
     log(level, msg) {
-        const date = new Date(this.now()).toISOString();
+        const date = new Date(this.now()).toLocaleString('en-US', {
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            fractionalSecondDigits: 3,
+            hour12: false,
+        });
         const detailedMessage = `${date} [${level}] ${msg}`;
         this.buffer.push(detailedMessage);
         if (!this.isDebugEnabled() && level === 'debug') {

package/dist/service/EnvService.js

@@ -3,7 +3,7 @@ import { EnvApiClient } from '../client/index.js';
 import { KnownException } from '../exceptions.js';
 import { logger } from '../logger.js';
 import { EnvStatus } from '../model/index.js';
-import { toLocalTime } from '../util.js';
+import { format, toDate } from '../util.js';
 import { BaseService } from './BaseService.js';
 import { ApplyMode, getApplyMode } from './TerraformAdapter.js';
 export class EnvService extends BaseService {
@@ -16,34 +16,22 @@ export class EnvService extends BaseService {
     }
     async status(key) {
         key = this.getKey(key);
-        logger.info(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (env === null) {
-            logger.info(`Env ${key} does not exist`);
+            logger.info(`Environment ${key} does not exist`);
             return;
         }
-        logger.info(`Env ${key} status: ${env.status}`);
+        logger.info(`Environment ${key} status: ${env.status}`);
         if (env.status !== EnvStatus.Deleting && env.status !== EnvStatus.DeleteError) {
-            logger.info(`Expires at ${toLocalTime(env.ttl)}`);
+            logger.info(`Expires at ${format(toDate(env.ttl))}`);
         }
         if (env.dir) {
             const dir = this.cli.getDir();
             if (env.dir !== dir) {
-                logger.warn(`Env ${key} was deployed from ${env.dir}`);
+                logger.warn(`Environment ${key} was deployed from ${env.dir}`);
             }
         }
     }
-    async getEnv(key) {
-        logger.info(`Check if env ${key} already exists`);
-        const env = await this.envApi.get(key);
-        if (env) {
-            logger.info(`Env ${key} status: ${env.status}`);
-        }
-        else {
-            logger.info(`Env ${key} does not exist`);
-        }
-        return env;
-    }
     async init(tfArgs) {
         await this.terraformAdapter.init(tfArgs);
         await this.terraformAdapter.lockProviders();
@@ -64,7 +52,7 @@ export class EnvService extends BaseService {
         if (env.dir) {
             const dir = this.cli.getDir();
             if (dir !== env.dir) {
-                throw new KnownException(`Env ${env.key} was deployed from ${env.dir} - make sure you run this command from the same directory`);
+                throw new KnownException(`Environment ${env.key} was deployed from ${env.dir} - make sure you run this command from the same directory`);
             }
         }
     }
@@ -72,27 +60,29 @@ export class EnvService extends BaseService {
         const { stateFile, stateUpdated } = this.terraformAdapter.validateAndGetStateFile();
         const key = this.terraformAdapter.getKey();
         const { lockFile, lockUpdated } = this.terraformAdapter.validateAndGetLockFile();
-        const applyMode = getApplyMode(tfArgs);
-        let env = await this.getEnv(key);
+        let env = await this.envApi.get(key);
         if (env === null) {
+            logger.info(`Environment ${key} does not exist`);
             const dir = this.cli.getDir();
             const createEnv = { key, dir, stateFile, lockFile };
-            logger.info('Creating env metadata');
+            logger.info('Creating environment metadata');
             env = await this.envApi.create(createEnv);
             await this.runApply(env, tfArgs);
             return env;
         }
+        logger.info(`Environment ${key} status: ${env.status}`);
         this.checkDir(env);
         if (env.status === EnvStatus.Deleting) {
-            throw new KnownException(`Env ${env.key} status is DELETING, please wait.\n
+            throw new KnownException(`Environment ${env.key} status is DELETING, please wait.\n
        If it is DELETING more than 10 minutes, you can try to run 'envctl delete ${env.key} --force' to remove it`);
         }
         if (env.status === EnvStatus.DeleteError) {
-            throw new KnownException(`Env ${env.key} status is DELETE_ERROR, most likely lack of permissions.\n
+            throw new KnownException(`Environment ${env.key} status is DELETE_ERROR, most likely lack of permissions.\n
        Check logs with 'envctl logs', address the issue and re-run 'envctl delete ${env.key}'`);
         }
         const status = env.status;
         if (status === EnvStatus.Init) {
+            const applyMode = getApplyMode(tfArgs);
             if (applyMode === ApplyMode.Default) {
                 throw new KnownException('Either run apply with planfile or with flag -auto-approve');
             }
@@ -115,9 +105,8 @@ export class EnvService extends BaseService {
     }
     async runApply(env, tfArgs) {
         this.terraformAdapter.saveHashes();
-        logger.info('Deploying resources');
         await this.terraformAdapter.apply(env, tfArgs);
-        logger.info('Activating env (to finish creation)');
+        logger.info('Activate environment');
         await this.envApi.activate(env);
         return env;
     }
@@ -127,30 +116,25 @@ export class EnvService extends BaseService {
     }
     async destroy(tfArgs, force) {
         const key = this.terraformAdapter.getKey();
-        const env = await this.get(key);
+        const env = await this.envApi.get(key);
+        if (!env) {
+            throw new KnownException(`Environment ${key} is not found`);
+        }
+        logger.info(`Environment status: ${env.status}`);
         if (env.status === EnvStatus.Init) {
-            logger.info(`Env ${env.key} status is INIT - no resources, nothing to destroy, just deleting metadata`);
+            logger.info(`Environment ${env.key} status is INIT - no resources, nothing to destroy, just deleting metadata`);
             await this.envApi.delete(key, force);
             return;
         }
         if (env.status === EnvStatus.Deleting && !force) {
-            throw new KnownException(`Env ${env.key} status is DELETING, please wait or re-run with --force`);
+            throw new KnownException(`Environment ${env.key} status is DELETING, please wait or re-run with --force`);
         }
         if (env.status === EnvStatus.Active) {
-            logger.info('Lock env to run destroy');
+            logger.info('Lock environment to run destroy');
             await this.envApi.lockForUpdate(env);
         }
         await this.terraformAdapter.destroy(key, tfArgs, force);
         await this.envApi.delete(key, force);
-        logger.info('Please wait for ~30 sec before you can create env with same name');
-    }
-    async get(key) {
-        logger.info(`Retrieve env ${key}`);
-        const env = await this.envApi.get(key);
-        if (!env) {
-            throw new KnownException(`Environment ${key} is not found`);
-        }
-        logger.info(`Env status: ${env.status}`);
-        return env;
+        logger.info('Please wait for ~30 sec before you can create environment with same name');
     }
 }

package/dist/service/TerraformAdapter.js

@@ -5,6 +5,7 @@ import { confirm } from '@inquirer/prompts';
 import {} from '../client/Cli.js';
 import { AbortedException, KnownException, ProcessException, TimeoutException } from '../exceptions.js';
 import { logger } from '../logger.js';
+import { format } from '../util.js';
 import { LocalStateService } from './LocalStateService.js';
 export const MAX_ATTEMPTS = 2;
 export const RETRYABLE_ERRORS = [
@@ -148,11 +149,7 @@ export class TerraformAdapter {
     }
     printTime() {
         const now = new Date();
-        const utc = now.toISOString();
-        const edt = now.toLocaleString('en-US', {
-            timeZone: 'America/New_York'
-        });
-        logger.info(`\nTime EDT: ${edt},  UTC: ${utc}\n`);
+        logger.info(`\nLocal time: ${format(now)},  UTC: ${now.toISOString()}\n`);
     }
     tfArgs(key, args) {
         const varDefs = this.getVarDefs();

package/dist/util.js

@@ -1,5 +1,7 @@
-export function toLocalTime(ttl, timeZone) {
-    const date = new Date(ttl * 1000);
+export function toDate(ttl) {
+    return new Date(ttl * 1000);
+}
+export function format(date, timeZone) {
     return date.toLocaleString('en-US', {
         timeZone,
         month: 'short',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilecustoms/envctl",
-  "version": "1.25.1",
+  "version": "1.26.0",
   "description": "node.js CLI client for manage environments",
   "keywords": [
     "terraform wrapper",
@@ -74,7 +74,7 @@
     "-e1-": "",
     "e1-desc": "ephemeral env in CI (must have ENVCTL_API_KEY_ in env vars)",
     "e1": "CWD=../tt-core CI=true ENVCTL_HOME=non-existing ENVCTL_API_KEY=\"$ENVCTL_API_KEY_\" npm run it --",
-    "e1-create": "npm run e1 -- create-ephemeral e1",
+    "e1-create": "npm run e1 -- create-ephemeral e1 --verbose",
     "e1-init": "  npm run e1 -- init -reconfigure -upgrade -backend-config=key=e1",
     "e1-plan": "  npm run e1 -- plan -var=env_size=min -var=env=e1 -out=plan",
     "e1-apply": " npm run e1 -- apply plan",