@cdktn/cli-core 0.22.0-pre.2

package/src/lib/cdktf-stack.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdktfStack = void 0;
+const output_1 = require("./output");
+const commons_1 = require("@cdktn/commons");
+const terraform_logs_1 = require("./server/terraform-logs");
+const terraform_cli_1 = require("./models/terraform-cli");
+const dependency_manager_1 = require("./dependencies/dependency-manager");
+const terraform_json_1 = require("./terraform-json");
+const terraform_provider_lock_1 = require("./terraform-provider-lock");
+const convert_1 = require("./convert");
+async function getTerraformClient(abortSignal, stack, createTerraformLogHandler) {
+    return new terraform_cli_1.TerraformCli(abortSignal, stack, createTerraformLogHandler);
+}
+class CdktfStack {
+    constructor(options) {
+        this.options = options;
+        this.stopped = false;
+        this.currentState = "idle";
+        this.stack = options.stack;
+        this.parsedContent = terraform_json_1.terraformJsonSchema.parse(JSON.parse(this.stack.content));
+    }
+    get isPending() {
+        return this.currentState === "idle" && !this.stopped;
+    }
+    get isDone() {
+        return (this.currentState === "done" ||
+            this.currentState === "errored" ||
+            this.stopped);
+    }
+    get isRunning() {
+        return !this.isPending && !this.isDone;
+    }
+    updateState(update) {
+        commons_1.logger.debug(`[${this.stack.name}]: ${update.type}`);
+        this.currentState = update.type;
+        switch (update.type) {
+            case "idle":
+            case "done":
+                break;
+            case "errored":
+                this.error = update.error;
+                this.options.onUpdate(update);
+                break;
+            case "outputs fetched":
+            case "deployed":
+                commons_1.logger.debug(`Outputs: ${JSON.stringify(update.outputs)}`);
+                commons_1.logger.debug(`OutputsByConstructId: ${JSON.stringify(update.outputsByConstructId)}`);
+                this.outputs = update.outputs;
+                this.outputsByConstructId = update.outputsByConstructId;
+                this.options.onUpdate(update);
+                break;
+            default:
+                this.options.onUpdate(update);
+                break;
+        }
+    }
+    createTerraformLogHandler(phase, filters) {
+        commons_1.logger.debug("Creating terraform log handler", phase);
+        const onLog = this.options.onLog;
+        return (msg, isError = false) => {
+            const message = (0, terraform_logs_1.extractJsonLogIfPresent)(msg);
+            commons_1.logger.debug(`[${this.options.stack.name}](${phase}): ${msg}`);
+            const filterToApply = filters === null || filters === void 0 ? void 0 : filters.find((filter) => filter.condition(message));
+            const filteredMessage = filterToApply
+                ? filterToApply.transform(message)
+                : message;
+            if (filteredMessage) {
+                commons_1.logger.debug(`Filter ${filterToApply} applied on line '${message}' with result '${filteredMessage}'`);
+            }
+            if (onLog) {
+                onLog({ message: filteredMessage, isError });
+            }
+        };
+    }
+    async terraformClient() {
+        return await getTerraformClient(this.options.abortSignal, this.options.stack, this.createTerraformLogHandler.bind(this));
+    }
+    async initalizeTerraform(noColor, skipProviderLock, migrateState) {
+        const terraform = await this.terraformClient();
+        const needsLockfileUpdate = skipProviderLock
+            ? false
+            : await this.checkNeedsLockfileUpdate();
+        const needsUpgrade = await this.checkNeedsUpgrade();
+        await terraform.init({
+            needsUpgrade,
+            noColor: noColor !== null && noColor !== void 0 ? noColor : false,
+            needsLockfileUpdate,
+            migrateState: migrateState !== null && migrateState !== void 0 ? migrateState : false,
+        });
+        return terraform;
+    }
+    requiredProviders() {
+        var _a;
+        // Read required providers from the stack output
+        const requiredProviders = (_a = this.parsedContent.terraform) === null || _a === void 0 ? void 0 : _a.required_providers;
+        return Object.values(requiredProviders || {}).reduce((acc, obj) => {
+            const constraint = new dependency_manager_1.ProviderConstraint(obj.source, obj.version);
+            acc[constraint.source] = constraint;
+            return acc;
+        }, {});
+    }
+    async checkNeedsLockfileUpdate() {
+        if (this.options.migrateState) {
+            // If we're migrating state, we need to init
+            return true;
+        }
+        const lock = new terraform_provider_lock_1.TerraformProviderLock(this.stack.workingDirectory);
+        const lockFileExists = await lock.hasProviderLockFile();
+        if (!lockFileExists) {
+            // If we don't have a lock file, this is probably the first init
+            return true;
+        }
+        const requiredProviders = this.requiredProviders();
+        for (const provider of Object.values(requiredProviders)) {
+            const hasProvider = await lock.hasMatchingProvider(provider);
+            if (!hasProvider) {
+                // If we don't have a provider or version doesn't match, we need to init
+                return true;
+            }
+        }
+        return false;
+    }
+    async checkNeedsUpgrade() {
+        const lock = new terraform_provider_lock_1.TerraformProviderLock(this.stack.workingDirectory);
+        const allProviders = this.requiredProviders();
+        const lockedProviders = Object.values(await lock.providers());
+        // Check if any provider contained in `providers` violates constraints in `lockedProviders`
+        // Upgrade if some provider constraint not met
+        // If a provider wasn't preset in lockedProviders, that's fine; it will just get added
+        return lockedProviders.some((lockedProvider) => {
+            var _a;
+            const lockedConstraint = lockedProvider.constraints;
+            if (!lockedConstraint) {
+                // Provider lock doesn't have a constraint specified, so we can't check.
+                // This shouldn't happen
+                commons_1.logger.debug(`Provider lock doesn't have a constraint for ${lockedProvider.name}`);
+                return false;
+            }
+            const provider = allProviders[lockedConstraint.source];
+            if (!provider) {
+                // else no longer using this provider, so won't cause problems
+                return;
+            }
+            return !lockedConstraint.matchesVersion((_a = provider.version) !== null && _a !== void 0 ? _a : ">0");
+        });
+    }
+    async run(cb) {
+        if (this.stopped) {
+            return;
+        }
+        try {
+            this.currentWorkPromise = cb();
+            await this.currentWorkPromise;
+            this.updateState({ type: "done" });
+        }
+        catch (e) {
+            commons_1.logger.trace("Error in currentWorkPromise", e);
+            this.currentWorkPromise = undefined;
+            this.updateState({
+                type: "errored",
+                stackName: this.stack.name,
+                error: String(e),
+            });
+            throw e;
+        }
+        finally {
+            this.currentWorkPromise = undefined;
+        }
+    }
+    async diff({ refreshOnly, terraformParallelism, vars, varFiles, noColor, }) {
+        await this.run(async () => {
+            this.updateState({ type: "planning", stackName: this.stack.name });
+            const terraform = await this.terraformClient();
+            await terraform.plan({
+                destroy: false,
+                refreshOnly,
+                parallelism: terraformParallelism,
+                vars,
+                varFiles,
+                noColor,
+            });
+            this.updateState({ type: "planned", stackName: this.stack.name });
+            // Find generated file
+            const configFile = await (0, terraform_cli_1.tryReadGeneratedConfigurationFile)(this.stack.workingDirectory);
+            if (configFile) {
+                this.updateState({
+                    type: "import with configuration detected",
+                    stackName: this.stack.name,
+                    configuration: configFile,
+                });
+                const convertedCode = await (0, convert_1.convertConfigurationFile)(configFile, this.stack.workingDirectory);
+                this.updateState({
+                    type: "import with configuration converted",
+                    stackName: this.stack.name,
+                    configuration: convertedCode,
+                });
+                const onLog = this.options.onLog;
+                if (onLog) {
+                    onLog({
+                        message: `Import without configuration detected. Terraform has created configuration for it:
+${configFile}
+
+CDKTN has translated the code to the following:
+
+${convertedCode}
+
+Please review the code and make any necessary changes before adding it to your codebase.
+Make sure to only copy the code within the construct's constructor.
+
+NOTE: Your resource has not yet become managed by CDKTN. 
+To finish the import remove the call "generateConfigForImport", add the above code within the construct's constructor, and then append the call importFrom(<resource_id_to_import_from>) to the generated code: 
+
+new SomeResource(...).importFrom("some_id")
+`,
+                        isError: false,
+                    });
+                }
+                await (0, terraform_cli_1.tryRemoveGeneratedConfigurationFile)(this.stack.workingDirectory);
+            }
+        });
+    }
+    async deploy(opts) {
+        const { refreshOnly, terraformParallelism, noColor, vars, varFiles } = opts;
+        await this.run(async () => {
+            this.updateState({ type: "planning", stackName: this.stack.name });
+            const terraform = await this.terraformClient();
+            const { cancelled } = await terraform.deploy({
+                autoApprove: this.options.autoApprove,
+                refreshOnly,
+                parallelism: terraformParallelism,
+                vars,
+                varFiles,
+                noColor,
+            }, (state) => {
+                // state updates while apply runs that affect the UI
+                if (state.type === "running" && !state.cancelled) {
+                    this.updateState({
+                        type: "deploying",
+                        stackName: this.stack.name,
+                    });
+                }
+                else if (state.type === "waiting for approval") {
+                    this.updateState({
+                        type: "waiting for stack approval",
+                        stackName: this.stack.name,
+                        approve: state.approve,
+                        reject: () => {
+                            state.reject();
+                            this.updateState({
+                                type: "dismissed",
+                                stackName: this.stack.name,
+                            });
+                        },
+                    });
+                }
+                else if (state.type === "waiting for sentinel override") {
+                    this.updateState({
+                        type: "waiting for stack sentinel override",
+                        stackName: this.stack.name,
+                        override: state.override,
+                        reject: () => {
+                            state.reject();
+                            this.updateState({
+                                type: "dismissed",
+                                stackName: this.stack.name,
+                            });
+                        },
+                    });
+                }
+                else if (state.type === "external approval reply") {
+                    this.updateState({
+                        type: "external stack approval reply",
+                        stackName: this.stack.name,
+                        approved: state.approved,
+                    });
+                }
+                else if (state.type === "external sentinel override reply") {
+                    this.updateState({
+                        type: "external stack sentinel override reply",
+                        stackName: this.stack.name,
+                        overridden: state.overridden,
+                    });
+                }
+            });
+            if (!cancelled) {
+                const outputs = await terraform.output();
+                const outputsByConstructId = (0, output_1.getConstructIdsForOutputs)(JSON.parse(this.stack.content), outputs);
+                this.updateState({
+                    type: "deployed",
+                    stackName: this.stack.name,
+                    outputs,
+                    outputsByConstructId,
+                });
+            }
+        });
+    }
+    async destroy(opts) {
+        const { terraformParallelism, noColor, vars, varFiles } = opts;
+        await this.run(async () => {
+            this.updateState({ type: "planning", stackName: this.stack.name });
+            const terraform = await this.terraformClient();
+            const { cancelled } = await terraform.destroy({
+                autoApprove: this.options.autoApprove,
+                parallelism: terraformParallelism,
+                vars,
+                varFiles,
+                noColor,
+            }, (state) => {
+                // state updates while apply runs that affect the UI
+                if (state.type === "running" && !state.cancelled) {
+                    this.updateState({
+                        type: "destroying",
+                        stackName: this.stack.name,
+                    });
+                }
+                else if (state.type === "waiting for approval") {
+                    this.updateState({
+                        type: "waiting for stack approval",
+                        stackName: this.stack.name,
+                        approve: state.approve,
+                        reject: () => {
+                            state.reject();
+                            this.updateState({
+                                type: "dismissed",
+                                stackName: this.stack.name,
+                            });
+                        },
+                    });
+                }
+                else if (state.type === "waiting for sentinel override") {
+                    this.updateState({
+                        type: "waiting for stack sentinel override",
+                        stackName: this.stack.name,
+                        override: state.override,
+                        reject: () => {
+                            state.reject();
+                            this.updateState({
+                                type: "dismissed",
+                                stackName: this.stack.name,
+                            });
+                        },
+                    });
+                }
+                else if (state.type === "external approval reply") {
+                    this.updateState({
+                        type: "external stack approval reply",
+                        stackName: this.stack.name,
+                        approved: state.approved,
+                    });
+                }
+                else if (state.type === "external sentinel override reply") {
+                    this.updateState({
+                        type: "external stack sentinel override reply",
+                        stackName: this.stack.name,
+                        overridden: state.overridden,
+                    });
+                }
+            });
+            if (!cancelled)
+                this.updateState({
+                    type: "destroyed",
+                    stackName: this.stack.name,
+                });
+        });
+    }
+    async fetchOutputs() {
+        await this.run(async () => {
+            const terraform = await this.terraformClient();
+            const outputs = await terraform.output();
+            const outputsByConstructId = (0, output_1.getConstructIdsForOutputs)(JSON.parse(this.stack.content), outputs);
+            this.updateState({
+                type: "outputs fetched",
+                stackName: this.stack.name,
+                outputs,
+                outputsByConstructId,
+            });
+        });
+        return this.outputs;
+    }
+    async stop() {
+        this.stopped = true;
+    }
+}
+exports.CdktfStack = CdktfStack;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdktf-stack.js","sourceRoot":"","sources":["cdktf-stack.ts"],"names":[],"mappings":";;;AAIA,qCAA6E;AAC7E,4CAAwC;AACxC,4DAAkE;AAClE,0DAKgC;AAChC,0EAAuE;AACvE,qDAAuE;AACvE,uEAAkE;AAClE,uCAAqD;AA4FrD,KAAK,UAAU,kBAAkB,CAC/B,WAAwB,EACxB,KAAuB,EACvB,yBAGiD;IAEjD,OAAO,IAAI,4BAAY,CAAC,WAAW,EAAE,KAAK,EAAE,yBAAyB,CAAC,CAAC;AACzE,CAAC;AA2BD,MAAa,UAAU;IAUrB,YAAmB,OAA0B;QAA1B,YAAO,GAAP,OAAO,CAAmB;QANtC,YAAO,GAAG,KAAK,CAAC;QAEP,iBAAY,GAAqB,MAAM,CAAC;QAKtD,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC,aAAa,GAAG,oCAAmB,CAAC,KAAK,CAC5C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/B,CAAC;IACJ,CAAC;IAED,IAAW,SAAS;QAClB,OAAO,IAAI,CAAC,YAAY,KAAK,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;IACvD,CAAC;IACD,IAAW,MAAM;QACf,OAAO,CACL,IAAI,CAAC,YAAY,KAAK,MAAM;YAC5B,IAAI,CAAC,YAAY,KAAK,SAAS;YAC/B,IAAI,CAAC,OAAO,CACb,CAAC;IACJ,CAAC;IACD,IAAW,SAAS;QAClB,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;IACzC,CAAC;IAEO,WAAW,CACjB,MAOoB;QAEpB,gBAAM,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,YAAiC,GAAG,MAAM,CAAC,IAAI,CAAC;QACtD,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;YACpB,KAAK,MAAM,CAAC;YACZ,KAAK,MAAM;gBACT,MAAM;YAER,KAAK,SAAS;gBACZ,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;gBAC1B,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAC9B,MAAM;YAER,KAAK,iBAAiB,CAAC;YACvB,KAAK,UAAU;gBACb,gBAAM,CAAC,KAAK,CAAC,YAAY,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;gBAC3D,gBAAM,CAAC,KAAK,CACV,yBAAyB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,oBAAoB,CAAC,EAAE,CACvE,CAAC;gBACF,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;gBAC9B,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC;gBACxD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAC9B,MAAM;YAER;gBACE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBAC9B,MAAM;QACV,CAAC;IACH,CAAC;IAEO,yBAAyB,CAC/B,KAAa,EACb,OAAwB;QAExB,gBAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE,KAAK,CAAC,CAAC;QAEtD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;QACjC,OAAO,CAAC,GAAW,EAAE,OAAO,GAAG,KAAK,EAAE,EAAE;YACtC,MAAM,OAAO,GAAG,IAAA,wCAAuB,EAAC,GAAG,CAAC,CAAC;YAC7C,gBAAM,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,MAAM,GAAG,EAAE,CAAC,CAAC;YAE/D,MAAM,aAAa,GAAG,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAC7C,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAC1B,CAAC;YACF,MAAM,eAAe,GAAG,aAAa;gBACnC,CAAC,CAAC,aAAa,CAAC,SAAS,CAAC,OAAO,CAAC;gBAClC,CAAC,CAAC,OAAO,CAAC;YAEZ,IAAI,eAAe,EAAE,CAAC;gBACpB,gBAAM,CAAC,KAAK,CACV,UAAU,aAAa,qBAAqB,OAAO,kBAAkB,eAAe,GAAG,CACxF,CAAC;YACJ,CAAC;YAED,IAAI,KAAK,EAAE,CAAC;gBACV,KAAK,CAAC,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,eAAe;QAC3B,OAAO,MAAM,kBAAkB,CAC7B,IAAI,CAAC,OAAO,CAAC,WAAW,EACxB,IAAI,CAAC,OAAO,CAAC,KAAK,EAClB,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,IAAI,CAAC,CAC1C,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAC7B,OAAiB,EACjB,gBAA0B,EAC1B,YAAsB;QAEtB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC/C,MAAM,mBAAmB,GAAG,gBAAgB;YAC1C,CAAC,CAAC,KAAK;YACP,CAAC,CAAC,MAAM,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAC1C,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACpD,MAAM,SAAS,CAAC,IAAI,CAAC;YACnB,YAAY;YACZ,OAAO,EAAE,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,KAAK;YACzB,mBAAmB;YACnB,YAAY,EAAE,YAAY,aAAZ,YAAY,cAAZ,YAAY,GAAI,KAAK;SACpC,CAAC,CAAC;QACH,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,iBAAiB;;QACvB,gDAAgD;QAChD,MAAM,iBAAiB,GAAG,MAAA,IAAI,CAAC,aAAa,CAAC,SAAS,0CAAE,kBAAkB,CAAC;QAE3E,OAAO,MAAM,CAAC,MAAM,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,MAAM,CAClD,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YACX,MAAM,UAAU,GAAG,IAAI,uCAAkB,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YACnE,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,UAAU,CAAC;YACpC,OAAO,GAAG,CAAC;QACb,CAAC,EACD,EAAwC,CACzC,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,wBAAwB;QACpC,IAAI,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YAC9B,4CAA4C;YAC5C,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,+CAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QACpE,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAExD,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,gEAAgE;YAChE,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEnD,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,EAAE,CAAC;YACxD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;YAC7D,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,wEAAwE;gBACxE,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,KAAK,CAAC,iBAAiB;QAC7B,MAAM,IAAI,GAAG,IAAI,+CAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QACpE,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC9C,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;QAE9D,2FAA2F;QAC3F,8CAA8C;QAC9C,sFAAsF;QACtF,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,EAAE;;YAC7C,MAAM,gBAAgB,GAAG,cAAc,CAAC,WAAW,CAAC;YACpD,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACtB,wEAAwE;gBACxE,wBAAwB;gBACxB,gBAAM,CAAC,KAAK,CACV,+CAA+C,cAAc,CAAC,IAAI,EAAE,CACrE,CAAC;gBACF,OAAO,KAAK,CAAC;YACf,CAAC;YAED,MAAM,QAAQ,GAAG,YAAY,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;YACvD,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,8DAA8D;gBAC9D,OAAO;YACT,CAAC;YAED,OAAO,CAAC,gBAAgB,CAAC,cAAc,CAAC,MAAA,QAAQ,CAAC,OAAO,mCAAI,IAAI,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,GAAG,CAAC,EAAuB;QACvC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,IAAI,CAAC,kBAAkB,GAAG,EAAE,EAAE,CAAC;YAC/B,MAAM,IAAI,CAAC,kBAAkB,CAAC;YAC9B,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,gBAAM,CAAC,KAAK,CAAC,6BAA6B,EAAE,CAAC,CAAC,CAAC;YAC/C,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;YACpC,IAAI,CAAC,WAAW,CAAC;gBACf,IAAI,EAAE,SAAS;gBACf,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;gBAC1B,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;aACjB,CAAC,CAAC;YACH,MAAM,CAAC,CAAC;QACV,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;QACtC,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,EAChB,WAAW,EACX,oBAAoB,EACpB,IAAI,EACJ,QAAQ,EACR,OAAO,GAOR;QACC,MAAM,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;YACxB,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YACnE,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;YAE/C,MAAM,SAAS,CAAC,IAAI,CAAC;gBACnB,OAAO,EAAE,KAAK;gBACd,WAAW;gBACX,WAAW,EAAE,oBAAoB;gBACjC,IAAI;gBACJ,QAAQ;gBACR,OAAO;aACR,CAAC,CAAC;YACH,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YAElE,sBAAsB;YACtB,MAAM,UAAU,GAAG,MAAM,IAAA,iDAAiC,EACxD,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAC5B,CAAC;YACF,IAAI,UAAU,EAAE,CAAC;gBACf,IAAI,CAAC,WAAW,CAAC;oBACf,IAAI,EAAE,oCAAoC;oBAC1C,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;oBAC1B,aAAa,EAAE,UAAU;iBAC1B,CAAC,CAAC;gBAEH,MAAM,aAAa,GAAG,MAAM,IAAA,kCAAwB,EAClD,UAAU,EACV,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAC5B,CAAC;gBACF,IAAI,CAAC,WAAW,CAAC;oBACf,IAAI,EAAE,qCAAqC;oBAC3C,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;oBAC1B,aAAa,EAAE,aAAa;iBAC7B,CAAC,CAAC;gBACH,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;gBACjC,IAAI,KAAK,EAAE,CAAC;oBACV,KAAK,CAAC;wBACJ,OAAO,EAAE;EACnB,UAAU;;;;EAIV,aAAa;;;;;;;;;CASd;wBACW,OAAO,EAAE,KAAK;qBACf,CAAC,CAAC;gBACL,CAAC;gBACD,MAAM,IAAA,mDAAmC,EAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;YACzE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,IAMnB;QACC,MAAM,EAAE,WAAW,EAAE,oBAAoB,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;QAC5E,MAAM,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;YACxB,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YACnE,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;YAE/C,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,SAAS,CAAC,MAAM,CAC1C;gBACE,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW;gBACrC,WAAW;gBACX,WAAW,EAAE,oBAAoB;gBACjC,IAAI;gBACJ,QAAQ;gBACR,OAAO;aACR,EACD,CAAC,KAAK,EAAE,EAAE;gBACR,oDAAoD;gBACpD,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;oBACjD,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,WAAW;wBACjB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;qBAC3B,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,KAAK,CAAC,IAAI,KAAK,sBAAsB,EAAE,CAAC;oBACjD,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,4BAA4B;wBAClC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;wBAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;wBACtB,MAAM,EAAE,GAAG,EAAE;4BACX,KAAK,CAAC,MAAM,EAAE,CAAC;4BACf,IAAI,CAAC,WAAW,CAAC;gCACf,IAAI,EAAE,WAAW;gCACjB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;6BAC3B,CAAC,CAAC;wBACL,CAAC;qBACF,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,KAAK,CAAC,IAAI,KAAK,+BAA+B,EAAE,CAAC;oBAC1D,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,qCAAqC;wBAC3C,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;wBAC1B,QAAQ,EAAE,KAAK,CAAC,QAAQ;wBACxB,MAAM,EAAE,GAAG,EAAE;4BACX,KAAK,CAAC,MAAM,EAAE,CAAC;4BACf,IAAI,CAAC,WAAW,CAAC;gCACf,IAAI,EAAE,WAAW;gCACjB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;6BAC3B,CAAC,CAAC;wBACL,CAAC;qBACF,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,KAAK,CAAC,IAAI,KAAK,yBAAyB,EAAE,CAAC;oBACpD,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,+BAA+B;wBACrC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;wBAC1B,QAAQ,EAAE,KAAK,CAAC,QAAQ;qBACzB,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,KAAK,CAAC,IAAI,KAAK,kCAAkC,EAAE,CAAC;oBAC7D,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,wCAAwC;wBAC9C,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;wBAC1B,UAAU,EAAE,KAAK,CAAC,UAAU;qBAC7B,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CACF,CAAC;YAEF,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,OAAO,GAAG,MAAM,SAAS,CAAC,MAAM,EAAE,CAAC;gBACzC,MAAM,oBAAoB,GAAG,IAAA,kCAAyB,EACpD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAC9B,OAAO,CACR,CAAC;gBAEF,IAAI,CAAC,WAAW,CAAC;oBACf,IAAI,EAAE,UAAU;oBAChB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;oBAC1B,OAAO;oBACP,oBAAoB;iBACrB,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,IAKpB;QACC,MAAM,EAAE,oBAAoB,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;QAC/D,MAAM,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;YACxB,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;YACnE,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;YAC/C,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,SAAS,CAAC,OAAO,CAC3C;gBACE,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW;gBACrC,WAAW,EAAE,oBAAoB;gBACjC,IAAI;gBACJ,QAAQ;gBACR,OAAO;aACR,EACD,CAAC,KAAK,EAAE,EAAE;gBACR,oDAAoD;gBACpD,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;oBACjD,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,YAAY;wBAClB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;qBAC3B,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,KAAK,CAAC,IAAI,KAAK,sBAAsB,EAAE,CAAC;oBACjD,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,4BAA4B;wBAClC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;wBAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;wBACtB,MAAM,EAAE,GAAG,EAAE;4BACX,KAAK,CAAC,MAAM,EAAE,CAAC;4BACf,IAAI,CAAC,WAAW,CAAC;gCACf,IAAI,EAAE,WAAW;gCACjB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;6BAC3B,CAAC,CAAC;wBACL,CAAC;qBACF,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,KAAK,CAAC,IAAI,KAAK,+BAA+B,EAAE,CAAC;oBAC1D,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,qCAAqC;wBAC3C,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;wBAC1B,QAAQ,EAAE,KAAK,CAAC,QAAQ;wBACxB,MAAM,EAAE,GAAG,EAAE;4BACX,KAAK,CAAC,MAAM,EAAE,CAAC;4BACf,IAAI,CAAC,WAAW,CAAC;gCACf,IAAI,EAAE,WAAW;gCACjB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;6BAC3B,CAAC,CAAC;wBACL,CAAC;qBACF,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,KAAK,CAAC,IAAI,KAAK,yBAAyB,EAAE,CAAC;oBACpD,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,+BAA+B;wBACrC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;wBAC1B,QAAQ,EAAE,KAAK,CAAC,QAAQ;qBACzB,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,KAAK,CAAC,IAAI,KAAK,kCAAkC,EAAE,CAAC;oBAC7D,IAAI,CAAC,WAAW,CAAC;wBACf,IAAI,EAAE,wCAAwC;wBAC9C,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;wBAC1B,UAAU,EAAE,KAAK,CAAC,UAAU;qBAC7B,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CACF,CAAC;YAEF,IAAI,CAAC,SAAS;gBACZ,IAAI,CAAC,WAAW,CAAC;oBACf,IAAI,EAAE,WAAW;oBACjB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;iBAC3B,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,YAAY;QACvB,MAAM,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;YACxB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;YAE/C,MAAM,OAAO,GAAG,MAAM,SAAS,CAAC,MAAM,EAAE,CAAC;YACzC,MAAM,oBAAoB,GAAG,IAAA,kCAAyB,EACpD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAC9B,OAAO,CACR,CAAC;YACF,IAAI,CAAC,WAAW,CAAC;gBACf,IAAI,EAAE,iBAAiB;gBACvB,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI;gBAC1B,OAAO;gBACP,oBAAoB;aACrB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAEM,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;CACF;AA7dD,gCA6dC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { SynthesizedStack } from \"./synth-stack\";\nimport { Terraform } from \"./models/terraform\";\nimport { getConstructIdsForOutputs, NestedTerraformOutputs } from \"./output\";\nimport { logger } from \"@cdktn/commons\";\nimport { extractJsonLogIfPresent } from \"./server/terraform-logs\";\nimport {\n  TerraformCli,\n  OutputFilter,\n  tryReadGeneratedConfigurationFile,\n  tryRemoveGeneratedConfigurationFile,\n} from \"./models/terraform-cli\";\nimport { ProviderConstraint } from \"./dependencies/dependency-manager\";\nimport { terraformJsonSchema, TerraformStack } from \"./terraform-json\";\nimport { TerraformProviderLock } from \"./terraform-provider-lock\";\nimport { convertConfigurationFile } from \"./convert\";\n\nexport type StackUpdate =\n  | {\n      type: \"planning\";\n      stackName: string;\n    }\n  | {\n      type: \"planned\";\n      stackName: string;\n    }\n  | {\n      type: \"deploying\";\n      stackName: string;\n    }\n  | {\n      type: \"deploy update\";\n      stackName: string;\n      deployOutput: string;\n    }\n  | {\n      type: \"deployed\";\n      stackName: string;\n      outputsByConstructId: NestedTerraformOutputs;\n      outputs: Record<string, any>;\n    }\n  | {\n      type: \"destroying\";\n      stackName: string;\n    }\n  | {\n      type: \"destroy update\";\n      stackName: string;\n      destroyOutput: string;\n    }\n  | {\n      type: \"destroyed\";\n      stackName: string;\n    }\n  | {\n      type: \"outputs fetched\";\n      stackName: string;\n      outputsByConstructId: NestedTerraformOutputs;\n      outputs: Record<string, any>;\n    }\n  | {\n      type: \"errored\";\n      stackName: string;\n      error: string;\n    }\n  | {\n      type: \"dismissed\";\n      stackName: string;\n    }\n  | {\n      type: \"import with configuration detected\";\n      stackName: string;\n      configuration: string;\n    }\n  | {\n      type: \"import with configuration converted\";\n      stackName: string;\n      configuration: string;\n    };\n\nexport type StackUserInputUpdate =\n  | StackApprovalUpdate\n  | StackSentinelOverrideUpdate;\n\nexport type StackApprovalUpdate = {\n  type: \"waiting for stack approval\";\n  stackName: string;\n  approve: () => void;\n  reject: () => void;\n};\nexport type StackSentinelOverrideUpdate = {\n  type: \"waiting for stack sentinel override\";\n  stackName: string;\n  override: () => void;\n  reject: () => void;\n};\nexport type ExternalStackApprovalUpdate = {\n  type: \"external stack approval reply\";\n  stackName: string;\n  approved: boolean; // false = rejected\n};\nexport type ExternalStackSentinelOverrideUpdate = {\n  type: \"external stack sentinel override reply\";\n  stackName: string;\n  overridden: boolean; // false = rejected\n};\n\nasync function getTerraformClient(\n  abortSignal: AbortSignal,\n  stack: SynthesizedStack,\n  createTerraformLogHandler: (\n    phase: string,\n    filter?: OutputFilter[],\n  ) => (message: string, isError?: boolean) => void,\n): Promise<Terraform> {\n  return new TerraformCli(abortSignal, stack, createTerraformLogHandler);\n}\n\ntype CdktfStackOptions = {\n  stack: SynthesizedStack;\n  onUpdate: (\n    update:\n      | StackUpdate\n      | StackApprovalUpdate\n      | ExternalStackApprovalUpdate\n      | StackSentinelOverrideUpdate\n      | ExternalStackSentinelOverrideUpdate,\n  ) => void;\n  onLog?: (log: { message: string; isError: boolean }) => void;\n  autoApprove?: boolean;\n  migrateState?: boolean;\n  abortSignal: AbortSignal;\n};\n\ntype CdktfStackStates =\n  | StackUpdate[\"type\"]\n  | StackApprovalUpdate[\"type\"]\n  | StackSentinelOverrideUpdate[\"type\"]\n  | ExternalStackApprovalUpdate[\"type\"]\n  | ExternalStackSentinelOverrideUpdate[\"type\"]\n  | \"idle\"\n  | \"done\";\n\nexport class CdktfStack {\n  public stack: SynthesizedStack;\n  public outputs?: Record<string, any>;\n  public outputsByConstructId?: NestedTerraformOutputs;\n  public stopped = false;\n  public currentWorkPromise: Promise<void> | undefined;\n  public readonly currentState: CdktfStackStates = \"idle\";\n  public error?: string;\n  private readonly parsedContent: TerraformStack;\n\n  constructor(public options: CdktfStackOptions) {\n    this.stack = options.stack;\n    this.parsedContent = terraformJsonSchema.parse(\n      JSON.parse(this.stack.content),\n    );\n  }\n\n  public get isPending(): boolean {\n    return this.currentState === \"idle\" && !this.stopped;\n  }\n  public get isDone(): boolean {\n    return (\n      this.currentState === \"done\" ||\n      this.currentState === \"errored\" ||\n      this.stopped\n    );\n  }\n  public get isRunning(): boolean {\n    return !this.isPending && !this.isDone;\n  }\n\n  private updateState(\n    update:\n      | StackUpdate\n      | StackApprovalUpdate\n      | StackSentinelOverrideUpdate\n      | ExternalStackApprovalUpdate\n      | ExternalStackSentinelOverrideUpdate\n      | { type: \"idle\" }\n      | { type: \"done\" },\n  ) {\n    logger.debug(`[${this.stack.name}]: ${update.type}`);\n    (this.currentState as CdktfStackStates) = update.type;\n    switch (update.type) {\n      case \"idle\":\n      case \"done\":\n        break;\n\n      case \"errored\":\n        this.error = update.error;\n        this.options.onUpdate(update);\n        break;\n\n      case \"outputs fetched\":\n      case \"deployed\":\n        logger.debug(`Outputs: ${JSON.stringify(update.outputs)}`);\n        logger.debug(\n          `OutputsByConstructId: ${JSON.stringify(update.outputsByConstructId)}`,\n        );\n        this.outputs = update.outputs;\n        this.outputsByConstructId = update.outputsByConstructId;\n        this.options.onUpdate(update);\n        break;\n\n      default:\n        this.options.onUpdate(update);\n        break;\n    }\n  }\n\n  private createTerraformLogHandler(\n    phase: string,\n    filters?: OutputFilter[],\n  ): (message: string, isError?: boolean) => void {\n    logger.debug(\"Creating terraform log handler\", phase);\n\n    const onLog = this.options.onLog;\n    return (msg: string, isError = false) => {\n      const message = extractJsonLogIfPresent(msg);\n      logger.debug(`[${this.options.stack.name}](${phase}): ${msg}`);\n\n      const filterToApply = filters?.find((filter) =>\n        filter.condition(message),\n      );\n      const filteredMessage = filterToApply\n        ? filterToApply.transform(message)\n        : message;\n\n      if (filteredMessage) {\n        logger.debug(\n          `Filter ${filterToApply} applied on line '${message}' with result '${filteredMessage}'`,\n        );\n      }\n\n      if (onLog) {\n        onLog({ message: filteredMessage, isError });\n      }\n    };\n  }\n\n  private async terraformClient() {\n    return await getTerraformClient(\n      this.options.abortSignal,\n      this.options.stack,\n      this.createTerraformLogHandler.bind(this),\n    );\n  }\n\n  public async initalizeTerraform(\n    noColor?: boolean,\n    skipProviderLock?: boolean,\n    migrateState?: boolean,\n  ) {\n    const terraform = await this.terraformClient();\n    const needsLockfileUpdate = skipProviderLock\n      ? false\n      : await this.checkNeedsLockfileUpdate();\n    const needsUpgrade = await this.checkNeedsUpgrade();\n    await terraform.init({\n      needsUpgrade,\n      noColor: noColor ?? false,\n      needsLockfileUpdate,\n      migrateState: migrateState ?? false,\n    });\n    return terraform;\n  }\n\n  private requiredProviders() {\n    // Read required providers from the stack output\n    const requiredProviders = this.parsedContent.terraform?.required_providers;\n\n    return Object.values(requiredProviders || {}).reduce(\n      (acc, obj) => {\n        const constraint = new ProviderConstraint(obj.source, obj.version);\n        acc[constraint.source] = constraint;\n        return acc;\n      },\n      {} as Record<string, ProviderConstraint>,\n    );\n  }\n\n  private async checkNeedsLockfileUpdate(): Promise<boolean> {\n    if (this.options.migrateState) {\n      // If we're migrating state, we need to init\n      return true;\n    }\n    const lock = new TerraformProviderLock(this.stack.workingDirectory);\n    const lockFileExists = await lock.hasProviderLockFile();\n\n    if (!lockFileExists) {\n      // If we don't have a lock file, this is probably the first init\n      return true;\n    }\n\n    const requiredProviders = this.requiredProviders();\n\n    for (const provider of Object.values(requiredProviders)) {\n      const hasProvider = await lock.hasMatchingProvider(provider);\n      if (!hasProvider) {\n        // If we don't have a provider or version doesn't match, we need to init\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  private async checkNeedsUpgrade(): Promise<boolean> {\n    const lock = new TerraformProviderLock(this.stack.workingDirectory);\n    const allProviders = this.requiredProviders();\n    const lockedProviders = Object.values(await lock.providers());\n\n    // Check if any provider contained in `providers` violates constraints in `lockedProviders`\n    // Upgrade if some provider constraint not met\n    // If a provider wasn't preset in lockedProviders, that's fine; it will just get added\n    return lockedProviders.some((lockedProvider) => {\n      const lockedConstraint = lockedProvider.constraints;\n      if (!lockedConstraint) {\n        // Provider lock doesn't have a constraint specified, so we can't check.\n        // This shouldn't happen\n        logger.debug(\n          `Provider lock doesn't have a constraint for ${lockedProvider.name}`,\n        );\n        return false;\n      }\n\n      const provider = allProviders[lockedConstraint.source];\n      if (!provider) {\n        // else no longer using this provider, so won't cause problems\n        return;\n      }\n\n      return !lockedConstraint.matchesVersion(provider.version ?? \">0\");\n    });\n  }\n\n  private async run(cb: () => Promise<void>) {\n    if (this.stopped) {\n      return;\n    }\n\n    try {\n      this.currentWorkPromise = cb();\n      await this.currentWorkPromise;\n      this.updateState({ type: \"done\" });\n    } catch (e) {\n      logger.trace(\"Error in currentWorkPromise\", e);\n      this.currentWorkPromise = undefined;\n      this.updateState({\n        type: \"errored\",\n        stackName: this.stack.name,\n        error: String(e),\n      });\n      throw e;\n    } finally {\n      this.currentWorkPromise = undefined;\n    }\n  }\n\n  public async diff({\n    refreshOnly,\n    terraformParallelism,\n    vars,\n    varFiles,\n    noColor,\n  }: {\n    refreshOnly?: boolean;\n    terraformParallelism?: number;\n    vars?: string[];\n    varFiles?: string[];\n    noColor?: boolean;\n  }) {\n    await this.run(async () => {\n      this.updateState({ type: \"planning\", stackName: this.stack.name });\n      const terraform = await this.terraformClient();\n\n      await terraform.plan({\n        destroy: false,\n        refreshOnly,\n        parallelism: terraformParallelism,\n        vars,\n        varFiles,\n        noColor,\n      });\n      this.updateState({ type: \"planned\", stackName: this.stack.name });\n\n      // Find generated file\n      const configFile = await tryReadGeneratedConfigurationFile(\n        this.stack.workingDirectory,\n      );\n      if (configFile) {\n        this.updateState({\n          type: \"import with configuration detected\",\n          stackName: this.stack.name,\n          configuration: configFile,\n        });\n\n        const convertedCode = await convertConfigurationFile(\n          configFile,\n          this.stack.workingDirectory,\n        );\n        this.updateState({\n          type: \"import with configuration converted\",\n          stackName: this.stack.name,\n          configuration: convertedCode,\n        });\n        const onLog = this.options.onLog;\n        if (onLog) {\n          onLog({\n            message: `Import without configuration detected. Terraform has created configuration for it:\n${configFile}\n\nCDKTN has translated the code to the following:\n\n${convertedCode}\n\nPlease review the code and make any necessary changes before adding it to your codebase.\nMake sure to only copy the code within the construct's constructor.\n\nNOTE: Your resource has not yet become managed by CDKTN. \nTo finish the import remove the call \"generateConfigForImport\", add the above code within the construct's constructor, and then append the call importFrom(<resource_id_to_import_from>) to the generated code: \n\nnew SomeResource(...).importFrom(\"some_id\")\n`,\n            isError: false,\n          });\n        }\n        await tryRemoveGeneratedConfigurationFile(this.stack.workingDirectory);\n      }\n    });\n  }\n\n  public async deploy(opts: {\n    refreshOnly?: boolean;\n    terraformParallelism?: number;\n    noColor?: boolean;\n    vars?: string[];\n    varFiles?: string[];\n  }) {\n    const { refreshOnly, terraformParallelism, noColor, vars, varFiles } = opts;\n    await this.run(async () => {\n      this.updateState({ type: \"planning\", stackName: this.stack.name });\n      const terraform = await this.terraformClient();\n\n      const { cancelled } = await terraform.deploy(\n        {\n          autoApprove: this.options.autoApprove,\n          refreshOnly,\n          parallelism: terraformParallelism,\n          vars,\n          varFiles,\n          noColor,\n        },\n        (state) => {\n          // state updates while apply runs that affect the UI\n          if (state.type === \"running\" && !state.cancelled) {\n            this.updateState({\n              type: \"deploying\",\n              stackName: this.stack.name,\n            });\n          } else if (state.type === \"waiting for approval\") {\n            this.updateState({\n              type: \"waiting for stack approval\",\n              stackName: this.stack.name,\n              approve: state.approve,\n              reject: () => {\n                state.reject();\n                this.updateState({\n                  type: \"dismissed\",\n                  stackName: this.stack.name,\n                });\n              },\n            });\n          } else if (state.type === \"waiting for sentinel override\") {\n            this.updateState({\n              type: \"waiting for stack sentinel override\",\n              stackName: this.stack.name,\n              override: state.override,\n              reject: () => {\n                state.reject();\n                this.updateState({\n                  type: \"dismissed\",\n                  stackName: this.stack.name,\n                });\n              },\n            });\n          } else if (state.type === \"external approval reply\") {\n            this.updateState({\n              type: \"external stack approval reply\",\n              stackName: this.stack.name,\n              approved: state.approved,\n            });\n          } else if (state.type === \"external sentinel override reply\") {\n            this.updateState({\n              type: \"external stack sentinel override reply\",\n              stackName: this.stack.name,\n              overridden: state.overridden,\n            });\n          }\n        },\n      );\n\n      if (!cancelled) {\n        const outputs = await terraform.output();\n        const outputsByConstructId = getConstructIdsForOutputs(\n          JSON.parse(this.stack.content),\n          outputs,\n        );\n\n        this.updateState({\n          type: \"deployed\",\n          stackName: this.stack.name,\n          outputs,\n          outputsByConstructId,\n        });\n      }\n    });\n  }\n\n  public async destroy(opts: {\n    terraformParallelism?: number;\n    vars?: string[];\n    varFiles?: string[];\n    noColor?: boolean;\n  }) {\n    const { terraformParallelism, noColor, vars, varFiles } = opts;\n    await this.run(async () => {\n      this.updateState({ type: \"planning\", stackName: this.stack.name });\n      const terraform = await this.terraformClient();\n      const { cancelled } = await terraform.destroy(\n        {\n          autoApprove: this.options.autoApprove,\n          parallelism: terraformParallelism,\n          vars,\n          varFiles,\n          noColor,\n        },\n        (state) => {\n          // state updates while apply runs that affect the UI\n          if (state.type === \"running\" && !state.cancelled) {\n            this.updateState({\n              type: \"destroying\",\n              stackName: this.stack.name,\n            });\n          } else if (state.type === \"waiting for approval\") {\n            this.updateState({\n              type: \"waiting for stack approval\",\n              stackName: this.stack.name,\n              approve: state.approve,\n              reject: () => {\n                state.reject();\n                this.updateState({\n                  type: \"dismissed\",\n                  stackName: this.stack.name,\n                });\n              },\n            });\n          } else if (state.type === \"waiting for sentinel override\") {\n            this.updateState({\n              type: \"waiting for stack sentinel override\",\n              stackName: this.stack.name,\n              override: state.override,\n              reject: () => {\n                state.reject();\n                this.updateState({\n                  type: \"dismissed\",\n                  stackName: this.stack.name,\n                });\n              },\n            });\n          } else if (state.type === \"external approval reply\") {\n            this.updateState({\n              type: \"external stack approval reply\",\n              stackName: this.stack.name,\n              approved: state.approved,\n            });\n          } else if (state.type === \"external sentinel override reply\") {\n            this.updateState({\n              type: \"external stack sentinel override reply\",\n              stackName: this.stack.name,\n              overridden: state.overridden,\n            });\n          }\n        },\n      );\n\n      if (!cancelled)\n        this.updateState({\n          type: \"destroyed\",\n          stackName: this.stack.name,\n        });\n    });\n  }\n\n  public async fetchOutputs() {\n    await this.run(async () => {\n      const terraform = await this.terraformClient();\n\n      const outputs = await terraform.output();\n      const outputsByConstructId = getConstructIdsForOutputs(\n        JSON.parse(this.stack.content),\n        outputs,\n      );\n      this.updateState({\n        type: \"outputs fetched\",\n        stackName: this.stack.name,\n        outputs,\n        outputsByConstructId,\n      });\n    });\n\n    return this.outputs;\n  }\n\n  public async stop() {\n    this.stopped = true;\n  }\n}\n"]}

