@agilecustoms/envctl 1.25.0 → 1.25.2

package/dist/client/EnvApiClient.js

@@ -1,7 +1,7 @@
 import { BusinessException, KnownException, NotFoundException } 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,6 +12,7 @@ export class EnvApiClient {
         return await fetch(url);
     }
     async get(key) {
+        logger.info(`Retrieve environment ${key}`);
         try {
             return await this.httpClient.fetch(`/ci/env/${key}`);
         }
@@ -46,7 +47,7 @@ export class EnvApiClient {
             }
             throw error;
         }
-        logger.debug(`Env ${env.key} created with TTL ${toLocalTime(result.ttl)}`);
+        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) {

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();
@@ -51,7 +39,7 @@ export class EnvService extends BaseService {
     async plan(tfArgs) {
         this.terraformAdapter.validateAndGetStateFile();
         const key = this.terraformAdapter.getKey();
-        this.terraformAdapter.getLockFile();
+        this.terraformAdapter.validateAndGetLockFile();
         await this.terraformAdapter.plan(key, tfArgs);
     }
     async createEphemeral(key) {
@@ -64,35 +52,37 @@ 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`);
             }
         }
     }
     async apply(tfArgs) {
         const { stateFile, stateUpdated } = this.terraformAdapter.validateAndGetStateFile();
         const key = this.terraformAdapter.getKey();
-        const { lockFile, lockUpdated } = this.terraformAdapter.getLockFile();
-        const applyMode = getApplyMode(tfArgs);
-        let env = await this.getEnv(key);
+        const { lockFile, lockUpdated } = this.terraformAdapter.validateAndGetLockFile();
+        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 = [
@@ -108,7 +109,7 @@ export class TerraformAdapter {
         config.stateHash = fileHash;
         return { stateFile: fileContent, stateUpdated };
     }
-    _getLockFile() {
+    getLockFile() {
         const lockPath = path.join(process.cwd(), '.terraform.lock.hcl');
         if (!fs.existsSync(lockPath)) {
             throw new KnownException(`Terraform lock file not found at: ${lockPath}`);
@@ -120,8 +121,8 @@ export class TerraformAdapter {
             throw new KnownException(`Failed to read terraform lock file: ${lockPath}`, { cause });
         }
     }
-    getLockFile() {
-        const fileContent = this._getLockFile();
+    validateAndGetLockFile() {
+        const fileContent = this.getLockFile();
         const config = this.localStateService.load();
         const fileHash = hash(fileContent);
         if (fileHash !== config.lockFileHash) {
@@ -141,18 +142,14 @@ export class TerraformAdapter {
             logger.info('Lock providers');
             await this.cli.run('terraform', ['providers', 'lock', '-platform=linux_arm64']);
         }
-        const fileContent = this._getLockFile();
+        const fileContent = this.getLockFile();
         const config = this.localStateService.load();
         config.lockFileHash = hash(fileContent);
         this.localStateService.save(config);
     }
     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.0",
+  "version": "1.25.2",
   "description": "node.js CLI client for manage environments",
   "keywords": [
     "terraform wrapper",