cdktn 0.26.0-pre.2 → 0.26.0-pre.21

package/lib/synthesize/required-version.d.ts

@@ -0,0 +1,32 @@
+import { IConstruct } from "constructs";
+/**
+ * Checks whether `required_version` should be written from `targetVersions` for the given scope: `targetVersions` is
+ * declared, rather than falling back to the defaults.
+ * @param scope - construct whose context is read, usually a stack
+ * @returns true if the settings files should be written
+ */
+export declare function writesRequiredVersion(scope: IConstruct): boolean;
+/**
+ * Writes a settings file for each product in `targetVersions` into the stack's working directory, in the stack's
+ * output format:
+ *
+ * - A product that isn't targeted gets no file, except that an OpenTofu-only project also writes its OpenTofu
+ *   constraint to the Terraform file, which OpenTofu 1.6 and 1.7 read in place of the OpenTofu file.
+ * - A product whose range allows every version gets a file without `required_version`, so that OpenTofu doesn't
+ *   fall back to the Terraform constraint.
+ * - A range with alternatives (`||`) can't be written as a constraint. It adds a warning, and the Terraform file is
+ *   skipped, or the OpenTofu file is written without `required_version`.
+ * - If targeted OpenTofu releases before 1.8 would be rejected by the Terraform constraint, it adds a warning and
+ *   skips the Terraform file.
+ * @param scope - construct whose `targetVersions` context is read and that receives warnings, usually a stack
+ * @param workingDirectory - absolute path of the stack's working directory
+ * @param hclOutput - whether to write `settings.tf` / `settings.tofu` instead of `settings.tf.json` /
+ * `settings.tofu.json`
+ */
+export declare function writeRequiredVersionFiles(scope: IConstruct, workingDirectory: string, hclOutput: boolean): void;
+/**
+ * Removes the settings files, in either format, written by a previous synth, so they don't outlive a change to
+ * `targetVersions` or the output format.
+ * @param workingDirectory - absolute path of the stack's working directory
+ */
+export declare function removeRequiredVersionFiles(workingDirectory: string): void;

package/lib/synthesize/required-version.js

