@cdktn/cli-core 0.22.0-pre.2

package/src/lib/models/terraform-cli.js

@@ -0,0 +1,357 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryRemoveGeneratedConfigurationFile = exports.tryReadGeneratedConfigurationFile = exports.TerraformCli = exports.TerraformCliPlan = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const commons_1 = require("@cdktn/commons");
+const terraform_1 = require("./terraform");
+const deploy_machine_1 = require("./deploy-machine");
+const waitFor_1 = require("xstate/lib/waitFor");
+const errors_1 = require("../errors");
+const terraform_json_1 = require("../terraform-json");
+const pty_process_1 = require("./pty-process");
+const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("fs-extra"));
+const GENERATE_CONFIG_OUT_FILE = "generated_resources.tf";
+class TerraformCliPlan extends terraform_1.AbstractTerraformPlan {
+    constructor(planFile, plan) {
+        super(planFile, plan === null || plan === void 0 ? void 0 : plan.resource_changes, plan === null || plan === void 0 ? void 0 : plan.output_changes);
+        this.planFile = planFile;
+        this.plan = plan;
+    }
+}
+exports.TerraformCliPlan = TerraformCliPlan;
+class AbstractOutputFilter {
+}
+// The plan might error if there is a variable missing, but the error message hints the user
+// in a wrong direction. We therefore catch the error and rethrow it with a more helpful message
+class VariableRequiredFilter extends AbstractOutputFilter {
+    // Example for "No value for required variable" error
+    // ╷
+    // │ Error: No value for required variable
+    // │
+    // │   on cdk.tf.json line 31, in variable:
+    // │   31:     "with-dashes": {
+    // │
+    // │ The root module input variable "with-dashes" is not set, and has no default
+    // │ value. Use a -var or -var-file command line argument to provide a value for
+    // │ this variable
+    static condition(input) {
+        const line = (0, strip_ansi_1.default)(input);
+        return (line.includes("Error: No value for required variable") &&
+            line.includes("The root module input variable"));
+    }
+    static transform(line) {
+        const startMarker = 'The root module input variable "';
+        const variableName = line.substring(line.indexOf(startMarker) + startMarker.length, line.indexOf('" is not set'));
+        return (0, errors_1.missingVariable)(variableName);
+    }
+}
+class TerraformCli {
+    constructor(abortSignal, stack, createTerraformLogHandler = (_phase, _filter) => (_stdout, _isErr = false) => { }) {
+        this.abortSignal = abortSignal;
+        this.stack = stack;
+        this.workdir = stack.workingDirectory;
+        this.onStdout =
+            (phase, filter) => (stdout) => createTerraformLogHandler(phase, filter)(Buffer.isBuffer(stdout) ? stdout.toString() : stdout);
+        this.onStderr =
+            (phase, filter) => (stderr) => createTerraformLogHandler(phase, filter)(stderr.toString(), true);
+    }
+    async init(opts) {
+        await this.setUserAgent();
+        const args = ["init"];
+        if (opts.needsUpgrade) {
+            args.push("-upgrade");
+        }
+        if (opts.noColor) {
+            args.push("-no-color");
+        }
+        if (opts.migrateState) {
+            args.push("-migrate-state");
+        }
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        let initCanNotContinue = (_err) => { };
+        const rejectsIfInitCanNotContinue = new Promise((_resolve, reject) => {
+            initCanNotContinue = reject;
+        });
+        const stdout = this.onStdout("init");
+        const { actions, exitCode } = (0, pty_process_1.spawnPty)({
+            file: commons_1.terraformBinaryName,
+            args,
+            options: {
+                cwd: this.workdir,
+                env: process.env,
+            },
+        }, (data) => {
+            stdout(data);
+            if (data.includes("Should Terraform migrate your existing state?") ||
+                data.includes("Do you want to copy existing state to the new backend")) {
+                // TODO: This only happens when terraform is passed the -migrate-state anyway, so this check is redundant
+                if (opts.migrateState) {
+                    actions.writeLine("yes");
+                }
+                else {
+                    actions.stop();
+                    initCanNotContinue("Please pass the --migrate-state flag to migrate your state");
+                }
+            }
+        });
+        this.abortSignal.addEventListener("abort", () => {
+            actions.stop();
+        });
+        const progress = exitCode.then((code) => {
+            if (code !== 0) {
+                throw new Error(`terraform init failed with exit code ${code}`);
+            }
+        });
+        await Promise.race([progress, rejectsIfInitCanNotContinue]);
+        // TODO: this might have performance implications because we don't know if we're
+        // running a remote plan or a local one (so we run it always for all platforms)
+        // while we'd only need it for remote plans
+        if (opts.needsLockfileUpdate) {
+            await (0, commons_1.exec)(commons_1.terraformBinaryName, [
+                "providers",
+                "lock",
+                "-platform=linux_amd64",
+                ...(opts.noColor ? ["-no-color"] : []),
+            ], {
+                cwd: this.workdir,
+                env: process.env,
+                signal: this.abortSignal,
+                noColor: opts.noColor,
+            }, this.onStdout("init"), this.onStderr("init"));
+        }
+    }
+    get isCloudStack() {
+        var _a, _b, _c;
+        const parsedStack = terraform_json_1.terraformJsonSchema.parse(JSON.parse(this.stack.content));
+        return Boolean(((_b = (_a = parsedStack.terraform) === null || _a === void 0 ? void 0 : _a.backend) === null || _b === void 0 ? void 0 : _b.remote) || ((_c = parsedStack.terraform) === null || _c === void 0 ? void 0 : _c.cloud));
+    }
+    get hasImports() {
+        const parsedStack = terraform_json_1.terraformJsonSchema.parse(JSON.parse(this.stack.content));
+        return Boolean(parsedStack.import);
+    }
+    async plan(opts) {
+        const { destroy = false, refreshOnly = false, parallelism = -1, vars = [], varFiles = [], noColor = false, } = opts;
+        const options = ["plan", "-input=false"];
+        const generatedConfigFile = path_1.default.join(this.workdir, GENERATE_CONFIG_OUT_FILE);
+        if (fs.existsSync(generatedConfigFile)) {
+            fs.remove(generatedConfigFile);
+        }
+        if (this.hasImports) {
+            options.push(`-generate-config-out=${GENERATE_CONFIG_OUT_FILE}`);
+        }
+        if (!this.isCloudStack) {
+            const planFile = "plan";
+            options.push("-out", planFile);
+        }
+        if (destroy) {
+            options.push("-destroy");
+        }
+        if (refreshOnly) {
+            options.push("-refresh-only");
+        }
+        if (parallelism > -1) {
+            options.push(`-parallelism=${parallelism}`);
+        }
+        if (noColor) {
+            options.push("-no-color");
+        }
+        vars.forEach((v) => options.push(`-var=${v}`));
+        varFiles.forEach((v) => options.push(`-var-file=${v}`));
+        commons_1.logger.debug(`Executing ${commons_1.terraformBinaryName} ${options.join(" ")} in ${this.workdir}`);
+        await this.setUserAgent();
+        await (0, commons_1.exec)(commons_1.terraformBinaryName, options, {
+            cwd: this.workdir,
+            env: process.env,
+            signal: this.abortSignal,
+            noColor,
+        }, this.onStdout("plan", [VariableRequiredFilter]), this.onStderr("plan", [VariableRequiredFilter]));
+    }
+    async deploy({ autoApprove = false, refreshOnly = false, noColor = false, parallelism = -1, extraOptions = [], vars = [], varFiles = [], }, callback) {
+        await this.setUserAgent();
+        const service = (0, deploy_machine_1.createAndStartDeployService)({
+            terraformBinaryName: commons_1.terraformBinaryName,
+            workdir: this.workdir,
+            refreshOnly,
+            noColor,
+            autoApprove,
+            parallelism,
+            extraOptions,
+            vars,
+            varFiles,
+        });
+        return this.handleService("deploy", service, callback);
+    }
+    async destroy({ autoApprove = false, parallelism = -1, noColor = false, extraOptions = [], vars = [], varFiles = [], }, callback) {
+        await this.setUserAgent();
+        const service = (0, deploy_machine_1.createAndStartDestroyService)({
+            terraformBinaryName: commons_1.terraformBinaryName,
+            workdir: this.workdir,
+            autoApprove,
+            parallelism,
+            noColor,
+            extraOptions,
+            vars,
+            varFiles,
+        });
+        return this.handleService("destroy", service, callback);
+    }
+    async handleService(type, service, callback) {
+        // stop terraform apply if signaled as such from the outside (e.g. via ctrl+c)
+        this.abortSignal.addEventListener("abort", () => {
+            service.send("STOP");
+        }, { once: true });
+        // relay logs to stdout
+        service.onEvent((event) => {
+            commons_1.logger.trace(`Terraform CLI state machine event: ${JSON.stringify(event)}`);
+            if ((0, deploy_machine_1.isDeployEvent)(event, "OUTPUT_RECEIVED"))
+                this.onStdout(type)(event.output);
+            else if ((0, deploy_machine_1.isDeployEvent)(event, "APPROVED_EXTERNALLY"))
+                callback({ type: "external approval reply", approved: true });
+            else if ((0, deploy_machine_1.isDeployEvent)(event, "REJECTED_EXTERNALLY"))
+                callback({ type: "external approval reply", approved: false });
+            else if ((0, deploy_machine_1.isDeployEvent)(event, "OVERRIDDEN_EXTERNALLY"))
+                callback({
+                    type: "external sentinel override reply",
+                    overridden: true,
+                });
+            else if ((0, deploy_machine_1.isDeployEvent)(event, "OVERRIDE_REJECTED_EXTERNALLY"))
+                callback({
+                    type: "external sentinel override reply",
+                    overridden: false,
+                });
+        });
+        let previousState = "idle";
+        service.onTransition((state) => {
+            // only send updates on actual state change
+            // onTransition is called even if the state didn't change but only an event happened
+            if (state.matches(previousState))
+                return;
+            commons_1.logger.trace(`Terraform CLI state machine state transition: ${JSON.stringify(previousState)} => ${JSON.stringify(state.value)}`);
+            if (state.matches({ running: "awaiting_approval" })) {
+                callback({
+                    type: "waiting for approval",
+                    approve: () => service.send("APPROVE"),
+                    reject: () => service.send("REJECT"),
+                });
+            }
+            else if (state.matches({ running: "awaiting_sentinel_override" })) {
+                callback({
+                    type: "waiting for sentinel override",
+                    override: () => service.send("OVERRIDE"),
+                    reject: () => service.send("REJECT_OVERRIDE"),
+                });
+            }
+            else if (state.matches({ running: "processing" })) {
+                callback({
+                    type: "running",
+                    cancelled: Boolean(state.context.cancelled),
+                });
+            }
+            previousState = state.value;
+        });
+        service.start();
+        const state = await (0, waitFor_1.waitFor)(service, (state) => !!state.done, {
+            timeout: Infinity,
+        });
+        commons_1.logger.trace(`Invoking Terraform CLI for ${type} done (state machine reached final state). Last event: ${JSON.stringify(state.event)}. Context: ${JSON.stringify(state.context)}`);
+        // example events: { type: 'EXITED', exitCode: 0 }, { type: 'EXTERNAL_REJECT' }
+        if (state.event.type === "EXITED" &&
+            state.event.exitCode !== 0 &&
+            !state.context.cancelled // don't fail if we cancelled the run
+        ) {
+            throw `Invoking Terraform CLI failed with exit code ${state.event.exitCode}`;
+        }
+        return { cancelled: Boolean(state.context.cancelled) };
+    }
+    async version() {
+        try {
+            return await (0, commons_1.exec)(commons_1.terraformBinaryName, ["-v"], {
+                cwd: this.workdir,
+                env: process.env,
+                signal: this.abortSignal,
+                noColor: true,
+            }, this.onStdout("version"), this.onStderr("version"));
+        }
+        catch (_a) {
+            throw new Error("Terraform CLI not present - Please install a current version https://learn.hashicorp.com/terraform/getting-started/install.html");
+        }
+    }
+    async output() {
+        const output = await (0, commons_1.exec)(commons_1.terraformBinaryName, ["output", "-json"], {
+            cwd: this.workdir,
+            env: process.env,
+            signal: this.abortSignal,
+            noColor: true,
+        }, 
+        // We don't need to log the output here since we use it later on
+        () => { }, // eslint-disable-line @typescript-eslint/no-empty-function
+        this.onStderr("output"));
+        try {
+            return JSON.parse(output);
+        }
+        catch (e) {
+            throw commons_1.Errors.External(`Failed to parse terraform output: ${e}. The output was '${output}'`);
+        }
+    }
+    async setUserAgent() {
+        // Read the cdktf version from the 'cdk.tf.json' file
+        // and set the user agent.
+        const version = await (0, commons_1.readCDKTFVersion)(this.workdir);
+        if (version != "") {
+            process.env.TF_APPEND_USER_AGENT =
+                "cdktn/" +
+                    version +
+                    " (+https://github.com/open-constructs/cdk-terrain)";
+        }
+    }
+    // We don't need to clean anything up for a running execution in the CLI since there is no left-over state in contrast to an open Terraform Cloud run
+    async abort() {
+        return;
+    }
+}
+exports.TerraformCli = TerraformCli;
+async function tryReadGeneratedConfigurationFile(workingDir) {
+    const generatedConfigPath = path_1.default.join(workingDir, GENERATE_CONFIG_OUT_FILE);
+    if (!fs.existsSync(generatedConfigPath)) {
+        return null;
+    }
+    return fs.readFileSync(generatedConfigPath, "utf-8");
+}
+exports.tryReadGeneratedConfigurationFile = tryReadGeneratedConfigurationFile;
+async function tryRemoveGeneratedConfigurationFile(workingDir) {
+    const generatedConfigPath = path_1.default.join(workingDir, GENERATE_CONFIG_OUT_FILE);
+    if (fs.existsSync(generatedConfigPath)) {
+        fs.unlinkSync(generatedConfigPath);
+    }
+}
+exports.tryRemoveGeneratedConfigurationFile = tryRemoveGeneratedConfigurationFile;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terraform-cli.js","sourceRoot":"","sources":["terraform-cli.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport stripAnsi from \"strip-ansi\";\nimport {\n  Errors,\n  exec,\n  logger,\n  readCDKTFVersion,\n  terraformBinaryName,\n} from \"@cdktn/commons\";\nimport {\n  Terraform,\n  TerraformPlan,\n  TerraformOutput,\n  AbstractTerraformPlan,\n  TerraformDeployState,\n} from \"./terraform\";\nimport { SynthesizedStack } from \"../synth-stack\";\nimport {\n  createAndStartDeployService,\n  createAndStartDestroyService,\n  DeployState,\n  isDeployEvent,\n} from \"./deploy-machine\";\nimport { waitFor } from \"xstate/lib/waitFor\";\nimport { missingVariable } from \"../errors\";\nimport { terraformJsonSchema } from \"../terraform-json\";\nimport { spawnPty } from \"./pty-process\";\nimport path from \"path\";\nimport * as fs from \"fs-extra\";\n\nconst GENERATE_CONFIG_OUT_FILE = \"generated_resources.tf\";\n\nexport class TerraformCliPlan\n  extends AbstractTerraformPlan\n  implements TerraformPlan\n{\n  constructor(\n    public readonly planFile: string,\n    public readonly plan: { [key: string]: any },\n  ) {\n    super(planFile, plan?.resource_changes, plan?.output_changes);\n  }\n}\n\nabstract class AbstractOutputFilter {\n  public static condition: (line: string) => boolean;\n  public static transform: (line: string) => string;\n}\nexport type OutputFilter = typeof AbstractOutputFilter;\n\n// The plan might error if there is a variable missing, but the error message hints the user\n// in a wrong direction. We therefore catch the error and rethrow it with a more helpful message\nclass VariableRequiredFilter extends AbstractOutputFilter {\n  // Example for \"No value for required variable\" error\n  // ╷\n  // │ Error: No value for required variable\n  // │\n  // │   on cdk.tf.json line 31, in variable:\n  // │   31:     \"with-dashes\": {\n  // │\n  // │ The root module input variable \"with-dashes\" is not set, and has no default\n  // │ value. Use a -var or -var-file command line argument to provide a value for\n  // │ this variable\n  public static condition(input: string) {\n    const line = stripAnsi(input);\n\n    return (\n      line.includes(\"Error: No value for required variable\") &&\n      line.includes(\"The root module input variable\")\n    );\n  }\n  public static transform(line: string) {\n    const startMarker = 'The root module input variable \"';\n    const variableName = line.substring(\n      line.indexOf(startMarker) + startMarker.length,\n      line.indexOf('\" is not set'),\n    );\n\n    return missingVariable(variableName);\n  }\n}\n\nexport class TerraformCli implements Terraform {\n  public readonly workdir: string;\n  private readonly onStdout: (\n    stateName: string,\n    filter?: OutputFilter[],\n  ) => (stdout: Buffer | string) => void;\n  private readonly onStderr: (\n    stateName: string,\n    filter?: OutputFilter[],\n  ) => (stderr: string | Uint8Array) => void;\n\n  constructor(\n    private readonly abortSignal: AbortSignal,\n    public readonly stack: SynthesizedStack,\n    createTerraformLogHandler = (_phase: string, _filter?: OutputFilter[]) =>\n      (_stdout: string, _isErr = false) => {}, // eslint-disable-line @typescript-eslint/no-empty-function\n  ) {\n    this.workdir = stack.workingDirectory;\n    this.onStdout =\n      (phase: string, filter?: OutputFilter[]) => (stdout: Buffer | string) =>\n        createTerraformLogHandler(\n          phase,\n          filter,\n        )(Buffer.isBuffer(stdout) ? stdout.toString() : stdout);\n    this.onStderr =\n      (phase: string, filter?: OutputFilter[]) =>\n      (stderr: string | Uint8Array) =>\n        createTerraformLogHandler(phase, filter)(stderr.toString(), true);\n  }\n\n  public async init(opts: {\n    needsUpgrade: boolean;\n    noColor?: boolean;\n    migrateState: boolean;\n    needsLockfileUpdate: boolean;\n  }): Promise<void> {\n    await this.setUserAgent();\n\n    const args = [\"init\"];\n    if (opts.needsUpgrade) {\n      args.push(\"-upgrade\");\n    }\n    if (opts.noColor) {\n      args.push(\"-no-color\");\n    }\n    if (opts.migrateState) {\n      args.push(\"-migrate-state\");\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    let initCanNotContinue = (_err: any) => {};\n    const rejectsIfInitCanNotContinue = new Promise((_resolve, reject) => {\n      initCanNotContinue = reject;\n    });\n\n    const stdout = this.onStdout(\"init\");\n    const { actions, exitCode } = spawnPty(\n      {\n        file: terraformBinaryName,\n        args,\n        options: {\n          cwd: this.workdir,\n          env: process.env as any,\n        },\n      },\n      (data) => {\n        stdout(data);\n        if (\n          data.includes(\"Should Terraform migrate your existing state?\") ||\n          data.includes(\"Do you want to copy existing state to the new backend\")\n        ) {\n          // TODO: This only happens when terraform is passed the -migrate-state anyway, so this check is redundant\n          if (opts.migrateState) {\n            actions.writeLine(\"yes\");\n          } else {\n            actions.stop();\n            initCanNotContinue(\n              \"Please pass the --migrate-state flag to migrate your state\",\n            );\n          }\n        }\n      },\n    );\n    this.abortSignal.addEventListener(\"abort\", () => {\n      actions.stop();\n    });\n\n    const progress = exitCode.then((code) => {\n      if (code !== 0) {\n        throw new Error(`terraform init failed with exit code ${code}`);\n      }\n    });\n    await Promise.race([progress, rejectsIfInitCanNotContinue]);\n\n    // TODO: this might have performance implications because we don't know if we're\n    // running a remote plan or a local one (so we run it always for all platforms)\n    // while we'd only need it for remote plans\n    if (opts.needsLockfileUpdate) {\n      await exec(\n        terraformBinaryName,\n        [\n          \"providers\",\n          \"lock\",\n          \"-platform=linux_amd64\",\n          ...(opts.noColor ? [\"-no-color\"] : []),\n        ],\n        {\n          cwd: this.workdir,\n          env: process.env,\n          signal: this.abortSignal,\n          noColor: opts.noColor,\n        },\n        this.onStdout(\"init\"),\n        this.onStderr(\"init\"),\n      );\n    }\n  }\n\n  private get isCloudStack(): boolean {\n    const parsedStack = terraformJsonSchema.parse(\n      JSON.parse(this.stack.content),\n    );\n\n    return Boolean(\n      parsedStack.terraform?.backend?.remote || parsedStack.terraform?.cloud,\n    );\n  }\n\n  private get hasImports(): boolean {\n    const parsedStack = terraformJsonSchema.parse(\n      JSON.parse(this.stack.content),\n    );\n\n    return Boolean(parsedStack.import);\n  }\n\n  public async plan(opts: {\n    destroy: boolean;\n    refreshOnly?: boolean;\n    parallelism?: number;\n    vars?: string[];\n    varFiles?: string[];\n    noColor?: boolean;\n  }): Promise<void> {\n    const {\n      destroy = false,\n      refreshOnly = false,\n      parallelism = -1,\n      vars = [],\n      varFiles = [],\n      noColor = false,\n    } = opts;\n    const options = [\"plan\", \"-input=false\"];\n\n    const generatedConfigFile = path.join(\n      this.workdir,\n      GENERATE_CONFIG_OUT_FILE,\n    );\n    if (fs.existsSync(generatedConfigFile)) {\n      fs.remove(generatedConfigFile);\n    }\n    if (this.hasImports) {\n      options.push(`-generate-config-out=${GENERATE_CONFIG_OUT_FILE}`);\n    }\n    if (!this.isCloudStack) {\n      const planFile = \"plan\";\n      options.push(\"-out\", planFile);\n    }\n\n    if (destroy) {\n      options.push(\"-destroy\");\n    }\n    if (refreshOnly) {\n      options.push(\"-refresh-only\");\n    }\n    if (parallelism > -1) {\n      options.push(`-parallelism=${parallelism}`);\n    }\n    if (noColor) {\n      options.push(\"-no-color\");\n    }\n\n    vars.forEach((v) => options.push(`-var=${v}`));\n    varFiles.forEach((v) => options.push(`-var-file=${v}`));\n\n    logger.debug(\n      `Executing ${terraformBinaryName} ${options.join(\" \")} in ${this.workdir}`,\n    );\n\n    await this.setUserAgent();\n\n    await exec(\n      terraformBinaryName,\n      options,\n      {\n        cwd: this.workdir,\n        env: process.env,\n        signal: this.abortSignal,\n        noColor,\n      },\n      this.onStdout(\"plan\", [VariableRequiredFilter]),\n      this.onStderr(\"plan\", [VariableRequiredFilter]),\n    );\n  }\n\n  public async deploy(\n    {\n      autoApprove = false,\n      refreshOnly = false,\n      noColor = false,\n      parallelism = -1,\n      extraOptions = [],\n      vars = [],\n      varFiles = [],\n    },\n    callback: (state: TerraformDeployState) => void,\n  ): Promise<{ cancelled: boolean }> {\n    await this.setUserAgent();\n    const service = createAndStartDeployService({\n      terraformBinaryName,\n      workdir: this.workdir,\n      refreshOnly,\n      noColor,\n      autoApprove,\n      parallelism,\n      extraOptions,\n      vars,\n      varFiles,\n    });\n    return this.handleService(\"deploy\", service, callback);\n  }\n\n  public async destroy(\n    {\n      autoApprove = false,\n      parallelism = -1,\n      noColor = false,\n      extraOptions = [],\n      vars = [],\n      varFiles = [],\n    },\n    callback: (state: TerraformDeployState) => void,\n  ): Promise<{ cancelled: boolean }> {\n    await this.setUserAgent();\n    const service = createAndStartDestroyService({\n      terraformBinaryName,\n      workdir: this.workdir,\n      autoApprove,\n      parallelism,\n      noColor,\n      extraOptions,\n      vars,\n      varFiles,\n    });\n    return this.handleService(\"destroy\", service, callback);\n  }\n\n  private async handleService(\n    type: \"deploy\" | \"destroy\",\n    service:\n      | ReturnType<typeof createAndStartDeployService>\n      | ReturnType<typeof createAndStartDestroyService>,\n    callback: (state: TerraformDeployState) => void,\n  ): Promise<{ cancelled: boolean }> {\n    // stop terraform apply if signaled as such from the outside (e.g. via ctrl+c)\n    this.abortSignal.addEventListener(\n      \"abort\",\n      () => {\n        service.send(\"STOP\");\n      },\n      { once: true },\n    );\n\n    // relay logs to stdout\n    service.onEvent((event) => {\n      logger.trace(\n        `Terraform CLI state machine event: ${JSON.stringify(event)}`,\n      );\n      if (isDeployEvent(event, \"OUTPUT_RECEIVED\"))\n        this.onStdout(type)(event.output);\n      else if (isDeployEvent(event, \"APPROVED_EXTERNALLY\"))\n        callback({ type: \"external approval reply\", approved: true });\n      else if (isDeployEvent(event, \"REJECTED_EXTERNALLY\"))\n        callback({ type: \"external approval reply\", approved: false });\n      else if (isDeployEvent(event, \"OVERRIDDEN_EXTERNALLY\"))\n        callback({\n          type: \"external sentinel override reply\",\n          overridden: true,\n        });\n      else if (isDeployEvent(event, \"OVERRIDE_REJECTED_EXTERNALLY\"))\n        callback({\n          type: \"external sentinel override reply\",\n          overridden: false,\n        });\n    });\n\n    let previousState: DeployState[\"value\"] = \"idle\";\n\n    service.onTransition((state) => {\n      // only send updates on actual state change\n      // onTransition is called even if the state didn't change but only an event happened\n      if (state.matches(previousState as DeployState[\"value\"])) return;\n\n      logger.trace(\n        `Terraform CLI state machine state transition: ${JSON.stringify(\n          previousState,\n        )} => ${JSON.stringify(state.value)}`,\n      );\n\n      if (state.matches({ running: \"awaiting_approval\" })) {\n        callback({\n          type: \"waiting for approval\",\n          approve: () => service.send(\"APPROVE\"),\n          reject: () => service.send(\"REJECT\"),\n        });\n      } else if (state.matches({ running: \"awaiting_sentinel_override\" })) {\n        callback({\n          type: \"waiting for sentinel override\",\n          override: () => service.send(\"OVERRIDE\"),\n          reject: () => service.send(\"REJECT_OVERRIDE\"),\n        });\n      } else if (state.matches({ running: \"processing\" })) {\n        callback({\n          type: \"running\",\n          cancelled: Boolean(state.context.cancelled),\n        });\n      }\n      previousState = state.value as DeployState[\"value\"];\n    });\n    service.start();\n    const state = await waitFor(service, (state) => !!state.done, {\n      timeout: Infinity,\n    });\n\n    logger.trace(\n      `Invoking Terraform CLI for ${type} done (state machine reached final state). Last event: ${JSON.stringify(\n        state.event,\n      )}. Context: ${JSON.stringify(state.context)}`,\n    );\n\n    // example events: { type: 'EXITED', exitCode: 0 }, { type: 'EXTERNAL_REJECT' }\n    if (\n      state.event.type === \"EXITED\" &&\n      state.event.exitCode !== 0 &&\n      !state.context.cancelled // don't fail if we cancelled the run\n    ) {\n      throw `Invoking Terraform CLI failed with exit code ${state.event.exitCode}`;\n    }\n\n    return { cancelled: Boolean(state.context.cancelled) };\n  }\n\n  public async version(): Promise<string> {\n    try {\n      return await exec(\n        terraformBinaryName,\n        [\"-v\"],\n        {\n          cwd: this.workdir,\n          env: process.env,\n          signal: this.abortSignal,\n          noColor: true,\n        },\n        this.onStdout(\"version\"),\n        this.onStderr(\"version\"),\n      );\n    } catch {\n      throw new Error(\n        \"Terraform CLI not present - Please install a current version https://learn.hashicorp.com/terraform/getting-started/install.html\",\n      );\n    }\n  }\n\n  public async output(): Promise<{ [key: string]: TerraformOutput }> {\n    const output = await exec(\n      terraformBinaryName,\n      [\"output\", \"-json\"],\n      {\n        cwd: this.workdir,\n        env: process.env,\n        signal: this.abortSignal,\n        noColor: true,\n      },\n      // We don't need to log the output here since we use it later on\n      () => {}, // eslint-disable-line @typescript-eslint/no-empty-function\n      this.onStderr(\"output\"),\n    );\n\n    try {\n      return JSON.parse(output);\n    } catch (e) {\n      throw Errors.External(\n        `Failed to parse terraform output: ${e}. The output was '${output}'`,\n      );\n    }\n  }\n\n  public async setUserAgent(): Promise<void> {\n    // Read the cdktf version from the 'cdk.tf.json' file\n    // and set the user agent.\n    const version = await readCDKTFVersion(this.workdir);\n    if (version != \"\") {\n      process.env.TF_APPEND_USER_AGENT =\n        \"cdktn/\" +\n        version +\n        \" (+https://github.com/open-constructs/cdk-terrain)\";\n    }\n  }\n\n  // We don't need to clean anything up for a running execution in the CLI since there is no left-over state in contrast to an open Terraform Cloud run\n  public async abort() {\n    return;\n  }\n}\n\nexport async function tryReadGeneratedConfigurationFile(\n  workingDir: string,\n): Promise<string | null> {\n  const generatedConfigPath = path.join(workingDir, GENERATE_CONFIG_OUT_FILE);\n  if (!fs.existsSync(generatedConfigPath)) {\n    return null;\n  }\n  return fs.readFileSync(generatedConfigPath, \"utf-8\");\n}\n\nexport async function tryRemoveGeneratedConfigurationFile(workingDir: string) {\n  const generatedConfigPath = path.join(workingDir, GENERATE_CONFIG_OUT_FILE);\n  if (fs.existsSync(generatedConfigPath)) {\n    fs.unlinkSync(generatedConfigPath);\n  }\n}\n"]}

