@cdktn/cli-core 0.22.0-pre.2

package/src/lib/cdktf-project.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdktfProject = exports.isWaitingForUserInputUpdate = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const commons_1 = require("@cdktn/commons");
+const synth_stack_1 = require("./synth-stack");
+const synth_1 = require("./synth");
+const cdktf_stack_1 = require("./cdktf-stack");
+const execution_logs_1 = require("./execution-logs");
+const stack_helpers_1 = require("./helpers/stack-helpers");
+const cdktf_project_io_handler_1 = require("./cdktf-project-io-handler");
+function isWaitingForUserInputUpdate(update) {
+    return ["waiting for approval", "waiting for sentinel override"].includes(update.type);
+}
+exports.isWaitingForUserInputUpdate = isWaitingForUserInputUpdate;
+class CdktfProject {
+    constructor({ synthCommand, outDir, onUpdate, onLog, workingDirectory = process.cwd(), synthOrigin, hcl = false, }) {
+        // Set during deploy / destroy
+        this.stacksToRun = [];
+        // This means sth different in deploy / destroy
+        this.stopAllStacksThatCanNotRunWithout = () => { }; // eslint-disable-line @typescript-eslint/no-empty-function
+        this.synthCommand = synthCommand;
+        this.outDir = outDir;
+        this.workingDirectory = workingDirectory;
+        this.onUpdate = onUpdate;
+        this.onLog = onLog;
+        const ac = new AbortController();
+        this.abortSignal = ac.signal;
+        this.synthOrigin = synthOrigin;
+        this.hcl =
+            process.env.SYNTH_HCL_OUTPUT === "true" ||
+                process.env.SYNTH_HCL_OUTPUT === "1" ||
+                hcl;
+        this.hardAbort = ac.abort.bind(ac);
+        this.ioHandler = new cdktf_project_io_handler_1.CdktfProjectIOHandler();
+    }
+    stopAllStacks() {
+        this.stacksToRun.forEach((stack) => stack.stop());
+        this.ioHandler.filterUserInputEventsFromBuffer();
+    }
+    handleUserUpdate(update, operations, originalCallback, eventType) {
+        const callbacks = (update) => Object.fromEntries(Object.entries(operations).map(([key, value]) => {
+            return [
+                key,
+                // This is passed in to make typescript happy only
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                (_) => {
+                    value(update);
+                    // We need to defer these calls for the case that approve() is instantly invoked
+                    // in the listener that receives these callbacks as it otherwise would already
+                    // remove the "waiting for stack approval" event from the buffer before we even
+                    // set waitingForApproval to true (at the end of this if statement) which results
+                    // in buffered updates which will never unblock
+                    setTimeout(() => this.ioHandler.resumeAfterUserInput(update.stackName), 0);
+                },
+            ];
+        }));
+        // always send to buffer, as resumeAfterUserInput() always expects a matching event
+        this.ioHandler.pushEvent({
+            cb: originalCallback,
+            value: {
+                type: eventType,
+                stackName: update.stackName,
+                ...callbacks(update),
+            },
+            type: "projectUpdate",
+        });
+        // if we aren't already waiting, this needs to go to cb() too to arrive at the UI
+        if (!this.ioHandler.isWaitingForUserInput()) {
+            originalCallback({
+                type: eventType,
+                stackName: update.stackName,
+                ...callbacks(update),
+            });
+        }
+    }
+    handleUserInputProcess(cb) {
+        return (update) => {
+            if (update.type === "external stack approval reply") {
+                if (!update.approved) {
+                    this.stopAllStacksThatCanNotRunWithout(update.stackName);
+                }
+                this.ioHandler.resumeAfterUserInput(update.stackName);
+                return; // aka don't send this event to any buffer
+            }
+            if (update.type === "external stack sentinel override reply") {
+                if (!update.overridden) {
+                    this.stopAllStacksThatCanNotRunWithout(update.stackName);
+                }
+                this.ioHandler.resumeAfterUserInput(update.stackName);
+                return; // aka don't send this event to any buffer
+            }
+            if (update.type === "waiting for stack approval" ||
+                update.type === "waiting for stack sentinel override") {
+                if (update.type === "waiting for stack approval") {
+                    this.handleUserUpdate(update, {
+                        approve: (update) => update.approve(),
+                        dismiss: (update) => {
+                            update.reject();
+                            this.stopAllStacksThatCanNotRunWithout(update.stackName);
+                        },
+                        stop: (update) => {
+                            update.reject();
+                            this.stopAllStacks();
+                        },
+                    }, cb, "waiting for approval");
+                }
+                else if (update.type === "waiting for stack sentinel override") {
+                    this.handleUserUpdate(update, {
+                        override: (update) => {
+                            update.override();
+                        },
+                        reject: (update) => {
+                            update.reject();
+                            this.stopAllStacksThatCanNotRunWithout(update.stackName);
+                        },
+                    }, cb, "waiting for sentinel override");
+                }
+                this.ioHandler.awaitUserInput();
+            }
+            else {
+                if (this.ioHandler.isWaitingForUserInput()) {
+                    this.ioHandler.pushEvent({
+                        cb,
+                        value: update,
+                        type: "projectUpdate",
+                    });
+                }
+                else {
+                    cb(update);
+                }
+            }
+        };
+    }
+    getStackExecutor(stack, opts = {}) {
+        const enhanceLogMessage = (0, execution_logs_1.createEnhanceLogMessage)(stack);
+        const onLog = this.ioHandler.bufferWhileAwaitingUserInput(this.onLog);
+        return new cdktf_stack_1.CdktfStack({
+            ...opts,
+            stack,
+            onUpdate: this.handleUserInputProcess(this.onUpdate),
+            onLog: onLog
+                ? ({ message }) => onLog({
+                    stackName: stack.name,
+                    message,
+                    messageWithConstructPath: enhanceLogMessage(message),
+                })
+                : undefined,
+            abortSignal: this.abortSignal,
+        });
+    }
+    get outputsByConstructId() {
+        return this.stacksToRun.reduce((acc, stack) => ({
+            ...acc,
+            ...stack.outputsByConstructId,
+        }), {});
+    }
+    async synth(noColor) {
+        this.onUpdate({
+            type: "synthesizing",
+        });
+        const stacks = await synth_stack_1.SynthStack.synth(this.abortSignal, this.synthCommand, this.outDir, this.workingDirectory, false, noColor, this.synthOrigin, this.hcl);
+        (0, synth_1.printAnnotations)(stacks);
+        this.onUpdate({
+            type: "synthesized",
+            stacks,
+        });
+        return stacks;
+    }
+    async readSynthesizedStacks() {
+        const stacks = await synth_stack_1.SynthStack.readSynthesizedStacks(this.outDir);
+        (0, synth_1.printAnnotations)(stacks);
+        this.onUpdate({
+            type: "synthesized",
+            stacks,
+        });
+        return stacks;
+    }
+    async diff(opts = {}) {
+        const stacks = opts.skipSynth
+            ? await this.readSynthesizedStacks()
+            : await this.synth(opts.noColor);
+        const stack = this.getStackExecutor((0, stack_helpers_1.getSingleStack)(stacks, opts === null || opts === void 0 ? void 0 : opts.stackName, "diff"));
+        await stack.initalizeTerraform(opts.noColor, opts.skipProviderLock, opts.migrateState);
+        try {
+            await stack.diff(opts);
+        }
+        catch (e) {
+            throw commons_1.Errors.External(`Stack failed to plan: ${stack.stack.name}. Please check the logs for more information.`, e);
+        }
+        if (stack.error) {
+            throw commons_1.Errors.External(`Stack failed to plan: ${stack.stack.name}. Please check the logs for more information.`, new Error(stack.error));
+        }
+        try {
+            await this.projectTelemetry("diff", {
+                stackMetadata: stacks.map((stack) => JSON.parse(stack.content)["//"]
+                    ? JSON.parse(stack.content)["//"].metadata
+                    : {}),
+                errors: stack.error,
+                requiredProviders: stacks.map((stack) => JSON.parse(stack.content)["terraform"]
+                    ? JSON.parse(stack.content)["terraform"].required_providers
+                    : {}),
+            });
+        }
+        catch (e) {
+            commons_1.logger.debug("Failed to send telemetry", e);
+        }
+    }
+    async execute(method, next, opts) {
+        // We only support refresh only on deploy, a bit of a leaky abstraction here
+        if (opts.refreshOnly && method !== "deploy") {
+            throw commons_1.Errors.Internal(`Refresh only is only supported on deploy`);
+        }
+        const maxParallelRuns = !opts.parallelism || opts.parallelism < 0 ? Infinity : opts.parallelism;
+        const allExecutions = [];
+        await this.initializeStacksToRunInSerial(opts.noColor, opts.skipProviderLock, opts.migrateState);
+        while (this.stacksToRun.filter((stack) => stack.isPending).length > 0) {
+            const runningStacks = this.stacksToRun.filter((stack) => stack.isRunning);
+            if (runningStacks.length >= maxParallelRuns) {
+                await Promise.race(runningStacks.map((s) => s.currentWorkPromise));
+                continue;
+            }
+            try {
+                const nextRunningExecutor = await next();
+                if (!nextRunningExecutor) {
+                    // In this case we have no pending stacks, but we also can not find a new executor
+                    break;
+                }
+                const promise = method === "deploy"
+                    ? nextRunningExecutor.deploy(opts)
+                    : nextRunningExecutor.destroy(opts);
+                allExecutions.push(promise);
+            }
+            catch (e) {
+                // await next() threw an error because a stack failed to apply/destroy
+                // wait for all other currently running stacks to complete before propagating that error
+                commons_1.logger.debug("Encountered an error while awaiting stack to finish", e);
+                const openStacks = this.stacksToRun.filter((ex) => ex.currentWorkPromise);
+                commons_1.logger.debug("Waiting for still running stacks to finish:", openStacks);
+                await Promise.allSettled(openStacks.map((ex) => ex.currentWorkPromise));
+                commons_1.logger.debug("Done waiting for still running stacks. All pending work finished");
+                throw e;
+            }
+        }
+        // We end the loop when all stacks are started, now we need to wait for them to be done
+        // We wait for all work to finish even if one of the promises threw an error.
+        await (0, commons_1.ensureAllSettledBeforeThrowing)(Promise.all(allExecutions), allExecutions);
+    }
+    async deploy(opts = {}) {
+        const stacks = opts.skipSynth
+            ? await this.readSynthesizedStacks()
+            : await this.synth(opts.noColor);
+        const stacksToRun = (0, stack_helpers_1.getMultipleStacks)(stacks, opts.stackNames, "deploy");
+        if (!opts.ignoreMissingStackDependencies) {
+            (0, stack_helpers_1.checkIfAllDependenciesAreIncluded)(stacksToRun);
+        }
+        this.stopAllStacksThatCanNotRunWithout = (stackName) => {
+            (0, stack_helpers_1.findAllNestedDependantStacks)(this.stacksToRun, stackName).forEach((stack) => stack.stop());
+        };
+        this.stacksToRun = stacksToRun.map((stack) => this.getStackExecutor(stack, opts));
+        const next = opts.ignoreMissingStackDependencies
+            ? () => Promise.resolve(this.stacksToRun.filter((stack) => stack.isPending)[0])
+            : () => (0, stack_helpers_1.getStackWithNoUnmetDependencies)(this.stacksToRun);
+        await this.execute("deploy", next, opts);
+        const unprocessedStacks = this.stacksToRun.filter((executor) => executor.isPending);
+        if (unprocessedStacks.length > 0) {
+            throw commons_1.Errors.External(`Some stacks failed to deploy: ${unprocessedStacks
+                .map((s) => s.stack.name)
+                .join(", ")}. Please check the logs for more information.`);
+        }
+        try {
+            await this.projectTelemetry("deploy", {
+                stackMetadata: stacksToRun.map((stack) => JSON.parse(stack.content)["//"]
+                    ? JSON.parse(stack.content)["//"].metadata
+                    : {}),
+                failedStacks: unprocessedStacks.map((stack) => stack.error),
+                requiredProviders: stacksToRun.map((stack) => JSON.parse(stack.content)["terraform"]
+                    ? JSON.parse(stack.content)["terraform"].required_providers
+                    : {}),
+            });
+        }
+        catch (e) {
+            commons_1.logger.debug("Failed to send telemetry", e);
+        }
+    }
+    async destroy(opts = {}) {
+        const stacks = opts.skipSynth
+            ? await this.readSynthesizedStacks()
+            : await this.synth(opts.noColor);
+        const stacksToRun = (0, stack_helpers_1.getMultipleStacks)(stacks, opts.stackNames, "destroy");
+        if (!opts.ignoreMissingStackDependencies) {
+            (0, stack_helpers_1.checkIfAllDependantsAreIncluded)(stacksToRun, stacks);
+        }
+        this.stopAllStacksThatCanNotRunWithout = (stackName) => {
+            const stackExecutor = this.stacksToRun.find((s) => s.stack.name === stackName);
+            if (!stackExecutor) {
+                throw commons_1.Errors.Internal(`Could not find stack "${stackName}" that was stopped`);
+            }
+            stackExecutor.stack.dependencies.forEach((dependant) => {
+                this.stopAllStacksThatCanNotRunWithout(dependant);
+                const dependantStack = this.stacksToRun.find((s) => s.stack.name === dependant);
+                if (!dependantStack) {
+                    throw commons_1.Errors.Internal(`Could not find stack "${dependant}" that was stopped`);
+                }
+                dependantStack.stop();
+            });
+        };
+        this.stacksToRun = stacksToRun.map((stack) => this.getStackExecutor(stack, opts));
+        const next = opts.ignoreMissingStackDependencies
+            ? () => Promise.resolve(this.stacksToRun.filter((stack) => stack.currentState !== "done")[0])
+            : () => (0, stack_helpers_1.getStackWithNoUnmetDependants)(this.stacksToRun);
+        await this.execute("destroy", next, opts);
+        const unprocessedStacks = this.stacksToRun.filter((executor) => executor.isPending);
+        if (unprocessedStacks.length > 0) {
+            throw commons_1.Errors.External(`Some stacks failed to destroy: ${unprocessedStacks
+                .map((s) => s.stack.name)
+                .join(", ")}. Please check the logs for more information.`);
+        }
+        try {
+            await this.projectTelemetry("destroy", {
+                stackMetadata: stacksToRun.map((stack) => JSON.parse(stack.content)["//"]
+                    ? JSON.parse(stack.content)["//"].metadata
+                    : {}),
+                failedStacks: unprocessedStacks.map((stack) => stack.error),
+                requiredProviders: stacksToRun.map((stack) => JSON.parse(stack.content)["terraform"]
+                    ? JSON.parse(stack.content)["terraform"].required_providers
+                    : {}),
+            });
+        }
+        catch (e) {
+            commons_1.logger.debug("Failed to send telemetry", e);
+        }
+    }
+    async projectTelemetry(command, payload) {
+        const config = (0, commons_1.readConfigSync)();
+        await (0, commons_1.sendTelemetry)(command, {
+            ...payload,
+            language: config.language,
+        });
+    }
+    async fetchOutputs(opts) {
+        const stacks = opts.skipSynth
+            ? await this.readSynthesizedStacks()
+            : await this.synth();
+        const stacksToRun = (0, stack_helpers_1.getMultipleStacks)(stacks, opts.stackNames || [], "deploy");
+        if (stacksToRun.length === 0) {
+            throw new Error("No stacks to fetch outputs for specified");
+        }
+        this.stacksToRun = stacksToRun.map((stack) => 
+        // Options are empty, because MultipleStackOptions doesn't have any relevant
+        // options for `getStackExecutor`, hence defaults are fine
+        this.getStackExecutor(stack, {}));
+        await this.initializeStacksToRunInSerial(undefined, opts.skipProviderLock);
+        const outputs = await Promise.all(this.stacksToRun.map(async (s) => {
+            const output = await s.fetchOutputs();
+            return {
+                [s.stack.name]: output,
+            };
+        }));
+        return outputs.reduce((acc, curr) => ({ ...acc, ...curr }), {});
+    }
+    // Serially run terraform init to prohibit text file busy errors for the cache files
+    async initializeStacksToRunInSerial(noColor, skipProviderLock, migrateState) {
+        for (const stack of this.stacksToRun) {
+            await stack.initalizeTerraform(noColor, skipProviderLock, migrateState);
+        }
+    }
+}
+exports.CdktfProject = CdktfProject;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdktf-project.js","sourceRoot":"","sources":["cdktf-project.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport {\n  Errors,\n  ensureAllSettledBeforeThrowing,\n  logger,\n  readConfigSync,\n  sendTelemetry,\n} from \"@cdktn/commons\";\nimport { SynthesizedStack, SynthOrigin, SynthStack } from \"./synth-stack\";\nimport { printAnnotations } from \"./synth\";\nimport {\n  CdktfStack,\n  ExternalStackApprovalUpdate,\n  ExternalStackSentinelOverrideUpdate,\n  StackApprovalUpdate,\n  StackSentinelOverrideUpdate,\n  StackUpdate,\n  StackUserInputUpdate,\n} from \"./cdktf-stack\";\nimport { NestedTerraformOutputs } from \"./output\";\nimport { createEnhanceLogMessage } from \"./execution-logs\";\nimport {\n  checkIfAllDependantsAreIncluded,\n  checkIfAllDependenciesAreIncluded,\n  findAllNestedDependantStacks,\n  getMultipleStacks,\n  getSingleStack,\n  getStackWithNoUnmetDependants,\n  getStackWithNoUnmetDependencies,\n} from \"./helpers/stack-helpers\";\nimport { CdktfProjectIOHandler } from \"./cdktf-project-io-handler\";\n\ntype MultiStackApprovalUpdate = {\n  type: \"waiting for approval\";\n  stackName: string;\n  approve: () => void;\n  dismiss: () => void;\n  stop: () => void;\n};\n\ntype MultiStackSentinelOverrideUpdate = {\n  type: \"waiting for sentinel override\";\n  stackName: string;\n  override: () => void;\n  reject: () => void;\n};\n\nexport type MultiStackUpdate =\n  | MultiStackApprovalUpdate\n  | MultiStackSentinelOverrideUpdate;\n\nexport type ProjectUpdate =\n  | {\n      type: \"synthesizing\";\n    }\n  | {\n      type: \"synthesized\";\n      stacks: SynthesizedStack[];\n      errorMessage?: string;\n    }\n  | StackUpdate\n  | MultiStackUpdate;\n\nexport type SingleStackOptions = {\n  stackName?: string;\n};\n\nexport type MultipleStackOptions = {\n  stackNames?: string[];\n};\n\nexport type SkipSynthOptions = {\n  skipSynth?: boolean;\n};\n\nexport type SkipProviderLockOptions = {\n  skipProviderLock?: boolean;\n};\n\nexport type FetchOutputOptions = SkipSynthOptions &\n  SkipProviderLockOptions &\n  MultipleStackOptions;\n\nexport type AutoApproveOptions = {\n  autoApprove?: boolean;\n};\n\nexport type DiffOptions = SingleStackOptions &\n  SkipProviderLockOptions &\n  SkipSynthOptions & {\n    refreshOnly?: boolean;\n    terraformParallelism?: number;\n    vars?: string[];\n    varFiles?: string[];\n    noColor?: boolean;\n    migrateState?: boolean;\n  };\n\nexport type MutationOptions = MultipleStackOptions &\n  SkipProviderLockOptions &\n  SkipSynthOptions &\n  AutoApproveOptions & {\n    refreshOnly?: boolean;\n    ignoreMissingStackDependencies?: boolean;\n    parallelism?: number;\n    terraformParallelism?: number;\n    vars?: string[];\n    varFiles?: string[];\n    noColor?: boolean;\n    migrateState?: boolean;\n  };\n\nexport type LogMessage = {\n  stackName: string;\n  messageWithConstructPath?: string;\n  message: string;\n};\n\n// Stores a log value of a certain type until it can be sent\ntype Buffered<T, V> = {\n  cb: (item: T) => void;\n  value: T;\n  type: V;\n};\n\nexport function isWaitingForUserInputUpdate(\n  update: ProjectUpdate | StackUpdate,\n) {\n  return [\"waiting for approval\", \"waiting for sentinel override\"].includes(\n    update.type,\n  );\n}\n\nexport type ProjectEvent =\n  | Buffered<ProjectUpdate, \"projectUpdate\">\n  | Buffered<LogMessage, \"logMessage\">;\nexport type CdktfProjectOptions = {\n  synthCommand: string;\n  outDir: string;\n  onUpdate: (update: ProjectUpdate) => void;\n  onLog?: (log: LogMessage) => void;\n  workingDirectory?: string;\n  synthOrigin?: SynthOrigin;\n  hcl?: boolean;\n};\nexport class CdktfProject {\n  public stacks?: SynthesizedStack[];\n  public hardAbort: () => void;\n\n  private synthCommand: string;\n  private outDir: string;\n  private workingDirectory: string;\n  private onUpdate: (update: ProjectUpdate) => void;\n  private onLog?: (log: LogMessage) => void;\n  private abortSignal: AbortSignal;\n  private synthOrigin?: SynthOrigin;\n  private hcl?: boolean;\n\n  // Set during deploy / destroy\n  public stacksToRun: CdktfStack[] = [];\n  // This means sth different in deploy / destroy\n  private stopAllStacksThatCanNotRunWithout: (stackName: string) => void =\n    () => {}; // eslint-disable-line @typescript-eslint/no-empty-function\n\n  private ioHandler: CdktfProjectIOHandler;\n\n  constructor({\n    synthCommand,\n    outDir,\n    onUpdate,\n    onLog,\n    workingDirectory = process.cwd(),\n    synthOrigin,\n    hcl = false,\n  }: CdktfProjectOptions) {\n    this.synthCommand = synthCommand;\n    this.outDir = outDir;\n    this.workingDirectory = workingDirectory;\n    this.onUpdate = onUpdate;\n    this.onLog = onLog;\n    const ac = new AbortController();\n    this.abortSignal = ac.signal;\n    this.synthOrigin = synthOrigin;\n    this.hcl =\n      process.env.SYNTH_HCL_OUTPUT === \"true\" ||\n      process.env.SYNTH_HCL_OUTPUT === \"1\" ||\n      hcl;\n\n    this.hardAbort = ac.abort.bind(ac);\n    this.ioHandler = new CdktfProjectIOHandler();\n  }\n\n  private stopAllStacks() {\n    this.stacksToRun.forEach((stack) => stack.stop());\n    this.ioHandler.filterUserInputEventsFromBuffer();\n  }\n\n  private handleUserUpdate<\n    T extends MultiStackUpdate,\n    V extends StackUserInputUpdate,\n  >(\n    update: StackUserInputUpdate,\n    operations: Record<string, (update: V) => void>,\n    originalCallback: (updateToSend: ProjectUpdate) => void,\n    eventType: T[\"type\"],\n  ) {\n    const callbacks = (update: V) =>\n      Object.fromEntries(\n        Object.entries(operations).map(([key, value]) => {\n          return [\n            key,\n            // This is passed in to make typescript happy only\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            (_: V) => {\n              value(update);\n\n              // We need to defer these calls for the case that approve() is instantly invoked\n              // in the listener that receives these callbacks as it otherwise would already\n              // remove the \"waiting for stack approval\" event from the buffer before we even\n              // set waitingForApproval to true (at the end of this if statement) which results\n              // in buffered updates which will never unblock\n              setTimeout(\n                () => this.ioHandler.resumeAfterUserInput(update.stackName),\n                0,\n              );\n            },\n          ];\n        }),\n      );\n\n    // always send to buffer, as resumeAfterUserInput() always expects a matching event\n    this.ioHandler.pushEvent({\n      cb: originalCallback,\n      value: {\n        type: eventType,\n        stackName: update.stackName,\n        ...callbacks(update as V),\n      } as T,\n      type: \"projectUpdate\",\n    });\n\n    // if we aren't already waiting, this needs to go to cb() too to arrive at the UI\n    if (!this.ioHandler.isWaitingForUserInput()) {\n      originalCallback({\n        type: eventType,\n        stackName: update.stackName,\n        ...callbacks(update as V),\n      } as T);\n    }\n  }\n\n  private handleUserInputProcess(cb: (updateToSend: ProjectUpdate) => void) {\n    return (\n      update:\n        | StackUpdate\n        | StackApprovalUpdate\n        | ExternalStackApprovalUpdate\n        | StackSentinelOverrideUpdate\n        | ExternalStackSentinelOverrideUpdate,\n    ) => {\n      if (update.type === \"external stack approval reply\") {\n        if (!update.approved) {\n          this.stopAllStacksThatCanNotRunWithout(update.stackName);\n        }\n        this.ioHandler.resumeAfterUserInput(update.stackName);\n        return; // aka don't send this event to any buffer\n      }\n      if (update.type === \"external stack sentinel override reply\") {\n        if (!update.overridden) {\n          this.stopAllStacksThatCanNotRunWithout(update.stackName);\n        }\n        this.ioHandler.resumeAfterUserInput(update.stackName);\n        return; // aka don't send this event to any buffer\n      }\n\n      if (\n        update.type === \"waiting for stack approval\" ||\n        update.type === \"waiting for stack sentinel override\"\n      ) {\n        if (update.type === \"waiting for stack approval\") {\n          this.handleUserUpdate<MultiStackApprovalUpdate, StackApprovalUpdate>(\n            update,\n            {\n              approve: (update) => update.approve(),\n              dismiss: (update) => {\n                update.reject();\n                this.stopAllStacksThatCanNotRunWithout(update.stackName);\n              },\n              stop: (update) => {\n                update.reject();\n                this.stopAllStacks();\n              },\n            },\n            cb,\n            \"waiting for approval\",\n          );\n        } else if (update.type === \"waiting for stack sentinel override\") {\n          this.handleUserUpdate<\n            MultiStackSentinelOverrideUpdate,\n            StackSentinelOverrideUpdate\n          >(\n            update,\n            {\n              override: (update) => {\n                update.override();\n              },\n              reject: (update) => {\n                update.reject();\n                this.stopAllStacksThatCanNotRunWithout(update.stackName);\n              },\n            },\n            cb,\n            \"waiting for sentinel override\",\n          );\n        }\n\n        this.ioHandler.awaitUserInput();\n      } else {\n        if (this.ioHandler.isWaitingForUserInput()) {\n          this.ioHandler.pushEvent({\n            cb,\n            value: update,\n            type: \"projectUpdate\",\n          });\n        } else {\n          cb(update as ProjectUpdate);\n        }\n      }\n    };\n  }\n\n  public getStackExecutor(\n    stack: SynthesizedStack,\n    opts: AutoApproveOptions = {},\n  ) {\n    const enhanceLogMessage = createEnhanceLogMessage(stack);\n    const onLog = this.ioHandler.bufferWhileAwaitingUserInput(this.onLog);\n    return new CdktfStack({\n      ...opts,\n      stack,\n      onUpdate: this.handleUserInputProcess(this.onUpdate),\n      onLog: onLog\n        ? ({ message }) =>\n            onLog({\n              stackName: stack.name,\n              message,\n              messageWithConstructPath: enhanceLogMessage(message),\n            })\n        : undefined,\n      abortSignal: this.abortSignal,\n    });\n  }\n\n  public get outputsByConstructId() {\n    return this.stacksToRun.reduce(\n      (acc, stack) => ({\n        ...acc,\n        ...stack.outputsByConstructId,\n      }),\n      {} as NestedTerraformOutputs,\n    );\n  }\n\n  public async synth(noColor?: boolean) {\n    this.onUpdate({\n      type: \"synthesizing\",\n    });\n\n    const stacks = await SynthStack.synth(\n      this.abortSignal as any,\n      this.synthCommand,\n      this.outDir,\n      this.workingDirectory,\n      false,\n      noColor,\n      this.synthOrigin,\n      this.hcl,\n    );\n\n    printAnnotations(stacks);\n\n    this.onUpdate({\n      type: \"synthesized\",\n      stacks,\n    });\n\n    return stacks;\n  }\n\n  public async readSynthesizedStacks() {\n    const stacks = await SynthStack.readSynthesizedStacks(this.outDir);\n\n    printAnnotations(stacks);\n\n    this.onUpdate({\n      type: \"synthesized\",\n      stacks,\n    });\n    return stacks;\n  }\n\n  public async diff(opts: DiffOptions = {}) {\n    const stacks = opts.skipSynth\n      ? await this.readSynthesizedStacks()\n      : await this.synth(opts.noColor);\n    const stack = this.getStackExecutor(\n      getSingleStack(stacks, opts?.stackName, \"diff\"),\n    );\n    await stack.initalizeTerraform(\n      opts.noColor,\n      opts.skipProviderLock,\n      opts.migrateState,\n    );\n\n    try {\n      await stack.diff(opts);\n    } catch (e: any) {\n      throw Errors.External(\n        `Stack failed to plan: ${stack.stack.name}. Please check the logs for more information.`,\n        e,\n      );\n    }\n    if (stack.error) {\n      throw Errors.External(\n        `Stack failed to plan: ${stack.stack.name}. Please check the logs for more information.`,\n        new Error(stack.error),\n      );\n    }\n\n    try {\n      await this.projectTelemetry(\"diff\", {\n        stackMetadata: stacks.map((stack) =>\n          JSON.parse(stack.content)[\"//\"]\n            ? JSON.parse(stack.content)[\"//\"].metadata\n            : {},\n        ),\n        errors: stack.error,\n        requiredProviders: stacks.map((stack: any) =>\n          JSON.parse(stack.content)[\"terraform\"]\n            ? JSON.parse(stack.content)[\"terraform\"].required_providers\n            : {},\n        ),\n      });\n    } catch (e) {\n      logger.debug(\"Failed to send telemetry\", e);\n    }\n  }\n\n  private async execute(\n    method: \"deploy\" | \"destroy\",\n    next: () => Promise<CdktfStack | undefined>,\n    opts: MutationOptions,\n  ) {\n    // We only support refresh only on deploy, a bit of a leaky abstraction here\n    if (opts.refreshOnly && method !== \"deploy\") {\n      throw Errors.Internal(`Refresh only is only supported on deploy`);\n    }\n    const maxParallelRuns =\n      !opts.parallelism || opts.parallelism < 0 ? Infinity : opts.parallelism;\n    const allExecutions = [];\n\n    await this.initializeStacksToRunInSerial(\n      opts.noColor,\n      opts.skipProviderLock,\n      opts.migrateState,\n    );\n    while (this.stacksToRun.filter((stack) => stack.isPending).length > 0) {\n      const runningStacks = this.stacksToRun.filter((stack) => stack.isRunning);\n      if (runningStacks.length >= maxParallelRuns) {\n        await Promise.race(runningStacks.map((s) => s.currentWorkPromise));\n        continue;\n      }\n      try {\n        const nextRunningExecutor = await next();\n        if (!nextRunningExecutor) {\n          // In this case we have no pending stacks, but we also can not find a new executor\n          break;\n        }\n        const promise =\n          method === \"deploy\"\n            ? nextRunningExecutor.deploy(opts)\n            : nextRunningExecutor.destroy(opts);\n\n        allExecutions.push(promise);\n      } catch (e) {\n        // await next() threw an error because a stack failed to apply/destroy\n        // wait for all other currently running stacks to complete before propagating that error\n        logger.debug(\"Encountered an error while awaiting stack to finish\", e);\n        const openStacks = this.stacksToRun.filter(\n          (ex) => ex.currentWorkPromise,\n        );\n        logger.debug(\"Waiting for still running stacks to finish:\", openStacks);\n        await Promise.allSettled(openStacks.map((ex) => ex.currentWorkPromise));\n        logger.debug(\n          \"Done waiting for still running stacks. All pending work finished\",\n        );\n        throw e;\n      }\n    }\n    // We end the loop when all stacks are started, now we need to wait for them to be done\n    // We wait for all work to finish even if one of the promises threw an error.\n    await ensureAllSettledBeforeThrowing(\n      Promise.all(allExecutions),\n      allExecutions,\n    );\n  }\n\n  public async deploy(opts: MutationOptions = {}) {\n    const stacks = opts.skipSynth\n      ? await this.readSynthesizedStacks()\n      : await this.synth(opts.noColor);\n    const stacksToRun = getMultipleStacks(stacks, opts.stackNames, \"deploy\");\n    if (!opts.ignoreMissingStackDependencies) {\n      checkIfAllDependenciesAreIncluded(stacksToRun);\n    }\n\n    this.stopAllStacksThatCanNotRunWithout = (stackName: string) => {\n      findAllNestedDependantStacks(this.stacksToRun, stackName).forEach(\n        (stack) => stack.stop(),\n      );\n    };\n\n    this.stacksToRun = stacksToRun.map((stack) =>\n      this.getStackExecutor(stack, opts),\n    );\n\n    const next = opts.ignoreMissingStackDependencies\n      ? () =>\n          Promise.resolve(\n            this.stacksToRun.filter((stack) => stack.isPending)[0],\n          )\n      : () => getStackWithNoUnmetDependencies(this.stacksToRun);\n\n    await this.execute(\"deploy\", next, opts);\n\n    const unprocessedStacks = this.stacksToRun.filter(\n      (executor) => executor.isPending,\n    );\n    if (unprocessedStacks.length > 0) {\n      throw Errors.External(\n        `Some stacks failed to deploy: ${unprocessedStacks\n          .map((s) => s.stack.name)\n          .join(\", \")}. Please check the logs for more information.`,\n      );\n    }\n\n    try {\n      await this.projectTelemetry(\"deploy\", {\n        stackMetadata: stacksToRun.map((stack) =>\n          JSON.parse(stack.content)[\"//\"]\n            ? JSON.parse(stack.content)[\"//\"].metadata\n            : {},\n        ),\n        failedStacks: unprocessedStacks.map((stack) => stack.error),\n        requiredProviders: stacksToRun.map((stack: any) =>\n          JSON.parse(stack.content)[\"terraform\"]\n            ? JSON.parse(stack.content)[\"terraform\"].required_providers\n            : {},\n        ),\n      });\n    } catch (e) {\n      logger.debug(\"Failed to send telemetry\", e);\n    }\n  }\n\n  public async destroy(opts: MutationOptions = {}) {\n    const stacks = opts.skipSynth\n      ? await this.readSynthesizedStacks()\n      : await this.synth(opts.noColor);\n    const stacksToRun = getMultipleStacks(stacks, opts.stackNames, \"destroy\");\n\n    if (!opts.ignoreMissingStackDependencies) {\n      checkIfAllDependantsAreIncluded(stacksToRun, stacks);\n    }\n\n    this.stopAllStacksThatCanNotRunWithout = (stackName: string) => {\n      const stackExecutor = this.stacksToRun.find(\n        (s) => s.stack.name === stackName,\n      );\n      if (!stackExecutor) {\n        throw Errors.Internal(\n          `Could not find stack \"${stackName}\" that was stopped`,\n        );\n      }\n\n      stackExecutor.stack.dependencies.forEach((dependant) => {\n        this.stopAllStacksThatCanNotRunWithout(dependant);\n\n        const dependantStack = this.stacksToRun.find(\n          (s) => s.stack.name === dependant,\n        );\n        if (!dependantStack) {\n          throw Errors.Internal(\n            `Could not find stack \"${dependant}\" that was stopped`,\n          );\n        }\n\n        dependantStack.stop();\n      });\n    };\n    this.stacksToRun = stacksToRun.map((stack) =>\n      this.getStackExecutor(stack, opts),\n    );\n    const next = opts.ignoreMissingStackDependencies\n      ? () =>\n          Promise.resolve(\n            this.stacksToRun.filter(\n              (stack) => stack.currentState !== \"done\",\n            )[0],\n          )\n      : () => getStackWithNoUnmetDependants(this.stacksToRun);\n\n    await this.execute(\"destroy\", next, opts);\n\n    const unprocessedStacks = this.stacksToRun.filter(\n      (executor) => executor.isPending,\n    );\n    if (unprocessedStacks.length > 0) {\n      throw Errors.External(\n        `Some stacks failed to destroy: ${unprocessedStacks\n          .map((s) => s.stack.name)\n          .join(\", \")}. Please check the logs for more information.`,\n      );\n    }\n\n    try {\n      await this.projectTelemetry(\"destroy\", {\n        stackMetadata: stacksToRun.map((stack) =>\n          JSON.parse(stack.content)[\"//\"]\n            ? JSON.parse(stack.content)[\"//\"].metadata\n            : {},\n        ),\n        failedStacks: unprocessedStacks.map((stack) => stack.error),\n        requiredProviders: stacksToRun.map((stack: any) =>\n          JSON.parse(stack.content)[\"terraform\"]\n            ? JSON.parse(stack.content)[\"terraform\"].required_providers\n            : {},\n        ),\n      });\n    } catch (e) {\n      logger.debug(\"Failed to send telemetry\", e);\n    }\n  }\n\n  public async projectTelemetry(command: string, payload: any): Promise<void> {\n    const config = readConfigSync();\n    await sendTelemetry(command, {\n      ...payload,\n      language: config.language,\n    });\n  }\n\n  public async fetchOutputs(opts: FetchOutputOptions) {\n    const stacks = opts.skipSynth\n      ? await this.readSynthesizedStacks()\n      : await this.synth();\n\n    const stacksToRun = getMultipleStacks(\n      stacks,\n      opts.stackNames || [],\n      \"deploy\",\n    );\n\n    if (stacksToRun.length === 0) {\n      throw new Error(\"No stacks to fetch outputs for specified\");\n    }\n\n    this.stacksToRun = stacksToRun.map((stack) =>\n      // Options are empty, because MultipleStackOptions doesn't have any relevant\n      // options for `getStackExecutor`, hence defaults are fine\n      this.getStackExecutor(stack, {}),\n    );\n\n    await this.initializeStacksToRunInSerial(undefined, opts.skipProviderLock);\n    const outputs = await Promise.all(\n      this.stacksToRun.map(async (s) => {\n        const output = await s.fetchOutputs();\n        return {\n          [s.stack.name]: output,\n        };\n      }),\n    );\n\n    return outputs.reduce(\n      (acc, curr) => ({ ...acc, ...curr }),\n      {},\n    ) as NestedTerraformOutputs;\n  }\n\n  // Serially run terraform init to prohibit text file busy errors for the cache files\n  private async initializeStacksToRunInSerial(\n    noColor?: boolean,\n    skipProviderLock?: boolean,\n    migrateState?: boolean,\n  ): Promise<void> {\n    for (const stack of this.stacksToRun) {\n      await stack.initalizeTerraform(noColor, skipProviderLock, migrateState);\n    }\n  }\n}\n"]}

