@cdktn/hcl2cdk 0.21.0

package/lib/iteration.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceStats = exports.forEachNamespaced = exports.forEachProvider = exports.forEachImport = exports.forEachGlobal = void 0;
+const telemetryAllowList_json_1 = require("./telemetryAllowList.json");
+// locals, variables, and outputs are global key value maps
+function forEachGlobal(scope, prefix, record, iterator) {
+    return Object.entries(record || {}).reduce((carry, [key, item]) => {
+        const id = `${prefix}.${key}`;
+        return {
+            ...carry,
+            [id]: {
+                code: async (graph) => await iterator(scope, key, id, item, graph),
+                value: item,
+            },
+        };
+    }, {});
+}
+exports.forEachGlobal = forEachGlobal;
+function forEachImport(scope, prefix, record, iterator) {
+    return (record || []).reduce((carry, item) => {
+        const target = item.to.startsWith("${") && item.to.endsWith("}")
+            ? item.to.substring(2, item.to.length - 1)
+            : item.to;
+        const id = `${prefix}.${target}`;
+        return {
+            ...carry,
+            [id]: {
+                code: async (graph) => await iterator(scope, id, item, graph),
+                value: item,
+            },
+        };
+    }, {});
+}
+exports.forEachImport = forEachImport;
+function forEachProvider(scope, record, iterator) {
+    return Object.entries(record || {}).reduce((carry, [key, items]) => {
+        return {
+            ...carry,
+            ...items.reduce((innerCarry, item) => {
+                const id = item.alias ? `${key}.${item.alias}` : `${key}`;
+                return {
+                    ...innerCarry,
+                    [id]: {
+                        code: async (graph) => await iterator(scope, key, id, item, graph),
+                        value: item,
+                    },
+                };
+            }, {}),
+        };
+    }, {});
+}
+exports.forEachProvider = forEachProvider;
+// data and resource are namespaced key value maps
+function forEachNamespaced(scope, record, iterator, prefix) {
+    return Object.entries(record || {}).reduce((outerCarry, [type, items]) => ({
+        ...outerCarry,
+        ...Object.entries(items).reduce((innerCarry, [key, item]) => {
+            const prefixedType = prefix ? `${prefix}.${type}` : type;
+            const id = prefix ? `${prefix}.${type}.${key}` : `${type}.${key}`;
+            return {
+                ...innerCarry,
+                [id]: {
+                    code: async (graph) => await iterator(scope, prefixedType, key, id, item, graph),
+                    value: item,
+                },
+            };
+        }, {}),
+    }), {});
+}
+exports.forEachNamespaced = forEachNamespaced;
+function resourceStats(obj) {
+    return Object.entries(obj).reduce((carry, [key, value]) => {
+        const [provider, ...resourceParts] = key.split("_");
+        const shouldBeTracked = telemetryAllowList_json_1.providers.includes(provider);
+        const providerKey = shouldBeTracked ? provider : "other";
+        const resourceName = shouldBeTracked ? resourceParts.join("_") : "other";
+        return {
+            ...carry,
+            [providerKey]: {
+                ...(carry[providerKey] || {}),
+                [resourceName]: Object.keys(value).length,
+            },
+        };
+    }, {});
+}
+exports.resourceStats = resourceStats;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iteration.js","sourceRoot":"","sources":["iteration.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { DirectedGraph } from \"graphology\";\nimport { providers as telemetryAllowedProviders } from \"./telemetryAllowList.json\";\nimport { ProgramScope } from \"./types\";\nimport { Import } from \"./schema\";\n\n// locals, variables, and outputs are global key value maps\nexport function forEachGlobal<T, R>(\n  scope: ProgramScope,\n  prefix: string,\n  record: Record<string, T> | undefined,\n  iterator: (\n    scope: ProgramScope,\n    key: string,\n    id: string,\n    value: T,\n    graph: DirectedGraph,\n  ) => Promise<R>,\n): Record<string, { code: (graph: DirectedGraph) => Promise<R>; value: T }> {\n  return Object.entries(record || {}).reduce((carry, [key, item]) => {\n    const id = `${prefix}.${key}`;\n    return {\n      ...carry,\n      [id]: {\n        code: async (graph: DirectedGraph) =>\n          await iterator(scope, key, id, item, graph),\n        value: item,\n      },\n    };\n  }, {});\n}\n\nexport function forEachImport<R>(\n  scope: ProgramScope,\n  prefix: string,\n  record: Import[] | undefined,\n  iterator: (\n    scope: ProgramScope,\n    id: string,\n    value: Import,\n    graph: DirectedGraph,\n  ) => Promise<R>,\n): Record<\n  string,\n  { code: (graph: DirectedGraph) => Promise<R>; value: Import }\n> {\n  return (record || []).reduce((carry, item) => {\n    const target =\n      item.to.startsWith(\"${\") && item.to.endsWith(\"}\")\n        ? item.to.substring(2, item.to.length - 1)\n        : item.to;\n\n    const id = `${prefix}.${target}`;\n    return {\n      ...carry,\n      [id]: {\n        code: async (graph: DirectedGraph) =>\n          await iterator(scope, id, item, graph),\n        value: item,\n      },\n    };\n  }, {});\n}\n\nexport function forEachProvider<T extends { alias?: string }, R>(\n  scope: ProgramScope,\n  record: Record<string, T[]> | undefined,\n  iterator: (\n    scope: ProgramScope,\n    key: string,\n    id: string,\n    value: T,\n    graph: DirectedGraph,\n  ) => Promise<R>,\n): Record<string, { code: (graph: DirectedGraph) => Promise<R>; value: T }> {\n  return Object.entries(record || {}).reduce((carry, [key, items]) => {\n    return {\n      ...carry,\n      ...items.reduce((innerCarry, item: T) => {\n        const id = item.alias ? `${key}.${item.alias}` : `${key}`;\n        return {\n          ...innerCarry,\n          [id]: {\n            code: async (graph: DirectedGraph) =>\n              await iterator(scope, key, id, item, graph),\n            value: item,\n          },\n        };\n      }, {}),\n    };\n  }, {});\n}\n\n// data and resource are namespaced key value maps\nexport function forEachNamespaced<T, R>(\n  scope: ProgramScope,\n  record: Record<string, Record<string, T>> | undefined,\n  iterator: (\n    scope: ProgramScope,\n    type: string,\n    key: string,\n    id: string,\n    value: T,\n    graph: DirectedGraph,\n  ) => Promise<R>,\n  prefix?: string,\n): Record<string, { code: (graph: DirectedGraph) => Promise<R>; value: T }> {\n  return Object.entries(record || {}).reduce(\n    (outerCarry, [type, items]) => ({\n      ...outerCarry,\n      ...Object.entries(items).reduce(\n        (innerCarry, [key, item]) => {\n          const prefixedType = prefix ? `${prefix}.${type}` : type;\n          const id = prefix ? `${prefix}.${type}.${key}` : `${type}.${key}`;\n          return {\n            ...innerCarry,\n            [id]: {\n              code: async (graph: DirectedGraph) =>\n                await iterator(scope, prefixedType, key, id, item, graph),\n              value: item,\n            },\n          };\n        },\n        {} as Record<\n          string,\n          { code: (graph: DirectedGraph) => Promise<R>; value: T }\n        >,\n      ),\n    }),\n    {} as Record<\n      string,\n      { code: (graph: DirectedGraph) => Promise<R>; value: T }\n    >,\n  );\n}\n\nexport function resourceStats(obj: Record<string, Record<string, unknown>>) {\n  return Object.entries(obj).reduce(\n    (carry, [key, value]) => {\n      const [provider, ...resourceParts] = key.split(\"_\");\n      const shouldBeTracked = telemetryAllowedProviders.includes(provider);\n      const providerKey = shouldBeTracked ? provider : \"other\";\n      const resourceName = shouldBeTracked ? resourceParts.join(\"_\") : \"other\";\n\n      return {\n        ...carry,\n        [providerKey]: {\n          ...(carry[providerKey] || {}),\n          [resourceName]: Object.keys(value).length,\n        },\n      };\n    },\n    {} as Record<string, Record<string, number>>,\n  );\n}\n"]}

