@cdktn/cli-core 0.23.0-pre.36 → 0.23.0-pre.39

package/build/lib/synth-stack.js

@@ -0,0 +1,251 @@
+"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.SynthStack = exports.StackDependencies = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const chalk = __importStar(require("chalk"));
+const indent_string_1 = __importDefault(require("indent-string"));
+const cdktn_1 = require("cdktn");
+const perf_hooks_1 = require("perf_hooks");
+const commons_1 = require("@cdktn/commons");
+const cdktf_config_1 = require("./cdktf-config");
+const hcl_tools_1 = require("@cdktn/hcl-tools");
+const chalkColour = new chalk.Instance();
+class StackDependencies {
+    constructor(stacks) {
+        this.stacks = stacks;
+        this.pendingStacks = [];
+        this.inflightStacks = [];
+        this.deployedStacks = [];
+        this.pendingStacks = [...this.stacks];
+    }
+    startRun(stack) {
+        this.pendingStacks = this.pendingStacks.filter((item) => item.name !== stack.name);
+        this.inflightStacks.push(stack);
+    }
+    finishRun(stack) {
+        this.inflightStacks = this.inflightStacks.filter((item) => item.name !== stack.name);
+        this.deployedStacks.push(stack);
+    }
+    get pendingDeployableStacks() {
+        return this.pendingStacks.filter((pendingStack) => {
+            const unmetDependencies = pendingStack.dependencies.filter((dependency) => {
+                return !this.deployedStacks.some((deployedStack) => {
+                    return deployedStack.name === dependency;
+                });
+            });
+            return unmetDependencies.length === 0;
+        });
+    }
+}
+exports.StackDependencies = StackDependencies;
+class SynthStack {
+    static async synth(abortSignal, command, outdir, workingDirectory = process.cwd(), graceful = false, // will not exit the process but rethrow the error instead
+    noColor = false, synthOrigin, hcl = false) {
+        // start performance timer
+        const startTime = perf_hooks_1.performance.now();
+        const isDirectory = (source) => fs.lstatSync(source).isDirectory();
+        const getDirectories = (source) => {
+            if (!fs.existsSync(source))
+                return [];
+            return fs
+                .readdirSync(source)
+                .map((name) => path.join(source, name))
+                .filter(isDirectory);
+        };
+        const existingDirectories = getDirectories(path.join(outdir, cdktn_1.Manifest.stacksFolder));
+        const env = Object.fromEntries(Object.entries(process.env).filter(
+        // We don't want to pass Terraform variables to the synth command since they should only be used at execution time
+        ([key]) => !key.startsWith("TF_VAR_")));
+        // Increases the default memory available to Node.js when synthesizing a TypeScript CDK project.
+        const nodeOptsSwitch = "--max-old-space-size";
+        const nodeOptsSetting = `${nodeOptsSwitch}=4096`;
+        if (env.NODE_OPTIONS && !env.NODE_OPTIONS.includes(nodeOptsSwitch)) {
+            commons_1.logger.warn(`WARNING: Found NODE_OPTIONS environment variable without a setting for ${nodeOptsSwitch}
+The synthesizing step for TypeScript may need an increased amount of memory if multiple large providers
+are used with locally generated bindings. You can ignore this if you don't use CDKTN with TypeScript.
+If not present, the cdktn-cli sets it to NODE_OPTIONS="${nodeOptsSetting}" by default. But as
+your environment already contains a NODE_OPTIONS variable, we won't override it. Hence, the app command
+might fail while synthesizing with an out of memory error.`);
+        }
+        else if (!env.NODE_OPTIONS) {
+            // increase memory to allow ts-node (when using TypeScript) to handle large amounts of generated code in memory
+            env.NODE_OPTIONS = `${env.NODE_OPTIONS || ""} ${nodeOptsSetting}`.trim();
+        }
+        const currentContext = process.env[cdktn_1.CONTEXT_ENV]
+            ? JSON.parse(process.env.CDKTF_CONTEXT_JSON)
+            : {};
+        const relativeModules = getRelativeTerraformModules();
+        try {
+            await (0, commons_1.shell)(command, [], {
+                shell: true,
+                env: {
+                    ...env,
+                    CDKTF_OUTDIR: outdir,
+                    CDKTF_CONTINUE_SYNTH_ON_ERROR_ANNOTATIONS: "true", // we want to display the errors ourselves
+                    [cdktn_1.CONTEXT_ENV]: JSON.stringify({
+                        ...currentContext,
+                        cdktfRelativeModules: relativeModules,
+                    }),
+                    SYNTH_HCL_OUTPUT: hcl.toString(),
+                },
+                cwd: workingDirectory,
+                signal: abortSignal,
+                noColor: noColor,
+            });
+        }
+        catch (e) {
+            const errorOutput = chalkColour `{redBright cdktn encountered an error while synthesizing}
+
+Synth command: {blue ${command}}
+Error:         {redBright ${e.message}}
+${e.stderr
+                ? chalkColour `
+Command output on stderr:
+
+{dim ${(0, indent_string_1.default)(e.stderr, 4)}}
+`
+                : ""}
+${e.stdout
+                ? chalkColour `
+Command output on stdout:
+
+{dim ${(0, indent_string_1.default)(e.stdout, 4)}}
+`
+                : ""}`;
+            await this.synthErrorTelemetry(synthOrigin);
+            if (graceful) {
+                e.errorOutput = errorOutput;
+                throw e;
+            }
+            console.error(`ERROR: ${errorOutput}`);
+            process.exit(1);
+        }
+        // Apply formatting to HCL files if hcl output was selected
+        if (hcl) {
+            await SynthStack.formatHclFiles(outdir);
+        }
+        // end performance timer
+        const endTime = perf_hooks_1.performance.now();
+        let stacks = [];
+        try {
+            stacks = await SynthStack.readSynthesizedStacks(outdir);
+        }
+        catch (e) {
+            const errorMessage = `ERROR: synthesis failed, because app was expected to call 'synth()', but didn't. Thus "${outdir}/${cdktn_1.Manifest.fileName}"  was not created: ${e}`;
+            if (graceful) {
+                throw new Error(errorMessage);
+            }
+            commons_1.logger.error(errorMessage);
+            process.exit(1);
+        }
+        await this.synthTelemetry(endTime - startTime, stacks, synthOrigin);
+        if (stacks.length === 0) {
+            commons_1.logger.error("ERROR: No Terraform code synthesized.");
+        }
+        const stackNames = stacks.map((s) => s.name);
+        const orphanedDirectories = existingDirectories.filter((e) => !stackNames.includes(path.basename(e)));
+        for (const orphanedDirectory of orphanedDirectories) {
+            fs.rmSync(orphanedDirectory, { recursive: true });
+        }
+        return stacks;
+    }
+    static async formatHclFiles(outDir) {
+        const manifestPath = path.join(outDir, cdktn_1.Manifest.fileName);
+        if (!(await fs.pathExists(manifestPath))) {
+            throw new Error(`Could not find manifest file at ${manifestPath}. In case --skip-synth was passed, please try again without the flag.`);
+        }
+        const manifest = JSON.parse(fs.readFileSync(manifestPath).toString());
+        for (const stackName in manifest.stacks) {
+            const stack = manifest.stacks[stackName];
+            const filePath = path.join(outDir, stack.synthesizedStackPath);
+            const hclContent = fs.readFileSync(filePath).toString();
+            const formattedHcl = await (0, hcl_tools_1.format)(hclContent);
+            fs.writeFileSync(filePath, formattedHcl);
+        }
+    }
+    static async readSynthesizedStacks(outdir) {
+        const manifestPath = path.join(outdir, cdktn_1.Manifest.fileName);
+        if (!(await fs.pathExists(manifestPath))) {
+            throw new Error(`Could not find manifest file at ${manifestPath}. In case --skip-synth was passed, please try again without the flag.`);
+        }
+        const stacks = [];
+        const manifest = JSON.parse(fs.readFileSync(manifestPath).toString());
+        for (const stackName in manifest.stacks) {
+            const stack = manifest.stacks[stackName];
+            const filePath = path.join(outdir, stack.synthesizedStackPath);
+            let jsonContent = {};
+            if (filePath.endsWith(".tf.json")) {
+                jsonContent = JSON.parse(fs.readFileSync(filePath).toString());
+            }
+            else {
+                const metadataPath = path.join(outdir, stack.stackMetadataPath);
+                jsonContent = JSON.parse(fs.readFileSync(metadataPath).toString());
+            }
+            stacks.push({
+                ...stack,
+                workingDirectory: path.join(outdir, stack.workingDirectory),
+                content: JSON.stringify(jsonContent, null, 2),
+            });
+        }
+        return stacks;
+    }
+    static async synthTelemetry(totalTime, stacks, synthOrigin) {
+        const config = (0, commons_1.readConfigSync)();
+        await (0, commons_1.sendTelemetry)("synth", {
+            totalTime: totalTime,
+            language: config.language,
+            synthOrigin,
+            stackMetadata: stacks.map((stack) => JSON.parse(stack.content)["//"].metadata),
+            requiredProviders: stacks.map((stack) => JSON.parse(stack.content)["terraform"].required_providers),
+        });
+    }
+    static async synthErrorTelemetry(synthOrigin) {
+        await (0, commons_1.sendTelemetry)("synth", { error: true, synthOrigin });
+    }
+}
+exports.SynthStack = SynthStack;
+function getRelativeTerraformModules() {
+    let cfg;
+    try {
+        cfg = cdktf_config_1.CdktfConfig.read();
+    }
+    catch (e) {
+        commons_1.logger.trace("Could not read cdktf.json: " + e);
+        return [];
+    }
+    return cfg.terraformModules.filter((mod) => {
+        return typeof mod === "string"
+            ? mod.startsWith("./") || mod.startsWith("../")
+            : mod.source.startsWith("./") || mod.source.startsWith("../");
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synth-stack.js","sourceRoot":"","sources":["../../src/lib/synth-stack.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,mCAAmC;AACnC,6CAA+B;AAC/B,2CAA6B;AAC7B,6CAA+B;AAC/B,kEAAyC;AACzC,iCAKe;AACf,2CAAyC;AACzC,4CAA8E;AAC9E,iDAA6C;AAC7C,gDAA0C;AAE1C,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;AAUzC,MAAa,iBAAiB;IAK5B,YAA6B,MAA0B;QAA1B,WAAM,GAAN,MAAM,CAAoB;QAJhD,kBAAa,GAAuB,EAAE,CAAC;QACvC,mBAAc,GAAuB,EAAE,CAAC;QACxC,mBAAc,GAAuB,EAAE,CAAC;QAG7C,IAAI,CAAC,aAAa,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAEM,QAAQ,CAAC,KAAuB;QACrC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAC5C,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CACnC,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAEM,SAAS,CAAC,KAAuB;QACtC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAC9C,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CACnC,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,IAAW,uBAAuB;QAChC,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,YAAY,EAAE,EAAE;YAChD,MAAM,iBAAiB,GAAG,YAAY,CAAC,YAAY,CAAC,MAAM,CACxD,CAAC,UAAU,EAAE,EAAE;gBACb,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,EAAE;oBACjD,OAAO,aAAa,CAAC,IAAI,KAAK,UAAU,CAAC;gBAC3C,CAAC,CAAC,CAAC;YACL,CAAC,CACF,CAAC;YAEF,OAAO,iBAAiB,CAAC,MAAM,KAAK,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AApCD,8CAoCC;AASD,MAAa,UAAU;IACd,MAAM,CAAC,KAAK,CAAC,KAAK,CACvB,WAAwB,EACxB,OAAe,EACf,MAAc,EACd,gBAAgB,GAAG,OAAO,CAAC,GAAG,EAAE,EAChC,QAAQ,GAAG,KAAK,EAAE,0DAA0D;IAC5E,OAAO,GAAG,KAAK,EACf,WAAyB,EACzB,GAAG,GAAG,KAAK;QAEX,0BAA0B;QAC1B,MAAM,SAAS,GAAG,wBAAW,CAAC,GAAG,EAAE,CAAC;QAEpC,MAAM,WAAW,GAAG,CAAC,MAAc,EAAE,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,CAAC;QAC3E,MAAM,cAAc,GAAG,CAAC,MAAc,EAAE,EAAE;YACxC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC;gBAAE,OAAO,EAAE,CAAC;YACtC,OAAO,EAAE;iBACN,WAAW,CAAC,MAAM,CAAC;iBACnB,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;iBACtC,MAAM,CAAC,WAAW,CAAC,CAAC;QACzB,CAAC,CAAC;QAEF,MAAM,mBAAmB,GAAG,cAAc,CACxC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,gBAAQ,CAAC,YAAY,CAAC,CACzC,CAAC;QAEF,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,CAC5B,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM;QAChC,kHAAkH;QAClH,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CACtC,CACF,CAAC;QAEF,gGAAgG;QAChG,MAAM,cAAc,GAAG,sBAAsB,CAAC;QAC9C,MAAM,eAAe,GAAG,GAAG,cAAc,OAAO,CAAC;QACjD,IAAI,GAAG,CAAC,YAAY,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YACnE,gBAAM,CAAC,IAAI,CAAC,0EAA0E,cAAc;;;yDAGjD,eAAe;;2DAEb,CAAC,CAAC;QACzD,CAAC;aAAM,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;YAC7B,+GAA+G;YAC/G,GAAG,CAAC,YAAY,GAAG,GAAG,GAAG,CAAC,YAAY,IAAI,EAAE,IAAI,eAAe,EAAE,CAAC,IAAI,EAAE,CAAC;QAC3E,CAAC;QAED,MAAM,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAW,CAAC;YAC7C,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;YAC5C,CAAC,CAAC,EAAE,CAAC;QACP,MAAM,eAAe,GAAG,2BAA2B,EAAE,CAAC;QAEtD,IAAI,CAAC;YACH,MAAM,IAAA,eAAK,EAAC,OAAO,EAAE,EAAE,EAAE;gBACvB,KAAK,EAAE,IAAI;gBACX,GAAG,EAAE;oBACH,GAAG,GAAG;oBACN,YAAY,EAAE,MAAM;oBACpB,yCAAyC,EAAE,MAAM,EAAE,0CAA0C;oBAC7F,CAAC,mBAAW,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC;wBAC5B,GAAG,cAAc;wBACjB,oBAAoB,EAAE,eAAe;qBACtC,CAAC;oBACF,gBAAgB,EAAE,GAAG,CAAC,QAAQ,EAAE;iBACjC;gBACD,GAAG,EAAE,gBAAgB;gBACrB,MAAM,EAAE,WAAW;gBACnB,OAAO,EAAE,OAAO;aACjB,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,WAAW,GAAG,WAAW,CAAA;;uBAEd,OAAO;4BACF,CAAC,CAAC,OAAO;EAEnC,CAAC,CAAC,MAAM;gBACN,CAAC,CAAC,WAAW,CAAA;;;OAGV,IAAA,uBAAY,EAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;CAC/B;gBACG,CAAC,CAAC,EACN;EAEE,CAAC,CAAC,MAAM;gBACN,CAAC,CAAC,WAAW,CAAA;;;OAGV,IAAA,uBAAY,EAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;CAC/B;gBACG,CAAC,CAAC,EACN,EAAE,CAAC;YACG,MAAM,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;YAC5C,IAAI,QAAQ,EAAE,CAAC;gBACb,CAAC,CAAC,WAAW,GAAG,WAAW,CAAC;gBAC5B,MAAM,CAAC,CAAC;YACV,CAAC;YACD,OAAO,CAAC,KAAK,CAAC,UAAU,WAAW,EAAE,CAAC,CAAC;YACvC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;QAED,2DAA2D;QAC3D,IAAI,GAAG,EAAE,CAAC;YACR,MAAM,UAAU,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAC1C,CAAC;QAED,wBAAwB;QACxB,MAAM,OAAO,GAAG,wBAAW,CAAC,GAAG,EAAE,CAAC;QAElC,IAAI,MAAM,GAAuB,EAAE,CAAC;QACpC,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,UAAU,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QAC1D,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,YAAY,GAAG,0FAA0F,MAAM,IAAI,gBAAQ,CAAC,QAAQ,uBAAuB,CAAC,EAAE,CAAC;YACrK,IAAI,QAAQ,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC;YAChC,CAAC;YACD,gBAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC3B,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC;QAED,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,GAAG,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;QAEpE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,gBAAM,CAAC,KAAK,CAAC,uCAAuC,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC7C,MAAM,mBAAmB,GAAG,mBAAmB,CAAC,MAAM,CACpD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAC9C,CAAC;QAEF,KAAK,MAAM,iBAAiB,IAAI,mBAAmB,EAAE,CAAC;YACpD,EAAE,CAAC,MAAM,CAAC,iBAAiB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACpD,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,MAAc;QAC/C,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,gBAAQ,CAAC,QAAQ,CAAC,CAAC;QAC1D,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CACb,mCAAmC,YAAY,uEAAuE,CACvH,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CACzB,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE,CACzB,CAAC;QAElB,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;YACxC,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC;YAE/D,MAAM,UAAU,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC;YACxD,MAAM,YAAY,GAAG,MAAM,IAAA,kBAAM,EAAC,UAAU,CAAC,CAAC;YAC9C,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,qBAAqB,CACvC,MAAc;QAEd,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,gBAAQ,CAAC,QAAQ,CAAC,CAAC;QAC1D,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CACb,mCAAmC,YAAY,uEAAuE,CACvH,CAAC;QACJ,CAAC;QAED,MAAM,MAAM,GAAuB,EAAE,CAAC;QACtC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CACzB,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE,CACzB,CAAC;QAElB,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;YACxC,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC;YAC/D,IAAI,WAAW,GAA6B,EAAE,CAAC;YAC/C,IAAI,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBAClC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;YACjE,CAAC;iBAAM,CAAC;gBACN,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAkB,CAAC,CAAC;gBACjE,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;YACrE,CAAC;YAED,MAAM,CAAC,IAAI,CAAC;gBACV,GAAG,KAAK;gBACR,gBAAgB,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,gBAAgB,CAAC;gBAC3D,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;aAC9C,CAAC,CAAC;QACL,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,cAAc,CAChC,SAAiB,EACjB,MAA0B,EAC1B,WAAyB;QAEzB,MAAM,MAAM,GAAG,IAAA,wBAAc,GAAE,CAAC;QAEhC,MAAM,IAAA,uBAAa,EAAC,OAAO,EAAE;YAC3B,SAAS,EAAE,SAAS;YACpB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,WAAW;YACX,aAAa,EAAE,MAAM,CAAC,GAAG,CACvB,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,CACpD;YACD,iBAAiB,EAAE,MAAM,CAAC,GAAG,CAC3B,CAAC,KAAU,EAAE,EAAE,CACb,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,CAAC,kBAAkB,CAC5D;SACF,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,WAAyB;QAC/D,MAAM,IAAA,uBAAa,EAAC,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;IAC7D,CAAC;CACF;AA/ND,gCA+NC;AAED,SAAS,2BAA2B;IAClC,IAAI,GAAG,CAAC;IAER,IAAI,CAAC;QACH,GAAG,GAAG,0BAAW,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,gBAAM,CAAC,KAAK,CAAC,6BAA6B,GAAG,CAAC,CAAC,CAAC;QAChD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE;QACzC,OAAO,OAAO,GAAG,KAAK,QAAQ;YAC5B,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC;YAC/C,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs-extra\";\nimport * as path from \"path\";\nimport * as chalk from \"chalk\";\nimport indentString from \"indent-string\";\nimport {\n  CONTEXT_ENV,\n  Manifest,\n  StackManifest,\n  TerraformStackMetadata,\n} from \"cdktn\";\nimport { performance } from \"perf_hooks\";\nimport { logger, readConfigSync, sendTelemetry, shell } from \"@cdktn/commons\";\nimport { CdktfConfig } from \"./cdktf-config\";\nimport { format } from \"@cdktn/hcl-tools\";\n\nconst chalkColour = new chalk.Instance();\n\nexport interface SynthesizedStackMetadata {\n  \"//\"?: { [key: string]: TerraformStackMetadata };\n}\n\nexport interface SynthesizedStack extends StackManifest {\n  content: string;\n}\n\nexport class StackDependencies {\n  public pendingStacks: SynthesizedStack[] = [];\n  public inflightStacks: SynthesizedStack[] = [];\n  public deployedStacks: SynthesizedStack[] = [];\n\n  constructor(private readonly stacks: SynthesizedStack[]) {\n    this.pendingStacks = [...this.stacks];\n  }\n\n  public startRun(stack: SynthesizedStack): void {\n    this.pendingStacks = this.pendingStacks.filter(\n      (item) => item.name !== stack.name,\n    );\n    this.inflightStacks.push(stack);\n  }\n\n  public finishRun(stack: SynthesizedStack): void {\n    this.inflightStacks = this.inflightStacks.filter(\n      (item) => item.name !== stack.name,\n    );\n    this.deployedStacks.push(stack);\n  }\n\n  public get pendingDeployableStacks(): SynthesizedStack[] {\n    return this.pendingStacks.filter((pendingStack) => {\n      const unmetDependencies = pendingStack.dependencies.filter(\n        (dependency) => {\n          return !this.deployedStacks.some((deployedStack) => {\n            return deployedStack.name === dependency;\n          });\n        },\n      );\n\n      return unmetDependencies.length === 0;\n    });\n  }\n}\n\ninterface ManifestJson {\n  version: string;\n  stacks: StackManifest[];\n}\n\nexport type SynthOrigin = \"watch\";\n\nexport class SynthStack {\n  public static async synth(\n    abortSignal: AbortSignal,\n    command: string,\n    outdir: string,\n    workingDirectory = process.cwd(),\n    graceful = false, // will not exit the process but rethrow the error instead\n    noColor = false,\n    synthOrigin?: SynthOrigin,\n    hcl = false,\n  ): Promise<SynthesizedStack[]> {\n    // start performance timer\n    const startTime = performance.now();\n\n    const isDirectory = (source: string) => fs.lstatSync(source).isDirectory();\n    const getDirectories = (source: string) => {\n      if (!fs.existsSync(source)) return [];\n      return fs\n        .readdirSync(source)\n        .map((name) => path.join(source, name))\n        .filter(isDirectory);\n    };\n\n    const existingDirectories = getDirectories(\n      path.join(outdir, Manifest.stacksFolder),\n    );\n\n    const env = Object.fromEntries(\n      Object.entries(process.env).filter(\n        // We don't want to pass Terraform variables to the synth command since they should only be used at execution time\n        ([key]) => !key.startsWith(\"TF_VAR_\"),\n      ),\n    );\n\n    // Increases the default memory available to Node.js when synthesizing a TypeScript CDK project.\n    const nodeOptsSwitch = \"--max-old-space-size\";\n    const nodeOptsSetting = `${nodeOptsSwitch}=4096`;\n    if (env.NODE_OPTIONS && !env.NODE_OPTIONS.includes(nodeOptsSwitch)) {\n      logger.warn(`WARNING: Found NODE_OPTIONS environment variable without a setting for ${nodeOptsSwitch}\nThe synthesizing step for TypeScript may need an increased amount of memory if multiple large providers\nare used with locally generated bindings. You can ignore this if you don't use CDKTN with TypeScript.\nIf not present, the cdktn-cli sets it to NODE_OPTIONS=\"${nodeOptsSetting}\" by default. But as\nyour environment already contains a NODE_OPTIONS variable, we won't override it. Hence, the app command\nmight fail while synthesizing with an out of memory error.`);\n    } else if (!env.NODE_OPTIONS) {\n      // increase memory to allow ts-node (when using TypeScript) to handle large amounts of generated code in memory\n      env.NODE_OPTIONS = `${env.NODE_OPTIONS || \"\"} ${nodeOptsSetting}`.trim();\n    }\n\n    const currentContext = process.env[CONTEXT_ENV]\n      ? JSON.parse(process.env.CDKTF_CONTEXT_JSON)\n      : {};\n    const relativeModules = getRelativeTerraformModules();\n\n    try {\n      await shell(command, [], {\n        shell: true,\n        env: {\n          ...env,\n          CDKTF_OUTDIR: outdir,\n          CDKTF_CONTINUE_SYNTH_ON_ERROR_ANNOTATIONS: \"true\", // we want to display the errors ourselves\n          [CONTEXT_ENV]: JSON.stringify({\n            ...currentContext,\n            cdktfRelativeModules: relativeModules,\n          }),\n          SYNTH_HCL_OUTPUT: hcl.toString(),\n        },\n        cwd: workingDirectory,\n        signal: abortSignal,\n        noColor: noColor,\n      });\n    } catch (e: any) {\n      const errorOutput = chalkColour`{redBright cdktn encountered an error while synthesizing}\n\nSynth command: {blue ${command}}\nError:         {redBright ${e.message}}\n${\n  e.stderr\n    ? chalkColour`\nCommand output on stderr:\n\n{dim ${indentString(e.stderr, 4)}}\n`\n    : \"\"\n}\n${\n  e.stdout\n    ? chalkColour`\nCommand output on stdout:\n\n{dim ${indentString(e.stdout, 4)}}\n`\n    : \"\"\n}`;\n      await this.synthErrorTelemetry(synthOrigin);\n      if (graceful) {\n        e.errorOutput = errorOutput;\n        throw e;\n      }\n      console.error(`ERROR: ${errorOutput}`);\n      process.exit(1);\n    }\n\n    // Apply formatting to HCL files if hcl output was selected\n    if (hcl) {\n      await SynthStack.formatHclFiles(outdir);\n    }\n\n    // end performance timer\n    const endTime = performance.now();\n\n    let stacks: SynthesizedStack[] = [];\n    try {\n      stacks = await SynthStack.readSynthesizedStacks(outdir);\n    } catch (e: any) {\n      const errorMessage = `ERROR: synthesis failed, because app was expected to call 'synth()', but didn't. Thus \"${outdir}/${Manifest.fileName}\"  was not created: ${e}`;\n      if (graceful) {\n        throw new Error(errorMessage);\n      }\n      logger.error(errorMessage);\n      process.exit(1);\n    }\n\n    await this.synthTelemetry(endTime - startTime, stacks, synthOrigin);\n\n    if (stacks.length === 0) {\n      logger.error(\"ERROR: No Terraform code synthesized.\");\n    }\n\n    const stackNames = stacks.map((s) => s.name);\n    const orphanedDirectories = existingDirectories.filter(\n      (e) => !stackNames.includes(path.basename(e)),\n    );\n\n    for (const orphanedDirectory of orphanedDirectories) {\n      fs.rmSync(orphanedDirectory, { recursive: true });\n    }\n\n    return stacks;\n  }\n\n  public static async formatHclFiles(outDir: string) {\n    const manifestPath = path.join(outDir, Manifest.fileName);\n    if (!(await fs.pathExists(manifestPath))) {\n      throw new Error(\n        `Could not find manifest file at ${manifestPath}. In case --skip-synth was passed, please try again without the flag.`,\n      );\n    }\n\n    const manifest = JSON.parse(\n      fs.readFileSync(manifestPath).toString(),\n    ) as ManifestJson;\n\n    for (const stackName in manifest.stacks) {\n      const stack = manifest.stacks[stackName];\n      const filePath = path.join(outDir, stack.synthesizedStackPath);\n\n      const hclContent = fs.readFileSync(filePath).toString();\n      const formattedHcl = await format(hclContent);\n      fs.writeFileSync(filePath, formattedHcl);\n    }\n  }\n\n  public static async readSynthesizedStacks(\n    outdir: string,\n  ): Promise<SynthesizedStack[]> {\n    const manifestPath = path.join(outdir, Manifest.fileName);\n    if (!(await fs.pathExists(manifestPath))) {\n      throw new Error(\n        `Could not find manifest file at ${manifestPath}. In case --skip-synth was passed, please try again without the flag.`,\n      );\n    }\n\n    const stacks: SynthesizedStack[] = [];\n    const manifest = JSON.parse(\n      fs.readFileSync(manifestPath).toString(),\n    ) as ManifestJson;\n\n    for (const stackName in manifest.stacks) {\n      const stack = manifest.stacks[stackName];\n      const filePath = path.join(outdir, stack.synthesizedStackPath);\n      let jsonContent: SynthesizedStackMetadata = {};\n      if (filePath.endsWith(\".tf.json\")) {\n        jsonContent = JSON.parse(fs.readFileSync(filePath).toString());\n      } else {\n        const metadataPath = path.join(outdir, stack.stackMetadataPath!);\n        jsonContent = JSON.parse(fs.readFileSync(metadataPath).toString());\n      }\n\n      stacks.push({\n        ...stack,\n        workingDirectory: path.join(outdir, stack.workingDirectory),\n        content: JSON.stringify(jsonContent, null, 2),\n      });\n    }\n\n    return stacks;\n  }\n\n  public static async synthTelemetry(\n    totalTime: number,\n    stacks: SynthesizedStack[],\n    synthOrigin?: SynthOrigin,\n  ): Promise<void> {\n    const config = readConfigSync();\n\n    await sendTelemetry(\"synth\", {\n      totalTime: totalTime,\n      language: config.language,\n      synthOrigin,\n      stackMetadata: stacks.map(\n        (stack) => JSON.parse(stack.content)[\"//\"].metadata,\n      ),\n      requiredProviders: stacks.map(\n        (stack: any) =>\n          JSON.parse(stack.content)[\"terraform\"].required_providers,\n      ),\n    });\n  }\n\n  public static async synthErrorTelemetry(synthOrigin?: SynthOrigin) {\n    await sendTelemetry(\"synth\", { error: true, synthOrigin });\n  }\n}\n\nfunction getRelativeTerraformModules() {\n  let cfg;\n\n  try {\n    cfg = CdktfConfig.read();\n  } catch (e) {\n    logger.trace(\"Could not read cdktf.json: \" + e);\n    return [];\n  }\n\n  return cfg.terraformModules.filter((mod) => {\n    return typeof mod === \"string\"\n      ? mod.startsWith(\"./\") || mod.startsWith(\"../\")\n      : mod.source.startsWith(\"./\") || mod.source.startsWith(\"../\");\n  });\n}\n"]}

package/build/lib/synth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synth.d.ts","sourceRoot":"","sources":["../../src/lib/synth.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAMjD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,QA0C1D"}

package/build/lib/synth.js

@@ -0,0 +1,67 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printAnnotations = void 0;
+const cdktn_1 = require("cdktn");
+const chalk = __importStar(require("chalk"));
+const chalkColour = new chalk.Instance();
+/**
+ * prints annotations via console
+ * @throws Error if an Annotation with level === ERROR has been encountered
+ */
+function printAnnotations(stacks) {
+    let encounteredAnnotationError = false;
+    stacks.forEach((stack) => (stack.annotations || []).forEach((annotation) => {
+        if (annotation.level === cdktn_1.AnnotationMetadataEntryType.ERROR)
+            encounteredAnnotationError = true;
+        let color = chalkColour.whiteBright;
+        let level = annotation.level;
+        switch (annotation.level) {
+            case cdktn_1.AnnotationMetadataEntryType.INFO: {
+                level = "INFO";
+                break;
+            }
+            case cdktn_1.AnnotationMetadataEntryType.WARN: {
+                color = chalkColour.hex("#FFA500"); // orange
+                level = "WARN";
+                break;
+            }
+            case cdktn_1.AnnotationMetadataEntryType.ERROR: {
+                color = chalkColour.redBright;
+                level = "ERROR";
+                break;
+            }
+        }
+        console.log(color(`${level} [${annotation.constructPath}]: ${annotation.message}`));
+        if (annotation.level === cdktn_1.AnnotationMetadataEntryType.ERROR &&
+            annotation.stacktrace)
+            console.log(chalkColour.gray(annotation.stacktrace.join("\n")));
+    }));
+    if (encounteredAnnotationError) {
+        throw new Error("While synthesizing one or more error annotations have been encountered. Please check the log output above.");
+    }
+}
+exports.printAnnotations = printAnnotations;
+//# sourceMappingURL=data:application/json;base64,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

package/{src → build}/lib/terraform-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terraform-json.d.ts","sourceRoot":"","sources":["terraform-json.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUI,CAAC;AAEjB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA0ClB,CAAC;AAEf,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACjE,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC"}
+{"version":3,"file":"terraform-json.d.ts","sourceRoot":"","sources":["../../src/lib/terraform-json.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUI,CAAC;AAEjB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA0ClB,CAAC;AAEf,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACjE,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC"}

package/build/lib/terraform-json.js

@@ -0,0 +1,82 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terraformJsonSchema = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const z = __importStar(require("zod"));
+const remote = z
+    .object({
+    organization: z.string(),
+    hostname: z.string().optional(),
+    token: z.string().optional(),
+    workspaces: z.object({
+        name: z.string().optional(),
+        prefix: z.string().optional(),
+    }),
+})
+    .deepPartial();
+exports.terraformJsonSchema = z
+    .object({
+    "//": z
+        .object({
+        metadata: z
+            .object({
+            version: z.string(),
+            stackName: z.string(),
+            backend: z.string(),
+        })
+            .nonstrict(),
+        outputs: z.record(z.any()),
+    })
+        .nonstrict(),
+    terraform: z.object({
+        backend: z
+            .object({
+            // All other backends are here as well, but we don't read them right now
+            remote,
+        })
+            .nonstrict(),
+        cloud: z
+            .object({
+            organization: z.string(),
+            hostname: z.string().optional(),
+            token: z.string().optional(),
+            workspaces: z.union([
+                z.object({ name: z.string() }),
+                z.object({ tags: z.array(z.string()) }),
+            ]),
+        })
+            .nonstrict(),
+        required_providers: z.record(z.object({ source: z.string(), version: z.string() }).nonstrict()),
+        required_version: z.string(),
+    }),
+    data: z.record(z.any()),
+    provider: z.record(z.any()),
+    resource: z.record(z.any()),
+})
+    .deepPartial()
+    .nonstrict();
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/terraform-provider-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terraform-provider-lock.d.ts","sourceRoot":"","sources":["../../src/lib/terraform-provider-lock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAKvE,KAAK,8BAA8B,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAQF,qBAAa,qBAAqB;IAEpB,OAAO,CAAC,qBAAqB;IADzC,OAAO,CAAC,iBAAiB,CAAuC;gBAC5C,qBAAqB,EAAE,MAAM;IAIjD,OAAO,KAAK,YAAY,GAEvB;IAEY,mBAAmB;YASlB,oBAAoB;IAYlC,OAAO,CAAC,qBAAqB;IAyChB,SAAS,CAAC,WAAW,UAAQ;;;IAS7B,mBAAmB,CAAC,UAAU,EAAE,kBAAkB;CAWhE"}

package/build/lib/terraform-provider-lock.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformProviderLock = void 0;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const dependency_manager_1 = require("./dependencies/dependency-manager");
+const commons_1 = require("@cdktn/commons");
+const TerraformLockFileName = ".terraform.lock.hcl";
+class TerraformProviderLock {
+    constructor(stackWorkingDirectory) {
+        this.stackWorkingDirectory = stackWorkingDirectory;
+        this._providerLockData = null;
+    }
+    get lockFilePath() {
+        return path_1.default.join(this.stackWorkingDirectory, TerraformLockFileName);
+    }
+    async hasProviderLockFile() {
+        try {
+            await promises_1.default.stat(this.lockFilePath);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async readProviderLockFile() {
+        try {
+            const lockFile = (await promises_1.default.readFile(this.lockFilePath)).toString();
+            return lockFile;
+        }
+        catch (e) {
+            commons_1.logger.debug("Unable to read provider lock file", e);
+        }
+        return "";
+    }
+    parseProviderLockFile(contents) {
+        const providerLockData = {
+            providers: {},
+        };
+        let currentProvider;
+        contents.split(/\r\n|\r|\n/).forEach((line) => {
+            if (currentProvider) {
+                const constraintMatch = line.match(/^\s*constraints\s+=\s+"(.*)"/);
+                if (constraintMatch) {
+                    providerLockData.providers[currentProvider].constraints =
+                        new dependency_manager_1.ProviderConstraint(currentProvider, constraintMatch[1]);
+                    return;
+                }
+                const versionMatch = line.match(/^\s*version\s+=\s+"(.*)"/);
+                if (versionMatch) {
+                    providerLockData.providers[currentProvider].version = versionMatch[1];
+                    return;
+                }
+                const endMatch = line.match(/^\s*}/);
+                if (endMatch) {
+                    currentProvider = undefined;
+                }
+                return;
+            }
+            const providerMatch = line.match(/provider "(.*)"/);
+            if (providerMatch) {
+                currentProvider = providerMatch[1];
+                providerLockData.providers[currentProvider] = {
+                    name: new dependency_manager_1.ProviderConstraint(currentProvider, ">=0").simplifiedName,
+                };
+            }
+        });
+        return providerLockData;
+    }
+    async providers(forceReread = false) {
+        if (!this._providerLockData || forceReread) {
+            const contents = await this.readProviderLockFile();
+            this._providerLockData = this.parseProviderLockFile(contents);
+        }
+        return this._providerLockData.providers;
+    }
+    async hasMatchingProvider(constraint) {
+        var _a, _b;
+        const providerLockData = await this.providers();
+        const lockedProvider = providerLockData[constraint.source];
+        if (lockedProvider) {
+            return (_a = lockedProvider.constraints) === null || _a === void 0 ? void 0 : _a.matchesVersion((_b = constraint.version) !== null && _b !== void 0 ? _b : ">0");
+        }
+        return false;
+    }
+}
+exports.TerraformProviderLock = TerraformProviderLock;
+//# sourceMappingURL=data:application/json;base64,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

package/{src → build}/lib/watch.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { CdktfProjectOptions, MutationOptions } from "./cdktf-project";
 import { CdktfStack } from "./cdktf-stack";
 export type State = {

package/build/lib/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/lib/watch.ts"],"names":[],"mappings":";AAGA,OAAO,EAEL,mBAAmB,EACnB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AA0E3C,MAAM,MAAM,KAAK,GACb;IACE,IAAI,EAAE,SAAS,CAAC;CACjB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB,GACD;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAExB,wBAAsB,KAAK,CACzB,cAAc,EAAE,mBAAmB,EACnC,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,CAAC,QAAQ,EAAE,KAAK,KAAK,IAAI,iBAiFzC"}