@agilecustoms/envctl 0.28.2 → 0.30.0

package/dist/client/EnvApiClient.js

@@ -34,7 +34,11 @@ export class EnvApiClient {
         env.status = EnvStatus.Active;
     }
     async lockForUpdate(env) {
-        const { status } = await this.httpClient.post(`/ci/env/${env.key}/lock-for-update`);
+        const body = {
+            stateFile: env.stateFile,
+            lockFile: env.lockFile
+        };
+        const { status } = await this.httpClient.post(`/ci/env/${env.key}/lock-for-update`, body);
         env.status = status;
     }
     async delete(env) {

package/dist/client/TerraformAdapter.js

@@ -19,7 +19,7 @@ export class TerraformAdapter {
             return acc;
         }, new Map());
     }
-    getKey(cwd) {
+    getStateFile(cwd) {
         const dir = cwd ?? process.cwd();
         const statePath = path.join(dir, '.terraform', 'terraform.tfstate');
         if (!fs.existsSync(statePath)) {
@@ -32,12 +32,29 @@ export class TerraformAdapter {
         catch (err) {
             throw new KnownException(`Failed to read terraform state file: ${statePath}`, { cause: err });
         }
+        return content;
+    }
+    getLockFile(cwd) {
+        const dir = cwd ?? process.cwd();
+        const lockPath = path.join(dir, '.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 });
+        }
+    }
+    getKey(cwd) {
+        const stateFile = this.getStateFile(cwd);
         let tfstate;
         try {
-            tfstate = JSON.parse(content);
+            tfstate = JSON.parse(stateFile);
         }
         catch (err) {
-            throw new KnownException(`Failed to parse terraform state file: ${statePath}`, { cause: err });
+            throw new KnownException(`Failed to parse terraform state file: .terraform/terraform.tfstate`, { cause: err });
         }
         const backendJson = tfstate.backend;
         const type = backendJson?.type;
@@ -53,6 +70,10 @@ export class TerraformAdapter {
         }
         return key;
     }
+    async lockProviders(cwd) {
+        console.log('Update lock file');
+        await this.processRunner.run('terraform', ['providers', 'lock', '-platform=linux_amd64'], cwd);
+    }
     printTime() {
         const now = new Date();
         const utc = now.toISOString();

package/dist/commands/configure.js

@@ -12,12 +12,11 @@ async function handler() {
     const answers = await inquirer.prompt([
         {
             type: 'input',
-            name: 'owner',
-            message: 'owner is required to deploy any env\n'
-                + 'this value will be used as default - if not provided via --owner key in "deploy" command\n'
+            name: 'userName',
+            message: 'userName is required to deploy any env\n'
                 + '(prefer GitHub username)\n'
-                + 'owner:',
+                + 'userName:',
         },
     ]);
-    configService.saveConfig({ owner: answers.owner });
+    configService.saveConfig({ userName: answers.userName });
 }

package/dist/service/ConfigService.js

@@ -23,11 +23,11 @@ export class ConfigService {
         }
         return this.config;
     }
-    getOwner() {
-        const owner = this.loadConfig()?.owner;
-        if (!owner) {
-            throw new KnownException('please first set owner via calling \'envctl configure\'');
+    getUserName() {
+        const userName = this.loadConfig()?.userName;
+        if (!userName) {
+            throw new KnownException('please first set userName via calling \'envctl configure\'');
         }
-        return owner;
+        return userName;
     }
 }

package/dist/service/EnvCtl.js

@@ -59,9 +59,9 @@ export class EnvCtl {
     checkInput(env, cwd) {
         if (env.ephemeral)
             return;
-        const owner = this.configService.getOwner();
-        if (env.owner !== owner) {
-            throw new KnownException(`Can not change env owner ${env.owner} -> ${owner}`);
+        const userName = this.configService.getUserName();
+        if (env.owner !== userName) {
+            throw new KnownException(`Can not change env owner ${env.owner} -> ${userName}`);
         }
         if (env.kind) {
             const kind = this.cliHelper.getKind(cwd);
@@ -81,7 +81,7 @@ export class EnvCtl {
     }
     async plan(tfArgs, cwd) {
         const key = this.terraformAdapter.getKey(cwd);
-        const owner = this.configService.getOwner();
+        const userName = this.configService.getUserName();
         const env = await this.tryGetEnv(key);
         let vars = undefined;
         if (env) {
@@ -93,7 +93,7 @@ export class EnvCtl {
             }
             vars = env.vars;
         }
-        const envTerraform = { key, ephemeral: false, owner, args: tfArgs, vars };
+        const envTerraform = { key, ephemeral: false, owner: userName, args: tfArgs, vars };
         await this.terraformAdapter.plan(envTerraform, cwd);
     }
     async createEphemeral(key) {
@@ -104,25 +104,32 @@ export class EnvCtl {
         const createEnv = { key };
         return await this.envApi.createEphemeral(createEnv);
     }
+    async lockTerraform(env, cwd) {
+        await this.terraformAdapter.lockProviders(cwd);
+        env.stateFile = this.terraformAdapter.getStateFile(cwd);
+        env.lockFile = this.terraformAdapter.getLockFile(cwd);
+    }
     async deploy(tfArgs, cwd) {
         const key = this.terraformAdapter.getKey(cwd);
         let env = await this.tryGetEnv(key);
         if (env === null) {
             const kind = this.cliHelper.getKind(cwd);
             console.log('Creating env metadata');
-            const owner = this.configService.getOwner();
-            const createEnv = { key, owner, kind };
+            const userName = this.configService.getUserName();
+            const createEnv = { key, owner: userName, kind };
+            await this.lockTerraform(createEnv, cwd);
             env = await this.envApi.create(createEnv);
         }
         else {
             this.checkInput(env, cwd);
             this.checkStatus(env);
+            await this.lockTerraform(env, cwd);
             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\nDo you want to proceed with deployment?`);
+                const answerYes = await this.cliHelper.promptYesNo(`Env status is ${env.status}, likely due to an error from a previous run\n
+          Do you want to proceed with deployment?`);
                 if (!answerYes) {
                     console.log('Aborting deployment');
                     return;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.28.2",
+  "version": "0.30.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {