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

package/src/__tests__/expressions.test.ts

@@ -0,0 +1,541 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+import { dynamicVariableToAst } from "../expressions";
+import { ProgramScope, Reference } from "../types";
+import {
+  extractReferencesFromExpression,
+  referenceToVariableName,
+} from "../references";
+import { getExpressionAst } from "@cdktn/hcl2json";
+import { TFExpressionSyntaxTree as tex } from "@cdktn/hcl2json";
+import { camelCase } from "../utils";
+
+const nodeIds = [
+  "var.input",
+  "module.vpc",
+  "data.aws_s3_bucket.examplebucket",
+  "aws_s3_bucket.examplebucket",
+  "aws_s3_bucket.otherbucket",
+  "var.users",
+  "aws_kms_key.key",
+  "local.service_name",
+];
+
+// Transforms a path with segments into literals describing the path
+function getPropertyAccessPath(input: string): string[] {
+  return input
+    .split(/(\[|\]|\.)/g)
+    .filter((p) => p.length > 0 && p !== "." && p !== "[" && p !== "]")
+    .map((p) => (p.startsWith(`"`) && p.endsWith(`"`) ? p.slice(1, -1) : p));
+}
+
+export function referenceToAst(scope: ProgramScope, ref: Reference) {
+  const [resource, , ...selector] = ref.referencee.full.split(".");
+
+  const variableReference = t.identifier(
+    camelCase(referenceToVariableName(scope, ref)),
+  );
+
+  if (resource === "data") {
+    selector.shift(); // remove the data part so that the name is not used in the selector
+  }
+
+  const accessor = selector.reduce(
+    (carry, member, index) =>
+      t.memberExpression(
+        carry,
+        t.identifier(
+          index === 0 && resource === "module"
+            ? camelCase(member + "Output")
+            : camelCase(member),
+        ),
+      ),
+    variableReference as t.Expression,
+  );
+
+  if (ref.useFqn) {
+    return t.memberExpression(accessor, t.identifier("fqn"));
+  }
+
+  if (ref.isVariable) {
+    return t.memberExpression(accessor, t.identifier("value"));
+  }
+  return accessor;
+}
+
+describe("expressions", () => {
+  describe("#extractReferencesFromExpression", () => {
+    it("finds no references in literals", () => {
+      return expect(
+        extractReferencesFromExpression("nothingtobeseen", nodeIds),
+      ).resolves.toEqual([]);
+    });
+
+    it("finds no references in literals with functions", () => {
+      return expect(
+        extractReferencesFromExpression("${foo(nothingtobeseen)}", nodeIds),
+      ).resolves.toEqual([]);
+    });
+
+    it("finds no references in literals with functions and artihmetics", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${foo(nothingtobeseen - 2) + 3}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([]);
+    });
+
+    it("finds plain var reference", () => {
+      return expect(
+        extractReferencesFromExpression("${var.input}", nodeIds),
+      ).resolves.toEqual([
+        {
+          referencee: { id: "var.input", full: "var.input" },
+          useFqn: false,
+          isVariable: true,
+          start: 2,
+          end: 11,
+        },
+      ]);
+    });
+
+    it("finds plain module reference", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${module.vpc.public_subnets}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "module.vpc",
+            full: "module.vpc.public_subnets",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 2,
+          end: 27,
+        },
+      ]);
+    });
+
+    it("finds plain data reference", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${data.aws_s3_bucket.examplebucket.arn}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "data.aws_s3_bucket.examplebucket",
+            full: "data.aws_s3_bucket.examplebucket.arn",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 2,
+          end: 38,
+        },
+      ]);
+    });
+
+    it("finds plain local reference", () => {
+      return expect(
+        extractReferencesFromExpression("${local.service_name}", nodeIds),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "local.service_name",
+            full: "local.service_name",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 2,
+          end: 20,
+        },
+      ]);
+    });
+
+    it("finds plain resource reference", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${aws_s3_bucket.examplebucket.id}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket.id",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 2,
+          end: 32,
+        },
+      ]);
+    });
+
+    it("finds plain resource references in artihmetics", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${aws_s3_bucket.examplebucket.count + aws_s3_bucket.otherbucket.count }",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket.count",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 2,
+          end: 35,
+        },
+        {
+          referencee: {
+            id: "aws_s3_bucket.otherbucket",
+            full: "aws_s3_bucket.otherbucket.count",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 38,
+          end: 69,
+        },
+      ]);
+    });
+
+    it("use fqn for splat reference", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${aws_s3_bucket.examplebucket.*.id}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket",
+          },
+          useFqn: true,
+          isVariable: false,
+          start: 2,
+          end: 29,
+        },
+      ]);
+    });
+
+    it("use no fqn if property is present on numeric access", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${aws_s3_bucket.examplebucket.network_interface.0.access_config.0.assigned_nat_ip}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket",
+          },
+          useFqn: true,
+          isVariable: false,
+          start: 2,
+          end: 81,
+        },
+      ]);
+    });
+
+    it("detect splat reference within function", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${toset(aws_s3_bucket.examplebucket.*)}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket",
+          },
+          useFqn: true,
+          isVariable: false,
+          start: 8,
+          end: 35,
+        },
+      ]);
+    });
+
+    it("finds all resources in conditional", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${aws_kms_key.key.deletion_window_in_days > 3 ? aws_s3_bucket.examplebucket.id : []}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_kms_key.key",
+            full: "aws_kms_key.key.deletion_window_in_days",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 2,
+          end: 41,
+        },
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket.id",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 48,
+          end: 78,
+        },
+      ]);
+    });
+
+    it("finds all resources in functions", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${element(aws_s3_bucket.examplebucket, 0).id}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 10,
+          end: 37,
+        },
+      ]);
+    });
+
+    it("finds all resources in functions with splat", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${element(aws_s3_bucket.examplebucket.*.id, 0)}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket",
+          },
+          useFqn: true,
+          isVariable: false,
+          start: 10,
+          end: 37,
+        },
+      ]);
+    });
+
+    it("finds all resources in for loops", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${{ for name, user in var.users : user.role => name...}}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: { id: "var.users", full: "var.users" },
+          useFqn: false,
+          isVariable: true,
+          start: 22,
+          end: 31,
+        },
+      ]);
+    });
+
+    it("finds resources with property access", () => {
+      return expect(
+        extractReferencesFromExpression(
+          "${aws_s3_bucket.examplebucket[0].id}",
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket",
+          },
+          useFqn: true,
+          isVariable: false,
+          start: 2,
+          end: 35,
+        },
+      ]);
+    });
+
+    it("finds references within functions that use arrays and comments", () => {
+      return expect(
+        extractReferencesFromExpression(
+          `\${compact([
+            # The example "bucket"
+            aws_s3_bucket.examplebucket,
+        
+            # The "Learn" single page application. This is not configured in all environments.
+            var.input,
+          ])}`,
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "aws_s3_bucket.examplebucket",
+            full: "aws_s3_bucket.examplebucket",
+          },
+          useFqn: false,
+          isVariable: false,
+          start: 59,
+          end: 86,
+        },
+        {
+          referencee: {
+            id: "var.input",
+            full: "var.input",
+          },
+          useFqn: false,
+          isVariable: true,
+          start: 204,
+          end: 213,
+        },
+      ]);
+    });
+
+    it("finds references for same referencees", () => {
+      return expect(
+        extractReferencesFromExpression(
+          `\${var.input == "test" ? "azure-ad-int" : "azure-ad-\${var.input}"}`,
+          nodeIds,
+        ),
+      ).resolves.toEqual([
+        {
+          referencee: {
+            id: "var.input",
+            full: "var.input",
+          },
+          useFqn: false,
+          isVariable: true,
+          start: 2,
+          end: 11,
+        },
+        {
+          referencee: {
+            id: "var.input",
+            full: "var.input",
+          },
+          useFqn: false,
+          isVariable: true,
+          start: 53,
+          end: 62,
+        },
+      ]);
+    });
+  });
+
+  describe("#referenceToAst", () => {
+    it("property access", () => {
+      const scope: ProgramScope = {
+        providerSchema: { format_version: "0.1" },
+        providerGenerator: {},
+        constructs: new Set<string>(),
+        variables: {},
+        hasTokenBasedTypeCoercion: false,
+        nodeIds: [],
+        importables: [],
+        topLevelConfig: {},
+      };
+      expect(
+        generate(
+          t.program([
+            t.expressionStatement(
+              referenceToAst(scope, {
+                start: 0,
+                end: 0,
+                useFqn: false,
+                isVariable: false,
+                referencee: {
+                  id: "aws_kms_key.key",
+                  full: "aws_kms_key.key.deletion_window_in_days",
+                },
+              }),
+            ),
+          ]) as any,
+        ).code,
+      ).toMatchInlineSnapshot(`"key.deletionWindowInDays;"`);
+    });
+  });
+
+  describe("#iteratorVariableToAst", () => {
+    async function run(value: string) {
+      const scope: ProgramScope = {
+        providerSchema: { format_version: "0.1" },
+        providerGenerator: {},
+        constructs: new Set<string>(),
+        variables: {},
+        hasTokenBasedTypeCoercion: false,
+        nodeIds: [],
+        importables: [],
+        topLevelConfig: {},
+      };
+      const ast = await getExpressionAst("main.tf", value);
+      return generate(
+        t.program([
+          t.expressionStatement(
+            dynamicVariableToAst(
+              scope,
+              ast!.children[0] as tex.ScopeTraversalExpression,
+              "myIterator",
+            ),
+          ),
+        ]) as any,
+      ).code;
+    }
+
+    it("should convert iterator key accessor", async () => {
+      expect(await run('"${each.key}"')).toMatchInlineSnapshot(
+        `"myIterator.key;"`,
+      );
+    });
+
+    it("should convert iterator value accessor", async () => {
+      expect(await run('"${each.value}"')).toMatchInlineSnapshot(
+        `"myIterator.value;"`,
+      );
+    });
+
+    it("should convert iterator value deep accessor", async () => {
+      expect(await run('"${each.value.list.map.name}"')).toMatchInlineSnapshot(
+        `"Fn.lookupNested(myIterator.value, ["list", "map", "name"]);"`,
+      );
+    });
+
+    it("should convert iterator value with map access", async () => {
+      expect(
+        await run('"${each.value[0]["map"]["name"]}"'),
+      ).toMatchInlineSnapshot(
+        `"Fn.lookupNested(myIterator.value, ["[0]", "[\\"map\\"]", "[\\"name\\"]"]);"`,
+      );
+    });
+  });
+
+  describe("#getPropertyAccessPath", () => {
+    it.each([
+      [".list.map.name", ["list", "map", "name"]],
+      [`[0]["map"]["name"]`, ["0", "map", "name"]],
+      [`[0].map["name"]`, ["0", "map", "name"]],
+    ])("should return the correct path for %s", (input, expected) => {
+      expect(getPropertyAccessPath(input)).toEqual(expected);
+    });
+  });
+});

