@cdktn/cli-core 0.23.0-pre.4 → 0.23.0-pre.40

package/build/lib/errors.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.missingVariable = void 0;
+const missingVariable = (variableName) => `Missing variable: '${variableName}'. You can provide it using the 'TF_VAR_${variableName}' environment variable.`;
+exports.missingVariable = missingVariable;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2xpYi9lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7R0FHRzs7O0FBRUksTUFBTSxlQUFlLEdBQUcsQ0FBQyxZQUFvQixFQUFFLEVBQUUsQ0FDdEQsc0JBQXNCLFlBQVksMkNBQTJDLFlBQVkseUJBQXlCLENBQUM7QUFEeEcsUUFBQSxlQUFlLG1CQUN5RiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IChjKSBIYXNoaUNvcnAsIEluYy5cbiAqIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNUEwtMi4wXG4gKi9cblxuZXhwb3J0IGNvbnN0IG1pc3NpbmdWYXJpYWJsZSA9ICh2YXJpYWJsZU5hbWU6IHN0cmluZykgPT5cbiAgYE1pc3NpbmcgdmFyaWFibGU6ICcke3ZhcmlhYmxlTmFtZX0nLiBZb3UgY2FuIHByb3ZpZGUgaXQgdXNpbmcgdGhlICdURl9WQVJfJHt2YXJpYWJsZU5hbWV9JyBlbnZpcm9ubWVudCB2YXJpYWJsZS5gO1xuIl19

package/build/lib/execution-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-logs.d.ts","sourceRoot":"","sources":["../../src/lib/execution-logs.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AA2BjD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,gBAAgB,GACtB,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CA6CzC"}

package/build/lib/execution-logs.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnhanceLogMessage = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const commons_1 = require("@cdktn/commons");
+// escapes any special charaters used in regex
+const escapeRegexSpecialChars = (str) => str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+// uses word boundary to match the whole of the tfIdentifer
+const lineHasExactMatch = (line, tfIdentifier) => new RegExp(`\\b${escapeRegexSpecialChars(tfIdentifier)}\\b`).test(line);
+function createEnhanceLogMessage(stack) {
+    // we never want to throw, if it does not work we just do as if it did not happen
+    const pathMapping = {};
+    try {
+        const json = JSON.parse(stack.content);
+        ["data", "resource"].forEach((type) => {
+            Object.entries(json[type] || {}).forEach(([resourceType, resourceInstances]) => {
+                Object.entries(resourceInstances || {}).forEach(([resourceName, resource]) => {
+                    // Some constructs don't have this metadata
+                    if (resource["//"] &&
+                        resource["//"].metadata &&
+                        resource["//"].metadata.path) {
+                        pathMapping[`${resourceType}.${resourceName}`] = resource["//"].metadata.path.replace(`${stack.name}/`, "");
+                    }
+                });
+            });
+        });
+    }
+    catch (e) {
+        commons_1.logger.debug(`Could not enhance log message: ${e}`);
+    }
+    return (message) => {
+        return message
+            .split("\n")
+            .map((line) => {
+            const matchingEntry = Object.entries(pathMapping).find(([tfIdentifier]) => lineHasExactMatch(line, tfIdentifier));
+            if (!matchingEntry) {
+                return line;
+            }
+            const [id, cdkPath] = matchingEntry;
+            return line.replace(id, `${id} (${cdkPath})`);
+        })
+            .join("\n");
+    };
+}
+exports.createEnhanceLogMessage = createEnhanceLogMessage;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../src/lib/get.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAEL,yBAAyB,EACzB,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,gBAAgB,CAAC;AAMxB,oBAAY,SAAS;IACnB,QAAQ,aAAa;IACrB,WAAW,qDAAqD;IAChE,IAAI,SAAS;IACb,KAAK,UAAU;CAChB;AAED,KAAK,0BAA0B,GAC3B,yBAAyB,GACzB,2BAA2B,GAC3B,6BAA6B,CAAC;AAElC,UAAU,SAAS;IAEjB,WAAW,EAAE,0BAA0B,EAAE,CAAC;IAE1C,qBAAqB,CAAC,EAAE,0BAA0B,EAAE,CAAC;IACrD,iBAAiB,EAAE,UAAU,CAAC;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,SAAS,KAAK,IAAI,CAAC;IACxC,eAAe,CAAC,EAAE,CAAC,SAAS,EAAE;QAC5B,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KACtC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrB;AAED,wBAAsB,GAAG,CAAC,EACxB,iBAAiB,EACjB,WAAW,EACX,qBAAqB,EACrB,cAAc,EACd,uBAAuB,EACvB,QAA0B,EAC1B,eAAuC,GACxC,EAAE,SAAS,iBAsCX;AAED,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,UAAO,iBAiB1D"}

package/build/lib/get.js

