@cdktn/hcl2cdk 0.21.0

package/lib/index.d.ts

@@ -0,0 +1,136 @@
+import { isRegistryModule } from "@cdktn/provider-generator";
+import * as rosetta from "jsii-rosetta";
+import * as z from "zod";
+import { attributeNameToCdktfName } from "./generation";
+import { replaceCsharpImports, replaceGoImports, replaceJavaImports, replacePythonImports } from "./jsii-rosetta-workarounds";
+import { ProviderSchema } from "@cdktn/commons";
+export declare const CODE_MARKER = "// define resources here";
+export declare function getParsedHcl(hcl: string): Promise<{
+    terraform?: {
+        backend?: Record<string, Record<string, any>[]> | undefined;
+        required_providers?: Record<string, string | {
+            source?: string | undefined;
+            version?: string | undefined;
+        }>[] | undefined;
+        required_version?: string | undefined;
+    }[] | undefined;
+    provider?: Record<string, Record<string, any>[]> | undefined;
+    module?: Record<string, z.objectOutputType<{
+        source: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[]> | undefined;
+    resource?: Record<string, Record<string, Record<string, any>[]>> | undefined;
+    data?: Record<string, Record<string, Record<string, any>[]>> | undefined;
+    output?: Record<string, {
+        value?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        depends_on?: string | undefined;
+    }[]> | undefined;
+    variable?: Record<string, {
+        type?: string | undefined;
+        default?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        nullable?: boolean | undefined;
+        validation?: {
+            error_message: string;
+            condition?: any;
+        }[] | undefined;
+    }[]> | undefined;
+    import?: {
+        to: string;
+        id: string;
+        provider?: any;
+    }[] | undefined;
+    locals?: Record<string, any>[] | undefined;
+}>;
+export declare function parseProviderRequirements(hcl: string): Promise<Record<string, string>>;
+export declare function convertToTypescript(hcl: string, providerSchema: ProviderSchema, codeContainer: string): Promise<{
+    all: string;
+    imports: string;
+    code: string;
+    providers: string[];
+    modules: string[];
+    stats: {
+        numberOfModules: number;
+        numberOfProviders: number;
+        resources: Record<string, Record<string, number>>;
+        data: Record<string, Record<string, number>>;
+        convertedLines: number;
+    };
+}>;
+declare const translators: {
+    python: {
+        visitor: () => rosetta.PythonVisitor;
+        postTranslationMutation: typeof replacePythonImports;
+    };
+    java: {
+        visitor: () => rosetta.JavaVisitor;
+        postTranslationMutation: typeof replaceJavaImports;
+    };
+    csharp: {
+        visitor: () => rosetta.CSharpVisitor;
+        postTranslationMutation: typeof replaceCsharpImports;
+    };
+    go: {
+        visitor: () => rosetta.GoVisitor;
+        postTranslationMutation: typeof replaceGoImports;
+    };
+};
+type ConvertOptions = {
+    /**
+     * The language to convert to
+     */
+    language: keyof typeof translators | "typescript";
+    /**
+     * The provider schema to use for conversion
+     */
+    providerSchema: ProviderSchema;
+    /**
+     * The base class to extend from. Defaults to `constructs.Construct`
+     */
+    codeContainer?: string;
+    /**
+     * Whether to throw an error if the translation fails
+     * Defaults to false
+     */
+    throwOnTranslationError?: boolean;
+};
+export declare function convert(hcl: string, { language, providerSchema, throwOnTranslationError, codeContainer, }: ConvertOptions): Promise<{
+    all: string;
+    imports: string;
+    code: string;
+    stats: {
+        language: "typescript" | "python" | "csharp" | "java" | "go";
+        numberOfModules: number;
+        numberOfProviders: number;
+        resources: Record<string, Record<string, number>>;
+        data: Record<string, Record<string, number>>;
+        convertedLines: number;
+    };
+    providers: string[];
+    modules: string[];
+}>;
+export declare function getTerraformConfigFromDir(importPath: string): string;
+type CdktfJson = Record<string, unknown> & {
+    terraformProviders: any[];
+    terraformModules: any[];
+};
+export declare function convertProject(combinedHcl: string, { language, providerSchema }: ConvertOptions): Promise<{
+    code: (inputMainFile: string) => string;
+    cdktfJson: (inputCdktfJson: CdktfJson) => {
+        [x: string]: unknown;
+        terraformProviders: any[];
+        terraformModules: any[];
+    };
+    stats: {
+        language: "typescript" | "python" | "csharp" | "java" | "go";
+        numberOfModules: number;
+        numberOfProviders: number;
+        resources: Record<string, Record<string, number>>;
+        data: Record<string, Record<string, number>>;
+        convertedLines: number;
+    };
+}>;
+export { isRegistryModule, attributeNameToCdktfName };
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,364 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attributeNameToCdktfName = exports.isRegistryModule = exports.convertProject = exports.getTerraformConfigFromDir = exports.convert = exports.convertToTypescript = exports.parseProviderRequirements = exports.getParsedHcl = exports.CODE_MARKER = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const hcl2json_1 = require("@cdktn/hcl2json");
+const provider_generator_1 = require("@cdktn/provider-generator");
+Object.defineProperty(exports, "isRegistryModule", { enumerable: true, get: function () { return provider_generator_1.isRegistryModule; } });
+const t = __importStar(require("@babel/types"));
+const prettier_1 = __importDefault(require("prettier"));
+const path = __importStar(require("path"));
+const glob = __importStar(require("glob"));
+const fs = __importStar(require("fs"));
+const graphology_1 = require("graphology");
+const rosetta = __importStar(require("jsii-rosetta"));
+const schema_1 = require("./schema");
+const references_1 = require("./references");
+const generation_1 = require("./generation");
+const iteration_1 = require("./iteration");
+const provider_1 = require("./provider");
+const utils_1 = require("./utils");
+const generation_2 = require("./generation");
+Object.defineProperty(exports, "attributeNameToCdktfName", { enumerable: true, get: function () { return generation_2.attributeNameToCdktfName; } });
+const jsii_rosetta_workarounds_1 = require("./jsii-rosetta-workarounds");
+const iteration_2 = require("./iteration");
+exports.CODE_MARKER = "// define resources here";
+async function getParsedHcl(hcl) {
+    utils_1.logger.debug(`Parsing HCL: ${hcl}`);
+    // Get the JSON representation of the HCL
+    let json;
+    try {
+        json = await (0, hcl2json_1.parse)("terraform.tf", hcl);
+    }
+    catch (err) {
+        utils_1.logger.error(`Failed to parse HCL: ${err}`);
+        throw new Error(`Error: Could not parse HCL, this means either that the HCL passed is invalid or that you found a bug. If the HCL seems valid, please file a bug under https://cdk.tf/bugs/new/convert`);
+    }
+    // Ensure the JSON representation matches the expected structure
+    let plan;
+    try {
+        plan = schema_1.schema.parse(json);
+    }
+    catch (err) {
+        throw new Error(`Error: HCL-JSON does not conform to schema. This is not expected, please file a bug under https://cdk.tf/bugs/new/convert
+Please include this information:
+${JSON.stringify(err.errors)}`);
+    }
+    return plan;
+}
+exports.getParsedHcl = getParsedHcl;
+async function parseProviderRequirements(hcl) {
+    utils_1.logger.debug("Parsing provider requirements");
+    const plan = await getParsedHcl(hcl);
+    return (0, provider_1.getProviderRequirements)(plan);
+}
+exports.parseProviderRequirements = parseProviderRequirements;
+async function convertToTypescript(hcl, providerSchema, codeContainer) {
+    var _a;
+    utils_1.logger.debug("Converting to typescript");
+    const plan = await getParsedHcl(hcl);
+    // Each key in the scope needs to be unique, therefore we save them in a set
+    // Each variable needs to be unique as well, we save them in a record so we can identify if two variables are the same
+    const scope = {
+        providerSchema,
+        providerGenerator: Object.keys(providerSchema.provider_schemas || {}).reduce((carry, fqpn) => {
+            const providerGenerator = new provider_generator_1.TerraformProviderGenerator(new provider_generator_1.CodeMaker(), providerSchema);
+            providerGenerator.buildResourceModels(fqpn); // can't use that type on the keys yet, since we are not on TS >=4.4 yet :sadcat:
+            return { ...carry, [fqpn]: providerGenerator };
+        }, {}),
+        constructs: new Set(),
+        variables: {},
+        hasTokenBasedTypeCoercion: false,
+        nodeIds: [],
+        importables: [],
+        topLevelConfig: {},
+    };
+    const graph = new graphology_1.DirectedGraph();
+    // Get all items in the JSON as a map of id to function that generates the AST
+    // We will use this to construct the nodes for a dependency graph
+    // We need to use a function here because the same node has different representation based on if it's referenced by another one
+    const nodeMap = {
+        ...(0, iteration_1.forEachProvider)(scope, plan.provider, generation_1.provider),
+        ...(0, iteration_1.forEachGlobal)(scope, "var", plan.variable, generation_1.variable),
+        // locals are a special case
+        ...(0, iteration_1.forEachGlobal)(scope, "local", Array.isArray(plan.locals)
+            ? plan.locals.reduce((carry, locals) => ({ ...carry, ...locals }), {})
+            : {}, generation_1.local),
+        ...(0, iteration_1.forEachGlobal)(scope, "out", plan.output, generation_1.output),
+        ...(0, iteration_1.forEachGlobal)(scope, "module", plan.module, generation_1.modules),
+        ...(0, iteration_2.forEachImport)(scope, "import", plan.import, generation_1.imports),
+        ...(0, iteration_1.forEachNamespaced)(scope, plan.resource, generation_1.resource),
+        ...(0, iteration_1.forEachNamespaced)(scope, plan.data, generation_1.resource, "data"),
+    };
+    // Add all nodes to the dependency graph so we can detect if an edge is added for an unknown link
+    Object.entries(nodeMap).forEach(([key, value]) => {
+        utils_1.logger.debug(`Adding node '${key}' to graph`);
+        graph.addNode(key, value);
+    });
+    // Finding references becomes easier of the to be referenced ids are already known
+    const nodeIds = Object.keys(nodeMap);
+    scope.nodeIds = nodeIds;
+    async function addEdges(id, value) {
+        (await (0, references_1.findUsedReferences)(nodeIds, value)).forEach((ref) => {
+            if (!graph.hasDirectedEdge(ref.referencee.id, id) &&
+                graph.hasNode(ref.referencee.id) // in case the referencee is a dynamic variable
+            ) {
+                if (!graph.hasNode(id)) {
+                    throw new Error(`The dependency graph is expected to link from ${ref.referencee.id} to ${id} but ${id} does not exist.
+            These nodes exist: ${graph.nodes().join("\n")}`);
+                }
+                // The graph should have no self-references
+                if (id === ref.referencee.id) {
+                    utils_1.logger.debug(`Skipping self-reference for ${id}`);
+                    return;
+                }
+                utils_1.logger.debug(`Adding edge from ${ref.referencee.id} to ${id}`);
+                graph.addDirectedEdge(ref.referencee.id, id, { ref });
+            }
+        });
+    }
+    // We recursively inspect each resource value to find references to other values
+    // We add these to a dependency graph so that the programming code has the right order
+    async function addGlobalEdges(_scope, _key, id, value) {
+        await addEdges(id, value);
+    }
+    async function addProviderEdges(_scope, _key, id, value) {
+        await addEdges(id, value);
+    }
+    async function addNamespacedEdges(_scope, _type, _key, id, value) {
+        await addEdges(id, value);
+    }
+    await Promise.all(Object.values({
+        ...(0, iteration_1.forEachProvider)(scope, plan.provider, addProviderEdges),
+        ...(0, iteration_1.forEachGlobal)(scope, "var", plan.variable, addGlobalEdges),
+        // locals are a special case
+        ...(0, iteration_1.forEachGlobal)(scope, "local", Array.isArray(plan.locals)
+            ? plan.locals.reduce((carry, locals) => ({ ...carry, ...locals }), {})
+            : {}, addGlobalEdges),
+        ...(0, iteration_1.forEachGlobal)(scope, "out", plan.output, addGlobalEdges),
+        ...(0, iteration_1.forEachGlobal)(scope, "module", plan.module, addGlobalEdges),
+        ...(0, iteration_1.forEachNamespaced)(scope, plan.resource, addNamespacedEdges),
+        ...(0, iteration_1.forEachNamespaced)(scope, plan.data, addNamespacedEdges, "data"),
+    }).map(({ code: addEdgesToGraph }) => addEdgesToGraph(graph)));
+    utils_1.logger.debug(`Graph: ${JSON.stringify(graph, null, 2)}`);
+    utils_1.logger.debug(`Starting to assemble the typescript code`);
+    // We traverse the dependency graph to get the unordered JSON nodes into an ordered array
+    // where no node is referenced before it's defined
+    // As we check that the nodes on both ends of an edge exist we can be sure
+    // that no infinite loop exists, there can be no stray dependency on a node
+    const expressions = [];
+    let nodesToVisit = [...nodeIds];
+    // This ensures we detect cycles and don't end up in an endless loop
+    let nodesVisitedThisIteration = 0;
+    do {
+        nodesVisitedThisIteration = 0;
+        // Find next nodes to visit
+        const nodeExpressionGenerators = graph.mapNodes((nodeId, { code }) => {
+            if (!nodesToVisit.includes(nodeId)) {
+                return undefined;
+            }
+            const unresolvedDependencies = graph
+                .inNeighbors(nodeId)
+                .filter((item) => nodesToVisit.includes(item));
+            if (unresolvedDependencies.length === 0) {
+                nodesToVisit = nodesToVisit.filter((id) => nodeId !== id);
+                nodesVisitedThisIteration = nodesVisitedThisIteration + 1;
+                utils_1.logger.debug(`Visiting node ${nodeId}`);
+                return code;
+            }
+            return undefined;
+        });
+        // Generate the code for the nodes
+        for (const code of nodeExpressionGenerators) {
+            if (code) {
+                expressions.push(...(await code(graph)));
+            }
+        }
+        utils_1.logger.debug(`${nodesToVisit.length} unvisited nodes: ${nodesToVisit.join(", ")}`);
+    } while (nodesToVisit.length > 0 && nodesVisitedThisIteration != 0);
+    if (nodesToVisit.length > 0) {
+        throw new Error(`There are ${nodesToVisit.length} terraform elements that could not be visited.
+      This is likely due to a cycle in the dependency graph.
+      These nodes are: ${nodesToVisit.join(", ")}`);
+    }
+    utils_1.logger.debug(`${nodesToVisit.length} unvisited nodes: ${nodesToVisit.join(", ")}`);
+    const backendExpressions = (await Promise.all(((_a = plan.terraform) === null || _a === void 0 ? void 0 : _a.map((terraform) => (0, generation_1.backendToExpression)(scope, terraform.backend))) || [Promise.resolve([])])).reduce((carry, item) => [...carry, ...item], []);
+    utils_1.logger.debug(`Using these backend expressions: ${JSON.stringify(backendExpressions, null, 2)}`);
+    // We collect all module sources
+    const moduleRequirements = [
+        ...new Set(Object.values(plan.module || {}).reduce((carry, moduleBlock) => [
+            ...carry,
+            ...moduleBlock.reduce((arr, { source, version }) => [
+                ...arr,
+                version ? `${source}@${version}` : source,
+            ], []),
+        ], []) || []),
+    ];
+    utils_1.logger.debug(`Found these modules: ${JSON.stringify(moduleRequirements, null, 2)}`);
+    if (Object.keys(plan.variable || {}).length > 0 && expressions.length > 0) {
+        expressions[0] = t.addComment(expressions[0], "leading", `Terraform Variables are not always the best fit for getting inputs in the context of Terraform CDK.
+You can read more about this at https://cdk.tf/variables`);
+    }
+    const providerRequirements = (0, provider_1.getProviderRequirements)(plan);
+    utils_1.logger.debug(`Found these provider requirements: ${JSON.stringify(providerRequirements, null, 2)}`);
+    // We add a comment if there are providers with missing schema information
+    const providersLackingSchema = Object.keys(providerRequirements).filter((providerName) => providerName !== "terraform" &&
+        !Object.keys(providerSchema.provider_schemas || {}).some((schemaName) => schemaName.endsWith(providerName)));
+    utils_1.logger.debug(`${providersLackingSchema.length} providers lack schema information: ${providersLackingSchema.join(", ")}`);
+    if (providersLackingSchema.length > 0) {
+        expressions[0] = t.addComment(expressions[0], "leading", `The following providers are missing schema information and might need manual adjustments to synthesize correctly: ${providersLackingSchema.join(", ")}.
+For a more precise conversion please use the --provider flag in convert.`);
+    }
+    // Always add constructs
+    scope.importables.push({
+        constructName: "Construct",
+        provider: "constructs",
+    });
+    if (scope.hasTokenBasedTypeCoercion) {
+        scope.importables.push({
+            constructName: "Token",
+            provider: "cdktn",
+        });
+    }
+    // Add specific import for codeContainer
+    (0, generation_1.addImportForCodeContainer)(scope, codeContainer);
+    const constructImports = (0, generation_1.buildImports)(scope.importables);
+    const code = [...(backendExpressions || []), ...expressions];
+    const configTypeName = Object.keys(scope.topLevelConfig).length > 0 ? "MyConfig" : undefined;
+    const classConfig = configTypeName
+        ? [(0, generation_1.generateConfigType)(configTypeName, scope.topLevelConfig)]
+        : [];
+    // We split up the generated code so that users can have more control over what to insert where
+    return {
+        // TODO: Remove imports and code because rosetta won't be able to translate them
+        all: await (0, generation_1.gen)([
+            ...constructImports,
+            ...(0, generation_1.moduleImports)(plan.module),
+            ...classConfig,
+            (0, generation_1.wrapCodeInConstructor)(codeContainer, code, "MyConvertedCode", configTypeName),
+        ]),
+        imports: await (0, generation_1.gen)([...constructImports, ...(0, generation_1.moduleImports)(plan.module)]),
+        code: await (0, generation_1.gen)(code),
+        providers: Object.entries(providerRequirements).map(([source, version]) => version === "*" ? source : `${source}@${version}`),
+        modules: moduleRequirements,
+        // We track some usage data to make it easier to understand what is used
+        stats: {
+            numberOfModules: moduleRequirements.length,
+            numberOfProviders: Object.keys(providerRequirements).length,
+            resources: (0, iteration_1.resourceStats)(plan.resource || {}),
+            data: (0, iteration_1.resourceStats)(plan.data || {}),
+            convertedLines: hcl.split("\n").length,
+        },
+    };
+}
+exports.convertToTypescript = convertToTypescript;
+const translators = {
+    python: {
+        visitor: () => new rosetta.PythonVisitor(),
+        postTranslationMutation: jsii_rosetta_workarounds_1.replacePythonImports,
+    },
+    java: {
+        visitor: () => new rosetta.JavaVisitor(),
+        postTranslationMutation: jsii_rosetta_workarounds_1.replaceJavaImports,
+    },
+    csharp: {
+        visitor: () => new rosetta.CSharpVisitor(),
+        postTranslationMutation: jsii_rosetta_workarounds_1.replaceCsharpImports,
+    },
+    go: {
+        visitor: () => new rosetta.GoVisitor(),
+        postTranslationMutation: jsii_rosetta_workarounds_1.replaceGoImports,
+    },
+};
+function translatorForLanguage(language) {
+    return (file, throwOnTranslationError) => {
+        const { visitor, postTranslationMutation } = translators[language];
+        const { translation, diagnostics } = rosetta.translateTypeScript(file, visitor(), throwOnTranslationError ? { includeCompilerDiagnostics: true } : {});
+        if (throwOnTranslationError &&
+            diagnostics.filter((diag) => diag.isError).length > 0) {
+            utils_1.logger.debug(`Could not translate TS to ${language}:\n${file.contents}`);
+            throw new Error(`Could not translate TS to ${language}: ${diagnostics
+                .map((diag) => diag.formattedMessage)
+                .join("\n")}`);
+        }
+        return postTranslationMutation(translation);
+    };
+}
+async function convert(hcl, { language, providerSchema, throwOnTranslationError = false, codeContainer = "cdktn.TerraformStack", }) {
+    const fileName = "terraform.tf";
+    const translater = language === "typescript"
+        ? (file, _throwOnTranslationError) => file.contents
+        : translatorForLanguage(language);
+    if (!translater) {
+        throw new Error("Unsupported language used: " + language);
+    }
+    const tsCode = await convertToTypescript(hcl, providerSchema, codeContainer);
+    return {
+        ...tsCode,
+        all: translater({ fileName, contents: tsCode.all }, throwOnTranslationError),
+        imports: translater({ fileName, contents: tsCode.imports }, false),
+        code: translater({ fileName, contents: tsCode.code }, false),
+        stats: { ...tsCode.stats, language },
+    };
+}
+exports.convert = convert;
+function getTerraformConfigFromDir(importPath) {
+    const absPath = path.resolve(importPath);
+    const fileContents = glob
+        .sync("./*.tf", { cwd: absPath })
+        .map((p) => fs.readFileSync(path.resolve(absPath, p), "utf8"));
+    return fileContents.join("\n");
+}
+exports.getTerraformConfigFromDir = getTerraformConfigFromDir;
+async function convertProject(combinedHcl, { language, providerSchema }) {
+    if (language !== "typescript") {
+        throw new Error("Unsupported language used: " + language);
+    }
+    const { imports, code, providers, modules: tfModules, stats, } = await convert(combinedHcl, {
+        language,
+        providerSchema,
+    });
+    return {
+        code: (inputMainFile) => {
+            const importMainFile = [imports, inputMainFile].join("\n");
+            const outputMainFile = importMainFile.replace(exports.CODE_MARKER, code);
+            return prettier_1.default.format(outputMainFile, { parser: "babel" });
+        },
+        cdktfJson: (inputCdktfJson) => {
+            const cdktfJson = { ...inputCdktfJson };
+            cdktfJson.terraformProviders = providers;
+            cdktfJson.terraformModules = tfModules;
+            return cdktfJson;
+        },
+        stats,
+    };
+}
+exports.convertProject = convertProject;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { parse } from \"@cdktn/hcl2json\";\nimport {\n  isRegistryModule,\n  TerraformProviderGenerator,\n  CodeMaker,\n} from \"@cdktn/provider-generator\";\n\nimport * as t from \"@babel/types\";\nimport prettier from \"prettier\";\nimport * as path from \"path\";\nimport * as glob from \"glob\";\nimport * as fs from \"fs\";\nimport { DirectedGraph } from \"graphology\";\nimport * as rosetta from \"jsii-rosetta\";\nimport * as z from \"zod\";\n\nimport { schema } from \"./schema\";\nimport { findUsedReferences } from \"./references\";\nimport {\n  backendToExpression,\n  gen,\n  local,\n  moduleImports,\n  modules,\n  output,\n  provider,\n  resource,\n  variable,\n  wrapCodeInConstructor,\n  addImportForCodeContainer,\n  buildImports,\n  generateConfigType,\n  imports,\n} from \"./generation\";\nimport { TerraformResourceBlock, ProgramScope } from \"./types\";\nimport {\n  forEachProvider,\n  forEachGlobal,\n  forEachNamespaced,\n  resourceStats,\n} from \"./iteration\";\nimport { getProviderRequirements } from \"./provider\";\nimport { logger } from \"./utils\";\nimport { FQPN } from \"@cdktn/provider-schema\";\nimport { attributeNameToCdktfName } from \"./generation\";\nimport {\n  replaceCsharpImports,\n  replaceGoImports,\n  replaceJavaImports,\n  replacePythonImports,\n} from \"./jsii-rosetta-workarounds\";\nimport { ProviderSchema } from \"@cdktn/commons\";\nimport { forEachImport } from \"./iteration\";\n\nexport const CODE_MARKER = \"// define resources here\";\n\nexport async function getParsedHcl(hcl: string) {\n  logger.debug(`Parsing HCL: ${hcl}`);\n  // Get the JSON representation of the HCL\n  let json: Record<string, unknown>;\n  try {\n    json = await parse(\"terraform.tf\", hcl);\n  } catch (err) {\n    logger.error(`Failed to parse HCL: ${err}`);\n    throw new Error(\n      `Error: Could not parse HCL, this means either that the HCL passed is invalid or that you found a bug. If the HCL seems valid, please file a bug under https://cdk.tf/bugs/new/convert`,\n    );\n  }\n\n  // Ensure the JSON representation matches the expected structure\n  let plan: z.infer<typeof schema>;\n  try {\n    plan = schema.parse(json);\n  } catch (err) {\n    throw new Error(`Error: HCL-JSON does not conform to schema. This is not expected, please file a bug under https://cdk.tf/bugs/new/convert\nPlease include this information:\n${JSON.stringify((err as z.ZodError).errors)}`);\n  }\n\n  return plan;\n}\n\nexport async function parseProviderRequirements(hcl: string) {\n  logger.debug(\"Parsing provider requirements\");\n  const plan = await getParsedHcl(hcl);\n  return getProviderRequirements(plan);\n}\n\nexport async function convertToTypescript(\n  hcl: string,\n  providerSchema: ProviderSchema,\n  codeContainer: string,\n) {\n  logger.debug(\"Converting to typescript\");\n  const plan = await getParsedHcl(hcl);\n\n  // Each key in the scope needs to be unique, therefore we save them in a set\n  // Each variable needs to be unique as well, we save them in a record so we can identify if two variables are the same\n  const scope: ProgramScope = {\n    providerSchema,\n    providerGenerator: Object.keys(\n      providerSchema.provider_schemas || {},\n    ).reduce((carry, fqpn) => {\n      const providerGenerator = new TerraformProviderGenerator(\n        new CodeMaker(),\n        providerSchema,\n      );\n      providerGenerator.buildResourceModels(fqpn as FQPN); // can't use that type on the keys yet, since we are not on TS >=4.4 yet :sadcat:\n      return { ...carry, [fqpn]: providerGenerator };\n    }, {}),\n    constructs: new Set<string>(),\n    variables: {},\n    hasTokenBasedTypeCoercion: false,\n    nodeIds: [],\n    importables: [],\n    topLevelConfig: {},\n  };\n\n  const graph = new DirectedGraph<{\n    code: (\n      g: DirectedGraph<any>,\n    ) => Promise<Array<t.Statement | t.VariableDeclaration>>;\n  }>();\n\n  // Get all items in the JSON as a map of id to function that generates the AST\n  // We will use this to construct the nodes for a dependency graph\n  // We need to use a function here because the same node has different representation based on if it's referenced by another one\n  const nodeMap: Record<\n    string,\n    {\n      code: (\n        g: typeof graph,\n      ) => Promise<Array<t.Statement | t.VariableDeclaration>>;\n      value: unknown;\n    }\n  > = {\n    ...forEachProvider(scope, plan.provider, provider),\n    ...forEachGlobal(scope, \"var\", plan.variable, variable),\n    // locals are a special case\n    ...forEachGlobal(\n      scope,\n      \"local\",\n      Array.isArray(plan.locals)\n        ? plan.locals.reduce((carry, locals) => ({ ...carry, ...locals }), {})\n        : {},\n      local,\n    ),\n    ...forEachGlobal(scope, \"out\", plan.output, output),\n    ...forEachGlobal(scope, \"module\", plan.module, modules),\n    ...forEachImport(scope, \"import\", plan.import, imports),\n    ...forEachNamespaced(scope, plan.resource, resource),\n    ...forEachNamespaced(scope, plan.data, resource, \"data\"),\n  };\n\n  // Add all nodes to the dependency graph so we can detect if an edge is added for an unknown link\n  Object.entries(nodeMap).forEach(([key, value]) => {\n    logger.debug(`Adding node '${key}' to graph`);\n    graph.addNode(key, value);\n  });\n\n  // Finding references becomes easier of the to be referenced ids are already known\n  const nodeIds = Object.keys(nodeMap);\n  scope.nodeIds = nodeIds;\n  async function addEdges(id: string, value: TerraformResourceBlock) {\n    (await findUsedReferences(nodeIds, value)).forEach((ref) => {\n      if (\n        !graph.hasDirectedEdge(ref.referencee.id, id) &&\n        graph.hasNode(ref.referencee.id) // in case the referencee is a dynamic variable\n      ) {\n        if (!graph.hasNode(id)) {\n          throw new Error(\n            `The dependency graph is expected to link from ${\n              ref.referencee.id\n            } to ${id} but ${id} does not exist.\n            These nodes exist: ${graph.nodes().join(\"\\n\")}`,\n          );\n        }\n\n        // The graph should have no self-references\n        if (id === ref.referencee.id) {\n          logger.debug(`Skipping self-reference for ${id}`);\n          return;\n        }\n\n        logger.debug(`Adding edge from ${ref.referencee.id} to ${id}`);\n        graph.addDirectedEdge(ref.referencee.id, id, { ref });\n      }\n    });\n  }\n\n  // We recursively inspect each resource value to find references to other values\n  // We add these to a dependency graph so that the programming code has the right order\n  async function addGlobalEdges(\n    _scope: ProgramScope,\n    _key: string,\n    id: string,\n    value: TerraformResourceBlock,\n  ) {\n    await addEdges(id, value);\n  }\n  async function addProviderEdges(\n    _scope: ProgramScope,\n    _key: string,\n    id: string,\n    value: TerraformResourceBlock,\n  ) {\n    await addEdges(id, value);\n  }\n  async function addNamespacedEdges(\n    _scope: ProgramScope,\n    _type: string,\n    _key: string,\n    id: string,\n    value: TerraformResourceBlock,\n  ) {\n    await addEdges(id, value);\n  }\n\n  await Promise.all(\n    Object.values({\n      ...forEachProvider(scope, plan.provider, addProviderEdges),\n      ...forEachGlobal(scope, \"var\", plan.variable, addGlobalEdges),\n      // locals are a special case\n      ...forEachGlobal(\n        scope,\n        \"local\",\n        Array.isArray(plan.locals)\n          ? plan.locals.reduce((carry, locals) => ({ ...carry, ...locals }), {})\n          : {},\n        addGlobalEdges,\n      ),\n      ...forEachGlobal(scope, \"out\", plan.output, addGlobalEdges),\n      ...forEachGlobal(scope, \"module\", plan.module, addGlobalEdges),\n      ...forEachNamespaced(scope, plan.resource, addNamespacedEdges),\n      ...forEachNamespaced(scope, plan.data, addNamespacedEdges, \"data\"),\n    }).map(({ code: addEdgesToGraph }) => addEdgesToGraph(graph)),\n  );\n\n  logger.debug(`Graph: ${JSON.stringify(graph, null, 2)}`);\n  logger.debug(`Starting to assemble the typescript code`);\n  // We traverse the dependency graph to get the unordered JSON nodes into an ordered array\n  // where no node is referenced before it's defined\n  // As we check that the nodes on both ends of an edge exist we can be sure\n  // that no infinite loop exists, there can be no stray dependency on a node\n  const expressions: t.Statement[] = [];\n  let nodesToVisit = [...nodeIds];\n  // This ensures we detect cycles and don't end up in an endless loop\n  let nodesVisitedThisIteration = 0;\n  do {\n    nodesVisitedThisIteration = 0;\n\n    // Find next nodes to visit\n    const nodeExpressionGenerators = graph.mapNodes((nodeId, { code }) => {\n      if (!nodesToVisit.includes(nodeId)) {\n        return undefined;\n      }\n\n      const unresolvedDependencies = graph\n        .inNeighbors(nodeId)\n        .filter((item) => nodesToVisit.includes(item));\n\n      if (unresolvedDependencies.length === 0) {\n        nodesToVisit = nodesToVisit.filter((id) => nodeId !== id);\n        nodesVisitedThisIteration = nodesVisitedThisIteration + 1;\n\n        logger.debug(`Visiting node ${nodeId}`);\n        return code;\n      }\n      return undefined;\n    });\n\n    // Generate the code for the nodes\n    for (const code of nodeExpressionGenerators) {\n      if (code) {\n        expressions.push(...(await code(graph)));\n      }\n    }\n\n    logger.debug(\n      `${nodesToVisit.length} unvisited nodes: ${nodesToVisit.join(\", \")}`,\n    );\n  } while (nodesToVisit.length > 0 && nodesVisitedThisIteration != 0);\n\n  if (nodesToVisit.length > 0) {\n    throw new Error(\n      `There are ${\n        nodesToVisit.length\n      } terraform elements that could not be visited.\n      This is likely due to a cycle in the dependency graph.\n      These nodes are: ${nodesToVisit.join(\", \")}`,\n    );\n  }\n\n  logger.debug(\n    `${nodesToVisit.length} unvisited nodes: ${nodesToVisit.join(\", \")}`,\n  );\n\n  const backendExpressions = (\n    await Promise.all(\n      plan.terraform?.map((terraform) =>\n        backendToExpression(scope, terraform.backend),\n      ) || [Promise.resolve([])],\n    )\n  ).reduce((carry, item) => [...carry, ...item], []);\n\n  logger.debug(\n    `Using these backend expressions: ${JSON.stringify(\n      backendExpressions,\n      null,\n      2,\n    )}`,\n  );\n\n  // We collect all module sources\n  const moduleRequirements = [\n    ...new Set(\n      Object.values(plan.module || {}).reduce(\n        (carry, moduleBlock) => [\n          ...carry,\n          ...moduleBlock.reduce(\n            (arr, { source, version }) => [\n              ...arr,\n              version ? `${source}@${version}` : source,\n            ],\n            [] as string[],\n          ),\n        ],\n        [] as string[],\n      ) || [],\n    ),\n  ];\n\n  logger.debug(\n    `Found these modules: ${JSON.stringify(moduleRequirements, null, 2)}`,\n  );\n\n  if (Object.keys(plan.variable || {}).length > 0 && expressions.length > 0) {\n    expressions[0] = t.addComment(\n      expressions[0],\n      \"leading\",\n      `Terraform Variables are not always the best fit for getting inputs in the context of Terraform CDK.\nYou can read more about this at https://cdk.tf/variables`,\n    );\n  }\n\n  const providerRequirements = getProviderRequirements(plan);\n  logger.debug(\n    `Found these provider requirements: ${JSON.stringify(\n      providerRequirements,\n      null,\n      2,\n    )}`,\n  );\n\n  // We add a comment if there are providers with missing schema information\n  const providersLackingSchema = Object.keys(providerRequirements).filter(\n    (providerName) =>\n      providerName !== \"terraform\" &&\n      !Object.keys(providerSchema.provider_schemas || {}).some((schemaName) =>\n        schemaName.endsWith(providerName),\n      ),\n  );\n  logger.debug(\n    `${\n      providersLackingSchema.length\n    } providers lack schema information: ${providersLackingSchema.join(\", \")}`,\n  );\n\n  if (providersLackingSchema.length > 0) {\n    expressions[0] = t.addComment(\n      expressions[0],\n      \"leading\",\n      `The following providers are missing schema information and might need manual adjustments to synthesize correctly: ${providersLackingSchema.join(\n        \", \",\n      )}.\nFor a more precise conversion please use the --provider flag in convert.`,\n    );\n  }\n\n  // Always add constructs\n  scope.importables.push({\n    constructName: \"Construct\",\n    provider: \"constructs\",\n  });\n\n  if (scope.hasTokenBasedTypeCoercion) {\n    scope.importables.push({\n      constructName: \"Token\",\n      provider: \"cdktn\",\n    });\n  }\n\n  // Add specific import for codeContainer\n  addImportForCodeContainer(scope, codeContainer);\n  const constructImports = buildImports(scope.importables);\n\n  const code = [...(backendExpressions || []), ...expressions];\n  const configTypeName =\n    Object.keys(scope.topLevelConfig).length > 0 ? \"MyConfig\" : undefined;\n\n  const classConfig = configTypeName\n    ? [generateConfigType(configTypeName, scope.topLevelConfig)]\n    : [];\n\n  // We split up the generated code so that users can have more control over what to insert where\n  return {\n    // TODO: Remove imports and code because rosetta won't be able to translate them\n    all: await gen([\n      ...constructImports,\n      ...moduleImports(plan.module),\n      ...classConfig,\n      wrapCodeInConstructor(\n        codeContainer,\n        code,\n        \"MyConvertedCode\",\n        configTypeName,\n      ),\n    ]),\n    imports: await gen([...constructImports, ...moduleImports(plan.module)]),\n    code: await gen(code),\n    providers: Object.entries(providerRequirements).map(([source, version]) =>\n      version === \"*\" ? source : `${source}@${version}`,\n    ),\n    modules: moduleRequirements,\n    // We track some usage data to make it easier to understand what is used\n    stats: {\n      numberOfModules: moduleRequirements.length,\n      numberOfProviders: Object.keys(providerRequirements).length,\n      resources: resourceStats(plan.resource || {}),\n      data: resourceStats(plan.data || {}),\n      convertedLines: hcl.split(\"\\n\").length,\n    },\n  };\n}\n\ntype File = { contents: string; fileName: string };\nconst translators = {\n  python: {\n    visitor: () => new rosetta.PythonVisitor(),\n    postTranslationMutation: replacePythonImports,\n  },\n  java: {\n    visitor: () => new rosetta.JavaVisitor(),\n    postTranslationMutation: replaceJavaImports,\n  },\n  csharp: {\n    visitor: () => new rosetta.CSharpVisitor(),\n    postTranslationMutation: replaceCsharpImports,\n  },\n  go: {\n    visitor: () => new rosetta.GoVisitor(),\n    postTranslationMutation: replaceGoImports,\n  },\n};\n\nfunction translatorForLanguage(language: keyof typeof translators) {\n  return (file: File, throwOnTranslationError: boolean) => {\n    const { visitor, postTranslationMutation } = translators[language];\n    const { translation, diagnostics } = rosetta.translateTypeScript(\n      file,\n      visitor(),\n      throwOnTranslationError ? { includeCompilerDiagnostics: true } : {},\n    );\n\n    if (\n      throwOnTranslationError &&\n      diagnostics.filter((diag) => diag.isError).length > 0\n    ) {\n      logger.debug(`Could not translate TS to ${language}:\\n${file.contents}`);\n      throw new Error(\n        `Could not translate TS to ${language}: ${diagnostics\n          .map((diag) => diag.formattedMessage)\n          .join(\"\\n\")}`,\n      );\n    }\n\n    return postTranslationMutation(translation);\n  };\n}\n\ntype ConvertOptions = {\n  /**\n   * The language to convert to\n   */\n  language: keyof typeof translators | \"typescript\";\n  /**\n   * The provider schema to use for conversion\n   */\n  providerSchema: ProviderSchema;\n  /**\n   * The base class to extend from. Defaults to `constructs.Construct`\n   */\n  codeContainer?: string;\n  /**\n   * Whether to throw an error if the translation fails\n   * Defaults to false\n   */\n  throwOnTranslationError?: boolean;\n};\n\nexport async function convert(\n  hcl: string,\n  {\n    language,\n    providerSchema,\n    throwOnTranslationError = false,\n    codeContainer = \"cdktn.TerraformStack\",\n  }: ConvertOptions,\n) {\n  const fileName = \"terraform.tf\";\n  const translater =\n    language === \"typescript\"\n      ? (file: File, _throwOnTranslationError: boolean) => file.contents\n      : translatorForLanguage(language);\n\n  if (!translater) {\n    throw new Error(\"Unsupported language used: \" + language);\n  }\n\n  const tsCode = await convertToTypescript(hcl, providerSchema, codeContainer);\n\n  return {\n    ...tsCode,\n    all: translater(\n      { fileName, contents: tsCode.all },\n      throwOnTranslationError,\n    ),\n    imports: translater({ fileName, contents: tsCode.imports }, false),\n    code: translater({ fileName, contents: tsCode.code }, false),\n    stats: { ...tsCode.stats, language },\n  };\n}\n\nexport function getTerraformConfigFromDir(importPath: string) {\n  const absPath = path.resolve(importPath);\n  const fileContents = glob\n    .sync(\"./*.tf\", { cwd: absPath })\n    .map((p) => fs.readFileSync(path.resolve(absPath, p), \"utf8\"));\n\n  return fileContents.join(\"\\n\");\n}\n\ntype CdktfJson = Record<string, unknown> & {\n  terraformProviders: any[];\n  terraformModules: any[];\n};\nexport async function convertProject(\n  combinedHcl: string,\n  { language, providerSchema }: ConvertOptions,\n) {\n  if (language !== \"typescript\") {\n    throw new Error(\"Unsupported language used: \" + language);\n  }\n\n  const {\n    imports,\n    code,\n    providers,\n    modules: tfModules,\n    stats,\n  } = await convert(combinedHcl, {\n    language,\n    providerSchema,\n  });\n\n  return {\n    code: (inputMainFile: string) => {\n      const importMainFile = [imports, inputMainFile].join(\"\\n\");\n      const outputMainFile = importMainFile.replace(CODE_MARKER, code);\n      return prettier.format(outputMainFile, { parser: \"babel\" });\n    },\n    cdktfJson: (inputCdktfJson: CdktfJson) => {\n      const cdktfJson = { ...inputCdktfJson };\n      cdktfJson.terraformProviders = providers;\n      cdktfJson.terraformModules = tfModules;\n      return cdktfJson;\n    },\n    stats,\n  };\n}\n\nexport { isRegistryModule, attributeNameToCdktfName };\n"]}

