cdktn 0.23.2 → 0.23.4

package/lib/upgrade-id-aspect.js

@@ -161,5 +161,5 @@ Refer to the following page for more information: https://cdktn.io/docs/examples
 }
 exports.MigrateIds = MigrateIds;
 _a = JSII_RTTI_SYMBOL_1;
-MigrateIds[_a] = { fqn: "cdktn.MigrateIds", version: "0.23.2" };
+MigrateIds[_a] = { fqn: "cdktn.MigrateIds", version: "0.23.4" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgrade-id-aspect.js","sourceRoot":"","sources":["../src/upgrade-id-aspect.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\n\nimport {\n  Annotations,\n  App,\n  TerraformElement,\n  TerraformModule,\n  TerraformResource,\n  TerraformStack,\n} from \".\";\nimport { IAspect } from \"./aspect\";\nimport { IConstruct, Node } from \"constructs\";\nimport * as crypto from \"crypto\";\nimport { cannotCalcIdForEmptySetOfComponents } from \"./errors\";\nimport * as path from \"path\";\n\n/**\n * We have to copy this from the old CDKTN version for now, so that we can\n * calculate the old logical IDs for now and for later for the migration.\n */\n\n/**\n * Resources with this ID are hidden from humans\n *\n * They do not appear in the human-readable part of the logical ID,\n * but they are included in the hash calculation.\n */\nconst HIDDEN_FROM_HUMAN_ID = \"Resource\";\n\n/**\n * Resources with this ID are complete hidden from the logical ID calculation.\n */\nconst HIDDEN_ID = \"Default\";\n\nconst PATH_SEP = \"/\";\nconst UNIQUE_SEP = \"_\";\n\nconst HASH_LEN = 8;\nconst MAX_HUMAN_LEN = 240; // max ID len is 255\nconst MAX_ID_LEN = 255;\n\n/**\n * Calculates a unique ID for a set of textual components.\n *\n * This is done by calculating a hash on the full path and using it as a suffix\n * of a length-limited \"human\" rendition of the path components.\n *\n * @param components The path components\n * @returns a unique alpha-numeric identifier with a maximum length of 255\n */\nfunction makeUniqueIdOldVersion(components: string[], allowSepChars: boolean) {\n  components = components.filter((x) => x !== HIDDEN_ID);\n\n  if (components.length === 0) {\n    throw cannotCalcIdForEmptySetOfComponents();\n  }\n\n  // top-level resources will simply use the `name` as-is in order to support\n  // transparent migration of cloudformation templates to the CDK without the\n  // need to rename all resources.\n  if (components.length === 1) {\n    // we filter out non-alpha characters but that is actually a bad idea\n    // because it could create conflicts (\"A-B\" and \"AB\" will render the same\n    // logical ID). sadly, changing it in the 1.x version line is impossible\n    // because it will be a breaking change. we should consider for v2.0.\n    // https://github.com/aws/aws-cdk/issues/6421\n    const candidate = removeDisallowedCharacters(components[0], allowSepChars);\n\n    // if our candidate is short enough, use it as is. otherwise, fall back to\n    // the normal mode.\n    if (candidate.length <= MAX_ID_LEN) {\n      return candidate;\n    }\n  }\n\n  const hash = pathHash(components);\n  const human = removeDupes(components)\n    .filter((x) => x !== HIDDEN_FROM_HUMAN_ID)\n    .map((s) => removeDisallowedCharacters(s, allowSepChars))\n    .join(UNIQUE_SEP)\n    .slice(0, MAX_HUMAN_LEN);\n\n  return human + UNIQUE_SEP + hash;\n}\n\n/**\n * Take a hash of the given path.\n *\n * The hash is limited in size.\n */\nfunction pathHash(path: string[]): string {\n  const md5 = crypto\n    .createHash(\"md5\")\n    .update(path.join(PATH_SEP))\n    .digest(\"hex\");\n  return md5.slice(0, HASH_LEN).toUpperCase();\n}\n\n/**\n *\n * @param s\n * @param allowSepChars\n * @returns\n */\nfunction removeDisallowedCharacters(s: string, allowSepChars: boolean) {\n  if (allowSepChars) {\n    return removeNonAlphanumericSep(s);\n  } else {\n    return removeNonAlphanumeric(s);\n  }\n}\n\n/**\n * Removes all non-alphanumeric characters in a string.\n */\nfunction removeNonAlphanumeric(s: string) {\n  return s.replace(/[^A-Za-z0-9]/g, \"\");\n}\n\n/**\n *\n * @param s\n * @returns\n */\nfunction removeNonAlphanumericSep(s: string) {\n  return s.replace(/[^A-Za-z0-9_-]/g, \"\");\n}\n\n/**\n * Remove duplicate \"terms\" from the path list\n *\n * If the previous path component name ends with this component name, skip the\n * current component.\n */\nfunction removeDupes(path: string[]): string[] {\n  const ret = new Array<string>();\n\n  for (const component of path) {\n    if (ret.length === 0 || !ret[ret.length - 1].endsWith(component)) {\n      ret.push(component);\n    }\n  }\n\n  return ret;\n}\n\n/**\n *\n * @param tfElement\n * @returns\n */\nfunction allocateLogicalIdOldVersion(\n  tfElement: TerraformElement | Node,\n): string {\n  const node = TerraformElement.isTerraformElement(tfElement)\n    ? tfElement.node\n    : tfElement;\n\n  // This is the previous behavior, which we want for now.\n  const stackIndex = 0;\n\n  const components = node.scopes.slice(stackIndex + 1).map((c) => c.node.id);\n  return components.length > 0 ? makeUniqueIdOldVersion(components, false) : \"\";\n}\n\n/**\n * For migrating past 0.17 where the feature flag for the old id generation logic was removed after being deprecated since 0.15\n */\nexport class MigrateIds implements IAspect {\n  visit(node: IConstruct) {\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (node instanceof TerraformResource) {\n      const oldId = allocateLogicalIdOldVersion(node);\n      node.moveFromId(`${node.terraformResourceType}.${oldId}`);\n    }\n    // eslint-disable-next-line no-instanceof/no-instanceof\n    if (node instanceof TerraformModule) {\n      const oldId = allocateLogicalIdOldVersion(node);\n      const appManifest = App.of(node).manifest;\n      const stackManifest = appManifest.forStack(TerraformStack.of(node));\n      const stackOutdir = path.join(\n        appManifest.outdir,\n        stackManifest.workingDirectory,\n      );\n      Annotations.of(node)\n        .addWarning(`Found module with new id ${node.friendlyUniqueId}. Moving this module requires a manual state migration.\nIf this module has not been moved yet, run \"terraform state mv module.${oldId} module.${node.friendlyUniqueId}\" in the output directory \"${stackOutdir}\" to migrate the existing state to its new id.\nRefer to the following page for more information: https://cdktn.io/docs/examples-and-guides/refactoring#moving-or-renaming-modules`);\n    }\n  }\n}\n"]}