package/src/lib/convert.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+export declare function convertConfigurationFile(configuration: string, stackWorkingDirectory: string): Promise<string>;
+//# sourceMappingURL=convert.d.ts.map

package/src/lib/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["convert.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAYH,wBAAsB,wBAAwB,CAC5C,aAAa,EAAE,MAAM,EACrB,qBAAqB,EAAE,MAAM,mBAqB9B"}

package/src/lib/convert.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertConfigurationFile = void 0;
+const hcl2cdk = __importStar(require("@cdktn/hcl2cdk"));
+const cdktf_config_1 = require("./cdktf-config");
+const provider_generator_1 = require("@cdktn/provider-generator");
+const provider_schema_1 = require("@cdktn/provider-schema");
+const commons_1 = require("@cdktn/commons");
+async function convertConfigurationFile(configuration, stackWorkingDirectory) {
+    const cfg = cdktf_config_1.CdktfConfig.read(stackWorkingDirectory);
+    const targets = cfg.terraformProviders.map((constraint) => commons_1.ConstructsMakerProviderTarget.from(new provider_generator_1.TerraformProviderConstraint(constraint), commons_1.LANGUAGES[0]));
+    const { providerSchema } = await (0, provider_schema_1.readSchema)(targets);
+    if (!providerSchema) {
+        throw commons_1.Errors.Internal("Could not fetch provider schema");
+    }
+    const { all } = await hcl2cdk.convert(configuration, {
+        providerSchema,
+        language: cfg.language,
+        codeContainer: "constructs.Construct",
+    });
+    return all;
+}
+exports.convertConfigurationFile = convertConfigurationFile;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udmVydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImNvbnZlcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7R0FHRzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCx3REFBMEM7QUFDMUMsaURBQTZDO0FBQzdDLGtFQUF3RTtBQUN4RSw0REFBb0Q7QUFDcEQsNENBSXdCO0FBRWpCLEtBQUssVUFBVSx3QkFBd0IsQ0FDNUMsYUFBcUIsRUFDckIscUJBQTZCO0lBRTdCLE1BQU0sR0FBRyxHQUFHLDBCQUFXLENBQUMsSUFBSSxDQUFDLHFCQUFxQixDQUFDLENBQUM7SUFDcEQsTUFBTSxPQUFPLEdBQUcsR0FBRyxDQUFDLGtCQUFrQixDQUFDLEdBQUcsQ0FBQyxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQ3hELHVDQUE2QixDQUFDLElBQUksQ0FDaEMsSUFBSSxnREFBMkIsQ0FBQyxVQUFVLENBQUMsRUFDM0MsbUJBQVMsQ0FBQyxDQUFDLENBQUMsQ0FDYixDQUNGLENBQUM7SUFDRixNQUFNLEVBQUUsY0FBYyxFQUFFLEdBQUcsTUFBTSxJQUFBLDRCQUFVLEVBQUMsT0FBTyxDQUFDLENBQUM7SUFDckQsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQ3BCLE1BQU0sZ0JBQU0sQ0FBQyxRQUFRLENBQUMsaUNBQWlDLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBRUQsTUFBTSxFQUFFLEdBQUcsRUFBRSxHQUFHLE1BQU0sT0FBTyxDQUFDLE9BQU8sQ0FBQyxhQUFhLEVBQUU7UUFDbkQsY0FBYztRQUNkLFFBQVEsRUFBRSxHQUFHLENBQUMsUUFBUTtRQUN0QixhQUFhLEVBQUUsc0JBQXNCO0tBQ3RDLENBQUMsQ0FBQztJQUVILE9BQU8sR0FBRyxDQUFDO0FBQ2IsQ0FBQztBQXZCRCw0REF1QkMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmMuXG4gKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTVBMLTIuMFxuICovXG5cbmltcG9ydCAqIGFzIGhjbDJjZGsgZnJvbSBcIkBjZGt0bi9oY2wyY2RrXCI7XG5pbXBvcnQgeyBDZGt0ZkNvbmZpZyB9IGZyb20gXCIuL2Nka3RmLWNvbmZpZ1wiO1xuaW1wb3J0IHsgVGVycmFmb3JtUHJvdmlkZXJDb25zdHJhaW50IH0gZnJvbSBcIkBjZGt0bi9wcm92aWRlci1nZW5lcmF0b3JcIjtcbmltcG9ydCB7IHJlYWRTY2hlbWEgfSBmcm9tIFwiQGNka3RuL3Byb3ZpZGVyLXNjaGVtYVwiO1xuaW1wb3J0IHtcbiAgRXJyb3JzLFxuICBMQU5HVUFHRVMsXG4gIENvbnN0cnVjdHNNYWtlclByb3ZpZGVyVGFyZ2V0LFxufSBmcm9tIFwiQGNka3RuL2NvbW1vbnNcIjtcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGNvbnZlcnRDb25maWd1cmF0aW9uRmlsZShcbiAgY29uZmlndXJhdGlvbjogc3RyaW5nLFxuICBzdGFja1dvcmtpbmdEaXJlY3Rvcnk6IHN0cmluZyxcbikge1xuICBjb25zdCBjZmcgPSBDZGt0ZkNvbmZpZy5yZWFkKHN0YWNrV29ya2luZ0RpcmVjdG9yeSk7XG4gIGNvbnN0IHRhcmdldHMgPSBjZmcudGVycmFmb3JtUHJvdmlkZXJzLm1hcCgoY29uc3RyYWludCkgPT5cbiAgICBDb25zdHJ1Y3RzTWFrZXJQcm92aWRlclRhcmdldC5mcm9tKFxuICAgICAgbmV3IFRlcnJhZm9ybVByb3ZpZGVyQ29uc3RyYWludChjb25zdHJhaW50KSxcbiAgICAgIExBTkdVQUdFU1swXSxcbiAgICApLFxuICApO1xuICBjb25zdCB7IHByb3ZpZGVyU2NoZW1hIH0gPSBhd2FpdCByZWFkU2NoZW1hKHRhcmdldHMpO1xuICBpZiAoIXByb3ZpZGVyU2NoZW1hKSB7XG4gICAgdGhyb3cgRXJyb3JzLkludGVybmFsKFwiQ291bGQgbm90IGZldGNoIHByb3ZpZGVyIHNjaGVtYVwiKTtcbiAgfVxuXG4gIGNvbnN0IHsgYWxsIH0gPSBhd2FpdCBoY2wyY2RrLmNvbnZlcnQoY29uZmlndXJhdGlvbiwge1xuICAgIHByb3ZpZGVyU2NoZW1hLFxuICAgIGxhbmd1YWdlOiBjZmcubGFuZ3VhZ2UsXG4gICAgY29kZUNvbnRhaW5lcjogXCJjb25zdHJ1Y3RzLkNvbnN0cnVjdFwiLFxuICB9KTtcblxuICByZXR1cm4gYWxsO1xufVxuIl19