package/src/lib/models/terraform.d.ts

@@ -0,0 +1,125 @@
+export declare enum PlannedResourceAction {
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete",
+    READ = "read",
+    NO_OP = "no-op"
+}
+export declare enum DeployingResourceApplyState {
+    WAITING = "waiting",
+    UPDATING = "updating",
+    UPDATED = "updated",
+    CREATING = "creating",
+    CREATED = "created",
+    DESTROYING = "destroying",
+    DESTROYED = "destroyed",
+    SUCCESS = "success",
+    ERROR = "error"
+}
+export interface PlannedResource {
+    id: string;
+    action: PlannedResourceAction;
+}
+export interface DeployingResource extends PlannedResource {
+    applyState: DeployingResourceApplyState;
+}
+export interface ResourceChangesChange {
+    actions: string[];
+    before: {
+        [key: string]: any;
+    };
+    after: {
+        [key: string]: any;
+    };
+}
+export interface ResourceChanges {
+    address: string;
+    module_address: string;
+    mode: string;
+    type: string;
+    name: string;
+    index: number;
+    provider_name: string;
+    change: ResourceChangesChange;
+}
+export interface TerraformOutput {
+    sensitive: boolean;
+    type: string | Array<any>;
+    value: string | Record<string, unknown> | Array<any>;
+}
+export declare function isTerraformOutput(output: any): output is TerraformOutput;
+export interface TerraformPlan {
+    readonly resources: PlannedResource[];
+    readonly applyableResources: PlannedResource[];
+    readonly needsApply: boolean;
+    readonly planFile: string;
+}
+export declare abstract class AbstractTerraformPlan implements TerraformPlan {
+    readonly planFile: string;
+    private readonly resourceChanges;
+    private readonly outputChanges;
+    constructor(planFile: string, resourceChanges: ResourceChanges[], outputChanges: Record<string, ResourceChangesChange>);
+    get resources(): PlannedResource[];
+    get applyableResources(): PlannedResource[];
+    get outputs(): PlannedResource[];
+    get changingOutputs(): PlannedResource[];
+    get needsApply(): boolean;
+}
+export type TerraformDeployState = {
+    type: "running";
+    cancelled: boolean;
+} | {
+    type: "waiting for approval";
+    approve: () => void;
+    reject: () => void;
+} | {
+    type: "waiting for sentinel override";
+    override: () => void;
+    reject: () => void;
+} | {
+    type: "external approval reply";
+    approved: boolean;
+} | {
+    type: "external sentinel override reply";
+    overridden: boolean;
+};
+export interface Terraform {
+    init: (opts: {
+        needsUpgrade: boolean;
+        noColor?: boolean;
+        needsLockfileUpdate: boolean;
+        migrateState: boolean;
+    }) => Promise<void>;
+    plan: (opts: {
+        destroy: boolean;
+        refreshOnly?: boolean;
+        parallelism?: number;
+        vars?: string[];
+        varFiles?: string[];
+        noColor?: boolean;
+    }) => Promise<void>;
+    deploy(options: {
+        autoApprove?: boolean;
+        refreshOnly?: boolean;
+        parallelism?: number;
+        vars?: string[];
+        varFiles?: string[];
+        noColor?: boolean;
+    }, callback: (state: TerraformDeployState) => void): Promise<{
+        cancelled: boolean;
+    }>;
+    destroy(options: {
+        autoApprove?: boolean;
+        parallelism?: number;
+        vars?: string[];
+        varFiles?: string[];
+        noColor?: boolean;
+    }, callback: (state: TerraformDeployState) => void): Promise<{
+        cancelled: boolean;
+    }>;
+    output(): Promise<{
+        [key: string]: TerraformOutput;
+    }>;
+    abort: () => Promise<void>;
+}
+//# sourceMappingURL=terraform.d.ts.map