package/lib/validations/index.d.ts

@@ -1,2 +1,5 @@
+export * from "./target-versions";
 export * from "./validate-binary-version";
+export * from "./validate-function-version-support";
 export * from "./validate-provider-presence";
+export * from "./validate-terraform-feature-version";

package/lib/validations/index.js

@@ -16,6 +16,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // Copyright (c) HashiCorp, Inc
 // SPDX-License-Identifier: MPL-2.0
+__exportStar(require("./target-versions"), exports);
 __exportStar(require("./validate-binary-version"), exports);
+__exportStar(require("./validate-function-version-support"), exports);
 __exportStar(require("./validate-provider-presence"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmFsaWRhdGlvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtCQUErQjtBQUMvQixtQ0FBbUM7QUFDbkMsNERBQTBDO0FBQzFDLCtEQUE2QyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNUEwtMi4wXG5leHBvcnQgKiBmcm9tIFwiLi92YWxpZGF0ZS1iaW5hcnktdmVyc2lvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdmFsaWRhdGUtcHJvdmlkZXItcHJlc2VuY2VcIjtcbiJdfQ==
+__exportStar(require("./validate-terraform-feature-version"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmFsaWRhdGlvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtCQUErQjtBQUMvQixtQ0FBbUM7QUFDbkMsb0RBQWtDO0FBQ2xDLDREQUEwQztBQUMxQyxzRUFBb0Q7QUFDcEQsK0RBQTZDO0FBQzdDLHVFQUFxRCIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNUEwtMi4wXG5leHBvcnQgKiBmcm9tIFwiLi90YXJnZXQtdmVyc2lvbnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3ZhbGlkYXRlLWJpbmFyeS12ZXJzaW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi92YWxpZGF0ZS1mdW5jdGlvbi12ZXJzaW9uLXN1cHBvcnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3ZhbGlkYXRlLXByb3ZpZGVyLXByZXNlbmNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi92YWxpZGF0ZS10ZXJyYWZvcm0tZmVhdHVyZS12ZXJzaW9uXCI7XG4iXX0=

package/lib/validations/target-versions.d.ts

@@ -0,0 +1,71 @@
+import { IConstruct, IValidation } from "constructs";
+import { TerraformFeatureVersionConstraints } from "./validate-terraform-feature-version";
+/**
+ * Context key carrying the project's declared Terraform-compatible runtime
+ * targets (set from the `targetVersions` field in cdktf.json by the CLI, or
+ * directly via App context / CDKTF_CONTEXT_JSON for standalone synth).
+ *
+ * This is the canonical definition. `@cdktn/commons` imports it from here
+ * (commons depends on cdktn; cdktn must not depend on commons), so the CLI
+ * writes and the construct library reads the exact same key. It is an
+ * internal wiring detail, deliberately not part of cdktn's public API.
+ */
+export declare const TARGET_VERSIONS_CONTEXT_KEY = "targetVersions";
+/**
+ * The Terraform-compatible runtimes a project declares it supports, as npm
+ * semver ranges per product. A missing product means the project does not
+ * target that product.
+ */
+export interface TerraformTargetVersions {
+    readonly terraform?: string;
+    readonly opentofu?: string;
+}
+/**
+ * Used when a project declares no `targetVersions`: the project is assumed
+ * to target every supported release of both products, which is the strictest
+ * (most portable) interpretation.
+ */
+export declare const DEFAULT_TARGET_VERSIONS: TerraformTargetVersions;
+/**
+ * The product keys a project may declare targets for. Exported for reuse by
+ * `@cdktn/commons` (imported via subpath), not part of cdktn's public API.
+ */
+export declare const TARGET_PRODUCTS: readonly ["terraform", "opentofu"];
+/**
+ * Resolves the declared target versions from construct context, falling back
+ * to DEFAULT_TARGET_VERSIONS. Returns errors instead of targets when the
+ * declared value is malformed (which can happen when context is set directly
+ * on the App rather than going through cdktf.json validation).
+ */
+export declare function resolveTargetVersions(scope: IConstruct): {
+    targets?: TerraformTargetVersions;
+    errors: string[];
+};
+/**
+ * Checks whether a feature is supported across the entire declared target
+ * range of every targeted product.
+ *
+ * `supportedIn` follows the TerraformFeatureVersionConstraints semantics: a
+ * missing product key means the feature is not supported by that product at
+ * any version. The check is a semver range subset: declaring
+ * `terraform: ">=1.5.7"` while a feature requires `>=1.8.0` fails, because
+ * the project claims to support 1.5.7..1.8.0 where the feature is missing.
+ */
+export declare function checkFeatureSupportedByTargets(featureName: string, supportedIn: TerraformFeatureVersionConstraints, targets: TerraformTargetVersions, hint?: string): string[];
+/**
+ * Validates that a feature is supported by the project's declared
+ * Terraform-compatible runtime targets (cdktf.json `targetVersions`),
+ * without probing any locally installed binary.
+ *
+ * Verifying the actually installed binary is a separate, explicit step:
+ * the opt-in `validateInstalledBinary` config handled by the CLI commands
+ * that execute the binary.
+ */
+export declare class ValidateFeatureTargetSupport implements IValidation {
+    protected scope: IConstruct;
+    protected featureName: string;
+    protected supportedIn: TerraformFeatureVersionConstraints;
+    protected hint?: string | undefined;
+    constructor(scope: IConstruct, featureName: string, supportedIn: TerraformFeatureVersionConstraints, hint?: string | undefined);
+    validate(): string[];
+}

package/lib/validations/target-versions.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateFeatureTargetSupport = exports.TARGET_PRODUCTS = exports.DEFAULT_TARGET_VERSIONS = exports.TARGET_VERSIONS_CONTEXT_KEY = void 0;
+exports.resolveTargetVersions = resolveTargetVersions;
+exports.checkFeatureSupportedByTargets = checkFeatureSupportedByTargets;
+const semver = require("semver");
+/**
+ * Context key carrying the project's declared Terraform-compatible runtime
+ * targets (set from the `targetVersions` field in cdktf.json by the CLI, or
+ * directly via App context / CDKTF_CONTEXT_JSON for standalone synth).
+ *
+ * This is the canonical definition. `@cdktn/commons` imports it from here
+ * (commons depends on cdktn; cdktn must not depend on commons), so the CLI
+ * writes and the construct library reads the exact same key. It is an
+ * internal wiring detail, deliberately not part of cdktn's public API.
+ */
+exports.TARGET_VERSIONS_CONTEXT_KEY = "targetVersions";
+/**
+ * Used when a project declares no `targetVersions`: the project is assumed
+ * to target every supported release of both products, which is the strictest
+ * (most portable) interpretation.
+ */
+exports.DEFAULT_TARGET_VERSIONS = {
+    terraform: ">=1.5.7",
+    opentofu: ">=1.6.0",
+};
+/**
+ * The product keys a project may declare targets for. Exported for reuse by
+ * `@cdktn/commons` (imported via subpath), not part of cdktn's public API.
+ */
+exports.TARGET_PRODUCTS = ["terraform", "opentofu"];
+/**
+ * Resolves the declared target versions from construct context, falling back
+ * to DEFAULT_TARGET_VERSIONS. Returns errors instead of targets when the
+ * declared value is malformed (which can happen when context is set directly
+ * on the App rather than going through cdktf.json validation).
+ */
+function resolveTargetVersions(scope) {
+    const declared = scope.node.tryGetContext(exports.TARGET_VERSIONS_CONTEXT_KEY);
+    if (declared === undefined) {
+        return { targets: exports.DEFAULT_TARGET_VERSIONS, errors: [] };
+    }
+    if (typeof declared !== "object" ||
+        declared === null ||
+        Array.isArray(declared)) {
+        return {
+            errors: [
+                `targetVersions context must be an object mapping products to semver ranges, e.g. { "terraform": ">=1.5.7" }`,
+            ],
+        };
+    }
+    const entries = Object.entries(declared);
+    if (entries.length === 0) {
+        return {
+            errors: [
+                `targetVersions must declare at least one product ("terraform" or "opentofu") or be omitted entirely`,
+            ],
+        };
+    }
+    const errors = [];
+    for (const [product, range] of entries) {
+        if (!exports.TARGET_PRODUCTS.includes(product)) {
+            errors.push(`targetVersions has unknown product "${product}" (expected "terraform" or "opentofu")`);
+        }
+        else if (typeof range === "string" && range.includes("~>")) {
+            // npm semver happens to parse "~>" as "~", which has different
+            // semantics than Terraform's "~>" pessimistic constraint — reject it
+            // instead of silently meaning something else
+            errors.push(`targetVersions.${product} "${range}" uses Terraform provider constraint syntax; use npm semver ranges instead (e.g. ">=1.5.7" or "~1.5.7")`);
+        }
+        else if (typeof range !== "string" || semver.validRange(range) === null) {
+            errors.push(`targetVersions.${product} ${JSON.stringify(range)} is not a valid semver range`);
+        }
+    }
+    if (errors.length > 0) {
+        return { errors };
+    }
+    return { targets: declared, errors: [] };
+}
+/**
+ * Checks whether a feature is supported across the entire declared target
+ * range of every targeted product.
+ *
+ * `supportedIn` follows the TerraformFeatureVersionConstraints semantics: a
+ * missing product key means the feature is not supported by that product at
+ * any version. The check is a semver range subset: declaring
+ * `terraform: ">=1.5.7"` while a feature requires `>=1.8.0` fails, because
+ * the project claims to support 1.5.7..1.8.0 where the feature is missing.
+ */
+function checkFeatureSupportedByTargets(featureName, supportedIn, targets, hint) {
+    const errors = [];
+    for (const product of exports.TARGET_PRODUCTS) {
+        const targetRange = targets[product];
+        if (!targetRange)
+            continue; // product not targeted by the project
+        const supportedRange = supportedIn[product];
+        if (!supportedRange) {
+            errors.push(`${featureName} is not supported by ${product}, but the project targets ${product} ${targetRange}. ${hint || ""}`.trimEnd());
+            continue;
+        }
+        if (!semver.subset(targetRange, supportedRange)) {
+            errors.push(`${featureName} requires ${product} ${supportedRange}, but the project targets ${product} ${targetRange}. ${hint || ""}`.trimEnd());
+        }
+    }
+    return errors;
+}
+/**
+ * Validates that a feature is supported by the project's declared
+ * Terraform-compatible runtime targets (cdktf.json `targetVersions`),
+ * without probing any locally installed binary.
+ *
+ * Verifying the actually installed binary is a separate, explicit step:
+ * the opt-in `validateInstalledBinary` config handled by the CLI commands
+ * that execute the binary.
+ */
+class ValidateFeatureTargetSupport {
+    constructor(scope, featureName, supportedIn, hint) {
+        this.scope = scope;
+        this.featureName = featureName;
+        this.supportedIn = supportedIn;
+        this.hint = hint;
+    }
+    validate() {
+        const { targets, errors } = resolveTargetVersions(this.scope);
+        if (!targets) {
+            return errors;
+        }
+        return checkFeatureSupportedByTargets(this.featureName, this.supportedIn, targets, this.hint);
+    }
+}
+exports.ValidateFeatureTargetSupport = ValidateFeatureTargetSupport;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"target-versions.js","sourceRoot":"","sources":["../../src/validations/target-versions.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { IConstruct, IValidation } from \"constructs\";\nimport * as semver from \"semver\";\nimport { TerraformFeatureVersionConstraints } from \"./validate-terraform-feature-version\";\n\n/**\n * Context key carrying the project's declared Terraform-compatible runtime\n * targets (set from the `targetVersions` field in cdktf.json by the CLI, or\n * directly via App context / CDKTF_CONTEXT_JSON for standalone synth).\n *\n * This is the canonical definition. `@cdktn/commons` imports it from here\n * (commons depends on cdktn; cdktn must not depend on commons), so the CLI\n * writes and the construct library reads the exact same key. It is an\n * internal wiring detail, deliberately not part of cdktn's public API.\n */\nexport const TARGET_VERSIONS_CONTEXT_KEY = \"targetVersions\";\n\n/**\n * The Terraform-compatible runtimes a project declares it supports, as npm\n * semver ranges per product. A missing product means the project does not\n * target that product.\n */\nexport interface TerraformTargetVersions {\n  readonly terraform?: string;\n  readonly opentofu?: string;\n}\n\n/**\n * Used when a project declares no `targetVersions`: the project is assumed\n * to target every supported release of both products, which is the strictest\n * (most portable) interpretation.\n */\nexport const DEFAULT_TARGET_VERSIONS: TerraformTargetVersions = {\n  terraform: \">=1.5.7\",\n  opentofu: \">=1.6.0\",\n};\n\n/**\n * The product keys a project may declare targets for. Exported for reuse by\n * `@cdktn/commons` (imported via subpath), not part of cdktn's public API.\n */\nexport const TARGET_PRODUCTS = [\"terraform\", \"opentofu\"] as const;\n\n/**\n * Resolves the declared target versions from construct context, falling back\n * to DEFAULT_TARGET_VERSIONS. Returns errors instead of targets when the\n * declared value is malformed (which can happen when context is set directly\n * on the App rather than going through cdktf.json validation).\n */\nexport function resolveTargetVersions(scope: IConstruct): {\n  targets?: TerraformTargetVersions;\n  errors: string[];\n} {\n  const declared = scope.node.tryGetContext(TARGET_VERSIONS_CONTEXT_KEY);\n  if (declared === undefined) {\n    return { targets: DEFAULT_TARGET_VERSIONS, errors: [] };\n  }\n\n  if (\n    typeof declared !== \"object\" ||\n    declared === null ||\n    Array.isArray(declared)\n  ) {\n    return {\n      errors: [\n        `targetVersions context must be an object mapping products to semver ranges, e.g. { \"terraform\": \">=1.5.7\" }`,\n      ],\n    };\n  }\n\n  const entries = Object.entries(declared);\n  if (entries.length === 0) {\n    return {\n      errors: [\n        `targetVersions must declare at least one product (\"terraform\" or \"opentofu\") or be omitted entirely`,\n      ],\n    };\n  }\n\n  const errors: string[] = [];\n  for (const [product, range] of entries) {\n    if (!TARGET_PRODUCTS.includes(product as any)) {\n      errors.push(\n        `targetVersions has unknown product \"${product}\" (expected \"terraform\" or \"opentofu\")`,\n      );\n    } else if (typeof range === \"string\" && range.includes(\"~>\")) {\n      // npm semver happens to parse \"~>\" as \"~\", which has different\n      // semantics than Terraform's \"~>\" pessimistic constraint — reject it\n      // instead of silently meaning something else\n      errors.push(\n        `targetVersions.${product} \"${range}\" uses Terraform provider constraint syntax; use npm semver ranges instead (e.g. \">=1.5.7\" or \"~1.5.7\")`,\n      );\n    } else if (typeof range !== \"string\" || semver.validRange(range) === null) {\n      errors.push(\n        `targetVersions.${product} ${JSON.stringify(\n          range,\n        )} is not a valid semver range`,\n      );\n    }\n  }\n\n  if (errors.length > 0) {\n    return { errors };\n  }\n\n  return { targets: declared as TerraformTargetVersions, errors: [] };\n}\n\n/**\n * Checks whether a feature is supported across the entire declared target\n * range of every targeted product.\n *\n * `supportedIn` follows the TerraformFeatureVersionConstraints semantics: a\n * missing product key means the feature is not supported by that product at\n * any version. The check is a semver range subset: declaring\n * `terraform: \">=1.5.7\"` while a feature requires `>=1.8.0` fails, because\n * the project claims to support 1.5.7..1.8.0 where the feature is missing.\n */\nexport function checkFeatureSupportedByTargets(\n  featureName: string,\n  supportedIn: TerraformFeatureVersionConstraints,\n  targets: TerraformTargetVersions,\n  hint?: string,\n): string[] {\n  const errors: string[] = [];\n\n  for (const product of TARGET_PRODUCTS) {\n    const targetRange = targets[product];\n    if (!targetRange) continue; // product not targeted by the project\n\n    const supportedRange = supportedIn[product];\n    if (!supportedRange) {\n      errors.push(\n        `${featureName} is not supported by ${product}, but the project targets ${product} ${targetRange}. ${\n          hint || \"\"\n        }`.trimEnd(),\n      );\n      continue;\n    }\n\n    if (!semver.subset(targetRange, supportedRange)) {\n      errors.push(\n        `${featureName} requires ${product} ${supportedRange}, but the project targets ${product} ${targetRange}. ${\n          hint || \"\"\n        }`.trimEnd(),\n      );\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Validates that a feature is supported by the project's declared\n * Terraform-compatible runtime targets (cdktf.json `targetVersions`),\n * without probing any locally installed binary.\n *\n * Verifying the actually installed binary is a separate, explicit step:\n * the opt-in `validateInstalledBinary` config handled by the CLI commands\n * that execute the binary.\n */\nexport class ValidateFeatureTargetSupport implements IValidation {\n  constructor(\n    protected scope: IConstruct,\n    protected featureName: string,\n    protected supportedIn: TerraformFeatureVersionConstraints,\n    protected hint?: string,\n  ) {}\n\n  public validate(): string[] {\n    const { targets, errors } = resolveTargetVersions(this.scope);\n    if (!targets) {\n      return errors;\n    }\n\n    return checkFeatureSupportedByTargets(\n      this.featureName,\n      this.supportedIn,\n      targets,\n      this.hint,\n    );\n  }\n}\n"]}

package/lib/validations/validate-binary-version.d.ts

@@ -2,6 +2,16 @@ import { IValidation } from "constructs";
 /**
  * A validation that can be applied to a construct that will error if the
  * construct is being used in an environment with a version of a binary lower than the specified version.
+ *
+ * TODO(target-versions): legacy synth-time binary probe that predates
+ * OpenTofu support and the declared `targetVersions` model. Existing
+ * consumers (e.g. ValidateTerraformVersion for resource moves) should
+ * migrate to ValidateFeatureTargetSupport, leaving installed-binary
+ * verification to the opt-in validateInstalledBinary CLI behavior. Left
+ * unchanged here only to keep this PR small; the migration is tracked in
+ * #275. Note this class is not exported from the cdktn package root, so the
+ * change is behavioral (synth no longer shelling out), not a symbol-level
+ * public-API break.
  */
 export declare class ValidateBinaryVersion implements IValidation {
     protected binary: string;

package/lib/validations/validate-binary-version.js

@@ -6,6 +6,16 @@ const semver = require("semver");
 /**
  * A validation that can be applied to a construct that will error if the
  * construct is being used in an environment with a version of a binary lower than the specified version.
+ *
+ * TODO(target-versions): legacy synth-time binary probe that predates
+ * OpenTofu support and the declared `targetVersions` model. Existing
+ * consumers (e.g. ValidateTerraformVersion for resource moves) should
+ * migrate to ValidateFeatureTargetSupport, leaving installed-binary
+ * verification to the opt-in validateInstalledBinary CLI behavior. Left
+ * unchanged here only to keep this PR small; the migration is tracked in
+ * #275. Note this class is not exported from the cdktn package root, so the
+ * change is behavioral (synth no longer shelling out), not a symbol-level
+ * public-API break.
  */
 class ValidateBinaryVersion {
     constructor(binary, versionConstraint, versionCommand, hint) {
@@ -41,4 +51,4 @@ class ValidateBinaryVersion {
     }
 }
 exports.ValidateBinaryVersion = ValidateBinaryVersion;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/validations/validate-function-version-support.d.ts

@@ -0,0 +1,21 @@
+import { IConstruct, IValidation } from "constructs";
+/**
+ * Validates that every Terraform function used through `Fn` is supported by
+ * the project's declared Terraform/OpenTofu targets (cdktf.json
+ * `targetVersions`, defaulting to the dual product baseline).
+ *
+ * Most functions are universally available and are not checked at all; only
+ * functions listed in the generated availability map are validated. The
+ * check is purely declarative — no binary is executed — so synth behaves
+ * identically in CI, package builds, and environments without Terraform or
+ * OpenTofu installed. Verifying the actually installed binary is the
+ * separate, opt-in `validateInstalledBinary` CLI behavior.
+ *
+ * Functions used via raw escape hatches (overrides, hand-written expression
+ * strings) are not tracked and therefore not validated.
+ */
+export declare class ValidateFunctionVersionSupport implements IValidation {
+    protected scope: IConstruct;
+    constructor(scope: IConstruct);
+    validate(): string[];
+}

package/lib/validations/validate-function-version-support.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateFunctionVersionSupport = void 0;
+const target_versions_1 = require("./target-versions");
+const function_availability_generated_1 = require("../functions/function-availability.generated");
+const usage_registry_1 = require("../functions/usage-registry");
+/**
+ * Validates that every Terraform function used through `Fn` is supported by
+ * the project's declared Terraform/OpenTofu targets (cdktf.json
+ * `targetVersions`, defaulting to the dual product baseline).
+ *
+ * Most functions are universally available and are not checked at all; only
+ * functions listed in the generated availability map are validated. The
+ * check is purely declarative — no binary is executed — so synth behaves
+ * identically in CI, package builds, and environments without Terraform or
+ * OpenTofu installed. Verifying the actually installed binary is the
+ * separate, opt-in `validateInstalledBinary` CLI behavior.
+ *
+ * Functions used via raw escape hatches (overrides, hand-written expression
+ * strings) are not tracked and therefore not validated.
+ */
+class ValidateFunctionVersionSupport {
+    constructor(scope) {
+        this.scope = scope;
+    }
+    validate() {
+        const constrainedFunctions = (0, usage_registry_1.getUsedFunctions)()
+            .filter((name) => name in function_availability_generated_1.functionVersionConstraints)
+            .sort();
+        // only universally available functions in use: nothing to validate
+        if (constrainedFunctions.length === 0) {
+            return [];
+        }
+        const { targets, errors } = (0, target_versions_1.resolveTargetVersions)(this.scope);
+        if (!targets) {
+            return errors;
+        }
+        return constrainedFunctions.flatMap((name) => {
+            const supportedIn = function_availability_generated_1.functionVersionConstraints[name];
+            return (0, target_versions_1.checkFeatureSupportedByTargets)(`Terraform function "${name}"`, supportedIn, targets, availabilityHint(supportedIn));
+        });
+    }
+}
+exports.ValidateFunctionVersionSupport = ValidateFunctionVersionSupport;
+/**
+ * Tells the user where the function IS available, so they can adjust their
+ * declared targetVersions (or drop the function).
+ */
+function availabilityHint(supportedIn) {
+    const parts = Object.entries(supportedIn).map(([product, range]) => `${product} ${range}`);
+    return `It is available in ${parts.join(" and ")}.`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/validations/validate-terraform-feature-version.d.ts

@@ -0,0 +1,34 @@
+export type TerraformCliName = "terraform" | "opentofu" | "unknown";
+export interface TerraformCliVersion {
+    readonly name: TerraformCliName;
+    readonly version?: string;
+}
+/**
+ * The versions at which Terraform and OpenTofu support a feature, as npm
+ * semver ranges. A missing product key means the feature is not supported by
+ * that product at any version.
+ *
+ * Features can become available in Terraform and OpenTofu at different
+ * versions, so the validation matrix is feature -> product -> semver range.
+ * Used together with the project's declared targets, see
+ * ValidateFeatureTargetSupport.
+ */
+export interface TerraformFeatureVersionConstraints {
+    readonly terraform?: string;
+    readonly opentofu?: string;
+}
+/**
+ * Parses the output of `terraform version` or `tofu version`.
+ *
+ * Plain text version output is used because both Terraform and OpenTofu expose
+ * a Terraform-compatible `terraform_version` key in `version -json` output.
+ *
+ * Note: synth-time validations check features against the project's declared
+ * `targetVersions` and do not execute any binary; this parser exists for
+ * consumers that explicitly interact with an installed CLI (e.g. the opt-in
+ * validateInstalledBinary behavior in the cdktn CLI). This is the canonical
+ * definition; `@cdktn/commons` imports it (commons depends on cdktn). Its
+ * return type uses a string-literal union, so it is kept out of cdktn's
+ * public (jsii) API and consumed via subpath import.
+ */
+export declare function parseTerraformCliVersion(versionOutput: string): TerraformCliVersion;

package/lib/validations/validate-terraform-feature-version.js

@@ -0,0 +1,34 @@
+"use strict";
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTerraformCliVersion = parseTerraformCliVersion;
+/**
+ * Parses the output of `terraform version` or `tofu version`.
+ *
+ * Plain text version output is used because both Terraform and OpenTofu expose
+ * a Terraform-compatible `terraform_version` key in `version -json` output.
+ *
+ * Note: synth-time validations check features against the project's declared
+ * `targetVersions` and do not execute any binary; this parser exists for
+ * consumers that explicitly interact with an installed CLI (e.g. the opt-in
+ * validateInstalledBinary behavior in the cdktn CLI). This is the canonical
+ * definition; `@cdktn/commons` imports it (commons depends on cdktn). Its
+ * return type uses a string-literal union, so it is kept out of cdktn's
+ * public (jsii) API and consumed via subpath import.
+ */
+function parseTerraformCliVersion(versionOutput) {
+    const firstLine = versionOutput.trim().split(/\r?\n/)[0] || "";
+    const firstLineMatch = firstLine.match(/^(Terraform|OpenTofu) v(\d+\.\d+\.\d+(?:[-+][^\s]+)?)/);
+    if (firstLineMatch) {
+        return {
+            name: firstLineMatch[1] === "OpenTofu" ? "opentofu" : "terraform",
+            version: firstLineMatch[2],
+        };
+    }
+    return {
+        name: "unknown",
+        version: versionOutput.match(/\d+\.\d+\.\d+(?:[-+][^\s]+)?/)?.[0],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/{call-bind-apply-helpers → safe-stable-stringify}/LICENSE

@@ -1,6 +1,6 @@
-MIT License
+The MIT License (MIT)
 
-Copyright (c) 2024 Jordan Harband
+Copyright (c) Ruben Bridgewater
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/node_modules/safe-stable-stringify/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "main": "wrapper.js"
+}

package/node_modules/safe-stable-stringify/esm/wrapper.d.ts

@@ -0,0 +1,4 @@
+import { stringify } from '../index.js'
+
+export * from '../index.js'
+export default stringify

package/node_modules/safe-stable-stringify/esm/wrapper.js

@@ -0,0 +1,6 @@
+import cjsModule from '../index.js'
+
+export const configure = cjsModule.configure
+
+export const stringify = cjsModule
+export default cjsModule

package/node_modules/safe-stable-stringify/index.d.ts

@@ -0,0 +1,22 @@
+export type Replacer = (number | string)[] | null | undefined | ((key: string, value: unknown) => string | number | boolean | null | object)
+
+export function stringify(value: undefined | symbol | ((...args: unknown[]) => unknown), replacer?: Replacer, space?: string | number): undefined
+export function stringify(value: string | number | unknown[] | null | boolean | object, replacer?: Replacer, space?: string | number): string
+export function stringify(value: unknown, replacer?: ((key: string, value: unknown) => unknown) | (number | string)[] | null | undefined, space?: string | number): string | undefined
+
+export interface StringifyOptions {
+  bigint?: boolean,
+  circularValue?: string | null | TypeErrorConstructor | ErrorConstructor,
+  deterministic?: boolean | ((a: string, b: string) => number),
+  maximumBreadth?: number,
+  maximumDepth?: number,
+  strict?: boolean,
+}
+
+export namespace stringify {
+  export function configure(options: StringifyOptions): typeof stringify
+}
+
+export function configure(options: StringifyOptions): typeof stringify
+
+export default stringify