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

package/src/expressions.ts

@@ -0,0 +1,968 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as t from "@babel/types";
+import template from "@babel/template";
+import { camelCase, fileBugCommentText, logger } from "./utils";
+import {
+  IteratorVariableReference,
+  ProgramScope,
+  ResourceScope,
+} from "./types";
+import { getReferencesInExpression, getExpressionAst } from "@cdktn/hcl2json";
+import {
+  TFExpressionSyntaxTree as tex,
+  wrapTerraformExpression,
+} from "@cdktn/hcl2json";
+import { functionsMap } from "./function-bindings/functions";
+import { coerceType, findExpressionType } from "./coerceType";
+import { AttributeType } from "@cdktn/commons";
+import { getTypeAtPath } from "./terraformSchema";
+import { containsReference } from "./references";
+import { variableName } from "./variables";
+
+const tfBinaryOperatorsToCdktf = {
+  logicalOr: "or",
+  logicalAnd: "and",
+  greaterThan: "gt",
+  greaterThanOrEqual: "gte",
+  lessThan: "lt",
+  lessThanOrEqual: "lte",
+  equal: "eq",
+  notEqual: "neq",
+  add: "add",
+  subtract: "sub",
+  multiply: "mul",
+  divide: "div",
+  modulo: "mod",
+};
+
+const tfUnaryOperatorsToCdktf = {
+  logicalNot: "not",
+  negate: "negate",
+};
+
+type supportedBinaryOperators = keyof typeof tfBinaryOperatorsToCdktf;
+type supportedUnaryOperators = keyof typeof tfUnaryOperatorsToCdktf;
+
+function traversalPartsToString(
+  traversals: tex.TerraformTraversalPart[],
+  asSuffix = false,
+) {
+  let seed = "";
+  if (asSuffix && tex.isNameTraversalPart(traversals[0])) {
+    seed = ".";
+  }
+  return traversals.reduce((acc, part) => {
+    if (part.type === "nameTraversal") {
+      if (acc === seed) {
+        return `${acc}${part.segment}`;
+      }
+      return `${acc}.${part.segment}`;
+    }
+    return `${acc}[${part.segment}]`;
+  }, seed);
+}
+
+function canUseFqn(expression: tex.ExpressionType) {
+  if (!tex.isScopeTraversalExpression(expression)) {
+    return false;
+  }
+
+  const rootSegment = expression.meta.traversal[0].segment;
+
+  return !["var", "local"].includes(rootSegment);
+}
+
+function traversalToVariableName(
+  scope: ProgramScope,
+  node: tex.ExpressionType,
+) {
+  if (!tex.isScopeTraversalExpression(node)) {
+    logger.error(
+      `Unexpected expression type ${node.type} with value ${node.meta.value} passed to convert to a variable. ${fileBugCommentText}`,
+    );
+    return "";
+  }
+
+  const segments = node.meta.traversal;
+  if (segments.length === 1) {
+    return node.meta.fullAccessor;
+  }
+  const rootSegment = segments[0].segment;
+  const resource =
+    rootSegment === "data"
+      ? `${segments[0].segment}.${segments[1].segment}`
+      : rootSegment;
+  const name =
+    rootSegment === "data" ? segments[2].segment : segments[1].segment;
+
+  return variableName(scope, resource, name);
+}
+
+function expressionForSerialStringConcatenation(
+  scope: ResourceScope,
+  nodes: t.Expression[],
+) {
+  const reducedNodes = nodes.reduce((acc, node) => {
+    const prev = acc[acc.length - 1];
+    if (!prev) return [node];
+
+    if (t.isStringLiteral(prev) && t.isStringLiteral(node)) {
+      acc.pop();
+      acc.push(t.stringLiteral(prev.value + node.value));
+      return acc;
+    }
+
+    acc.push(node);
+    return acc;
+  }, [] as t.Expression[]);
+
+  return reducedNodes.reduce(
+    (acc: t.Expression | undefined, node: t.Expression) => {
+      if (!acc) {
+        return node;
+      }
+
+      // wrap access to dynamic blocks in Token.asString() as they return a Lazy
+      // for .key and .value which can't be concatenated in languages like Python
+      // because JSII currently has no support for the toString() method in
+      // languages other than TypeScript: https://github.com/aws/jsii/issues/380
+      // example: dynamic_iterator0.key / dynamic_iterator0.value
+      if (
+        t.isMemberExpression(node) &&
+        t.isIdentifier(node.object) &&
+        Object.values(scope.scopedVariables || {}).includes(node.object.name) &&
+        t.isIdentifier(node.property) &&
+        ["key", "value"].includes(node.property.name)
+      ) {
+        node = coerceType(scope, node, "dynamic", "string");
+      }
+
+      return t.binaryExpression("+", acc as t.Expression, node);
+    },
+  );
+}
+
+function getTfResourcePathFromNode(node: tex.ScopeTraversalExpression) {
+  const segments = node.meta.traversal;
+  let resource = segments[0].segment;
+  let result = [];
+  let attributes = [];
+
+  if (segments[0].segment === "data") {
+    result.push(segments[0].segment);
+    resource = segments[1].segment;
+    attributes = segments.slice(3); // we want to skip the variable name
+  } else {
+    attributes = segments.slice(2); // we want to skip the variable name
+  }
+
+  const [provider, ...resourceNameFragments] = resource.split("_");
+
+  // Hack: This happens in the case of `external` provider
+  // where the data source does not have a provider name prefix
+  if (resourceNameFragments.length === 0) {
+    resourceNameFragments.push(provider);
+  }
+
+  result.push(provider);
+  result.push(resourceNameFragments.join("_"));
+  result = [
+    ...result,
+    ...attributes.map((seg) => {
+      if (tex.isIndexTraversalPart(seg)) {
+        return `[${seg.segment}]`;
+      }
+      return seg.segment;
+    }),
+  ];
+
+  return result.join(".");
+}
+
+function convertLiteralValueExpressionToTs(
+  _scope: ResourceScope,
+  node: tex.LiteralValueExpression,
+) {
+  const literalType = node.meta.type;
+  if (literalType === "number") {
+    return t.numericLiteral(Number(node.meta.value));
+  }
+  if (literalType === "bool") {
+    return t.booleanLiteral(node.meta.value === "true" ? true : false);
+  }
+
+  return t.stringLiteral(node.meta.value);
+}
+
+function convertScopeTraversalExpressionToTs(
+  scope: ResourceScope,
+  node: tex.ScopeTraversalExpression,
+) {
+  const hasReference = containsReference(node);
+
+  const segments = node.meta.traversal;
+
+  if (segments[0].segment === "each" && scope.forEachIteratorName) {
+    return dynamicVariableToAst(scope, node, scope.forEachIteratorName);
+  }
+
+  if (segments[0].segment === "count" && scope.countIteratorName) {
+    return dynamicVariableToAst(scope, node, scope.countIteratorName, "count");
+  }
+
+  if (segments[0].segment === "self") {
+    scope.importables.push({
+      constructName: "TerraformSelf",
+      provider: "cdktn",
+    });
+
+    return t.callExpression(
+      t.memberExpression(t.identifier("TerraformSelf"), t.identifier("getAny")),
+
+      [t.stringLiteral(traversalPartsToString(segments.slice(1)))],
+    );
+  }
+
+  // setting.value, setting.value[1].id
+  const dynamicBlock = scope.scopedVariables?.[segments[0].segment];
+  if (dynamicBlock) {
+    if (dynamicBlock === "dynamic-block") {
+      return dynamicVariableToAst(
+        scope,
+        node,
+        dynamicBlock,
+        traversalPartsToString(segments),
+      );
+    }
+    return dynamicVariableToAst(scope, node, dynamicBlock, segments[0].segment);
+  }
+
+  // This may be a variable reference that we don't understand yet, so we wrap it in a template string
+  // for Terraform to handle
+  let varIdentifier: t.Expression = t.stringLiteral(
+    `\${${node.meta.fullAccessor}}`,
+  );
+
+  if (hasReference) {
+    varIdentifier = t.identifier(
+      camelCase(traversalToVariableName(scope, node)),
+    );
+  }
+
+  if (["var", "local"].includes(segments[0].segment)) {
+    const variableAccessor =
+      segments[0].segment === "var"
+        ? t.memberExpression(varIdentifier, t.identifier("value"))
+        : varIdentifier;
+
+    if (segments.length > 2) {
+      scope.importables.push({
+        constructName: "Fn",
+        provider: "cdktn",
+      });
+      const callee = t.memberExpression(
+        t.identifier("Fn"),
+        t.identifier("lookupNested"),
+      );
+      return t.callExpression(callee, [
+        variableAccessor,
+        t.arrayExpression(
+          segments.slice(2).map((s) => t.stringLiteral(s.segment)),
+        ),
+      ]);
+    }
+
+    return variableAccessor;
+  }
+
+  if (!hasReference || scope.withinOverrideExpression) {
+    return varIdentifier;
+  }
+
+  const rootSegment = segments[0].segment;
+  const attributeIndex = rootSegment === "data" ? 3 : 2;
+  const attributeSegments = segments.slice(attributeIndex);
+  const numericAccessorIndex = attributeSegments.findIndex((seg) =>
+    tex.isIndexTraversalPart(seg),
+  );
+  let minAccessorIndex = numericAccessorIndex;
+  let mapAccessorIndex = -1;
+  if (numericAccessorIndex === -1) {
+    // only do this if we have to, if we already have a
+    // numeric accessor, we don't have to do this additional work
+    const resourcePath = getTfResourcePathFromNode(node);
+    let usingSubPathType = false;
+    const parts = resourcePath.split(".").filter((p) => p !== "");
+    const minParts = attributeIndex; // we need to stop before data.aws.resource_name or aws.resource_name
+    const originalParts = parts.length;
+    let hasMapAccessor = false;
+    while (parts.length >= minParts) {
+      const type = getTypeAtPath(scope.providerSchema, parts.join("."));
+      if (type !== null) {
+        if (Array.isArray(type) && type[0] === "map" && usingSubPathType) {
+          hasMapAccessor = true;
+          break;
+        }
+      }
+      parts.pop();
+      usingSubPathType = true;
+    }
+
+    if (hasMapAccessor) {
+      mapAccessorIndex = originalParts - parts.length - 1;
+      minAccessorIndex = mapAccessorIndex;
+    }
+  }
+
+  const needsPropertyAccess = minAccessorIndex >= 0;
+
+  const refSegments = needsPropertyAccess
+    ? attributeSegments.slice(0, minAccessorIndex)
+    : attributeSegments;
+  const nonRefSegments = needsPropertyAccess
+    ? attributeSegments.slice(minAccessorIndex)
+    : [];
+
+  const ref = refSegments.reduce(
+    (acc: t.Expression, seg, index) =>
+      t.memberExpression(
+        acc,
+        t.identifier(
+          index === 0 && rootSegment === "module"
+            ? camelCase(seg.segment + "Output")
+            : camelCase(seg.segment),
+        ),
+      ),
+    varIdentifier,
+  );
+
+  if (nonRefSegments.length === 0) {
+    return ref;
+  }
+
+  scope.importables.push({
+    constructName: "Fn",
+    provider: "cdktn",
+  });
+  const callee = t.memberExpression(
+    t.identifier("Fn"),
+    t.identifier("lookupNested"),
+  );
+  return t.callExpression(callee, [
+    ref,
+    t.arrayExpression(nonRefSegments.map((s) => t.stringLiteral(s.segment))),
+  ]);
+}
+
+function convertUnaryOpExpressionToTs(
+  scope: ResourceScope,
+  node: tex.UnaryOpExpression,
+) {
+  const operand = convertTFExpressionAstToTs(
+    scope,
+    tex.getChildWithValue(node, node.meta.valueExpression)!,
+  );
+
+  let fnName = node.meta.operator;
+  if (tfUnaryOperatorsToCdktf[fnName as supportedUnaryOperators]) {
+    fnName = tfUnaryOperatorsToCdktf[fnName as supportedUnaryOperators];
+  } else {
+    throw new Error(`Cannot convert unknown operator ${node.meta.operator}`);
+  }
+
+  scope.importables.push({
+    constructName: "Op",
+    provider: "cdktn",
+  });
+
+  const fn = t.memberExpression(t.identifier("Op"), t.identifier(fnName));
+
+  return t.callExpression(fn, [operand]);
+}
+
+function convertBinaryOpExpressionToTs(
+  scope: ResourceScope,
+  node: tex.BinaryOpExpression,
+) {
+  const left = convertTFExpressionAstToTs(
+    scope,
+    tex.getChildWithValue(node, node.meta.lhsExpression)!,
+  );
+  const right = convertTFExpressionAstToTs(
+    scope,
+    tex.getChildWithValue(node, node.meta.rhsExpression)!,
+  );
+
+  let fnName = node.meta.operator;
+  if (tfBinaryOperatorsToCdktf[fnName as supportedBinaryOperators]) {
+    fnName = tfBinaryOperatorsToCdktf[fnName as supportedBinaryOperators];
+  } else {
+    throw new Error(`Cannot convert unknown operator ${node.meta.operator}`);
+  }
+
+  scope.importables.push({
+    constructName: "Op",
+    provider: "cdktn",
+  });
+
+  const fn = t.memberExpression(t.identifier("Op"), t.identifier(fnName));
+  return t.callExpression(fn, [left, right]);
+}
+
+function convertTemplateExpressionToTs(
+  scope: ResourceScope,
+  node: tex.TemplateExpression | tex.TemplateWrapExpression,
+) {
+  const parts = node.children.map((child) => ({
+    node: child,
+    expr: convertTFExpressionAstToTs(scope, child),
+  }));
+
+  const lastPart = parts[parts.length - 1];
+  if (t.isStringLiteral(lastPart.expr) && lastPart.expr.value === "\n") {
+    // This is a bit of a hack, but the trailing newline we add due to
+    // heredocs looks ugly and unnecessary in the generated code, so we
+    // try to remove it
+    parts.pop();
+  }
+
+  if (parts.length === 0) {
+    return t.stringLiteral(node.meta.value);
+  }
+
+  if (parts.length === 1) {
+    return parts[0].expr;
+  }
+
+  let isScopedTraversal = false;
+  const expressions: t.Expression[] = [];
+  for (const { node, expr } of parts) {
+    if (
+      tex.isScopeTraversalExpression(node) &&
+      !t.isStringLiteral(expr) &&
+      !t.isCallExpression(expr)
+    ) {
+      expressions.push(t.stringLiteral("${"));
+      isScopedTraversal = true;
+    } else if (
+      // we should ideally be doing type coercion more
+      // carefully here, because it may not always be needed
+      t.isCallExpression(expr)
+    ) {
+      scope.importables.push({
+        constructName: "Token",
+        provider: "cdktn",
+      });
+
+      expressions.push(
+        template.expression(`Token.asString(%%expr%%)`)({
+          expr,
+        }) as t.Expression,
+      );
+      continue;
+    } else {
+      if (isScopedTraversal) {
+        expressions.push(t.stringLiteral("}"));
+        isScopedTraversal = false;
+      }
+    }
+    expressions.push(expr);
+  }
+
+  if (isScopedTraversal) {
+    expressions.push(t.stringLiteral("}"));
+  }
+
+  return expressionForSerialStringConcatenation(scope, expressions);
+}
+
+function convertObjectExpressionToTs(
+  scope: ResourceScope,
+  node: tex.ObjectExpression,
+) {
+  return t.objectExpression(
+    Object.entries(node.meta.items)
+      .map(([key, value]) => {
+        const valueChild = tex.getChildWithValue(node, value);
+        if (!valueChild) {
+          logger.error(`Unable to value for object key '${key}': ${value}`);
+          return null;
+        }
+
+        return t.objectProperty(
+          t.identifier(key),
+          convertTFExpressionAstToTs(scope, valueChild),
+        );
+      })
+      .filter((s) => s !== null) as t.ObjectProperty[],
+  );
+}
+
+function convertFunctionCallExpressionToTs(
+  scope: ResourceScope,
+  node: tex.FunctionCallExpression,
+) {
+  const functionName = node.meta.name;
+  const mapping = functionsMap[functionName];
+
+  if (!mapping) {
+    logger.error(
+      `Unknown function ${functionName} encountered. ${fileBugCommentText}`,
+    );
+    const argumentExpressions = node.children.map((child) =>
+      convertTFExpressionAstToTs(scope, child),
+    );
+
+    return t.callExpression(t.identifier(functionName), argumentExpressions);
+  }
+
+  const transformedNode: tex.FunctionCallExpression = mapping.transformer
+    ? mapping.transformer(node)
+    : node;
+
+  const argumentExpressions = transformedNode.children.map((child) =>
+    convertTFExpressionAstToTs(scope, child),
+  );
+
+  scope.importables.push({
+    constructName: "Fn",
+    provider: "cdktn",
+  });
+
+  const callee = t.memberExpression(
+    t.identifier("Fn"),
+    t.identifier(mapping.name),
+  );
+
+  if (
+    mapping.parameters.length > 0 &&
+    mapping.parameters[mapping.parameters.length - 1].variadic
+  ) {
+    const lastParameterType =
+      mapping.parameters[mapping.parameters.length - 1].type;
+    const nonVariadicArguments = argumentExpressions.slice(
+      0,
+      mapping.parameters.length - 1,
+    );
+
+    const fnCallArguments = [
+      ...nonVariadicArguments.map((argExpr, index) =>
+        coerceType(
+          scope,
+          argExpr,
+          findExpressionType(scope, argExpr),
+          mapping.parameters[index].type,
+        ),
+      ),
+
+      t.arrayExpression(
+        argumentExpressions
+          .slice(mapping.parameters.length - 1)
+          .map((argExpr) =>
+            coerceType(
+              scope,
+              argExpr,
+              findExpressionType(scope, argExpr),
+              lastParameterType,
+            ),
+          ),
+      ),
+    ];
+
+    return t.callExpression(callee, fnCallArguments);
+  }
+
+  return t.callExpression(
+    callee,
+    argumentExpressions.map((argExpr, index) =>
+      coerceType(
+        scope,
+        argExpr,
+        findExpressionType(scope, argExpr),
+        mapping.parameters[index].type,
+      ),
+    ),
+  );
+}
+
+function convertIndexExpressionToTs(
+  scope: ResourceScope,
+  node: tex.IndexExpression,
+) {
+  const collectionExpressionChild = tex.getChildWithValue(
+    node,
+    node.meta.collectionExpression,
+  );
+  const keyExpressionChild = tex.getChildWithValue(
+    node,
+    node.meta.keyExpression,
+  );
+
+  const collectionExpression = convertTFExpressionAstToTs(
+    scope,
+    collectionExpressionChild!,
+  );
+  const keyExpression = convertTFExpressionAstToTs(scope, keyExpressionChild!);
+
+  scope.importables.push({
+    constructName: "Fn",
+    provider: "cdktn",
+  });
+  const callee = t.memberExpression(
+    t.identifier("Fn"),
+    t.identifier("lookupNested"),
+  );
+  return t.callExpression(callee, [
+    collectionExpression,
+    t.arrayExpression([keyExpression]),
+  ]);
+}
+
+function convertSplatExpressionToTs(
+  scope: ResourceScope,
+  node: tex.SplatExpression,
+) {
+  const sourceExpressionChild = tex.getChildWithValue(
+    node,
+    node.meta.sourceExpression,
+  )!;
+  const sourceExpression = convertTFExpressionAstToTs(
+    scope,
+    sourceExpressionChild,
+  );
+
+  // We don't convert the relative expression because everything after the splat is going to be
+  // a string
+  const relativeExpression = node.meta.eachExpression.startsWith(
+    node.meta.anonSymbolExpression,
+  )
+    ? node.meta.eachExpression.slice(node.meta.anonSymbolExpression.length)
+    : node.meta.eachExpression;
+
+  const segments = relativeExpression.split(/\.|\[|\]/).filter((s) => s);
+  scope.importables.push({
+    constructName: "Fn",
+    provider: "cdktn",
+  });
+  const callee = t.memberExpression(
+    t.identifier("Fn"),
+    t.identifier("lookupNested"),
+  );
+
+  return t.callExpression(callee, [
+    sourceExpression,
+    t.arrayExpression([
+      // we don't need to use the anonSymbolExpression here because
+      // it only changes between .* and [*] which we don't care about
+      t.stringLiteral("*"),
+      ...segments.map(t.stringLiteral),
+    ]),
+  ]);
+}
+
+function convertConditionalExpressionToTs(
+  scope: ResourceScope,
+  node: tex.ConditionalExpression,
+) {
+  const conditionChild = tex.getChildWithValue(
+    node,
+    node.meta.conditionExpression,
+  )!;
+  let condition = convertTFExpressionAstToTs(scope, conditionChild);
+  if (t.isIdentifier(condition) && canUseFqn(conditionChild)) {
+    // We have a resource or data source here, which we would need to
+    // reference using fqn
+    condition = t.memberExpression(condition, t.identifier("fqn"));
+  }
+
+  const trueExpression = convertTFExpressionAstToTs(
+    scope,
+    tex.getChildWithValue(node, node.meta.trueExpression)!,
+  );
+
+  const falseExpression = convertTFExpressionAstToTs(
+    scope,
+    tex.getChildWithValue(node, node.meta.falseExpression)!,
+  );
+
+  scope.importables.push({
+    constructName: "conditional",
+    provider: "cdktn",
+  });
+
+  return t.callExpression(t.identifier("conditional"), [
+    condition,
+    trueExpression,
+    falseExpression,
+  ]);
+}
+
+function convertTupleExpressionToTs(
+  scope: ResourceScope,
+  node: tex.TupleExpression,
+) {
+  const expressions = node.children.map((child) =>
+    convertTFExpressionAstToTs(scope, child),
+  );
+
+  return t.arrayExpression(expressions);
+}
+
+function convertRelativeTraversalExpressionToTs(
+  scope: ResourceScope,
+  node: tex.RelativeTraversalExpression,
+) {
+  const segments = node.meta.traversal;
+
+  // The left hand side / source of a relative traversal is not a proper
+  // object / resource / data thing that is being referenced
+  const source = convertTFExpressionAstToTs(
+    scope,
+    tex.getChildWithValue(node, node.meta.sourceExpression)!,
+  );
+
+  scope.importables.push({
+    constructName: "Fn",
+    provider: "cdktn",
+  });
+  const callee = t.memberExpression(
+    t.identifier("Fn"),
+    t.identifier("lookupNested"),
+  );
+
+  return t.callExpression(callee, [
+    source,
+    t.arrayExpression(segments.map((s) => t.stringLiteral(s.segment))),
+  ]);
+}
+
+function convertForExpressionToTs(
+  scope: ResourceScope,
+  node: tex.ForExpression,
+) {
+  const collectionChild = tex.getChildWithValue(
+    node,
+    node.meta.collectionExpression,
+  )!;
+
+  let collectionExpression = convertTFExpressionAstToTs(scope, collectionChild);
+
+  if (t.isIdentifier(collectionExpression) && canUseFqn(collectionChild)) {
+    // We have a resource or data source here, which we would need to
+    // reference using fqn
+    collectionExpression = t.memberExpression(
+      collectionExpression,
+      t.identifier("fqn"),
+    );
+  }
+
+  const collectionRequiresWrapping = !t.isStringLiteral(collectionExpression);
+  const expressions = [];
+  const conditionBody = node.meta.keyVar
+    ? `${node.meta.keyVar}, ${node.meta.valVar}`
+    : node.meta.valVar;
+
+  const openBrace = node.meta.openRangeValue;
+  const closeBrace = node.meta.closeRangeValue;
+  const grouped = node.meta.groupedValue ? "..." : "";
+  const valueExpression = `${node.meta.valueExpression}${grouped}`;
+
+  const prefix = `\${${openBrace} for ${conditionBody} in `;
+  const keyValue = node.meta.keyExpression
+    ? ` : ${node.meta.keyExpression} => ${valueExpression}`
+    : ` : ${valueExpression}`;
+  const conditional = node.meta.conditionalExpression;
+  const suffix = `${keyValue}${
+    conditional ? ` if ${conditional}` : ""
+  }${closeBrace}}`;
+
+  expressions.push(t.stringLiteral(prefix));
+  if (collectionRequiresWrapping) {
+    expressions.push(t.stringLiteral("${"));
+  }
+  expressions.push(collectionExpression);
+  if (collectionRequiresWrapping) {
+    expressions.push(t.stringLiteral("}"));
+  }
+  expressions.push(t.stringLiteral(suffix));
+
+  return expressionForSerialStringConcatenation(scope, expressions);
+}
+
+function convertTFExpressionAstToTs(
+  scope: ResourceScope,
+  node: tex.ExpressionType,
+): t.Expression {
+  if (tex.isLiteralValueExpression(node)) {
+    return convertLiteralValueExpressionToTs(scope, node);
+  }
+
+  if (tex.isScopeTraversalExpression(node)) {
+    return convertScopeTraversalExpressionToTs(scope, node);
+  }
+
+  if (tex.isUnaryOpExpression(node)) {
+    return convertUnaryOpExpressionToTs(scope, node);
+  }
+
+  if (tex.isBinaryOpExpression(node)) {
+    return convertBinaryOpExpressionToTs(scope, node);
+  }
+
+  if (tex.isTemplateExpression(node) || tex.isTemplateWrapExpression(node)) {
+    return convertTemplateExpressionToTs(scope, node);
+  }
+
+  if (tex.isObjectExpression(node)) {
+    return convertObjectExpressionToTs(scope, node);
+  }
+
+  if (tex.isFunctionCallExpression(node)) {
+    return convertFunctionCallExpressionToTs(scope, node);
+  }
+
+  if (tex.isIndexExpression(node)) {
+    return convertIndexExpressionToTs(scope, node);
+  }
+
+  if (tex.isSplatExpression(node)) {
+    return convertSplatExpressionToTs(scope, node);
+  }
+
+  if (tex.isConditionalExpression(node)) {
+    return convertConditionalExpressionToTs(scope, node);
+  }
+
+  if (tex.isTupleExpression(node)) {
+    return convertTupleExpressionToTs(scope, node);
+  }
+
+  if (tex.isRelativeTraversalExpression(node)) {
+    return convertRelativeTraversalExpressionToTs(scope, node);
+  }
+
+  if (tex.isForExpression(node)) {
+    return convertForExpressionToTs(scope, node);
+  }
+
+  return t.stringLiteral("");
+}
+
+export async function expressionAst(
+  input: string,
+): Promise<tex.ExpressionType> {
+  const { wrap, wrapOffset } = wrapTerraformExpression(input);
+  const ast = await getExpressionAst("main.tf", wrap);
+
+  if (!ast) {
+    throw new Error(`Unable to parse terraform expression: ${input}`);
+  }
+
+  if (wrapOffset != 0 && tex.isTemplateWrapExpression(ast)) {
+    return ast.children[0];
+  }
+
+  return ast;
+}
+
+export async function convertTerraformExpressionToTs(
+  scope: ResourceScope,
+  input: string,
+  targetType: () => AttributeType,
+): Promise<t.Expression> {
+  logger.debug(`convertTerraformExpressionToTs(${input})`);
+  const tsExpression = convertTFExpressionAstToTs(
+    scope,
+    await expressionAst(input),
+  );
+
+  return coerceType(
+    scope,
+    tsExpression,
+    findExpressionType(scope, tsExpression),
+    targetType(),
+  );
+}
+
+export async function extractIteratorVariablesFromExpression(
+  input: string,
+): Promise<IteratorVariableReference[]> {
+  const possibleVariableSpots = await getReferencesInExpression(
+    "main.tf",
+    input,
+  );
+
+  return possibleVariableSpots
+    .filter((spot) => spot.value.startsWith("each."))
+    .map((spot) => ({
+      start: spot.startPosition,
+      end: spot.endPosition,
+      value: spot.value,
+    }));
+}
+
+export function dynamicVariableToAst(
+  scope: ProgramScope,
+  node: tex.ScopeTraversalExpression,
+  iteratorName: string,
+  block: string = "each",
+): t.Expression {
+  if (iteratorName === "dynamic-block") {
+    return expressionForSerialStringConcatenation(scope, [
+      t.stringLiteral("${"),
+      t.stringLiteral(block),
+      t.stringLiteral("}"),
+    ]);
+  }
+  if (node.meta.value === `${block}.key`) {
+    return t.memberExpression(t.identifier(iteratorName), t.identifier("key"));
+  }
+  if (node.meta.value === `${block}.value`) {
+    return t.memberExpression(
+      t.identifier(iteratorName),
+      t.identifier("value"),
+    );
+  }
+
+  if (block === "count" && node.meta.value === `${block}.index`) {
+    return t.memberExpression(
+      t.identifier(iteratorName),
+      t.identifier("index"),
+    );
+  }
+
+  const segments = node.meta.traversal;
+
+  if (
+    segments.length > 2 &&
+    segments[0].segment === block &&
+    segments[1].segment === "value"
+  ) {
+    const segmentsAfterEachValue = segments.slice(2);
+    scope.importables.push({
+      constructName: "Fn",
+      provider: "cdktn",
+    });
+    const callee = t.memberExpression(
+      t.identifier("Fn"),
+      t.identifier("lookupNested"),
+    );
+    return t.callExpression(callee, [
+      t.memberExpression(t.identifier(iteratorName), t.identifier("value")),
+      t.arrayExpression(
+        segmentsAfterEachValue.map((part) => {
+          if (part.type === "nameTraversal") {
+            return t.stringLiteral(part.segment);
+          } else {
+            return t.stringLiteral(`[${part.segment}]`);
+          }
+        }),
+      ),
+    ]);
+  }
+
+  throw new Error(
+    `Can not create AST for iterator variable of '${node.meta.value}'`,
+  );
+}