@cdktn/hcl2cdk 0.24.0-pre.43 → 0.24.0-pre.47

package/src/__tests__/terraformSchema.test.ts

@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import { ProviderSchema } from "@cdktn/commons";
+import { getTypeAtPath } from "../terraformSchema";
+
+describe("getTypeAtPath", () => {
+  const schema: ProviderSchema = {
+    provider_schemas: {
+      test: {
+        provider: {} as any,
+        data_source_schemas: {},
+        resource_schemas: {
+          test_resource: {
+            version: 1,
+            block: {
+              attributes: {
+                stringAttribute: {
+                  type: "string",
+                },
+                numberAttribute: {
+                  type: "number",
+                },
+                booleanAttribute: {
+                  type: "bool",
+                },
+                stringListAttribute: {
+                  type: ["list", "string"],
+                },
+                stringSetAttribute: {
+                  type: ["set", "string"],
+                },
+                stringMapAttribute: {
+                  type: ["map", "string"],
+                },
+                stringListListAttribute: {
+                  type: ["list", ["list", "string"]],
+                },
+                objectAttribute: {
+                  type: [
+                    "object",
+                    {
+                      stringAttribute: "string",
+                    },
+                  ],
+                },
+              },
+              block_types: {
+                listMode: {
+                  nesting_mode: "list",
+                  block: {
+                    attributes: {
+                      stringAttribute: {
+                        type: "string",
+                      },
+                    },
+                    block_types: {
+                      listMode: {
+                        nesting_mode: "list",
+                        block: {
+                          attributes: {
+                            stringAttribute: {
+                              type: "string",
+                            },
+                          },
+                          block_types: {},
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  };
+
+  it("should return null if it can not find the resource", () => {
+    expect(getTypeAtPath(schema, "test.nonExistantResource")).toBeNull();
+  });
+  it("should return null if it can not find the attribute on the resource", () => {
+    expect(getTypeAtPath(schema, "test.resource.ponyfoo")).toBeNull();
+  });
+
+  describe("known types", () => {
+    it.each([
+      ["stringAttribute", "string"],
+      ["numberAttribute", "number"],
+      ["booleanAttribute", "bool"],
+      ["stringListAttribute", ["list", "string"]],
+      ["stringSetAttribute", ["set", "string"]],
+      ["stringMapAttribute", ["map", "string"]],
+      ["stringMapAttribute.whateverkey", "string"],
+      ["stringListListAttribute", ["list", ["list", "string"]]],
+      ["stringListListAttribute.[]", ["list", "string"]],
+      ["stringListListAttribute.[].[]", "string"],
+      ["listMode.[].listMode.[].stringAttribute", "string"],
+      ["objectAttribute.stringAttribute", "string"],
+    ])(`access to %s returns %s`, (attr, res) => {
+      expect(getTypeAtPath(schema, `test.resource.${attr}`)).toEqual(res);
+    });
+  });
+});

package/src/__tests__/testHelpers.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+
+export function astToCode(e: t.Expression): string {
+  return generate(e as any).code;
+}

package/src/coerceType.ts

@@ -0,0 +1,261 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import template from "@babel/template";
+import * as t from "@babel/types";
+import { logger, AttributeType } from "@cdktn/commons";
+import { ProgramScope } from "./types";
+import deepEqual from "deep-equal";
+import { tsFunctionsMap } from "./function-bindings/functions";
+import { getTypeAtPath } from "./terraformSchema";
+import { toSnakeCase } from "codemaker";
+
+function changeValueAccessor(
+  ast: t.MemberExpression,
+  newAccessor: string,
+): t.MemberExpression {
+  const propertyIdentifier: t.Identifier = {
+    ...(ast.property as t.Identifier),
+    name: newAccessor,
+  };
+  return {
+    ...ast,
+    property: propertyIdentifier,
+  };
+}
+
+export function typeForCallExpression(ast: t.CallExpression): AttributeType {
+  // Find all cdktf.Fn.* || cdktn.Fn.* calls
+  if (
+    t.isMemberExpression(ast.callee) &&
+    t.isMemberExpression(ast.callee.object) &&
+    t.isIdentifier(ast.callee.object.object) &&
+    (ast.callee.object.object.name === "cdktf" ||
+      ast.callee.object.object.name === "cdktn") &&
+    t.isIdentifier(ast.callee.object.property) &&
+    ast.callee.object.property.name === "Fn" &&
+    t.isIdentifier(ast.callee.property)
+  ) {
+    const meta = tsFunctionsMap[ast.callee.property.name];
+    if (meta) {
+      return meta.returnType;
+    } else {
+      return "dynamic";
+    }
+  }
+
+  // cdktf.conditional, cdktf.propertyAccess, cdktf.Op.* are all dynamic
+  // By default we assume dynamic
+  return "dynamic";
+}
+
+export const coerceType = (
+  scope: ProgramScope,
+  ast: t.Expression,
+  from: AttributeType,
+  to: AttributeType | undefined,
+): t.Expression => {
+  if (to === undefined) {
+    return ast;
+  }
+
+  if (deepEqual(to, from)) {
+    return ast;
+  }
+
+  const isTerraformVariableOrLocal =
+    ast.type === "MemberExpression" &&
+    ast.property.type === "Identifier" &&
+    ast.property.name === "value" &&
+    ast.object.type === "Identifier" &&
+    Object.values(scope.variables).some(
+      (knownVars) =>
+        knownVars.variableName === (ast.object as t.Identifier).name &&
+        ["var", "local"].includes(knownVars.resource),
+    );
+
+  const addTokenToImports = () =>
+    scope.importables.push({
+      constructName: "Token",
+      provider: "cdktn",
+    });
+
+  if (Array.isArray(to)) {
+    if (to[0] === "list" || to[0] === "set") {
+      switch (to[1]) {
+        case "string":
+          if (isTerraformVariableOrLocal) {
+            return changeValueAccessor(ast as t.MemberExpression, "listValue");
+          }
+
+          addTokenToImports();
+          return template.expression(`Token.asList(%%ast%%)`)({
+            ast: ast,
+          }) as t.Expression;
+        case "number":
+          addTokenToImports();
+          return template.expression(`Token.asNumberList(%%ast%%)`)({
+            ast: ast,
+          }) as t.Expression;
+        case "bool":
+          addTokenToImports();
+          return template.expression(`Token.asAny(%%ast%%)`)({
+            ast: ast,
+          }) as t.Expression;
+        default:
+          addTokenToImports();
+          return template.expression(`Token.asAny(%%ast%%)`)({
+            ast: ast,
+          }) as t.Expression;
+      }
+    }
+
+    if (to[0] === "map") {
+      switch (to[1]) {
+        case "string":
+          addTokenToImports();
+          return template.expression(`Token.asStringMap(%%ast%%)`)({
+            ast: ast,
+          }) as t.Expression;
+        case "number":
+          addTokenToImports();
+          return template.expression(`Token.asNumberMap(%%ast%%)`)({
+            ast: ast,
+          }) as t.Expression;
+        case "bool":
+          addTokenToImports();
+          return template.expression(`Token.asBooleanMap(%%ast%%)`)({
+            ast: ast,
+          }) as t.Expression;
+        default:
+          addTokenToImports();
+          return template.expression(`Token.asAnyMap(%%ast%%)`)({
+            ast: ast,
+          }) as t.Expression;
+      }
+    }
+  }
+
+  switch (to) {
+    case "number":
+      if (isTerraformVariableOrLocal) {
+        return changeValueAccessor(ast as t.MemberExpression, "numberValue");
+      }
+      addTokenToImports();
+      return template.expression(`Token.asNumber(%%ast%%)`)({
+        ast: ast,
+      }) as t.Expression;
+    case "string":
+      if (isTerraformVariableOrLocal) {
+        return changeValueAccessor(ast as t.MemberExpression, "stringValue");
+      }
+      addTokenToImports();
+      return template.expression(`Token.asString(%%ast%%)`)({
+        ast: ast,
+      }) as t.Expression;
+    case "bool":
+      if (isTerraformVariableOrLocal) {
+        return changeValueAccessor(ast as t.MemberExpression, "booleanValue");
+      }
+      addTokenToImports();
+      return template.expression(`Token.asBoolean(%%ast%%)`)({
+        ast: ast,
+      }) as t.Expression;
+  }
+
+  logger.debug(`Could not coerce from ${from} to ${to} for ${ast}`);
+  return ast;
+};
+
+export function findExpressionType(
+  scope: ProgramScope,
+  ast: t.Expression,
+): AttributeType {
+  const isReferenceWithoutTemplateString =
+    ast.type === "MemberExpression" && ast.object.type === "Identifier";
+
+  // If we have a property to cdktf.propertyAccess call it's dynamic
+  if (ast.type === "CallExpression") {
+    return typeForCallExpression(ast);
+  }
+
+  if (ast.type === "StringLiteral") {
+    return "string";
+  }
+  if (ast.type === "NumericLiteral") {
+    return "number";
+  }
+  if (ast.type === "BooleanLiteral") {
+    return "bool";
+  }
+
+  // If we only have one reference this is a
+  if (isReferenceWithoutTemplateString) {
+    const destructuredAst = destructureAst(ast);
+    if (!destructuredAst) {
+      logger.debug(
+        `Could not destructure ast: ${JSON.stringify(ast, null, 2)}`,
+      );
+      return "dynamic";
+    }
+
+    const [astVariableName, ...attributes] = destructuredAst;
+    const variable = Object.values(scope.variables).find(
+      (x) => x.variableName === astVariableName,
+    );
+
+    if (!variable) {
+      logger.debug(
+        `Could not find variable ${astVariableName} given scope: ${JSON.stringify(
+          scope.variables,
+          null,
+          2,
+        )}`,
+      );
+      // We don't know, this should not happen, but if it does we assume the worst case and make it dynamic
+      return "dynamic";
+    }
+
+    if (variable.resource === "var") {
+      return "dynamic";
+    }
+
+    const { resource: resourceType } = variable;
+    const [provider, ...resourceNameFragments] = resourceType.split("_");
+    const tfResourcePath = `${provider}.${resourceNameFragments.join(
+      "_",
+    )}.${attributes.map((x) => toSnakeCase(x)).join(".")}`;
+    const type = getTypeAtPath(scope.providerSchema, tfResourcePath);
+
+    // If this is an attribute type we can return it
+    if (typeof type === "string" || Array.isArray(type)) {
+      return type;
+    }
+
+    // Either nothing is found or it's a block type
+    return "dynamic";
+  }
+
+  return "string";
+}
+
+/*
+ * Transforms a babel AST into a list of string accessors
+ * e.g. foo.bar.baz -> ["foo", "bar", "baz"]
+ */
+function destructureAst(ast: t.Expression): string[] | undefined {
+  switch (ast.type) {
+    case "Identifier":
+      return [ast.name];
+    case "MemberExpression": {
+      const object = destructureAst(ast.object);
+      const property = destructureAst(ast.property as t.Expression);
+      if (object && property) {
+        return [...object, ...property];
+      } else {
+        return undefined;
+      }
+    }
+    default:
+      return undefined;
+  }
+}

package/src/dynamic-blocks.ts

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import { DynamicBlock, TerraformResourceBlock } from "./types";
+
+export function isNestedDynamicBlock(
+  dynBlocks: DynamicBlock[],
+  block: DynamicBlock,
+): boolean {
+  return dynBlocks.some(
+    (dyn) => dyn.path !== block.path && block.path.startsWith(dyn.path),
+  );
+}
+
+export const extractDynamicBlocks = (
+  config: TerraformResourceBlock,
+  path = "",
+): DynamicBlock[] => {
+  if (typeof config !== "object") {
+    return [];
+  }
+
+  if (!config) {
+    return [];
+  }
+
+  if (Array.isArray(config)) {
+    return config.reduce(
+      (carry, item, index) => [
+        ...carry,
+        ...extractDynamicBlocks(item, `${path}.${index}`),
+      ],
+      [],
+    );
+  }
+
+  if ("dynamic" in config) {
+    const dynamic = (config as any).dynamic;
+    const scopedVar = Object.keys(dynamic)[0];
+    const { for_each, content } = dynamic[scopedVar][0];
+
+    return [
+      {
+        path: `${path}.dynamic.${scopedVar}`,
+        for_each,
+        content,
+        scopedVar,
+      },
+      ...extractDynamicBlocks(
+        content,
+        `${path}.dynamic.${scopedVar}.0.content`,
+      ),
+    ];
+  }
+
+  return Object.entries(config).reduce((carry, [key, value]) => {
+    return [...carry, ...extractDynamicBlocks(value as any, `${path}.${key}`)];
+  }, [] as DynamicBlock[]);
+};