package/src/lib/models/terraform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terraform.d.ts","sourceRoot":"","sources":["terraform.ts"],"names":[],"mappings":"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"}

package/src/lib/models/terraform.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractTerraformPlan = exports.isTerraformOutput = exports.DeployingResourceApplyState = exports.PlannedResourceAction = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+var PlannedResourceAction;
+(function (PlannedResourceAction) {
+    PlannedResourceAction["CREATE"] = "create";
+    PlannedResourceAction["UPDATE"] = "update";
+    PlannedResourceAction["DELETE"] = "delete";
+    PlannedResourceAction["READ"] = "read";
+    PlannedResourceAction["NO_OP"] = "no-op";
+})(PlannedResourceAction || (exports.PlannedResourceAction = PlannedResourceAction = {}));
+var DeployingResourceApplyState;
+(function (DeployingResourceApplyState) {
+    DeployingResourceApplyState["WAITING"] = "waiting";
+    DeployingResourceApplyState["UPDATING"] = "updating";
+    DeployingResourceApplyState["UPDATED"] = "updated";
+    DeployingResourceApplyState["CREATING"] = "creating";
+    DeployingResourceApplyState["CREATED"] = "created";
+    DeployingResourceApplyState["DESTROYING"] = "destroying";
+    DeployingResourceApplyState["DESTROYED"] = "destroyed";
+    DeployingResourceApplyState["SUCCESS"] = "success";
+    DeployingResourceApplyState["ERROR"] = "error";
+})(DeployingResourceApplyState || (exports.DeployingResourceApplyState = DeployingResourceApplyState = {}));
+function isTerraformOutput(output) {
+    return (typeof output === "object" &&
+        typeof output.sensitive === "boolean" &&
+        (typeof output.type === "string" || Array.isArray(output.type)));
+}
+exports.isTerraformOutput = isTerraformOutput;
+function filterChangingResources(resources) {
+    const applyActions = [
+        PlannedResourceAction.UPDATE,
+        PlannedResourceAction.CREATE,
+        PlannedResourceAction.DELETE,
+        PlannedResourceAction.READ,
+    ];
+    return resources.filter((resource) => applyActions.includes(resource.action));
+}
+class AbstractTerraformPlan {
+    constructor(planFile, resourceChanges, outputChanges) {
+        this.planFile = planFile;
+        this.resourceChanges = resourceChanges;
+        this.outputChanges = outputChanges;
+    }
+    get resources() {
+        return (this.resourceChanges || []).map((resource) => {
+            return {
+                id: resource.address,
+                action: resource.change.actions[0],
+            };
+        });
+    }
+    get applyableResources() {
+        return filterChangingResources(this.resources);
+    }
+    get outputs() {
+        return Object.entries(this.outputChanges || {}).map(([key, value]) => ({
+            id: `output.${key}`,
+            action: value.actions[0],
+        }));
+    }
+    get changingOutputs() {
+        return filterChangingResources(this.outputs);
+    }
+    get needsApply() {
+        return (this.applyableResources.length > 0 || this.changingOutputs.length > 0);
+    }
+}
+exports.AbstractTerraformPlan = AbstractTerraformPlan;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terraform.js","sourceRoot":"","sources":["terraform.ts"],"names":[],"mappings":";;;AAAA,+BAA+B;AAC/B,mCAAmC;AACnC,IAAY,qBAMX;AAND,WAAY,qBAAqB;IAC/B,0CAAiB,CAAA;IACjB,0CAAiB,CAAA;IACjB,0CAAiB,CAAA;IACjB,sCAAa,CAAA;IACb,wCAAe,CAAA;AACjB,CAAC,EANW,qBAAqB,qCAArB,qBAAqB,QAMhC;AAED,IAAY,2BAUX;AAVD,WAAY,2BAA2B;IACrC,kDAAmB,CAAA;IACnB,oDAAqB,CAAA;IACrB,kDAAmB,CAAA;IACnB,oDAAqB,CAAA;IACrB,kDAAmB,CAAA;IACnB,wDAAyB,CAAA;IACzB,sDAAuB,CAAA;IACvB,kDAAmB,CAAA;IACnB,8CAAe,CAAA;AACjB,CAAC,EAVW,2BAA2B,2CAA3B,2BAA2B,QAUtC;AAiCD,SAAgB,iBAAiB,CAAC,MAAW;IAC3C,OAAO,CACL,OAAO,MAAM,KAAK,QAAQ;QAC1B,OAAO,MAAM,CAAC,SAAS,KAAK,SAAS;QACrC,CAAC,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAChE,CAAC;AACJ,CAAC;AAND,8CAMC;AASD,SAAS,uBAAuB,CAAC,SAA4B;IAC3D,MAAM,YAAY,GAAG;QACnB,qBAAqB,CAAC,MAAM;QAC5B,qBAAqB,CAAC,MAAM;QAC5B,qBAAqB,CAAC,MAAM;QAC5B,qBAAqB,CAAC,IAAI;KAC3B,CAAC;IACF,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;AAChF,CAAC;AACD,MAAsB,qBAAqB;IACzC,YACkB,QAAgB,EACf,eAAkC,EAClC,aAAoD;QAFrD,aAAQ,GAAR,QAAQ,CAAQ;QACf,oBAAe,GAAf,eAAe,CAAmB;QAClC,kBAAa,GAAb,aAAa,CAAuC;IACpE,CAAC;IAEJ,IAAW,SAAS;QAClB,OAAO,CAAC,IAAI,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;YACnD,OAAO;gBACL,EAAE,EAAE,QAAQ,CAAC,OAAO;gBACpB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;aAChB,CAAC;QACvB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAW,kBAAkB;QAC3B,OAAO,uBAAuB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACjD,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;YACrE,EAAE,EAAE,UAAU,GAAG,EAAE;YACnB,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;SACzB,CAAC,CAAsB,CAAC;IAC3B,CAAC;IAED,IAAW,eAAe;QACxB,OAAO,uBAAuB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,CACL,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CACtE,CAAC;IACJ,CAAC;CACF;AApCD,sDAoCC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nexport enum PlannedResourceAction {\n  CREATE = \"create\",\n  UPDATE = \"update\",\n  DELETE = \"delete\",\n  READ = \"read\",\n  NO_OP = \"no-op\",\n}\n\nexport enum DeployingResourceApplyState {\n  WAITING = \"waiting\",\n  UPDATING = \"updating\",\n  UPDATED = \"updated\",\n  CREATING = \"creating\",\n  CREATED = \"created\",\n  DESTROYING = \"destroying\",\n  DESTROYED = \"destroyed\",\n  SUCCESS = \"success\",\n  ERROR = \"error\",\n}\nexport interface PlannedResource {\n  id: string;\n  action: PlannedResourceAction;\n}\n\nexport interface DeployingResource extends PlannedResource {\n  applyState: DeployingResourceApplyState;\n}\n\nexport interface ResourceChangesChange {\n  actions: string[];\n  before: { [key: string]: any };\n  after: { [key: string]: any };\n}\n\nexport interface ResourceChanges {\n  address: string;\n  module_address: string;\n  mode: string;\n  type: string;\n  name: string;\n  index: number;\n  provider_name: string;\n  change: ResourceChangesChange;\n}\n\nexport interface TerraformOutput {\n  sensitive: boolean;\n  type: string | Array<any>;\n  value: string | Record<string, unknown> | Array<any>;\n}\n\nexport function isTerraformOutput(output: any): output is TerraformOutput {\n  return (\n    typeof output === \"object\" &&\n    typeof output.sensitive === \"boolean\" &&\n    (typeof output.type === \"string\" || Array.isArray(output.type))\n  );\n}\n\nexport interface TerraformPlan {\n  readonly resources: PlannedResource[];\n  readonly applyableResources: PlannedResource[];\n  readonly needsApply: boolean;\n  readonly planFile: string;\n}\n\nfunction filterChangingResources(resources: PlannedResource[]) {\n  const applyActions = [\n    PlannedResourceAction.UPDATE,\n    PlannedResourceAction.CREATE,\n    PlannedResourceAction.DELETE,\n    PlannedResourceAction.READ,\n  ];\n  return resources.filter((resource) => applyActions.includes(resource.action));\n}\nexport abstract class AbstractTerraformPlan implements TerraformPlan {\n  constructor(\n    public readonly planFile: string,\n    private readonly resourceChanges: ResourceChanges[],\n    private readonly outputChanges: Record<string, ResourceChangesChange>,\n  ) {}\n\n  public get resources(): PlannedResource[] {\n    return (this.resourceChanges || []).map((resource) => {\n      return {\n        id: resource.address,\n        action: resource.change.actions[0],\n      } as PlannedResource;\n    });\n  }\n\n  public get applyableResources(): PlannedResource[] {\n    return filterChangingResources(this.resources);\n  }\n\n  public get outputs(): PlannedResource[] {\n    return Object.entries(this.outputChanges || {}).map(([key, value]) => ({\n      id: `output.${key}`,\n      action: value.actions[0],\n    })) as PlannedResource[];\n  }\n\n  public get changingOutputs(): PlannedResource[] {\n    return filterChangingResources(this.outputs);\n  }\n\n  public get needsApply(): boolean {\n    return (\n      this.applyableResources.length > 0 || this.changingOutputs.length > 0\n    );\n  }\n}\n\nexport type TerraformDeployState =\n  | { type: \"running\"; cancelled: boolean }\n  | {\n      type: \"waiting for approval\";\n      approve: () => void;\n      reject: () => void;\n    }\n  | {\n      type: \"waiting for sentinel override\";\n      override: () => void;\n      reject: () => void;\n    }\n  | { type: \"external approval reply\"; approved: boolean }\n  | { type: \"external sentinel override reply\"; overridden: boolean };\n\nexport interface Terraform {\n  init: (opts: {\n    needsUpgrade: boolean;\n    noColor?: boolean;\n    needsLockfileUpdate: boolean;\n    migrateState: boolean;\n  }) => Promise<void>;\n\n  plan: (opts: {\n    destroy: boolean;\n    refreshOnly?: boolean;\n    parallelism?: number;\n    vars?: string[];\n    varFiles?: string[];\n    noColor?: boolean;\n  }) => Promise<void>;\n  deploy(\n    options: {\n      autoApprove?: boolean;\n      refreshOnly?: boolean;\n      parallelism?: number;\n      vars?: string[];\n      varFiles?: string[];\n      noColor?: boolean;\n    },\n    callback: (state: TerraformDeployState) => void,\n  ): Promise<{ cancelled: boolean }>;\n  destroy(\n    options: {\n      autoApprove?: boolean;\n      parallelism?: number;\n      vars?: string[];\n      varFiles?: string[];\n      noColor?: boolean;\n    },\n    callback: (state: TerraformDeployState) => void,\n  ): Promise<{ cancelled: boolean }>;\n  output(): Promise<{ [key: string]: TerraformOutput }>;\n  abort: () => Promise<void>;\n}\n"]}