@@ -0,0 +1,90 @@
+"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.runGetInDir = exports.get = exports.GetStatus = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const provider_generator_1 = require("@cdktn/provider-generator");
+const commons_1 = require("@cdktn/commons");
+const fs = __importStar(require("fs-extra"));
+const commons_2 = require("@cdktn/commons");
+const path = __importStar(require("path"));
+const cdktf_config_1 = require("./cdktf-config");
+var GetStatus;
+(function (GetStatus) {
+    GetStatus["STARTING"] = "starting";
+    GetStatus["DOWNLOADING"] = "downloading and generating modules and providers";
+    GetStatus["DONE"] = "done";
+    GetStatus["ERROR"] = "error";
+})(GetStatus || (exports.GetStatus = GetStatus = {}));
+async function get({ constructsOptions, constraints, constraintsToGenerate, cleanDirectory, providerSchemaCachePath, onUpdate = () => undefined, reportTelemetry = async () => undefined, }) {
+    commons_2.logger.debug(`Starting get with outdir ${constructsOptions.codeMakerOutput}`);
+    const constructsMaker = new provider_generator_1.ConstructsMaker(constructsOptions, providerSchemaCachePath, reportTelemetry);
+    if (cleanDirectory) {
+        await fs.remove(constructsOptions.codeMakerOutput);
+    }
+    else {
+        // Remove all providers that are not in the new list
+        await constructsMaker.removeFoldersThatShouldNotExist(constraints);
+        if (constructsOptions.targetLanguage === commons_1.Language.TYPESCRIPT) {
+            // Remove all modules
+            await fs.remove(path.resolve(constructsOptions.codeMakerOutput, "modules"));
+        }
+    }
+    // Filter constraints to generate
+    const toGenerate = constraintsToGenerate ||
+        (await constructsMaker.filterAlreadyGenerated(constraints));
+    onUpdate(GetStatus.DOWNLOADING);
+    commons_2.logger.debug("Generating provider bindings");
+    await constructsMaker.generate(constraints, toGenerate);
+    commons_2.logger.debug("Provider bindings generated");
+    if (!(await fs.pathExists(constructsOptions.codeMakerOutput))) {
+        onUpdate(GetStatus.ERROR);
+        commons_2.logger.debug("Failed to generate provider bindings");
+    }
+    else {
+        onUpdate(GetStatus.DONE);
+        commons_2.logger.debug("Provider bindings generated");
+    }
+}
+exports.get = get;
+async function runGetInDir(dir, clean = true) {
+    const config = cdktf_config_1.CdktfConfig.read(dir);
+    const constraints = [
+        ...config.terraformProviders.map((c) => new commons_1.TerraformProviderConstraint(c)),
+        ...config.terraformModules.map((c) => new commons_1.TerraformModuleConstraint(c)),
+    ];
+    await get({
+        constraints,
+        constructsOptions: {
+            codeMakerOutput: path.resolve(dir, config.codeMakerOutput),
+            targetLanguage: config.language,
+            jsiiParallelism: 1,
+        },
+        cleanDirectory: clean,
+    });
+}
+exports.runGetInDir = runGetInDir;
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/helpers/stack-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/helpers/stack-helpers.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,wBAAgB,cAAc,CAC5B,MAAM,EAAE,gBAAgB,EAAE,EAC1B,SAAS,CAAC,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,MAAM,oBA4BtB;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,gBAAgB,EAAE,EAC1B,QAAQ,CAAC,EAAE,MAAM,EAAE,EACnB,YAAY,CAAC,EAAE,MAAM,sBA0BtB;AAMD,wBAAsB,+BAA+B,CACnD,cAAc,EAAE,UAAU,EAAE,GAC3B,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAyCjC;AAWD,wBAAgB,4BAA4B,CAC1C,cAAc,EAAE,UAAU,EAAE,EAC5B,SAAS,EAAE,MAAM,EACjB,wBAAwB,GAAE,GAAG,CAAC,MAAM,CAAa,GAChD,UAAU,EAAE,CAkBd;AAGD,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,UAAU,EAAE,GAC3B,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAmCjC;AAGD,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,gBAAgB,EAAE,EAC/B,SAAS,EAAE,gBAAgB,EAAE,QAsB9B;AAED;;;;;EAKE;AACF,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,gBAAgB,EAAE,QAoBhC"}

package/build/lib/helpers/stack-helpers.js

