@cdktn/provider-schema 0.24.0-pre.88 → 0.24.0-pre.89

package/build/cache.js

@@ -33,10 +33,16 @@ const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 // We keep this very simple since the caching feature is experimental
 // we might need to do housekeeping / include terraform / cdktf version in the future
-function cacheKey(input) {
-    return `${encodeURIComponent(input.fqn)}@${encodeURIComponent(input.version || "")}`;
+//
+// keySuffix distinguishes cache entries fetched by different CLIs/versions
+// (e.g. "terraform-1.7") so a schema fetched by a CLI too old to emit newer
+// sections (functions, ephemeral resources, ...) isn't served up as if it
+// were a complete fetch. See read.ts.
+function cacheKey(input, keySuffix) {
+    const base = `${encodeURIComponent(input.fqn)}@${encodeURIComponent(input.version || "")}`;
+    return keySuffix ? `${base}@${encodeURIComponent(keySuffix)}` : base;
 }
-function cachedAccess(producer, cacheDir) {
+function cachedAccess(producer, cacheDir, keySuffix) {
     const cacheEnabled = typeof cacheDir === "string" && cacheDir.length > 0;
     if (cacheEnabled && !fs.lstatSync(cacheDir).isDirectory()) {
         throw commons_1.Errors.Usage(`Provider Schema Cache directory '${cacheDir}' is not a directory`);
@@ -49,7 +55,7 @@ function cachedAccess(producer, cacheDir) {
     }
     commons_1.logger.debug(`Provider Schema Cache enabled, caching at ${cacheDir}`);
     return async (input) => {
-        const key = cacheKey(input);
+        const key = cacheKey(input, keySuffix);
         const cachePath = path.join(cacheDir, `${key}.json`);
         if (fs.existsSync(cachePath)) {
             commons_1.logger.debug(`Cache hit for ${key}`);
@@ -63,4 +69,4 @@ function cachedAccess(producer, cacheDir) {
     };
 }
 exports.cachedAccess = cachedAccess;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/emission-check.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The newer-protocol schema sections that a fetching CLI only starts to
+ * *emit* in `terraform providers schema -json` as of a certain version.
+ *
+ * NOTE: these are emission boundaries, not language-support boundaries -
+ * e.g. provider functions are usable in HCL since Terraform 1.7.0, but only
+ * show up in the schema dump as of 1.8.0.
+ */
+export type SchemaEmissionFamily = "functions" | "ephemeral_resource_schemas" | "write_only" | "resource_identity_schemas";
+declare const TARGET_PRODUCTS: readonly ["terraform", "opentofu"];
+type TargetProduct = (typeof TARGET_PRODUCTS)[number];
+/**
+ * Hand-maintained from `tools/provider-feature-availability/features-matrix.json`
+ * — specifically each feature's `documented_emitted_from` /
+ * `observed_introduced` fields per product (see that directory's README for
+ * how the dataset itself is produced/regenerated, and its "In-repo
+ * consumers" section for how this map and `providerFeatureConstraints` in
+ * `packages/cdktn/src/provider-feature-constraints.ts` relate to the
+ * matrix and to each other).
+ *
+ * There is no automated check that this map stays in sync with the matrix;
+ * updates must be applied by hand when the matrix changes. An automated
+ * drift check is tracked in #309.
+ */
+export declare const SCHEMA_EMISSION_BOUNDARIES: Record<SchemaEmissionFamily, Record<TargetProduct, string>>;
+export declare const SCHEMA_EMISSION_FAMILY_LABELS: Record<SchemaEmissionFamily, string>;
+export {};
+//# sourceMappingURL=emission-check.d.ts.map

package/build/emission-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emission-check.d.ts","sourceRoot":"","sources":["../src/emission-check.ts"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAC5B,WAAW,GACX,4BAA4B,GAC5B,YAAY,GACZ,2BAA2B,CAAC;AAEhC,QAAA,MAAM,eAAe,oCAAqC,CAAC;AAC3D,KAAK,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAC7C,oBAAoB,EACpB,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAM9B,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAChD,oBAAoB,EACpB,MAAM,CAMP,CAAC"}

package/build/emission-check.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestedEmittingCliVersions = exports.checkSchemaEmissionGapFamilies = exports.checkSchemaEmissionGaps = exports.SCHEMA_EMISSION_FAMILY_LABELS = exports.SCHEMA_EMISSION_BOUNDARIES = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const semver = __importStar(require("semver"));
+const TARGET_PRODUCTS = ["terraform", "opentofu"];
+/**
+ * Hand-maintained from `tools/provider-feature-availability/features-matrix.json`
+ * — specifically each feature's `documented_emitted_from` /
+ * `observed_introduced` fields per product (see that directory's README for
+ * how the dataset itself is produced/regenerated, and its "In-repo
+ * consumers" section for how this map and `providerFeatureConstraints` in
+ * `packages/cdktn/src/provider-feature-constraints.ts` relate to the
+ * matrix and to each other).
+ *
+ * There is no automated check that this map stays in sync with the matrix;
+ * updates must be applied by hand when the matrix changes. An automated
+ * drift check is tracked in #309.
+ */
+exports.SCHEMA_EMISSION_BOUNDARIES = {
+    functions: { terraform: "1.8.0", opentofu: "1.8.0" },
+    ephemeral_resource_schemas: { terraform: "1.10.0", opentofu: "1.11.0" },
+    write_only: { terraform: "1.11.0", opentofu: "1.11.0" },
+    resource_identity_schemas: { terraform: "1.12.0", opentofu: "1.12.0" },
+};
+exports.SCHEMA_EMISSION_FAMILY_LABELS = {
+    functions: "provider functions",
+    ephemeral_resource_schemas: "ephemeral resources",
+    write_only: "write-only attributes",
+    resource_identity_schemas: "resource identity",
+};
+/**
+ * Determines which schema-emission gaps the given fetching CLI has, in
+ * light of the project's declared `targetVersions`.
+ *
+ * A family is reported when both are true:
+ * - the fetching CLI's own version predates that family's emission
+ *   boundary for its product (so this particular fetch could not have
+ *   included the section, even if the provider implements it)
+ * - at least one of the project's targeted products declares a range that
+ *   intersects the versions where that family is emitted (i.e. the project
+ *   actually intends to run on versions where the feature would show up)
+ *
+ * @internal exposed for testing
+ */
+function checkSchemaEmissionGaps(cli, targets) {
+    return checkSchemaEmissionGapFamilies(cli, targets).map((family) => exports.SCHEMA_EMISSION_FAMILY_LABELS[family]);
+}
+exports.checkSchemaEmissionGaps = checkSchemaEmissionGaps;
+/**
+ * Same as checkSchemaEmissionGaps, but returns the raw family keys so
+ * callers can also compute a remedy (see suggestedEmittingCliVersions).
+ *
+ * @internal exposed for testing
+ */
+function checkSchemaEmissionGapFamilies(cli, targets) {
+    if (cli.name === "unknown" || !cli.version)
+        return [];
+    const cliProduct = cli.name;
+    const gaps = [];
+    for (const family of Object.keys(exports.SCHEMA_EMISSION_BOUNDARIES)) {
+        const boundaries = exports.SCHEMA_EMISSION_BOUNDARIES[family];
+        const cliBoundary = boundaries[cliProduct];
+        if (!cliBoundary)
+            continue;
+        // The fetching CLI is new enough to emit this family - no gap.
+        if (!semver.lt(cli.version, cliBoundary))
+            continue;
+        const wanted = TARGET_PRODUCTS.some((product) => {
+            const targetRange = targets[product];
+            if (!targetRange)
+                return false;
+            if (semver.validRange(targetRange) === null)
+                return false;
+            const supportedRange = `>=${boundaries[product]}`;
+            try {
+                return semver.intersects(targetRange, supportedRange);
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+        if (wanted)
+            gaps.push(family);
+    }
+    return gaps;
+}
+exports.checkSchemaEmissionGapFamilies = checkSchemaEmissionGapFamilies;
+/**
+ * The lowest CLI version per product whose `providers schema -json` emits
+ * every one of the given families — the remedy to suggest alongside the
+ * fetch-time warning.
+ *
+ * @internal exposed for testing
+ */
+function suggestedEmittingCliVersions(families) {
+    return TARGET_PRODUCTS.map((product) => {
+        const needed = families
+            .map((family) => exports.SCHEMA_EMISSION_BOUNDARIES[family][product])
+            .sort(semver.compare)
+            .pop();
+        return needed ? `${product} >=${needed}` : undefined;
+    })
+        .filter((part) => part !== undefined)
+        .join(" / ");
+}
+exports.suggestedEmittingCliVersions = suggestedEmittingCliVersions;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emission-check.js","sourceRoot":"","sources":["../src/emission-check.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,mCAAmC;AACnC,+CAAiC;AAqBjC,MAAM,eAAe,GAAG,CAAC,WAAW,EAAE,UAAU,CAAU,CAAC;AAG3D;;;;;;;;;;;;GAYG;AACU,QAAA,0BAA0B,GAGnC;IACF,SAAS,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE;IACpD,0BAA0B,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE;IACvE,UAAU,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE;IACvD,yBAAyB,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE;CACvE,CAAC;AAEW,QAAA,6BAA6B,GAGtC;IACF,SAAS,EAAE,oBAAoB;IAC/B,0BAA0B,EAAE,qBAAqB;IACjD,UAAU,EAAE,uBAAuB;IACnC,yBAAyB,EAAE,mBAAmB;CAC/C,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,SAAgB,uBAAuB,CACrC,GAAwB,EACxB,OAAgC;IAEhC,OAAO,8BAA8B,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,GAAG,CACrD,CAAC,MAAM,EAAE,EAAE,CAAC,qCAA6B,CAAC,MAAM,CAAC,CAClD,CAAC;AACJ,CAAC;AAPD,0DAOC;AAED;;;;;GAKG;AACH,SAAgB,8BAA8B,CAC5C,GAAwB,EACxB,OAAgC;IAEhC,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,GAAG,CAAC,OAAO;QAAE,OAAO,EAAE,CAAC;IACtD,MAAM,UAAU,GAAG,GAAG,CAAC,IAAqB,CAAC;IAE7C,MAAM,IAAI,GAA2B,EAAE,CAAC;IAExC,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI,CAC9B,kCAA0B,CACD,EAAE,CAAC;QAC5B,MAAM,UAAU,GAAG,kCAA0B,CAAC,MAAM,CAAC,CAAC;QACtD,MAAM,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;QAC3C,IAAI,CAAC,WAAW;YAAE,SAAS;QAE3B,+DAA+D;QAC/D,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC;YAAE,SAAS;QAEnD,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;YAC9C,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;YACrC,IAAI,CAAC,WAAW;gBAAE,OAAO,KAAK,CAAC;YAC/B,IAAI,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,KAAK,IAAI;gBAAE,OAAO,KAAK,CAAC;YAC1D,MAAM,cAAc,GAAG,KAAK,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YAClD,IAAI,CAAC;gBACH,OAAO,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;YACxD,CAAC;YAAC,WAAM,CAAC;gBACP,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,MAAM;YAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAnCD,wEAmCC;AAED;;;;;;GAMG;AACH,SAAgB,4BAA4B,CAC1C,QAAgC;IAEhC,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;QACrC,MAAM,MAAM,GAAG,QAAQ;aACpB,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,kCAA0B,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC;aAC5D,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;aACpB,GAAG,EAAE,CAAC;QACT,OAAO,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,MAAM,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IACvD,CAAC,CAAC;SACC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC;SACpC,IAAI,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC;AAZD,oEAYC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as semver from \"semver\";\n\nimport type {\n  TerraformCliVersion,\n  TerraformTargetVersions,\n} from \"@cdktn/commons\";\n\n/**\n * The newer-protocol schema sections that a fetching CLI only starts to\n * *emit* in `terraform providers schema -json` as of a certain version.\n *\n * NOTE: these are emission boundaries, not language-support boundaries -\n * e.g. provider functions are usable in HCL since Terraform 1.7.0, but only\n * show up in the schema dump as of 1.8.0.\n */\nexport type SchemaEmissionFamily =\n  | \"functions\"\n  | \"ephemeral_resource_schemas\"\n  | \"write_only\"\n  | \"resource_identity_schemas\";\n\nconst TARGET_PRODUCTS = [\"terraform\", \"opentofu\"] as const;\ntype TargetProduct = (typeof TARGET_PRODUCTS)[number];\n\n/**\n * Hand-maintained from `tools/provider-feature-availability/features-matrix.json`\n * — specifically each feature's `documented_emitted_from` /\n * `observed_introduced` fields per product (see that directory's README for\n * how the dataset itself is produced/regenerated, and its \"In-repo\n * consumers\" section for how this map and `providerFeatureConstraints` in\n * `packages/cdktn/src/provider-feature-constraints.ts` relate to the\n * matrix and to each other).\n *\n * There is no automated check that this map stays in sync with the matrix;\n * updates must be applied by hand when the matrix changes. An automated\n * drift check is tracked in #309.\n */\nexport const SCHEMA_EMISSION_BOUNDARIES: Record<\n  SchemaEmissionFamily,\n  Record<TargetProduct, string>\n> = {\n  functions: { terraform: \"1.8.0\", opentofu: \"1.8.0\" },\n  ephemeral_resource_schemas: { terraform: \"1.10.0\", opentofu: \"1.11.0\" },\n  write_only: { terraform: \"1.11.0\", opentofu: \"1.11.0\" },\n  resource_identity_schemas: { terraform: \"1.12.0\", opentofu: \"1.12.0\" },\n};\n\nexport const SCHEMA_EMISSION_FAMILY_LABELS: Record<\n  SchemaEmissionFamily,\n  string\n> = {\n  functions: \"provider functions\",\n  ephemeral_resource_schemas: \"ephemeral resources\",\n  write_only: \"write-only attributes\",\n  resource_identity_schemas: \"resource identity\",\n};\n\n/**\n * Determines which schema-emission gaps the given fetching CLI has, in\n * light of the project's declared `targetVersions`.\n *\n * A family is reported when both are true:\n * - the fetching CLI's own version predates that family's emission\n *   boundary for its product (so this particular fetch could not have\n *   included the section, even if the provider implements it)\n * - at least one of the project's targeted products declares a range that\n *   intersects the versions where that family is emitted (i.e. the project\n *   actually intends to run on versions where the feature would show up)\n *\n * @internal exposed for testing\n */\nexport function checkSchemaEmissionGaps(\n  cli: TerraformCliVersion,\n  targets: TerraformTargetVersions,\n): string[] {\n  return checkSchemaEmissionGapFamilies(cli, targets).map(\n    (family) => SCHEMA_EMISSION_FAMILY_LABELS[family],\n  );\n}\n\n/**\n * Same as checkSchemaEmissionGaps, but returns the raw family keys so\n * callers can also compute a remedy (see suggestedEmittingCliVersions).\n *\n * @internal exposed for testing\n */\nexport function checkSchemaEmissionGapFamilies(\n  cli: TerraformCliVersion,\n  targets: TerraformTargetVersions,\n): SchemaEmissionFamily[] {\n  if (cli.name === \"unknown\" || !cli.version) return [];\n  const cliProduct = cli.name as TargetProduct;\n\n  const gaps: SchemaEmissionFamily[] = [];\n\n  for (const family of Object.keys(\n    SCHEMA_EMISSION_BOUNDARIES,\n  ) as SchemaEmissionFamily[]) {\n    const boundaries = SCHEMA_EMISSION_BOUNDARIES[family];\n    const cliBoundary = boundaries[cliProduct];\n    if (!cliBoundary) continue;\n\n    // The fetching CLI is new enough to emit this family - no gap.\n    if (!semver.lt(cli.version, cliBoundary)) continue;\n\n    const wanted = TARGET_PRODUCTS.some((product) => {\n      const targetRange = targets[product];\n      if (!targetRange) return false;\n      if (semver.validRange(targetRange) === null) return false;\n      const supportedRange = `>=${boundaries[product]}`;\n      try {\n        return semver.intersects(targetRange, supportedRange);\n      } catch {\n        return false;\n      }\n    });\n\n    if (wanted) gaps.push(family);\n  }\n\n  return gaps;\n}\n\n/**\n * The lowest CLI version per product whose `providers schema -json` emits\n * every one of the given families — the remedy to suggest alongside the\n * fetch-time warning.\n *\n * @internal exposed for testing\n */\nexport function suggestedEmittingCliVersions(\n  families: SchemaEmissionFamily[],\n): string {\n  return TARGET_PRODUCTS.map((product) => {\n    const needed = families\n      .map((family) => SCHEMA_EMISSION_BOUNDARIES[family][product])\n      .sort(semver.compare)\n      .pop();\n    return needed ? `${product} >=${needed}` : undefined;\n  })\n    .filter((part) => part !== undefined)\n    .join(\" / \");\n}\n"]}

package/build/provider-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider-schema.d.ts","sourceRoot":"","sources":["../src/provider-schema.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,2BAA2B,EAC3B,6BAA6B,EAG7B,YAAY,EACZ,cAAc,EAMf,MAAM,gBAAgB,CAAC;AAiExB;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,4BAA4B,CAAA;CAAE,CAAC;AACrE,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC;AACzE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE,CAAC;AAE/D,eAAO,MAAM,SAAS,MAAO,IAAI;cAMnB,gBAAgB;eACf,iBAAiB;UACtB,YAAY;CAErB,CAAC;AAkIF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,CAAC;IACnD,SAAS,EAAE;QACT,kBAAkB,CAAC,EAAE;YACnB,CAAC,IAAI,EAAE,MAAM,GAAG;gBAAE,MAAM,CAAC,EAAE,MAAM,CAAC;gBAAC,OAAO,CAAC,EAAE,MAAM,CAAA;aAAE,CAAC;SACvD,CAAC;KACH,CAAC;IACF,MAAM,CAAC,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;CACnE;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,6BAA6B,2BAuCtC;AAID,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAsC7E;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,2BAA2B,yCAqCzE"}
+{"version":3,"file":"provider-schema.d.ts","sourceRoot":"","sources":["../src/provider-schema.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,2BAA2B,EAC3B,6BAA6B,EAG7B,YAAY,EACZ,cAAc,EAUf,MAAM,gBAAgB,CAAC;AA2FxB;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,4BAA4B,CAAA;CAAE,CAAC;AACrE,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC;AACzE,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE,CAAC;AAE/D,eAAO,MAAM,SAAS,MAAO,IAAI;cAMnB,gBAAgB;eACf,iBAAiB;UACtB,YAAY;CAErB,CAAC;AAuIF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,CAAC;IACnD,SAAS,EAAE;QACT,kBAAkB,CAAC,EAAE;YACnB,CAAC,IAAI,EAAE,MAAM,GAAG;gBAAE,MAAM,CAAC,EAAE,MAAM,CAAC;gBAAC,OAAO,CAAC,EAAE,MAAM,CAAA;aAAE,CAAC;SACvD,CAAC;KACH,CAAC;IACF,MAAM,CAAC,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;CACnE;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,6BAA6B,2BAoDtC;AA2DD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAuC7E;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,2BAA2B,yCAqCzE"}

package/build/provider-schema.js

@@ -23,14 +23,35 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readModuleSchema = exports.sanitizeProviderSchema = exports.readProviderSchema = exports.parseFQPN = exports.terraformInitWithRetry = void 0;
+exports.readModuleSchema = exports.sanitizeProviderSchema = exports.warnIfSchemaEmissionGaps = exports.readProviderSchema = exports.parseFQPN = exports.terraformInitWithRetry = exports.getFetchingCliVersion = void 0;
 // Copyright (c) HashiCorp, Inc
 // SPDX-License-Identifier: MPL-2.0
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 const hcl2json_1 = require("@cdktn/hcl2json");
 const commons_1 = require("@cdktn/commons");
+const emission_check_1 = require("./emission-check");
 const terraformBinaryName = process.env.TERRAFORM_BINARY_NAME || "terraform";
+let fetchingCliVersionPromise;
+/**
+ * Determines the version of the fetching CLI (`terraform`/`tofu` binary
+ * resolved via `TERRAFORM_BINARY_NAME`) once per process, memoized.
+ *
+ * Used both to stamp fetched provider schemas (`cli_name`/`cli_version`)
+ * and as the cache key suffix in read.ts, since schema emission is fixed
+ * per CLI minor version.
+ *
+ * @internal exposed for testing like terraformInitWithRetry
+ */
+function getFetchingCliVersion() {
+    if (!fetchingCliVersionPromise) {
+        fetchingCliVersionPromise = (0, commons_1.exec)(terraformBinaryName, ["version"], {
+            cwd: process.cwd(),
+        }).then(commons_1.parseTerraformCliVersion);
+    }
+    return fetchingCliVersionPromise;
+}
+exports.getFetchingCliVersion = getFetchingCliVersion;
 // Provider binaries are downloaded from GitHub release CDNs during
 // `terraform init`, which intermittently returns 5xx. Retry on those
 // signatures only — real config/schema errors should still fail fast.
@@ -181,6 +202,11 @@ const harvestModuleSchema = async (workingDirectory, modules) => {
     }
     return result;
 };
+function joinWithAnd(items) {
+    if (items.length <= 1)
+        return items.join("");
+    return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
 async function readProviderSchema(target) {
     const config = {
         provider: {},
@@ -207,9 +233,65 @@ async function readProviderSchema(target) {
         }));
         providerSchema.provider_versions = versionSchema.provider_selections;
     });
+    // Stamp the fetching CLI's identity so downstream consumers can reason
+    // about which newer-protocol sections this fetch could possibly have
+    // emitted. Never fail the fetch over this - it's best-effort metadata.
+    try {
+        const cli = await getFetchingCliVersion();
+        providerSchema.cli_name = cli.name;
+        providerSchema.cli_version = cli.version;
+    }
+    catch (error) {
+        commons_1.logger.debug(`Could not determine fetching CLI version to stamp provider schema: ${error}`);
+    }
     return sanitizeProviderSchema(providerSchema);
 }
 exports.readProviderSchema = readProviderSchema;
+/**
+ * Warns when the CLI that produced a given provider schema predates one or
+ * more schema-emission boundaries the project's declared `targetVersions`
+ * care about (see emission-check.ts) - i.e. some newer-protocol sections
+ * (functions, ephemeral resources, ...) may be missing from the generated
+ * bindings even though the schema fetch itself succeeded.
+ *
+ * Deliberately decoupled from the fetch path (readProviderSchema) so it
+ * also runs for schemas served from the on-disk cache: cached JSON carries
+ * the same `cli_name`/`cli_version` stamps a fresh fetch would have
+ * written (the cache key already segments by CLI product+minor), so the gap
+ * check is just as meaningful on a cache hit as on a miss.
+ *
+ * No-op without `targetVersions` - there is nothing to compare the CLI
+ * against. Falls back to the current process's fetching CLI version when
+ * the schema itself isn't stamped (e.g. older cache entries written before
+ * stamping existed).
+ *
+ * @internal exposed for testing
+ */
+async function warnIfSchemaEmissionGaps(schema, targetVersions) {
+    if (!targetVersions)
+        return;
+    let cli;
+    if (schema.cli_name && schema.cli_version) {
+        if (schema.cli_name !== "terraform" && schema.cli_name !== "opentofu") {
+            return;
+        }
+        cli = { name: schema.cli_name, version: schema.cli_version };
+    }
+    else {
+        try {
+            cli = await getFetchingCliVersion();
+        }
+        catch (error) {
+            commons_1.logger.debug(`Could not determine fetching CLI version to check for schema emission gaps: ${error}`);
+            return;
+        }
+    }
+    const gapFamilies = (0, emission_check_1.checkSchemaEmissionGapFamilies)(cli, targetVersions);
+    if (gapFamilies.length > 0 && cli.version) {
+        commons_1.logger.warn(`provider schema fetched with ${cli.name} ${cli.version} — ${joinWithAnd(gapFamilies.map((family) => emission_check_1.SCHEMA_EMISSION_FAMILY_LABELS[family]))} will not be generated; run cdktn get with ${(0, emission_check_1.suggestedEmittingCliVersions)(gapFamilies)}`);
+    }
+}
+exports.warnIfSchemaEmissionGaps = warnIfSchemaEmissionGaps;
 // The providers have some potential bugs that we want to pro-actively
 // fix here so that the rest of the code can assume a consistent schema.
 function sanitizeProviderSchema(schema) {
@@ -237,6 +319,7 @@ function sanitizeProviderSchema(schema) {
             provider.provider,
             ...Object.values(provider.resource_schemas || {}),
             ...Object.values(provider.data_source_schemas || {}),
+            ...Object.values(provider.ephemeral_resource_schemas || {}),
         ];
         entities.forEach((entity) => {
             sanitizeBlock(entity.block);
@@ -275,4 +358,4 @@ async function readModuleSchema(target) {
     return moduleSchema;
 }
 exports.readModuleSchema = readModuleSchema;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-schema.js","sourceRoot":"","sources":["../src/provider-schema.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs-extra\";\nimport * as path from \"path\";\n\nimport { convertFiles } from \"@cdktn/hcl2json\";\nimport {\n  Attribute,\n  AttributeType,\n  Block,\n  ConstructsMakerModuleTarget,\n  ConstructsMakerProviderTarget,\n  Input,\n  ModuleIndex,\n  ModuleSchema,\n  ProviderSchema,\n  TerraformModuleConstraint,\n  VersionSchema,\n  exec,\n  isNestedTypeAttribute,\n  withTempDir,\n} from \"@cdktn/commons\";\n\nconst terraformBinaryName = process.env.TERRAFORM_BINARY_NAME || \"terraform\";\n\n// Provider binaries are downloaded from GitHub release CDNs during\n// `terraform init`, which intermittently returns 5xx. Retry on those\n// signatures only — real config/schema errors should still fail fast.\nconst TRANSIENT_INIT_ERROR_PATTERNS = [\n  /\\b50[234]\\b/,\n  /Bad Gateway/i,\n  /Service Unavailable/i,\n  /Gateway Timeout/i,\n  /ECONNRESET/i,\n  /ETIMEDOUT/i,\n  /EAI_AGAIN/i,\n  /unexpected EOF/i,\n];\n\n/**\n * Runs `terraform init` and retries on transient HTTP/network failures.\n *\n * Provider binaries are pulled from GitHub's release CDN, which\n * intermittently returns 5xx. The retry only fires when stderr matches a\n * known transient pattern — real errors (bad version, schema parse, etc.)\n * still fail on the first attempt.\n *\n * @param options - spawn options forwarded to `exec` (`cwd` is required so\n *   `terraform init` runs inside the temp dir holding `main.tf.json`)\n * @param maxAttempts - total attempts including the initial call; the number\n *   of retries is `maxAttempts - 1`. Defaults to 5 (1 initial + 4 retries)\n * @param baseDelayMs - delay before the first retry. Tests pass `0` to skip\n *   waits. Defaults to 5000ms\n * @param backoffMultiplier - factor applied to the delay on each subsequent\n *   retry (so retries wait `baseDelayMs * multiplier^(attempt-1)`). Defaults\n *   to 2 (1s → 2s → 4s …)\n * @returns stdout from the successful `terraform init` invocation\n * @internal exposed for testing\n */\nexport async function terraformInitWithRetry(\n  options: { cwd: string },\n  maxAttempts = 5,\n  baseDelayMs = 5000,\n  backoffMultiplier = 2,\n): Promise<string> {\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    try {\n      return await exec(terraformBinaryName, [\"init\"], options);\n    } catch (error: any) {\n      const stderr: string = error?.stderr ?? \"\";\n      const transient = TRANSIENT_INIT_ERROR_PATTERNS.some((p) =>\n        p.test(stderr),\n      );\n      if (!transient || attempt === maxAttempts) {\n        throw error;\n      }\n      const delayMs = baseDelayMs * backoffMultiplier ** (attempt - 1);\n      console.log(\n        `terraform init failed with a transient error, retrying in ${delayMs}ms (attempt ${attempt}/${maxAttempts - 1})`,\n      );\n      await new Promise((resolve) => setTimeout(resolve, delayMs));\n    }\n  }\n  throw new Error(\"unreachable\");\n}\n\n/**\n * Fully Qualified provider name in the format:\n * like e.g. registry.terraform.io/hashicorp/aws\n */\nexport type FQPN = string & { __type: \"FullyQualifiedProviderName\" };\nexport type ProviderHostname = string & { __type: \"ProviderHostname\" };\nexport type ProviderNamespace = string & { __type: \"ProviderNamespace\" };\nexport type ProviderName = string & { __type: \"ProviderName\" };\n\nexport const parseFQPN = (f: FQPN) => {\n  const [hostname, namespace, name] = f.split(\"/\");\n  if (!name) {\n    throw new Error(`can't handle ${f}`);\n  }\n  return { hostname, namespace, name } as {\n    hostname: ProviderHostname;\n    namespace: ProviderNamespace;\n    name: ProviderName;\n  };\n};\n\nconst unwrapIfArray = <T>(item: T | T[]): T =>\n  Array.isArray(item) ? item[0] : item;\n\nconst transformVariables = (variables: any) => {\n  const result: Input[] = [];\n\n  if (!variables) return result;\n\n  for (const name of Object.keys(variables)) {\n    const variable = unwrapIfArray(variables[name]);\n    let variableType: string;\n\n    if (\n      // eslint-disable-next-line no-prototype-builtins\n      variable.hasOwnProperty(\"type\") == false &&\n      // eslint-disable-next-line no-prototype-builtins\n      variable.hasOwnProperty(\"default\") == true\n    ) {\n      switch (typeof variable[\"default\"]) {\n        case \"boolean\":\n          variableType = \"bool\";\n          break;\n        case \"number\":\n          variableType = \"number\";\n          break;\n        default:\n          variableType = \"any\";\n      }\n    } else {\n      const rawVariableType = variable[\"type\"];\n      if (\n        typeof rawVariableType === \"string\" &&\n        rawVariableType.startsWith(\"${\") &&\n        rawVariableType.endsWith(\"}\") &&\n        !rawVariableType.includes(\"\\n\")\n      ) {\n        variableType = rawVariableType.slice(2, -1);\n      } else {\n        variableType = \"any\";\n      }\n    }\n\n    const item: Input = {\n      name,\n      type: variableType,\n      description: variable[\"description\"],\n      // eslint-disable-next-line no-prototype-builtins\n      required: variable.hasOwnProperty(\"default\") == false,\n    };\n\n    if (!item.required) {\n      item[\"default\"] = variable[\"default\"];\n    }\n\n    result.push(item);\n  }\n\n  return result;\n};\n\nconst transformOutputs = (outputs: any) => {\n  const result = [];\n\n  if (outputs) {\n    for (const name of Object.keys(outputs)) {\n      const output = unwrapIfArray(outputs[name]);\n\n      const item: any = {\n        name,\n        description: output[\"description\"],\n      };\n\n      result.push(item);\n    }\n  }\n\n  return result;\n};\n\nconst harvestModuleSchema = async (\n  workingDirectory: string,\n  modules: string[],\n): Promise<Record<string, any>> => {\n  const fileName = path.join(\n    workingDirectory,\n    \".terraform\",\n    \"modules\",\n    \"modules.json\",\n  );\n  const result: Record<string, any> = {};\n\n  if (!fs.existsSync(fileName)) {\n    throw new Error(\n      `Modules were not generated properly - couldn't find ${fileName}`,\n    );\n  }\n\n  const moduleIndex = JSON.parse(\n    fs.readFileSync(fileName, \"utf-8\"),\n  ) as ModuleIndex;\n\n  for (const mod of modules) {\n    const m = moduleIndex.Modules.find((other) => mod === other.Key);\n\n    if (!m) {\n      throw new Error(`Couldn't find ${m}`);\n    }\n\n    const parsed = await convertFiles(path.join(workingDirectory, m.Dir));\n\n    if (!parsed) {\n      throw new Error(\n        `Modules were not generated properly - couldn't parse ${m.Dir}`,\n      );\n    }\n\n    const schema: ModuleSchema = {\n      inputs: transformVariables(parsed.variable),\n      outputs: transformOutputs(parsed.output),\n      name: mod,\n    };\n\n    result[mod] = schema;\n  }\n\n  return result;\n};\n\nexport interface TerraformConfig {\n  provider?: { [name: string]: Record<string, any> };\n  terraform: {\n    required_providers?: {\n      [name: string]: { source?: string; version?: string };\n    };\n  };\n  module?: { [name: string]: { source: string; version?: string } };\n}\n\nexport async function readProviderSchema(\n  target: ConstructsMakerProviderTarget,\n) {\n  const config: TerraformConfig = {\n    provider: {},\n    terraform: {\n      required_providers: {},\n    },\n  };\n\n  config.provider![target.name] = {};\n  config.terraform.required_providers![target.name] = {\n    version: target.version,\n    source: target.source,\n  };\n\n  let providerSchema: ProviderSchema = { format_version: \"0.1\" };\n\n  await withTempDir(\"fetchProviderSchema\", async () => {\n    const outdir = process.cwd();\n    const filePath = path.join(outdir, \"main.tf.json\");\n    await fs.writeFile(filePath, JSON.stringify(config));\n\n    await terraformInitWithRetry({ cwd: outdir });\n    providerSchema = JSON.parse(\n      await exec(terraformBinaryName, [\"providers\", \"schema\", \"-json\"], {\n        cwd: outdir,\n      }),\n    ) as ProviderSchema;\n\n    const versionSchema = JSON.parse(\n      await exec(terraformBinaryName, [\"version\", \"-json\"], {\n        cwd: outdir,\n      }),\n    ) as VersionSchema;\n\n    providerSchema.provider_versions = versionSchema.provider_selections;\n  });\n\n  return sanitizeProviderSchema(providerSchema);\n}\n\n// The providers have some potential bugs that we want to pro-actively\n// fix here so that the rest of the code can assume a consistent schema.\nexport function sanitizeProviderSchema(schema: ProviderSchema): ProviderSchema {\n  // Mainly some attributes are \"doubled\", e.g. [\"list\", \"string\", \"list\", \"string\"]\n  // instead of [\"list\", \"string\"]\n  function attributeDoublingFix(attribute: Attribute): Attribute {\n    if (isNestedTypeAttribute(attribute) || !Array.isArray(attribute.type)) {\n      return attribute;\n    }\n\n    const type =\n      attribute.type.length === 2\n        ? attribute.type\n        : (attribute.type as string[]).slice(0, 2); // The types tell us this can't happen, reality begs to differ\n\n    attribute.type = type as AttributeType;\n    return attribute;\n  }\n\n  // Mutates block with the fix\n  function sanitizeBlock(block: Block) {\n    Object.values(block.attributes || {}).forEach(attributeDoublingFix);\n    Object.values(block.block_types || {}).forEach((blockType) => {\n      sanitizeBlock(blockType.block);\n    });\n  }\n\n  Object.values(schema.provider_schemas || {}).forEach((provider) => {\n    const entities = [\n      provider.provider,\n      ...Object.values(provider.resource_schemas || {}),\n      ...Object.values(provider.data_source_schemas || {}),\n    ];\n\n    entities.forEach((entity) => {\n      sanitizeBlock(entity.block);\n    });\n  });\n\n  return schema;\n}\n\nexport async function readModuleSchema(target: ConstructsMakerModuleTarget) {\n  let moduleSchema: Record<string, ModuleSchema> = {};\n\n  await withTempDir(\"fetchSchema\", async () => {\n    const config: TerraformConfig = {\n      terraform: {},\n    };\n\n    if (!config.module) config.module = {};\n    let source: string = target.source;\n\n    const localSource = (target.constraint as TerraformModuleConstraint)\n      .localSourceAbsolutePath;\n    if (localSource) {\n      // create relative path to module in the user project\n      source = path.relative(process.cwd(), localSource);\n    }\n\n    config.module[target.moduleKey] = { source: source };\n    if (target.version) {\n      config.module[target.moduleKey][\"version\"] = target.version;\n    }\n\n    const outdir = process.cwd();\n    const filePath = path.join(outdir, \"main.tf.json\");\n    await fs.writeFile(filePath, JSON.stringify(config));\n\n    await exec(terraformBinaryName, [\"get\"], { cwd: outdir });\n    if (config.module) {\n      moduleSchema = await harvestModuleSchema(\n        outdir,\n        Object.keys(config.module),\n      );\n    }\n  });\n\n  return moduleSchema;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-schema.js","sourceRoot":"","sources":["../src/provider-schema.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs-extra\";\nimport * as path from \"path\";\n\nimport { convertFiles } from \"@cdktn/hcl2json\";\nimport {\n  Attribute,\n  AttributeType,\n  Block,\n  ConstructsMakerModuleTarget,\n  ConstructsMakerProviderTarget,\n  Input,\n  ModuleIndex,\n  ModuleSchema,\n  ProviderSchema,\n  TerraformCliVersion,\n  TerraformModuleConstraint,\n  TerraformTargetVersions,\n  VersionSchema,\n  exec,\n  isNestedTypeAttribute,\n  logger,\n  parseTerraformCliVersion,\n  withTempDir,\n} from \"@cdktn/commons\";\nimport {\n  SCHEMA_EMISSION_FAMILY_LABELS,\n  checkSchemaEmissionGapFamilies,\n  suggestedEmittingCliVersions,\n} from \"./emission-check\";\n\nconst terraformBinaryName = process.env.TERRAFORM_BINARY_NAME || \"terraform\";\n\nlet fetchingCliVersionPromise: Promise<TerraformCliVersion> | undefined;\n\n/**\n * Determines the version of the fetching CLI (`terraform`/`tofu` binary\n * resolved via `TERRAFORM_BINARY_NAME`) once per process, memoized.\n *\n * Used both to stamp fetched provider schemas (`cli_name`/`cli_version`)\n * and as the cache key suffix in read.ts, since schema emission is fixed\n * per CLI minor version.\n *\n * @internal exposed for testing like terraformInitWithRetry\n */\nexport function getFetchingCliVersion(): Promise<TerraformCliVersion> {\n  if (!fetchingCliVersionPromise) {\n    fetchingCliVersionPromise = exec(terraformBinaryName, [\"version\"], {\n      cwd: process.cwd(),\n    }).then(parseTerraformCliVersion);\n  }\n  return fetchingCliVersionPromise;\n}\n\n// Provider binaries are downloaded from GitHub release CDNs during\n// `terraform init`, which intermittently returns 5xx. Retry on those\n// signatures only — real config/schema errors should still fail fast.\nconst TRANSIENT_INIT_ERROR_PATTERNS = [\n  /\\b50[234]\\b/,\n  /Bad Gateway/i,\n  /Service Unavailable/i,\n  /Gateway Timeout/i,\n  /ECONNRESET/i,\n  /ETIMEDOUT/i,\n  /EAI_AGAIN/i,\n  /unexpected EOF/i,\n];\n\n/**\n * Runs `terraform init` and retries on transient HTTP/network failures.\n *\n * Provider binaries are pulled from GitHub's release CDN, which\n * intermittently returns 5xx. The retry only fires when stderr matches a\n * known transient pattern — real errors (bad version, schema parse, etc.)\n * still fail on the first attempt.\n *\n * @param options - spawn options forwarded to `exec` (`cwd` is required so\n *   `terraform init` runs inside the temp dir holding `main.tf.json`)\n * @param maxAttempts - total attempts including the initial call; the number\n *   of retries is `maxAttempts - 1`. Defaults to 5 (1 initial + 4 retries)\n * @param baseDelayMs - delay before the first retry. Tests pass `0` to skip\n *   waits. Defaults to 5000ms\n * @param backoffMultiplier - factor applied to the delay on each subsequent\n *   retry (so retries wait `baseDelayMs * multiplier^(attempt-1)`). Defaults\n *   to 2 (1s → 2s → 4s …)\n * @returns stdout from the successful `terraform init` invocation\n * @internal exposed for testing\n */\nexport async function terraformInitWithRetry(\n  options: { cwd: string },\n  maxAttempts = 5,\n  baseDelayMs = 5000,\n  backoffMultiplier = 2,\n): Promise<string> {\n  for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n    try {\n      return await exec(terraformBinaryName, [\"init\"], options);\n    } catch (error: any) {\n      const stderr: string = error?.stderr ?? \"\";\n      const transient = TRANSIENT_INIT_ERROR_PATTERNS.some((p) =>\n        p.test(stderr),\n      );\n      if (!transient || attempt === maxAttempts) {\n        throw error;\n      }\n      const delayMs = baseDelayMs * backoffMultiplier ** (attempt - 1);\n      console.log(\n        `terraform init failed with a transient error, retrying in ${delayMs}ms (attempt ${attempt}/${maxAttempts - 1})`,\n      );\n      await new Promise((resolve) => setTimeout(resolve, delayMs));\n    }\n  }\n  throw new Error(\"unreachable\");\n}\n\n/**\n * Fully Qualified provider name in the format:\n * like e.g. registry.terraform.io/hashicorp/aws\n */\nexport type FQPN = string & { __type: \"FullyQualifiedProviderName\" };\nexport type ProviderHostname = string & { __type: \"ProviderHostname\" };\nexport type ProviderNamespace = string & { __type: \"ProviderNamespace\" };\nexport type ProviderName = string & { __type: \"ProviderName\" };\n\nexport const parseFQPN = (f: FQPN) => {\n  const [hostname, namespace, name] = f.split(\"/\");\n  if (!name) {\n    throw new Error(`can't handle ${f}`);\n  }\n  return { hostname, namespace, name } as {\n    hostname: ProviderHostname;\n    namespace: ProviderNamespace;\n    name: ProviderName;\n  };\n};\n\nconst unwrapIfArray = <T>(item: T | T[]): T =>\n  Array.isArray(item) ? item[0] : item;\n\nconst transformVariables = (variables: any) => {\n  const result: Input[] = [];\n\n  if (!variables) return result;\n\n  for (const name of Object.keys(variables)) {\n    const variable = unwrapIfArray(variables[name]);\n    let variableType: string;\n\n    if (\n      // eslint-disable-next-line no-prototype-builtins\n      variable.hasOwnProperty(\"type\") == false &&\n      // eslint-disable-next-line no-prototype-builtins\n      variable.hasOwnProperty(\"default\") == true\n    ) {\n      switch (typeof variable[\"default\"]) {\n        case \"boolean\":\n          variableType = \"bool\";\n          break;\n        case \"number\":\n          variableType = \"number\";\n          break;\n        default:\n          variableType = \"any\";\n      }\n    } else {\n      const rawVariableType = variable[\"type\"];\n      if (\n        typeof rawVariableType === \"string\" &&\n        rawVariableType.startsWith(\"${\") &&\n        rawVariableType.endsWith(\"}\") &&\n        !rawVariableType.includes(\"\\n\")\n      ) {\n        variableType = rawVariableType.slice(2, -1);\n      } else {\n        variableType = \"any\";\n      }\n    }\n\n    const item: Input = {\n      name,\n      type: variableType,\n      description: variable[\"description\"],\n      // eslint-disable-next-line no-prototype-builtins\n      required: variable.hasOwnProperty(\"default\") == false,\n    };\n\n    if (!item.required) {\n      item[\"default\"] = variable[\"default\"];\n    }\n\n    result.push(item);\n  }\n\n  return result;\n};\n\nconst transformOutputs = (outputs: any) => {\n  const result = [];\n\n  if (outputs) {\n    for (const name of Object.keys(outputs)) {\n      const output = unwrapIfArray(outputs[name]);\n\n      const item: any = {\n        name,\n        description: output[\"description\"],\n      };\n\n      result.push(item);\n    }\n  }\n\n  return result;\n};\n\nconst harvestModuleSchema = async (\n  workingDirectory: string,\n  modules: string[],\n): Promise<Record<string, any>> => {\n  const fileName = path.join(\n    workingDirectory,\n    \".terraform\",\n    \"modules\",\n    \"modules.json\",\n  );\n  const result: Record<string, any> = {};\n\n  if (!fs.existsSync(fileName)) {\n    throw new Error(\n      `Modules were not generated properly - couldn't find ${fileName}`,\n    );\n  }\n\n  const moduleIndex = JSON.parse(\n    fs.readFileSync(fileName, \"utf-8\"),\n  ) as ModuleIndex;\n\n  for (const mod of modules) {\n    const m = moduleIndex.Modules.find((other) => mod === other.Key);\n\n    if (!m) {\n      throw new Error(`Couldn't find ${m}`);\n    }\n\n    const parsed = await convertFiles(path.join(workingDirectory, m.Dir));\n\n    if (!parsed) {\n      throw new Error(\n        `Modules were not generated properly - couldn't parse ${m.Dir}`,\n      );\n    }\n\n    const schema: ModuleSchema = {\n      inputs: transformVariables(parsed.variable),\n      outputs: transformOutputs(parsed.output),\n      name: mod,\n    };\n\n    result[mod] = schema;\n  }\n\n  return result;\n};\n\nfunction joinWithAnd(items: string[]): string {\n  if (items.length <= 1) return items.join(\"\");\n  return `${items.slice(0, -1).join(\", \")} and ${items[items.length - 1]}`;\n}\n\nexport interface TerraformConfig {\n  provider?: { [name: string]: Record<string, any> };\n  terraform: {\n    required_providers?: {\n      [name: string]: { source?: string; version?: string };\n    };\n  };\n  module?: { [name: string]: { source: string; version?: string } };\n}\n\nexport async function readProviderSchema(\n  target: ConstructsMakerProviderTarget,\n) {\n  const config: TerraformConfig = {\n    provider: {},\n    terraform: {\n      required_providers: {},\n    },\n  };\n\n  config.provider![target.name] = {};\n  config.terraform.required_providers![target.name] = {\n    version: target.version,\n    source: target.source,\n  };\n\n  let providerSchema: ProviderSchema = { format_version: \"0.1\" };\n\n  await withTempDir(\"fetchProviderSchema\", async () => {\n    const outdir = process.cwd();\n    const filePath = path.join(outdir, \"main.tf.json\");\n    await fs.writeFile(filePath, JSON.stringify(config));\n\n    await terraformInitWithRetry({ cwd: outdir });\n    providerSchema = JSON.parse(\n      await exec(terraformBinaryName, [\"providers\", \"schema\", \"-json\"], {\n        cwd: outdir,\n      }),\n    ) as ProviderSchema;\n\n    const versionSchema = JSON.parse(\n      await exec(terraformBinaryName, [\"version\", \"-json\"], {\n        cwd: outdir,\n      }),\n    ) as VersionSchema;\n\n    providerSchema.provider_versions = versionSchema.provider_selections;\n  });\n\n  // Stamp the fetching CLI's identity so downstream consumers can reason\n  // about which newer-protocol sections this fetch could possibly have\n  // emitted. Never fail the fetch over this - it's best-effort metadata.\n  try {\n    const cli = await getFetchingCliVersion();\n    providerSchema.cli_name = cli.name;\n    providerSchema.cli_version = cli.version;\n  } catch (error) {\n    logger.debug(\n      `Could not determine fetching CLI version to stamp provider schema: ${error}`,\n    );\n  }\n\n  return sanitizeProviderSchema(providerSchema);\n}\n\n/**\n * Warns when the CLI that produced a given provider schema predates one or\n * more schema-emission boundaries the project's declared `targetVersions`\n * care about (see emission-check.ts) - i.e. some newer-protocol sections\n * (functions, ephemeral resources, ...) may be missing from the generated\n * bindings even though the schema fetch itself succeeded.\n *\n * Deliberately decoupled from the fetch path (readProviderSchema) so it\n * also runs for schemas served from the on-disk cache: cached JSON carries\n * the same `cli_name`/`cli_version` stamps a fresh fetch would have\n * written (the cache key already segments by CLI product+minor), so the gap\n * check is just as meaningful on a cache hit as on a miss.\n *\n * No-op without `targetVersions` - there is nothing to compare the CLI\n * against. Falls back to the current process's fetching CLI version when\n * the schema itself isn't stamped (e.g. older cache entries written before\n * stamping existed).\n *\n * @internal exposed for testing\n */\nexport async function warnIfSchemaEmissionGaps(\n  schema: ProviderSchema,\n  targetVersions?: TerraformTargetVersions,\n): Promise<void> {\n  if (!targetVersions) return;\n\n  let cli: TerraformCliVersion;\n  if (schema.cli_name && schema.cli_version) {\n    if (schema.cli_name !== \"terraform\" && schema.cli_name !== \"opentofu\") {\n      return;\n    }\n    cli = { name: schema.cli_name, version: schema.cli_version };\n  } else {\n    try {\n      cli = await getFetchingCliVersion();\n    } catch (error) {\n      logger.debug(\n        `Could not determine fetching CLI version to check for schema emission gaps: ${error}`,\n      );\n      return;\n    }\n  }\n\n  const gapFamilies = checkSchemaEmissionGapFamilies(cli, targetVersions);\n  if (gapFamilies.length > 0 && cli.version) {\n    logger.warn(\n      `provider schema fetched with ${cli.name} ${cli.version} — ${joinWithAnd(\n        gapFamilies.map((family) => SCHEMA_EMISSION_FAMILY_LABELS[family]),\n      )} will not be generated; run cdktn get with ${suggestedEmittingCliVersions(\n        gapFamilies,\n      )}`,\n    );\n  }\n}\n\n// The providers have some potential bugs that we want to pro-actively\n// fix here so that the rest of the code can assume a consistent schema.\nexport function sanitizeProviderSchema(schema: ProviderSchema): ProviderSchema {\n  // Mainly some attributes are \"doubled\", e.g. [\"list\", \"string\", \"list\", \"string\"]\n  // instead of [\"list\", \"string\"]\n  function attributeDoublingFix(attribute: Attribute): Attribute {\n    if (isNestedTypeAttribute(attribute) || !Array.isArray(attribute.type)) {\n      return attribute;\n    }\n\n    const type =\n      attribute.type.length === 2\n        ? attribute.type\n        : (attribute.type as string[]).slice(0, 2); // The types tell us this can't happen, reality begs to differ\n\n    attribute.type = type as AttributeType;\n    return attribute;\n  }\n\n  // Mutates block with the fix\n  function sanitizeBlock(block: Block) {\n    Object.values(block.attributes || {}).forEach(attributeDoublingFix);\n    Object.values(block.block_types || {}).forEach((blockType) => {\n      sanitizeBlock(blockType.block);\n    });\n  }\n\n  Object.values(schema.provider_schemas || {}).forEach((provider) => {\n    const entities = [\n      provider.provider,\n      ...Object.values(provider.resource_schemas || {}),\n      ...Object.values(provider.data_source_schemas || {}),\n      ...Object.values(provider.ephemeral_resource_schemas || {}),\n    ];\n\n    entities.forEach((entity) => {\n      sanitizeBlock(entity.block);\n    });\n  });\n\n  return schema;\n}\n\nexport async function readModuleSchema(target: ConstructsMakerModuleTarget) {\n  let moduleSchema: Record<string, ModuleSchema> = {};\n\n  await withTempDir(\"fetchSchema\", async () => {\n    const config: TerraformConfig = {\n      terraform: {},\n    };\n\n    if (!config.module) config.module = {};\n    let source: string = target.source;\n\n    const localSource = (target.constraint as TerraformModuleConstraint)\n      .localSourceAbsolutePath;\n    if (localSource) {\n      // create relative path to module in the user project\n      source = path.relative(process.cwd(), localSource);\n    }\n\n    config.module[target.moduleKey] = { source: source };\n    if (target.version) {\n      config.module[target.moduleKey][\"version\"] = target.version;\n    }\n\n    const outdir = process.cwd();\n    const filePath = path.join(outdir, \"main.tf.json\");\n    await fs.writeFile(filePath, JSON.stringify(config));\n\n    await exec(terraformBinaryName, [\"get\"], { cwd: outdir });\n    if (config.module) {\n      moduleSchema = await harvestModuleSchema(\n        outdir,\n        Object.keys(config.module),\n      );\n    }\n  });\n\n  return moduleSchema;\n}\n"]}

package/build/read.d.ts

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: MPL-2.0
  */
 export { isRegistryModule, TerraformModuleConstraint, TerraformProviderConstraint, isLocalModule, } from "@cdktn/commons";
-import { TerraformDependencyConstraint } from "@cdktn/commons";
+import { TerraformDependencyConstraint, TerraformTargetVersions } from "@cdktn/commons";
 import { readModuleSchema, readProviderSchema } from "./provider-schema";
 export type Schema = {
     providerSchema?: Awaited<ReturnType<typeof readProviderSchema>>;
     moduleSchema?: Awaited<ReturnType<typeof readModuleSchema>>;
 };
-export declare function readSchema(constraints: TerraformDependencyConstraint[], cacheDir?: string): Promise<Schema>;
+export declare function readSchema(constraints: TerraformDependencyConstraint[], cacheDir?: string, targetVersions?: TerraformTargetVersions): Promise<Schema>;
 //# sourceMappingURL=read.d.ts.map

package/build/read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../src/read.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,2BAA2B,EAC3B,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,6BAA6B,EAK9B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAGzE,MAAM,MAAM,MAAM,GAAG;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC;IAChE,YAAY,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC;CAC7D,CAAC;AAEF,wBAAsB,UAAU,CAC9B,WAAW,EAAE,6BAA6B,EAAE,EAC5C,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,CAAC,CA6BjB"}
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../src/read.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,2BAA2B,EAC3B,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,6BAA6B,EAI7B,uBAAuB,EAGxB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAEL,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,mBAAmB,CAAC;AAG3B,MAAM,MAAM,MAAM,GAAG;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC;IAChE,YAAY,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC;CAC7D,CAAC;AA4BF,wBAAsB,UAAU,CAC9B,WAAW,EAAE,6BAA6B,EAAE,EAC5C,QAAQ,CAAC,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,uBAAuB,GACvC,OAAO,CAAC,MAAM,CAAC,CAuCjB"}

package/build/read.js

@@ -17,13 +17,40 @@ const commons_2 = require("@cdktn/commons");
 const deepmerge_1 = __importDefault(require("deepmerge"));
 const provider_schema_1 = require("./provider-schema");
 const cache_1 = require("./cache");
-async function readSchema(constraints, cacheDir) {
-    const cachedReadProviderSchema = (0, cache_1.cachedAccess)(provider_schema_1.readProviderSchema, cacheDir);
+// Schema emission is fixed per CLI product+minor version, so that's enough
+// granularity for the cache key - no need for the full patch version.
+async function resolveCacheKeySuffix(cacheDir) {
+    if (!cacheDir)
+        return undefined;
+    try {
+        const cli = await (0, provider_schema_1.getFetchingCliVersion)();
+        if (cli.name === "unknown" || !cli.version) {
+            commons_2.logger.debug("Could not determine fetching CLI name/version for the schema cache key, falling back to 'unknown-cli'");
+            return "unknown-cli";
+        }
+        const [major, minor] = cli.version.split(".");
+        return `${cli.name}-${major}.${minor}`;
+    }
+    catch (error) {
+        commons_2.logger.debug(`Could not determine fetching CLI version for the schema cache key: ${error}`);
+        return "unknown-cli";
+    }
+}
+async function readSchema(constraints, cacheDir, targetVersions) {
+    const keySuffix = await resolveCacheKeySuffix(cacheDir);
+    const cachedReadProviderSchema = (0, cache_1.cachedAccess)(provider_schema_1.readProviderSchema, cacheDir, keySuffix);
     const targets = constraints.map((constraint) => commons_2.ConstructsMakerProviderTarget.from(constraint, commons_2.LANGUAGES[0]));
     throwIfTargetsConflict(targets);
     const schemas = await Promise.all(targets.map((t) => t.isModule
         ? (0, provider_schema_1.readModuleSchema)(t).then((s) => ({ moduleSchema: s }))
-        : cachedReadProviderSchema(t).then((s) => ({ providerSchema: s }))));
+        : cachedReadProviderSchema(t).then(async (s) => {
+            // Runs on both cache hits and misses: cached schemas carry the
+            // same cli_name/cli_version stamps a fresh fetch would have
+            // written, so the emission-gap warning is just as relevant on
+            // a hit as on a miss.
+            await (0, provider_schema_1.warnIfSchemaEmissionGaps)(s, targetVersions);
+            return { providerSchema: s };
+        })));
     // ensure we have a schema for each target type
     schemas.unshift({
         providerSchema: {
@@ -44,4 +71,4 @@ function throwIfTargetsConflict(targets) {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9yZWFkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7O0dBR0c7Ozs7OztBQUVILDBDQUt3QjtBQUp0QiwyR0FBQSxnQkFBZ0IsT0FBQTtBQUNoQixvSEFBQSx5QkFBeUIsT0FBQTtBQUN6QixzSEFBQSwyQkFBMkIsT0FBQTtBQUMzQix3R0FBQSxhQUFhLE9BQUE7QUFFZiw0Q0FNd0I7QUFDeEIsMERBQWtDO0FBQ2xDLHVEQUF5RTtBQUN6RSxtQ0FBdUM7QUFPaEMsS0FBSyxVQUFVLFVBQVUsQ0FDOUIsV0FBNEMsRUFDNUMsUUFBaUI7SUFFakIsTUFBTSx3QkFBd0IsR0FBRyxJQUFBLG9CQUFZLEVBQUMsb0NBQWtCLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDNUUsTUFBTSxPQUFPLEdBQUcsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQzdDLHVDQUE2QixDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsbUJBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUM3RCxDQUFDO0lBRUYsc0JBQXNCLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFaEMsTUFBTSxPQUFPLEdBQUcsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUMvQixPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FDaEIsQ0FBQyxDQUFDLFFBQVE7UUFDUixDQUFDLENBQUMsSUFBQSxrQ0FBZ0IsRUFBQyxDQUFRLENBQUMsQ0FBQyxJQUFJLENBQzdCLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBQUUsWUFBWSxFQUFFLENBQUMsRUFBRSxDQUFXLENBQ3ZDO1FBQ0gsQ0FBQyxDQUFDLHdCQUF3QixDQUFDLENBQVEsQ0FBQyxDQUFDLElBQUksQ0FDckMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxjQUFjLEVBQUUsQ0FBQyxFQUFFLENBQVcsQ0FDekMsQ0FDTixDQUNGLENBQUM7SUFFRiwrQ0FBK0M7SUFDL0MsT0FBTyxDQUFDLE9BQU8sQ0FBQztRQUNkLGNBQWMsRUFBRTtZQUNkLGNBQWMsRUFBRSxLQUFLO1NBQ3RCO1FBQ0QsWUFBWSxFQUFFLEVBQUU7S0FDakIsQ0FBQyxDQUFDO0lBRUgsT0FBTyxtQkFBUyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztBQUNoQyxDQUFDO0FBaENELGdDQWdDQztBQUVELFNBQVMsc0JBQXNCLENBQzdCLE9BQXdFO0lBRXhFLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQzVCLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUNlLENBQUM7SUFFbkMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFO1FBQzFCLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQyxPQUFPLEVBQUUsRUFBRTtZQUMxQixJQUFJLE9BQU8sS0FBSyxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksS0FBSyxPQUFPLENBQUMsSUFBSSxFQUFFLENBQUM7Z0JBQ3pELE1BQU0sZ0JBQU0sQ0FBQyxLQUFLLENBQ2hCLHlDQUF5QyxPQUFPLENBQUMsSUFBSSw0TUFBNE0sQ0FDbFEsQ0FBQztZQUNKLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IChjKSBIYXNoaUNvcnAsIEluYy5cbiAqIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNUEwtMi4wXG4gKi9cblxuZXhwb3J0IHtcbiAgaXNSZWdpc3RyeU1vZHVsZSxcbiAgVGVycmFmb3JtTW9kdWxlQ29uc3RyYWludCxcbiAgVGVycmFmb3JtUHJvdmlkZXJDb25zdHJhaW50LFxuICBpc0xvY2FsTW9kdWxlLFxufSBmcm9tIFwiQGNka3RuL2NvbW1vbnNcIjtcbmltcG9ydCB7XG4gIFRlcnJhZm9ybURlcGVuZGVuY3lDb25zdHJhaW50LFxuICBMQU5HVUFHRVMsXG4gIENvbnN0cnVjdHNNYWtlclByb3ZpZGVyVGFyZ2V0LFxuICBDb25zdHJ1Y3RzTWFrZXJNb2R1bGVUYXJnZXQsXG4gIEVycm9ycyxcbn0gZnJvbSBcIkBjZGt0bi9jb21tb25zXCI7XG5pbXBvcnQgZGVlcG1lcmdlIGZyb20gXCJkZWVwbWVyZ2VcIjtcbmltcG9ydCB7IHJlYWRNb2R1bGVTY2hlbWEsIHJlYWRQcm92aWRlclNjaGVtYSB9IGZyb20gXCIuL3Byb3ZpZGVyLXNjaGVtYVwiO1xuaW1wb3J0IHsgY2FjaGVkQWNjZXNzIH0gZnJvbSBcIi4vY2FjaGVcIjtcblxuZXhwb3J0IHR5cGUgU2NoZW1hID0ge1xuICBwcm92aWRlclNjaGVtYT86IEF3YWl0ZWQ8UmV0dXJuVHlwZTx0eXBlb2YgcmVhZFByb3ZpZGVyU2NoZW1hPj47XG4gIG1vZHVsZVNjaGVtYT86IEF3YWl0ZWQ8UmV0dXJuVHlwZTx0eXBlb2YgcmVhZE1vZHVsZVNjaGVtYT4+O1xufTtcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJlYWRTY2hlbWEoXG4gIGNvbnN0cmFpbnRzOiBUZXJyYWZvcm1EZXBlbmRlbmN5Q29uc3RyYWludFtdLFxuICBjYWNoZURpcj86IHN0cmluZyxcbik6IFByb21pc2U8U2NoZW1hPiB7XG4gIGNvbnN0IGNhY2hlZFJlYWRQcm92aWRlclNjaGVtYSA9IGNhY2hlZEFjY2VzcyhyZWFkUHJvdmlkZXJTY2hlbWEsIGNhY2hlRGlyKTtcbiAgY29uc3QgdGFyZ2V0cyA9IGNvbnN0cmFpbnRzLm1hcCgoY29uc3RyYWludCkgPT5cbiAgICBDb25zdHJ1Y3RzTWFrZXJQcm92aWRlclRhcmdldC5mcm9tKGNvbnN0cmFpbnQsIExBTkdVQUdFU1swXSksXG4gICk7XG5cbiAgdGhyb3dJZlRhcmdldHNDb25mbGljdCh0YXJnZXRzKTtcblxuICBjb25zdCBzY2hlbWFzID0gYXdhaXQgUHJvbWlzZS5hbGwoXG4gICAgdGFyZ2V0cy5tYXAoKHQpID0+XG4gICAgICB0LmlzTW9kdWxlXG4gICAgICAgID8gcmVhZE1vZHVsZVNjaGVtYSh0IGFzIGFueSkudGhlbihcbiAgICAgICAgICAgIChzKSA9PiAoeyBtb2R1bGVTY2hlbWE6IHMgfSkgYXMgU2NoZW1hLFxuICAgICAgICAgIClcbiAgICAgICAgOiBjYWNoZWRSZWFkUHJvdmlkZXJTY2hlbWEodCBhcyBhbnkpLnRoZW4oXG4gICAgICAgICAgICAocykgPT4gKHsgcHJvdmlkZXJTY2hlbWE6IHMgfSkgYXMgU2NoZW1hLFxuICAgICAgICAgICksXG4gICAgKSxcbiAgKTtcblxuICAvLyBlbnN1cmUgd2UgaGF2ZSBhIHNjaGVtYSBmb3IgZWFjaCB0YXJnZXQgdHlwZVxuICBzY2hlbWFzLnVuc2hpZnQoe1xuICAgIHByb3ZpZGVyU2NoZW1hOiB7XG4gICAgICBmb3JtYXRfdmVyc2lvbjogXCIwLjFcIixcbiAgICB9LFxuICAgIG1vZHVsZVNjaGVtYToge30sXG4gIH0pO1xuXG4gIHJldHVybiBkZWVwbWVyZ2UuYWxsKHNjaGVtYXMpO1xufVxuXG5mdW5jdGlvbiB0aHJvd0lmVGFyZ2V0c0NvbmZsaWN0KFxuICB0YXJnZXRzOiAoQ29uc3RydWN0c01ha2VyUHJvdmlkZXJUYXJnZXQgfCBDb25zdHJ1Y3RzTWFrZXJNb2R1bGVUYXJnZXQpW10sXG4pIHtcbiAgY29uc3QgbW9kdWxlcyA9IHRhcmdldHMuZmlsdGVyKFxuICAgICh0KSA9PiB0LmlzTW9kdWxlLFxuICApIGFzIENvbnN0cnVjdHNNYWtlck1vZHVsZVRhcmdldFtdO1xuXG4gIG1vZHVsZXMuZm9yRWFjaCgobW9kdWxlQSkgPT4ge1xuICAgIG1vZHVsZXMuZm9yRWFjaCgobW9kdWxlQikgPT4ge1xuICAgICAgaWYgKG1vZHVsZUEgIT09IG1vZHVsZUIgJiYgbW9kdWxlQS5uYW1lID09PSBtb2R1bGVCLm5hbWUpIHtcbiAgICAgICAgdGhyb3cgRXJyb3JzLlVzYWdlKFxuICAgICAgICAgIGBGb3VuZCB0d28gbW9kdWxlcyB3aXRoIHRoZSBzYW1lIG5hbWUgXCIke21vZHVsZUEubmFtZX1cIiB3aGljaCBpcyBub3Qgc3VwcG9ydGVkLiBQbGVhc2UgcmVuYW1lIG9uZSBvZiB0aGUgbW9kdWxlcyBpbiB5b3VyIGNka3RmLmpzb24gY29uZmlnLiBGb3IgbW9yZSBpbmZvcm1hdGlvbiBvbiBob3cgdG8gc2V0IHRoZSBuYW1lIHJlZmVyIHRvIGh0dHBzOi8vY2RrdG4uaW8vZG9jcy9jb25jZXB0cy9tb2R1bGVzI2FkZC1tb2R1bGUtdG8tY2RrdGYtanNvbmAsXG4gICAgICAgICk7XG4gICAgICB9XG4gICAgfSk7XG4gIH0pO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"read.js","sourceRoot":"","sources":["../src/read.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nexport {\n  isRegistryModule,\n  TerraformModuleConstraint,\n  TerraformProviderConstraint,\n  isLocalModule,\n} from \"@cdktn/commons\";\nimport {\n  TerraformDependencyConstraint,\n  LANGUAGES,\n  ConstructsMakerProviderTarget,\n  ConstructsMakerModuleTarget,\n  TerraformTargetVersions,\n  Errors,\n  logger,\n} from \"@cdktn/commons\";\nimport deepmerge from \"deepmerge\";\nimport {\n  getFetchingCliVersion,\n  readModuleSchema,\n  readProviderSchema,\n  warnIfSchemaEmissionGaps,\n} from \"./provider-schema\";\nimport { cachedAccess } from \"./cache\";\n\nexport type Schema = {\n  providerSchema?: Awaited<ReturnType<typeof readProviderSchema>>;\n  moduleSchema?: Awaited<ReturnType<typeof readModuleSchema>>;\n};\n\n// Schema emission is fixed per CLI product+minor version, so that's enough\n// granularity for the cache key - no need for the full patch version.\nasync function resolveCacheKeySuffix(\n  cacheDir?: string,\n): Promise<string | undefined> {\n  if (!cacheDir) return undefined;\n\n  try {\n    const cli = await getFetchingCliVersion();\n    if (cli.name === \"unknown\" || !cli.version) {\n      logger.debug(\n        \"Could not determine fetching CLI name/version for the schema cache key, falling back to 'unknown-cli'\",\n      );\n      return \"unknown-cli\";\n    }\n\n    const [major, minor] = cli.version.split(\".\");\n    return `${cli.name}-${major}.${minor}`;\n  } catch (error) {\n    logger.debug(\n      `Could not determine fetching CLI version for the schema cache key: ${error}`,\n    );\n    return \"unknown-cli\";\n  }\n}\n\nexport async function readSchema(\n  constraints: TerraformDependencyConstraint[],\n  cacheDir?: string,\n  targetVersions?: TerraformTargetVersions,\n): Promise<Schema> {\n  const keySuffix = await resolveCacheKeySuffix(cacheDir);\n  const cachedReadProviderSchema = cachedAccess(\n    readProviderSchema,\n    cacheDir,\n    keySuffix,\n  );\n  const targets = constraints.map((constraint) =>\n    ConstructsMakerProviderTarget.from(constraint, LANGUAGES[0]),\n  );\n\n  throwIfTargetsConflict(targets);\n\n  const schemas = await Promise.all(\n    targets.map((t) =>\n      t.isModule\n        ? readModuleSchema(t as any).then(\n            (s) => ({ moduleSchema: s }) as Schema,\n          )\n        : cachedReadProviderSchema(t as any).then(async (s) => {\n            // Runs on both cache hits and misses: cached schemas carry the\n            // same cli_name/cli_version stamps a fresh fetch would have\n            // written, so the emission-gap warning is just as relevant on\n            // a hit as on a miss.\n            await warnIfSchemaEmissionGaps(s, targetVersions);\n            return { providerSchema: s } as Schema;\n          }),\n    ),\n  );\n\n  // ensure we have a schema for each target type\n  schemas.unshift({\n    providerSchema: {\n      format_version: \"0.1\",\n    },\n    moduleSchema: {},\n  });\n\n  return deepmerge.all(schemas);\n}\n\nfunction throwIfTargetsConflict(\n  targets: (ConstructsMakerProviderTarget | ConstructsMakerModuleTarget)[],\n) {\n  const modules = targets.filter(\n    (t) => t.isModule,\n  ) as ConstructsMakerModuleTarget[];\n\n  modules.forEach((moduleA) => {\n    modules.forEach((moduleB) => {\n      if (moduleA !== moduleB && moduleA.name === moduleB.name) {\n        throw Errors.Usage(\n          `Found two modules with the same name \"${moduleA.name}\" which is not supported. Please rename one of the modules in your cdktf.json config. For more information on how to set the name refer to https://cdktn.io/docs/concepts/modules#add-module-to-cdktf-json`,\n        );\n      }\n    });\n  });\n}\n"]}