package/lib/iteration.d.ts

@@ -0,0 +1,23 @@
+import { DirectedGraph } from "graphology";
+import { ProgramScope } from "./types";
+import { Import } from "./schema";
+export declare function forEachGlobal<T, R>(scope: ProgramScope, prefix: string, record: Record<string, T> | undefined, iterator: (scope: ProgramScope, key: string, id: string, value: T, graph: DirectedGraph) => Promise<R>): Record<string, {
+    code: (graph: DirectedGraph) => Promise<R>;
+    value: T;
+}>;
+export declare function forEachImport<R>(scope: ProgramScope, prefix: string, record: Import[] | undefined, iterator: (scope: ProgramScope, id: string, value: Import, graph: DirectedGraph) => Promise<R>): Record<string, {
+    code: (graph: DirectedGraph) => Promise<R>;
+    value: Import;
+}>;
+export declare function forEachProvider<T extends {
+    alias?: string;
+}, R>(scope: ProgramScope, record: Record<string, T[]> | undefined, iterator: (scope: ProgramScope, key: string, id: string, value: T, graph: DirectedGraph) => Promise<R>): Record<string, {
+    code: (graph: DirectedGraph) => Promise<R>;
+    value: T;
+}>;
+export declare function forEachNamespaced<T, R>(scope: ProgramScope, record: Record<string, Record<string, T>> | undefined, iterator: (scope: ProgramScope, type: string, key: string, id: string, value: T, graph: DirectedGraph) => Promise<R>, prefix?: string): Record<string, {
+    code: (graph: DirectedGraph) => Promise<R>;
+    value: T;
+}>;
+export declare function resourceStats(obj: Record<string, Record<string, unknown>>): Record<string, Record<string, number>>;
+//# sourceMappingURL=iteration.d.ts.map