@@ -0,0 +1,155 @@
+"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.checkIfAllDependenciesAreIncluded = exports.checkIfAllDependantsAreIncluded = exports.getStackWithNoUnmetDependants = exports.findAllNestedDependantStacks = exports.getStackWithNoUnmetDependencies = exports.getMultipleStacks = exports.getSingleStack = void 0;
+const commons_1 = require("@cdktn/commons");
+const minimatch_1 = __importDefault(require("minimatch"));
+function getSingleStack(stacks, stackName, targetAction) {
+    if (!stacks) {
+        throw commons_1.Errors.Internal("Trying to access a stack before it has been synthesized");
+    }
+    if (stackName) {
+        const stack = stacks.find((s) => s.name === stackName);
+        if (!stack) {
+            throw commons_1.Errors.Usage("Could not find stack: " + stackName);
+        }
+        return stack;
+    }
+    if (stacks.length === 1) {
+        return stacks[0];
+    }
+    throw commons_1.Errors.Usage(`Found more than one stack, please specify a target stack. Run cdktn ${targetAction || "<verb>"} <stack> with one of these stacks: ${stacks
+        .map((s) => s.name)
+        .join(", ")} `);
+}
+exports.getSingleStack = getSingleStack;
+function getMultipleStacks(stacks, patterns, targetAction) {
+    if (!patterns || !patterns.length) {
+        if (stacks.length === 1) {
+            return [stacks[0]];
+        }
+        throw commons_1.Errors.Usage(`Found more than one stack, please specify a target stack. Run cdktn ${targetAction || "<verb>"} <stack> with one of these stacks: ${stacks
+            .map((s) => s.name)
+            .join(", ")} `);
+    }
+    return patterns.flatMap((pattern) => {
+        const matchingStacks = stacks.filter((stack) => (0, minimatch_1.default)(stack.name, pattern));
+        if (matchingStacks.length === 0) {
+            throw commons_1.Errors.Usage(`Could not find stack for pattern '${pattern}'`);
+        }
+        return matchingStacks;
+    });
+}
+exports.getMultipleStacks = getMultipleStacks;
+// Returns the first stack that has no unmet dependencies
+// An unmet dependency is a dependency that has not been deployed yet
+// If there is no unfinished stack, returns undefined
+// If there is no stack ready to be worked on, it returns a promise that will resolve as soon as there is a follow-up stack available
+async function getStackWithNoUnmetDependencies(stackExecutors) {
+    commons_1.logger.debug("Checking for stacks with unmet dependencies");
+    commons_1.logger.debug("stack executors:", stackExecutors);
+    const pendingStacks = stackExecutors.filter((executor) => executor.isPending);
+    commons_1.logger.debug("pending stacks:", stackExecutors);
+    if (pendingStacks.length === 0) {
+        return undefined;
+    }
+    const currentlyReadyStack = pendingStacks.find((executor) => executor.stack.dependencies.every((dependency) => {
+        var _a;
+        return ((_a = stackExecutors.find((executor) => executor.stack.name === dependency)) === null || _a === void 0 ? void 0 : _a.currentState) === "done";
+    }));
+    if (currentlyReadyStack) {
+        commons_1.logger.debug("Found a stack with no unmet dependencies");
+        return currentlyReadyStack;
+    }
+    const stackExecutionPromises = stackExecutors
+        .filter((ex) => ex.currentWorkPromise)
+        .map((ex) => ex.currentWorkPromise);
+    commons_1.logger.debug(`${stackExecutionPromises.length} stacks are currently busy, waiting for one to finish`);
+    if (!stackExecutionPromises.length) {
+        return undefined;
+    }
+    await (0, commons_1.ensureAllSettledBeforeThrowing)(Promise.race(stackExecutionPromises), stackExecutionPromises);
+    return await getStackWithNoUnmetDependencies(stackExecutors);
+}
+exports.getStackWithNoUnmetDependencies = getStackWithNoUnmetDependencies;
+function findAllDependantStacks(stackExecutors, stackName) {
+    return stackExecutors.filter((innerExecutor) => innerExecutor.stack.dependencies.includes(stackName));
+}
+function findAllNestedDependantStacks(stackExecutors, stackName, knownDependantStackNames = new Set()) {
+    const dependantStacks = findAllDependantStacks(stackExecutors, stackName);
+    dependantStacks.forEach((stack) => {
+        if (knownDependantStackNames.has(stack.stack.name)) {
+            return;
+        }
+        knownDependantStackNames.add(stack.stack.name);
+        findAllNestedDependantStacks(stackExecutors, stack.stack.name, knownDependantStackNames);
+    });
+    return stackExecutors.filter((executor) => knownDependantStackNames.has(executor.stack.name));
+}
+exports.findAllNestedDependantStacks = findAllNestedDependantStacks;
+// Returns the first stack that has no dependents that need to be destroyed first
+async function getStackWithNoUnmetDependants(stackExecutors) {
+    commons_1.logger.debug("Checking for stacks with unmet dependants");
+    commons_1.logger.debug("stack executors:", stackExecutors);
+    const pendingStacks = stackExecutors.filter((executor) => executor.isPending);
+    commons_1.logger.debug("pending stacks:", stackExecutors);
+    if (pendingStacks.length === 0) {
+        return undefined;
+    }
+    const currentlyReadyStack = pendingStacks.find((executor) => {
+        const dependantStacks = findAllDependantStacks(stackExecutors, executor.stack.name);
+        return dependantStacks.every((stack) => stack.currentState === "done");
+    });
+    if (currentlyReadyStack) {
+        commons_1.logger.debug("Found a stack with no unmet dependants");
+        return currentlyReadyStack;
+    }
+    const stackExecutionPromises = stackExecutors
+        .filter((ex) => ex.currentWorkPromise)
+        .map((ex) => ex.currentWorkPromise);
+    commons_1.logger.debug(`${stackExecutionPromises.length} stacks are currently busy, waiting for one to finish`);
+    if (!stackExecutionPromises.length) {
+        return undefined;
+    }
+    await Promise.race(stackExecutionPromises);
+    return await getStackWithNoUnmetDependants(stackExecutors);
+}
+exports.getStackWithNoUnmetDependants = getStackWithNoUnmetDependants;
+// Throws an error if there is a dependant stack that is not included
+function checkIfAllDependantsAreIncluded(stacksToRun, allStacks) {
+    const allDependants = new Set();
+    stacksToRun
+        .map((stack) => allStacks.filter((s) => s.dependencies.includes(stack.name)))
+        .flat()
+        .forEach((dependant) => allDependants.add(dependant.name));
+    const stackNames = stacksToRun.map((stack) => stack.name);
+    const missingDependants = [...allDependants].filter((dependant) => !stackNames.includes(dependant));
+    if (missingDependants.length > 0) {
+        throw commons_1.Errors.Usage(`The following dependant stacks are not included in the stacks to run: ${missingDependants.join(", ")}. Either add them or add the --ignore-missing-stack-dependencies flag.`);
+    }
+}
+exports.checkIfAllDependantsAreIncluded = checkIfAllDependantsAreIncluded;
+/**
+  Throws an error if there is a dependency that is not included
+  Cycles are detected on dependency creation at synthesis time
+  Running this prevents us from being in a situation where we
+  have to wait for a stack to be deployed that is not included to be run
+*/
+function checkIfAllDependenciesAreIncluded(stacksToRun) {
+    const allDependencies = new Set();
+    stacksToRun
+        .map((stack) => stack.dependencies)
+        .flat()
+        .forEach((dependency) => allDependencies.add(dependency));
+    const stackNames = stacksToRun.map((stack) => stack.name);
+    const missingDependencies = [...allDependencies].filter((dependency) => !stackNames.includes(dependency));
+    if (missingDependencies.length > 0) {
+        throw commons_1.Errors.Usage(`The following dependencies are not included in the stacks to run: ${missingDependencies.join(", ")}. Either add them or add the --ignore-missing-stack-dependencies flag.`);
+    }
+}
+exports.checkIfAllDependenciesAreIncluded = checkIfAllDependenciesAreIncluded;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-helpers.js","sourceRoot":"","sources":["../../../src/lib/helpers/stack-helpers.ts"],"names":[],"mappings":";AAAA,+BAA+B;AAC/B,mCAAmC;;;;;;AAEnC,4CAAgF;AAChF,0DAAkC;AAIlC,SAAgB,cAAc,CAC5B,MAA0B,EAC1B,SAAkB,EAClB,YAAqB;IAErB,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,gBAAM,CAAC,QAAQ,CACnB,yDAAyD,CAC1D,CAAC;IACJ,CAAC;IAED,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;QACvD,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,gBAAM,CAAC,KAAK,CAAC,wBAAwB,GAAG,SAAS,CAAC,CAAC;QAC3D,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IAED,MAAM,gBAAM,CAAC,KAAK,CAChB,uEACE,YAAY,IAAI,QAClB,sCAAsC,MAAM;SACzC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;SAClB,IAAI,CAAC,IAAI,CAAC,GAAG,CACjB,CAAC;AACJ,CAAC;AA/BD,wCA+BC;AAED,SAAgB,iBAAiB,CAC/B,MAA0B,EAC1B,QAAmB,EACnB,YAAqB;IAErB,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;QAClC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACrB,CAAC;QACD,MAAM,gBAAM,CAAC,KAAK,CAChB,uEACE,YAAY,IAAI,QAClB,sCAAsC,MAAM;aACzC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;aAClB,IAAI,CAAC,IAAI,CAAC,GAAG,CACjB,CAAC;IACJ,CAAC;IAED,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAClC,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAC7C,IAAA,mBAAS,EAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAC/B,CAAC;QAEF,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,gBAAM,CAAC,KAAK,CAAC,qCAAqC,OAAO,GAAG,CAAC,CAAC;QACtE,CAAC;QAED,OAAO,cAAc,CAAC;IACxB,CAAC,CAAC,CAAC;AACL,CAAC;AA7BD,8CA6BC;AAED,yDAAyD;AACzD,qEAAqE;AACrE,qDAAqD;AACrD,qIAAqI;AAC9H,KAAK,UAAU,+BAA+B,CACnD,cAA4B;IAE5B,gBAAM,CAAC,KAAK,CAAC,6CAA6C,CAAC,CAAC;IAC5D,gBAAM,CAAC,KAAK,CAAC,kBAAkB,EAAE,cAAc,CAAC,CAAC;IACjD,MAAM,aAAa,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC9E,gBAAM,CAAC,KAAK,CAAC,iBAAiB,EAAE,cAAc,CAAC,CAAC;IAEhD,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,mBAAmB,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAC1D,QAAQ,CAAC,KAAK,CAAC,YAAY,CAAC,KAAK,CAC/B,CAAC,UAAU,EAAE,EAAE;;QACb,OAAA,CAAA,MAAA,cAAc,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC,0CACjE,YAAY,MAAK,MAAM,CAAA;KAAA,CAC9B,CACF,CAAC;IAEF,IAAI,mBAAmB,EAAE,CAAC;QACxB,gBAAM,CAAC,KAAK,CAAC,0CAA0C,CAAC,CAAC;QACzD,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IAED,MAAM,sBAAsB,GAAG,cAAc;SAC1C,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,kBAAkB,CAAC;SACrC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC;IAEtC,gBAAM,CAAC,KAAK,CACV,GAAG,sBAAsB,CAAC,MAAM,uDAAuD,CACxF,CAAC;IAEF,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC;QACnC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,IAAA,wCAA8B,EAClC,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,EACpC,sBAAsB,CACvB,CAAC;IAEF,OAAO,MAAM,+BAA+B,CAAC,cAAc,CAAC,CAAC;AAC/D,CAAC;AA3CD,0EA2CC;AAED,SAAS,sBAAsB,CAC7B,cAA4B,EAC5B,SAAiB;IAEjB,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,EAAE,CAC7C,aAAa,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,CACrD,CAAC;AACJ,CAAC;AAED,SAAgB,4BAA4B,CAC1C,cAA4B,EAC5B,SAAiB,EACjB,2BAAwC,IAAI,GAAG,EAAE;IAEjD,MAAM,eAAe,GAAG,sBAAsB,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;IAC1E,eAAe,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QAChC,IAAI,wBAAwB,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACnD,OAAO;QACT,CAAC;QAED,wBAAwB,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC/C,4BAA4B,CAC1B,cAAc,EACd,KAAK,CAAC,KAAK,CAAC,IAAI,EAChB,wBAAwB,CACzB,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CACxC,wBAAwB,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAClD,CAAC;AACJ,CAAC;AAtBD,oEAsBC;AAED,iFAAiF;AAC1E,KAAK,UAAU,6BAA6B,CACjD,cAA4B;IAE5B,gBAAM,CAAC,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC1D,gBAAM,CAAC,KAAK,CAAC,kBAAkB,EAAE,cAAc,CAAC,CAAC;IACjD,MAAM,aAAa,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC9E,gBAAM,CAAC,KAAK,CAAC,iBAAiB,EAAE,cAAc,CAAC,CAAC;IAEhD,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,mBAAmB,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;QAC1D,MAAM,eAAe,GAAG,sBAAsB,CAC5C,cAAc,EACd,QAAQ,CAAC,KAAK,CAAC,IAAI,CACpB,CAAC;QACF,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,KAAK,MAAM,CAAC,CAAC;IACzE,CAAC,CAAC,CAAC;IAEH,IAAI,mBAAmB,EAAE,CAAC;QACxB,gBAAM,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;QACvD,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IACD,MAAM,sBAAsB,GAAG,cAAc;SAC1C,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,kBAAkB,CAAC;SACrC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC;IAEtC,gBAAM,CAAC,KAAK,CACV,GAAG,sBAAsB,CAAC,MAAM,uDAAuD,CACxF,CAAC;IACF,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC;QACnC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;IAC3C,OAAO,MAAM,6BAA6B,CAAC,cAAc,CAAC,CAAC;AAC7D,CAAC;AArCD,sEAqCC;AAED,qEAAqE;AACrE,SAAgB,+BAA+B,CAC7C,WAA+B,EAC/B,SAA6B;IAE7B,MAAM,aAAa,GAAG,IAAI,GAAG,EAAU,CAAC;IACxC,WAAW;SACR,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CACb,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAC7D;SACA,IAAI,EAAE;SACN,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IAE7D,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1D,MAAM,iBAAiB,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,MAAM,CACjD,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,CAC/C,CAAC;IAEF,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjC,MAAM,gBAAM,CAAC,KAAK,CAChB,yEAAyE,iBAAiB,CAAC,IAAI,CAC7F,IAAI,CACL,wEAAwE,CAC1E,CAAC;IACJ,CAAC;AACH,CAAC;AAxBD,0EAwBC;AAED;;;;;EAKE;AACF,SAAgB,iCAAiC,CAC/C,WAA+B;IAE/B,MAAM,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;IAC1C,WAAW;SACR,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC;SAClC,IAAI,EAAE;SACN,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,eAAe,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;IAE5D,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1D,MAAM,mBAAmB,GAAG,CAAC,GAAG,eAAe,CAAC,CAAC,MAAM,CACrD,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CACjD,CAAC;IAEF,IAAI,mBAAmB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnC,MAAM,gBAAM,CAAC,KAAK,CAChB,qEAAqE,mBAAmB,CAAC,IAAI,CAC3F,IAAI,CACL,wEAAwE,CAC1E,CAAC;IACJ,CAAC;AACH,CAAC;AArBD,8EAqBC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\n\nimport { ensureAllSettledBeforeThrowing, Errors, logger } from \"@cdktn/commons\";\nimport minimatch from \"minimatch\";\nimport { CdktfStack } from \"../cdktf-stack\";\nimport { SynthesizedStack } from \"../synth-stack\";\n\nexport function getSingleStack(\n  stacks: SynthesizedStack[],\n  stackName?: string,\n  targetAction?: string,\n) {\n  if (!stacks) {\n    throw Errors.Internal(\n      \"Trying to access a stack before it has been synthesized\",\n    );\n  }\n\n  if (stackName) {\n    const stack = stacks.find((s) => s.name === stackName);\n    if (!stack) {\n      throw Errors.Usage(\"Could not find stack: \" + stackName);\n    }\n\n    return stack;\n  }\n\n  if (stacks.length === 1) {\n    return stacks[0];\n  }\n\n  throw Errors.Usage(\n    `Found more than one stack, please specify a target stack. Run cdktn ${\n      targetAction || \"<verb>\"\n    } <stack> with one of these stacks: ${stacks\n      .map((s) => s.name)\n      .join(\", \")} `,\n  );\n}\n\nexport function getMultipleStacks(\n  stacks: SynthesizedStack[],\n  patterns?: string[],\n  targetAction?: string,\n) {\n  if (!patterns || !patterns.length) {\n    if (stacks.length === 1) {\n      return [stacks[0]];\n    }\n    throw Errors.Usage(\n      `Found more than one stack, please specify a target stack. Run cdktn ${\n        targetAction || \"<verb>\"\n      } <stack> with one of these stacks: ${stacks\n        .map((s) => s.name)\n        .join(\", \")} `,\n    );\n  }\n\n  return patterns.flatMap((pattern) => {\n    const matchingStacks = stacks.filter((stack) =>\n      minimatch(stack.name, pattern),\n    );\n\n    if (matchingStacks.length === 0) {\n      throw Errors.Usage(`Could not find stack for pattern '${pattern}'`);\n    }\n\n    return matchingStacks;\n  });\n}\n\n// Returns the first stack that has no unmet dependencies\n// An unmet dependency is a dependency that has not been deployed yet\n// If there is no unfinished stack, returns undefined\n// If there is no stack ready to be worked on, it returns a promise that will resolve as soon as there is a follow-up stack available\nexport async function getStackWithNoUnmetDependencies(\n  stackExecutors: CdktfStack[],\n): Promise<CdktfStack | undefined> {\n  logger.debug(\"Checking for stacks with unmet dependencies\");\n  logger.debug(\"stack executors:\", stackExecutors);\n  const pendingStacks = stackExecutors.filter((executor) => executor.isPending);\n  logger.debug(\"pending stacks:\", stackExecutors);\n\n  if (pendingStacks.length === 0) {\n    return undefined;\n  }\n\n  const currentlyReadyStack = pendingStacks.find((executor) =>\n    executor.stack.dependencies.every(\n      (dependency) =>\n        stackExecutors.find((executor) => executor.stack.name === dependency)\n          ?.currentState === \"done\",\n    ),\n  );\n\n  if (currentlyReadyStack) {\n    logger.debug(\"Found a stack with no unmet dependencies\");\n    return currentlyReadyStack;\n  }\n\n  const stackExecutionPromises = stackExecutors\n    .filter((ex) => ex.currentWorkPromise)\n    .map((ex) => ex.currentWorkPromise);\n\n  logger.debug(\n    `${stackExecutionPromises.length} stacks are currently busy, waiting for one to finish`,\n  );\n\n  if (!stackExecutionPromises.length) {\n    return undefined;\n  }\n\n  await ensureAllSettledBeforeThrowing(\n    Promise.race(stackExecutionPromises),\n    stackExecutionPromises,\n  );\n\n  return await getStackWithNoUnmetDependencies(stackExecutors);\n}\n\nfunction findAllDependantStacks(\n  stackExecutors: CdktfStack[],\n  stackName: string,\n): CdktfStack[] {\n  return stackExecutors.filter((innerExecutor) =>\n    innerExecutor.stack.dependencies.includes(stackName),\n  );\n}\n\nexport function findAllNestedDependantStacks(\n  stackExecutors: CdktfStack[],\n  stackName: string,\n  knownDependantStackNames: Set<string> = new Set(),\n): CdktfStack[] {\n  const dependantStacks = findAllDependantStacks(stackExecutors, stackName);\n  dependantStacks.forEach((stack) => {\n    if (knownDependantStackNames.has(stack.stack.name)) {\n      return;\n    }\n\n    knownDependantStackNames.add(stack.stack.name);\n    findAllNestedDependantStacks(\n      stackExecutors,\n      stack.stack.name,\n      knownDependantStackNames,\n    );\n  });\n\n  return stackExecutors.filter((executor) =>\n    knownDependantStackNames.has(executor.stack.name),\n  );\n}\n\n// Returns the first stack that has no dependents that need to be destroyed first\nexport async function getStackWithNoUnmetDependants(\n  stackExecutors: CdktfStack[],\n): Promise<CdktfStack | undefined> {\n  logger.debug(\"Checking for stacks with unmet dependants\");\n  logger.debug(\"stack executors:\", stackExecutors);\n  const pendingStacks = stackExecutors.filter((executor) => executor.isPending);\n  logger.debug(\"pending stacks:\", stackExecutors);\n\n  if (pendingStacks.length === 0) {\n    return undefined;\n  }\n\n  const currentlyReadyStack = pendingStacks.find((executor) => {\n    const dependantStacks = findAllDependantStacks(\n      stackExecutors,\n      executor.stack.name,\n    );\n    return dependantStacks.every((stack) => stack.currentState === \"done\");\n  });\n\n  if (currentlyReadyStack) {\n    logger.debug(\"Found a stack with no unmet dependants\");\n    return currentlyReadyStack;\n  }\n  const stackExecutionPromises = stackExecutors\n    .filter((ex) => ex.currentWorkPromise)\n    .map((ex) => ex.currentWorkPromise);\n\n  logger.debug(\n    `${stackExecutionPromises.length} stacks are currently busy, waiting for one to finish`,\n  );\n  if (!stackExecutionPromises.length) {\n    return undefined;\n  }\n\n  await Promise.race(stackExecutionPromises);\n  return await getStackWithNoUnmetDependants(stackExecutors);\n}\n\n// Throws an error if there is a dependant stack that is not included\nexport function checkIfAllDependantsAreIncluded(\n  stacksToRun: SynthesizedStack[],\n  allStacks: SynthesizedStack[],\n) {\n  const allDependants = new Set<string>();\n  stacksToRun\n    .map((stack) =>\n      allStacks.filter((s) => s.dependencies.includes(stack.name)),\n    )\n    .flat()\n    .forEach((dependant) => allDependants.add(dependant.name));\n\n  const stackNames = stacksToRun.map((stack) => stack.name);\n  const missingDependants = [...allDependants].filter(\n    (dependant) => !stackNames.includes(dependant),\n  );\n\n  if (missingDependants.length > 0) {\n    throw Errors.Usage(\n      `The following dependant stacks are not included in the stacks to run: ${missingDependants.join(\n        \", \",\n      )}. Either add them or add the --ignore-missing-stack-dependencies flag.`,\n    );\n  }\n}\n\n/** \n  Throws an error if there is a dependency that is not included\n  Cycles are detected on dependency creation at synthesis time\n  Running this prevents us from being in a situation where we \n  have to wait for a stack to be deployed that is not included to be run\n*/\nexport function checkIfAllDependenciesAreIncluded(\n  stacksToRun: SynthesizedStack[],\n) {\n  const allDependencies = new Set<string>();\n  stacksToRun\n    .map((stack) => stack.dependencies)\n    .flat()\n    .forEach((dependency) => allDependencies.add(dependency));\n\n  const stackNames = stacksToRun.map((stack) => stack.name);\n  const missingDependencies = [...allDependencies].filter(\n    (dependency) => !stackNames.includes(dependency),\n  );\n\n  if (missingDependencies.length > 0) {\n    throw Errors.Usage(\n      `The following dependencies are not included in the stacks to run: ${missingDependencies.join(\n        \", \",\n      )}. Either add them or add the --ignore-missing-stack-dependencies flag.`,\n    );\n  }\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAC1E,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,KAAK,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,EACL,sBAAsB,EACtB,WAAW,EACX,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,iBAAiB,EACjB,2BAA2B,EAC3B,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,GAChB,MAAM,oBAAoB,CAAC"}

