@cdktn/hcl2cdk 0.24.0-pre.45 → 0.24.0-pre.48

package/src/generation.ts

@@ -0,0 +1,1189 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import generate from "@babel/generator";
+import template from "@babel/template";
+import * as t from "@babel/types";
+import { DirectedGraph } from "graphology";
+import prettier from "prettier";
+
+import {
+  TerraformResourceBlock,
+  ProgramScope,
+  ResourceScope,
+  ImportableConstruct,
+  AttributePath,
+} from "./types";
+import { camelCase, logger, pascalCase, uniqueId } from "./utils";
+import {
+  Resource,
+  TerraformConfig,
+  Module,
+  Provider,
+  Variable,
+  Output,
+  Import,
+} from "./schema";
+import { convertTerraformExpressionToTs, expressionAst } from "./expressions";
+import { Reference } from "./types";
+import { findUsedReferences } from "./references";
+import {
+  TerraformModuleConstraint,
+  escapeAttributeName,
+} from "@cdktn/provider-generator";
+import {
+  getTypeAtPath,
+  isMapAttribute,
+  getDesiredType,
+} from "./terraformSchema";
+import { Errors, AttributeType, BlockType, Schema } from "@cdktn/commons";
+import { TFExpressionSyntaxTree as tex } from "@cdktn/hcl2json";
+import { extractDynamicBlocks, isNestedDynamicBlock } from "./dynamic-blocks";
+import {
+  constructAst,
+  referenceToVariableName,
+  variableName,
+} from "./variables";
+import { snakeCase } from "cdktn/lib/util";
+import { fillWithConfigAccessors } from "./partialCode";
+
+function getReference(graph: DirectedGraph, id: string) {
+  logger.debug(`Finding reference for ${id}`);
+  const neighbors = graph.outNeighbors(id);
+
+  if (neighbors.length > 0) {
+    logger.debug(`Found neighbors ${neighbors} for ${id}`);
+    const edge = graph.directedEdge(id, neighbors[0]);
+
+    if (edge) {
+      logger.debug(`Found first edge ${edge} for ${id}`);
+      logger.debug(
+        `Returning reference ${graph.getEdgeAttribute(edge, "ref")}`,
+      );
+      return graph.getEdgeAttribute(edge, "ref") as Reference;
+    } else {
+      logger.debug(`Found no edge for ${id}`);
+      return undefined;
+    }
+  } else {
+    return undefined;
+  }
+}
+
+export function attributeNameToCdktfName(name: string) {
+  return escapeAttributeName(camelCase(name));
+}
+
+export const valueToTs = async (
+  scope: ResourceScope,
+  item: TerraformResourceBlock,
+  path: string,
+  isModule = false,
+): Promise<t.Expression> => {
+  switch (typeof item) {
+    case "string":
+      if (
+        (await findUsedReferences(scope.nodeIds, item)).some((ref) =>
+          path.startsWith(ref.referencee.id),
+        )
+      ) {
+        return t.stringLiteral(item);
+      }
+
+      return await convertTerraformExpressionToTs(scope, `"${item}"`, () =>
+        getDesiredType(scope, path),
+      );
+
+    case "boolean":
+      return await convertTerraformExpressionToTs(scope, `${item}`, () =>
+        getDesiredType(scope, path),
+      );
+    case "number":
+      return await convertTerraformExpressionToTs(scope, `${item}`, () =>
+        getDesiredType(scope, path),
+      );
+    case "object": {
+      if (item === undefined || item === null) {
+        return t.nullLiteral();
+      }
+
+      // For iterators and dynamic blocks we put the correct TS expression in the config ahead of time
+      if (t.isNode(item) && t.isExpression(item)) {
+        return item;
+      }
+
+      const attributeType = getTypeAtPath(scope.providerSchema, path);
+
+      function shouldRemoveArrayBasedOnType(
+        attributeType: Schema | AttributeType | BlockType | null,
+      ): boolean {
+        if (!attributeType) {
+          return false; // The default assumption is we need the array
+        }
+
+        // maps and object don't need to be wrapped in an array
+        if (
+          Array.isArray(attributeType) &&
+          (attributeType[0] === "map" || attributeType[0] === "object")
+        ) {
+          return true;
+        }
+
+        // If it's a block type with max_items = 1 we don't need to wrap it in an array
+        if (
+          typeof attributeType === "object" &&
+          "max_items" in attributeType &&
+          attributeType.max_items === 1
+        ) {
+          return true;
+        }
+
+        return false;
+      }
+
+      const unwrappedItem =
+        Array.isArray(item) &&
+        (shouldRemoveArrayBasedOnType(attributeType) ||
+          path.endsWith("lifecycle") ||
+          path.endsWith("connection"))
+          ? item[0]
+          : item;
+
+      if (Array.isArray(unwrappedItem)) {
+        return t.arrayExpression(
+          await Promise.all(
+            unwrappedItem.map((i) => valueToTs(scope, i, `${path}.[]`)),
+          ),
+        );
+      }
+
+      return t.objectExpression(
+        (
+          await Promise.all(
+            Object.entries(unwrappedItem).map(async ([key, value]) => {
+              if (value === undefined) {
+                return undefined;
+              }
+
+              if (key === "dynamic") {
+                const { for_each: _for_each, ...others } = value as any;
+                const dynamicRef = Object.keys(others)[0];
+                return t.objectProperty(
+                  t.identifier(
+                    scope.withinOverrideExpression
+                      ? dynamicRef
+                      : escapeAttributeName(camelCase(dynamicRef)),
+                  ),
+                  t.arrayExpression(),
+                );
+              }
+
+              const itemPath = `${path}.${key}`;
+              const itemAttributeType = getTypeAtPath(
+                scope.providerSchema,
+                itemPath,
+              );
+
+              const typeMetadata = getTypeAtPath(
+                scope.providerSchema,
+                itemPath,
+              );
+
+              const isSingleItemBlock =
+                typeMetadata &&
+                typeof typeMetadata === "object" &&
+                Object.prototype.hasOwnProperty.call(typeMetadata, "max_items")
+                  ? (typeMetadata as any).max_items === 1
+                  : false;
+
+              const shouldBeArray =
+                typeof value === "object" &&
+                !Array.isArray(value) &&
+                !(t.isNode(value) && t.isExpression(value)) &&
+                !isSingleItemBlock &&
+                // Map type attributes must not be wrapped in arrays
+                !isMapAttribute(itemAttributeType) &&
+                key !== "tags" &&
+                key !== "forEach" &&
+                key !== "lifecycle";
+
+              const keepKeyName: boolean =
+                !isModule &&
+                key !== "depends_on" &&
+                !path.includes("lifecycle") &&
+                (key === "for_each" ||
+                  !typeMetadata ||
+                  isMapAttribute(attributeType)) &&
+                !(path.startsWith("var.") && path.includes("validation"));
+
+              return t.objectProperty(
+                t.stringLiteral(
+                  keepKeyName ? key : attributeNameToCdktfName(key),
+                ),
+                shouldBeArray
+                  ? t.arrayExpression([await valueToTs(scope, value, itemPath)])
+                  : await valueToTs(scope, value, itemPath),
+              );
+            }),
+          )
+        ).filter((expr) => expr !== undefined) as t.ObjectProperty[],
+      );
+    }
+  }
+  throw new Error("Unsupported type " + item);
+};
+
+export async function backendToExpression(
+  scope: ProgramScope,
+  tf: TerraformConfig["backend"],
+): Promise<t.Statement[]> {
+  return (
+    await Promise.all(
+      Object.entries(tf || {}).map(async ([type, [config]]) => {
+        const backendIdentifier = pascalCase(`${type}Backend`);
+        scope.importables.push({
+          constructName: backendIdentifier,
+          provider: "cdktn",
+        });
+        return t.expressionStatement(
+          t.newExpression(t.identifier(backendIdentifier), [
+            t.thisExpression(),
+            t.objectExpression(
+              (
+                await Promise.all(
+                  Object.entries(config).map(async ([property, value]) =>
+                    t.objectProperty(
+                      t.identifier(camelCase(property)),
+                      await valueToTs(
+                        scope,
+                        value,
+                        "path-for-backends-can-be-ignored",
+                      ),
+                    ),
+                  ),
+                )
+              ).reduce(
+                (carry, item) => [...carry, item],
+                [] as t.ObjectProperty[],
+              ),
+            ),
+          ]),
+        );
+      }),
+    )
+  ).reduce((carry, item) => [...carry, item], [] as t.Statement[]);
+}
+
+function addOverrideExpression(
+  variable: string,
+  path: string,
+  value: t.Expression,
+  explanatoryComment?: string,
+) {
+  const ast = t.expressionStatement(
+    t.callExpression(
+      t.memberExpression(t.identifier(variable), t.identifier("addOverride")),
+      [t.stringLiteral(path), value],
+    ),
+  );
+
+  if (explanatoryComment) {
+    t.addComment(ast, "leading", explanatoryComment);
+  }
+
+  return ast;
+}
+
+function addOverrideLogicalIdExpression(variable: string, logicalId: string) {
+  const ast = t.expressionStatement(
+    t.callExpression(
+      t.memberExpression(
+        t.identifier(variable),
+        t.identifier("overrideLogicalId"),
+      ),
+      [t.stringLiteral(logicalId)],
+    ),
+  );
+
+  t.addComment(
+    ast,
+    "leading",
+    "This allows the Terraform resource name to match the original name. You can remove the call if you don't need them to match.",
+  );
+
+  return ast;
+}
+
+function getRemoteStateType(item: Resource) {
+  const backendRecord = item.find((val) => val.backend);
+  if (backendRecord) {
+    const backend = backendRecord.backend;
+    switch (backend) {
+      case "remote":
+        return "";
+      case "etcdv3":
+        return "_etcd_v3";
+      default:
+        return `_${backend}`;
+    }
+  } else {
+    return "";
+  }
+}
+
+function resourceType(provider: string, name: string[], item: Resource) {
+  switch (provider) {
+    case "data.terraform":
+      return `cdktn.data_terraform_${name.join("_")}${getRemoteStateType(
+        item,
+      )}`;
+    case "null":
+      return `NullProvider.${name.join("_")}`;
+    default:
+      return `${provider}.${name.join("_")}`;
+  }
+}
+
+function mapConfigPerResourceType(resource: string, item: Resource[0]) {
+  // Backends have a slightly different API
+  if (resource.startsWith("cdktn.data_terraform_")) {
+    return item.config;
+  }
+  return item;
+}
+
+const loopComment = `In most cases loops should be handled in the programming language context and
+not inside of the Terraform context. If you are looping over something external, e.g. a variable or a file input
+you should consider using a for loop. If you are looping over something only known to Terraform, e.g. a result of a data source
+you need to keep this like it is.`;
+export async function resource(
+  scope: ProgramScope,
+  type: string,
+  key: string,
+  id: string,
+  item: Resource,
+  graph: DirectedGraph,
+): Promise<t.Statement[]> {
+  const [provider, ...name] = type.split("_");
+  const resource = resourceType(provider, name, item);
+
+  if (!provider) {
+    throw new Error(`Could not parse resource type '${type}'`);
+  }
+  let expressions: t.Statement[] = [];
+  const varName = variableName(scope, resource, key);
+  const { for_each, count, provisioner, ...config } = item[0];
+  const mappedConfig = mapConfigPerResourceType(resource, config);
+
+  let forEachIteratorName: string | undefined;
+  if (for_each) {
+    forEachIteratorName = variableName(
+      scope,
+      resource,
+      `${key}_for_each_iterator`,
+    );
+    const referenceAst = await convertTerraformExpressionToTs(
+      scope,
+      `"${for_each}"`,
+      () => ["list", "dynamic"],
+    );
+
+    scope.importables.push({
+      provider: "cdktn",
+      constructName: "TerraformIterator",
+    });
+
+    const iterator = t.variableDeclaration("const", [
+      t.variableDeclarator(
+        t.identifier(forEachIteratorName),
+        t.callExpression(
+          t.memberExpression(
+            t.identifier("TerraformIterator"),
+            t.identifier("fromList"),
+          ),
+
+          [referenceAst],
+        ),
+      ),
+    ]);
+    t.addComment(iterator, "leading", loopComment);
+    expressions.push(iterator);
+
+    mappedConfig.forEach = t.identifier(forEachIteratorName);
+  }
+
+  let countIteratorName: string | undefined;
+  if (count) {
+    countIteratorName = variableName(scope, resource, `${key}_count`);
+    const referenceAst = await convertTerraformExpressionToTs(
+      scope,
+      `"${count}"`,
+      () => "number",
+    );
+
+    scope.importables.push({
+      provider: "cdktn",
+      constructName: "TerraformCount",
+    });
+
+    const iterator = t.variableDeclaration("const", [
+      t.variableDeclarator(
+        t.identifier(countIteratorName),
+        t.callExpression(
+          t.memberExpression(
+            t.identifier("TerraformCount"),
+            t.identifier("of"),
+          ),
+          [referenceAst],
+        ),
+      ),
+    ]);
+    t.addComment(iterator, "leading", loopComment);
+    mappedConfig.count = t.identifier(countIteratorName);
+    expressions.push(iterator);
+  }
+
+  const dynBlocks = extractDynamicBlocks(mappedConfig);
+  const nestedDynamicBlocks = dynBlocks.filter((block) =>
+    isNestedDynamicBlock(dynBlocks, block),
+  );
+  const dynamicBlocksUsingOverrides = dynBlocks.filter(
+    (block) =>
+      // nested blocks need overrides
+      nestedDynamicBlocks.includes(block) ||
+      // blocks that contain nested blocks need them as well
+      nestedDynamicBlocks.some((nestedBlock) =>
+        nestedBlock.path.startsWith(block.path),
+      ),
+  );
+  // all others can be handled by the CDKTN runtime
+  const dynamicBlocksUsingRuntime = dynBlocks.filter(
+    (block) => !dynamicBlocksUsingOverrides.includes(block),
+  );
+
+  for (const [i, block] of dynamicBlocksUsingRuntime.entries()) {
+    const dynamicBlockIteratorName = variableName(
+      scope,
+      resource,
+      `${key}_dynamic_iterator_${i}`,
+    );
+
+    const referenceAst = await convertTerraformExpressionToTs(
+      scope,
+      `"${block.for_each}"`,
+      () => ["list", "dynamic"],
+    );
+
+    scope.importables.push({
+      provider: "cdktn",
+      constructName: "TerraformIterator",
+    });
+
+    const iterator = t.variableDeclaration("const", [
+      t.variableDeclarator(
+        t.identifier(dynamicBlockIteratorName),
+        t.callExpression(
+          t.memberExpression(
+            t.identifier("TerraformIterator"),
+            t.identifier("fromList"),
+          ),
+          [referenceAst],
+        ),
+      ),
+    ]);
+    t.addComment(iterator, "leading", loopComment);
+    expressions.push(iterator);
+    const dynamicCallExpression = t.callExpression(
+      t.memberExpression(
+        t.identifier(dynamicBlockIteratorName),
+        t.identifier("dynamic"),
+      ),
+      [
+        await valueToTs(
+          {
+            ...scope,
+            scopedVariables: {
+              [block.scopedVar]: dynamicBlockIteratorName,
+            },
+          },
+          fillWithConfigAccessors(
+            scope,
+            Array.isArray(block.content) ? block.content[0] : block.content,
+            block.path.replace(block.scopedVar, ""),
+          ),
+          block.path.replace(block.scopedVar, ""),
+          false,
+        ),
+      ],
+    );
+
+    const parts = block.path
+      .replace(`dynamic.${block.scopedVar}`, "")
+      .split(".")
+      .filter((p) => p.length > 0);
+
+    const parent = parts.reduce((acc, part) => {
+      if (Array.isArray(acc) && !Number.isNaN(parseInt(part, 10))) {
+        return acc[parseInt(part, 10)];
+      } else {
+        return acc[part];
+      }
+    }, mappedConfig);
+    parent[block.scopedVar] = dynamicCallExpression;
+    delete parent.dynamic;
+  }
+
+  const overrideReference = dynamicBlocksUsingOverrides.length
+    ? {
+        start: 0,
+        end: 0,
+        referencee: {
+          id: `${type}.${key}`,
+          full: `${type}.${key}`,
+        },
+      }
+    : undefined;
+
+  if (provisioner) {
+    mappedConfig.provisioners = await Promise.all(
+      Object.entries(provisioner).flatMap(([type, p]: [string, any]) =>
+        p.map((pp: Record<string, any>) =>
+          valueToTs(
+            scope,
+            { type, ...pp },
+            "path-for-provisioners-can-be-ignored",
+          ),
+        ),
+      ),
+    );
+  }
+
+  const importGraphId = `import.${resource.replace(".", "_")}.${key}`;
+  const importDefinition: Import | undefined = graph.hasNode(importGraphId)
+    ? graph.getNodeAttribute(importGraphId, "value")
+    : undefined;
+
+  expressions = expressions.concat(
+    await asExpression(
+      { ...scope, forEachIteratorName, countIteratorName },
+      resource,
+      key,
+      mappedConfig,
+      false,
+      false,
+      getReference(graph, id) || overrideReference,
+      importDefinition,
+    ),
+  );
+
+  // Check for dynamic blocks
+  expressions = expressions.concat(
+    await Promise.all(
+      dynamicBlocksUsingOverrides.map(async ({ path, for_each, content }) => {
+        // We need to let the expression conversion know all available
+        // dynamic block names, so we don't replace them. The "dynamic-block"
+        // scoped variable indicates to the expression conversion to use the
+        // key name instead of an iterator
+        const scopedVariablesInPath = Object.fromEntries(
+          path
+            .substring(1) // The path starts with a dot that results in an empty split
+            .split(".")
+            .filter(
+              (p) => !["dynamic", "content"].includes(p) && isNaN(parseInt(p)),
+            )
+            .map((p) => [p, "dynamic-block"]),
+        );
+
+        return addOverrideExpression(
+          varName,
+          path.substring(1), // The path starts with a dot that we don't want
+          await valueToTs(
+            {
+              ...scope,
+              withinOverrideExpression: true,
+              scopedVariables: scopedVariablesInPath,
+            },
+            {
+              for_each,
+              content,
+            },
+            "path-for-dynamic-blocks-can-be-ignored",
+          ),
+          loopComment,
+        );
+      }),
+    ),
+  );
+
+  return expressions;
+}
+
+async function asExpression(
+  scope: ResourceScope,
+  type: string,
+  name: string,
+  config: TerraformResourceBlock,
+  isModuleImport: boolean,
+  isProvider: boolean,
+  reference?: Reference,
+  imported?: Import,
+) {
+  const { providers, ...otherOptions } = config as any;
+
+  const constructId = uniqueId(scope.constructs, name);
+  const overrideId = !isProvider && constructId !== name;
+
+  const completeObject = fillWithConfigAccessors(scope, otherOptions, type);
+
+  const expression = t.newExpression(
+    constructAst(scope, type, isModuleImport),
+    [
+      t.thisExpression(),
+      t.stringLiteral(constructId),
+
+      await valueToTs(
+        scope,
+        {
+          ...completeObject,
+          providers:
+            providers && Object.keys(providers).length
+              ? Object.entries(providers).map(([key, value]) => ({
+                  moduleAlias: key,
+                  provider: value,
+                }))
+              : undefined,
+        },
+        `${type}`,
+        isModuleImport,
+      ),
+    ],
+  );
+
+  const statements = [];
+  const varName = reference
+    ? referenceToVariableName(scope, reference)
+    : variableName(scope, type, name);
+
+  if (reference || overrideId || imported) {
+    statements.push(
+      t.variableDeclaration("const", [
+        t.variableDeclarator(t.identifier(varName), expression),
+      ]),
+    );
+  } else {
+    statements.push(t.expressionStatement(expression));
+  }
+
+  if (overrideId) {
+    statements.push(addOverrideLogicalIdExpression(varName, name));
+  }
+
+  if (imported) {
+    // Adds myVar.importFrom("my-arn")
+    const importExpression = t.expressionStatement(
+      t.callExpression(
+        t.memberExpression(t.identifier(varName), t.identifier("importFrom")),
+        [t.stringLiteral(imported.id)],
+      ),
+    );
+
+    if (imported.provider) {
+      t.addComment(
+        importExpression,
+        "leading",
+        `This import was configured with a provider. CDKTN does support this, but the cdktn convert command does not yet. Please add the provider reference manually. See https://cdktn.io/docs/concepts/resources#importing-resources for more information.`,
+      );
+    }
+
+    statements.push(importExpression);
+  }
+
+  return statements;
+}
+
+export async function output(
+  scope: ProgramScope,
+  key: string,
+  _id: string,
+  item: Output,
+  _graph: DirectedGraph,
+) {
+  const [{ value, description, sensitive }] = item;
+
+  return asExpression(
+    scope,
+    "cdktn.TerraformOutput",
+    key,
+    {
+      value,
+      description,
+      sensitive,
+    },
+    false,
+    false,
+    undefined,
+    undefined,
+  );
+}
+
+export async function variableTypeToAst(
+  scope: ProgramScope,
+  type: string,
+): Promise<t.Expression> {
+  const addVariableTypeToImports = () =>
+    scope.importables.push({
+      constructName: "VariableType",
+      provider: "cdktn",
+    });
+
+  function parsedTypeToAst(type: tex.ExpressionType): t.Expression {
+    if (tex.isScopeTraversalExpression(type)) {
+      addVariableTypeToImports();
+      switch (type.meta.value) {
+        case "string":
+          return t.identifier("VariableType.STRING");
+        case "number":
+          return t.identifier("VariableType.NUMBER");
+        case "bool":
+          return t.identifier("VariableType.BOOL");
+        case "any":
+        default:
+          return t.identifier("VariableType.ANY");
+      }
+    }
+
+    if (tex.isFunctionCallExpression(type)) {
+      addVariableTypeToImports();
+      switch (type.meta.name) {
+        case "list":
+        case "set":
+        case "map":
+        case "tuple":
+        case "object":
+          return t.callExpression(
+            t.identifier(`VariableType.${type.meta.name}`),
+            type.children.map((child) => parsedTypeToAst(child)),
+          );
+      }
+    }
+
+    if (tex.isObjectExpression(type)) {
+      return t.objectExpression(
+        Object.entries(type.meta.items).map(([key, value]) =>
+          t.objectProperty(
+            t.stringLiteral(key),
+            // This does not deal with complex types nested within objects
+            // If such a type is found it will result in an Any type
+            // e.g. { foo: list(string) } will result in { foo: any }
+            parsedTypeToAst({
+              type: "scopeTraversal",
+              meta: { value },
+            } as any),
+          ),
+        ),
+      );
+    }
+
+    addVariableTypeToImports();
+    return t.identifier("VariableType.ANY");
+  }
+
+  return parsedTypeToAst(await expressionAst(type));
+}
+
+export async function variable(
+  scope: ProgramScope,
+  key: string,
+  id: string,
+  item: Variable,
+  graph: DirectedGraph,
+) {
+  const [{ type, ...props }] = item;
+
+  if (!getReference(graph, id)) {
+    return [];
+  }
+
+  return asExpression(
+    scope,
+    id,
+    key,
+    { ...props, type: type ? await variableTypeToAst(scope, type) : undefined },
+    false,
+    false,
+    getReference(graph, id),
+    undefined,
+  );
+}
+
+export async function local(
+  scope: ProgramScope,
+  key: string,
+  id: string,
+  item: TerraformResourceBlock,
+  graph: DirectedGraph,
+): Promise<t.VariableDeclaration[]> {
+  logger.debug(`Initializing local resource ${key} with id ${id}`);
+  if (!getReference(graph, id)) {
+    logger.debug(`No reference found for ${key}`);
+    return [];
+  }
+  return [
+    t.variableDeclaration("const", [
+      t.variableDeclarator(
+        t.identifier(variableName(scope, "local", key)),
+        await valueToTs(scope, item, "path-for-local-blocks-can-be-ignored"),
+      ),
+    ]),
+  ];
+}
+
+export async function modules(
+  scope: ProgramScope,
+  key: string,
+  id: string,
+  item: Module,
+  graph: DirectedGraph,
+) {
+  const [{ source, version: _version, ...props }] = item;
+
+  const moduleConstraint = new TerraformModuleConstraint(source);
+
+  return asExpression(
+    scope,
+    moduleConstraint.className,
+    key,
+    props,
+    true,
+    false,
+    getReference(graph, id),
+    undefined,
+  );
+}
+
+export async function imports(
+  scope: ProgramScope,
+  _id: string,
+  item: Import,
+  graph: DirectedGraph,
+) {
+  // Move from ${aws_instance.example} to aws_instance.example
+  const target =
+    item.to.startsWith("${") && item.to.endsWith("}")
+      ? item.to.substring(2, item.to.length - 1)
+      : item.to;
+
+  // Check if the import goes into a module
+  if (target.startsWith("module.")) {
+    return [
+      t.addComment(
+        t.emptyStatement(),
+        "leading",
+        `CDKTN does not support imports into modules yet, please remove the import block importing ${item.id} into ${target} from your configuration`,
+      ),
+    ];
+  }
+
+  // We now know that the import goes into a resource, e.g. aws_instance.example
+  const [resourceTypeIdentifier, resourceName] = target.split(".");
+  if (resourceName.includes("[")) {
+    return [
+      t.addComment(
+        t.emptyStatement(),
+        "leading",
+        `CDKTN does not support imports into resources with count or for_each yet, please remove the import block importing ${item.id} into ${target} from your configuration`,
+      ),
+    ];
+  }
+
+  // Check if we have a existing resource config with the given name
+  if (graph.hasNode(target)) {
+    // We will handle this case in the resource function
+    // so we can skip over it
+    return [];
+  }
+
+  const [provider, ...resourceTypeNameParts] =
+    resourceTypeIdentifier.split("_");
+
+  const constructId = uniqueId(scope.constructs, camelCase(resourceName));
+  const constructClass = constructAst(
+    scope,
+    `${provider}.${resourceTypeNameParts.join("_")}`,
+    false,
+  );
+  return [
+    t.expressionStatement(
+      t.callExpression(
+        t.memberExpression(
+          constructClass,
+          t.identifier("generateConfigForImport"),
+        ),
+        [
+          t.thisExpression(),
+          t.stringLiteral(constructId),
+          t.stringLiteral(item.id),
+        ],
+      ),
+    ),
+  ];
+}
+
+export async function provider(
+  scope: ProgramScope,
+  key: string,
+  id: string,
+  item: Provider[0],
+  graph: DirectedGraph,
+) {
+  const { version: _version, ...props } = item;
+
+  const importKey = key === "null" ? "NullProvider" : key;
+
+  return asExpression(
+    scope,
+    `${importKey}.${pascalCase(key)}Provider`,
+    key,
+    props,
+    false,
+    true,
+    getReference(graph, id),
+    undefined,
+  );
+}
+
+export const cdktfImport = template(
+  `import * as cdktn from "cdktn"`,
+)() as t.Statement;
+
+export const constructsImport = template(
+  `import * as constructs from "constructs"`,
+)() as t.Statement;
+
+export const providerImports = (providers: string[]) =>
+  providers.map((providerName) => {
+    const parts = providerName.split("/");
+    const name = parts.length > 1 ? parts[1] : parts[0];
+    const importName = name === "null" ? "NullProvider" : name;
+    return template(
+      `import * as ${importName} from "./.gen/providers/${name.replace(
+        "./",
+        "",
+      )}"`,
+    )() as t.Statement;
+  });
+
+export const moduleImports = (modules: Record<string, Module> | undefined) => {
+  const uniqueModules = new Set<string>();
+  Object.values(modules || {}).map(([module]) =>
+    uniqueModules.add(module.source),
+  );
+
+  const imports: t.Statement[] = [];
+  uniqueModules.forEach((m) => {
+    const moduleConstraint = new TerraformModuleConstraint(m);
+    imports.push(
+      template.ast(
+        `import * as ${moduleConstraint.className} from "./.gen/modules/${moduleConstraint.fileName}"`,
+      ) as t.Statement,
+    );
+  });
+  return imports;
+};
+
+export async function gen(statements: t.Statement[]) {
+  logger.debug(`Generating code for ${JSON.stringify(statements, null, 2)}`);
+  const code = prettier.format(generate(t.program(statements) as any).code, {
+    parser: "babel",
+  });
+
+  logger.debug(`Generated code:\n${code}`);
+
+  return code;
+}
+
+export function addImportForCodeContainer(
+  scope: ProgramScope,
+  codeContainer: string,
+) {
+  switch (codeContainer) {
+    case "constructs.Construct":
+      scope.importables.push({
+        provider: "constructs",
+        constructName: "Construct",
+      });
+      break;
+
+    case "cdktn.TerraformStack":
+      scope.importables.push({
+        provider: "cdktn",
+        constructName: "TerraformStack",
+      });
+      break;
+
+    case "cdktf.TerraformStack":
+      scope.importables.push({
+        provider: "cdktf",
+        constructName: "TerraformStack",
+      });
+      break;
+    default:
+      throw Errors.Internal("Unsupported code container: " + codeContainer);
+  }
+}
+
+export function wrapCodeInConstructor(
+  codeContainer: string,
+  code: t.Statement[],
+  className: string,
+  configTypeName?: string,
+): t.Statement {
+  let baseContainerClass: t.Identifier;
+  switch (codeContainer) {
+    case "constructs.Construct":
+      baseContainerClass = t.identifier("Construct");
+      break;
+
+    case "cdktn.TerraformStack":
+      baseContainerClass = t.identifier("TerraformStack");
+      break;
+    default:
+      throw Errors.Internal("Unsupported code container: " + codeContainer);
+  }
+  if (configTypeName) {
+    return template.statement(
+      `
+  class %%className%% extends %%base%% {
+    constructor(scope: Construct, name: string, config: ${configTypeName}) {
+      super(scope, name);
+      %%code%%
+    }
+  }
+`,
+      { syntacticPlaceholders: true, plugins: ["typescript"] },
+    )({
+      code,
+      base: baseContainerClass,
+      className: t.identifier(className),
+    }) as t.Statement;
+  }
+  return template.statement(
+    `
+  class %%className%% extends %%base%% {
+    constructor(scope: Construct, name: string) {
+      super(scope, name);
+      %%code%%
+    }
+  }
+`,
+    { syntacticPlaceholders: true, plugins: ["typescript"] },
+  )({
+    code,
+    base: baseContainerClass,
+    className: t.identifier(className),
+  }) as t.Statement;
+}
+
+export const providerConstructImports = (importable: ImportableConstruct[]) => {
+  let provider = importable[0].provider;
+  let namespace = importable[0].namespace;
+  const names = importable.map((i) => i.constructName);
+
+  if (provider === "cdktn" || provider === "constructs") {
+    return template(
+      `import { ${names.join(", ")} } from "${provider}"`,
+    )() as t.Statement;
+  }
+
+  if (namespace) {
+    namespace = snakeCase(namespace).replace(/_/g, "-");
+  }
+
+  // Special cases to undo provider names that we override
+  if (provider === "NullProvider") {
+    provider = "null";
+  }
+
+  return template(
+    `import { ${names.join(
+      ", ",
+    )} } from "./.gen/providers/${provider}/${namespace}"`,
+  )() as t.Statement;
+};
+
+export function buildImports(importables: ImportableConstruct[]) {
+  const groupedImportables = importables.reduce(
+    (acc, importable) => {
+      const ns = importable.namespace || "";
+      // Doing some hacky ordering of the imports to make them look a bit nicer
+      const prefix =
+        importable.provider === "constructs"
+          ? "1"
+          : importable.provider === "cdktn"
+            ? "2"
+            : importable.provider === "cdktf"
+              ? "3"
+              : "4";
+      const groupName = `${prefix}.${importable.provider}.${ns}`;
+      const fullName = `${importable.provider}.${ns}.${importable.constructName}`;
+
+      if (acc[groupName]) {
+        const existsAlready = acc[groupName].some(
+          (importable) =>
+            `${importable.provider}.${ns}.${importable.constructName}` ===
+            fullName,
+        );
+        if (existsAlready) {
+          return acc;
+        }
+        acc[groupName].push(importable);
+        acc[groupName].sort();
+      } else {
+        acc[groupName] = [importable];
+      }
+
+      return acc;
+    },
+    {} as Record<string, ImportableConstruct[]>,
+  );
+
+  let commentAdded = false;
+  const constructImports = Object.keys(groupedImportables)
+    .sort()
+    .map((groupName) => {
+      const importStatement = providerConstructImports(
+        groupedImportables[groupName],
+      );
+
+      if (groupName.startsWith("4.") && !commentAdded) {
+        commentAdded = true;
+        t.addComment(
+          importStatement,
+          "leading",
+          `\n* Provider bindings are generated by running \`cdktn get\`.
+* See https://cdktn.io/docs/concepts/providers#import-providers for more details.\n`,
+        );
+      }
+      return importStatement;
+    });
+
+  return constructImports;
+}
+
+export function generateConfigType(
+  name: string,
+  config: Record<string, AttributePath>,
+): t.Statement {
+  return t.tsInterfaceDeclaration(
+    t.identifier(name),
+    undefined,
+    undefined,
+    t.tsInterfaceBody(
+      Object.entries(config).map(([key, _value]) =>
+        t.tsPropertySignature(
+          t.identifier(key),
+          t.tSTypeAnnotation(t.tsAnyKeyword()), // TODO: Try to make this better than any
+        ),
+      ),
+    ),
+  );
+}