cdktn 0.25.0-pre.8 → 0.25.0

package/lib/assets.js

@@ -0,0 +1,333 @@
+"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.ChainBundler = exports.BundlerKey = exports.BundleResult = exports.BundleOutputType = exports.AssetPackaging = exports.AssetHashType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const errors_1 = require("./errors");
+const fs_1 = require("./private/fs");
+/**
+ * The type of asset hash.
+ *
+ * The hash identifies a specific revision of the asset and caches deployment
+ * work such as packaging and uploading.
+ */
+var AssetHashType;
+(function (AssetHashType) {
+    /**
+     * Based on the content of the source path.
+     *
+     * Use `SOURCE` to track changes to the source files directly.
+     */
+    AssetHashType["SOURCE"] = "source";
+    /**
+     * Based on the content of the bundling output.
+     *
+     * Use `OUTPUT` when the source is a top-level folder holding code and/or
+     * dependencies not directly linked to the asset.
+     */
+    AssetHashType["OUTPUT"] = "output";
+    /**
+     * Use a custom hash.
+     */
+    AssetHashType["CUSTOM"] = "custom";
+})(AssetHashType || (exports.AssetHashType = AssetHashType = {}));
+/**
+ * Copies a single file verbatim.
+ */
+class FilePackaging {
+    extension = "";
+    producesDirectory = false;
+    acceptsDirectorySource = false;
+    omitsDirectoryEntries = false;
+    pack(options) {
+        fs.copyFileSync(options.source, options.target);
+    }
+}
+/**
+ * Copies a directory tree verbatim, without archiving it.
+ */
+class DirectoryPackaging {
+    extension = "";
+    producesDirectory = true;
+    acceptsDirectorySource = true;
+    omitsDirectoryEntries = false;
+    pack(options) {
+        (0, fs_1.copySync)(options.source, options.target, {
+            shouldExclude: options.ignoreStrategy
+                ? (relativePath, isDirectory) => options.ignoreStrategy.ignores({ relativePath, isDirectory })
+                : undefined,
+            descendIntoExcludedDirectories: options.ignoreStrategy?.pruneExcludedDirectories === false,
+        });
+    }
+}
+/**
+ * Archives a directory tree into a single zip file.
+ */
+class ZipPackaging {
+    extension = ".zip";
+    producesDirectory = false;
+    acceptsDirectorySource = true;
+    omitsDirectoryEntries = true;
+    pack(options) {
+        (0, fs_1.archiveSync)(options.source, options.target, options.ignoreStrategy
+            ? (relativePath, isDirectory) => options.ignoreStrategy.ignores({ relativePath, isDirectory })
+            : undefined, options.ignoreStrategy?.pruneExcludedDirectories === false);
+    }
+}
+/**
+ * Built-in packaging strategies. Custom formats implement `IAssetPackaging`
+ * directly rather than extending this class.
+ */
+class AssetPackaging {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.AssetPackaging", version: "0.25.0" };
+    /**
+     * Copy a single file as-is.
+     */
+    static FILE = new FilePackaging();
+    /**
+     * Copy a directory tree as-is, without archiving.
+     */
+    static DIRECTORY = new DirectoryPackaging();
+    /**
+     * Archive a directory tree into a single zip file.
+     */
+    static ZIP = new ZipPackaging();
+    constructor() { }
+}
+exports.AssetPackaging = AssetPackaging;
+/**
+ * The shape of a bundler's output, so staging and packaging can treat a
+ * single-file artifact (a tarball, a `.zip`) differently from a directory
+ * tree without inferring it from the path.
+ */
+var BundleOutputType;
+(function (BundleOutputType) {
+    /**
+     * The output is a directory tree.
+     *
+     * Packaged like an unbundled source directory. The default, and the only
+     * shape that predates archive support.
+     */
+    BundleOutputType["DIRECTORY"] = "directory";
+    /**
+     * The output is a single file the bundler already produced in its final
+     * form.
+     *
+     * A tarball or a deterministic `.zip`. Staged verbatim rather than
+     * re-archived, so `AssetType.FILE` no longer has to reject a bundler.
+     */
+    BundleOutputType["FILE"] = "file";
+})(BundleOutputType || (exports.BundleOutputType = BundleOutputType = {}));
+/**
+ * What a bundler produced, returned from {@link IAssetBundler.bundle}.
+ *
+ * Carries the artifact path and its shape, or a declined state signalling the
+ * caller should fall back. See {@link declined} for the decline protocol.
+ */
+class BundleResult {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.BundleResult", version: "0.25.0" };
+    /**
+     * A directory-tree artifact at `path`.
+     */
+    static directory(path) {
+        return new BundleResult(BundleOutputType.DIRECTORY, path, false);
+    }
+    /**
+     * A single-file artifact at `path` (a tarball, a `.zip`), staged verbatim.
+     */
+    static file(path) {
+        return new BundleResult(BundleOutputType.FILE, path, false);
+    }
+    /**
+     * The bundler declined to run here; the caller should fall back.
+     *
+     * Distinct from a thrown error, which is a hard failure.
+     */
+    static declined() {
+        return new BundleResult(undefined, undefined, true);
+    }
+    /**
+     * The artifact's shape, or undefined when {@link isDeclined}.
+     */
+    outputType;
+    /**
+     * The artifact path, or undefined when {@link isDeclined}.
+     */
+    path;
+    /**
+     * Whether the bundler declined to run, signalling the caller to fall back.
+     */
+    isDeclined;
+    constructor(outputType, path, isDeclined) {
+        this.outputType = outputType;
+        this.path = path;
+        this.isDeclined = isDeclined;
+    }
+}
+exports.BundleResult = BundleResult;
+/**
+ * Builds an {@link IAssetBundler.bundlerKey} from an ordered set of parts.
+ *
+ * A `bundlerKey` has to serialize everything that can move a build's output;
+ * done ad hoc, every bundler invents its own delimiter and forgets an input
+ * differently. This gives the convention one implementation: parts are joined
+ * with a separator that is escaped inside values, so distinct inputs cannot
+ * collide into the same key.
+ *
+ * @example
+ * const key = BundlerKey.of("docker", image, command)
+ *   .withEnv({ NODE_ENV: nodeEnv })
+ *   .toString();
+ */
+class BundlerKey {
+    parts;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.BundlerKey", version: "0.25.0" };
+    /**
+     * Start a key from an ordered list of parts.
+     *
+     * Order is significant: it is part of what the key identifies.
+     */
+    static of(...parts) {
+        return new BundlerKey(parts);
+    }
+    static escape(part) {
+        return part.replace(/\\/g, "\\\\").replace(/:/g, "\\:");
+    }
+    constructor(parts) {
+        this.parts = parts;
+    }
+    /**
+     * Append parts, returning a new key.
+     */
+    add(...parts) {
+        return new BundlerKey([...this.parts, ...parts]);
+    }
+    /**
+     * Append `key=value` parts for a record, sorted by key so the result does
+     * not depend on property order.
+     */
+    withEnv(entries) {
+        const kept = Object.keys(entries)
+            .sort()
+            .map((k) => `${k}=${entries[k]}`);
+        return new BundlerKey([...this.parts, ...kept]);
+    }
+    /**
+     * Render the collected parts to the string passed as `bundlerKey`.
+     */
+    toString() {
+        return this.parts.map(BundlerKey.escape).join(":");
+    }
+}
+exports.BundlerKey = BundlerKey;
+/**
+ * Composes bundlers into a "try each in order until one runs" chain.
+ *
+ * This is how a local bundler and a Docker bundler compose without being
+ * rewritten as one: each leg declines (`BundleResult.declined()`) when it
+ * cannot run here, and the chain moves to the next. The first non-declining
+ * result wins; if all decline, `bundle` throws, since staging has nothing to
+ * fall back to. Each leg builds into its own output directory, so a leg that
+ * writes before declining cannot leak partial files into the leg that wins.
+ *
+ * The chain's `bundlerKey` folds in *every* leg's key, so identity is the same
+ * regardless of which leg ends up running — a build that could have gone local
+ * or Docker is one asset, not two.
+ *
+ * This makes the legs interchangeable only if they produce equivalent output.
+ * Under `SOURCE` hashing they must: a machine with a host tool and one without
+ * run different legs, and non-equivalent legs would stage different bytes under
+ * the same hash. Use `OUTPUT` hashing when legs may diverge, so identity tracks
+ * the artifact each leg actually produced.
+ */
+class ChainBundler {
+    bundlers;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.ChainBundler", version: "0.25.0" };
+    /**
+     * Chain bundlers in the order given; earlier bundlers are preferred.
+     */
+    static of(...bundlers) {
+        return new ChainBundler(bundlers);
+    }
+    bundlerKey;
+    outputFileName;
+    constructor(bundlers) {
+        this.bundlers = bundlers;
+        if (bundlers.length === 0) {
+            throw (0, errors_1.chainBundlerRequiresAtLeastOneBundler)();
+        }
+        // Fold in every leg's key so which leg runs cannot change identity. A leg
+        // without a key contributes an empty part, still distinguishing "two legs"
+        // from "one leg" positionally.
+        const keys = bundlers.map((b) => b.bundlerKey ?? "");
+        this.bundlerKey = keys.some((k) => k !== "")
+            ? BundlerKey.of("chain", ...keys).toString()
+            : undefined;
+        // The staged file name is fixed at construction, before any leg runs, so
+        // legs that declare one must agree — otherwise the name would depend on
+        // which leg happens to run.
+        const names = new Set(bundlers
+            .map((b) => b.outputFileName)
+            .filter((n) => n !== undefined));
+        if (names.size > 1) {
+            throw (0, errors_1.chainBundlerConflictingOutputFileName)([...names]);
+        }
+        this.outputFileName = names.size === 1 ? [...names][0] : undefined;
+    }
+    bundle(options) {
+        for (let i = 0; i < this.bundlers.length; i++) {
+            // Each leg gets its own output directory. A leg is free to write before
+            // it declines (esbuild failing on an unsupported target, a Docker leg
+            // creating output before finding the daemon down), and sharing one
+            // directory would leak those partial files into the leg that succeeds.
+            const legOutputDir = path.join(options.outputDir, `leg-${i}`);
+            fs.mkdirSync(legOutputDir);
+            const result = this.bundlers[i].bundle({
+                source: options.source,
+                outputDir: legOutputDir,
+            });
+            if (!result.isDeclined) {
+                return result;
+            }
+        }
+        throw (0, errors_1.chainBundlerAllDeclined)(this.bundlers.length);
+    }
+}
+exports.ChainBundler = ChainBundler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assets.js","sourceRoot":"","sources":["../src/assets.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\n\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport {\n  chainBundlerAllDeclined,\n  chainBundlerConflictingOutputFileName,\n  chainBundlerRequiresAtLeastOneBundler,\n} from \"./errors\";\nimport { archiveSync, copySync } from \"./private/fs\";\nimport { IIgnoreStrategy } from \"./ignore-strategy\";\n\n/**\n * Common interface for all assets.\n */\nexport interface IAsset {\n  /**\n   * A hash of this asset, available at construction time.\n   *\n   * Being a plain string, it can be used in construct IDs to force a new\n   * resource when the content hash changes.\n   */\n  readonly assetHash: string;\n}\n\n/**\n * Options controlling how an asset's hash is derived.\n */\nexport interface AssetOptions {\n  /**\n   * Specify a custom hash for this asset. If `assetHashType` is set it must\n   * be set to `AssetHashType.CUSTOM`. The value is used verbatim as the asset\n   * hash, and because it names the staged asset file it may only contain\n   * letters, digits, `_`, `.` and `-`.\n   *\n   * The hash identifies a specific revision of the asset and caches deployment\n   * work (packaging, uploading). A custom hash must be updated whenever the\n   * asset changes, or some deployments will not be invalidated.\n   *\n   * @default - based on `assetHashType`\n   */\n  readonly assetHash?: string;\n\n  /**\n   * Specifies the type of hash to calculate for this asset.\n   *\n   * If `assetHash` is configured, this option must be `undefined` or\n   * `AssetHashType.CUSTOM`.\n   *\n   * @default - the default is `AssetHashType.SOURCE`, but if `assetHash` is\n   * explicitly specified this value defaults to `AssetHashType.CUSTOM`.\n   */\n  readonly assetHashType?: AssetHashType;\n}\n\n/**\n * The type of asset hash.\n *\n * The hash identifies a specific revision of the asset and caches deployment\n * work such as packaging and uploading.\n */\nexport enum AssetHashType {\n  /**\n   * Based on the content of the source path.\n   *\n   * Use `SOURCE` to track changes to the source files directly.\n   */\n  SOURCE = \"source\",\n\n  /**\n   * Based on the content of the bundling output.\n   *\n   * Use `OUTPUT` when the source is a top-level folder holding code and/or\n   * dependencies not directly linked to the asset.\n   */\n  OUTPUT = \"output\",\n\n  /**\n   * Use a custom hash.\n   */\n  CUSTOM = \"custom\",\n}\n\n/**\n * How a staged asset is produced and what shape it takes on disk.\n *\n * Packaging answers two independent questions: how the artifact is produced\n * (copy, zip, tar.gz, ...) and whether the result is a directory or a single\n * file. A closed enum can only ever answer the second one, so it is an\n * interface rather than an enum — custom formats (e.g. `tar.bz2`) need no\n * core change.\n */\nexport interface IAssetPackaging {\n  /**\n   * Appended to the staged artifact name, e.g. \".zip\", \"\", \".tar.bz2\".\n   */\n  readonly extension: string;\n\n  /**\n   * Whether the staged result is a directory rather than a single file.\n   *\n   * Publishers branch on this to decide whether they upload one object or\n   * sync a tree.\n   */\n  readonly producesDirectory: boolean;\n\n  /**\n   * Whether `pack` accepts a directory as its `source`.\n   *\n   * Independent of `producesDirectory` and `omitsDirectoryEntries`, both of\n   * which describe the output: a `tar.gz` packaging takes a directory source\n   * yet emits a single file. Bundler output is always a directory, so a\n   * packaging that is `false` here cannot stage it.\n   */\n  readonly acceptsDirectorySource: boolean;\n\n  /**\n   * Whether `pack` emits an artifact with no directory entries of its own —\n   * only the ignore-strategy-aware source walk. `hashPath`'s `archive` frame\n   * must agree with this or the hash and the artifact describe different\n   * file sets.\n   *\n   * `ZipPackaging` sets this because `archiveSync` never emits ZIP directory\n   * entries. A directory-producing packaging that mirrors the source tree\n   * (e.g. `DirectoryPackaging`) leaves this false, since its directories are\n   * real entries on disk.\n   */\n  readonly omitsDirectoryEntries: boolean;\n\n  /**\n   * Write the packaged result to `options.target`.\n   */\n  pack(options: PackOptions): void;\n}\n\n/**\n * Options for {@link IAssetPackaging.pack}.\n *\n * A struct rather than positional parameters: adding a struct field is\n * additive, adding a method parameter is not, and `pack` is called through\n * JSII where that distinction is a breaking-change boundary.\n */\nexport interface PackOptions {\n  /**\n   * Path to the resolved (already bundled, if applicable) source.\n   */\n  readonly source: string;\n\n  /**\n   * Path the packaged result should be written to.\n   */\n  readonly target: string;\n\n  /**\n   * Entries to omit from the packaged result. Must match the strategy used\n   * to hash the same source, or the hash and the artifact describe\n   * different sets of files.\n   *\n   * @default - nothing is excluded\n   */\n  readonly ignoreStrategy?: IIgnoreStrategy;\n}\n\n/**\n * Copies a single file verbatim.\n */\nclass FilePackaging implements IAssetPackaging {\n  public readonly extension = \"\";\n  public readonly producesDirectory = false;\n  public readonly acceptsDirectorySource = false;\n  public readonly omitsDirectoryEntries = false;\n  public pack(options: PackOptions): void {\n    fs.copyFileSync(options.source, options.target);\n  }\n}\n\n/**\n * Copies a directory tree verbatim, without archiving it.\n */\nclass DirectoryPackaging implements IAssetPackaging {\n  public readonly extension = \"\";\n  public readonly producesDirectory = true;\n  public readonly acceptsDirectorySource = true;\n  public readonly omitsDirectoryEntries = false;\n  public pack(options: PackOptions): void {\n    copySync(options.source, options.target, {\n      shouldExclude: options.ignoreStrategy\n        ? (relativePath, isDirectory) =>\n            options.ignoreStrategy!.ignores({ relativePath, isDirectory })\n        : undefined,\n      descendIntoExcludedDirectories:\n        options.ignoreStrategy?.pruneExcludedDirectories === false,\n    });\n  }\n}\n\n/**\n * Archives a directory tree into a single zip file.\n */\nclass ZipPackaging implements IAssetPackaging {\n  public readonly extension = \".zip\";\n  public readonly producesDirectory = false;\n  public readonly acceptsDirectorySource = true;\n  public readonly omitsDirectoryEntries = true;\n  public pack(options: PackOptions): void {\n    archiveSync(\n      options.source,\n      options.target,\n      options.ignoreStrategy\n        ? (relativePath, isDirectory) =>\n            options.ignoreStrategy!.ignores({ relativePath, isDirectory })\n        : undefined,\n      options.ignoreStrategy?.pruneExcludedDirectories === false,\n    );\n  }\n}\n\n/**\n * Built-in packaging strategies. Custom formats implement `IAssetPackaging`\n * directly rather than extending this class.\n */\nexport class AssetPackaging {\n  /**\n   * Copy a single file as-is.\n   */\n  public static readonly FILE: IAssetPackaging = new FilePackaging();\n\n  /**\n   * Copy a directory tree as-is, without archiving.\n   */\n  public static readonly DIRECTORY: IAssetPackaging = new DirectoryPackaging();\n\n  /**\n   * Archive a directory tree into a single zip file.\n   */\n  public static readonly ZIP: IAssetPackaging = new ZipPackaging();\n\n  private constructor() {}\n}\n\n/**\n * Options handed to an {@link IAssetBundler} when it runs.\n *\n * A struct rather than positional parameters: adding a field is additive,\n * adding a method parameter is not, and `bundle` is called through JSII where\n * that distinction is a breaking-change boundary.\n */\nexport interface BundleOptions {\n  /**\n   * Absolute path to the asset's source file or directory. The bundler reads\n   * from here and must not modify it.\n   *\n   * Exclusions (`exclude` / `ignoreStrategy`) are already applied: when any\n   * are configured this points at a filtered copy, not the original tree, so\n   * the bundler reads exactly the file set the asset hash was taken over.\n   */\n  readonly source: string;\n\n  /**\n   * A scratch directory the bundler may write into, owned and created by the\n   * caller. The bundler produces its output here (or in a subdirectory) and\n   * returns a {@link BundleResult} pointing at the finished artifact — see\n   * {@link IAssetBundler.bundle}.\n   */\n  readonly outputDir: string;\n}\n\n/**\n * The shape of a bundler's output, so staging and packaging can treat a\n * single-file artifact (a tarball, a `.zip`) differently from a directory\n * tree without inferring it from the path.\n */\nexport enum BundleOutputType {\n  /**\n   * The output is a directory tree.\n   *\n   * Packaged like an unbundled source directory. The default, and the only\n   * shape that predates archive support.\n   */\n  DIRECTORY = \"directory\",\n\n  /**\n   * The output is a single file the bundler already produced in its final\n   * form.\n   *\n   * A tarball or a deterministic `.zip`. Staged verbatim rather than\n   * re-archived, so `AssetType.FILE` no longer has to reject a bundler.\n   */\n  FILE = \"file\",\n}\n\n/**\n * What a bundler produced, returned from {@link IAssetBundler.bundle}.\n *\n * Carries the artifact path and its shape, or a declined state signalling the\n * caller should fall back. See {@link declined} for the decline protocol.\n */\nexport class BundleResult {\n  /**\n   * A directory-tree artifact at `path`.\n   */\n  public static directory(path: string): BundleResult {\n    return new BundleResult(BundleOutputType.DIRECTORY, path, false);\n  }\n\n  /**\n   * A single-file artifact at `path` (a tarball, a `.zip`), staged verbatim.\n   */\n  public static file(path: string): BundleResult {\n    return new BundleResult(BundleOutputType.FILE, path, false);\n  }\n\n  /**\n   * The bundler declined to run here; the caller should fall back.\n   *\n   * Distinct from a thrown error, which is a hard failure.\n   */\n  public static declined(): BundleResult {\n    return new BundleResult(undefined, undefined, true);\n  }\n\n  /**\n   * The artifact's shape, or undefined when {@link isDeclined}.\n   */\n  public readonly outputType?: BundleOutputType;\n\n  /**\n   * The artifact path, or undefined when {@link isDeclined}.\n   */\n  public readonly path?: string;\n\n  /**\n   * Whether the bundler declined to run, signalling the caller to fall back.\n   */\n  public readonly isDeclined: boolean;\n\n  private constructor(\n    outputType: BundleOutputType | undefined,\n    path: string | undefined,\n    isDeclined: boolean,\n  ) {\n    this.outputType = outputType;\n    this.path = path;\n    this.isDeclined = isDeclined;\n  }\n}\n\n/**\n * Transforms a source tree into a built artifact. Runs at synth, before the\n * output is packaged and staged.\n *\n * This is the extension point for asset bundling: core ships no bundler.\n * Docker, esbuild, pip, `go build`, and similar are an open-ended, non\n * cloud-specific set, so each lives in its own package and implements this\n * one interface — the same way {@link IIgnoreStrategy} lets richer exclusion\n * live outside core. Users pass an instance via the consuming construct's\n * `bundler` option.\n *\n * `bundle` runs during the owning construct's `onSynthesize` hook and may\n * touch the filesystem. Deferring it there keeps it skippable when the asset's\n * stack is not being synthesized, which holds as long as the hash is taken\n * over the source rather than the built output.\n *\n * Bundlers compose through {@link ChainBundler} rather than a hierarchy: a\n * bundler declines (see {@link BundleResult.declined}) instead of failing when\n * it cannot run, and the chain falls through to the next.\n */\nexport interface IAssetBundler {\n  /**\n   * A value identifying the build, folded into the asset hash.\n   *\n   * The source tree alone cannot see the build, so swapping a `node:18` base\n   * image for `node:20` would otherwise leave identity unchanged. Under\n   * `SOURCE` hashing this is the only channel by which the build reaches\n   * identity, so it must serialize every input that can move the output, or a\n   * changed build silently reuses a stale artifact. {@link BundlerKey} builds\n   * one from an ordered set of parts.\n   *\n   * Mirrors {@link IIgnoreStrategy.cacheKey}: omit it when the build cannot be\n   * summarized as a string, and fall back to `extraHash`.\n   *\n   * @default - the build does not contribute to the hash\n   */\n  readonly bundlerKey?: string;\n\n  /**\n   * The name a single-file artifact is staged under (e.g. `archive.zip`).\n   *\n   * A file-producing bundler (`BundleResult.file`) staged with\n   * `AssetType.FILE` would otherwise take the source path's basename, which is\n   * a directory name when the source is a directory. Declaring the name here\n   * lets the artifact reflect what the bundler produces. It is static\n   * configuration, needed at construction before a deferred `SOURCE` build\n   * runs, not the file's runtime name.\n   *\n   * Valid only for a file-producing bundler: setting it with a directory\n   * packaging (anything but `AssetType.FILE`) is rejected at construction.\n   *\n   * @default - the source path's basename\n   */\n  readonly outputFileName?: string;\n\n  /**\n   * Produce the artifact and return a {@link BundleResult} describing it.\n   *\n   * Implementations write into `options.outputDir` and never write back to\n   * `options.source`. The returned path must exist and match its declared\n   * shape, or staging rejects it.\n   *\n   * A bundler that cannot run in this environment returns\n   * `BundleResult.declined()` so a {@link ChainBundler} can fall through to\n   * the next; a thrown error is a hard failure, not a decline.\n   */\n  bundle(options: BundleOptions): BundleResult;\n}\n\n/**\n * Builds an {@link IAssetBundler.bundlerKey} from an ordered set of parts.\n *\n * A `bundlerKey` has to serialize everything that can move a build's output;\n * done ad hoc, every bundler invents its own delimiter and forgets an input\n * differently. This gives the convention one implementation: parts are joined\n * with a separator that is escaped inside values, so distinct inputs cannot\n * collide into the same key.\n *\n * @example\n * const key = BundlerKey.of(\"docker\", image, command)\n *   .withEnv({ NODE_ENV: nodeEnv })\n *   .toString();\n */\nexport class BundlerKey {\n  /**\n   * Start a key from an ordered list of parts.\n   *\n   * Order is significant: it is part of what the key identifies.\n   */\n  public static of(...parts: string[]): BundlerKey {\n    return new BundlerKey(parts);\n  }\n\n  private static escape(part: string): string {\n    return part.replace(/\\\\/g, \"\\\\\\\\\").replace(/:/g, \"\\\\:\");\n  }\n\n  private constructor(private readonly parts: string[]) {}\n\n  /**\n   * Append parts, returning a new key.\n   */\n  public add(...parts: string[]): BundlerKey {\n    return new BundlerKey([...this.parts, ...parts]);\n  }\n\n  /**\n   * Append `key=value` parts for a record, sorted by key so the result does\n   * not depend on property order.\n   */\n  public withEnv(entries: Record<string, string>): BundlerKey {\n    const kept = Object.keys(entries)\n      .sort()\n      .map((k) => `${k}=${entries[k]}`);\n    return new BundlerKey([...this.parts, ...kept]);\n  }\n\n  /**\n   * Render the collected parts to the string passed as `bundlerKey`.\n   */\n  public toString(): string {\n    return this.parts.map(BundlerKey.escape).join(\":\");\n  }\n}\n\n/**\n * Composes bundlers into a \"try each in order until one runs\" chain.\n *\n * This is how a local bundler and a Docker bundler compose without being\n * rewritten as one: each leg declines (`BundleResult.declined()`) when it\n * cannot run here, and the chain moves to the next. The first non-declining\n * result wins; if all decline, `bundle` throws, since staging has nothing to\n * fall back to. Each leg builds into its own output directory, so a leg that\n * writes before declining cannot leak partial files into the leg that wins.\n *\n * The chain's `bundlerKey` folds in *every* leg's key, so identity is the same\n * regardless of which leg ends up running — a build that could have gone local\n * or Docker is one asset, not two.\n *\n * This makes the legs interchangeable only if they produce equivalent output.\n * Under `SOURCE` hashing they must: a machine with a host tool and one without\n * run different legs, and non-equivalent legs would stage different bytes under\n * the same hash. Use `OUTPUT` hashing when legs may diverge, so identity tracks\n * the artifact each leg actually produced.\n */\nexport class ChainBundler implements IAssetBundler {\n  /**\n   * Chain bundlers in the order given; earlier bundlers are preferred.\n   */\n  public static of(...bundlers: IAssetBundler[]): ChainBundler {\n    return new ChainBundler(bundlers);\n  }\n\n  public readonly bundlerKey?: string;\n\n  public readonly outputFileName?: string;\n\n  private constructor(private readonly bundlers: IAssetBundler[]) {\n    if (bundlers.length === 0) {\n      throw chainBundlerRequiresAtLeastOneBundler();\n    }\n    // Fold in every leg's key so which leg runs cannot change identity. A leg\n    // without a key contributes an empty part, still distinguishing \"two legs\"\n    // from \"one leg\" positionally.\n    const keys = bundlers.map((b) => b.bundlerKey ?? \"\");\n    this.bundlerKey = keys.some((k) => k !== \"\")\n      ? BundlerKey.of(\"chain\", ...keys).toString()\n      : undefined;\n\n    // The staged file name is fixed at construction, before any leg runs, so\n    // legs that declare one must agree — otherwise the name would depend on\n    // which leg happens to run.\n    const names = new Set(\n      bundlers\n        .map((b) => b.outputFileName)\n        .filter((n): n is string => n !== undefined),\n    );\n    if (names.size > 1) {\n      throw chainBundlerConflictingOutputFileName([...names]);\n    }\n    this.outputFileName = names.size === 1 ? [...names][0] : undefined;\n  }\n\n  public bundle(options: BundleOptions): BundleResult {\n    for (let i = 0; i < this.bundlers.length; i++) {\n      // Each leg gets its own output directory. A leg is free to write before\n      // it declines (esbuild failing on an unsupported target, a Docker leg\n      // creating output before finding the daemon down), and sharing one\n      // directory would leak those partial files into the leg that succeeds.\n      const legOutputDir = path.join(options.outputDir, `leg-${i}`);\n      fs.mkdirSync(legOutputDir);\n      const result = this.bundlers[i].bundle({\n        source: options.source,\n        outputDir: legOutputDir,\n      });\n      if (!result.isDeclined) {\n        return result;\n      }\n    }\n    throw chainBundlerAllDeclined(this.bundlers.length);\n  }\n}\n\n/**\n * A staged artifact, ready to hand to an `IAssetPublisher`.\n *\n * Deliberately narrower than a location: `path` and `isDirectory` are known\n * once staging runs, at synth time, before anything is published. Where an\n * asset ends up — a bucket name, an object key, a URL — is resolved at\n * apply time and belongs on the publisher's own reference type instead.\n */\nexport interface StagedAsset {\n  /**\n   * A hash on the content source, uniquely identifying this asset.\n   *\n   * The asset is not rebuilt or republished while this value is unchanged.\n   */\n  readonly assetHash: string;\n\n  /**\n   * The path to the staged artifact, relative to the stack directory.\n   */\n  readonly path: string;\n\n  /**\n   * Whether the staged artifact is a directory rather than a single file.\n   *\n   * Publishers branch on this to decide whether they upload one object or\n   * sync a tree; see `IAssetPackaging.producesDirectory`.\n   */\n  readonly isDirectory: boolean;\n}\n"]}

