cdktn 0.25.0-pre.9 → 0.25.0

package/lib/private/fs.d.ts

@@ -1,15 +1,52 @@
+/**
+ * Predicate deciding whether a tree entry is skipped.
+ * `relPath` is always `/`-separated and relative to the walk root, so patterns
+ * behave identically on Windows. `isDirectory` is supplied from the walker's
+ * `lstat` so `.gitignore` / `.dockerignore`-style directory-only patterns can
+ * be honored without the predicate stat-ing the path itself.
+ */
+export type ExcludePredicate = (relPath: string, isDirectory: boolean) => boolean;
+export interface CopySyncOptions {
+    /**
+     * Entries for which this returns true are not copied. Called with the
+     * entry's `/`-separated relative path and whether it is a directory.
+     * Excluding a directory also skips everything below it, unless
+     * {@link descendIntoExcludedDirectories} is set.
+     *
+     * @default - nothing is excluded
+     */
+    readonly shouldExclude?: ExcludePredicate;
+    /**
+     * Keep walking into an excluded directory instead of pruning it. The
+     * directory entry itself is still omitted; its children are visited and
+     * re-tested against {@link shouldExclude}, so a strategy with negation
+     * patterns (`node_modules` + `!node_modules/keep`) can re-include entries
+     * below an excluded parent. Costs a full walk of excluded subtrees, so it
+     * is off unless a strategy asks for it.
+     *
+     * @default false
+     */
+    readonly descendIntoExcludedDirectories?: boolean;
+}
 /**
  * Copy a file or directory. The directory can have contents and subfolders.
+ * Symlinks are recreated as symlinks rather than dereferenced, which keeps the
+ * copy consistent with {@link hashPath} (it hashes links by their target) and
+ * makes dangling links and link cycles harmless.
  * @param src - source path
  * @param dest - destination path
+ * @param options - copy behaviour, see {@link CopySyncOptions}
  */
-export declare function copySync(src: string, dest: string): void;
+export declare function copySync(src: string, dest: string, options?: CopySyncOptions): void;
 /**
  * Zips contents at src and places zip archive at dest.
  * @param src - directory to archive
  * @param dest - path to write the resulting zip to
+ * @param shouldExclude - entries to omit, see {@link CopySyncOptions.shouldExclude}
+ * @param descendIntoExcludedDirectories - keep walking excluded directories,
+ * see {@link CopySyncOptions.descendIntoExcludedDirectories}
  */
-export declare function archiveSync(src: string, dest: string): void;
+export declare function archiveSync(src: string, dest: string, shouldExclude?: ExcludePredicate, descendIntoExcludedDirectories?: boolean): void;
 export interface HashPathOptions {
     /**
      * Use the canonical entry-framed hash instead of the legacy
@@ -25,6 +62,25 @@ export interface HashPathOptions {
      * the legacy scheme, which never records directories.
      */
     readonly archive?: boolean;
+    /**
+     * Entries for which this returns true are omitted from the digest. Excluding
+     * a directory also omits everything below it, unless
+     * {@link descendIntoExcludedDirectories} is set. The same predicate must be
+     * given to {@link copySync} so the hash and the emitted artifact describe the
+     * same set of files.
+     *
+     * @default - nothing is excluded
+     */
+    readonly shouldExclude?: ExcludePredicate;
+    /**
+     * Keep walking into excluded directories, see
+     * {@link CopySyncOptions.descendIntoExcludedDirectories}. Must match the
+     * value given to {@link copySync} / {@link archiveSync} so the digest covers
+     * the same file set the artifact contains.
+     *
+     * @default false
+     */
+    readonly descendIntoExcludedDirectories?: boolean;
 }
 /**
  * Compute a stable MD5 hash of a file or directory's contents.
@@ -37,6 +93,22 @@ export interface HashPathOptions {
  * @returns uppercased hex digest, truncated to HASH_LEN characters
  */
 export declare function hashPath(src: string, options?: HashPathOptions): string;
+/**
+ * Build a predicate matching the exclusion forms accepted by
+ * `AssetHashOptions.exclude` (via `ExcludeIgnoreStrategy`): an exact relative
+ * path, a `*.ext` suffix, or a directory (with or without a trailing `/`),
+ * which also excludes its contents.
+ * Deliberately not a full glob implementation — `**`, `?`, character classes and
+ * `!` negation are not supported, and a pattern is never interpreted as
+ * anchoring to a subdirectory it does not name.
+ * The returned matcher looks only at the path, not at whether the entry is a
+ * directory: `dir` and `dir/` both match a directory named `dir` and its
+ * contents. It is therefore narrower than {@link ExcludePredicate}, which also
+ * receives an `isDirectory` flag for strategies that need it.
+ * @param exclude - patterns to exclude
+ * @returns predicate over `/`-separated paths relative to the asset root
+ */
+export declare function excludeMatcher(exclude: string[]): (relativePath: string) => boolean;
 /**
  * Walk upward from `rootPath` looking for a file with the given name.
  * Returns the absolute path of the first match, or `null` if the search

package/lib/private/fs.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.copySync = copySync;
 exports.archiveSync = archiveSync;
 exports.hashPath = hashPath;
+exports.excludeMatcher = excludeMatcher;
 exports.findFileAboveCwd = findFileAboveCwd;
 // Copyright (c) HashiCorp, Inc
 // SPDX-License-Identifier: MPL-2.0
@@ -67,17 +68,28 @@ function zipAttrs(mode) {
 // Full implementation at https://github.com/jprichardson/node-fs-extra/blob/master/lib/copy/copy-sync.js
 /**
  * Copy a file or directory. The directory can have contents and subfolders.
+ * Symlinks are recreated as symlinks rather than dereferenced, which keeps the
+ * copy consistent with {@link hashPath} (it hashes links by their target) and
+ * makes dangling links and link cycles harmless.
  * @param src - source path
  * @param dest - destination path
+ * @param options - copy behaviour, see {@link CopySyncOptions}
  */