package/src/__tests__/findExpressionType.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import { convertTerraformExpressionToTs } from "../expressions";
+import { findExpressionType } from "../coerceType";
+
+const s3BucketSchema = {
+  format_version: "1.0",
+  provider_schemas: {
+    "registry.terraform.io/hashicorp/aws": {
+      provider: {},
+      resource_schemas: {
+        aws_s3_bucket: {
+          version: 0,
+          block: {
+            attributes: {
+              bucket: {
+                type: "string",
+                description_kind: "plain",
+                optional: true,
+                computed: true,
+              },
+              id: {
+                type: "string",
+                description_kind: "plain",
+                optional: true,
+                computed: true,
+              },
+              tags: {
+                type: ["map", "string"],
+                description_kind: "plain",
+                optional: true,
+              },
+              website_domain: {
+                type: "string",
+                description_kind: "plain",
+                deprecated: true,
+                computed: true,
+              },
+              website_endpoint: {
+                type: "string",
+                description_kind: "plain",
+                deprecated: true,
+                computed: true,
+              },
+            },
+            block_types: {
+              cors_rule: {
+                nesting_mode: "list",
+                block: {
+                  attributes: {
+                    allowed_headers: {
+                      type: ["list", "string"],
+                      description_kind: "plain",
+                      optional: true,
+                    },
+                  },
+                  description_kind: "plain",
+                  deprecated: true,
+                },
+              },
+            },
+          },
+        },
+      },
+      data_source_schemas: {},
+    },
+  },
+};
+
+const variable = (fullName: string) => {
+  const [resource, variableName] = fullName.split(".");
+  return {
+    [variableName]: {
+      resource,
+      variableName,
+    },
+  };
+};
+
+const variables = {
+  ...variable("var.test"),
+  ...variable("aws_s3_bucket.examplebucket"),
+};
+
+describe("findExpressionType", () => {
+  it.each([
+    ['"${each.key}"', "string"],
+    ['"${each.value}"', "string"],
+    ['"${var.test}"', "dynamic"],
+    ['"${var.test}"', "dynamic"],
+    ["22", "number"],
+    ["true", "bool"],
+    ['"hello"', "string"],
+    ['"${aws_s3_bucket.examplebucket.bucket}"', "string"],
+  ])("finds type for %s as %s", async (input, expected) => {
+    const scope = {
+      variables,
+      providerSchema: s3BucketSchema,
+    };
+    const ast = await convertTerraformExpressionToTs(
+      scope as any,
+      input,
+      () => "dynamic",
+    );
+    const result = findExpressionType(scope as any, ast);
+
+    expect(result).toEqual(expected);
+  });
+});