package/lib/backends/azurerm-backend.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataTerraformRemoteStateAzurerm = exports.AzurermBackend = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
@@ -8,6 +7,8 @@ const util_1 = require("../util");
 const terraform_remote_state_1 = require("../terraform-remote-state");
 // eslint-disable-next-line jsdoc/require-jsdoc
 class AzurermBackend extends terraform_backend_1.TerraformBackend {
+    props;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.AzurermBackend", version: "0.25.0" };
     constructor(scope, props) {
         super(scope, "backend", "azurerm");
         this.props = props;
@@ -26,15 +27,12 @@ class AzurermBackend extends terraform_backend_1.TerraformBackend {
     }
 }
 exports.AzurermBackend = AzurermBackend;
-_a = JSII_RTTI_SYMBOL_1;
-AzurermBackend[_a] = { fqn: "cdktn.AzurermBackend", version: "0.25.0-pre.8" };
 // eslint-disable-next-line jsdoc/require-jsdoc
 class DataTerraformRemoteStateAzurerm extends terraform_remote_state_1.TerraformRemoteState {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.DataTerraformRemoteStateAzurerm", version: "0.25.0" };
     constructor(scope, id, config) {
         super(scope, id, "azurerm", config);
     }
 }
 exports.DataTerraformRemoteStateAzurerm = DataTerraformRemoteStateAzurerm;
-_b = JSII_RTTI_SYMBOL_1;
-DataTerraformRemoteStateAzurerm[_b] = { fqn: "cdktn.DataTerraformRemoteStateAzurerm", version: "0.25.0-pre.8" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"azurerm-backend.js","sourceRoot":"","sources":["../../src/backends/azurerm-backend.ts"],"names":[],"mappings":";;;;;AAGA,4DAAwD;AACxD,kCAA0C;AAC1C,sEAGmC;AAEnC,+CAA+C;AAC/C,MAAa,cAAe,SAAQ,oCAAgB;IAClD,YACE,KAAgB,EACC,KAA2B;QAE5C,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QAFlB,UAAK,GAAL,KAAK,CAAsB;IAG9C,CAAC;IAES,oBAAoB;QAC5B,OAAO,IAAA,sBAAe,EAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IAC5C,CAAC;IAES,uBAAuB;QAC/B,OAAO,IAAA,sBAAe,EAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IAC5C,CAAC;IAEM,wBAAwB,CAC7B,KAAgB,EAChB,IAAY,EACZ,UAAkB;QAElB,OAAO,IAAI,+BAA+B,CAAC,KAAK,EAAE,IAAI,EAAE;YACtD,GAAG,IAAI,CAAC,KAAK;YACb,SAAS,EAAE,wBAAwB;SACpC,CAAC,CAAC;IACL,CAAC;;AAzBH,wCA0BC;;;AAED,+CAA+C;AAC/C,MAAa,+BAAgC,SAAQ,6CAAoB;IACvE,YACE,KAAgB,EAChB,EAAU,EACV,MAA6C;QAE7C,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;;AAPH,0EAQC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { Construct } from \"constructs\";\nimport { TerraformBackend } from \"../terraform-backend\";\nimport { keysToSnakeCase } from \"../util\";\nimport {\n  TerraformRemoteState,\n  DataTerraformRemoteStateConfig,\n} from \"../terraform-remote-state\";\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport class AzurermBackend extends TerraformBackend {\n  constructor(\n    scope: Construct,\n    private readonly props: AzurermBackendConfig,\n  ) {\n    super(scope, \"backend\", \"azurerm\");\n  }\n\n  protected synthesizeAttributes(): { [name: string]: any } {\n    return keysToSnakeCase({ ...this.props });\n  }\n\n  protected synthesizeHclAttributes(): { [name: string]: any } {\n    return keysToSnakeCase({ ...this.props });\n  }\n\n  public getRemoteStateDataSource(\n    scope: Construct,\n    name: string,\n    _fromStack: string,\n  ): TerraformRemoteState {\n    return new DataTerraformRemoteStateAzurerm(scope, name, {\n      ...this.props,\n      workspace: \"${terraform.workspace}\",\n    });\n  }\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport class DataTerraformRemoteStateAzurerm extends TerraformRemoteState {\n  constructor(\n    scope: Construct,\n    id: string,\n    config: DataTerraformRemoteStateAzurermConfig,\n  ) {\n    super(scope, id, \"azurerm\", config);\n  }\n}\n/**\n * Stores the state as a Blob with the given Key\n * within the Blob Container within the Blob Storage Account.\n *\n * This backend supports state locking and consistency checking\n * with Azure Blob Storage native capabilities.\n *\n * Note: By default the Azure Backend uses ADAL for authentication which is deprecated\n * in favour of MSAL - MSAL can be used by setting use_microsoft_graph to true.\n * The default for this will change in Terraform 1.2,\n * so that MSAL authentication is used by default.\n *\n * Read more about this backend in the Terraform docs:\n * https://developer.hashicorp.com/terraform/language/settings/backends/azurerm\n */\nexport interface AzurermBackendConfig {\n  /**\n   * (Required) The Name of the Storage Account.\n   */\n  readonly storageAccountName: string;\n  /**\n   * (Required) The Name of the Storage Container within the Storage Account.\n   */\n  readonly containerName: string;\n  /**\n   * (Required) The name of the Blob used to retrieve/store Terraform's State file\n   * inside the Storage Container.\n   */\n  readonly key: string;\n  /**\n   * (Optional) The Azure Environment which should be used.\n   * This can also be sourced from the ARM_ENVIRONMENT environment variable.\n   *  Possible values are public, china, german, stack and usgovernment. Defaults to public.\n   */\n  readonly environment?: string;\n  /**\n   * (Optional) The Custom Endpoint for Azure Resource Manager.\n   * This can also be sourced from the ARM_ENDPOINT environment variable.\n   *\n   * NOTE: An endpoint should only be configured when using Azure Stack.\n   */\n  readonly endpoint?: string;\n  /**\n   * (Optional) The Hostname of the Azure Metadata Service (for example management.azure.com),\n   * used to obtain the Cloud Environment when using a Custom Azure Environment.\n   * This can also be sourced from the ARM_METADATA_HOSTNAME Environment Variable.)\n   */\n  readonly metadataHost?: string;\n  /**\n   * (Optional) Should the Blob used to store the Terraform Statefile be\n   * snapshotted before use? Defaults to false. This value can also be sourced\n   * from the ARM_SNAPSHOT environment variable.\n   */\n  readonly snapshot?: boolean;\n  /**\n   * (Optional) The Subscription ID in which the Storage Account exists.\n   * This can also be sourced from the ARM_SUBSCRIPTION_ID environment variable.\n   */\n  readonly subscriptionId?: string;\n  /**\n   * (Optional) The Tenant ID in which the Subscription exists.\n   * This can also be sourced from the ARM_TENANT_ID environment variable.\n   */\n  readonly tenantId?: string;\n  /**\n   * (Optional) The path to a custom Managed Service Identity endpoint which is automatically\n   * determined if not specified.\n   * This can also be sourced from the ARM_MSI_ENDPOINT environment variable.\n   */\n  readonly msiEndpoint?: string;\n  /**\n   * (Optional) Should Managed Service Identity authentication be used?\n   * This can also be sourced from the ARM_USE_MSI environment variable.\n   */\n  readonly useMsi?: boolean;\n  /**\n   * (Optional) The SAS Token used to access the Blob Storage Account.\n   * This can also be sourced from the ARM_SAS_TOKEN environment variable.\n   */\n  readonly sasToken?: string;\n  /**\n   * access_key - (Optional) The Access Key used to access the Blob Storage Account.\n   * This can also be sourced from the ARM_ACCESS_KEY environment variable.\n   */\n  readonly accessKey?: string;\n  /**\n   * (Required) The Name of the Resource Group in which the Storage Account exists.\n   */\n  readonly resourceGroupName?: string;\n  /**\n   * (Optional) The Client ID of the Service Principal.\n   * This can also be sourced from the ARM_CLIENT_ID environment variable.\n   */\n  readonly clientId?: string;\n  /**\n   * (Optional) The Client Secret of the Service Principal.\n   * This can also be sourced from the ARM_CLIENT_SECRET environment variable.\n   */\n  readonly clientSecret?: string;\n  /**\n   * (Optional) The password associated with the Client Certificate specified\n   * in client_certificate_path. This can also be sourced from the\n   * ARM_CLIENT_CERTIFICATE_PASSWORD environment variable.\n   */\n  readonly clientCertificatePassword?: string;\n  /**\n   * (Optional) The path to the PFX file used as the Client Certificate when\n   * authenticating as a Service Principal. This can also be sourced from the\n   * ARM_CLIENT_CERTIFICATE_PATH environment variable.\n   */\n  readonly clientCertificatePath?: string;\n  /**\n   * (Optional) Should MSAL be used for authentication instead of ADAL, and\n   * should Microsoft Graph be used instead of Azure Active Directory Graph?\n   * Defaults to true.\n   *\n   * Note: In Terraform 1.2 the Azure Backend uses MSAL (and Microsoft Graph)\n   * rather than ADAL (and Azure Active Directory Graph) for authentication by\n   * default - you can disable this by setting use_microsoft_graph to false.\n   * This setting will be removed in Terraform 1.3, due to Microsoft's\n   * deprecation of ADAL.\n   */\n  readonly useMicrosoftGraph?: boolean;\n  /**\n   * (Optional) The URL for the OIDC provider from which to request an ID token.\n   * This can also be sourced from the ARM_OIDC_REQUEST_URL or\n   * ACTIONS_ID_TOKEN_REQUEST_URL environment variables.\n   */\n  readonly oidcRequestUrl?: string;\n  /**\n   * (Optional) The bearer token for the request to the OIDC provider. This can\n   * also be sourced from the ARM_OIDC_REQUEST_TOKEN or\n   * ACTIONS_ID_TOKEN_REQUEST_TOKEN environment variables.\n   */\n  readonly oidcRequestToken?: string;\n  /**\n   * (Optional) The ID token when authenticating using OpenID Connect (OIDC).\n   * This can also be sourced from the ARM_OIDC_TOKEN environment variable.\n   */\n  readonly oidcToken?: string;\n  /**\n   * (Optional) The path to a file containing an ID token when authenticating using OpenID Connect (OIDC).\n   * This can also be sourced from the ARM_OIDC_TOKEN_FILE_PATH environment variable.\n   */\n  readonly oidcTokenFilePath?: string;\n  /**\n   * (Optional) Should OIDC authentication be used? This can also be sourced\n   * from the ARM_USE_OIDC environment variable.\n   *\n   * Note: When using OIDC for authentication, use_microsoft_graph\n   * must be set to true (which is the default).\n   */\n  readonly useOidc?: boolean;\n  /**\n   * (Optional) Should AzureAD Authentication be used to access the Blob Storage\n   * Account. This can also be sourced from the ARM_USE_AZUREAD environment\n   * variable.\n   *\n   * Note: When using AzureAD for Authentication to Storage you also need to\n   * ensure the Storage Blob Data Owner role is assigned.\n   */\n  readonly useAzureadAuth?: boolean;\n}\n\nexport interface DataTerraformRemoteStateAzurermConfig\n  extends DataTerraformRemoteStateConfig, AzurermBackendConfig {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"azurerm-backend.js","sourceRoot":"","sources":["../../src/backends/azurerm-backend.ts"],"names":[],"mappings":";;;;AAGA,4DAAwD;AACxD,kCAA0C;AAC1C,sEAGmC;AAEnC,+CAA+C;AAC/C,MAAa,cAAe,SAAQ,oCAAgB;IAG/B;;IAFnB,YACE,KAAgB,EACC,KAA2B;QAE5C,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QAFlB,UAAK,GAAL,KAAK,CAAsB;IAG9C,CAAC;IAES,oBAAoB;QAC5B,OAAO,IAAA,sBAAe,EAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IAC5C,CAAC;IAES,uBAAuB;QAC/B,OAAO,IAAA,sBAAe,EAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IAC5C,CAAC;IAEM,wBAAwB,CAC7B,KAAgB,EAChB,IAAY,EACZ,UAAkB;QAElB,OAAO,IAAI,+BAA+B,CAAC,KAAK,EAAE,IAAI,EAAE;YACtD,GAAG,IAAI,CAAC,KAAK;YACb,SAAS,EAAE,wBAAwB;SACpC,CAAC,CAAC;IACL,CAAC;;AAzBH,wCA0BC;AAED,+CAA+C;AAC/C,MAAa,+BAAgC,SAAQ,6CAAoB;;IACvE,YACE,KAAgB,EAChB,EAAU,EACV,MAA6C;QAE7C,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;;AAPH,0EAQC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { Construct } from \"constructs\";\nimport { TerraformBackend } from \"../terraform-backend\";\nimport { keysToSnakeCase } from \"../util\";\nimport {\n  TerraformRemoteState,\n  DataTerraformRemoteStateConfig,\n} from \"../terraform-remote-state\";\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport class AzurermBackend extends TerraformBackend {\n  constructor(\n    scope: Construct,\n    private readonly props: AzurermBackendConfig,\n  ) {\n    super(scope, \"backend\", \"azurerm\");\n  }\n\n  protected synthesizeAttributes(): { [name: string]: any } {\n    return keysToSnakeCase({ ...this.props });\n  }\n\n  protected synthesizeHclAttributes(): { [name: string]: any } {\n    return keysToSnakeCase({ ...this.props });\n  }\n\n  public getRemoteStateDataSource(\n    scope: Construct,\n    name: string,\n    _fromStack: string,\n  ): TerraformRemoteState {\n    return new DataTerraformRemoteStateAzurerm(scope, name, {\n      ...this.props,\n      workspace: \"${terraform.workspace}\",\n    });\n  }\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport class DataTerraformRemoteStateAzurerm extends TerraformRemoteState {\n  constructor(\n    scope: Construct,\n    id: string,\n    config: DataTerraformRemoteStateAzurermConfig,\n  ) {\n    super(scope, id, \"azurerm\", config);\n  }\n}\n/**\n * Stores the state as a Blob with the given Key\n * within the Blob Container within the Blob Storage Account.\n *\n * This backend supports state locking and consistency checking\n * with Azure Blob Storage native capabilities.\n *\n * Note: By default the Azure Backend uses ADAL for authentication which is deprecated\n * in favour of MSAL - MSAL can be used by setting use_microsoft_graph to true.\n * The default for this will change in Terraform 1.2,\n * so that MSAL authentication is used by default.\n *\n * Read more about this backend in the Terraform docs:\n * https://developer.hashicorp.com/terraform/language/settings/backends/azurerm\n */\nexport interface AzurermBackendConfig {\n  /**\n   * (Required) The Name of the Storage Account.\n   */\n  readonly storageAccountName: string;\n  /**\n   * (Required) The Name of the Storage Container within the Storage Account.\n   */\n  readonly containerName: string;\n  /**\n   * (Required) The name of the Blob used to retrieve/store Terraform's State file\n   * inside the Storage Container.\n   */\n  readonly key: string;\n  /**\n   * (Optional) The Azure Environment which should be used.\n   * This can also be sourced from the ARM_ENVIRONMENT environment variable.\n   *  Possible values are public, china, german, stack and usgovernment. Defaults to public.\n   */\n  readonly environment?: string;\n  /**\n   * (Optional) The Custom Endpoint for Azure Resource Manager.\n   * This can also be sourced from the ARM_ENDPOINT environment variable.\n   *\n   * NOTE: An endpoint should only be configured when using Azure Stack.\n   */\n  readonly endpoint?: string;\n  /**\n   * (Optional) The Hostname of the Azure Metadata Service (for example management.azure.com),\n   * used to obtain the Cloud Environment when using a Custom Azure Environment.\n   * This can also be sourced from the ARM_METADATA_HOSTNAME Environment Variable.)\n   */\n  readonly metadataHost?: string;\n  /**\n   * (Optional) Should the Blob used to store the Terraform Statefile be\n   * snapshotted before use? Defaults to false. This value can also be sourced\n   * from the ARM_SNAPSHOT environment variable.\n   */\n  readonly snapshot?: boolean;\n  /**\n   * (Optional) The Subscription ID in which the Storage Account exists.\n   * This can also be sourced from the ARM_SUBSCRIPTION_ID environment variable.\n   */\n  readonly subscriptionId?: string;\n  /**\n   * (Optional) The Tenant ID in which the Subscription exists.\n   * This can also be sourced from the ARM_TENANT_ID environment variable.\n   */\n  readonly tenantId?: string;\n  /**\n   * (Optional) The path to a custom Managed Service Identity endpoint which is automatically\n   * determined if not specified.\n   * This can also be sourced from the ARM_MSI_ENDPOINT environment variable.\n   */\n  readonly msiEndpoint?: string;\n  /**\n   * (Optional) Should Managed Service Identity authentication be used?\n   * This can also be sourced from the ARM_USE_MSI environment variable.\n   */\n  readonly useMsi?: boolean;\n  /**\n   * (Optional) The SAS Token used to access the Blob Storage Account.\n   * This can also be sourced from the ARM_SAS_TOKEN environment variable.\n   */\n  readonly sasToken?: string;\n  /**\n   * access_key - (Optional) The Access Key used to access the Blob Storage Account.\n   * This can also be sourced from the ARM_ACCESS_KEY environment variable.\n   */\n  readonly accessKey?: string;\n  /**\n   * (Required) The Name of the Resource Group in which the Storage Account exists.\n   */\n  readonly resourceGroupName?: string;\n  /**\n   * (Optional) The Client ID of the Service Principal.\n   * This can also be sourced from the ARM_CLIENT_ID environment variable.\n   */\n  readonly clientId?: string;\n  /**\n   * (Optional) The Client Secret of the Service Principal.\n   * This can also be sourced from the ARM_CLIENT_SECRET environment variable.\n   */\n  readonly clientSecret?: string;\n  /**\n   * (Optional) The password associated with the Client Certificate specified\n   * in client_certificate_path. This can also be sourced from the\n   * ARM_CLIENT_CERTIFICATE_PASSWORD environment variable.\n   */\n  readonly clientCertificatePassword?: string;\n  /**\n   * (Optional) The path to the PFX file used as the Client Certificate when\n   * authenticating as a Service Principal. This can also be sourced from the\n   * ARM_CLIENT_CERTIFICATE_PATH environment variable.\n   */\n  readonly clientCertificatePath?: string;\n  /**\n   * (Optional) Should MSAL be used for authentication instead of ADAL, and\n   * should Microsoft Graph be used instead of Azure Active Directory Graph?\n   * Defaults to true.\n   *\n   * Note: In Terraform 1.2 the Azure Backend uses MSAL (and Microsoft Graph)\n   * rather than ADAL (and Azure Active Directory Graph) for authentication by\n   * default - you can disable this by setting use_microsoft_graph to false.\n   * This setting will be removed in Terraform 1.3, due to Microsoft's\n   * deprecation of ADAL.\n   */\n  readonly useMicrosoftGraph?: boolean;\n  /**\n   * (Optional) The URL for the OIDC provider from which to request an ID token.\n   * This can also be sourced from the ARM_OIDC_REQUEST_URL or\n   * ACTIONS_ID_TOKEN_REQUEST_URL environment variables.\n   */\n  readonly oidcRequestUrl?: string;\n  /**\n   * (Optional) The bearer token for the request to the OIDC provider. This can\n   * also be sourced from the ARM_OIDC_REQUEST_TOKEN or\n   * ACTIONS_ID_TOKEN_REQUEST_TOKEN environment variables.\n   */\n  readonly oidcRequestToken?: string;\n  /**\n   * (Optional) The ID token when authenticating using OpenID Connect (OIDC).\n   * This can also be sourced from the ARM_OIDC_TOKEN environment variable.\n   */\n  readonly oidcToken?: string;\n  /**\n   * (Optional) The path to a file containing an ID token when authenticating using OpenID Connect (OIDC).\n   * This can also be sourced from the ARM_OIDC_TOKEN_FILE_PATH environment variable.\n   */\n  readonly oidcTokenFilePath?: string;\n  /**\n   * (Optional) Should OIDC authentication be used? This can also be sourced\n   * from the ARM_USE_OIDC environment variable.\n   *\n   * Note: When using OIDC for authentication, use_microsoft_graph\n   * must be set to true (which is the default).\n   */\n  readonly useOidc?: boolean;\n  /**\n   * (Optional) Should AzureAD Authentication be used to access the Blob Storage\n   * Account. This can also be sourced from the ARM_USE_AZUREAD environment\n   * variable.\n   *\n   * Note: When using AzureAD for Authentication to Storage you also need to\n   * ensure the Storage Blob Data Owner role is assigned.\n   */\n  readonly useAzureadAuth?: boolean;\n}\n\nexport interface DataTerraformRemoteStateAzurermConfig\n  extends DataTerraformRemoteStateConfig, AzurermBackendConfig {}\n"]}