package/src/lib/dependencies/cdktf-config-manager.d.ts

@@ -0,0 +1,12 @@
+import { ProviderConstraint } from "./dependency-manager";
+/**
+ * facilitates adding provider dependencies to cdktf.json
+ */
+export declare class CdktfConfigManager {
+    private config;
+    hasProvider(constraint: ProviderConstraint): Promise<boolean>;
+    private setProvider;
+    addProvider(constraint: ProviderConstraint): Promise<void>;
+    updateProvider(constraint: ProviderConstraint): Promise<void>;
+}
+//# sourceMappingURL=cdktf-config-manager.d.ts.map

package/src/lib/dependencies/cdktf-config-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdktf-config-manager.d.ts","sourceRoot":"","sources":["cdktf-config-manager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAmC;IAEpC,WAAW,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;YAQ5D,WAAW;IAoBZ,WAAW,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1D,cAAc,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAG3E"}

package/src/lib/dependencies/cdktf-config-manager.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdktfConfigManager = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const cdktf_config_1 = require("../cdktf-config");
+const dependency_manager_1 = require("./dependency-manager");
+/**
+ * facilitates adding provider dependencies to cdktf.json
+ */
+class CdktfConfigManager {
+    constructor() {
+        this.config = cdktf_config_1.CdktfConfig.read();
+    }
+    async hasProvider(constraint) {
+        return this.config.terraformProviders.some((provider) => dependency_manager_1.ProviderConstraint.fromConfigEntry(provider).source ===
+            constraint.source);
+    }
+    async setProvider(constraint) {
+        // excluding the constraint to be added (if it already existed)
+        const currentProviders = this.config.terraformProviders.filter((provider) => dependency_manager_1.ProviderConstraint.fromConfigEntry(provider).source !==
+            constraint.source);
+        const simplifiedSource = constraint.source.replace("registry.terraform.io/", "");
+        const provider = simplifiedSource + (constraint.version ? `@${constraint.version}` : "");
+        currentProviders.push(provider);
+        this.config.writeTerraformProviders(currentProviders);
+    }
+    async addProvider(constraint) {
+        await this.setProvider(constraint);
+    }
+    async updateProvider(constraint) {
+        await this.setProvider(constraint);
+    }
+}
+exports.CdktfConfigManager = CdktfConfigManager;
+//# sourceMappingURL=data:application/json;base64,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