@cdktn/hcl2cdk 0.22.0-pre.2

package/lib/__tests__/terraformSchema.test.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const terraformSchema_1 = require("../terraformSchema");
+describe("getTypeAtPath", () => {
+    const schema = {
+        provider_schemas: {
+            test: {
+                provider: {},
+                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((0, terraformSchema_1.getTypeAtPath)(schema, "test.nonExistantResource")).toBeNull();
+    });
+    it("should return null if it can not find the attribute on the resource", () => {
+        expect((0, terraformSchema_1.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((0, terraformSchema_1.getTypeAtPath)(schema, `test.resource.${attr}`)).toEqual(res);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/__tests__/testHelpers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import * as t from "@babel/types";
+export declare function astToCode(e: t.Expression): string;
+//# sourceMappingURL=testHelpers.d.ts.map

package/lib/__tests__/testHelpers.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astToCode = void 0;
+const generator_1 = __importDefault(require("@babel/generator"));
+function astToCode(e) {
+    return (0, generator_1.default)(e).code;
+}
+exports.astToCode = astToCode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdEhlbHBlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0ZXN0SGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7OztHQUdHOzs7Ozs7QUFFSCxpRUFBd0M7QUFHeEMsU0FBZ0IsU0FBUyxDQUFDLENBQWU7SUFDdkMsT0FBTyxJQUFBLG1CQUFRLEVBQUMsQ0FBUSxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQ2pDLENBQUM7QUFGRCw4QkFFQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IChjKSBIYXNoaUNvcnAsIEluYy5cbiAqIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNUEwtMi4wXG4gKi9cblxuaW1wb3J0IGdlbmVyYXRlIGZyb20gXCJAYmFiZWwvZ2VuZXJhdG9yXCI7XG5pbXBvcnQgKiBhcyB0IGZyb20gXCJAYmFiZWwvdHlwZXNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIGFzdFRvQ29kZShlOiB0LkV4cHJlc3Npb24pOiBzdHJpbmcge1xuICByZXR1cm4gZ2VuZXJhdGUoZSBhcyBhbnkpLmNvZGU7XG59XG4iXX0=

package/lib/coerceType.d.ts

@@ -0,0 +1,7 @@
+import * as t from "@babel/types";
+import { AttributeType } from "@cdktn/commons";
+import { ProgramScope } from "./types";
+export declare function typeForCallExpression(ast: t.CallExpression): AttributeType;
+export declare const coerceType: (scope: ProgramScope, ast: t.Expression, from: AttributeType, to: AttributeType | undefined) => t.Expression;
+export declare function findExpressionType(scope: ProgramScope, ast: t.Expression): AttributeType;
+//# sourceMappingURL=coerceType.d.ts.map

package/lib/coerceType.js

@@ -0,0 +1,240 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExpressionType = exports.coerceType = exports.typeForCallExpression = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const template_1 = __importDefault(require("@babel/template"));
+const t = __importStar(require("@babel/types"));
+const commons_1 = require("@cdktn/commons");
+const deep_equal_1 = __importDefault(require("deep-equal"));
+const functions_1 = require("./function-bindings/functions");
+const terraformSchema_1 = require("./terraformSchema");
+const codemaker_1 = require("codemaker");
+function changeValueAccessor(ast, newAccessor) {
+    const propertyIdentifier = {
+        ...ast.property,
+        name: newAccessor,
+    };
+    return {
+        ...ast,
+        property: propertyIdentifier,
+    };
+}
+function typeForCallExpression(ast) {
+    // 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 = functions_1.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";
+}
+exports.typeForCallExpression = typeForCallExpression;
+const coerceType = (scope, ast, from, to) => {
+    if (to === undefined) {
+        return ast;
+    }
+    if ((0, deep_equal_1.default)(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.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, "listValue");
+                    }
+                    addTokenToImports();
+                    return template_1.default.expression(`Token.asList(%%ast%%)`)({
+                        ast: ast,
+                    });
+                case "number":
+                    addTokenToImports();
+                    return template_1.default.expression(`Token.asNumberList(%%ast%%)`)({
+                        ast: ast,
+                    });
+                case "bool":
+                    addTokenToImports();
+                    return template_1.default.expression(`Token.asAny(%%ast%%)`)({
+                        ast: ast,
+                    });
+                default:
+                    addTokenToImports();
+                    return template_1.default.expression(`Token.asAny(%%ast%%)`)({
+                        ast: ast,
+                    });
+            }
+        }
+        if (to[0] === "map") {
+            switch (to[1]) {
+                case "string":
+                    addTokenToImports();
+                    return template_1.default.expression(`Token.asStringMap(%%ast%%)`)({
+                        ast: ast,
+                    });
+                case "number":
+                    addTokenToImports();
+                    return template_1.default.expression(`Token.asNumberMap(%%ast%%)`)({
+                        ast: ast,
+                    });
+                case "bool":
+                    addTokenToImports();
+                    return template_1.default.expression(`Token.asBooleanMap(%%ast%%)`)({
+                        ast: ast,
+                    });
+                default:
+                    addTokenToImports();
+                    return template_1.default.expression(`Token.asAnyMap(%%ast%%)`)({
+                        ast: ast,
+                    });
+            }
+        }
+    }
+    switch (to) {
+        case "number":
+            if (isTerraformVariableOrLocal) {
+                return changeValueAccessor(ast, "numberValue");
+            }
+            addTokenToImports();
+            return template_1.default.expression(`Token.asNumber(%%ast%%)`)({
+                ast: ast,
+            });
+        case "string":
+            if (isTerraformVariableOrLocal) {
+                return changeValueAccessor(ast, "stringValue");
+            }
+            addTokenToImports();
+            return template_1.default.expression(`Token.asString(%%ast%%)`)({
+                ast: ast,
+            });
+        case "bool":
+            if (isTerraformVariableOrLocal) {
+                return changeValueAccessor(ast, "booleanValue");
+            }
+            addTokenToImports();
+            return template_1.default.expression(`Token.asBoolean(%%ast%%)`)({
+                ast: ast,
+            });
+    }
+    commons_1.logger.debug(`Could not coerce from ${from} to ${to} for ${ast}`);
+    return ast;
+};
+exports.coerceType = coerceType;
+function findExpressionType(scope, ast) {
+    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) {
+            commons_1.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) {
+            commons_1.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) => (0, codemaker_1.toSnakeCase)(x)).join(".")}`;
+        const type = (0, terraformSchema_1.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";
+}
+exports.findExpressionType = findExpressionType;
+/*
+ * Transforms a babel AST into a list of string accessors
+ * e.g. foo.bar.baz -> ["foo", "bar", "baz"]
+ */
+function destructureAst(ast) {
+    switch (ast.type) {
+        case "Identifier":
+            return [ast.name];
+        case "MemberExpression": {
+            const object = destructureAst(ast.object);
+            const property = destructureAst(ast.property);
+            if (object && property) {
+                return [...object, ...property];
+            }
+            else {
+                return undefined;
+            }
+        }
+        default:
+            return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"coerceType.js","sourceRoot":"","sources":["coerceType.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,mCAAmC;AACnC,+DAAuC;AACvC,gDAAkC;AAClC,4CAAuD;AAEvD,4DAAmC;AACnC,6DAA+D;AAC/D,uDAAkD;AAClD,yCAAwC;AAExC,SAAS,mBAAmB,CAC1B,GAAuB,EACvB,WAAmB;IAEnB,MAAM,kBAAkB,GAAiB;QACvC,GAAI,GAAG,CAAC,QAAyB;QACjC,IAAI,EAAE,WAAW;KAClB,CAAC;IACF,OAAO;QACL,GAAG,GAAG;QACN,QAAQ,EAAE,kBAAkB;KAC7B,CAAC;AACJ,CAAC;AAED,SAAgB,qBAAqB,CAAC,GAAqB;IACzD,0CAA0C;IAC1C,IACE,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC;QAChC,CAAC,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC;QACvC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;QACxC,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO;YACxC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO,CAAC;QAC5C,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC;QAC1C,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI;QACxC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,EACnC,CAAC;QACD,MAAM,IAAI,GAAG,0BAAc,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACtD,IAAI,IAAI,EAAE,CAAC;YACT,OAAO,IAAI,CAAC,UAAU,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAED,sEAAsE;IACtE,+BAA+B;IAC/B,OAAO,SAAS,CAAC;AACnB,CAAC;AAvBD,sDAuBC;AAEM,MAAM,UAAU,GAAG,CACxB,KAAmB,EACnB,GAAiB,EACjB,IAAmB,EACnB,EAA6B,EACf,EAAE;IAChB,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;QACrB,OAAO,GAAG,CAAC;IACb,CAAC;IAED,IAAI,IAAA,oBAAS,EAAC,EAAE,EAAE,IAAI,CAAC,EAAE,CAAC;QACxB,OAAO,GAAG,CAAC;IACb,CAAC;IAED,MAAM,0BAA0B,GAC9B,GAAG,CAAC,IAAI,KAAK,kBAAkB;QAC/B,GAAG,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;QAClC,GAAG,CAAC,QAAQ,CAAC,IAAI,KAAK,OAAO;QAC7B,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY;QAChC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,CACjC,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,YAAY,KAAM,GAAG,CAAC,MAAuB,CAAC,IAAI;YAC5D,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAChD,CAAC;IAEJ,MAAM,iBAAiB,GAAG,GAAG,EAAE,CAC7B,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC;QACrB,aAAa,EAAE,OAAO;QACtB,QAAQ,EAAE,OAAO;KAClB,CAAC,CAAC;IAEL,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC;QACtB,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC;YACxC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACd,KAAK,QAAQ;oBACX,IAAI,0BAA0B,EAAE,CAAC;wBAC/B,OAAO,mBAAmB,CAAC,GAAyB,EAAE,WAAW,CAAC,CAAC;oBACrE,CAAC;oBAED,iBAAiB,EAAE,CAAC;oBACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,uBAAuB,CAAC,CAAC;wBAClD,GAAG,EAAE,GAAG;qBACT,CAAiB,CAAC;gBACrB,KAAK,QAAQ;oBACX,iBAAiB,EAAE,CAAC;oBACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,6BAA6B,CAAC,CAAC;wBACxD,GAAG,EAAE,GAAG;qBACT,CAAiB,CAAC;gBACrB,KAAK,MAAM;oBACT,iBAAiB,EAAE,CAAC;oBACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,sBAAsB,CAAC,CAAC;wBACjD,GAAG,EAAE,GAAG;qBACT,CAAiB,CAAC;gBACrB;oBACE,iBAAiB,EAAE,CAAC;oBACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,sBAAsB,CAAC,CAAC;wBACjD,GAAG,EAAE,GAAG;qBACT,CAAiB,CAAC;YACvB,CAAC;QACH,CAAC;QAED,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC;YACpB,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACd,KAAK,QAAQ;oBACX,iBAAiB,EAAE,CAAC;oBACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,4BAA4B,CAAC,CAAC;wBACvD,GAAG,EAAE,GAAG;qBACT,CAAiB,CAAC;gBACrB,KAAK,QAAQ;oBACX,iBAAiB,EAAE,CAAC;oBACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,4BAA4B,CAAC,CAAC;wBACvD,GAAG,EAAE,GAAG;qBACT,CAAiB,CAAC;gBACrB,KAAK,MAAM;oBACT,iBAAiB,EAAE,CAAC;oBACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,6BAA6B,CAAC,CAAC;wBACxD,GAAG,EAAE,GAAG;qBACT,CAAiB,CAAC;gBACrB;oBACE,iBAAiB,EAAE,CAAC;oBACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,yBAAyB,CAAC,CAAC;wBACpD,GAAG,EAAE,GAAG;qBACT,CAAiB,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;IAED,QAAQ,EAAE,EAAE,CAAC;QACX,KAAK,QAAQ;YACX,IAAI,0BAA0B,EAAE,CAAC;gBAC/B,OAAO,mBAAmB,CAAC,GAAyB,EAAE,aAAa,CAAC,CAAC;YACvE,CAAC;YACD,iBAAiB,EAAE,CAAC;YACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,yBAAyB,CAAC,CAAC;gBACpD,GAAG,EAAE,GAAG;aACT,CAAiB,CAAC;QACrB,KAAK,QAAQ;YACX,IAAI,0BAA0B,EAAE,CAAC;gBAC/B,OAAO,mBAAmB,CAAC,GAAyB,EAAE,aAAa,CAAC,CAAC;YACvE,CAAC;YACD,iBAAiB,EAAE,CAAC;YACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,yBAAyB,CAAC,CAAC;gBACpD,GAAG,EAAE,GAAG;aACT,CAAiB,CAAC;QACrB,KAAK,MAAM;YACT,IAAI,0BAA0B,EAAE,CAAC;gBAC/B,OAAO,mBAAmB,CAAC,GAAyB,EAAE,cAAc,CAAC,CAAC;YACxE,CAAC;YACD,iBAAiB,EAAE,CAAC;YACpB,OAAO,kBAAQ,CAAC,UAAU,CAAC,0BAA0B,CAAC,CAAC;gBACrD,GAAG,EAAE,GAAG;aACT,CAAiB,CAAC;IACvB,CAAC;IAED,gBAAM,CAAC,KAAK,CAAC,yBAAyB,IAAI,OAAO,EAAE,QAAQ,GAAG,EAAE,CAAC,CAAC;IAClE,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AApHW,QAAA,UAAU,cAoHrB;AAEF,SAAgB,kBAAkB,CAChC,KAAmB,EACnB,GAAiB;IAEjB,MAAM,gCAAgC,GACpC,GAAG,CAAC,IAAI,KAAK,kBAAkB,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY,CAAC;IAEtE,kEAAkE;IAClE,IAAI,GAAG,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QAClC,OAAO,qBAAqB,CAAC,GAAG,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,GAAG,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;QACjC,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,IAAI,GAAG,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QAClC,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,IAAI,GAAG,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,0CAA0C;IAC1C,IAAI,gCAAgC,EAAE,CAAC;QACrC,MAAM,eAAe,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,gBAAM,CAAC,KAAK,CACV,8BAA8B,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAC7D,CAAC;YACF,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,CAAC,eAAe,EAAE,GAAG,UAAU,CAAC,GAAG,eAAe,CAAC;QACzD,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,CAClD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,KAAK,eAAe,CAC1C,CAAC;QAEF,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,gBAAM,CAAC,KAAK,CACV,2BAA2B,eAAe,iBAAiB,IAAI,CAAC,SAAS,CACvE,KAAK,CAAC,SAAS,EACf,IAAI,EACJ,CAAC,CACF,EAAE,CACJ,CAAC;YACF,qGAAqG;YACrG,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAI,QAAQ,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;YAChC,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,QAAQ,CAAC;QAC5C,MAAM,CAAC,QAAQ,EAAE,GAAG,qBAAqB,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrE,MAAM,cAAc,GAAG,GAAG,QAAQ,IAAI,qBAAqB,CAAC,IAAI,CAC9D,GAAG,CACJ,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAA,uBAAW,EAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACvD,MAAM,IAAI,GAAG,IAAA,+BAAa,EAAC,KAAK,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;QAEjE,gDAAgD;QAChD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACpD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,+CAA+C;QAC/C,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAtED,gDAsEC;AAED;;;GAGG;AACH,SAAS,cAAc,CAAC,GAAiB;IACvC,QAAQ,GAAG,CAAC,IAAI,EAAE,CAAC;QACjB,KAAK,YAAY;YACf,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACpB,KAAK,kBAAkB,CAAC,CAAC,CAAC;YACxB,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC1C,MAAM,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC,QAAwB,CAAC,CAAC;YAC9D,IAAI,MAAM,IAAI,QAAQ,EAAE,CAAC;gBACvB,OAAO,CAAC,GAAG,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC;YAClC,CAAC;iBAAM,CAAC;gBACN,OAAO,SAAS,CAAC;YACnB,CAAC;QACH,CAAC;QACD;YACE,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport template from \"@babel/template\";\nimport * as t from \"@babel/types\";\nimport { logger, AttributeType } from \"@cdktn/commons\";\nimport { ProgramScope } from \"./types\";\nimport deepEqual from \"deep-equal\";\nimport { tsFunctionsMap } from \"./function-bindings/functions\";\nimport { getTypeAtPath } from \"./terraformSchema\";\nimport { toSnakeCase } from \"codemaker\";\n\nfunction changeValueAccessor(\n  ast: t.MemberExpression,\n  newAccessor: string,\n): t.MemberExpression {\n  const propertyIdentifier: t.Identifier = {\n    ...(ast.property as t.Identifier),\n    name: newAccessor,\n  };\n  return {\n    ...ast,\n    property: propertyIdentifier,\n  };\n}\n\nexport function typeForCallExpression(ast: t.CallExpression): AttributeType {\n  // Find all cdktf.Fn.* || cdktn.Fn.* calls\n  if (\n    t.isMemberExpression(ast.callee) &&\n    t.isMemberExpression(ast.callee.object) &&\n    t.isIdentifier(ast.callee.object.object) &&\n    (ast.callee.object.object.name === \"cdktf\" ||\n      ast.callee.object.object.name === \"cdktn\") &&\n    t.isIdentifier(ast.callee.object.property) &&\n    ast.callee.object.property.name === \"Fn\" &&\n    t.isIdentifier(ast.callee.property)\n  ) {\n    const meta = tsFunctionsMap[ast.callee.property.name];\n    if (meta) {\n      return meta.returnType;\n    } else {\n      return \"dynamic\";\n    }\n  }\n\n  // cdktf.conditional, cdktf.propertyAccess, cdktf.Op.* are all dynamic\n  // By default we assume dynamic\n  return \"dynamic\";\n}\n\nexport const coerceType = (\n  scope: ProgramScope,\n  ast: t.Expression,\n  from: AttributeType,\n  to: AttributeType | undefined,\n): t.Expression => {\n  if (to === undefined) {\n    return ast;\n  }\n\n  if (deepEqual(to, from)) {\n    return ast;\n  }\n\n  const isTerraformVariableOrLocal =\n    ast.type === \"MemberExpression\" &&\n    ast.property.type === \"Identifier\" &&\n    ast.property.name === \"value\" &&\n    ast.object.type === \"Identifier\" &&\n    Object.values(scope.variables).some(\n      (knownVars) =>\n        knownVars.variableName === (ast.object as t.Identifier).name &&\n        [\"var\", \"local\"].includes(knownVars.resource),\n    );\n\n  const addTokenToImports = () =>\n    scope.importables.push({\n      constructName: \"Token\",\n      provider: \"cdktn\",\n    });\n\n  if (Array.isArray(to)) {\n    if (to[0] === \"list\" || to[0] === \"set\") {\n      switch (to[1]) {\n        case \"string\":\n          if (isTerraformVariableOrLocal) {\n            return changeValueAccessor(ast as t.MemberExpression, \"listValue\");\n          }\n\n          addTokenToImports();\n          return template.expression(`Token.asList(%%ast%%)`)({\n            ast: ast,\n          }) as t.Expression;\n        case \"number\":\n          addTokenToImports();\n          return template.expression(`Token.asNumberList(%%ast%%)`)({\n            ast: ast,\n          }) as t.Expression;\n        case \"bool\":\n          addTokenToImports();\n          return template.expression(`Token.asAny(%%ast%%)`)({\n            ast: ast,\n          }) as t.Expression;\n        default:\n          addTokenToImports();\n          return template.expression(`Token.asAny(%%ast%%)`)({\n            ast: ast,\n          }) as t.Expression;\n      }\n    }\n\n    if (to[0] === \"map\") {\n      switch (to[1]) {\n        case \"string\":\n          addTokenToImports();\n          return template.expression(`Token.asStringMap(%%ast%%)`)({\n            ast: ast,\n          }) as t.Expression;\n        case \"number\":\n          addTokenToImports();\n          return template.expression(`Token.asNumberMap(%%ast%%)`)({\n            ast: ast,\n          }) as t.Expression;\n        case \"bool\":\n          addTokenToImports();\n          return template.expression(`Token.asBooleanMap(%%ast%%)`)({\n            ast: ast,\n          }) as t.Expression;\n        default:\n          addTokenToImports();\n          return template.expression(`Token.asAnyMap(%%ast%%)`)({\n            ast: ast,\n          }) as t.Expression;\n      }\n    }\n  }\n\n  switch (to) {\n    case \"number\":\n      if (isTerraformVariableOrLocal) {\n        return changeValueAccessor(ast as t.MemberExpression, \"numberValue\");\n      }\n      addTokenToImports();\n      return template.expression(`Token.asNumber(%%ast%%)`)({\n        ast: ast,\n      }) as t.Expression;\n    case \"string\":\n      if (isTerraformVariableOrLocal) {\n        return changeValueAccessor(ast as t.MemberExpression, \"stringValue\");\n      }\n      addTokenToImports();\n      return template.expression(`Token.asString(%%ast%%)`)({\n        ast: ast,\n      }) as t.Expression;\n    case \"bool\":\n      if (isTerraformVariableOrLocal) {\n        return changeValueAccessor(ast as t.MemberExpression, \"booleanValue\");\n      }\n      addTokenToImports();\n      return template.expression(`Token.asBoolean(%%ast%%)`)({\n        ast: ast,\n      }) as t.Expression;\n  }\n\n  logger.debug(`Could not coerce from ${from} to ${to} for ${ast}`);\n  return ast;\n};\n\nexport function findExpressionType(\n  scope: ProgramScope,\n  ast: t.Expression,\n): AttributeType {\n  const isReferenceWithoutTemplateString =\n    ast.type === \"MemberExpression\" && ast.object.type === \"Identifier\";\n\n  // If we have a property to cdktf.propertyAccess call it's dynamic\n  if (ast.type === \"CallExpression\") {\n    return typeForCallExpression(ast);\n  }\n\n  if (ast.type === \"StringLiteral\") {\n    return \"string\";\n  }\n  if (ast.type === \"NumericLiteral\") {\n    return \"number\";\n  }\n  if (ast.type === \"BooleanLiteral\") {\n    return \"bool\";\n  }\n\n  // If we only have one reference this is a\n  if (isReferenceWithoutTemplateString) {\n    const destructuredAst = destructureAst(ast);\n    if (!destructuredAst) {\n      logger.debug(\n        `Could not destructure ast: ${JSON.stringify(ast, null, 2)}`,\n      );\n      return \"dynamic\";\n    }\n\n    const [astVariableName, ...attributes] = destructuredAst;\n    const variable = Object.values(scope.variables).find(\n      (x) => x.variableName === astVariableName,\n    );\n\n    if (!variable) {\n      logger.debug(\n        `Could not find variable ${astVariableName} given scope: ${JSON.stringify(\n          scope.variables,\n          null,\n          2,\n        )}`,\n      );\n      // We don't know, this should not happen, but if it does we assume the worst case and make it dynamic\n      return \"dynamic\";\n    }\n\n    if (variable.resource === \"var\") {\n      return \"dynamic\";\n    }\n\n    const { resource: resourceType } = variable;\n    const [provider, ...resourceNameFragments] = resourceType.split(\"_\");\n    const tfResourcePath = `${provider}.${resourceNameFragments.join(\n      \"_\",\n    )}.${attributes.map((x) => toSnakeCase(x)).join(\".\")}`;\n    const type = getTypeAtPath(scope.providerSchema, tfResourcePath);\n\n    // If this is an attribute type we can return it\n    if (typeof type === \"string\" || Array.isArray(type)) {\n      return type;\n    }\n\n    // Either nothing is found or it's a block type\n    return \"dynamic\";\n  }\n\n  return \"string\";\n}\n\n/*\n * Transforms a babel AST into a list of string accessors\n * e.g. foo.bar.baz -> [\"foo\", \"bar\", \"baz\"]\n */\nfunction destructureAst(ast: t.Expression): string[] | undefined {\n  switch (ast.type) {\n    case \"Identifier\":\n      return [ast.name];\n    case \"MemberExpression\": {\n      const object = destructureAst(ast.object);\n      const property = destructureAst(ast.property as t.Expression);\n      if (object && property) {\n        return [...object, ...property];\n      } else {\n        return undefined;\n      }\n    }\n    default:\n      return undefined;\n  }\n}\n"]}

package/lib/dynamic-blocks.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { DynamicBlock, TerraformResourceBlock } from "./types";
+export declare function isNestedDynamicBlock(dynBlocks: DynamicBlock[], block: DynamicBlock): boolean;
+export declare const extractDynamicBlocks: (config: TerraformResourceBlock, path?: string) => DynamicBlock[];
+//# sourceMappingURL=dynamic-blocks.d.ts.map

package/lib/dynamic-blocks.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDynamicBlocks = exports.isNestedDynamicBlock = void 0;
+function isNestedDynamicBlock(dynBlocks, block) {
+    return dynBlocks.some((dyn) => dyn.path !== block.path && block.path.startsWith(dyn.path));
+}
+exports.isNestedDynamicBlock = isNestedDynamicBlock;
+const extractDynamicBlocks = (config, path = "") => {
+    if (typeof config !== "object") {
+        return [];
+    }
+    if (!config) {
+        return [];
+    }
+    if (Array.isArray(config)) {
+        return config.reduce((carry, item, index) => [
+            ...carry,
+            ...(0, exports.extractDynamicBlocks)(item, `${path}.${index}`),
+        ], []);
+    }
+    if ("dynamic" in config) {
+        const dynamic = config.dynamic;
+        const scopedVar = Object.keys(dynamic)[0];
+        const { for_each, content } = dynamic[scopedVar][0];
+        return [
+            {
+                path: `${path}.dynamic.${scopedVar}`,
+                for_each,
+                content,
+                scopedVar,
+            },
+            ...(0, exports.extractDynamicBlocks)(content, `${path}.dynamic.${scopedVar}.0.content`),
+        ];
+    }
+    return Object.entries(config).reduce((carry, [key, value]) => {
+        return [...carry, ...(0, exports.extractDynamicBlocks)(value, `${path}.${key}`)];
+    }, []);
+};
+exports.extractDynamicBlocks = extractDynamicBlocks;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/expressions.d.ts

@@ -0,0 +1,9 @@
+import * as t from "@babel/types";
+import { IteratorVariableReference, ProgramScope, ResourceScope } from "./types";
+import { TFExpressionSyntaxTree as tex } from "@cdktn/hcl2json";
+import { AttributeType } from "@cdktn/commons";
+export declare function expressionAst(input: string): Promise<tex.ExpressionType>;
+export declare function convertTerraformExpressionToTs(scope: ResourceScope, input: string, targetType: () => AttributeType): Promise<t.Expression>;
+export declare function extractIteratorVariablesFromExpression(input: string): Promise<IteratorVariableReference[]>;
+export declare function dynamicVariableToAst(scope: ProgramScope, node: tex.ScopeTraversalExpression, iteratorName: string, block?: string): t.Expression;
+//# sourceMappingURL=expressions.d.ts.map