package/lib/jsii-rosetta-workarounds.d.ts

@@ -0,0 +1,5 @@
+export declare function replacePythonImports(code: string): string;
+export declare function replaceJavaImports(code: string): string;
+export declare function replaceCsharpImports(code: string): string;
+export declare function replaceGoImports(code: string): string;
+//# sourceMappingURL=jsii-rosetta-workarounds.d.ts.map

package/lib/jsii-rosetta-workarounds.js

@@ -0,0 +1,126 @@
+"use strict";
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceGoImports = exports.replaceCsharpImports = exports.replaceJavaImports = exports.replacePythonImports = void 0;
+function replacePythonImports(code) {
+    return code
+        .split("\n")
+        .map((line) => {
+        // Replace from-import lines with lib
+        const fromImportLibRegex = /from \.\.\.gen\.providers\.([^.]+)(?:\.lib)?\.(.*) import/;
+        if (fromImportLibRegex.test(line)) {
+            return line.replace(fromImportLibRegex, "from imports.$1.$2 import");
+        }
+        // Replace import lines with lib
+        const importLibRegex = /import \.\.\.gen\.providers\.([^.]+)(?:\.lib)?\.(.*) as (.*)/;
+        if (importLibRegex.test(line)) {
+            return line.replace(importLibRegex, "import imports.$1.$2 as $3");
+        }
+        // Replace from-import lines
+        if (line.startsWith("from ...gen.providers.")) {
+            return line.replace("from ...gen.providers.", "from imports.");
+        }
+        // Replace import lines
+        if (line.startsWith("import ...gen.providers.")) {
+            return line.replace("import ...gen.providers.", "import imports.");
+        }
+        // Replace modules
+        if (line.startsWith("import ...gen.modules.")) {
+            return line.replace("import ...gen.modules.", "import imports.");
+        }
+        return line;
+    })
+        .join("\n");
+}
+exports.replacePythonImports = replacePythonImports;
+function replaceJavaImports(code) {
+    return code
+        .split("\n")
+        .map((line) => {
+        // Replace using lines with lib and precices import
+        const importWithLib = /import gen\.providers\.([^.]+)(?:\.lib)?\.([^.]+)\.(.*);/;
+        const matchWithLib = line.match(importWithLib);
+        if (matchWithLib) {
+            const [, provider, resource, className] = matchWithLib;
+            return `import imports.${provider}.${resource}.${className};`;
+        }
+        // Replace using lines
+        const importWithoutLib = /import gen\.providers\.([^.]+)\.([^.]+)\.\*;/;
+        const matchWithoutLib = line.match(importWithoutLib);
+        if (matchWithoutLib) {
+            const [, provider, resource] = matchWithoutLib;
+            return `import imports.${provider}.${resource}.*;`;
+        }
+        // Replace using lines
+        const importModules = /import gen\.modules\.(.+)\.\*;/;
+        const importModulesMatch = line.match(importModules);
+        if (importModulesMatch) {
+            const [, module] = importModulesMatch;
+            return `import imports.${module}.*;`;
+        }
+        return line;
+    })
+        .join("\n");
+}
+exports.replaceJavaImports = replaceJavaImports;
+function replaceCsharpImports(code) {
+    return code
+        .split("\n")
+        .map((line) => {
+        // Replace using lines with lib
+        const fromImportLibRegex = /using Gen\.Providers\.([^.]*)(?:\.Lib)?\.(.*);/;
+        const match = line.match(fromImportLibRegex);
+        if (match) {
+            const [, provider, resource] = match;
+            return `using ${lowercaseFirstChar(provider)}.${resource};`;
+        }
+        // Replace using lines
+        if (line.startsWith("using Gen.Providers.")) {
+            const importLine = line.replace("using Gen.Providers.", "");
+            return `using ${importLine
+                .substring(0, 1)
+                .toLocaleLowerCase()}${importLine.substring(1)}`;
+        }
+        if (line.startsWith("using Gen.Modules.")) {
+            const importLine = line.replace("using Gen.Modules.", "");
+            return `using ${importLine}`;
+        }
+        return line;
+    })
+        .join("\n");
+}
+exports.replaceCsharpImports = replaceCsharpImports;
+function replaceGoImports(code) {
+    return code
+        .split("\n")
+        .map((line) => {
+        // Replace using lines with lib
+        const fromImportLibRegex = /import \"github.com\/aws-samples\/dummy\/gen\/providers\/([^\/]*)(?:\/lib)?\/(.*)\"/;
+        const matchLib = line.match(fromImportLibRegex);
+        if (matchLib) {
+            const [, provider, resource] = matchLib;
+            return `import "cdk.tf/go/stack/generated/${provider}/${resource}"`;
+        }
+        // Replace using lines
+        const fromImportRegex = /import \"github.com\/aws-samples\/dummy\/gen\/providers\/([^\/]+)\/(.*)\"/;
+        const match = line.match(fromImportRegex);
+        if (match) {
+            const [, provider, resource] = match;
+            return `import "cdk.tf/go/stack/generated/${provider}/${resource}"`;
+        }
+        const importModulesRegex = /import (.*) \"github.com\/aws-samples\/dummy\/gen\/modules\/(.*)\"/;
+        const matchModules = line.match(importModulesRegex);
+        if (matchModules) {
+            const [, name, module] = matchModules;
+            return `import ${name} "cdk.tf/go/stack/generated/${module}"`;
+        }
+        return line;
+    })
+        .join("\n");
+}
+exports.replaceGoImports = replaceGoImports;
+function lowercaseFirstChar(str) {
+    return str.substring(0, 1).toLocaleLowerCase() + str.substring(1);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsii-rosetta-workarounds.js","sourceRoot":"","sources":["jsii-rosetta-workarounds.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\n\nexport function replacePythonImports(code: string) {\n  return code\n    .split(\"\\n\")\n    .map((line) => {\n      // Replace from-import lines with lib\n      const fromImportLibRegex =\n        /from \\.\\.\\.gen\\.providers\\.([^.]+)(?:\\.lib)?\\.(.*) import/;\n      if (fromImportLibRegex.test(line)) {\n        return line.replace(fromImportLibRegex, \"from imports.$1.$2 import\");\n      }\n\n      // Replace import lines with lib\n      const importLibRegex =\n        /import \\.\\.\\.gen\\.providers\\.([^.]+)(?:\\.lib)?\\.(.*) as (.*)/;\n      if (importLibRegex.test(line)) {\n        return line.replace(importLibRegex, \"import imports.$1.$2 as $3\");\n      }\n\n      // Replace from-import lines\n      if (line.startsWith(\"from ...gen.providers.\")) {\n        return line.replace(\"from ...gen.providers.\", \"from imports.\");\n      }\n      // Replace import lines\n      if (line.startsWith(\"import ...gen.providers.\")) {\n        return line.replace(\"import ...gen.providers.\", \"import imports.\");\n      }\n\n      // Replace modules\n      if (line.startsWith(\"import ...gen.modules.\")) {\n        return line.replace(\"import ...gen.modules.\", \"import imports.\");\n      }\n\n      return line;\n    })\n    .join(\"\\n\");\n}\n\nexport function replaceJavaImports(code: string) {\n  return code\n    .split(\"\\n\")\n    .map((line) => {\n      // Replace using lines with lib and precices import\n      const importWithLib =\n        /import gen\\.providers\\.([^.]+)(?:\\.lib)?\\.([^.]+)\\.(.*);/;\n      const matchWithLib = line.match(importWithLib);\n      if (matchWithLib) {\n        const [, provider, resource, className] = matchWithLib;\n        return `import imports.${provider}.${resource}.${className};`;\n      }\n\n      // Replace using lines\n      const importWithoutLib = /import gen\\.providers\\.([^.]+)\\.([^.]+)\\.\\*;/;\n      const matchWithoutLib = line.match(importWithoutLib);\n      if (matchWithoutLib) {\n        const [, provider, resource] = matchWithoutLib;\n        return `import imports.${provider}.${resource}.*;`;\n      }\n\n      // Replace using lines\n      const importModules = /import gen\\.modules\\.(.+)\\.\\*;/;\n      const importModulesMatch = line.match(importModules);\n      if (importModulesMatch) {\n        const [, module] = importModulesMatch;\n        return `import imports.${module}.*;`;\n      }\n\n      return line;\n    })\n    .join(\"\\n\");\n}\n\nexport function replaceCsharpImports(code: string) {\n  return code\n    .split(\"\\n\")\n    .map((line) => {\n      // Replace using lines with lib\n      const fromImportLibRegex =\n        /using Gen\\.Providers\\.([^.]*)(?:\\.Lib)?\\.(.*);/;\n      const match = line.match(fromImportLibRegex);\n      if (match) {\n        const [, provider, resource] = match;\n        return `using ${lowercaseFirstChar(provider)}.${resource};`;\n      }\n\n      // Replace using lines\n      if (line.startsWith(\"using Gen.Providers.\")) {\n        const importLine = line.replace(\"using Gen.Providers.\", \"\");\n\n        return `using ${importLine\n          .substring(0, 1)\n          .toLocaleLowerCase()}${importLine.substring(1)}`;\n      }\n\n      if (line.startsWith(\"using Gen.Modules.\")) {\n        const importLine = line.replace(\"using Gen.Modules.\", \"\");\n\n        return `using ${importLine}`;\n      }\n\n      return line;\n    })\n    .join(\"\\n\");\n}\n\nexport function replaceGoImports(code: string) {\n  return code\n    .split(\"\\n\")\n    .map((line) => {\n      // Replace using lines with lib\n      const fromImportLibRegex =\n        /import \\\"github.com\\/aws-samples\\/dummy\\/gen\\/providers\\/([^\\/]*)(?:\\/lib)?\\/(.*)\\\"/;\n      const matchLib = line.match(fromImportLibRegex);\n      if (matchLib) {\n        const [, provider, resource] = matchLib;\n        return `import \"cdk.tf/go/stack/generated/${provider}/${resource}\"`;\n      }\n\n      // Replace using lines\n      const fromImportRegex =\n        /import \\\"github.com\\/aws-samples\\/dummy\\/gen\\/providers\\/([^\\/]+)\\/(.*)\\\"/;\n      const match = line.match(fromImportRegex);\n      if (match) {\n        const [, provider, resource] = match;\n        return `import \"cdk.tf/go/stack/generated/${provider}/${resource}\"`;\n      }\n\n      const importModulesRegex =\n        /import (.*) \\\"github.com\\/aws-samples\\/dummy\\/gen\\/modules\\/(.*)\\\"/;\n      const matchModules = line.match(importModulesRegex);\n      if (matchModules) {\n        const [, name, module] = matchModules;\n        return `import ${name} \"cdk.tf/go/stack/generated/${module}\"`;\n      }\n\n      return line;\n    })\n    .join(\"\\n\");\n}\n\nfunction lowercaseFirstChar(str: string) {\n  return str.substring(0, 1).toLocaleLowerCase() + str.substring(1);\n}\n"]}

package/lib/partialCode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { getTypeAtPath } from "./terraformSchema";
+import { ResourceScope, TerraformResourceBlock } from "./types";
+export declare function fillWithConfigAccessors(scope: ResourceScope, config: TerraformResourceBlock, path: string): any;
+type Key = string;
+export declare function getRequiredAttributes(attributeType: ReturnType<typeof getTypeAtPath>): Key[];
+export {};
+//# sourceMappingURL=partialCode.d.ts.map

package/lib/partialCode.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+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.getRequiredAttributes = exports.fillWithConfigAccessors = void 0;
+const terraformSchema_1 = require("./terraformSchema");
+const t = __importStar(require("@babel/types"));
+const utils_1 = require("./utils");
+function getConfigFieldName(topLevelConfig, name) {
+    const sanitizedName = (0, utils_1.camelCase)(name);
+    return deduplicateName(Object.keys(topLevelConfig), sanitizedName);
+}
+function deduplicateName(existingNames, name) {
+    let newName = name;
+    let i = 1;
+    while (existingNames.includes(newName)) {
+        newName = `${name}${i}`;
+        i++;
+    }
+    return newName;
+}
+function fillWithConfigAccessors(scope, config, path) {
+    if (Array.isArray(config)) {
+        return config.map((c) => fillWithConfigAccessors(scope, c, `${path}.[]`));
+    }
+    if (typeof config === "object" && config !== null) {
+        const mutated = Object.entries(config).reduce((acc, [key, value]) => ({
+            ...acc,
+            [key]: fillWithConfigAccessors(scope, value, `${path}.${key}`),
+        }), {});
+        // Get type of this part of the config
+        const attributeType = (0, terraformSchema_1.getTypeAtPath)(scope.providerSchema, path);
+        const requiredAttributes = getRequiredAttributes(attributeType);
+        // Add accessors for all required attributes that are missing
+        requiredAttributes.forEach((key) => {
+            const value = mutated[key];
+            const isNotDirectlyAccessible = value === undefined;
+            const isReplacedByAst = (t.isNode(mutated) && t.isExpression(mutated)) ||
+                t.isExpression(value);
+            const isEmptyArray = Array.isArray(value) && value.length === 0;
+            // If this was already replaced by an AST node, we don't need to do anything
+            // We assume all fields are filled in by the AST
+            if (isReplacedByAst) {
+                return;
+            }
+            if (isNotDirectlyAccessible || isEmptyArray) {
+                const fieldName = getConfigFieldName(scope.topLevelConfig, key);
+                mutated[key] = t.memberExpression(t.identifier("config"), t.identifier(fieldName));
+                scope.topLevelConfig[fieldName] = `${path}.${key}`;
+            }
+        });
+        return mutated;
+    }
+    else {
+        return config;
+    }
+}
+exports.fillWithConfigAccessors = fillWithConfigAccessors;
+function getRequiredAttributes(attributeType) {
+    if (!attributeType) {
+        return [];
+    }
+    if (typeof attributeType !== "object" ||
+        Array.isArray(attributeType) ||
+        attributeType === null ||
+        attributeType === undefined ||
+        !("block" in attributeType)) {
+        return [];
+    }
+    const requiredAttributes = Object.entries(attributeType.block.attributes || {}).reduce((acc, [key, value]) => (value.required ? [...acc, key] : acc), []);
+    // Logic taken from (and should be shared with) provider generator resource parser: attributeForBlockType
+    const requiredBlockTypes = Object.entries(attributeType.block.block_types || {}).reduce((acc, [key, value]) => {
+        if (value.nesting_mode === "single" &&
+            !Object.values(value.block.attributes || {}).some((x) => !x.required)) {
+            return [...acc, key];
+        }
+        if (value.nesting_mode === "map") {
+            return acc;
+        }
+        if ((value.nesting_mode === "list" || value.nesting_mode === "set") &&
+            value.min_items === undefined
+            ? false
+            : value.min_items > 0) {
+            return [...acc, key];
+        }
+        return acc;
+    }, []);
+    return [...requiredAttributes, ...requiredBlockTypes].sort();
+}
+exports.getRequiredAttributes = getRequiredAttributes;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"partialCode.js","sourceRoot":"","sources":["partialCode.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nimport { getTypeAtPath } from \"./terraformSchema\";\nimport { ResourceScope, TerraformResourceBlock } from \"./types\";\nimport * as t from \"@babel/types\";\nimport { camelCase } from \"./utils\";\n\nfunction getConfigFieldName(\n  topLevelConfig: Record<string, unknown>,\n  name: string,\n) {\n  const sanitizedName = camelCase(name);\n  return deduplicateName(Object.keys(topLevelConfig), sanitizedName);\n}\n\nfunction deduplicateName(existingNames: string[], name: string) {\n  let newName = name;\n  let i = 1;\n  while (existingNames.includes(newName)) {\n    newName = `${name}${i}`;\n    i++;\n  }\n  return newName;\n}\n\nexport function fillWithConfigAccessors(\n  scope: ResourceScope,\n  config: TerraformResourceBlock,\n  path: string,\n): any {\n  if (Array.isArray(config)) {\n    return config.map((c) => fillWithConfigAccessors(scope, c, `${path}.[]`));\n  }\n\n  if (typeof config === \"object\" && config !== null) {\n    const mutated = Object.entries(config).reduce(\n      (acc, [key, value]) => ({\n        ...acc,\n        [key]: fillWithConfigAccessors(scope, value, `${path}.${key}`),\n      }),\n      {} as Record<string, TerraformResourceBlock>,\n    );\n\n    // Get type of this part of the config\n    const attributeType = getTypeAtPath(scope.providerSchema, path);\n    const requiredAttributes = getRequiredAttributes(attributeType);\n\n    // Add accessors for all required attributes that are missing\n    requiredAttributes.forEach((key) => {\n      const value = mutated[key];\n      const isNotDirectlyAccessible = value === undefined;\n      const isReplacedByAst =\n        (t.isNode(mutated) && t.isExpression(mutated)) ||\n        t.isExpression(value as any);\n      const isEmptyArray = Array.isArray(value) && value.length === 0;\n\n      // If this was already replaced by an AST node, we don't need to do anything\n      // We assume all fields are filled in by the AST\n      if (isReplacedByAst) {\n        return;\n      }\n\n      if (isNotDirectlyAccessible || isEmptyArray) {\n        const fieldName = getConfigFieldName(scope.topLevelConfig, key);\n        mutated[key] = t.memberExpression(\n          t.identifier(\"config\"),\n          t.identifier(fieldName),\n        );\n        scope.topLevelConfig[fieldName] = `${path}.${key}`;\n      }\n    });\n\n    return mutated;\n  } else {\n    return config;\n  }\n}\n\ntype Key = string;\nexport function getRequiredAttributes(\n  attributeType: ReturnType<typeof getTypeAtPath>,\n): Key[] {\n  if (!attributeType) {\n    return [];\n  }\n  if (\n    typeof attributeType !== \"object\" ||\n    Array.isArray(attributeType) ||\n    attributeType === null ||\n    attributeType === undefined ||\n    !(\"block\" in attributeType)\n  ) {\n    return [];\n  }\n\n  const requiredAttributes = Object.entries(\n    attributeType.block.attributes || {},\n  ).reduce(\n    (acc, [key, value]) => (value.required ? [...acc, key] : acc),\n    [] as string[],\n  );\n\n  // Logic taken from (and should be shared with) provider generator resource parser: attributeForBlockType\n  const requiredBlockTypes = Object.entries(\n    attributeType.block.block_types || {},\n  ).reduce((acc, [key, value]) => {\n    if (\n      value.nesting_mode === \"single\" &&\n      !Object.values(value.block.attributes || {}).some((x) => !x.required)\n    ) {\n      return [...acc, key];\n    }\n    if (value.nesting_mode === \"map\") {\n      return acc;\n    }\n\n    if (\n      (value.nesting_mode === \"list\" || value.nesting_mode === \"set\") &&\n      value.min_items === undefined\n        ? false\n        : (value as any).min_items > 0\n    ) {\n      return [...acc, key];\n    }\n\n    return acc;\n  }, [] as string[]);\n  return [...requiredAttributes, ...requiredBlockTypes].sort();\n}\n"]}