-function copySync(src, dest) {
+function copySync(src, dest, options = {}) {
     /**
      * Copies file if present otherwise walks subfolder.
      * @param p - path relative to src/dest
+     * @param relPath - `/`-separated path relative to the copy root
      */
-    function copyItem(p) {
+    function copyItem(p, relPath) {
         const sourcePath = path.resolve(src, p);
         const stat = fs.lstatSync(sourcePath);
+        const excluded = !!options.shouldExclude?.(relPath, stat.isDirectory());
+        // Skip, unless it is an excluded directory being descended into.
+        if (excluded &&
+            !(stat.isDirectory() && options.descendIntoExcludedDirectories)) {
+            return;
+        }
         if (stat.isSymbolicLink()) {
             fs.symlinkSync(fs.readlinkSync(sourcePath), path.resolve(dest, p));
         }
@@ -85,26 +97,30 @@ function copySync(src, dest) {
             fs.copyFileSync(sourcePath, path.resolve(dest, p));
         }
         else if (stat.isDirectory()) {
-            walkSubfolder(p);
+            walkSubfolder(p, relPath);
         }
     }
     /**
      * Copies contents of subfolder.
      * @param p - path relative to src/dest
+     * @param relPath - `/`-separated path relative to the copy root
      */
-    function walkSubfolder(p) {
+    function walkSubfolder(p, relPath) {
         const sourceDir = path.resolve(src, p);
         fs.mkdirSync(path.resolve(dest, p), { recursive: true });
-        fs.readdirSync(sourceDir).forEach((item) => copyItem(path.join(p, item)));
+        fs.readdirSync(sourceDir).forEach((item) => copyItem(path.join(p, item), relPath ? `${relPath}/${item}` : item));
     }
-    walkSubfolder(".");
+    walkSubfolder(".", "");
 }
 /**
  * Zips contents at src and places zip archive at dest.
  * @param src - directory to archive
  * @param dest - path to write the resulting zip to
+ * @param shouldExclude - entries to omit, see {@link CopySyncOptions.shouldExclude}
+ * @param descendIntoExcludedDirectories - keep walking excluded directories,
+ * see {@link CopySyncOptions.descendIntoExcludedDirectories}
  */
-function archiveSync(src, dest) {
+function archiveSync(src, dest, shouldExclude, descendIntoExcludedDirectories = false) {
     try {
         const files = {};
         const walk = (dir, prefix) => {
@@ -114,6 +130,11 @@ function archiveSync(src, dest) {
                 const full = path.join(dir, entry);
                 const zipPath = prefix ? `${prefix}/${entry}` : entry;
                 const stat = fs.lstatSync(full);
+                const excluded = !!shouldExclude?.(zipPath, stat.isDirectory());
+                if (excluded &&
+                    !(stat.isDirectory() && descendIntoExcludedDirectories)) {
+                    continue;
+                }
                 if (stat.isSymbolicLink()) {
                     // Store the link target as the entry data with S_IFLNK attrs so
                     // extractors recreate the symlink instead of a copy of the target.
@@ -160,8 +181,8 @@ function archiveSync(src, dest) {
  */
 function hashPath(src, options = {}) {
     const digest = options.canonical
-        ? canonicalHashPath(src, !options.archive)
-        : legacyHashPath(src);
+        ? canonicalHashPath(src, !options.archive, options.shouldExclude, options.descendIntoExcludedDirectories)
+        : legacyHashPath(src, options.shouldExclude, options.descendIntoExcludedDirectories);
     return digest.slice(0, HASH_LEN).toUpperCase();
 }
 /**
@@ -173,8 +194,11 @@ function hashPath(src, options = {}) {
  * bytes, so a file containing `foo` can never collide with a symlink
  * targeting `foo`.
  * @param src - path to a file or directory to hash
+ * @param shouldExclude - entries to omit, see {@link HashPathOptions.shouldExclude}
+ * @param descendIntoExcludedDirectories - keep walking excluded directories,
+ * see {@link HashPathOptions.descendIntoExcludedDirectories}
  */
-function legacyHashPath(src) {
+function legacyHashPath(src, shouldExclude, descendIntoExcludedDirectories = false) {
     const content = crypto.createHash("md5");
     const links = crypto.createHash("md5");
     let linkCount = 0;
@@ -196,7 +220,18 @@ function legacyHashPath(src) {
             content.update(fs.readFileSync(p));
         }
         else if (stat.isDirectory()) {
-            fs.readdirSync(p).forEach((filename) => hashRecursion(path.resolve(p, filename), relPath ? `${relPath}/${filename}` : filename));
+            fs.readdirSync(p).forEach((filename) => {
+                const entryRelPath = relPath ? `${relPath}/${filename}` : filename;
+                const childPath = path.resolve(p, filename);
+                const childIsDir = fs.lstatSync(childPath).isDirectory();
+                if (shouldExclude?.(entryRelPath, childIsDir)) {
+                    // Skip, unless it is an excluded directory being descended into.
+                    if (!(childIsDir && descendIntoExcludedDirectories)) {
+                        return;
+                    }
+                }
+                hashRecursion(childPath, entryRelPath);
+            });
         }
     }
     hashRecursion(src, "", true);
@@ -227,8 +262,9 @@ function legacyHashPath(src) {
  * @param src - path to a file or directory to hash
  * @param includeDirectories - record directory entries; false for archive
  * artifacts, where the emitted zip has no directory entries
+ * @param shouldExclude - entries to omit, see {@link HashPathOptions.shouldExclude}
  */
-function canonicalHashPath(src, includeDirectories) {
+function canonicalHashPath(src, includeDirectories, shouldExclude, descendIntoExcludedDirectories = false) {
     const hash = crypto.createHash("md5");
     /**
      * Walk `p`, framing each entry into the enclosing hash accumulator.
@@ -251,17 +287,60 @@ function canonicalHashPath(src, includeDirectories) {
             hash.update(data);
         }
         else if (stat.isDirectory()) {
+            // Records the `D` entry even for a descended-into excluded directory,
+            // matching the empty directory copySync leaves on disk.
             if (relPath && includeDirectories) {
                 hash.update(`D ${relPath}\0`);
             }
             for (const filename of fs.readdirSync(p).sort()) {
-                hashRecursion(path.resolve(p, filename), relPath ? `${relPath}/${filename}` : filename);
+                const entryRelPath = relPath ? `${relPath}/${filename}` : filename;
+                const childPath = path.resolve(p, filename);
+                const childIsDir = fs.lstatSync(childPath).isDirectory();
+                if (shouldExclude?.(entryRelPath, childIsDir)) {
+                    // Skip, unless it is an excluded directory being descended into.
+                    if (!(childIsDir && descendIntoExcludedDirectories)) {
+                        continue;
+                    }
+                }
+                hashRecursion(childPath, entryRelPath);
             }
         }
     }
     hashRecursion(src, "", true);
     return hash.digest("hex");
 }
+/**
+ * Build a predicate matching the exclusion forms accepted by
+ * `AssetHashOptions.exclude` (via `ExcludeIgnoreStrategy`): an exact relative
+ * path, a `*.ext` suffix, or a directory (with or without a trailing `/`),
+ * which also excludes its contents.
+ * Deliberately not a full glob implementation — `**`, `?`, character classes and
+ * `!` negation are not supported, and a pattern is never interpreted as
+ * anchoring to a subdirectory it does not name.
+ * The returned matcher looks only at the path, not at whether the entry is a
+ * directory: `dir` and `dir/` both match a directory named `dir` and its
+ * contents. It is therefore narrower than {@link ExcludePredicate}, which also
+ * receives an `isDirectory` flag for strategies that need it.
+ * @param exclude - patterns to exclude
+ * @returns predicate over `/`-separated paths relative to the asset root
+ */
+function excludeMatcher(exclude) {
+    // `/`-separated throughout: relative paths are normalized before matching, so
+    // `dir/child` patterns work the same on Windows.
+    const patterns = exclude.map((p) => p.replace(/\\/g, "/"));
+    return (relativePath) => {
+        for (const pattern of patterns) {
+            if (pattern.startsWith("*.") && relativePath.endsWith(pattern.slice(1))) {
+                return true;
+            }
+            const dir = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+            if (relativePath === dir || relativePath.startsWith(`${dir}/`)) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
 /**
  * Walk upward from `rootPath` looking for a file with the given name.
  * Returns the absolute path of the first match, or `null` if the search
@@ -281,4 +360,4 @@ function findFileAboveCwd(file, rootPath = process.cwd()) {
     }
     return null;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fs.js","sourceRoot":"","sources":["../../src/private/fs.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport * as crypto from \"crypto\";\nimport { strToU8, zipSync } from \"fflate\";\nimport type { ZipOptions } from \"fflate\";\nimport { assetCanNotCreateZipArchive } from \"../errors\";\n\nconst HASH_LEN = 32;\n\n// Unix file-type bits for zip external attributes (st_mode upper nibble)\nconst S_IFLNK = 0o120000;\nconst S_IFREG = 0o100000;\nconst PERM_MASK = 0o7777;\n// \"version made by\" host byte; unzip only honors unix mode attrs when set\nconst ZIP_OS_UNIX = 3;\n// Pinned so archives are byte-reproducible across synths. fflate encodes\n// DOS dates from local-time getters and rejects years outside 1980-2099,\n// so this must be a local-time 1980 date (a UTC one underflows to 1979 in\n// timezones west of UTC).\nconst ZIP_ENTRY_MTIME = new Date(1980, 0, 1);\n\n/**\n * Zip external attributes for a unix mode: file-type and permission bits\n * belong in the high 16 bits of the 32-bit field.\n * @param mode - unix st_mode bits (type | permissions)\n */\nfunction zipAttrs(mode: number): number {\n  return (mode << 16) >>> 0;\n}\n\n// Full implementation at https://github.com/jprichardson/node-fs-extra/blob/master/lib/copy/copy-sync.js\n/**\n * Copy a file or directory. The directory can have contents and subfolders.\n * @param src - source path\n * @param dest - destination path\n */\nexport function copySync(src: string, dest: string) {\n  /**\n   * Copies file if present otherwise walks subfolder.\n   * @param p - path relative to src/dest\n   */\n  function copyItem(p: string) {\n    const sourcePath = path.resolve(src, p);\n    const stat = fs.lstatSync(sourcePath);\n    if (stat.isSymbolicLink()) {\n      fs.symlinkSync(fs.readlinkSync(sourcePath), path.resolve(dest, p));\n    } else if (stat.isFile()) {\n      fs.copyFileSync(sourcePath, path.resolve(dest, p));\n    } else if (stat.isDirectory()) {\n      walkSubfolder(p);\n    }\n  }\n  /**\n   * Copies contents of subfolder.\n   * @param p - path relative to src/dest\n   */\n  function walkSubfolder(p: string) {\n    const sourceDir = path.resolve(src, p);\n    fs.mkdirSync(path.resolve(dest, p), { recursive: true });\n    fs.readdirSync(sourceDir).forEach((item: string) =>\n      copyItem(path.join(p, item)),\n    );\n  }\n\n  walkSubfolder(\".\");\n}\n\n/**\n * Zips contents at src and places zip archive at dest.\n * @param src - directory to archive\n * @param dest - path to write the resulting zip to\n */\nexport function archiveSync(src: string, dest: string) {\n  try {\n    const files: Record<string, [Uint8Array, ZipOptions]> = {};\n    const walk = (dir: string, prefix: string) => {\n      // Sorted so entry order — and therefore archive bytes — cannot depend\n      // on filesystem enumeration order; matches the canonical hash walk.\n      for (const entry of fs.readdirSync(dir).sort()) {\n        const full = path.join(dir, entry);\n        const zipPath = prefix ? `${prefix}/${entry}` : entry;\n        const stat = fs.lstatSync(full);\n        if (stat.isSymbolicLink()) {\n          // Store the link target as the entry data with S_IFLNK attrs so\n          // extractors recreate the symlink instead of a copy of the target.\n          // Never recursing through links also makes cycles unreachable.\n          files[zipPath] = [\n            strToU8(fs.readlinkSync(full)),\n            {\n              os: ZIP_OS_UNIX,\n              attrs: zipAttrs(S_IFLNK | (stat.mode & PERM_MASK)),\n              level: 0,\n            },\n          ];\n        } else if (stat.isDirectory()) {\n          walk(full, zipPath);\n        } else {\n          files[zipPath] = [\n            fs.readFileSync(full),\n            {\n              os: ZIP_OS_UNIX,\n              attrs: zipAttrs(S_IFREG | (stat.mode & PERM_MASK)),\n            },\n          ];\n        }\n      }\n    };\n    walk(src, \"\");\n    fs.writeFileSync(\n      dest,\n      zipSync(files, { level: 9, mtime: ZIP_ENTRY_MTIME }),\n    );\n  } catch (err: any) {\n    throw assetCanNotCreateZipArchive(src, dest, err);\n  }\n}\n\nexport interface HashPathOptions {\n  /**\n   * Use the canonical entry-framed hash instead of the legacy\n   * content-concatenation hash. Enabled through the `canonicalAssetHashes`\n   * feature flag.\n   */\n  readonly canonical?: boolean;\n  /**\n   * Frame for an archive artifact: archiveSync never emits ZIP directory\n   * entries, so canonical hashing omits directory records and the hash\n   * tracks the emitted archive bytes exactly. Non-empty directories stay\n   * visible through the relative paths of their contents. Has no effect on\n   * the legacy scheme, which never records directories.\n   */\n  readonly archive?: boolean;\n}\n\n/**\n * Compute a stable MD5 hash of a file or directory's contents.\n * In both schemes symlinks are hashed by their metadata (path + target)\n * instead of being followed, so shared targets are not double-counted and\n * cycles cannot recurse; a symlink at the root itself is followed, matching\n * how the asset source path is opened when the artifact is emitted.\n * @param src - path to a file or directory to hash\n * @param options - hash scheme selection, see {@link HashPathOptions}\n * @returns uppercased hex digest, truncated to HASH_LEN characters\n */\nexport function hashPath(src: string, options: HashPathOptions = {}): string {\n  const digest = options.canonical\n    ? canonicalHashPath(src, !options.archive)\n    : legacyHashPath(src);\n  return digest.slice(0, HASH_LEN).toUpperCase();\n}\n\n/**\n * Legacy-compatible hash: file contents fold into one digest in\n * directory-listing order, exactly as earlier releases did, so trees without\n * symlinks keep their historical hashes. Symlink metadata goes into a second\n * digest, and only when symlinks exist are the two combined under a tagged\n * outer hash — the tag keeps symlink metadata in a separate domain from file\n * bytes, so a file containing `foo` can never collide with a symlink\n * targeting `foo`.\n * @param src - path to a file or directory to hash\n */\nfunction legacyHashPath(src: string): string {\n  const content = crypto.createHash(\"md5\");\n  const links = crypto.createHash(\"md5\");\n  let linkCount = 0;\n\n  /**\n   * Walk `p`, feeding file contents and symlink metadata into the enclosing\n   * accumulators.\n   * @param p - path to walk\n   * @param relPath - path of `p` relative to the walk root, `/`-separated\n   * @param isRoot - follow a symlink only at the root, matching how the\n   * asset's own path is resolved when it is read\n   */\n  function hashRecursion(p: string, relPath: string, isRoot = false) {\n    const stat = isRoot ? fs.statSync(p) : fs.lstatSync(p);\n    if (stat.isSymbolicLink()) {\n      links.update(`${relPath}\\0${fs.readlinkSync(p)}\\0`);\n      linkCount++;\n    } else if (stat.isFile()) {\n      content.update(fs.readFileSync(p));\n    } else if (stat.isDirectory()) {\n      fs.readdirSync(p).forEach((filename) =>\n        hashRecursion(\n          path.resolve(p, filename),\n          relPath ? `${relPath}/${filename}` : filename,\n        ),\n      );\n    }\n  }\n\n  hashRecursion(src, \"\", true);\n  if (linkCount === 0) {\n    return content.digest(\"hex\");\n  }\n  const outer = crypto.createHash(\"md5\");\n  outer.update(\"cdktn/asset-hash/symlinks/v1\\0\");\n  outer.update(content.digest(\"hex\"));\n  outer.update(links.digest(\"hex\"));\n  return outer.digest(\"hex\");\n}\n\n/**\n * Canonical hash, modeled on git trees and Nix NAR: every entry is framed\n * with everything that affects the emitted artifact —\n *\n * - files:      `F <mode> <relPath>\\0<size>\\0` + content, where `<mode>` is\n *               the octal permission mask (`0o7777` bits) that archiveSync\n *               preserves in zip external attributes,\n * - symlinks:   `L <mode> <relPath>\\0<target byte length>\\0` + target,\n * - directories (including empty ones, which copySync materializes):\n *               `D <relPath>\\0`, with no mode — neither archiveSync nor\n *               copySync preserves directory permissions,\n *\n * in sorted directory order with `/`-separated relative paths, so renames,\n * entry-boundary shifts, permission changes, empty-directory changes, and\n * file-vs-symlink swaps all change the digest.\n * @param src - path to a file or directory to hash\n * @param includeDirectories - record directory entries; false for archive\n * artifacts, where the emitted zip has no directory entries\n */\nfunction canonicalHashPath(src: string, includeDirectories: boolean): string {\n  const hash = crypto.createHash(\"md5\");\n\n  /**\n   * Walk `p`, framing each entry into the enclosing hash accumulator.\n   * @param p - path to walk\n   * @param relPath - path of `p` relative to the walk root, `/`-separated\n   * @param isRoot - follow a symlink only at the root, matching how the\n   * asset's own path is resolved when the artifact is emitted\n   */\n  function hashRecursion(p: string, relPath: string, isRoot = false) {\n    const stat = isRoot ? fs.statSync(p) : fs.lstatSync(p);\n    const mode = (stat.mode & PERM_MASK).toString(8);\n    if (stat.isSymbolicLink()) {\n      const target = fs.readlinkSync(p);\n      hash.update(`L ${mode} ${relPath}\\0${Buffer.byteLength(target)}\\0`);\n      hash.update(target);\n    } else if (stat.isFile()) {\n      const data = fs.readFileSync(p);\n      hash.update(`F ${mode} ${relPath}\\0${data.length}\\0`);\n      hash.update(data);\n    } else if (stat.isDirectory()) {\n      if (relPath && includeDirectories) {\n        hash.update(`D ${relPath}\\0`);\n      }\n      for (const filename of fs.readdirSync(p).sort()) {\n        hashRecursion(\n          path.resolve(p, filename),\n          relPath ? `${relPath}/${filename}` : filename,\n        );\n      }\n    }\n  }\n\n  hashRecursion(src, \"\", true);\n  return hash.digest(\"hex\");\n}\n\n/**\n * Walk upward from `rootPath` looking for a file with the given name.\n * Returns the absolute path of the first match, or `null` if the search\n * reaches the filesystem root without finding it.\n * @param file - filename to search for\n * @param rootPath - directory to start the search from (defaults to cwd)\n * @returns absolute path to the file, or null if not found\n */\nexport function findFileAboveCwd(\n  file: string,\n  rootPath: string = process.cwd(),\n): string | null {\n  const fullPath = path.resolve(rootPath, file);\n  if (fs.existsSync(fullPath)) {\n    return fullPath;\n  }\n\n  const parentDir = path.resolve(rootPath, \"..\");\n  if (fs.existsSync(parentDir) && parentDir !== rootPath) {\n    return findFileAboveCwd(file, parentDir);\n  }\n\n  return null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fs.js","sourceRoot":"","sources":["../../src/private/fs.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport * as crypto from \"crypto\";\nimport { strToU8, zipSync } from \"fflate\";\nimport type { ZipOptions } from \"fflate\";\nimport { assetCanNotCreateZipArchive } from \"../errors\";\n\nconst HASH_LEN = 32;\n\n// Unix file-type bits for zip external attributes (st_mode upper nibble)\nconst S_IFLNK = 0o120000;\nconst S_IFREG = 0o100000;\nconst PERM_MASK = 0o7777;\n// \"version made by\" host byte; unzip only honors unix mode attrs when set\nconst ZIP_OS_UNIX = 3;\n// Pinned so archives are byte-reproducible across synths. fflate encodes\n// DOS dates from local-time getters and rejects years outside 1980-2099,\n// so this must be a local-time 1980 date (a UTC one underflows to 1979 in\n// timezones west of UTC).\nconst ZIP_ENTRY_MTIME = new Date(1980, 0, 1);\n\n/**\n * Zip external attributes for a unix mode: file-type and permission bits\n * belong in the high 16 bits of the 32-bit field.\n * @param mode - unix st_mode bits (type | permissions)\n */\nfunction zipAttrs(mode: number): number {\n  return (mode << 16) >>> 0;\n}\n\n/**\n * Predicate deciding whether a tree entry is skipped.\n * `relPath` is always `/`-separated and relative to the walk root, so patterns\n * behave identically on Windows. `isDirectory` is supplied from the walker's\n * `lstat` so `.gitignore` / `.dockerignore`-style directory-only patterns can\n * be honored without the predicate stat-ing the path itself.\n */\nexport type ExcludePredicate = (\n  relPath: string,\n  isDirectory: boolean,\n) => boolean;\n\nexport interface CopySyncOptions {\n  /**\n   * Entries for which this returns true are not copied. Called with the\n   * entry's `/`-separated relative path and whether it is a directory.\n   * Excluding a directory also skips everything below it, unless\n   * {@link descendIntoExcludedDirectories} is set.\n   *\n   * @default - nothing is excluded\n   */\n  readonly shouldExclude?: ExcludePredicate;\n\n  /**\n   * Keep walking into an excluded directory instead of pruning it. The\n   * directory entry itself is still omitted; its children are visited and\n   * re-tested against {@link shouldExclude}, so a strategy with negation\n   * patterns (`node_modules` + `!node_modules/keep`) can re-include entries\n   * below an excluded parent. Costs a full walk of excluded subtrees, so it\n   * is off unless a strategy asks for it.\n   *\n   * @default false\n   */\n  readonly descendIntoExcludedDirectories?: boolean;\n}\n\n// Full implementation at https://github.com/jprichardson/node-fs-extra/blob/master/lib/copy/copy-sync.js\n/**\n * Copy a file or directory. The directory can have contents and subfolders.\n * Symlinks are recreated as symlinks rather than dereferenced, which keeps the\n * copy consistent with {@link hashPath} (it hashes links by their target) and\n * makes dangling links and link cycles harmless.\n * @param src - source path\n * @param dest - destination path\n * @param options - copy behaviour, see {@link CopySyncOptions}\n */\nexport function copySync(\n  src: string,\n  dest: string,\n  options: CopySyncOptions = {},\n) {\n  /**\n   * Copies file if present otherwise walks subfolder.\n   * @param p - path relative to src/dest\n   * @param relPath - `/`-separated path relative to the copy root\n   */\n  function copyItem(p: string, relPath: string) {\n    const sourcePath = path.resolve(src, p);\n    const stat = fs.lstatSync(sourcePath);\n    const excluded = !!options.shouldExclude?.(relPath, stat.isDirectory());\n    // Skip, unless it is an excluded directory being descended into.\n    if (\n      excluded &&\n      !(stat.isDirectory() && options.descendIntoExcludedDirectories)\n    ) {\n      return;\n    }\n    if (stat.isSymbolicLink()) {\n      fs.symlinkSync(fs.readlinkSync(sourcePath), path.resolve(dest, p));\n    } else if (stat.isFile()) {\n      fs.copyFileSync(sourcePath, path.resolve(dest, p));\n    } else if (stat.isDirectory()) {\n      walkSubfolder(p, relPath);\n    }\n  }\n  /**\n   * Copies contents of subfolder.\n   * @param p - path relative to src/dest\n   * @param relPath - `/`-separated path relative to the copy root\n   */\n  function walkSubfolder(p: string, relPath: string) {\n    const sourceDir = path.resolve(src, p);\n    fs.mkdirSync(path.resolve(dest, p), { recursive: true });\n    fs.readdirSync(sourceDir).forEach((item: string) =>\n      copyItem(path.join(p, item), relPath ? `${relPath}/${item}` : item),\n    );\n  }\n\n  walkSubfolder(\".\", \"\");\n}\n\n/**\n * Zips contents at src and places zip archive at dest.\n * @param src - directory to archive\n * @param dest - path to write the resulting zip to\n * @param shouldExclude - entries to omit, see {@link CopySyncOptions.shouldExclude}\n * @param descendIntoExcludedDirectories - keep walking excluded directories,\n * see {@link CopySyncOptions.descendIntoExcludedDirectories}\n */\nexport function archiveSync(\n  src: string,\n  dest: string,\n  shouldExclude?: ExcludePredicate,\n  descendIntoExcludedDirectories = false,\n) {\n  try {\n    const files: Record<string, [Uint8Array, ZipOptions]> = {};\n    const walk = (dir: string, prefix: string) => {\n      // Sorted so entry order — and therefore archive bytes — cannot depend\n      // on filesystem enumeration order; matches the canonical hash walk.\n      for (const entry of fs.readdirSync(dir).sort()) {\n        const full = path.join(dir, entry);\n        const zipPath = prefix ? `${prefix}/${entry}` : entry;\n        const stat = fs.lstatSync(full);\n        const excluded = !!shouldExclude?.(zipPath, stat.isDirectory());\n        if (\n          excluded &&\n          !(stat.isDirectory() && descendIntoExcludedDirectories)\n        ) {\n          continue;\n        }\n        if (stat.isSymbolicLink()) {\n          // Store the link target as the entry data with S_IFLNK attrs so\n          // extractors recreate the symlink instead of a copy of the target.\n          // Never recursing through links also makes cycles unreachable.\n          files[zipPath] = [\n            strToU8(fs.readlinkSync(full)),\n            {\n              os: ZIP_OS_UNIX,\n              attrs: zipAttrs(S_IFLNK | (stat.mode & PERM_MASK)),\n              level: 0,\n            },\n          ];\n        } else if (stat.isDirectory()) {\n          walk(full, zipPath);\n        } else {\n          files[zipPath] = [\n            fs.readFileSync(full),\n            {\n              os: ZIP_OS_UNIX,\n              attrs: zipAttrs(S_IFREG | (stat.mode & PERM_MASK)),\n            },\n          ];\n        }\n      }\n    };\n    walk(src, \"\");\n    fs.writeFileSync(\n      dest,\n      zipSync(files, { level: 9, mtime: ZIP_ENTRY_MTIME }),\n    );\n  } catch (err: any) {\n    throw assetCanNotCreateZipArchive(src, dest, err);\n  }\n}\n\nexport interface HashPathOptions {\n  /**\n   * Use the canonical entry-framed hash instead of the legacy\n   * content-concatenation hash. Enabled through the `canonicalAssetHashes`\n   * feature flag.\n   */\n  readonly canonical?: boolean;\n  /**\n   * Frame for an archive artifact: archiveSync never emits ZIP directory\n   * entries, so canonical hashing omits directory records and the hash\n   * tracks the emitted archive bytes exactly. Non-empty directories stay\n   * visible through the relative paths of their contents. Has no effect on\n   * the legacy scheme, which never records directories.\n   */\n  readonly archive?: boolean;\n  /**\n   * Entries for which this returns true are omitted from the digest. Excluding\n   * a directory also omits everything below it, unless\n   * {@link descendIntoExcludedDirectories} is set. The same predicate must be\n   * given to {@link copySync} so the hash and the emitted artifact describe the\n   * same set of files.\n   *\n   * @default - nothing is excluded\n   */\n  readonly shouldExclude?: ExcludePredicate;\n\n  /**\n   * Keep walking into excluded directories, see\n   * {@link CopySyncOptions.descendIntoExcludedDirectories}. Must match the\n   * value given to {@link copySync} / {@link archiveSync} so the digest covers\n   * the same file set the artifact contains.\n   *\n   * @default false\n   */\n  readonly descendIntoExcludedDirectories?: boolean;\n}\n\n/**\n * Compute a stable MD5 hash of a file or directory's contents.\n * In both schemes symlinks are hashed by their metadata (path + target)\n * instead of being followed, so shared targets are not double-counted and\n * cycles cannot recurse; a symlink at the root itself is followed, matching\n * how the asset source path is opened when the artifact is emitted.\n * @param src - path to a file or directory to hash\n * @param options - hash scheme selection, see {@link HashPathOptions}\n * @returns uppercased hex digest, truncated to HASH_LEN characters\n */\nexport function hashPath(src: string, options: HashPathOptions = {}): string {\n  const digest = options.canonical\n    ? canonicalHashPath(\n        src,\n        !options.archive,\n        options.shouldExclude,\n        options.descendIntoExcludedDirectories,\n      )\n    : legacyHashPath(\n        src,\n        options.shouldExclude,\n        options.descendIntoExcludedDirectories,\n      );\n  return digest.slice(0, HASH_LEN).toUpperCase();\n}\n\n/**\n * Legacy-compatible hash: file contents fold into one digest in\n * directory-listing order, exactly as earlier releases did, so trees without\n * symlinks keep their historical hashes. Symlink metadata goes into a second\n * digest, and only when symlinks exist are the two combined under a tagged\n * outer hash — the tag keeps symlink metadata in a separate domain from file\n * bytes, so a file containing `foo` can never collide with a symlink\n * targeting `foo`.\n * @param src - path to a file or directory to hash\n * @param shouldExclude - entries to omit, see {@link HashPathOptions.shouldExclude}\n * @param descendIntoExcludedDirectories - keep walking excluded directories,\n * see {@link HashPathOptions.descendIntoExcludedDirectories}\n */\nfunction legacyHashPath(\n  src: string,\n  shouldExclude?: ExcludePredicate,\n  descendIntoExcludedDirectories = false,\n): string {\n  const content = crypto.createHash(\"md5\");\n  const links = crypto.createHash(\"md5\");\n  let linkCount = 0;\n\n  /**\n   * Walk `p`, feeding file contents and symlink metadata into the enclosing\n   * accumulators.\n   * @param p - path to walk\n   * @param relPath - path of `p` relative to the walk root, `/`-separated\n   * @param isRoot - follow a symlink only at the root, matching how the\n   * asset's own path is resolved when it is read\n   */\n  function hashRecursion(p: string, relPath: string, isRoot = false) {\n    const stat = isRoot ? fs.statSync(p) : fs.lstatSync(p);\n    if (stat.isSymbolicLink()) {\n      links.update(`${relPath}\\0${fs.readlinkSync(p)}\\0`);\n      linkCount++;\n    } else if (stat.isFile()) {\n      content.update(fs.readFileSync(p));\n    } else if (stat.isDirectory()) {\n      fs.readdirSync(p).forEach((filename) => {\n        const entryRelPath = relPath ? `${relPath}/${filename}` : filename;\n        const childPath = path.resolve(p, filename);\n        const childIsDir = fs.lstatSync(childPath).isDirectory();\n        if (shouldExclude?.(entryRelPath, childIsDir)) {\n          // Skip, unless it is an excluded directory being descended into.\n          if (!(childIsDir && descendIntoExcludedDirectories)) {\n            return;\n          }\n        }\n        hashRecursion(childPath, entryRelPath);\n      });\n    }\n  }\n\n  hashRecursion(src, \"\", true);\n  if (linkCount === 0) {\n    return content.digest(\"hex\");\n  }\n  const outer = crypto.createHash(\"md5\");\n  outer.update(\"cdktn/asset-hash/symlinks/v1\\0\");\n  outer.update(content.digest(\"hex\"));\n  outer.update(links.digest(\"hex\"));\n  return outer.digest(\"hex\");\n}\n\n/**\n * Canonical hash, modeled on git trees and Nix NAR: every entry is framed\n * with everything that affects the emitted artifact —\n *\n * - files:      `F <mode> <relPath>\\0<size>\\0` + content, where `<mode>` is\n *               the octal permission mask (`0o7777` bits) that archiveSync\n *               preserves in zip external attributes,\n * - symlinks:   `L <mode> <relPath>\\0<target byte length>\\0` + target,\n * - directories (including empty ones, which copySync materializes):\n *               `D <relPath>\\0`, with no mode — neither archiveSync nor\n *               copySync preserves directory permissions,\n *\n * in sorted directory order with `/`-separated relative paths, so renames,\n * entry-boundary shifts, permission changes, empty-directory changes, and\n * file-vs-symlink swaps all change the digest.\n * @param src - path to a file or directory to hash\n * @param includeDirectories - record directory entries; false for archive\n * artifacts, where the emitted zip has no directory entries\n * @param shouldExclude - entries to omit, see {@link HashPathOptions.shouldExclude}\n */\nfunction canonicalHashPath(\n  src: string,\n  includeDirectories: boolean,\n  shouldExclude?: ExcludePredicate,\n  descendIntoExcludedDirectories = false,\n): string {\n  const hash = crypto.createHash(\"md5\");\n\n  /**\n   * Walk `p`, framing each entry into the enclosing hash accumulator.\n   * @param p - path to walk\n   * @param relPath - path of `p` relative to the walk root, `/`-separated\n   * @param isRoot - follow a symlink only at the root, matching how the\n   * asset's own path is resolved when the artifact is emitted\n   */\n  function hashRecursion(p: string, relPath: string, isRoot = false) {\n    const stat = isRoot ? fs.statSync(p) : fs.lstatSync(p);\n    const mode = (stat.mode & PERM_MASK).toString(8);\n    if (stat.isSymbolicLink()) {\n      const target = fs.readlinkSync(p);\n      hash.update(`L ${mode} ${relPath}\\0${Buffer.byteLength(target)}\\0`);\n      hash.update(target);\n    } else if (stat.isFile()) {\n      const data = fs.readFileSync(p);\n      hash.update(`F ${mode} ${relPath}\\0${data.length}\\0`);\n      hash.update(data);\n    } else if (stat.isDirectory()) {\n      // Records the `D` entry even for a descended-into excluded directory,\n      // matching the empty directory copySync leaves on disk.\n      if (relPath && includeDirectories) {\n        hash.update(`D ${relPath}\\0`);\n      }\n      for (const filename of fs.readdirSync(p).sort()) {\n        const entryRelPath = relPath ? `${relPath}/${filename}` : filename;\n        const childPath = path.resolve(p, filename);\n        const childIsDir = fs.lstatSync(childPath).isDirectory();\n        if (shouldExclude?.(entryRelPath, childIsDir)) {\n          // Skip, unless it is an excluded directory being descended into.\n          if (!(childIsDir && descendIntoExcludedDirectories)) {\n            continue;\n          }\n        }\n        hashRecursion(childPath, entryRelPath);\n      }\n    }\n  }\n\n  hashRecursion(src, \"\", true);\n  return hash.digest(\"hex\");\n}\n\n/**\n * Build a predicate matching the exclusion forms accepted by\n * `AssetHashOptions.exclude` (via `ExcludeIgnoreStrategy`): an exact relative\n * path, a `*.ext` suffix, or a directory (with or without a trailing `/`),\n * which also excludes its contents.\n * Deliberately not a full glob implementation — `**`, `?`, character classes and\n * `!` negation are not supported, and a pattern is never interpreted as\n * anchoring to a subdirectory it does not name.\n * The returned matcher looks only at the path, not at whether the entry is a\n * directory: `dir` and `dir/` both match a directory named `dir` and its\n * contents. It is therefore narrower than {@link ExcludePredicate}, which also\n * receives an `isDirectory` flag for strategies that need it.\n * @param exclude - patterns to exclude\n * @returns predicate over `/`-separated paths relative to the asset root\n */\nexport function excludeMatcher(\n  exclude: string[],\n): (relativePath: string) => boolean {\n  // `/`-separated throughout: relative paths are normalized before matching, so\n  // `dir/child` patterns work the same on Windows.\n  const patterns = exclude.map((p) => p.replace(/\\\\/g, \"/\"));\n  return (relativePath: string) => {\n    for (const pattern of patterns) {\n      if (pattern.startsWith(\"*.\") && relativePath.endsWith(pattern.slice(1))) {\n        return true;\n      }\n      const dir = pattern.endsWith(\"/\") ? pattern.slice(0, -1) : pattern;\n      if (relativePath === dir || relativePath.startsWith(`${dir}/`)) {\n        return true;\n      }\n    }\n    return false;\n  };\n}\n\n/**\n * Walk upward from `rootPath` looking for a file with the given name.\n * Returns the absolute path of the first match, or `null` if the search\n * reaches the filesystem root without finding it.\n * @param file - filename to search for\n * @param rootPath - directory to start the search from (defaults to cwd)\n * @returns absolute path to the file, or null if not found\n */\nexport function findFileAboveCwd(\n  file: string,\n  rootPath: string = process.cwd(),\n): string | null {\n  const fullPath = path.resolve(rootPath, file);\n  if (fs.existsSync(fullPath)) {\n    return fullPath;\n  }\n\n  const parentDir = path.resolve(rootPath, \"..\");\n  if (fs.existsSync(parentDir) && parentDir !== rootPath) {\n    return findFileAboveCwd(file, parentDir);\n  }\n\n  return null;\n}\n"]}

package/lib/resource.js

@@ -11,7 +11,7 @@ const terraform_stack_1 = require("./terraform-stack");
  * @deprecated - Please use Construct from the constructs package instead.
  */
 class Resource extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.Resource", version: "0.25.0-pre.9" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.Resource", version: "0.25.0" };
     stack;
     constructor(scope, id) {
         super(scope, id);

package/lib/synthesize/synthesizer.js

@@ -47,7 +47,7 @@ const safe_stable_stringify_1 = __importDefault(require("safe-stable-stringify")
 const annotations_1 = require("../annotations");
 const constructs_1 = require("constructs");
 const aspect_1 = require("../aspect");
-const validate_terraform_version_1 = require("../validations/validate-terraform-version");
+const target_versions_1 = require("../validations/target-versions");
 const errors_1 = require("../errors");
 // eslint-disable-next-line jsdoc/require-jsdoc
 class StackSynthesizer {
@@ -68,29 +68,16 @@ class StackSynthesizer {
     synthesize(session) {
         invokeAspects(this.stack);
         if (!session.stacksPrepared) {
-            // This session wasn't built by App.synth() (which already prepared
-            // every stack up front) - prepare this stack ourselves so
-            // resolve-discovered provider-feature usage and Terraform-function
-            // usage are rediscovered for the current pass before validations run
-            // below. See ISynthesisSession.stacksPrepared.
-            //
-            // Terraform-function usage is recorded per-stack (see
-            // `TerraformStack._usedFunctions`) and `prepareStack()` clears this
-            // stack's own usage sets itself, as the first step of
-            // `_runPreparingResolve()`, before rediscovering them. Without this,
-            // a function rendered by an earlier pass over this same stack (e.g. a
-            // previous direct call to this same synthesize()) would keep failing
-            // target-version validation in a later pass even after that usage is
-            // gone, breaking the per-synthesis-epoch guarantee that App.synth()
-            // and Testing.synth()/synthHcl() already provide.
+            // Sessions not built by App.synth() arrive unprepared: prepare this
+            // stack so stale provider-feature and function usage is cleared and
+            // rediscovered before validations run (ISynthesisSession.stacksPrepared).
             this.stack.prepareStack();
         }
         if (this.stack.hasResourceMove()) {
-            // TODO(target-versions): this probes the locally installed binary during
-            // synth. Migrate to ValidateFeatureTargetSupport (declared cdktf.json
-            // targetVersions) and leave installed-binary verification to the opt-in
-            // validateInstalledBinary CLI behavior.
-            this.stack.node.addValidation(new validate_terraform_version_1.ValidateTerraformVersion(">=1.5", `Resource move functionality is only supported for Terraform >=1.5. Please upgrade your Terraform version.`));
+            this.stack.node.addValidation(new target_versions_1.ValidateFeatureTargetSupport(this.stack, "The moved block", {
+                terraform: ">=1.5.0",
+                opentofu: ">=1.6.0",
+            }));
         }
         if (!session.skipValidation) {
             this.stack.runAllValidations();
@@ -203,4 +190,4 @@ function addCustomSynthesis(construct, synthesis) {
 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 { ValidateTerraformVersion } from \"../validations/validate-terraform-version\";\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      // This session wasn't built by App.synth() (which already prepared\n      // every stack up front) - prepare this stack ourselves so\n      // resolve-discovered provider-feature usage and Terraform-function\n      // usage are rediscovered for the current pass before validations run\n      // below. See ISynthesisSession.stacksPrepared.\n      //\n      // Terraform-function usage is recorded per-stack (see\n      // `TerraformStack._usedFunctions`) and `prepareStack()` clears this\n      // stack's own usage sets itself, as the first step of\n      // `_runPreparingResolve()`, before rediscovering them. Without this,\n      // a function rendered by an earlier pass over this same stack (e.g. a\n      // previous direct call to this same synthesize()) would keep failing\n      // target-version validation in a later pass even after that usage is\n      // gone, breaking the per-synthesis-epoch guarantee that App.synth()\n      // and Testing.synth()/synthHcl() already provide.\n      this.stack.prepareStack();\n    }\n\n    if (this.stack.hasResourceMove()) {\n      // TODO(target-versions): this probes the locally installed binary during\n      // synth. Migrate to ValidateFeatureTargetSupport (declared cdktf.json\n      // targetVersions) and leave installed-binary verification to the opt-in\n      // validateInstalledBinary CLI behavior.\n      this.stack.node.addValidation(\n        new ValidateTerraformVersion(\n          \">=1.5\",\n          `Resource move functionality is only supported for Terraform >=1.5. Please upgrade your Terraform version.`,\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\";\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"]}