@@ -0,0 +1,205 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writesRequiredVersion = writesRequiredVersion;
+exports.writeRequiredVersionFiles = writeRequiredVersionFiles;
+exports.removeRequiredVersionFiles = removeRequiredVersionFiles;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const semver = __importStar(require("semver"));
+const annotations_1 = require("../annotations");
+const target_versions_1 = require("../validations/target-versions");
+/**
+ * Names of the files, in the stack's working directory, that hold each product's `required_version`, in the stack's
+ * output format. Terraform reads every `.tf` / `.tf.json` file in the directory and never reads `.tofu` /
+ * `.tofu.json` files. OpenTofu 1.8+ loads the OpenTofu file in place of the Terraform file of the same format, and
+ * OpenTofu 1.12+ only reads `required_version` from `.tofu` / `.tofu.json` files.
+ */
+const SETTINGS_FILES = {
+    json: { terraform: "settings.tf.json", opentofu: "settings.tofu.json" },
+    hcl: { terraform: "settings.tf", opentofu: "settings.tofu" },
+};
+// The first OpenTofu release
+const OPENTOFU_FIRST_RELEASE = "1.6.0";
+// The first OpenTofu release that loads the OpenTofu settings file in place of the Terraform one
+const OPENTOFU_TOFU_FILES_SINCE = "1.8.0";
+/**
+ * Checks whether `required_version` should be written from `targetVersions` for the given scope: `targetVersions` is
+ * declared, rather than falling back to the defaults.
+ * @param scope - construct whose context is read, usually a stack
+ * @returns true if the settings files should be written
+ */
+function writesRequiredVersion(scope) {
+    return scope.node.tryGetContext(target_versions_1.TARGET_VERSIONS_CONTEXT_KEY) !== undefined;
+}
+/**
+ * Converts one comparator set of a normalised npm range into a Terraform version constraint, e.g. the set for `^1.8.0`
+ * into `>= 1.8.0, < 2.0.0`. Terraform's syntax can express any single comparator set, but not alternatives (`||`).
+ * @param comparators - the comparators of a range without alternatives
+ * @returns the Terraform version constraint, or `undefined` when the comparators allow every version
+ */
+function toTerraformConstraint(comparators) {
+    const constraints = comparators
+        .filter((comparator) => comparator.value !== "") // "*" normalises to a comparator that matches any version
+        .map((comparator) => `${comparator.operator || "="} ${constraintVersion(comparator)}`);
+    return constraints.length > 0 ? constraints.join(", ") : undefined;
+}
+/**
+ * Renders a comparator's version for a Terraform constraint. npm writes upper bounds as `<2.0.0-0` so that
+ * prereleases of 2.0.0 are excluded; Terraform's `< 2.0.0` already excludes them, since Terraform only matches a
+ * prerelease when the constraint names one.
+ * @param comparator - one comparator of a normalised npm range
+ * @returns the version to write after the operator
+ */
+function constraintVersion(comparator) {
+    const version = comparator.semver;
+    const isUpperBoundSentinel = comparator.operator === "<" &&
+        version.prerelease.length === 1 &&
+        version.prerelease[0] === 0;
+    return isUpperBoundSentinel
+        ? `${version.major}.${version.minor}.${version.patch}`
+        : version.version;
+}
+/**
+ * Narrows an OpenTofu range to the released versions that read the Terraform settings file: 1.6 and 1.7.
+ * @param opentofu - the project's OpenTofu range
+ * @returns an npm range of the targeted OpenTofu releases that don't load the OpenTofu settings file
+ */
+function opentofuReadingTerraformFile(opentofu) {
+    return new semver.Range(opentofu).set
+        .map((comparators) => [
+        ...comparators.map((comparator) => comparator.value),
+        `>=${OPENTOFU_FIRST_RELEASE}`,
+        `<${OPENTOFU_TOFU_FILES_SINCE}`,
+    ].join(" "))
+        .join(" || ");
+}
+/**
+ * Writes a settings file for each product in `targetVersions` into the stack's working directory, in the stack's
+ * output format:
+ *
+ * - A product that isn't targeted gets no file, except that an OpenTofu-only project also writes its OpenTofu
+ *   constraint to the Terraform file, which OpenTofu 1.6 and 1.7 read in place of the OpenTofu file.
+ * - A product whose range allows every version gets a file without `required_version`, so that OpenTofu doesn't
+ *   fall back to the Terraform constraint.
+ * - A range with alternatives (`||`) can't be written as a constraint. It adds a warning, and the Terraform file is
+ *   skipped, or the OpenTofu file is written without `required_version`.
+ * - If targeted OpenTofu releases before 1.8 would be rejected by the Terraform constraint, it adds a warning and
+ *   skips the Terraform file.
+ * @param scope - construct whose `targetVersions` context is read and that receives warnings, usually a stack
+ * @param workingDirectory - absolute path of the stack's working directory
+ * @param hclOutput - whether to write `settings.tf` / `settings.tofu` instead of `settings.tf.json` /
+ * `settings.tofu.json`
+ */
+function writeRequiredVersionFiles(scope, workingDirectory, hclOutput) {
+    const { targets } = (0, target_versions_1.resolveTargetVersions)(scope);
+    if (!targets) {
+        return;
+    }
+    const files = SETTINGS_FILES[hclOutput ? "hcl" : "json"];
+    const { terraform, opentofu } = targets;
+    const warnAboutAlternatives = (product, range, outcome) => annotations_1.Annotations.of(scope).addWarning(`targetVersions.${product} "${range}" uses "||", which can't be written as a required_version constraint, so ${files[product]} ${outcome}.`);
+    // the constraint to write for each file; a file with an undefined constraint is written without required_version
+    const constraints = new Map();
+    if (opentofu !== undefined) {
+        const comparatorSets = new semver.Range(opentofu).set;
+        if (comparatorSets.length > 1) {
+            warnAboutAlternatives("opentofu", opentofu, "is written without one");
+            constraints.set("opentofu", undefined);
+        }
+        else {
+            constraints.set("opentofu", toTerraformConstraint(comparatorSets[0]));
+        }
+    }
+    if (terraform !== undefined) {
+        const comparatorSets = new semver.Range(terraform).set;
+        if (comparatorSets.length > 1) {
+            warnAboutAlternatives("terraform", terraform, "isn't written");
+        }
+        else if (opentofu !== undefined &&
+            !semver.subset(opentofuReadingTerraformFile(opentofu), terraform)) {
+            annotations_1.Annotations.of(scope).addWarning(`targetVersions.opentofu "${opentofu}" allows OpenTofu releases before ${OPENTOFU_TOFU_FILES_SINCE}, which read ${files.terraform} instead of ${files.opentofu}, and targetVersions.terraform "${terraform}" would reject some of them, so ${files.terraform} isn't written. Set targetVersions.opentofu to ">=${OPENTOFU_TOFU_FILES_SINCE}" or narrower to constrain Terraform as well.`);
+        }
+        else {
+            constraints.set("terraform", toTerraformConstraint(comparatorSets[0]));
+        }
+    }
+    else if (constraints.get("opentofu") !== undefined) {
+        // Terraform isn't targeted, so the Terraform file can carry the OpenTofu constraint for OpenTofu 1.6 and 1.7
+        constraints.set("terraform", constraints.get("opentofu"));
+    }
+    for (const [product, requiredVersion] of constraints) {
+        fs.writeFileSync(path.join(workingDirectory, files[product]), hclOutput
+            ? renderHclSettings(requiredVersion)
+            : renderJsonSettings(requiredVersion));
+    }
+}
+/**
+ * Renders a settings file as Terraform JSON configuration.
+ * @param requiredVersion - the Terraform version constraint, or `undefined` for an empty configuration
+ * @returns the file's content
+ */
+function renderJsonSettings(requiredVersion) {
+    const content = requiredVersion === undefined
+        ? {}
+        : { terraform: { required_version: requiredVersion } };
+    return JSON.stringify(content, null, 2);
+}
+/**
+ * Renders a settings file as HCL.
+ * @param requiredVersion - the Terraform version constraint, or `undefined` for an empty configuration
+ * @returns the file's content
+ */
+function renderHclSettings(requiredVersion) {
+    // a constraint holds only operators, versions, commas and spaces, so a JSON string literal is a valid HCL one
+    return requiredVersion === undefined
+        ? ""
+        : `terraform {\n  required_version = ${JSON.stringify(requiredVersion)}\n}\n`;
+}
+/**
+ * Removes the settings files, in either format, written by a previous synth, so they don't outlive a change to
+ * `targetVersions` or the output format.
+ * @param workingDirectory - absolute path of the stack's working directory
+ */
+function removeRequiredVersionFiles(workingDirectory) {
+    for (const files of Object.values(SETTINGS_FILES)) {
+        for (const file of Object.values(files)) {
+            fs.rmSync(path.join(workingDirectory, file), { force: true });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"required-version.js","sourceRoot":"","sources":["../../src/synthesize/required-version.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\";\nimport * as semver from \"semver\";\nimport { IConstruct } from \"constructs\";\nimport { Annotations } from \"../annotations\";\nimport {\n  resolveTargetVersions,\n  TARGET_VERSIONS_CONTEXT_KEY,\n  TerraformTargetVersions,\n} from \"../validations/target-versions\";\n\ntype Product = keyof TerraformTargetVersions;\n\n/**\n * Names of the files, in the stack's working directory, that hold each product's `required_version`, in the stack's\n * output format. Terraform reads every `.tf` / `.tf.json` file in the directory and never reads `.tofu` /\n * `.tofu.json` files. OpenTofu 1.8+ loads the OpenTofu file in place of the Terraform file of the same format, and\n * OpenTofu 1.12+ only reads `required_version` from `.tofu` / `.tofu.json` files.\n */\nconst SETTINGS_FILES: Record<\"json\" | \"hcl\", Record<Product, string>> = {\n  json: { terraform: \"settings.tf.json\", opentofu: \"settings.tofu.json\" },\n  hcl: { terraform: \"settings.tf\", opentofu: \"settings.tofu\" },\n};\n\n// The first OpenTofu release\nconst OPENTOFU_FIRST_RELEASE = \"1.6.0\";\n\n// The first OpenTofu release that loads the OpenTofu settings file in place of the Terraform one\nconst OPENTOFU_TOFU_FILES_SINCE = \"1.8.0\";\n\n/**\n * Checks whether `required_version` should be written from `targetVersions` for the given scope: `targetVersions` is\n * declared, rather than falling back to the defaults.\n * @param scope - construct whose context is read, usually a stack\n * @returns true if the settings files should be written\n */\nexport function writesRequiredVersion(scope: IConstruct): boolean {\n  return scope.node.tryGetContext(TARGET_VERSIONS_CONTEXT_KEY) !== undefined;\n}\n\n/**\n * Converts one comparator set of a normalised npm range into a Terraform version constraint, e.g. the set for `^1.8.0`\n * into `>= 1.8.0, < 2.0.0`. Terraform's syntax can express any single comparator set, but not alternatives (`||`).\n * @param comparators - the comparators of a range without alternatives\n * @returns the Terraform version constraint, or `undefined` when the comparators allow every version\n */\nfunction toTerraformConstraint(\n  comparators: readonly semver.Comparator[],\n): string | undefined {\n  const constraints = comparators\n    .filter((comparator) => comparator.value !== \"\") // \"*\" normalises to a comparator that matches any version\n    .map(\n      (comparator) =>\n        `${comparator.operator || \"=\"} ${constraintVersion(comparator)}`,\n    );\n  return constraints.length > 0 ? constraints.join(\", \") : undefined;\n}\n\n/**\n * Renders a comparator's version for a Terraform constraint. npm writes upper bounds as `<2.0.0-0` so that\n * prereleases of 2.0.0 are excluded; Terraform's `< 2.0.0` already excludes them, since Terraform only matches a\n * prerelease when the constraint names one.\n * @param comparator - one comparator of a normalised npm range\n * @returns the version to write after the operator\n */\nfunction constraintVersion(comparator: semver.Comparator): string {\n  const version = comparator.semver;\n  const isUpperBoundSentinel =\n    comparator.operator === \"<\" &&\n    version.prerelease.length === 1 &&\n    version.prerelease[0] === 0;\n  return isUpperBoundSentinel\n    ? `${version.major}.${version.minor}.${version.patch}`\n    : version.version;\n}\n\n/**\n * Narrows an OpenTofu range to the released versions that read the Terraform settings file: 1.6 and 1.7.\n * @param opentofu - the project's OpenTofu range\n * @returns an npm range of the targeted OpenTofu releases that don't load the OpenTofu settings file\n */\nfunction opentofuReadingTerraformFile(opentofu: string): string {\n  return new semver.Range(opentofu).set\n    .map((comparators) =>\n      [\n        ...comparators.map((comparator) => comparator.value),\n        `>=${OPENTOFU_FIRST_RELEASE}`,\n        `<${OPENTOFU_TOFU_FILES_SINCE}`,\n      ].join(\" \"),\n    )\n    .join(\" || \");\n}\n\n/**\n * Writes a settings file for each product in `targetVersions` into the stack's working directory, in the stack's\n * output format:\n *\n * - A product that isn't targeted gets no file, except that an OpenTofu-only project also writes its OpenTofu\n *   constraint to the Terraform file, which OpenTofu 1.6 and 1.7 read in place of the OpenTofu file.\n * - A product whose range allows every version gets a file without `required_version`, so that OpenTofu doesn't\n *   fall back to the Terraform constraint.\n * - A range with alternatives (`||`) can't be written as a constraint. It adds a warning, and the Terraform file is\n *   skipped, or the OpenTofu file is written without `required_version`.\n * - If targeted OpenTofu releases before 1.8 would be rejected by the Terraform constraint, it adds a warning and\n *   skips the Terraform file.\n * @param scope - construct whose `targetVersions` context is read and that receives warnings, usually a stack\n * @param workingDirectory - absolute path of the stack's working directory\n * @param hclOutput - whether to write `settings.tf` / `settings.tofu` instead of `settings.tf.json` /\n * `settings.tofu.json`\n */\nexport function writeRequiredVersionFiles(\n  scope: IConstruct,\n  workingDirectory: string,\n  hclOutput: boolean,\n): void {\n  const { targets } = resolveTargetVersions(scope);\n  if (!targets) {\n    return;\n  }\n\n  const files = SETTINGS_FILES[hclOutput ? \"hcl\" : \"json\"];\n  const { terraform, opentofu } = targets;\n  const warnAboutAlternatives = (\n    product: Product,\n    range: string,\n    outcome: string,\n  ) =>\n    Annotations.of(scope).addWarning(\n      `targetVersions.${product} \"${range}\" uses \"||\", which can't be written as a required_version constraint, so ${files[product]} ${outcome}.`,\n    );\n\n  // the constraint to write for each file; a file with an undefined constraint is written without required_version\n  const constraints = new Map<Product, string | undefined>();\n\n  if (opentofu !== undefined) {\n    const comparatorSets = new semver.Range(opentofu).set;\n    if (comparatorSets.length > 1) {\n      warnAboutAlternatives(\"opentofu\", opentofu, \"is written without one\");\n      constraints.set(\"opentofu\", undefined);\n    } else {\n      constraints.set(\"opentofu\", toTerraformConstraint(comparatorSets[0]));\n    }\n  }\n\n  if (terraform !== undefined) {\n    const comparatorSets = new semver.Range(terraform).set;\n    if (comparatorSets.length > 1) {\n      warnAboutAlternatives(\"terraform\", terraform, \"isn't written\");\n    } else if (\n      opentofu !== undefined &&\n      !semver.subset(opentofuReadingTerraformFile(opentofu), terraform)\n    ) {\n      Annotations.of(scope).addWarning(\n        `targetVersions.opentofu \"${opentofu}\" allows OpenTofu releases before ${OPENTOFU_TOFU_FILES_SINCE}, which read ${files.terraform} instead of ${files.opentofu}, and targetVersions.terraform \"${terraform}\" would reject some of them, so ${files.terraform} isn't written. Set targetVersions.opentofu to \">=${OPENTOFU_TOFU_FILES_SINCE}\" or narrower to constrain Terraform as well.`,\n      );\n    } else {\n      constraints.set(\"terraform\", toTerraformConstraint(comparatorSets[0]));\n    }\n  } else if (constraints.get(\"opentofu\") !== undefined) {\n    // Terraform isn't targeted, so the Terraform file can carry the OpenTofu constraint for OpenTofu 1.6 and 1.7\n    constraints.set(\"terraform\", constraints.get(\"opentofu\"));\n  }\n\n  for (const [product, requiredVersion] of constraints) {\n    fs.writeFileSync(\n      path.join(workingDirectory, files[product]),\n      hclOutput\n        ? renderHclSettings(requiredVersion)\n        : renderJsonSettings(requiredVersion),\n    );\n  }\n}\n\n/**\n * Renders a settings file as Terraform JSON configuration.\n * @param requiredVersion - the Terraform version constraint, or `undefined` for an empty configuration\n * @returns the file's content\n */\nfunction renderJsonSettings(requiredVersion: string | undefined): string {\n  const content =\n    requiredVersion === undefined\n      ? {}\n      : { terraform: { required_version: requiredVersion } };\n  return JSON.stringify(content, null, 2);\n}\n\n/**\n * Renders a settings file as HCL.\n * @param requiredVersion - the Terraform version constraint, or `undefined` for an empty configuration\n * @returns the file's content\n */\nfunction renderHclSettings(requiredVersion: string | undefined): string {\n  // a constraint holds only operators, versions, commas and spaces, so a JSON string literal is a valid HCL one\n  return requiredVersion === undefined\n    ? \"\"\n    : `terraform {\\n  required_version = ${JSON.stringify(requiredVersion)}\\n}\\n`;\n}\n\n/**\n * Removes the settings files, in either format, written by a previous synth, so they don't outlive a change to\n * `targetVersions` or the output format.\n * @param workingDirectory - absolute path of the stack's working directory\n */\nexport function removeRequiredVersionFiles(workingDirectory: string): void {\n  for (const files of Object.values(SETTINGS_FILES)) {\n    for (const file of Object.values(files)) {\n      fs.rmSync(path.join(workingDirectory, file), { force: true });\n    }\n  }\n}\n"]}

package/lib/synthesize/synthesizer.d.ts

@@ -1,6 +1,10 @@
 import { TerraformStack } from "../terraform-stack";
 import { IStackSynthesizer, ISynthesisSession } from "./types";
 import { IConstruct } from "constructs";
+/**
+ * Default stack synthesizer: invokes aspects, runs validations, collects annotations into the manifest and writes
+ * the stack's Terraform configuration (JSON or HCL) to its working directory.
+ */
 export declare class StackSynthesizer implements IStackSynthesizer {
     protected stack: TerraformStack;
     private continueOnErrorAnnotations;
@@ -10,6 +14,9 @@ export declare class StackSynthesizer implements IStackSynthesizer {
      * @param continueOnErrorAnnotations if set to true, `synthesize()` will not throw an error
      * if it encounters an error Annotation. However, it will still add all errors to the manifest
      * file. The cdktn-cli uses this flag to print the errors itself.
+     * @param hclOutput if set to true, the stack is always written as HCL.
+     * Otherwise it is written as HCL when the manifest names the stack file
+     * `cdk.tf`, which follows `App`'s `hclOutput` and `SYNTH_HCL_OUTPUT`.
      */
     constructor(stack: TerraformStack, continueOnErrorAnnotations?: boolean, hclOutput?: boolean);
     synthesize(session: ISynthesisSession): void;
@@ -32,4 +39,10 @@ export interface ICustomSynthesis {
      */
     onSynthesize(session: ISynthesisSession): void;
 }
+/**
+ * Attaches custom synthesis logic to a construct; its `onSynthesize` is called when the containing stack is
+ * synthesized
+ * @param construct Construct to attach the custom synthesis to
+ * @param synthesis Custom synthesis to run for the construct
+ */
 export declare function addCustomSynthesis(construct: IConstruct, synthesis: ICustomSynthesis): void;

package/lib/synthesize/synthesizer.js

@@ -49,7 +49,11 @@ const constructs_1 = require("constructs");
 const aspect_1 = require("../aspect");
 const target_versions_1 = require("../validations/target-versions");
 const errors_1 = require("../errors");
-// eslint-disable-next-line jsdoc/require-jsdoc
+const required_version_1 = require("./required-version");
+/**
+ * Default stack synthesizer: invokes aspects, runs validations, collects annotations into the manifest and writes
+ * the stack's Terraform configuration (JSON or HCL) to its working directory.
+ */
 class StackSynthesizer {
     stack;
     continueOnErrorAnnotations;
@@ -59,6 +63,9 @@ class StackSynthesizer {
      * @param continueOnErrorAnnotations if set to true, `synthesize()` will not throw an error
      * if it encounters an error Annotation. However, it will still add all errors to the manifest
      * file. The cdktn-cli uses this flag to print the errors itself.
+     * @param hclOutput if set to true, the stack is always written as HCL.
+     * Otherwise it is written as HCL when the manifest names the stack file
+     * `cdk.tf`, which follows `App`'s `hclOutput` and `SYNTH_HCL_OUTPUT`.
      */
     constructor(stack, continueOnErrorAnnotations = false, hclOutput = false) {
         this.stack = stack;
@@ -87,6 +94,10 @@ class StackSynthesizer {
         const workingDirectory = path.join(session.outdir, stackManifest.workingDirectory);
         if (!fs.existsSync(workingDirectory))
             fs.mkdirSync(workingDirectory);
+        (0, required_version_1.removeRequiredVersionFiles)(workingDirectory);
+        if ((0, required_version_1.writesRequiredVersion)(this.stack)) {
+            (0, required_version_1.writeRequiredVersionFiles)(this.stack, workingDirectory, this.hclOutput);
+        }
         // call custom synthesis on child nodes (leafs first)
         this.stack.node
             .findAll(constructs_1.ConstructOrder.POSTORDER)
@@ -115,7 +126,8 @@ class StackSynthesizer {
                 .map((a) => `[${a.constructPath}] ${a.message}`)
                 .join("\n"));
         }
-        if (this.hclOutput) {
+        // The manifest names the stack file, so it also decides its format.
+        if (this.hclOutput || manifest.hclOutput) {
             const hcl = this.stack.toHclTerraform();
             fs.writeFileSync(path.join(session.outdir, stackManifest.synthesizedStackPath), hcl.hcl);
             fs.writeFileSync(path.join(session.outdir, stackManifest.stackMetadataPath), (0, safe_stable_stringify_1.default)(hcl.metadata, null, 2));
@@ -135,7 +147,12 @@ function invokeAspects(root) {
     const invokedByPath = {};
     let nestedAspectWarning = false;
     recurse(root, []);
-    // eslint-disable-next-line jsdoc/require-jsdoc
+    /**
+     * Invokes inherited and own aspects on the construct, skipping any already invoked on it, then recurses into its
+     * children
+     * @param construct Construct to visit
+     * @param inheritedAspects Aspects applied to the construct's ancestors
+     */
     function recurse(construct, inheritedAspects) {
         const node = construct.node;
         const aspects = aspect_1.Aspects.of(construct);
@@ -169,25 +186,42 @@ const annotationMetadataEntryTypes = [
     annotations_1.AnnotationMetadataEntryType.WARN,
     annotations_1.AnnotationMetadataEntryType.ERROR,
 ];
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Determines if the metadata entry is an info, warning or error annotation
+ * @param metadata Metadata entry to test
+ * @returns Boolean
+ */
 function isAnnotationMetadata(metadata) {
     return annotationMetadataEntryTypes.includes(metadata.type);
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Determines if the annotation has error level
+ * @param annotation Annotation to test
+ * @returns Boolean
+ */
 function isErrorAnnotation(annotation) {
     return annotation.level === annotations_1.AnnotationMetadataEntryType.ERROR;
 }
 // originally from https://github.com/aws/aws-cdk/blob/dcae3eead0dbf9acb1ed80ba95bb104c64cb1bd7/packages/%40aws-cdk/core/lib/private/synthesis.ts#L52
 const CUSTOM_SYNTHESIS_SYM = Symbol.for("cdktf/customSynthesis");
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Attaches custom synthesis logic to a construct; its `onSynthesize` is called when the containing stack is
+ * synthesized
+ * @param construct Construct to attach the custom synthesis to
+ * @param synthesis Custom synthesis to run for the construct
+ */
 function addCustomSynthesis(construct, synthesis) {
     Object.defineProperty(construct, CUSTOM_SYNTHESIS_SYM, {
         value: synthesis,
         enumerable: false,
     });
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Returns the custom synthesis attached to a construct via addCustomSynthesis
+ * @param construct Construct to read the custom synthesis from
+ * @returns The attached custom synthesis, or undefined if none is attached
+ */
 function getCustomSynthesis(construct) {
     return construct[CUSTOM_SYNTHESIS_SYM];
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synthesizer.js","sourceRoot":"","sources":["../../src/synthesize/synthesizer.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\";\nimport stringify from \"safe-stable-stringify\";\nimport { TerraformStack } from \"../terraform-stack\";\nimport { IStackSynthesizer, ISynthesisSession } from \"./types\";\nimport { AnnotationMetadataEntryType, Annotations } from \"../annotations\";\nimport { ConstructOrder, IConstruct, MetadataEntry } from \"constructs\";\nimport { Aspects, IAspect } from \"../aspect\";\nimport { StackAnnotation } from \"../manifest\";\nimport { ValidateFeatureTargetSupport } from \"../validations/target-versions\";\nimport { encounteredAnnotationWithLevelError } from \"../errors\";\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport class StackSynthesizer implements IStackSynthesizer {\n  /**\n   * @param stack the stack to synthesize\n   * @param continueOnErrorAnnotations if set to true, `synthesize()` will not throw an error\n   * if it encounters an error Annotation. However, it will still add all errors to the manifest\n   * file. The cdktn-cli uses this flag to print the errors itself.\n   */\n  constructor(\n    protected stack: TerraformStack,\n    private continueOnErrorAnnotations = false,\n    private hclOutput = false,\n  ) {}\n\n  synthesize(session: ISynthesisSession) {\n    invokeAspects(this.stack);\n\n    if (!session.stacksPrepared) {\n      // Sessions not built by App.synth() arrive unprepared: prepare this\n      // stack so stale provider-feature and function usage is cleared and\n      // rediscovered before validations run (ISynthesisSession.stacksPrepared).\n      this.stack.prepareStack();\n    }\n\n    if (this.stack.hasResourceMove()) {\n      this.stack.node.addValidation(\n        new ValidateFeatureTargetSupport(this.stack, \"The moved block\", {\n          terraform: \">=1.5.0\",\n          opentofu: \">=1.6.0\",\n        }),\n      );\n    }\n\n    if (!session.skipValidation) {\n      this.stack.runAllValidations();\n    }\n\n    const manifest = session.manifest;\n    const stackManifest = manifest.forStack(this.stack);\n\n    const workingDirectory = path.join(\n      session.outdir,\n      stackManifest.workingDirectory,\n    );\n    if (!fs.existsSync(workingDirectory)) fs.mkdirSync(workingDirectory);\n\n    // call custom synthesis on child nodes (leafs first)\n    this.stack.node\n      .findAll(ConstructOrder.POSTORDER)\n      .forEach((node) => getCustomSynthesis(node)?.onSynthesize(session));\n\n    // collect Annotations into Manifest\n    const annotations = this.stack.node\n      .findAll()\n      .map((node) => ({\n        node,\n        metadatas: node.node.metadata.filter(isAnnotationMetadata),\n      }))\n      .map<StackAnnotation[]>(({ node, metadatas }) =>\n        metadatas.map((metadata) => ({\n          constructPath: node.node.path,\n          level: metadata.type as AnnotationMetadataEntryType,\n          message: metadata.data,\n          stacktrace: metadata.trace,\n        })),\n      )\n      .reduce((list, metadatas) => [...list, ...metadatas], []); // Array.flat()\n\n    // it is readonly but this is the place where we are allowed to write to it\n    (stackManifest.annotations as any) = annotations;\n\n    // abort if one or more error annotations have been encountered\n    if (\n      !this.continueOnErrorAnnotations &&\n      annotations.some(isErrorAnnotation)\n    ) {\n      throw encounteredAnnotationWithLevelError(\n        annotations\n          .filter(isErrorAnnotation)\n          .map((a) => `[${a.constructPath}] ${a.message}`)\n          .join(\"\\n\"),\n      );\n    }\n\n    if (this.hclOutput) {\n      const hcl = this.stack.toHclTerraform();\n      fs.writeFileSync(\n        path.join(session.outdir, stackManifest.synthesizedStackPath),\n        hcl.hcl,\n      );\n\n      fs.writeFileSync(\n        path.join(session.outdir, stackManifest.stackMetadataPath!),\n        stringify(hcl.metadata, null, 2) as string,\n      );\n\n      return;\n    }\n\n    const jsonTfConfig = this.stack.toTerraform();\n\n    fs.writeFileSync(\n      path.join(session.outdir, stackManifest.synthesizedStackPath),\n      stringify(jsonTfConfig, null, 2) as string,\n    );\n  }\n}\n\n/**\n * Invoke aspects on the given construct tree.\n *\n * originally from https://github.com/aws/aws-cdk/blob/dcae3eead0dbf9acb1ed80ba95bb104c64cb1bd7/packages/@aws-cdk/core/lib/private/synthesis.ts#L99-L137\n */\nexport function invokeAspects(root: IConstruct) {\n  const invokedByPath: { [nodePath: string]: IAspect[] } = {};\n\n  let nestedAspectWarning = false;\n  recurse(root, []);\n\n  // eslint-disable-next-line jsdoc/require-jsdoc\n  function recurse(construct: IConstruct, inheritedAspects: IAspect[]) {\n    const node = construct.node;\n    const aspects = Aspects.of(construct);\n    const allAspectsHere = [...(inheritedAspects ?? []), ...aspects.all];\n    const nodeAspectsCount = aspects.all.length;\n    for (const aspect of allAspectsHere) {\n      let invoked = invokedByPath[node.path];\n      if (!invoked) {\n        invoked = invokedByPath[node.path] = [];\n      }\n\n      if (invoked.includes(aspect)) {\n        continue;\n      }\n\n      aspect.visit(construct);\n\n      // if an aspect was added to the node while invoking another aspect it will not be invoked, emit a warning\n      // the `nestedAspectWarning` flag is used to prevent the warning from being emitted for every child\n      if (!nestedAspectWarning && nodeAspectsCount !== aspects.all.length) {\n        Annotations.of(construct).addWarning(\n          \"We detected an Aspect was added via another Aspect, and will not be applied\",\n        );\n        nestedAspectWarning = true;\n      }\n\n      // mark as invoked for this node\n      invoked.push(aspect);\n    }\n\n    for (const child of construct.node.children) {\n      recurse(child, allAspectsHere);\n    }\n  }\n}\n\nconst annotationMetadataEntryTypes = [\n  AnnotationMetadataEntryType.INFO,\n  AnnotationMetadataEntryType.WARN,\n  AnnotationMetadataEntryType.ERROR,\n] as string[];\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction isAnnotationMetadata(metadata: MetadataEntry): boolean {\n  return annotationMetadataEntryTypes.includes(metadata.type);\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction isErrorAnnotation(annotation: StackAnnotation): boolean {\n  return annotation.level === AnnotationMetadataEntryType.ERROR;\n}\n\n// originally from https://github.com/aws/aws-cdk/blob/dcae3eead0dbf9acb1ed80ba95bb104c64cb1bd7/packages/%40aws-cdk/core/lib/private/synthesis.ts#L52\nconst CUSTOM_SYNTHESIS_SYM = Symbol.for(\"cdktf/customSynthesis\");\n\n/**\n * Interface for constructs that want to do something custom during synthesis\n *\n * This feature is intended for use by the CDKTN only; 3rd party\n * library authors and CDK users should not use this function.\n */\nexport interface ICustomSynthesis {\n  /**\n   * Called when the construct is synthesized\n   */\n  onSynthesize(session: ISynthesisSession): void;\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function addCustomSynthesis(\n  construct: IConstruct,\n  synthesis: ICustomSynthesis,\n): void {\n  Object.defineProperty(construct, CUSTOM_SYNTHESIS_SYM, {\n    value: synthesis,\n    enumerable: false,\n  });\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction getCustomSynthesis(\n  construct: IConstruct,\n): ICustomSynthesis | undefined {\n  return (construct as any)[CUSTOM_SYNTHESIS_SYM];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synthesizer.js","sourceRoot":"","sources":["../../src/synthesize/synthesizer.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\";\nimport stringify from \"safe-stable-stringify\";\nimport { TerraformStack } from \"../terraform-stack\";\nimport { IStackSynthesizer, ISynthesisSession } from \"./types\";\nimport { AnnotationMetadataEntryType, Annotations } from \"../annotations\";\nimport { ConstructOrder, IConstruct, MetadataEntry } from \"constructs\";\nimport { Aspects, IAspect } from \"../aspect\";\nimport { StackAnnotation } from \"../manifest\";\nimport { ValidateFeatureTargetSupport } from \"../validations/target-versions\";\nimport { encounteredAnnotationWithLevelError } from \"../errors\";\nimport {\n  removeRequiredVersionFiles,\n  writeRequiredVersionFiles,\n  writesRequiredVersion,\n} from \"./required-version\";\n\n/**\n * Default stack synthesizer: invokes aspects, runs validations, collects annotations into the manifest and writes\n * the stack's Terraform configuration (JSON or HCL) to its working directory.\n */\nexport class StackSynthesizer implements IStackSynthesizer {\n  /**\n   * @param stack the stack to synthesize\n   * @param continueOnErrorAnnotations if set to true, `synthesize()` will not throw an error\n   * if it encounters an error Annotation. However, it will still add all errors to the manifest\n   * file. The cdktn-cli uses this flag to print the errors itself.\n   * @param hclOutput if set to true, the stack is always written as HCL.\n   * Otherwise it is written as HCL when the manifest names the stack file\n   * `cdk.tf`, which follows `App`'s `hclOutput` and `SYNTH_HCL_OUTPUT`.\n   */\n  constructor(\n    protected stack: TerraformStack,\n    private continueOnErrorAnnotations = false,\n    private hclOutput = false,\n  ) {}\n\n  synthesize(session: ISynthesisSession) {\n    invokeAspects(this.stack);\n\n    if (!session.stacksPrepared) {\n      // Sessions not built by App.synth() arrive unprepared: prepare this\n      // stack so stale provider-feature and function usage is cleared and\n      // rediscovered before validations run (ISynthesisSession.stacksPrepared).\n      this.stack.prepareStack();\n    }\n\n    if (this.stack.hasResourceMove()) {\n      this.stack.node.addValidation(\n        new ValidateFeatureTargetSupport(this.stack, \"The moved block\", {\n          terraform: \">=1.5.0\",\n          opentofu: \">=1.6.0\",\n        }),\n      );\n    }\n\n    if (!session.skipValidation) {\n      this.stack.runAllValidations();\n    }\n\n    const manifest = session.manifest;\n    const stackManifest = manifest.forStack(this.stack);\n\n    const workingDirectory = path.join(\n      session.outdir,\n      stackManifest.workingDirectory,\n    );\n    if (!fs.existsSync(workingDirectory)) fs.mkdirSync(workingDirectory);\n\n    removeRequiredVersionFiles(workingDirectory);\n    if (writesRequiredVersion(this.stack)) {\n      writeRequiredVersionFiles(this.stack, workingDirectory, this.hclOutput);\n    }\n\n    // call custom synthesis on child nodes (leafs first)\n    this.stack.node\n      .findAll(ConstructOrder.POSTORDER)\n      .forEach((node) => getCustomSynthesis(node)?.onSynthesize(session));\n\n    // collect Annotations into Manifest\n    const annotations = this.stack.node\n      .findAll()\n      .map((node) => ({\n        node,\n        metadatas: node.node.metadata.filter(isAnnotationMetadata),\n      }))\n      .map<StackAnnotation[]>(({ node, metadatas }) =>\n        metadatas.map((metadata) => ({\n          constructPath: node.node.path,\n          level: metadata.type as AnnotationMetadataEntryType,\n          message: metadata.data,\n          stacktrace: metadata.trace,\n        })),\n      )\n      .reduce((list, metadatas) => [...list, ...metadatas], []); // Array.flat()\n\n    // it is readonly but this is the place where we are allowed to write to it\n    (stackManifest.annotations as any) = annotations;\n\n    // abort if one or more error annotations have been encountered\n    if (\n      !this.continueOnErrorAnnotations &&\n      annotations.some(isErrorAnnotation)\n    ) {\n      throw encounteredAnnotationWithLevelError(\n        annotations\n          .filter(isErrorAnnotation)\n          .map((a) => `[${a.constructPath}] ${a.message}`)\n          .join(\"\\n\"),\n      );\n    }\n\n    // The manifest names the stack file, so it also decides its format.\n    if (this.hclOutput || manifest.hclOutput) {\n      const hcl = this.stack.toHclTerraform();\n      fs.writeFileSync(\n        path.join(session.outdir, stackManifest.synthesizedStackPath),\n        hcl.hcl,\n      );\n\n      fs.writeFileSync(\n        path.join(session.outdir, stackManifest.stackMetadataPath!),\n        stringify(hcl.metadata, null, 2) as string,\n      );\n\n      return;\n    }\n\n    const jsonTfConfig = this.stack.toTerraform();\n\n    fs.writeFileSync(\n      path.join(session.outdir, stackManifest.synthesizedStackPath),\n      stringify(jsonTfConfig, null, 2) as string,\n    );\n  }\n}\n\n/**\n * Invoke aspects on the given construct tree.\n *\n * originally from https://github.com/aws/aws-cdk/blob/dcae3eead0dbf9acb1ed80ba95bb104c64cb1bd7/packages/@aws-cdk/core/lib/private/synthesis.ts#L99-L137\n */\nexport function invokeAspects(root: IConstruct) {\n  const invokedByPath: { [nodePath: string]: IAspect[] } = {};\n\n  let nestedAspectWarning = false;\n  recurse(root, []);\n\n  /**\n   * Invokes inherited and own aspects on the construct, skipping any already invoked on it, then recurses into its\n   * children\n   * @param construct Construct to visit\n   * @param inheritedAspects Aspects applied to the construct's ancestors\n   */\n  function recurse(construct: IConstruct, inheritedAspects: IAspect[]) {\n    const node = construct.node;\n    const aspects = Aspects.of(construct);\n    const allAspectsHere = [...(inheritedAspects ?? []), ...aspects.all];\n    const nodeAspectsCount = aspects.all.length;\n    for (const aspect of allAspectsHere) {\n      let invoked = invokedByPath[node.path];\n      if (!invoked) {\n        invoked = invokedByPath[node.path] = [];\n      }\n\n      if (invoked.includes(aspect)) {\n        continue;\n      }\n\n      aspect.visit(construct);\n\n      // if an aspect was added to the node while invoking another aspect it will not be invoked, emit a warning\n      // the `nestedAspectWarning` flag is used to prevent the warning from being emitted for every child\n      if (!nestedAspectWarning && nodeAspectsCount !== aspects.all.length) {\n        Annotations.of(construct).addWarning(\n          \"We detected an Aspect was added via another Aspect, and will not be applied\",\n        );\n        nestedAspectWarning = true;\n      }\n\n      // mark as invoked for this node\n      invoked.push(aspect);\n    }\n\n    for (const child of construct.node.children) {\n      recurse(child, allAspectsHere);\n    }\n  }\n}\n\nconst annotationMetadataEntryTypes = [\n  AnnotationMetadataEntryType.INFO,\n  AnnotationMetadataEntryType.WARN,\n  AnnotationMetadataEntryType.ERROR,\n] as string[];\n\n/**\n * Determines if the metadata entry is an info, warning or error annotation\n * @param metadata Metadata entry to test\n * @returns Boolean\n */\nfunction isAnnotationMetadata(metadata: MetadataEntry): boolean {\n  return annotationMetadataEntryTypes.includes(metadata.type);\n}\n\n/**\n * Determines if the annotation has error level\n * @param annotation Annotation to test\n * @returns Boolean\n */\nfunction isErrorAnnotation(annotation: StackAnnotation): boolean {\n  return annotation.level === AnnotationMetadataEntryType.ERROR;\n}\n\n// originally from https://github.com/aws/aws-cdk/blob/dcae3eead0dbf9acb1ed80ba95bb104c64cb1bd7/packages/%40aws-cdk/core/lib/private/synthesis.ts#L52\nconst CUSTOM_SYNTHESIS_SYM = Symbol.for(\"cdktf/customSynthesis\");\n\n/**\n * Interface for constructs that want to do something custom during synthesis\n *\n * This feature is intended for use by the CDKTN only; 3rd party\n * library authors and CDK users should not use this function.\n */\nexport interface ICustomSynthesis {\n  /**\n   * Called when the construct is synthesized\n   */\n  onSynthesize(session: ISynthesisSession): void;\n}\n\n/**\n * Attaches custom synthesis logic to a construct; its `onSynthesize` is called when the containing stack is\n * synthesized\n * @param construct Construct to attach the custom synthesis to\n * @param synthesis Custom synthesis to run for the construct\n */\nexport function addCustomSynthesis(\n  construct: IConstruct,\n  synthesis: ICustomSynthesis,\n): void {\n  Object.defineProperty(construct, CUSTOM_SYNTHESIS_SYM, {\n    value: synthesis,\n    enumerable: false,\n  });\n}\n\n/**\n * Returns the custom synthesis attached to a construct via addCustomSynthesis\n * @param construct Construct to read the custom synthesis from\n * @returns The attached custom synthesis, or undefined if none is attached\n */\nfunction getCustomSynthesis(\n  construct: IConstruct,\n): ICustomSynthesis | undefined {\n  return (construct as any)[CUSTOM_SYNTHESIS_SYM];\n}\n"]}

package/lib/terraform-asset.d.ts

@@ -66,6 +66,10 @@ export declare enum AssetType {
     DIRECTORY = 1,
     ARCHIVE = 2
 }
+/**
+ * A local file or directory that is hashed and copied into the stack's output directory at synthesis, optionally
+ * built by a bundler and packaged as an archive, so other resources can reference it by path.
+ */
 export declare class TerraformAsset extends Construct implements IAsset {
     private stack;
     private sourcePath;

package/lib/terraform-asset.js

@@ -72,9 +72,12 @@ const PACKAGING_BY_TYPE = {
     [AssetType.DIRECTORY]: assets_1.AssetPackaging.DIRECTORY,
     [AssetType.ARCHIVE]: assets_1.AssetPackaging.ZIP,
 };
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * A local file or directory that is hashed and copied into the stack's output directory at synthesis, optionally
+ * built by a bundler and packaged as an archive, so other resources can reference it by path.
+ */
 class TerraformAsset extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.TerraformAsset", version: "0.26.0-pre.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.TerraformAsset", version: "0.26.0-pre.21" };
     stack;
     sourcePath;
     // hash value of the asset that can be passed to consuming constructs (e.g. to not recreate a lambda function in case the underlying files did not change)
@@ -210,4 +213,4 @@ class TerraformAsset extends constructs_1.Construct {
     }
 }
 exports.TerraformAsset = TerraformAsset;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terraform-asset.js","sourceRoot":"","sources":["../src/terraform-asset.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { Construct } from \"constructs\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport {\n  AssetPackaging,\n  AssetHashType,\n  IAsset,\n  IAssetBundler,\n  IAssetPackaging,\n} from \"./assets\";\nimport { AssetStaging } from \"./asset-staging\";\nimport { IIgnoreStrategy } from \"./ignore-strategy\";\nimport { findFileAboveCwd } from \"./private/fs\";\nimport { ISynthesisSession } from \"./synthesize\";\nimport { addCustomSynthesis } from \"./synthesize/synthesizer\";\nimport { TerraformStack } from \"./terraform-stack\";\nimport {\n  assetBundlerOutputFileNameInvalid,\n  assetExpectsDirectory,\n  assetOutOfScopeOfCDKTFJson,\n  assetStagingBundlerFileOutputNeedsFilePackaging,\n  assetTypeNotImplemented,\n} from \"./errors\";\n\nexport interface TerraformAssetConfig {\n  // path to the file or folder configured. If relative, the path is resolved from the location of cdktf.json\n  readonly path: string;\n  // file type of the asset, either AssetType.FILE, AssetType.DIRECTORY, AssetType.ARCHIVE\n  readonly type?: AssetType;\n  // hash value of the asset, if passed will be used as returned assetHash\n  readonly assetHash?: string;\n  /**\n   * How the `assetHash` is derived.\n   *\n   * `SOURCE` (the default) hashes the source path. `CUSTOM` uses the\n   * `assetHash` value verbatim and requires it to be set. `OUTPUT` hashes the\n   * source too, unless a `bundler` is set — then it hashes the bundler's\n   * built output, which forces an eager build (see `bundler`).\n   *\n   * If `assetHash` is set, this must be `undefined` or `AssetHashType.CUSTOM`.\n   *\n   * @default AssetHashType.SOURCE\n   */\n  readonly assetHashType?: AssetHashType;\n\n  /**\n   * Paths to exclude from the asset, relative to `path`. See\n   * `AssetStagingOptions.exclude` for the accepted forms. Both the computed\n   * hash and the staged/packed content honor the exclusion. Cannot be\n   * combined with `ignoreStrategy`, which replaces this matcher rather than\n   * layering on top of it.\n   *\n   * @default - nothing is excluded\n   */\n  readonly exclude?: string[];\n\n  /**\n   * Exclusion matching, for callers that need `.gitignore` / `.dockerignore`\n   * parity (including `!`-negation) rather than the built-in exact-path /\n   * suffix / directory matcher. See `AssetStagingOptions.ignoreStrategy`.\n   *\n   * `!`-negation only takes effect if the strategy also sets\n   * `pruneExcludedDirectories: false`; otherwise an excluded directory is\n   * pruned before its contents are ever checked against a re-include\n   * pattern. See `IIgnoreStrategy.pruneExcludedDirectories`.\n   *\n   * @default - `exclude` is used with the built-in matcher\n   */\n  readonly ignoreStrategy?: IIgnoreStrategy;\n\n  /**\n   * Extra information to fold into the hash (e.g. build instructions and\n   * other inputs).\n   *\n   * @default - no extra hash\n   */\n  readonly extraHash?: string;\n\n  /**\n   * A bundler that builds the source into an artifact before staging.\n   *\n   * Core ships no bundler; implement `IAssetBundler` or use one from a bundler\n   * package. Under the default `SOURCE` hashing the build is deferred to synth\n   * and stays skippable; `OUTPUT` hashing builds eagerly to hash the artifact.\n   * The bundler's output shape must match `type`. See\n   * `AssetStagingOptions.bundler`.\n   *\n   * @default - the source is staged verbatim, with no build step\n   */\n  readonly bundler?: IAssetBundler;\n}\n\nexport enum AssetType {\n  FILE,\n  DIRECTORY,\n  ARCHIVE,\n}\n\n// Base name for a packaged (non-directory, non-verbatim-file) artifact. The\n// packaging's `extension` is appended, so a zip stays `archive.zip` and a\n// future `tar.bz2` packaging would be `archive.tar.bz2` with no change here.\nconst ARCHIVE_BASENAME = \"archive\";\nconst ASSETS_DIRECTORY = \"assets\";\n\n// A bundler's outputFileName becomes a path segment under the asset's hash\n// directory (see `path`/`fileName`), so it must be a plain file name that\n// cannot traverse or absolutize. Rejects empty, `.`, `..`, and any `/` or `\\`.\nconst SAFE_OUTPUT_FILE_NAME = /^(?!\\.\\.?$)[^/\\\\]+$/;\n\n/**\n * Maps each `AssetType` to how it is written to disk at synthesis time.\n *\n * Internal only: a future format is added by changing this map's values,\n * without any change to the public `AssetType` surface.\n */\nconst PACKAGING_BY_TYPE: Record<AssetType, IAssetPackaging> = {\n  [AssetType.FILE]: AssetPackaging.FILE,\n  [AssetType.DIRECTORY]: AssetPackaging.DIRECTORY,\n  [AssetType.ARCHIVE]: AssetPackaging.ZIP,\n};\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport class TerraformAsset extends Construct implements IAsset {\n  private stack: TerraformStack;\n  private sourcePath: string;\n  // hash value of the asset that can be passed to consuming constructs (e.g. to not recreate a lambda function in case the underlying files did not change)\n  public readonly assetHash: string;\n  // file type of the asset, either AssetType.FILE, AssetType.DIRECTORY, AssetType.ARCHIVE\n  public type: AssetType;\n  // owns hashing and packing; `AssetStaging` also validates a custom `assetHash`\n  private readonly staging: AssetStaging;\n  // set when a bundler builds the artifact; names a single-file result\n  private readonly bundler?: IAssetBundler;\n\n  /**\n   * A Terraform Asset takes a file or directory outside of the CDK Terrain context and moves it into it.\n   *\n   * Assets copy referenced files into the stacks context for further usage in other resources.\n   */\n  constructor(scope: Construct, id: string, config: TerraformAssetConfig) {\n    super(scope, id);\n\n    this.stack = TerraformStack.of(this);\n\n    if (path.isAbsolute(config.path)) {\n      this.sourcePath = config.path;\n    } else {\n      const cdktfJsonPath =\n        scope.node.tryGetContext(\"cdktfJsonPath\") ??\n        findFileAboveCwd(\"cdktf.json\");\n      if (cdktfJsonPath) {\n        // Relative paths are always considered to be relative to cdktf.json, but operations are performed relative to process.cwd\n        const absolutePath = path.resolve(\n          path.dirname(cdktfJsonPath),\n          config.path,\n        );\n        this.sourcePath = path.relative(process.cwd(), absolutePath);\n      } else {\n        throw assetOutOfScopeOfCDKTFJson(id, config.path);\n      }\n    }\n\n    const stat = fs.statSync(this.sourcePath);\n    const inferredType = stat.isFile() ? AssetType.FILE : AssetType.DIRECTORY;\n    this.type = config.type ?? inferredType;\n\n    // Without a bundler the source is staged verbatim, so its shape must match\n    // the type. A bundler decouples them, so the check moves to the bundler\n    // output shape, validated in AssetStaging once the build runs.\n    if (!config.bundler && stat.isFile() !== (this.type === AssetType.FILE)) {\n      throw assetExpectsDirectory(id, config.path);\n    }\n\n    this.bundler = config.bundler;\n\n    const outputFileName = config.bundler?.outputFileName;\n    if (outputFileName !== undefined) {\n      if (!SAFE_OUTPUT_FILE_NAME.test(outputFileName)) {\n        throw assetBundlerOutputFileNameInvalid(id, outputFileName);\n      }\n      // outputFileName is declared statically, so a bundler that sets it is\n      // announcing FILE output. Catch a FILE/packaging mismatch now rather\n      // than after a (possibly minutes-long) build; validateOutputShape stays\n      // the backstop for the dynamic case where the shape is only known once\n      // bundle() returns.\n      if (this.type !== AssetType.FILE) {\n        throw assetStagingBundlerFileOutputNeedsFilePackaging(id);\n      }\n    }\n\n    this.staging = new AssetStaging(this, \"Staging\", {\n      sourcePath: this.sourcePath,\n      displayName: id,\n      packaging: this.packaging,\n      assetHash: config.assetHash,\n      assetHashType: config.assetHashType,\n      exclude: config.exclude,\n      ignoreStrategy: config.ignoreStrategy,\n      extraHash: config.extraHash,\n      bundler: config.bundler,\n    });\n    this.assetHash = this.staging.assetHash;\n\n    addCustomSynthesis(this, {\n      onSynthesize: this._onSynthesize.bind(this),\n    });\n  }\n\n  private get namedFolder(): string {\n    return path.posix.join(\n      ASSETS_DIRECTORY,\n      this.stack.getLogicalId(this.node),\n    );\n  }\n\n  /**\n   * How this asset is written to disk. The layout (directory vs single file)\n   * and the artifact name are derived from this rather than from `type`\n   * directly, so the two never disagree.\n   */\n  private get packaging(): IAssetPackaging {\n    const packaging = PACKAGING_BY_TYPE[this.type];\n    if (!packaging) {\n      throw assetTypeNotImplemented();\n    }\n    return packaging;\n  }\n\n  /**\n   * The path relative to the root of the terraform directory in posix format\n   * Use this property to reference the asset\n   */\n  public get path(): string {\n    return path.posix.join(\n      this.namedFolder, // readable name\n      this.assetHash, // hash depending on content so that path changes if content changes\n      // A directory-producing packaging has no file segment; anything else\n      // contributes its artifact name.\n      this.packaging.producesDirectory ? \"\" : this.fileName,\n    );\n  }\n\n  /**\n   * Name of the asset\n   */\n  public get fileName(): string {\n    const { extension } = this.packaging;\n    // Repackaged artifacts (extension set) get a stable base + extension.\n    if (extension) {\n      return `${ARCHIVE_BASENAME}${extension}`;\n    }\n    // A single-file bundler artifact uses the name the bundler declares,\n    // falling back to the source basename.\n    if (this.bundler?.outputFileName) {\n      return this.bundler.outputFileName;\n    }\n    return path.basename(this.sourcePath);\n  }\n\n  private _onSynthesize(session: ISynthesisSession) {\n    const stackManifest = session.manifest.forStack(this.stack);\n    const basePath = path.join(\n      session.manifest.outdir,\n      stackManifest.synthesizedStackPath,\n      \"..\",\n    );\n\n    // Cleanup existing assets\n    const previousVersionsFolder = path.join(basePath, this.namedFolder);\n    if (fs.existsSync(previousVersionsFolder)) {\n      fs.rmSync(previousVersionsFolder, { recursive: true });\n    }\n\n    const targetPath = path.join(basePath, this.path);\n    const packaging = this.packaging;\n\n    if (packaging.producesDirectory) {\n      fs.mkdirSync(targetPath, { recursive: true });\n    } else {\n      fs.mkdirSync(path.dirname(targetPath), { recursive: true });\n    }\n\n    this.staging.stage(targetPath);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terraform-asset.js","sourceRoot":"","sources":["../src/terraform-asset.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { Construct } from \"constructs\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport {\n  AssetPackaging,\n  AssetHashType,\n  IAsset,\n  IAssetBundler,\n  IAssetPackaging,\n} from \"./assets\";\nimport { AssetStaging } from \"./asset-staging\";\nimport { IIgnoreStrategy } from \"./ignore-strategy\";\nimport { findFileAboveCwd } from \"./private/fs\";\nimport { ISynthesisSession } from \"./synthesize\";\nimport { addCustomSynthesis } from \"./synthesize/synthesizer\";\nimport { TerraformStack } from \"./terraform-stack\";\nimport {\n  assetBundlerOutputFileNameInvalid,\n  assetExpectsDirectory,\n  assetOutOfScopeOfCDKTFJson,\n  assetStagingBundlerFileOutputNeedsFilePackaging,\n  assetTypeNotImplemented,\n} from \"./errors\";\n\nexport interface TerraformAssetConfig {\n  // path to the file or folder configured. If relative, the path is resolved from the location of cdktf.json\n  readonly path: string;\n  // file type of the asset, either AssetType.FILE, AssetType.DIRECTORY, AssetType.ARCHIVE\n  readonly type?: AssetType;\n  // hash value of the asset, if passed will be used as returned assetHash\n  readonly assetHash?: string;\n  /**\n   * How the `assetHash` is derived.\n   *\n   * `SOURCE` (the default) hashes the source path. `CUSTOM` uses the\n   * `assetHash` value verbatim and requires it to be set. `OUTPUT` hashes the\n   * source too, unless a `bundler` is set — then it hashes the bundler's\n   * built output, which forces an eager build (see `bundler`).\n   *\n   * If `assetHash` is set, this must be `undefined` or `AssetHashType.CUSTOM`.\n   *\n   * @default AssetHashType.SOURCE\n   */\n  readonly assetHashType?: AssetHashType;\n\n  /**\n   * Paths to exclude from the asset, relative to `path`. See\n   * `AssetStagingOptions.exclude` for the accepted forms. Both the computed\n   * hash and the staged/packed content honor the exclusion. Cannot be\n   * combined with `ignoreStrategy`, which replaces this matcher rather than\n   * layering on top of it.\n   *\n   * @default - nothing is excluded\n   */\n  readonly exclude?: string[];\n\n  /**\n   * Exclusion matching, for callers that need `.gitignore` / `.dockerignore`\n   * parity (including `!`-negation) rather than the built-in exact-path /\n   * suffix / directory matcher. See `AssetStagingOptions.ignoreStrategy`.\n   *\n   * `!`-negation only takes effect if the strategy also sets\n   * `pruneExcludedDirectories: false`; otherwise an excluded directory is\n   * pruned before its contents are ever checked against a re-include\n   * pattern. See `IIgnoreStrategy.pruneExcludedDirectories`.\n   *\n   * @default - `exclude` is used with the built-in matcher\n   */\n  readonly ignoreStrategy?: IIgnoreStrategy;\n\n  /**\n   * Extra information to fold into the hash (e.g. build instructions and\n   * other inputs).\n   *\n   * @default - no extra hash\n   */\n  readonly extraHash?: string;\n\n  /**\n   * A bundler that builds the source into an artifact before staging.\n   *\n   * Core ships no bundler; implement `IAssetBundler` or use one from a bundler\n   * package. Under the default `SOURCE` hashing the build is deferred to synth\n   * and stays skippable; `OUTPUT` hashing builds eagerly to hash the artifact.\n   * The bundler's output shape must match `type`. See\n   * `AssetStagingOptions.bundler`.\n   *\n   * @default - the source is staged verbatim, with no build step\n   */\n  readonly bundler?: IAssetBundler;\n}\n\nexport enum AssetType {\n  FILE,\n  DIRECTORY,\n  ARCHIVE,\n}\n\n// Base name for a packaged (non-directory, non-verbatim-file) artifact. The\n// packaging's `extension` is appended, so a zip stays `archive.zip` and a\n// future `tar.bz2` packaging would be `archive.tar.bz2` with no change here.\nconst ARCHIVE_BASENAME = \"archive\";\nconst ASSETS_DIRECTORY = \"assets\";\n\n// A bundler's outputFileName becomes a path segment under the asset's hash\n// directory (see `path`/`fileName`), so it must be a plain file name that\n// cannot traverse or absolutize. Rejects empty, `.`, `..`, and any `/` or `\\`.\nconst SAFE_OUTPUT_FILE_NAME = /^(?!\\.\\.?$)[^/\\\\]+$/;\n\n/**\n * Maps each `AssetType` to how it is written to disk at synthesis time.\n *\n * Internal only: a future format is added by changing this map's values,\n * without any change to the public `AssetType` surface.\n */\nconst PACKAGING_BY_TYPE: Record<AssetType, IAssetPackaging> = {\n  [AssetType.FILE]: AssetPackaging.FILE,\n  [AssetType.DIRECTORY]: AssetPackaging.DIRECTORY,\n  [AssetType.ARCHIVE]: AssetPackaging.ZIP,\n};\n\n/**\n * A local file or directory that is hashed and copied into the stack's output directory at synthesis, optionally\n * built by a bundler and packaged as an archive, so other resources can reference it by path.\n */\nexport class TerraformAsset extends Construct implements IAsset {\n  private stack: TerraformStack;\n  private sourcePath: string;\n  // hash value of the asset that can be passed to consuming constructs (e.g. to not recreate a lambda function in case the underlying files did not change)\n  public readonly assetHash: string;\n  // file type of the asset, either AssetType.FILE, AssetType.DIRECTORY, AssetType.ARCHIVE\n  public type: AssetType;\n  // owns hashing and packing; `AssetStaging` also validates a custom `assetHash`\n  private readonly staging: AssetStaging;\n  // set when a bundler builds the artifact; names a single-file result\n  private readonly bundler?: IAssetBundler;\n\n  /**\n   * A Terraform Asset takes a file or directory outside of the CDK Terrain context and moves it into it.\n   *\n   * Assets copy referenced files into the stacks context for further usage in other resources.\n   */\n  constructor(scope: Construct, id: string, config: TerraformAssetConfig) {\n    super(scope, id);\n\n    this.stack = TerraformStack.of(this);\n\n    if (path.isAbsolute(config.path)) {\n      this.sourcePath = config.path;\n    } else {\n      const cdktfJsonPath =\n        scope.node.tryGetContext(\"cdktfJsonPath\") ??\n        findFileAboveCwd(\"cdktf.json\");\n      if (cdktfJsonPath) {\n        // Relative paths are always considered to be relative to cdktf.json, but operations are performed relative to process.cwd\n        const absolutePath = path.resolve(\n          path.dirname(cdktfJsonPath),\n          config.path,\n        );\n        this.sourcePath = path.relative(process.cwd(), absolutePath);\n      } else {\n        throw assetOutOfScopeOfCDKTFJson(id, config.path);\n      }\n    }\n\n    const stat = fs.statSync(this.sourcePath);\n    const inferredType = stat.isFile() ? AssetType.FILE : AssetType.DIRECTORY;\n    this.type = config.type ?? inferredType;\n\n    // Without a bundler the source is staged verbatim, so its shape must match\n    // the type. A bundler decouples them, so the check moves to the bundler\n    // output shape, validated in AssetStaging once the build runs.\n    if (!config.bundler && stat.isFile() !== (this.type === AssetType.FILE)) {\n      throw assetExpectsDirectory(id, config.path);\n    }\n\n    this.bundler = config.bundler;\n\n    const outputFileName = config.bundler?.outputFileName;\n    if (outputFileName !== undefined) {\n      if (!SAFE_OUTPUT_FILE_NAME.test(outputFileName)) {\n        throw assetBundlerOutputFileNameInvalid(id, outputFileName);\n      }\n      // outputFileName is declared statically, so a bundler that sets it is\n      // announcing FILE output. Catch a FILE/packaging mismatch now rather\n      // than after a (possibly minutes-long) build; validateOutputShape stays\n      // the backstop for the dynamic case where the shape is only known once\n      // bundle() returns.\n      if (this.type !== AssetType.FILE) {\n        throw assetStagingBundlerFileOutputNeedsFilePackaging(id);\n      }\n    }\n\n    this.staging = new AssetStaging(this, \"Staging\", {\n      sourcePath: this.sourcePath,\n      displayName: id,\n      packaging: this.packaging,\n      assetHash: config.assetHash,\n      assetHashType: config.assetHashType,\n      exclude: config.exclude,\n      ignoreStrategy: config.ignoreStrategy,\n      extraHash: config.extraHash,\n      bundler: config.bundler,\n    });\n    this.assetHash = this.staging.assetHash;\n\n    addCustomSynthesis(this, {\n      onSynthesize: this._onSynthesize.bind(this),\n    });\n  }\n\n  private get namedFolder(): string {\n    return path.posix.join(\n      ASSETS_DIRECTORY,\n      this.stack.getLogicalId(this.node),\n    );\n  }\n\n  /**\n   * How this asset is written to disk. The layout (directory vs single file)\n   * and the artifact name are derived from this rather than from `type`\n   * directly, so the two never disagree.\n   */\n  private get packaging(): IAssetPackaging {\n    const packaging = PACKAGING_BY_TYPE[this.type];\n    if (!packaging) {\n      throw assetTypeNotImplemented();\n    }\n    return packaging;\n  }\n\n  /**\n   * The path relative to the root of the terraform directory in posix format\n   * Use this property to reference the asset\n   */\n  public get path(): string {\n    return path.posix.join(\n      this.namedFolder, // readable name\n      this.assetHash, // hash depending on content so that path changes if content changes\n      // A directory-producing packaging has no file segment; anything else\n      // contributes its artifact name.\n      this.packaging.producesDirectory ? \"\" : this.fileName,\n    );\n  }\n\n  /**\n   * Name of the asset\n   */\n  public get fileName(): string {\n    const { extension } = this.packaging;\n    // Repackaged artifacts (extension set) get a stable base + extension.\n    if (extension) {\n      return `${ARCHIVE_BASENAME}${extension}`;\n    }\n    // A single-file bundler artifact uses the name the bundler declares,\n    // falling back to the source basename.\n    if (this.bundler?.outputFileName) {\n      return this.bundler.outputFileName;\n    }\n    return path.basename(this.sourcePath);\n  }\n\n  private _onSynthesize(session: ISynthesisSession) {\n    const stackManifest = session.manifest.forStack(this.stack);\n    const basePath = path.join(\n      session.manifest.outdir,\n      stackManifest.synthesizedStackPath,\n      \"..\",\n    );\n\n    // Cleanup existing assets\n    const previousVersionsFolder = path.join(basePath, this.namedFolder);\n    if (fs.existsSync(previousVersionsFolder)) {\n      fs.rmSync(previousVersionsFolder, { recursive: true });\n    }\n\n    const targetPath = path.join(basePath, this.path);\n    const packaging = this.packaging;\n\n    if (packaging.producesDirectory) {\n      fs.mkdirSync(targetPath, { recursive: true });\n    } else {\n      fs.mkdirSync(path.dirname(targetPath), { recursive: true });\n    }\n\n    this.staging.stage(targetPath);\n  }\n}\n"]}

package/lib/terraform-backend.d.ts

@@ -1,6 +1,9 @@
 import { Construct } from "constructs";
 import { TerraformRemoteState } from "./terraform-remote-state";
 import { TerraformElement } from "./terraform-element";
+/**
+ * Base class for backends, which synthesize the `terraform.backend` block that sets where a stack stores its state.
+ */
 export declare abstract class TerraformBackend extends TerraformElement {
     protected readonly name: string;
     constructor(scope: Construct, id: string, name: string);