@agilecustoms/envctl 0.36.2 → 0.37.1

package/dist/container.js

@@ -3,6 +3,7 @@ import { AwsCredsHelper } from './client/AwsCredsHelper.js';
 import { CliHelper, EnvApiClient, HttpClient, TerraformAdapter } from './client/index.js';
 import { ProcessRunner } from './client/ProcessRunner.js';
 import { ConfigService, EnvService } from './service/index.js';
+import { LocalStateService } from './service/LocalStateService.js';
 import { LogService } from './service/LogService.js';
 const cliHelper = new CliHelper();
 const configService = new ConfigService();
@@ -14,6 +15,7 @@ const httpClient = new HttpClient(awsCredsHelper);
 const envApiClient = new EnvApiClient(httpClient);
 const processRunner = new ProcessRunner();
 const terraformAdapter = new TerraformAdapter(processRunner, cliHelper, backends);
-const envService = new EnvService(cliHelper, envApiClient, terraformAdapter);
+const localStateService = new LocalStateService();
+const envService = new EnvService(cliHelper, envApiClient, terraformAdapter, localStateService);
 const logService = new LogService(envApiClient, terraformAdapter, processRunner);
 export { awsCredsHelper, configService, envService, logService };

package/dist/service/EnvService.js

@@ -1,13 +1,17 @@
+import { CliHelper, EnvApiClient, TerraformAdapter } from '../client/index.js';
 import { KnownException } from '../exceptions.js';
-import { EnvStatus, } from '../model/index.js';
+import { EnvStatus } from '../model/index.js';
+import { LocalStateService } from './LocalStateService.js';
 export class EnvService {
     cliHelper;
     envApi;
     terraformAdapter;
-    constructor(cliHelper, envApi, terraformAdapter) {
+    localStateService;
+    constructor(cliHelper, envApi, terraformAdapter, localStateService) {
         this.cliHelper = cliHelper;
         this.envApi = envApi;
         this.terraformAdapter = terraformAdapter;
+        this.localStateService = localStateService;
     }
     async status(key, cwd) {
         key = this.terraformAdapter.getKey(key, cwd);
@@ -81,15 +85,32 @@ export class EnvService {
         return await this.envApi.createEphemeral(createEnv);
     }
     async lockTerraform(env, cwd) {
+        const config = this.localStateService.load(cwd);
         console.log('validate terraform.tfstate file');
-        env.stateFile = this.terraformAdapter.getTerraformBackend(cwd).validateAndGetStateFileContent();
-        await this.terraformAdapter.lockProviders(cwd);
-        env.lockFile = this.terraformAdapter.getLockFile(cwd);
+        const stateFileContent = this.terraformAdapter.getTerraformBackend(cwd).validateAndGetStateFileContent();
+        const stateHash = this.localStateService.hash(stateFileContent);
+        if (config.stateHash !== stateHash) {
+            config.stateHash = stateHash;
+            env.stateFile = stateFileContent;
+        }
+        const linuxArm64 = process.platform === 'linux' && process.arch === 'arm64';
+        if (!linuxArm64) {
+            let lockFileContent = this.terraformAdapter.getLockFile(cwd);
+            const lockFileHash = this.localStateService.hash(lockFileContent);
+            if (config.lockHash !== lockFileHash) {
+                await this.terraformAdapter.lockProviders(cwd);
+                lockFileContent = this.terraformAdapter.getLockFile(cwd);
+                config.lockHash = this.localStateService.hash(lockFileContent);
+                env.lockFile = lockFileContent;
+            }
+        }
+        this.localStateService.save(config, cwd);
     }
     async deploy(tfArgs, cwd) {
         const key = this.terraformAdapter.getTerraformBackend(cwd).getKey();
         let env = await this.tryGetEnv(key);
         if (env === null) {
+            this.localStateService.init(cwd);
             const kind = this.cliHelper.getKind(cwd);
             console.log(`Inferred kind from directory name: ${kind}`);
             const createEnv = { key, kind };
@@ -102,6 +123,10 @@ export class EnvService {
         this.checkKind(env, cwd);
         switch (env.status) {
             case EnvStatus.Init:
+                this.localStateService.init(cwd);
+                await this.lockTerraform(env, cwd);
+                await this.envApi.lockForUpdate(env);
+                break;
             case EnvStatus.Active:
                 if (env.status === EnvStatus.Active) {
                     console.log('Env status is ACTIVE\nWill lock for update and run terraform apply (to update resources)');

package/dist/service/LocalStateService.js

@@ -0,0 +1,59 @@
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import path from 'path';
+const CURRENT_VERSION = 1;
+export class LocalStateService {
+    config;
+    constructor() {
+    }
+    filePath(cwd) {
+        cwd = cwd || process.cwd();
+        return path.join(cwd, '.terraform', 'envctl.json');
+    }
+    hash(data) {
+        return createHash('sha256').update(data).digest('hex');
+    }
+    createEmptyConfig(filePath) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        this.config = { version: CURRENT_VERSION };
+        fs.writeFileSync(filePath, JSON.stringify(this.config, null, 2));
+        return this.config;
+    }
+    init(cwd) {
+        const filePath = this.filePath(cwd);
+        if (!fs.existsSync(filePath)) {
+            this.createEmptyConfig(filePath);
+            return;
+        }
+        const data = fs.readFileSync(filePath, 'utf-8');
+        const config = JSON.parse(data);
+        if (config.version == CURRENT_VERSION) {
+            this.config = config;
+            return;
+        }
+        console.log('local state file version mismatch, re-initializing');
+        this.createEmptyConfig(filePath);
+    }
+    load(cwd) {
+        if (this.config)
+            return this.config;
+        console.log('load local state config');
+        const filePath = this.filePath(cwd);
+        if (!fs.existsSync(filePath)) {
+            console.warn('local state file does not exist, must have been accidentally deleted, re-initializing');
+            return this.createEmptyConfig(filePath);
+        }
+        const data = fs.readFileSync(filePath, 'utf-8');
+        this.config = JSON.parse(data);
+        return this.config;
+    }
+    save(config, cwd) {
+        if (!this.config) {
+            throw new Error('call init or load first');
+        }
+        const mergedConfig = { ...this.load(cwd), ...config };
+        const data = JSON.stringify(mergedConfig, null, 2);
+        const filePath = this.filePath(cwd);
+        fs.writeFileSync(filePath, data);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.36.2",
+  "version": "0.37.1",
   "author": "Alex Chekulaev",
   "type": "module",
   "engines": {
@@ -32,7 +32,7 @@
     "run-version": "  tsc --sourceMap true && npm run run -- --version",
     "run-configure": "tsc --sourceMap true && npm run run -- configure",
     "~": "",
-    "run-core-init": "cd ../tt-core && terraform init -upgrade -backend-config=key=laxa1986",
+    "run-core-init": "cd ../tt-core && terraform init -upgrade -backend-config=key=laxa1986 -reconfigure",
     "run-core-status": " tsc --sourceMap true && npm run run -- status  --cwd ../tt-core",
     "run-core-plan": "   tsc --sourceMap true && npm run run -- plan    --cwd ../tt-core",
     "run-core-deploy": " tsc --sourceMap true && npm run run -- deploy  --cwd ../tt-core -var=\"env_size=min\"",