@cdktn/hcl2cdk 0.21.0

package/lib/__tests__/functions.test.js

@@ -0,0 +1,605 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const t = __importStar(require("@babel/types"));
+const coerceType_1 = require("../coerceType");
+const functions_1 = require("../function-bindings/functions");
+const testHelpers_1 = require("./testHelpers");
+const scope = {
+    providerSchema: {},
+    providerGenerator: {},
+    constructs: new Set(),
+    variables: {},
+    hasTokenBasedTypeCoercion: false,
+    nodeIds: [],
+    importables: [],
+    topLevelConfig: {},
+};
+// '${replace(module.foo.output, "-", var.bar)}'
+// from https://github.com/hashicorp/terraform-cdk/pull/2729
+const dummy2 = {
+    children: [
+        {
+            children: [
+                {
+                    children: [],
+                    meta: {
+                        traversal: [
+                            {
+                                range: {
+                                    End: {
+                                        Byte: 16,
+                                        Column: 16,
+                                        Line: 0,
+                                    },
+                                    Filename: "",
+                                    Start: {
+                                        Byte: 10,
+                                        Column: 10,
+                                        Line: 0,
+                                    },
+                                },
+                                segment: "module",
+                            },
+                            {
+                                range: {
+                                    End: {
+                                        Byte: 20,
+                                        Column: 20,
+                                        Line: 0,
+                                    },
+                                    Filename: "",
+                                    Start: {
+                                        Byte: 16,
+                                        Column: 16,
+                                        Line: 0,
+                                    },
+                                },
+                                segment: "foo",
+                            },
+                            {
+                                range: {
+                                    End: {
+                                        Byte: 27,
+                                        Column: 27,
+                                        Line: 0,
+                                    },
+                                    Filename: "",
+                                    Start: {
+                                        Byte: 20,
+                                        Column: 20,
+                                        Line: 0,
+                                    },
+                                },
+                                segment: "output",
+                            },
+                        ],
+                    },
+                    range: {
+                        end: {
+                            byte: 27,
+                            column: 27,
+                            line: 0,
+                        },
+                        start: {
+                            byte: 10,
+                            column: 10,
+                            line: 0,
+                        },
+                    },
+                    type: "ScopeTraversal",
+                },
+                {
+                    children: [
+                        {
+                            children: [],
+                            meta: {
+                                type: "string",
+                                value: "-",
+                            },
+                            range: {
+                                end: {
+                                    byte: 31,
+                                    column: 31,
+                                    line: 0,
+                                },
+                                start: {
+                                    byte: 30,
+                                    column: 30,
+                                    line: 0,
+                                },
+                            },
+                            type: "LiteralValue",
+                        },
+                    ],
+                    range: {
+                        end: {
+                            byte: 31,
+                            column: 31,
+                            line: 0,
+                        },
+                        start: {
+                            byte: 30,
+                            column: 30,
+                            line: 0,
+                        },
+                    },
+                    type: "Template",
+                },
+                {
+                    children: [],
+                    meta: {
+                        traversal: [
+                            {
+                                range: {
+                                    End: {
+                                        Byte: 37,
+                                        Column: 37,
+                                        Line: 0,
+                                    },
+                                    Filename: "",
+                                    Start: {
+                                        Byte: 34,
+                                        Column: 34,
+                                        Line: 0,
+                                    },
+                                },
+                                segment: "var",
+                            },
+                            {
+                                range: {
+                                    End: {
+                                        Byte: 41,
+                                        Column: 41,
+                                        Line: 0,
+                                    },
+                                    Filename: "",
+                                    Start: {
+                                        Byte: 37,
+                                        Column: 37,
+                                        Line: 0,
+                                    },
+                                },
+                                segment: "bar",
+                            },
+                        ],
+                    },
+                    range: {
+                        end: {
+                            byte: 41,
+                            column: 41,
+                            line: 0,
+                        },
+                        start: {
+                            byte: 34,
+                            column: 34,
+                            line: 0,
+                        },
+                    },
+                    type: "ScopeTraversal",
+                },
+            ],
+            meta: {
+                closeParenRange: {
+                    end: {
+                        byte: 42,
+                        column: 42,
+                        line: 0,
+                    },
+                    start: {
+                        byte: 41,
+                        column: 41,
+                        line: 0,
+                    },
+                },
+                expandedFinalArgument: false,
+                name: "replace",
+                nameRange: {
+                    end: {
+                        byte: 9,
+                        column: 9,
+                        line: 0,
+                    },
+                    start: {
+                        byte: 2,
+                        column: 2,
+                        line: 0,
+                    },
+                },
+                openParenRange: {
+                    end: {
+                        byte: 10,
+                        column: 10,
+                        line: 0,
+                    },
+                    start: {
+                        byte: 9,
+                        column: 9,
+                        line: 0,
+                    },
+                },
+            },
+            range: {
+                end: {
+                    byte: 10,
+                    column: 10,
+                    line: 0,
+                },
+                start: {
+                    byte: 2,
+                    column: 2,
+                    line: 0,
+                },
+            },
+            type: "function",
+        },
+    ],
+    range: {
+        end: {
+            byte: 43,
+            column: 43,
+            line: 0,
+        },
+        start: {
+            byte: 0,
+            column: 0,
+            line: 0,
+        },
+    },
+    type: "TemplateWrap",
+};
+describe("bindings for Terraform functions", () => {
+    it("should convert Terraform AST into TS AST", () => {
+        expect((0, testHelpers_1.astToCode)(terraformThingToTs(scope, dummy2, "dynamic"))).toMatchInlineSnapshot(`"Fn.replace(TodoReference-module-foo-output, "-", TodoReference-var-bar)"`);
+    });
+    it("should convert Terraform AST into TS AST for overriden function name", () => {
+        expect((0, testHelpers_1.astToCode)(terraformThingToTs(scope, {
+            type: "function",
+            meta: {
+                name: "length",
+            },
+            children: [
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "list",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+            ],
+        }, "number"))).toMatchInlineSnapshot(`"Fn.lengthOf(TodoReference-var-list)"`);
+    });
+    it("should convert Terraform AST into TS AST for overriden function with variadic args for optional params", () => {
+        expect((0, testHelpers_1.astToCode)(terraformThingToTs(scope, {
+            type: "function",
+            meta: {
+                name: "bcrypt",
+            },
+            children: [
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "str",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "cost",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+            ],
+        }, "string"))).toMatchInlineSnapshot(`"Fn.bcrypt(TodoReference-var-str, TodoReference-var-cost)"`);
+    });
+    it("should convert Terraform AST into TS AST for overriden function with variadic args for optional params that are not passed", () => {
+        expect((0, testHelpers_1.astToCode)(terraformThingToTs(scope, {
+            type: "function",
+            meta: {
+                name: "bcrypt",
+            },
+            children: [
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "str",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+            ],
+        }, "string"))).toMatchInlineSnapshot(`"Fn.bcrypt(TodoReference-var-str)"`);
+    });
+    it("should convert Terraform AST into TS AST for function with variadic param", () => {
+        expect((0, testHelpers_1.astToCode)(terraformThingToTs(scope, {
+            type: "function",
+            meta: {
+                name: "try",
+            },
+            children: [
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "strA",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "strB",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+            ],
+        }, "dynamic"))).toMatchInlineSnapshot(`"Fn.try([TodoReference-var-strA, TodoReference-var-strB])"`);
+    });
+    it("should convert Terraform AST into TS AST for join function with single list param", () => {
+        expect((0, testHelpers_1.astToCode)(terraformThingToTs(scope, {
+            type: "function",
+            meta: {
+                name: "join",
+            },
+            children: [
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "str",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "list",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+            ],
+        }, "string"))).toMatchInlineSnapshot(`"Fn.join(TodoReference-var-str, TodoReference-var-list)"`);
+    });
+    it("should convert Terraform AST into TS AST for join function with multiple list params", () => {
+        expect((0, testHelpers_1.astToCode)(terraformThingToTs(scope, {
+            type: "function",
+            meta: {
+                name: "join",
+            },
+            children: [
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "str",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "listA",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+                {
+                    type: "ScopeTraversal",
+                    meta: {
+                        traversal: [
+                            {
+                                segment: "var",
+                            },
+                            {
+                                segment: "listB",
+                            },
+                        ],
+                    },
+                    children: [],
+                },
+            ],
+        }, "string"))).toMatchInlineSnapshot(`"Fn.join(TodoReference-var-str, Token.asList(Fn.concat([TodoReference-var-listA, TodoReference-var-listB])))"`);
+    });
+    it("should throw if not enough parameters were passed", () => {
+        expect(() => (0, testHelpers_1.astToCode)(terraformThingToTs(scope, {
+            type: "function",
+            meta: {
+                name: "bcrypt",
+            },
+            children: [],
+        }, "string"))).toThrowErrorMatchingInlineSnapshot(`"Terraform function call to "bcrypt" is not valid! Parameter at index 0 of type string is not optional but received no value. The following parameters were passed: []"`);
+    });
+    // TODO: tests for type coercion
+});
+function terraformThingToTs(scope, tfAst, targetType) {
+    switch (tfAst.type) {
+        case "function": {
+            return terraformFunctionCallToTs(scope, tfAst, targetType);
+        }
+        case "TemplateWrap": {
+            // If there's just one child, we can skip them
+            if (tfAst.children.length === 1) {
+                return terraformThingToTs(scope, tfAst.children[0], targetType);
+            }
+            throw new Error("TemplateWrap with not exactly one child is not supported yet: " +
+                tfAst.children);
+        }
+        case "ScopeTraversal": {
+            return terraformScopeTraversalToTs(tfAst, targetType);
+        }
+        case "Template": {
+            return terraformTemplateToTs(scope, tfAst, targetType);
+        }
+        case "LiteralValue": {
+            return terraformLiteralValueToTs(tfAst, targetType);
+        }
+        default:
+            throw new Error("Unsupported type: " + tfAst.type);
+    }
+}
+function terraformScopeTraversalToTs(tfAst, _targetType) {
+    return t.identifier("TodoReference-" + tfAst.meta.traversal.map((t) => t.segment).join("-"));
+}
+function terraformTemplateToTs(scope, tfAst, targetType) {
+    if (tfAst.children.length === 1) {
+        return terraformThingToTs(scope, tfAst.children[0], targetType);
+    }
+    throw new Error("Template currently only supports exactly one child");
+}
+function terraformLiteralValueToTs(tfAst, targetType) {
+    const literalExpression = t.stringLiteral(tfAst.meta.value);
+    return (0, coerceType_1.coerceType)(
+    // TODO: scope should be passed instead, even if coerceType won't need it probably
+    {
+        constructs: new Set(),
+        hasTokenBasedTypeCoercion: false,
+        providerGenerator: {},
+        providerSchema: {},
+        variables: {},
+        nodeIds: [],
+        importables: [],
+        topLevelConfig: {},
+    }, literalExpression, tfAst.meta.type, targetType);
+}
+function terraformFunctionCallToTs(scope, tfAst, targetType) {
+    const { name } = tfAst.meta;
+    const mapping = functions_1.functionsMap[name];
+    if (!mapping) {
+        throw new Error(`Mapping not found for function: ${name}`);
+    }
+    if (mapping.transformer) {
+        const newTfAst = mapping.transformer(tfAst);
+        if (newTfAst !== tfAst)
+            return terraformFunctionCallToTs(scope, newTfAst, targetType);
+    }
+    scope.importables.push({
+        constructName: "Fn",
+        provider: "cdktn",
+    });
+    const callee = t.memberExpression(t.identifier("Fn"), t.identifier(mapping.name));
+    const args = [];
+    mapping.parameters.forEach((param, idx) => {
+        if (param.variadic) {
+            // return an array with all remaining children (each mapped accordingly)
+            args.push(t.arrayExpression(tfAst.children
+                .slice(idx)
+                .map((child) => terraformThingToTs(scope, child, param.type))));
+        }
+        else {
+            const child = tfAst.children[idx];
+            if (child) {
+                args.push(terraformThingToTs(scope, child, param.type));
+            }
+            else if (!param.optional) {
+                throw new Error(`Terraform function call to "${name}" is not valid! Parameter at index ${idx} of type ${param.type} is not optional but received no value. The following parameters were passed: ${JSON.stringify(tfAst.children)}`);
+            }
+        }
+    });
+    const returnType = mapping.returnType;
+    const callExpression = t.callExpression(callee, args);
+    return (0, coerceType_1.coerceType)(
+    // TODO: scope should be passed instead, even if coerceType won't need it probably
+    {
+        constructs: new Set(),
+        hasTokenBasedTypeCoercion: false,
+        providerGenerator: {},
+        providerSchema: {},
+        variables: {},
+        nodeIds: [],
+        importables: [],
+        topLevelConfig: {},
+    }, callExpression, returnType, targetType);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"functions.test.js","sourceRoot":"","sources":["functions.test.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nimport * as t from \"@babel/types\";\nimport { AttributeType } from \"@cdktn/commons\";\nimport { coerceType } from \"../coerceType\";\nimport { functionsMap } from \"../function-bindings/functions\";\nimport { ProgramScope } from \"../types\";\nimport { astToCode } from \"./testHelpers\";\n\ntype BaseThing = {\n  type: string;\n  children: Thing[];\n  meta?: object;\n  range?: unknown; // optional as we don't care about it\n};\n\ntype FunctionCall = BaseThing & {\n  type: \"function\";\n  meta: {\n    name: string;\n    expandedFinalArgument?: boolean; // optional as we don't care about it\n    closeParenRange?: unknown; // optional as we don't care about it\n    openParenRange?: unknown; // optional as we don't care about it\n    nameRange?: unknown; // optional as we don't care about it\n  };\n};\n\ntype TemplateWrap = BaseThing & {\n  type: \"TemplateWrap\";\n};\n\ntype Template = BaseThing & {\n  type: \"Template\";\n};\n\ntype LiteralValue = BaseThing & {\n  type: \"LiteralValue\";\n  meta: {\n    type: \"string\";\n    value: string; // this is available in other \"Things\" too but we only need it here yet\n  };\n};\n\ntype ScopeTraversal = BaseThing & {\n  type: \"ScopeTraversal\";\n  meta: {\n    traversal: {\n      segment: string;\n      range?: unknown; // optional as we don't care about it\n    }[];\n  };\n};\n\nconst scope: ProgramScope = {\n  providerSchema: {},\n  providerGenerator: {},\n  constructs: new Set(),\n  variables: {},\n  hasTokenBasedTypeCoercion: false,\n  nodeIds: [],\n  importables: [],\n  topLevelConfig: {},\n};\n\ntype Thing =\n  | FunctionCall\n  | TemplateWrap\n  | Template\n  | ScopeTraversal\n  | LiteralValue;\n\n// '${replace(module.foo.output, \"-\", var.bar)}'\n// from https://github.com/hashicorp/terraform-cdk/pull/2729\nconst dummy2: Thing = {\n  children: [\n    {\n      children: [\n        {\n          children: [],\n          meta: {\n            traversal: [\n              {\n                range: {\n                  End: {\n                    Byte: 16,\n                    Column: 16,\n                    Line: 0,\n                  },\n                  Filename: \"\",\n                  Start: {\n                    Byte: 10,\n                    Column: 10,\n                    Line: 0,\n                  },\n                },\n                segment: \"module\",\n              },\n              {\n                range: {\n                  End: {\n                    Byte: 20,\n                    Column: 20,\n                    Line: 0,\n                  },\n                  Filename: \"\",\n                  Start: {\n                    Byte: 16,\n                    Column: 16,\n                    Line: 0,\n                  },\n                },\n                segment: \"foo\",\n              },\n              {\n                range: {\n                  End: {\n                    Byte: 27,\n                    Column: 27,\n                    Line: 0,\n                  },\n                  Filename: \"\",\n                  Start: {\n                    Byte: 20,\n                    Column: 20,\n                    Line: 0,\n                  },\n                },\n                segment: \"output\",\n              },\n            ],\n          },\n          range: {\n            end: {\n              byte: 27,\n              column: 27,\n              line: 0,\n            },\n            start: {\n              byte: 10,\n              column: 10,\n              line: 0,\n            },\n          },\n          type: \"ScopeTraversal\",\n        },\n        {\n          children: [\n            {\n              children: [],\n              meta: {\n                type: \"string\",\n                value: \"-\",\n              },\n              range: {\n                end: {\n                  byte: 31,\n                  column: 31,\n                  line: 0,\n                },\n                start: {\n                  byte: 30,\n                  column: 30,\n                  line: 0,\n                },\n              },\n              type: \"LiteralValue\",\n            },\n          ],\n          range: {\n            end: {\n              byte: 31,\n              column: 31,\n              line: 0,\n            },\n            start: {\n              byte: 30,\n              column: 30,\n              line: 0,\n            },\n          },\n          type: \"Template\",\n        },\n        {\n          children: [],\n          meta: {\n            traversal: [\n              {\n                range: {\n                  End: {\n                    Byte: 37,\n                    Column: 37,\n                    Line: 0,\n                  },\n                  Filename: \"\",\n                  Start: {\n                    Byte: 34,\n                    Column: 34,\n                    Line: 0,\n                  },\n                },\n                segment: \"var\",\n              },\n              {\n                range: {\n                  End: {\n                    Byte: 41,\n                    Column: 41,\n                    Line: 0,\n                  },\n                  Filename: \"\",\n                  Start: {\n                    Byte: 37,\n                    Column: 37,\n                    Line: 0,\n                  },\n                },\n                segment: \"bar\",\n              },\n            ],\n          },\n          range: {\n            end: {\n              byte: 41,\n              column: 41,\n              line: 0,\n            },\n            start: {\n              byte: 34,\n              column: 34,\n              line: 0,\n            },\n          },\n          type: \"ScopeTraversal\",\n        },\n      ],\n      meta: {\n        closeParenRange: {\n          end: {\n            byte: 42,\n            column: 42,\n            line: 0,\n          },\n          start: {\n            byte: 41,\n            column: 41,\n            line: 0,\n          },\n        },\n        expandedFinalArgument: false,\n        name: \"replace\",\n        nameRange: {\n          end: {\n            byte: 9,\n            column: 9,\n            line: 0,\n          },\n          start: {\n            byte: 2,\n            column: 2,\n            line: 0,\n          },\n        },\n        openParenRange: {\n          end: {\n            byte: 10,\n            column: 10,\n            line: 0,\n          },\n          start: {\n            byte: 9,\n            column: 9,\n            line: 0,\n          },\n        },\n      },\n      range: {\n        end: {\n          byte: 10,\n          column: 10,\n          line: 0,\n        },\n        start: {\n          byte: 2,\n          column: 2,\n          line: 0,\n        },\n      },\n      type: \"function\",\n    },\n  ],\n  range: {\n    end: {\n      byte: 43,\n      column: 43,\n      line: 0,\n    },\n    start: {\n      byte: 0,\n      column: 0,\n      line: 0,\n    },\n  },\n  type: \"TemplateWrap\",\n};\n\ndescribe(\"bindings for Terraform functions\", () => {\n  it(\"should convert Terraform AST into TS AST\", () => {\n    expect(\n      astToCode(terraformThingToTs(scope, dummy2, \"dynamic\")),\n    ).toMatchInlineSnapshot(\n      `\"Fn.replace(TodoReference-module-foo-output, \"-\", TodoReference-var-bar)\"`,\n    );\n  });\n\n  it(\"should convert Terraform AST into TS AST for overriden function name\", () => {\n    expect(\n      astToCode(\n        terraformThingToTs(\n          scope,\n          {\n            type: \"function\",\n            meta: {\n              name: \"length\",\n            },\n            children: [\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"list\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n            ],\n          },\n          \"number\",\n        ),\n      ),\n    ).toMatchInlineSnapshot(`\"Fn.lengthOf(TodoReference-var-list)\"`);\n  });\n\n  it(\"should convert Terraform AST into TS AST for overriden function with variadic args for optional params\", () => {\n    expect(\n      astToCode(\n        terraformThingToTs(\n          scope,\n          {\n            type: \"function\",\n            meta: {\n              name: \"bcrypt\",\n            },\n            children: [\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"str\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"cost\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n            ],\n          },\n          \"string\",\n        ),\n      ),\n    ).toMatchInlineSnapshot(\n      `\"Fn.bcrypt(TodoReference-var-str, TodoReference-var-cost)\"`,\n    );\n  });\n\n  it(\"should convert Terraform AST into TS AST for overriden function with variadic args for optional params that are not passed\", () => {\n    expect(\n      astToCode(\n        terraformThingToTs(\n          scope,\n          {\n            type: \"function\",\n            meta: {\n              name: \"bcrypt\",\n            },\n            children: [\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"str\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n            ],\n          },\n          \"string\",\n        ),\n      ),\n    ).toMatchInlineSnapshot(`\"Fn.bcrypt(TodoReference-var-str)\"`);\n  });\n\n  it(\"should convert Terraform AST into TS AST for function with variadic param\", () => {\n    expect(\n      astToCode(\n        terraformThingToTs(\n          scope,\n          {\n            type: \"function\",\n            meta: {\n              name: \"try\",\n            },\n            children: [\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"strA\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"strB\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n            ],\n          },\n          \"dynamic\",\n        ),\n      ),\n    ).toMatchInlineSnapshot(\n      `\"Fn.try([TodoReference-var-strA, TodoReference-var-strB])\"`,\n    );\n  });\n\n  it(\"should convert Terraform AST into TS AST for join function with single list param\", () => {\n    expect(\n      astToCode(\n        terraformThingToTs(\n          scope,\n          {\n            type: \"function\",\n            meta: {\n              name: \"join\",\n            },\n            children: [\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"str\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"list\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n            ],\n          },\n          \"string\",\n        ),\n      ),\n    ).toMatchInlineSnapshot(\n      `\"Fn.join(TodoReference-var-str, TodoReference-var-list)\"`,\n    );\n  });\n\n  it(\"should convert Terraform AST into TS AST for join function with multiple list params\", () => {\n    expect(\n      astToCode(\n        terraformThingToTs(\n          scope,\n          {\n            type: \"function\",\n            meta: {\n              name: \"join\",\n            },\n            children: [\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"str\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"listA\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n              {\n                type: \"ScopeTraversal\",\n                meta: {\n                  traversal: [\n                    {\n                      segment: \"var\",\n                    },\n                    {\n                      segment: \"listB\",\n                    },\n                  ],\n                },\n                children: [],\n              },\n            ],\n          },\n          \"string\",\n        ),\n      ),\n    ).toMatchInlineSnapshot(\n      `\"Fn.join(TodoReference-var-str, Token.asList(Fn.concat([TodoReference-var-listA, TodoReference-var-listB])))\"`,\n    );\n  });\n\n  it(\"should throw if not enough parameters were passed\", () => {\n    expect(() =>\n      astToCode(\n        terraformThingToTs(\n          scope,\n          {\n            type: \"function\",\n            meta: {\n              name: \"bcrypt\",\n            },\n            children: [],\n          },\n          \"string\",\n        ),\n      ),\n    ).toThrowErrorMatchingInlineSnapshot(\n      `\"Terraform function call to \"bcrypt\" is not valid! Parameter at index 0 of type string is not optional but received no value. The following parameters were passed: []\"`,\n    );\n  });\n\n  // TODO: tests for type coercion\n});\n\nfunction terraformThingToTs(\n  scope: ProgramScope,\n  tfAst: Thing,\n  targetType: AttributeType | undefined,\n): t.Expression {\n  switch (tfAst.type) {\n    case \"function\": {\n      return terraformFunctionCallToTs(scope, tfAst, targetType);\n    }\n    case \"TemplateWrap\": {\n      // If there's just one child, we can skip them\n      if (tfAst.children.length === 1) {\n        return terraformThingToTs(scope, tfAst.children[0], targetType);\n      }\n      throw new Error(\n        \"TemplateWrap with not exactly one child is not supported yet: \" +\n          tfAst.children,\n      );\n    }\n    case \"ScopeTraversal\": {\n      return terraformScopeTraversalToTs(tfAst, targetType);\n    }\n    case \"Template\": {\n      return terraformTemplateToTs(scope, tfAst, targetType);\n    }\n    case \"LiteralValue\": {\n      return terraformLiteralValueToTs(tfAst, targetType);\n    }\n    default:\n      throw new Error(\"Unsupported type: \" + (tfAst as any).type);\n  }\n}\n\nfunction terraformScopeTraversalToTs(\n  tfAst: ScopeTraversal,\n  _targetType: AttributeType | undefined,\n): t.Expression {\n  return t.identifier(\n    \"TodoReference-\" + tfAst.meta.traversal.map((t) => t.segment).join(\"-\"),\n  );\n}\n\nfunction terraformTemplateToTs(\n  scope: ProgramScope,\n  tfAst: Template,\n  targetType: AttributeType | undefined,\n): t.Expression {\n  if (tfAst.children.length === 1) {\n    return terraformThingToTs(scope, tfAst.children[0], targetType);\n  }\n  throw new Error(\"Template currently only supports exactly one child\");\n}\n\nfunction terraformLiteralValueToTs(\n  tfAst: LiteralValue,\n  targetType: AttributeType | undefined,\n): t.Expression {\n  const literalExpression = t.stringLiteral(tfAst.meta.value);\n  return coerceType(\n    // TODO: scope should be passed instead, even if coerceType won't need it probably\n    {\n      constructs: new Set(),\n      hasTokenBasedTypeCoercion: false,\n      providerGenerator: {},\n      providerSchema: {},\n      variables: {},\n      nodeIds: [],\n      importables: [],\n      topLevelConfig: {},\n    },\n    literalExpression,\n    tfAst.meta.type,\n    targetType,\n  );\n}\n\nfunction terraformFunctionCallToTs(\n  scope: ProgramScope,\n  tfAst: FunctionCall,\n  targetType: AttributeType | undefined,\n): t.Expression {\n  const { name } = tfAst.meta;\n\n  const mapping = functionsMap[name];\n  if (!mapping) {\n    throw new Error(`Mapping not found for function: ${name}`);\n  }\n\n  if (mapping.transformer) {\n    const newTfAst = mapping.transformer(tfAst);\n    if (newTfAst !== tfAst)\n      return terraformFunctionCallToTs(scope, newTfAst, targetType);\n  }\n\n  scope.importables.push({\n    constructName: \"Fn\",\n    provider: \"cdktn\",\n  });\n\n  const callee = t.memberExpression(\n    t.identifier(\"Fn\"),\n    t.identifier(mapping.name),\n  );\n\n  const args: t.Expression[] = [];\n  mapping.parameters.forEach((param, idx) => {\n    if (param.variadic) {\n      // return an array with all remaining children (each mapped accordingly)\n      args.push(\n        t.arrayExpression(\n          tfAst.children\n            .slice(idx)\n            .map((child) => terraformThingToTs(scope, child, param.type)),\n        ),\n      );\n    } else {\n      const child = tfAst.children[idx];\n      if (child) {\n        args.push(terraformThingToTs(scope, child, param.type));\n      } else if (!param.optional) {\n        throw new Error(\n          `Terraform function call to \"${name}\" is not valid! Parameter at index ${idx} of type ${\n            param.type\n          } is not optional but received no value. The following parameters were passed: ${JSON.stringify(\n            tfAst.children,\n          )}`,\n        );\n      }\n    }\n  });\n\n  const returnType = mapping.returnType;\n\n  const callExpression = t.callExpression(callee, args);\n\n  return coerceType(\n    // TODO: scope should be passed instead, even if coerceType won't need it probably\n    {\n      constructs: new Set(),\n      hasTokenBasedTypeCoercion: false,\n      providerGenerator: {},\n      providerSchema: {},\n      variables: {},\n      nodeIds: [],\n      importables: [],\n      topLevelConfig: {},\n    },\n    callExpression,\n    returnType,\n    targetType,\n  );\n}\n"]}