package/{src → build}/lib/index.js

@@ -4,7 +4,6 @@
 // This is the programmatic entrypoint that the CLI uses.
 // While this is the closest we have to a programmatic API, please understand that the interfaces in this file are not stable.
 // Convert is not included here since it's published independently as @cdktn/hcl2cdk.
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlannedResourceAction = exports.isTerraformOutput = exports.DeployingResourceApplyState = exports.normalizeOutputPath = exports.saveOutputs = exports.watch = exports.CdktfProject = exports.runGetInDir = exports.GetStatus = exports.get = exports.templatesDir = exports.templates = exports.init = exports.CdktfStack = exports.initializErrorReporting = exports.CdktfConfig = exports.TerraformCli = exports.providerAdd = exports.getAllPrebuiltProviders = exports.ProviderConstraint = exports.DependencyManager = void 0;
 var dependency_manager_1 = require("./dependencies/dependency-manager");
@@ -41,4 +40,4 @@ var terraform_1 = require("./models/terraform");
 Object.defineProperty(exports, "DeployingResourceApplyState", { enumerable: true, get: function () { return terraform_1.DeployingResourceApplyState; } });
 Object.defineProperty(exports, "isTerraformOutput", { enumerable: true, get: function () { return terraform_1.isTerraformOutput; } });
 Object.defineProperty(exports, "PlannedResourceAction", { enumerable: true, get: function () { return terraform_1.PlannedResourceAction; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/lib/init.ts"],"names":[],"mappings":"AAuBA,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,uBAAuB,EAAE,MAAM,CAAC;CACjC;AACD,MAAM,MAAM,OAAO,GAAG,YAAY,GAAG,aAAa,CAAC;AAEnD,MAAM,MAAM,QAAQ,GAAG;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,YAAY,QAAgD,CAAC;AAK1E,eAAO,MAAM,SAAS,EAAE,MAAM,EAAO,CAAC;AAKtC,wBAAsB,IAAI,CAAC,EACzB,YAAY,EACZ,WAAW,EACX,IAAI,EACJ,SAAS,EACT,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,mBAAmB,EACnB,MAAM,GACP,EAAE,QAAQ,oBA4BV;AAED,MAAM,WAAW,IAAI;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AACD,wBAAsB,aAAa,CACjC,OAAO,GAAE,MAAoB,EAC7B,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAqEf"}

package/build/lib/init.js

@@ -0,0 +1,131 @@
+"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.determineDeps = exports.init = exports.templates = exports.templatesDir = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const pkgUp = __importStar(require("pkg-up"));
+const commons_1 = require("@cdktn/commons");
+const sscaff_1 = require("sscaff");
+const features_1 = require("cdktn/lib/features");
+const cdktf_config_1 = require("./cdktf-config");
+const provider_add_1 = require("./provider-add");
+const readPackageJson = () => {
+    const pkgPath = pkgUp.sync({ cwd: __dirname });
+    if (!pkgPath) {
+        throw new Error("unable to find package.json");
+    }
+    return JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+};
+const pkg = readPackageJson();
+const constructsVersion = pkg.dependencies.constructs;
+exports.templatesDir = path.join(__dirname, "..", "..", "templates");
+const availableTemplates = fs
+    .readdirSync(exports.templatesDir)
+    .filter((x) => !x.startsWith("."));
+exports.templates = [];
+for (const template of availableTemplates) {
+    exports.templates.push(template);
+}
+async function init({ cdktfVersion, destination, dist, projectId, projectInfo, templatePath, sendCrashReports, providers, providersForceLocal, silent, }) {
+    const deps = await determineDeps(cdktfVersion, dist);
+    const futureFlags = Object.entries(features_1.FUTURE_FLAGS)
+        .map(([key, value]) => `    "${key}": "${value}"`)
+        .join(`,\n`);
+    await (0, sscaff_1.sscaff)(templatePath, destination, {
+        ...deps,
+        ...projectInfo,
+        futureFlags,
+        projectId,
+        sendCrashReports,
+        silent,
+    });
+    const cdktfConfig = cdktf_config_1.CdktfConfig.read(destination);
+    let needsGet = false;
+    if (providers && providers.length) {
+        needsGet = await (0, provider_add_1.providerAdd)({
+            providers: providers,
+            language: cdktfConfig.language,
+            projectDirectory: destination,
+            forceLocal: providersForceLocal,
+            dist,
+        });
+    }
+    return needsGet;
+}
+exports.init = init;
+async function determineDeps(version = pkg.version, dist) {
+    // TS: cdktf-0.10.1-dev.2160938258
+    // Py: cdktf-0.10.1.dev1658821493.whl
+    const pythonVersion = version
+        .replace(/-pre\./g, ".dev")
+        .replace(/-dev\./g, ".dev");
+    if (dist) {
+        // TODO: What about existing cdktf TS/PY dependencies?
+        const ret = {
+            npm_cdktf: path.resolve(dist, "js", `cdktn@${version}.jsii.tgz`),
+            npm_cdktf_cli: path.resolve(dist, "js", `cdktn-cli-${version}.tgz`),
+            pypi_cdktf: path.resolve(dist, "python", `cdktn-${pythonVersion}-py3-none-any.whl`),
+            mvn_cdktf: path.resolve(dist, "java", `io/cdktn/cdktn/${version}/cdktn-${version}.jar`),
+            nuget_cdktf: path.resolve(dist, "dotnet", `Io.Cdktn.${version}.nupkg`),
+            go_cdktf: path.resolve(dist, "go", `cdktn`),
+        };
+        for (const file of Object.values(ret)) {
+            if (!(await fs.pathExists(file))) {
+                throw commons_1.Errors.Internal(`unable to find ${file} under the "dist" directory (${dist})`, new Error(), { version });
+            }
+        }
+        const versions = {
+            cdktf_version: version,
+            constructs_version: constructsVersion,
+        };
+        return {
+            ...ret,
+            ...versions,
+        };
+    }
+    if (version === "0.0.0") {
+        throw commons_1.Errors.Usage(`cannot use version 0.0.0, use --cdktf-version, --dist or CDKTF_DIST to install from a "dist" directory`);
+    }
+    // determine if we want a specific pinned version or a version range we take
+    // a pinned version if version includes a hyphen which means it is a
+    // pre-release (e.g. "0.12.0-pre.e6834d3"). otherwise, we require a caret
+    // version.
+    const ver = version.includes("-") ? version : `^${version}`;
+    return {
+        cdktf_version: version,
+        constructs_version: constructsVersion,
+        npm_cdktf: `cdktn@${ver}`,
+        npm_cdktf_cli: `cdktn-cli@${ver}`,
+        pypi_cdktf: `cdktn~=${pythonVersion}`,
+        mvn_cdktf: version,
+        nuget_cdktf: version,
+        go_cdktf: `v${version}`,
+    };
+}
+exports.determineDeps = determineDeps;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init.js","sourceRoot":"","sources":["../../src/lib/init.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as path from \"path\";\nimport * as fs from \"fs-extra\";\nimport * as pkgUp from \"pkg-up\";\nimport { Errors } from \"@cdktn/commons\";\n\nimport { sscaff } from \"sscaff\";\nimport { FUTURE_FLAGS } from \"cdktn/lib/features\";\nimport { CdktfConfig } from \"./cdktf-config\";\nimport { providerAdd } from \"./provider-add\";\n\nconst readPackageJson = () => {\n  const pkgPath = pkgUp.sync({ cwd: __dirname });\n  if (!pkgPath) {\n    throw new Error(\"unable to find package.json\");\n  }\n\n  return JSON.parse(fs.readFileSync(pkgPath, \"utf-8\"));\n};\nconst pkg = readPackageJson();\nconst constructsVersion = pkg.dependencies.constructs;\n\nexport interface LocalProject {\n  Description: string;\n  Name: string;\n}\n\nexport interface RemoteProject extends LocalProject {\n  OrganizationName: string;\n  WorkspaceName: string;\n  TerraformRemoteHostname: string;\n}\nexport type Project = LocalProject | RemoteProject;\n\nexport type InitArgs = {\n  cdktfVersion?: string;\n  destination: string;\n  dist?: string;\n  providers?: string[];\n  providersForceLocal?: boolean;\n  projectId: string;\n  projectInfo: Project;\n  templatePath: string;\n  sendCrashReports: boolean;\n  silent?: boolean;\n};\n\nexport const templatesDir = path.join(__dirname, \"..\", \"..\", \"templates\");\n\nconst availableTemplates = fs\n  .readdirSync(templatesDir)\n  .filter((x) => !x.startsWith(\".\"));\nexport const templates: string[] = [];\nfor (const template of availableTemplates) {\n  templates.push(template);\n}\n\nexport async function init({\n  cdktfVersion,\n  destination,\n  dist,\n  projectId,\n  projectInfo,\n  templatePath,\n  sendCrashReports,\n  providers,\n  providersForceLocal,\n  silent,\n}: InitArgs) {\n  const deps: any = await determineDeps(cdktfVersion, dist);\n\n  const futureFlags = Object.entries(FUTURE_FLAGS)\n    .map(([key, value]) => `    \"${key}\": \"${value}\"`)\n    .join(`,\\n`);\n\n  await sscaff(templatePath, destination, {\n    ...deps,\n    ...projectInfo,\n    futureFlags,\n    projectId,\n    sendCrashReports,\n    silent,\n  });\n  const cdktfConfig = CdktfConfig.read(destination);\n\n  let needsGet = false;\n  if (providers && providers.length) {\n    needsGet = await providerAdd({\n      providers: providers,\n      language: cdktfConfig.language,\n      projectDirectory: destination,\n      forceLocal: providersForceLocal,\n      dist,\n    });\n  }\n  return needsGet;\n}\n\nexport interface Deps {\n  npm_cdktf: string;\n  npm_cdktf_cli: string;\n  pypi_cdktf: string;\n  mvn_cdktf: string;\n  nuget_cdktf: string;\n  go_cdktf: string;\n  cdktf_version: string;\n  constructs_version: string;\n}\nexport async function determineDeps(\n  version: string = pkg.version,\n  dist?: string,\n): Promise<Deps> {\n  // TS: cdktf-0.10.1-dev.2160938258\n  // Py: cdktf-0.10.1.dev1658821493.whl\n  const pythonVersion = version\n    .replace(/-pre\\./g, \".dev\")\n    .replace(/-dev\\./g, \".dev\");\n\n  if (dist) {\n    // TODO: What about existing cdktf TS/PY dependencies?\n    const ret = {\n      npm_cdktf: path.resolve(dist, \"js\", `cdktn@${version}.jsii.tgz`),\n      npm_cdktf_cli: path.resolve(dist, \"js\", `cdktn-cli-${version}.tgz`),\n      pypi_cdktf: path.resolve(\n        dist,\n        \"python\",\n        `cdktn-${pythonVersion}-py3-none-any.whl`,\n      ),\n      mvn_cdktf: path.resolve(\n        dist,\n        \"java\",\n        `io/cdktn/cdktn/${version}/cdktn-${version}.jar`,\n      ),\n      nuget_cdktf: path.resolve(dist, \"dotnet\", `Io.Cdktn.${version}.nupkg`),\n      go_cdktf: path.resolve(dist, \"go\", `cdktn`),\n    };\n\n    for (const file of Object.values(ret)) {\n      if (!(await fs.pathExists(file))) {\n        throw Errors.Internal(\n          `unable to find ${file} under the \"dist\" directory (${dist})`,\n          new Error(),\n          { version },\n        );\n      }\n    }\n\n    const versions = {\n      cdktf_version: version,\n      constructs_version: constructsVersion,\n    };\n\n    return {\n      ...ret,\n      ...versions,\n    };\n  }\n\n  if (version === \"0.0.0\") {\n    throw Errors.Usage(\n      `cannot use version 0.0.0, use --cdktf-version, --dist or CDKTF_DIST to install from a \"dist\" directory`,\n    );\n  }\n\n  // determine if we want a specific pinned version or a version range we take\n  // a pinned version if version includes a hyphen which means it is a\n  // pre-release (e.g. \"0.12.0-pre.e6834d3\"). otherwise, we require a caret\n  // version.\n  const ver = version.includes(\"-\") ? version : `^${version}`;\n\n  return {\n    cdktf_version: version,\n    constructs_version: constructsVersion,\n    npm_cdktf: `cdktn@${ver}`,\n    npm_cdktf_cli: `cdktn-cli@${ver}`,\n    pypi_cdktf: `cdktn~=${pythonVersion}`,\n    mvn_cdktf: version,\n    nuget_cdktf: version,\n    go_cdktf: `v${version}`,\n  };\n}\n"]}

package/build/lib/local-provider-constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-provider-constraints.d.ts","sourceRoot":"","sources":["../../src/lib/local-provider-constraints.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,QAAA,MAAM,eAAe;;;;;;;;;EAGnB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAI1D;;;GAGG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,WAAW,CAA0B;IAE7C,OAAO,KAAK,YAAY,GAGvB;YAEa,wBAAwB;IA+BzB,0BAA0B;;;;IAU1B,qBAAqB,CAChC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAe1B"}