package/lib/provider.d.ts

@@ -0,0 +1,8 @@
+import * as z from "zod";
+import { ProviderSchema, BlockType, Attribute } from "@cdktn/commons";
+import { schema } from "./schema";
+export { BlockType, Attribute };
+export declare function getFullProviderName(schema: ProviderSchema, providerName: string): string | undefined;
+type Plan = z.infer<typeof schema>;
+export declare function getProviderRequirements(plan: Plan): Record<string, string>;
+//# sourceMappingURL=provider.d.ts.map

package/lib/provider.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProviderRequirements = exports.getFullProviderName = void 0;
+function getFullProviderName(schema, providerName) {
+    return Object.keys(schema.provider_schemas || {}).find((name) => name.endsWith(providerName));
+}
+exports.getFullProviderName = getFullProviderName;
+function getProviderRequirements(plan) {
+    var _a;
+    // In Terraform one can implicitly define the provider by using resources of that type
+    const explicitProviders = Object.keys(plan.provider || {});
+    const implicitProviders = Object.keys({ ...plan.resource, ...plan.data })
+        .filter((type) => type !== "terraform_remote_state")
+        .filter((type) => type !== "terraform_data")
+        .map((type) => type.split("_")[0]);
+    const providerRequirements = Array.from(new Set([...explicitProviders, ...implicitProviders])).reduce((carry, req) => ({ ...carry, [req]: "*" }), {});
+    (_a = plan.terraform) === null || _a === void 0 ? void 0 : _a.forEach(({ required_providers }) => (required_providers || []).forEach((providerBlock) => Object.entries(providerBlock).forEach(([key, value]) => {
+        let name, version;
+        if (typeof value === "string") {
+            name = key;
+            version = value;
+        }
+        else {
+            name = value.source;
+            version = value.version;
+        }
+        if (!name) {
+            return;
+        }
+        // implicitly only the last part of the path is used (e.g. docker for kreuzwerker/docker)
+        const parts = name.split("/");
+        if (parts.length > 1) {
+            delete providerRequirements[parts.pop() || ""];
+        }
+        providerRequirements[name] = version || "*";
+    })));
+    return providerRequirements;
+}
+exports.getProviderRequirements = getProviderRequirements;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/references.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { TFExpressionSyntaxTree as tex } from "@cdktn/hcl2json";
+import { ProgramScope, Reference, TerraformResourceBlock } from "./types";
+export declare function referenceToVariableName(scope: ProgramScope, ref: Reference): string;
+export declare function containsReference(expression: tex.ExpressionType): boolean;
+export declare function extractReferencesFromExpression(input: string, nodeIds: readonly string[], scopedIds?: readonly string[]): Promise<Reference[]>;
+export declare function findUsedReferences(nodeIds: string[], item: TerraformResourceBlock): Promise<Reference[]>;
+//# sourceMappingURL=references.d.ts.map