@cdktn/hcl2cdk 0.23.0-pre.4 → 0.23.0-pre.41

package/build/function-bindings/functions.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsFunctionsMap = exports.functionsMap = void 0;
+const functions_generated_1 = require("./functions.generated");
+exports.functionsMap = {
+    ...functions_generated_1.functionsMapGenerated,
+    bcrypt: {
+        name: "bcrypt", // this one is not variadic anymore after we mapped it
+        returnType: "string",
+        parameters: [{ type: "string" }, { type: "number", optional: true }],
+    },
+    join: {
+        name: "join",
+        returnType: "string",
+        parameters: [{ type: "string" }, { type: ["list", "string"] }],
+        /**
+         * Terraform supports join(separator, listA, listB)
+         * wheras CDKTN only supports join(separator, list) (to make it simpler to use as JSII does not support variadic parameters)
+         * and we'd need to convert this to join(separator, concat(listA, listB)) if multiple variadic args are passed
+         */
+        transformer: (fc) => {
+            if (fc.children.length <= 2) {
+                return fc; // just one child -> nothing to do
+            }
+            const concatFunction = {
+                type: "function",
+                meta: {
+                    name: "concat",
+                    expandedFinalArgument: fc.meta.expandedFinalArgument,
+                    nameRange: {},
+                    openParenRange: {},
+                    closeParenRange: {},
+                    argsRanges: [],
+                },
+                children: fc.children.slice(1),
+            };
+            return {
+                type: "function",
+                meta: {
+                    name: "join",
+                },
+                children: [
+                    fc.children[0], // the first parameter is the separator, so keep it as is
+                    concatFunction,
+                ],
+            };
+        },
+    },
+    range: {
+        name: "range",
+        returnType: ["list", "string"], // TODO: Fn.range() currently returns string[] but should return number[] (according to functions.json)
+        parameters: [
+            { type: "number" },
+            { type: "number" },
+            { type: "number", optional: true },
+        ],
+    },
+    lookup: {
+        name: "lookup",
+        returnType: "dynamic",
+        parameters: [{ type: "dynamic" }, { type: "string" }, { type: "dynamic" }],
+    },
+};
+exports.tsFunctionsMap = Object.entries(exports.functionsMap).reduce((acc, [name, fnInfo]) => {
+    // Swap the names around
+    acc[fnInfo.name] = { ...fnInfo, name: name };
+    return acc;
+}, {});
+//# sourceMappingURL=data:application/json;base64,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