@agilecustoms/envctl 1.22.0 → 1.24.0

package/dist/client/EnvApiClient.js

@@ -62,6 +62,7 @@ export class EnvApiClient {
         env.status = EnvStatus.Active;
     }
     async lockForUpdate(env) {
+        logger.info('Lock for update');
         const body = {
             stateFile: env.stateFile,
             lockFile: env.lockFile

package/dist/client/HttpClient.js

@@ -64,7 +64,18 @@ export class HttpClient {
             throw new Error('Error (network?) making the request:', { cause: error });
         }
         const contentType = response.headers?.get('Content-Type') || '';
-        const body = contentType.includes('application/json') ? await response.json() : await response.text();
+        let body = await response.text();
+        if (contentType.includes('application/json')) {
+            try {
+                body = JSON.parse(body);
+            }
+            catch (e) {
+                if (e instanceof SyntaxError) {
+                    throw new Error(`Malformed json response: ${body}`, { cause: e });
+                }
+                throw new Error('Unexpected error when parsing JSON response', { cause: e });
+            }
+        }
         if (response.ok) {
             return body;
         }
@@ -72,7 +83,7 @@ export class HttpClient {
             throw new NotFoundException(body);
         }
         if (response.status === 422) {
-            throw new BusinessException(body);
+            throw new BusinessException(body.message);
         }
         if (response.status === 426) {
             throw new KnownException(body.message);

package/dist/commands/_utils.js

@@ -13,7 +13,7 @@ export function wrap(callable) {
             else if (error instanceof AbortedException || error instanceof ExitPromptError) {
             }
             else {
-                logger.error('Unknown error: ' + error);
+                logger.error('Unknown error: \n' + error.stack);
             }
             process.exit(1);
         }

package/dist/commands/index.js

@@ -3,6 +3,7 @@ export { configure } from './configure.js';
 export { createEphemeral } from './createEphemeral.js';
 export { deleteIt } from './delete.js';
 export { destroy } from './destroy.js';
+export { init } from './init.js';
 export { logs } from './logs.js';
 export { plan } from './plan.js';
 export { status } from './status.js';

package/dist/commands/init.js

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { ConfigService, EnvService } from '../service/index.js';
+import { _keys } from './_keys.js';
+import { wrap } from './_utils.js';
+export function init(program, configService, envService) {
+    program
+        .command('init')
+        .description('High level wrapper for terraform init')
+        .option('--profile <profile>', _keys.PROFILE)
+        .allowUnknownOption(true)
+        .argument('[args...]')
+        .action(wrap(async (tfArgs, options) => {
+        const { profile } = options;
+        configService.init(profile, false);
+        await envService.init(tfArgs);
+    }));
+}

package/dist/container.js

@@ -15,7 +15,7 @@ export function buildContainer(appVersion) {
     const localStateService = new LocalStateService();
     const nonInteractive = !process.stdout.isTTY || process.env.CI === 'true';
     const terraformAdapter = new TerraformAdapter(Date.now, configService, cli, localStateService, backends, nonInteractive);
-    const envService = new EnvService(configService, cli, envApiClient, terraformAdapter);
+    const envService = new EnvService(cli, envApiClient, terraformAdapter);
     const logService = new LogService(cli, envApiClient, terraformAdapter);
     return { configService, envService, logService };
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from 'module';
 import { Command } from 'commander';
 import updateNotifier from 'update-notifier';
-import { configure, createEphemeral, deleteIt, apply, destroy, logs, plan, status } from './commands/index.js';
+import { configure, createEphemeral, deleteIt, apply, destroy, logs, plan, status, init } from './commands/index.js';
 import { buildContainer } from './container.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
@@ -23,6 +23,7 @@ configure(program, configService);
 createEphemeral(program, configService, envService);
 deleteIt(program, configService, envService);
 destroy(program, configService, envService);
+init(program, configService, envService);
 logs(program, configService, logService);
 plan(program, configService, envService);
 status(program, configService, envService);

package/dist/service/BaseService.js

@@ -7,7 +7,7 @@ export class BaseService {
     getKey(key) {
         if (!key) {
             logger.info('Key is not provided, inferring from state file');
-            key = this.terraformAdapter.getTerraformBackend().getKey();
+            key = this.terraformAdapter.getKey();
         }
         return key;
     }

package/dist/service/EnvService.js

@@ -5,13 +5,12 @@ import { logger } from '../logger.js';
 import { EnvStatus } from '../model/index.js';
 import { toLocalTime } from '../util.js';
 import { BaseService } from './BaseService.js';
+import { ApplyMode, getApplyMode } from './TerraformAdapter.js';
 export class EnvService extends BaseService {
-    configService;
     cli;
     envApi;
-    constructor(configService, cli, envApi, terraformAdapter) {
+    constructor(cli, envApi, terraformAdapter) {
         super(terraformAdapter);
-        this.configService = configService;
         this.cli = cli;
         this.envApi = envApi;
     }
@@ -34,10 +33,7 @@ export class EnvService extends BaseService {
             }
         }
     }
-    async tryGetEnv(key) {
-        if (this.configService.getApiKey() === undefined) {
-            return null;
-        }
+    async getEnv(key) {
         logger.info(`Check if env ${key} already exists`);
         const env = await this.envApi.get(key);
         if (env) {
@@ -48,27 +44,19 @@ export class EnvService extends BaseService {
         }
         return env;
     }
+    async init(tfArgs) {
+        await this.terraformAdapter.init(tfArgs);
+        await this.terraformAdapter.lockProviders();
+    }
     async plan(tfArgs) {
-        const key = this.terraformAdapter.getTerraformBackend().getKey();
-        await this.lockTerraform(null, true);
+        this.terraformAdapter.validateAndGetStateFile();
+        const key = this.terraformAdapter.getKey();
         await this.terraformAdapter.plan(key, tfArgs);
     }
     async createEphemeral(key) {
         const createEnv = { key };
         return await this.envApi.createEphemeral(createEnv);
     }
-    async lockTerraform(env, newEnv) {
-        logger.info('Lock providers');
-        const res = await this.terraformAdapter.lock(newEnv);
-        if (env !== null) {
-            if (res.lockFile) {
-                env.lockFile = res.lockFile;
-            }
-            if (res.stateFile) {
-                env.stateFile = res.stateFile;
-            }
-        }
-    }
     checkDir(env) {
         if (env.ephemeral)
             return;
@@ -80,16 +68,18 @@ export class EnvService extends BaseService {
         }
     }
     async apply(tfArgs) {
-        const key = this.terraformAdapter.getTerraformBackend().getKey();
-        let env = await this.tryGetEnv(key);
+        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);
         if (env === null) {
             const dir = this.cli.getDir();
-            const createEnv = { key, dir };
-            await this.lockTerraform(createEnv, true);
+            const createEnv = { key, dir, stateFile, lockFile };
             logger.info('Creating env metadata');
             env = await this.envApi.create(createEnv);
             await this.runApply(env, tfArgs);
-            return;
+            return env;
         }
         this.checkDir(env);
         if (env.status === EnvStatus.Deleting) {
@@ -101,28 +91,41 @@ export class EnvService extends BaseService {
        Check logs with 'envctl logs', address the issue and re-run 'envctl delete ${env.key}'`);
         }
         const status = env.status;
-        if (status === EnvStatus.Init || status === EnvStatus.Active) {
-            const newEnv = status === EnvStatus.Init;
-            await this.lockTerraform(env, newEnv);
-            logger.info('Will lock for update and run terraform apply (to update resources)');
+        if (status === EnvStatus.Init) {
+            if (applyMode === ApplyMode.Default) {
+                throw new KnownException('Either run apply with planfile or with flag -auto-approve');
+            }
+            env.stateFile = stateFile;
+            env.lockFile = lockFile;
             await this.envApi.lockForUpdate(env);
             await this.runApply(env, tfArgs);
-            return;
+            return env;
+        }
+        if (stateUpdated) {
+            env.stateFile = stateFile;
+        }
+        if (lockUpdated) {
+            env.lockFile = lockFile;
         }
-        await this.runApply(env, tfArgs);
+        if (status === EnvStatus.Active || stateUpdated || lockUpdated) {
+            await this.envApi.lockForUpdate(env);
+        }
+        return await this.runApply(env, tfArgs);
     }
     async runApply(env, tfArgs) {
+        this.terraformAdapter.saveHashes();
         logger.info('Deploying resources');
         await this.terraformAdapter.apply(env, tfArgs);
         logger.info('Activating env (to finish creation)');
         await this.envApi.activate(env);
+        return env;
     }
     async delete(force, key) {
         key = this.getKey(key);
         await this.envApi.delete(key, force);
     }
     async destroy(tfArgs, force) {
-        const key = this.terraformAdapter.getTerraformBackend().getKey();
+        const key = this.terraformAdapter.getKey();
         const env = await this.get(key);
         if (env.status === EnvStatus.Init) {
             logger.info(`Env ${env.key} status is INIT - no resources, nothing to destroy, just deleting metadata`);

package/dist/service/TerraformAdapter.js

@@ -16,6 +16,35 @@ export const RETRYABLE_ERRORS = [
 function hash(data) {
     return createHash('sha256').update(data).digest('hex');
 }
+export var ApplyMode;
+(function (ApplyMode) {
+    ApplyMode["Plan"] = "PLAN";
+    ApplyMode["AutoApprove"] = "AUTO_APPROVE";
+    ApplyMode["Default"] = "DEFAULT";
+})(ApplyMode || (ApplyMode = {}));
+export function getApplyMode(tfArgs) {
+    let hasAutoApprove = false;
+    for (let i = 0; i < tfArgs.length; i++) {
+        const arg = tfArgs[i];
+        if (arg === '-auto-approve') {
+            hasAutoApprove = true;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            if (!arg.includes('=')
+                && i + 1 < tfArgs.length
+                && !tfArgs[i + 1].startsWith('-')) {
+                i++;
+            }
+            continue;
+        }
+        return ApplyMode.Plan;
+    }
+    if (hasAutoApprove) {
+        return ApplyMode.AutoApprove;
+    }
+    return ApplyMode.Default;
+}
 export class TerraformAdapter {
     now;
     configService;
@@ -35,19 +64,7 @@ export class TerraformAdapter {
             return acc;
         }, new Map());
     }
-    getLockFile() {
-        const lockPath = path.join(process.cwd(), '.terraform.lock.hcl');
-        if (!fs.existsSync(lockPath)) {
-            throw new KnownException(`Terraform lock file not found at: ${lockPath}`);
-        }
-        try {
-            return fs.readFileSync(lockPath, 'utf8');
-        }
-        catch (err) {
-            throw new KnownException(`Failed to read terraform lock file: ${lockPath}`, { cause: err });
-        }
-    }
-    getTerraformBackend() {
+    getBackend() {
         if (this.backend) {
             return this.backend;
         }
@@ -80,37 +97,45 @@ export class TerraformAdapter {
         this.backend = backend;
         return backend;
     }
-    async lock(newEnv) {
-        const res = {};
-        const stateFileContent = this.getTerraformBackend().validateAndGetStateFileContent();
-        const stateHash = hash(stateFileContent);
+    getKey() {
+        return this.getBackend().getKey();
+    }
+    validateAndGetStateFile() {
+        const fileContent = this.getBackend().validateAndGetStateFileContent();
         const config = this.localStateService.load();
-        if (config.stateHash !== stateHash || newEnv) {
-            config.stateHash = stateHash;
-            res.stateFile = stateFileContent;
+        const fileHash = hash(fileContent);
+        const stateUpdated = config.stateHash !== fileHash;
+        config.stateHash = fileHash;
+        return { stateFile: fileContent, stateUpdated };
+    }
+    getLockFile() {
+        const lockPath = path.join(process.cwd(), '.terraform.lock.hcl');
+        if (!fs.existsSync(lockPath)) {
+            throw new KnownException(`Terraform lock file not found at: ${lockPath}`);
         }
-        const linuxArm64 = process.platform === 'linux' && process.arch === 'arm64';
-        if (!linuxArm64 || newEnv) {
-            let lockFileContent = this.getLockFile();
-            if (!linuxArm64) {
-                const lockFileHash = hash(lockFileContent);
-                if (config.lockHash !== lockFileHash) {
-                    await this.lockProviders();
-                    lockFileContent = this.getLockFile();
-                    config.lockHash = hash(lockFileContent);
-                    res.lockFile = lockFileContent;
-                }
-            }
-            if (newEnv) {
-                res.lockFile = lockFileContent;
-            }
+        let fileContent;
+        try {
+            fileContent = fs.readFileSync(lockPath, 'utf8');
+        }
+        catch (cause) {
+            throw new KnownException(`Failed to read terraform lock file: ${lockPath}`, { cause });
         }
+        const config = this.localStateService.load();
+        const fileHash = hash(fileContent);
+        const lockUpdated = config.lockHash !== fileHash;
+        config.stateHash = fileHash;
+        return { lockFile: fileContent, lockUpdated };
+    }
+    saveHashes() {
+        const config = this.localStateService.load();
         this.localStateService.save(config);
-        return res;
     }
     async lockProviders() {
-        logger.info('Update lock file');
-        await this.cli.run('terraform', ['providers', 'lock', '-platform=linux_arm64']);
+        const linuxArm64 = process.platform === 'linux' && process.arch === 'arm64';
+        if (!linuxArm64) {
+            logger.info('Lock providers');
+            await this.cli.run('terraform', ['providers', 'lock', '-platform=linux_arm64']);
+        }
     }
     printTime() {
         const now = new Date();
@@ -179,6 +204,18 @@ export class TerraformAdapter {
         });
         return result;
     }
+    async init(args) {
+        logger.info('Running: terraform init ' + args.join(' ') + '\n');
+        try {
+            await this.cli.run('terraform', ['init', ...args], { interactive: true });
+        }
+        catch (error) {
+            if (!(error instanceof ProcessException)) {
+                throw error;
+            }
+            throw new KnownException(`terraform init failed with code ${error.code}:\n${error.message}`, { cause: error });
+        }
+    }
     async plan(key, args) {
         args = this.tfArgs(key, args);
         await this._plan(args, 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilecustoms/envctl",
-  "version": "1.22.0",
+  "version": "1.24.0",
   "description": "node.js CLI client for manage environments",
   "keywords": [
     "terraform wrapper",
@@ -44,36 +44,44 @@
     "-d1-": "",
     "d1-desc": "dev env (fully fledged ~/.envctl/default.json)",
     "d1": "CWD=../tt-core npm run it --",
-    "d1-init": "cd ../tt-core && terraform init -upgrade -backend-config=key=d1 -reconfigure",
+    "d1-init": "  npm run d1 -- init -reconfigure -upgrade -backend-config=key=d1",
     "d1-status": "npm run d1 -- status --verbose",
-    "d1-apply": " npm run d1 -- apply --auto-approve",
+    "d1-apply": " npm run d1 -- apply --auto-approve -var=env_size=min",
     "d1-delete": "npm run d1 -- delete",
+    "d1-logs": "  npm run d1 -- logs",
     "-d2-": "",
     "d2-desc": "dev env destroy",
     "d2": "CWD=../tt-core npm run it --",
-    "d2-init": "cd ../tt-core && terraform init -upgrade -backend-config=key=d2 -reconfigure",
+    "d2-init": "   npm run d2 -- init -reconfigure -upgrade -backend-config=key=d2",
     "d2-status": " npm run d2 -- status",
-    "d2-apply": "  npm run d2 -- apply --auto-approve -var=env_size=min",
+    "d2-apply": "  npm run d2 -- apply --auto-approve",
     "d2-destroy": "npm run d2 -- destroy -var=env_size=min --auto-approve",
     "-d3-": "",
     "d3-desc": "dev env plan apply",
     "d3": "CWD=../tt-core npm run it --",
-    "d3-init": "cd ../tt-core && terraform init -upgrade -backend-config=key=d3 -reconfigure",
+    "d3-init": "  npm run d3 -- init -reconfigure -upgrade -backend-config=key=d3",
     "d3-plan": "  npm run d3 -- plan -var=env_size=min -var=env=d3 -out=plan",
     "d3-apply": " npm run d3 -- apply plan",
     "d3-delete": "npm run d3 -- delete",
+    "-d4-": "",
+    "d4-desc": "terraform plan and then envctl apply",
+    "d4": "CWD=../tt-core npm run it --",
+    "d4-init": "cd ../tt-core && rm .terraform.lock.hcl && terraform init -reconfigure -upgrade -backend-config=key=d4",
+    "d4-plan": "cd ../tt-core && terraform plan -var=env_size=min -var=env=d4 -out=plan",
+    "d4-apply": " npm run d4 -- apply plan",
+    "d4-delete": "npm run d4 -- delete",
     "-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-init": "cd ../tt-core && terraform init -upgrade -backend-config=key=e1 -reconfigure",
+    "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",
     "e1-delete": "npm run e1 -- delete",
     "-tt-": "",
     "tt-desc": "deploy TT project from local machine",
     "tt": "CWD=../tt-gitops AWS_PROFILE=ac-tt-dev-deployer npm run it --",
-    "run-init": "cd ../tt-gitops && terraform init -upgrade -backend-config=key=laxa1986 -reconfigure",
+    "run-init": "   npm run tt -- init -reconfigure -upgrade -backend-config=key=laxa1986",
     "run-status": " npm run tt -- status",
     "run-apply": "  npm run tt -- apply --auto-approve -var=env_size=min -var-file=versions.tfvars",
     "run-delete": " npm run tt -- delete"