package/lib/backends/cloud-backend.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaggedCloudWorkspaces = exports.NamedCloudWorkspace = exports.CloudWorkspace = exports.CloudBackend = void 0;
 exports.getHostNameType = getHostNameType;
@@ -7,7 +6,7 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const util_1 = require("../util");
 const remote_backend_1 = require("./remote-backend");
 const terraform_backend_1 = require("../terraform-backend");
-const validate_terraform_version_1 = require("../validations/validate-terraform-version");
+const validations_1 = require("../validations");
 const errors_1 = require("../errors");
 /**
  * checks whether the given hostname belongs to tfc or (else) to tfe
@@ -28,10 +27,15 @@ function getHostNameType(hostname) {
  * When Terraform Cloud uses a configuration that contains a cloud block - for example, when a workspace is configured to use a VCS provider directly - it ignores the block and behaves according to its own workspace settings.
  */
 class CloudBackend extends terraform_backend_1.TerraformBackend {
+    props;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.CloudBackend", version: "0.25.0" };
     constructor(scope, props) {
         super(scope, "backend", "cloud");
         this.props = props;
-        this.node.addValidation(new validate_terraform_version_1.ValidateTerraformVersion(">=1.1", `The cloud block is only supported for Terraform >=1.1. Please upgrade your Terraform version.`));
+        this.node.addValidation(new validations_1.ValidateFeatureTargetSupport(this, "The cloud block", {
+            terraform: ">=1.1.0",
+            opentofu: ">=1.6.0",
+        }));
     }
     toHclTerraform() {
         return {
@@ -86,21 +90,21 @@ class CloudBackend extends terraform_backend_1.TerraformBackend {
     }
 }
 exports.CloudBackend = CloudBackend;
-_a = JSII_RTTI_SYMBOL_1;
-CloudBackend[_a] = { fqn: "cdktn.CloudBackend", version: "0.25.0-pre.8" };
 /**
  * A cloud workspace can either be a single named workspace, or a list of tagged workspaces.
  */
 class CloudWorkspace {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.CloudWorkspace", version: "0.25.0" };
 }
 exports.CloudWorkspace = CloudWorkspace;
-_b = JSII_RTTI_SYMBOL_1;
-CloudWorkspace[_b] = { fqn: "cdktn.CloudWorkspace", version: "0.25.0-pre.8" };
 /**
  * The name of a single Terraform Cloud workspace.
  * You will only be able to use the workspace specified in the configuration with this working directory, and cannot manage workspaces from the CLI (e.g. terraform workspace select or terraform workspace new).
  */
 class NamedCloudWorkspace extends CloudWorkspace {
+    name;
+    project;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.NamedCloudWorkspace", version: "0.25.0" };
     constructor(name, project) {
         super();
         this.name = name;
@@ -123,12 +127,13 @@ class NamedCloudWorkspace extends CloudWorkspace {
     }
 }
 exports.NamedCloudWorkspace = NamedCloudWorkspace;
-_c = JSII_RTTI_SYMBOL_1;
-NamedCloudWorkspace[_c] = { fqn: "cdktn.NamedCloudWorkspace", version: "0.25.0-pre.8" };
 /**
  *  A set of Terraform Cloud workspace tags. You will be able to use this working directory with any workspaces that have all of the specified tags, and can use the terraform workspace commands to switch between them or create new workspaces. New workspaces will automatically have the specified tags. This option conflicts with name.
  */
 class TaggedCloudWorkspaces extends CloudWorkspace {
+    tags;
+    project;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.TaggedCloudWorkspaces", version: "0.25.0" };
     constructor(tags, project) {
         super();
         this.tags = tags;
@@ -151,6 +156,4 @@ class TaggedCloudWorkspaces extends CloudWorkspace {
     }
 }
 exports.TaggedCloudWorkspaces = TaggedCloudWorkspaces;
-_d = JSII_RTTI_SYMBOL_1;
-TaggedCloudWorkspaces[_d] = { fqn: "cdktn.TaggedCloudWorkspaces", version: "0.25.0-pre.8" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-backend.js","sourceRoot":"","sources":["../../src/backends/cloud-backend.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { Construct } from \"constructs\";\nimport { keysToSnakeCase, deepMerge } from \"../util\";\nimport { DataTerraformRemoteState } from \"./remote-backend\";\nimport { TerraformRemoteState } from \"../terraform-remote-state\";\nimport { TerraformBackend } from \"../terraform-backend\";\nimport { ValidateTerraformVersion } from \"../validations/validate-terraform-version\";\nimport { cloudBackendWorkspaceIsNotDefinedByName } from \"../errors\";\n\n/**\n * checks whether the given hostname belongs to tfc or (else) to tfe\n * If no hostname is given, it will return tfc, as that's the default in backends.\n * @param hostname e.g. app.terraform.io, app.terraform.io:80, tfe.myorg.org\n * @returns \"tfc\" or \"tfe\"\n */\nexport function getHostNameType(hostname?: string): \"tfc\" | \"tfe\" {\n  if (!hostname) return \"tfc\"; // default is tfc when not passing a hostname to backends\n  return hostname.startsWith(\"app.terraform.io\") ? \"tfc\" : \"tfe\";\n}\n\n/**\n * The Cloud Backend synthesizes a {@link https://developer.hashicorp.com/terraform/cli/cloud/settings#the-cloud-block cloud block}.\n * The cloud block is a nested block within the top-level terraform settings block.\n * It specifies which Terraform Cloud workspaces to use for the current working directory.\n * The cloud block only affects Terraform CLI's behavior.\n * When Terraform Cloud uses a configuration that contains a cloud block - for example, when a workspace is configured to use a VCS provider directly - it ignores the block and behaves according to its own workspace settings.\n */\nexport class CloudBackend extends TerraformBackend {\n  constructor(\n    scope: Construct,\n    private readonly props: CloudBackendConfig,\n  ) {\n    super(scope, \"backend\", \"cloud\");\n\n    this.node.addValidation(\n      new ValidateTerraformVersion(\n        \">=1.1\",\n        `The cloud block is only supported for Terraform >=1.1. Please upgrade your Terraform version.`,\n      ),\n    );\n  }\n\n  public toHclTerraform(): any {\n    return {\n      terraform: {\n        cloud: deepMerge(this.synthesizeHclAttributes(), this.rawOverrides),\n      },\n    };\n  }\n\n  /**\n   * Adds this resource to the terraform JSON output.\n   */\n  public toTerraform(): any {\n    return {\n      terraform: {\n        cloud: deepMerge(this.synthesizeAttributes(), this.rawOverrides),\n      },\n    };\n  }\n\n  public toMetadata() {\n    const cloud = getHostNameType(this.props.hostname);\n    return { ...super.toMetadata(), cloud };\n  }\n\n  protected synthesizeHclAttributes(): { [name: string]: any } {\n    return {\n      ...keysToSnakeCase(this.props),\n      workspaces: {\n        value: this.props.workspaces.toHclTerraform(),\n        isBlock: true,\n        type: \"map\",\n        storageClassType: \"stringmap\",\n      },\n    };\n  }\n\n  protected synthesizeAttributes(): { [name: string]: any } {\n    return keysToSnakeCase({\n      ...this.props,\n      workspaces: this.props.workspaces.toTerraform(),\n    });\n  }\n\n  public getRemoteStateDataSource(\n    scope: Construct,\n    name: string,\n    _fromStack: string,\n  ): TerraformRemoteState {\n    // The cloud \"backend\" does not have a coresponding remote state data source since it's meant to also\n    // work with multiple workspaces through tags.\n    if (\"name\" in this.props.workspaces) {\n      return new DataTerraformRemoteState(scope, name, {\n        organization: this.props.organization,\n        workspaces: { name: (this.props.workspaces as any).name },\n        token: this.props.token,\n        hostname: this.props.hostname,\n      });\n    }\n\n    throw cloudBackendWorkspaceIsNotDefinedByName();\n  }\n}\n\n/**\n * The Cloud Backend synthesizes a {@link https://developer.hashicorp.com/terraform/cli/cloud/settings#the-cloud-block cloud block}.\n * The cloud block is a nested block within the top-level terraform settings block.\n * It specifies which Terraform Cloud workspaces to use for the current working directory.\n * The cloud block only affects Terraform CLI's behavior.\n * When Terraform Cloud uses a configuration that contains a cloud block - for example, when a workspace is configured to use a VCS provider directly - it ignores the block and behaves according to its own workspace settings.\n *\n * https://developer.hashicorp.com/terraform/cli/cloud/settings#arguments\n */\nexport interface CloudBackendConfig {\n  /**\n   * The name of the organization containing the workspace(s) the current configuration should use.\n   */\n  readonly organization: string;\n\n  /**\n   * A nested block that specifies which remote Terraform Cloud workspaces to use for the current configuration.\n   * The workspaces block must contain exactly one of the following arguments, each denoting a strategy for how workspaces should be mapped:\n   */\n  readonly workspaces: NamedCloudWorkspace | TaggedCloudWorkspaces;\n\n  /**\n   * The hostname of a Terraform Enterprise installation, if using Terraform Enterprise.\n   *\n   * @default app.terraform.io\n   */\n  readonly hostname?: string;\n\n  /**\n   * The token used to authenticate with Terraform Cloud.\n   * We recommend omitting the token from the configuration, and instead using terraform login or manually configuring credentials in the CLI config file.\n   */\n  readonly token?: string;\n}\n\n/**\n * A cloud workspace can either be a single named workspace, or a list of tagged workspaces.\n */\nexport abstract class CloudWorkspace {\n  public abstract toTerraform(): any;\n}\n\n/**\n * The name of a single Terraform Cloud workspace.\n * You will only be able to use the workspace specified in the configuration with this working directory, and cannot manage workspaces from the CLI (e.g. terraform workspace select or terraform workspace new).\n */\nexport class NamedCloudWorkspace extends CloudWorkspace {\n  public constructor(\n    public name: string,\n    public project?: string,\n  ) {\n    super();\n  }\n\n  public toHclTerraform(): any {\n    return {\n      name: {\n        value: this.name,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n    };\n  }\n\n  public toTerraform(): any {\n    return {\n      name: this.name,\n      project: this.project,\n    };\n  }\n}\n\n/**\n *  A set of Terraform Cloud workspace tags. You will be able to use this working directory with any workspaces that have all of the specified tags, and can use the terraform workspace commands to switch between them or create new workspaces. New workspaces will automatically have the specified tags. This option conflicts with name.\n */\nexport class TaggedCloudWorkspaces extends CloudWorkspace {\n  public constructor(\n    public tags: string[],\n    public project?: string,\n  ) {\n    super();\n  }\n\n  public toHclTerraform(): any {\n    return {\n      tags: {\n        value: this.tags,\n        type: \"list\",\n        storageClassType: \"stringList\",\n      },\n    };\n  }\n\n  public toTerraform(): any {\n    return {\n      tags: this.tags,\n      project: this.project,\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-backend.js","sourceRoot":"","sources":["../../src/backends/cloud-backend.ts"],"names":[],"mappings":";;;AAgBA,0CAGC;;AAhBD,kCAAqD;AACrD,qDAA4D;AAE5D,4DAAwD;AACxD,gDAA8D;AAC9D,sCAAoE;AAEpE;;;;;GAKG;AACH,SAAgB,eAAe,CAAC,QAAiB;IAC/C,IAAI,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC,CAAC,yDAAyD;IACtF,OAAO,QAAQ,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;AACjE,CAAC;AAED;;;;;;GAMG;AACH,MAAa,YAAa,SAAQ,oCAAgB;IAG7B;;IAFnB,YACE,KAAgB,EACC,KAAyB;QAE1C,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAFhB,UAAK,GAAL,KAAK,CAAoB;QAI1C,IAAI,CAAC,IAAI,CAAC,aAAa,CACrB,IAAI,0CAA4B,CAAC,IAAI,EAAE,iBAAiB,EAAE;YACxD,SAAS,EAAE,SAAS;YACpB,QAAQ,EAAE,SAAS;SACpB,CAAC,CACH,CAAC;IACJ,CAAC;IAEM,cAAc;QACnB,OAAO;YACL,SAAS,EAAE;gBACT,KAAK,EAAE,IAAA,gBAAS,EAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,IAAI,CAAC,YAAY,CAAC;aACpE;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO;YACL,SAAS,EAAE;gBACT,KAAK,EAAE,IAAA,gBAAS,EAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,IAAI,CAAC,YAAY,CAAC;aACjE;SACF,CAAC;IACJ,CAAC;IAEM,UAAU;QACf,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACnD,OAAO,EAAE,GAAG,KAAK,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,CAAC;IAC1C,CAAC;IAES,uBAAuB;QAC/B,OAAO;YACL,GAAG,IAAA,sBAAe,EAAC,IAAI,CAAC,KAAK,CAAC;YAC9B,UAAU,EAAE;gBACV,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,cAAc,EAAE;gBAC7C,OAAO,EAAE,IAAI;gBACb,IAAI,EAAE,KAAK;gBACX,gBAAgB,EAAE,WAAW;aAC9B;SACF,CAAC;IACJ,CAAC;IAES,oBAAoB;QAC5B,OAAO,IAAA,sBAAe,EAAC;YACrB,GAAG,IAAI,CAAC,KAAK;YACb,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE;SAChD,CAAC,CAAC;IACL,CAAC;IAEM,wBAAwB,CAC7B,KAAgB,EAChB,IAAY,EACZ,UAAkB;QAElB,qGAAqG;QACrG,8CAA8C;QAC9C,IAAI,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC;YACpC,OAAO,IAAI,yCAAwB,CAAC,KAAK,EAAE,IAAI,EAAE;gBAC/C,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY;gBACrC,UAAU,EAAE,EAAE,IAAI,EAAG,IAAI,CAAC,KAAK,CAAC,UAAkB,CAAC,IAAI,EAAE;gBACzD,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK;gBACvB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;aAC9B,CAAC,CAAC;QACL,CAAC;QAED,MAAM,IAAA,gDAAuC,GAAE,CAAC;IAClD,CAAC;;AA3EH,oCA4EC;AAqCD;;GAEG;AACH,MAAsB,cAAc;;;AAApC,wCAEC;AAED;;;GAGG;AACH,MAAa,mBAAoB,SAAQ,cAAc;IAE5C;IACA;;IAFT,YACS,IAAY,EACZ,OAAgB;QAEvB,KAAK,EAAE,CAAC;QAHD,SAAI,GAAJ,IAAI,CAAQ;QACZ,YAAO,GAAP,OAAO,CAAS;IAGzB,CAAC;IAEM,cAAc;QACnB,OAAO;YACL,IAAI,EAAE;gBACJ,KAAK,EAAE,IAAI,CAAC,IAAI;gBAChB,IAAI,EAAE,QAAQ;gBACd,gBAAgB,EAAE,QAAQ;aAC3B;SACF,CAAC;IACJ,CAAC;IAEM,WAAW;QAChB,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAC;IACJ,CAAC;;AAvBH,kDAwBC;AAED;;GAEG;AACH,MAAa,qBAAsB,SAAQ,cAAc;IAE9C;IACA;;IAFT,YACS,IAAc,EACd,OAAgB;QAEvB,KAAK,EAAE,CAAC;QAHD,SAAI,GAAJ,IAAI,CAAU;QACd,YAAO,GAAP,OAAO,CAAS;IAGzB,CAAC;IAEM,cAAc;QACnB,OAAO;YACL,IAAI,EAAE;gBACJ,KAAK,EAAE,IAAI,CAAC,IAAI;gBAChB,IAAI,EAAE,MAAM;gBACZ,gBAAgB,EAAE,YAAY;aAC/B;SACF,CAAC;IACJ,CAAC;IAEM,WAAW;QAChB,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAC;IACJ,CAAC;;AAvBH,sDAwBC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { Construct } from \"constructs\";\nimport { keysToSnakeCase, deepMerge } from \"../util\";\nimport { DataTerraformRemoteState } from \"./remote-backend\";\nimport { TerraformRemoteState } from \"../terraform-remote-state\";\nimport { TerraformBackend } from \"../terraform-backend\";\nimport { ValidateFeatureTargetSupport } from \"../validations\";\nimport { cloudBackendWorkspaceIsNotDefinedByName } from \"../errors\";\n\n/**\n * checks whether the given hostname belongs to tfc or (else) to tfe\n * If no hostname is given, it will return tfc, as that's the default in backends.\n * @param hostname e.g. app.terraform.io, app.terraform.io:80, tfe.myorg.org\n * @returns \"tfc\" or \"tfe\"\n */\nexport function getHostNameType(hostname?: string): \"tfc\" | \"tfe\" {\n  if (!hostname) return \"tfc\"; // default is tfc when not passing a hostname to backends\n  return hostname.startsWith(\"app.terraform.io\") ? \"tfc\" : \"tfe\";\n}\n\n/**\n * The Cloud Backend synthesizes a {@link https://developer.hashicorp.com/terraform/cli/cloud/settings#the-cloud-block cloud block}.\n * The cloud block is a nested block within the top-level terraform settings block.\n * It specifies which Terraform Cloud workspaces to use for the current working directory.\n * The cloud block only affects Terraform CLI's behavior.\n * When Terraform Cloud uses a configuration that contains a cloud block - for example, when a workspace is configured to use a VCS provider directly - it ignores the block and behaves according to its own workspace settings.\n */\nexport class CloudBackend extends TerraformBackend {\n  constructor(\n    scope: Construct,\n    private readonly props: CloudBackendConfig,\n  ) {\n    super(scope, \"backend\", \"cloud\");\n\n    this.node.addValidation(\n      new ValidateFeatureTargetSupport(this, \"The cloud block\", {\n        terraform: \">=1.1.0\",\n        opentofu: \">=1.6.0\",\n      }),\n    );\n  }\n\n  public toHclTerraform(): any {\n    return {\n      terraform: {\n        cloud: deepMerge(this.synthesizeHclAttributes(), this.rawOverrides),\n      },\n    };\n  }\n\n  /**\n   * Adds this resource to the terraform JSON output.\n   */\n  public toTerraform(): any {\n    return {\n      terraform: {\n        cloud: deepMerge(this.synthesizeAttributes(), this.rawOverrides),\n      },\n    };\n  }\n\n  public toMetadata() {\n    const cloud = getHostNameType(this.props.hostname);\n    return { ...super.toMetadata(), cloud };\n  }\n\n  protected synthesizeHclAttributes(): { [name: string]: any } {\n    return {\n      ...keysToSnakeCase(this.props),\n      workspaces: {\n        value: this.props.workspaces.toHclTerraform(),\n        isBlock: true,\n        type: \"map\",\n        storageClassType: \"stringmap\",\n      },\n    };\n  }\n\n  protected synthesizeAttributes(): { [name: string]: any } {\n    return keysToSnakeCase({\n      ...this.props,\n      workspaces: this.props.workspaces.toTerraform(),\n    });\n  }\n\n  public getRemoteStateDataSource(\n    scope: Construct,\n    name: string,\n    _fromStack: string,\n  ): TerraformRemoteState {\n    // The cloud \"backend\" does not have a coresponding remote state data source since it's meant to also\n    // work with multiple workspaces through tags.\n    if (\"name\" in this.props.workspaces) {\n      return new DataTerraformRemoteState(scope, name, {\n        organization: this.props.organization,\n        workspaces: { name: (this.props.workspaces as any).name },\n        token: this.props.token,\n        hostname: this.props.hostname,\n      });\n    }\n\n    throw cloudBackendWorkspaceIsNotDefinedByName();\n  }\n}\n\n/**\n * The Cloud Backend synthesizes a {@link https://developer.hashicorp.com/terraform/cli/cloud/settings#the-cloud-block cloud block}.\n * The cloud block is a nested block within the top-level terraform settings block.\n * It specifies which Terraform Cloud workspaces to use for the current working directory.\n * The cloud block only affects Terraform CLI's behavior.\n * When Terraform Cloud uses a configuration that contains a cloud block - for example, when a workspace is configured to use a VCS provider directly - it ignores the block and behaves according to its own workspace settings.\n *\n * https://developer.hashicorp.com/terraform/cli/cloud/settings#arguments\n */\nexport interface CloudBackendConfig {\n  /**\n   * The name of the organization containing the workspace(s) the current configuration should use.\n   */\n  readonly organization: string;\n\n  /**\n   * A nested block that specifies which remote Terraform Cloud workspaces to use for the current configuration.\n   * The workspaces block must contain exactly one of the following arguments, each denoting a strategy for how workspaces should be mapped:\n   */\n  readonly workspaces: NamedCloudWorkspace | TaggedCloudWorkspaces;\n\n  /**\n   * The hostname of a Terraform Enterprise installation, if using Terraform Enterprise.\n   *\n   * @default app.terraform.io\n   */\n  readonly hostname?: string;\n\n  /**\n   * The token used to authenticate with Terraform Cloud.\n   * We recommend omitting the token from the configuration, and instead using terraform login or manually configuring credentials in the CLI config file.\n   */\n  readonly token?: string;\n}\n\n/**\n * A cloud workspace can either be a single named workspace, or a list of tagged workspaces.\n */\nexport abstract class CloudWorkspace {\n  public abstract toTerraform(): any;\n}\n\n/**\n * The name of a single Terraform Cloud workspace.\n * You will only be able to use the workspace specified in the configuration with this working directory, and cannot manage workspaces from the CLI (e.g. terraform workspace select or terraform workspace new).\n */\nexport class NamedCloudWorkspace extends CloudWorkspace {\n  public constructor(\n    public name: string,\n    public project?: string,\n  ) {\n    super();\n  }\n\n  public toHclTerraform(): any {\n    return {\n      name: {\n        value: this.name,\n        type: \"simple\",\n        storageClassType: \"string\",\n      },\n    };\n  }\n\n  public toTerraform(): any {\n    return {\n      name: this.name,\n      project: this.project,\n    };\n  }\n}\n\n/**\n *  A set of Terraform Cloud workspace tags. You will be able to use this working directory with any workspaces that have all of the specified tags, and can use the terraform workspace commands to switch between them or create new workspaces. New workspaces will automatically have the specified tags. This option conflicts with name.\n */\nexport class TaggedCloudWorkspaces extends CloudWorkspace {\n  public constructor(\n    public tags: string[],\n    public project?: string,\n  ) {\n    super();\n  }\n\n  public toHclTerraform(): any {\n    return {\n      tags: {\n        value: this.tags,\n        type: \"list\",\n        storageClassType: \"stringList\",\n      },\n    };\n  }\n\n  public toTerraform(): any {\n    return {\n      tags: this.tags,\n      project: this.project,\n    };\n  }\n}\n"]}