package/src/lib/cdktf-stack.d.ts

@@ -0,0 +1,134 @@
+import { SynthesizedStack } from "./synth-stack";
+import { Terraform } from "./models/terraform";
+import { NestedTerraformOutputs } from "./output";
+export type StackUpdate = {
+    type: "planning";
+    stackName: string;
+} | {
+    type: "planned";
+    stackName: string;
+} | {
+    type: "deploying";
+    stackName: string;
+} | {
+    type: "deploy update";
+    stackName: string;
+    deployOutput: string;
+} | {
+    type: "deployed";
+    stackName: string;
+    outputsByConstructId: NestedTerraformOutputs;
+    outputs: Record<string, any>;
+} | {
+    type: "destroying";
+    stackName: string;
+} | {
+    type: "destroy update";
+    stackName: string;
+    destroyOutput: string;
+} | {
+    type: "destroyed";
+    stackName: string;
+} | {
+    type: "outputs fetched";
+    stackName: string;
+    outputsByConstructId: NestedTerraformOutputs;
+    outputs: Record<string, any>;
+} | {
+    type: "errored";
+    stackName: string;
+    error: string;
+} | {
+    type: "dismissed";
+    stackName: string;
+} | {
+    type: "import with configuration detected";
+    stackName: string;
+    configuration: string;
+} | {
+    type: "import with configuration converted";
+    stackName: string;
+    configuration: string;
+};
+export type StackUserInputUpdate = StackApprovalUpdate | StackSentinelOverrideUpdate;
+export type StackApprovalUpdate = {
+    type: "waiting for stack approval";
+    stackName: string;
+    approve: () => void;
+    reject: () => void;
+};
+export type StackSentinelOverrideUpdate = {
+    type: "waiting for stack sentinel override";
+    stackName: string;
+    override: () => void;
+    reject: () => void;
+};
+export type ExternalStackApprovalUpdate = {
+    type: "external stack approval reply";
+    stackName: string;
+    approved: boolean;
+};
+export type ExternalStackSentinelOverrideUpdate = {
+    type: "external stack sentinel override reply";
+    stackName: string;
+    overridden: boolean;
+};
+type CdktfStackOptions = {
+    stack: SynthesizedStack;
+    onUpdate: (update: StackUpdate | StackApprovalUpdate | ExternalStackApprovalUpdate | StackSentinelOverrideUpdate | ExternalStackSentinelOverrideUpdate) => void;
+    onLog?: (log: {
+        message: string;
+        isError: boolean;
+    }) => void;
+    autoApprove?: boolean;
+    migrateState?: boolean;
+    abortSignal: AbortSignal;
+};
+type CdktfStackStates = StackUpdate["type"] | StackApprovalUpdate["type"] | StackSentinelOverrideUpdate["type"] | ExternalStackApprovalUpdate["type"] | ExternalStackSentinelOverrideUpdate["type"] | "idle" | "done";
+export declare class CdktfStack {
+    options: CdktfStackOptions;
+    stack: SynthesizedStack;
+    outputs?: Record<string, any>;
+    outputsByConstructId?: NestedTerraformOutputs;
+    stopped: boolean;
+    currentWorkPromise: Promise<void> | undefined;
+    readonly currentState: CdktfStackStates;
+    error?: string;
+    private readonly parsedContent;
+    constructor(options: CdktfStackOptions);
+    get isPending(): boolean;
+    get isDone(): boolean;
+    get isRunning(): boolean;
+    private updateState;
+    private createTerraformLogHandler;
+    private terraformClient;
+    initalizeTerraform(noColor?: boolean, skipProviderLock?: boolean, migrateState?: boolean): Promise<Terraform>;
+    private requiredProviders;
+    private checkNeedsLockfileUpdate;
+    private checkNeedsUpgrade;
+    private run;
+    diff({ refreshOnly, terraformParallelism, vars, varFiles, noColor, }: {
+        refreshOnly?: boolean;
+        terraformParallelism?: number;
+        vars?: string[];
+        varFiles?: string[];
+        noColor?: boolean;
+    }): Promise<void>;
+    deploy(opts: {
+        refreshOnly?: boolean;
+        terraformParallelism?: number;
+        noColor?: boolean;
+        vars?: string[];
+        varFiles?: string[];
+    }): Promise<void>;
+    destroy(opts: {
+        terraformParallelism?: number;
+        vars?: string[];
+        varFiles?: string[];
+        noColor?: boolean;
+    }): Promise<void>;
+    fetchOutputs(): Promise<Record<string, any> | undefined>;
+    stop(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=cdktf-stack.d.ts.map

package/src/lib/cdktf-stack.d.ts.map

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