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

package/src/function-bindings/functions.ts

@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import { AttributeType } from "@cdktn/commons";
+import { functionsMapGenerated } from "./functions.generated";
+import { TFExpressionSyntaxTree as tex } from "@cdktn/hcl2json";
+
+type FunctionCall = any; // TODO: this will come from the types for hcl2json (aka from the Terraform AST)
+
+type FunctionMeta = {
+  name: string;
+  returnType: AttributeType;
+  parameters: {
+    type: AttributeType;
+    optional?: boolean;
+    variadic?: boolean;
+  }[];
+  /**
+   * Allows transforming the function call before it is handled. This is currently used to handle
+   * different APIs between TF supporting join(sep, listA, listB) and CDKTN only supporting join(sep, list)
+   * (as the alternative due to JSIIs lack of support for variadic parametes would be join(sep, lists) which
+   *  would have a worse UX as most often just a single list is passed)
+   * In the case of join() the transformer will convert the function call to join(sep, concat(listA, listB))
+   * before handling it
+   *
+   * Caution: Beware of infinite recursion if the returned function call is to the same function that has this
+   * transformer. Return the same instance of the passed functionCall to break out of that recursion.
+   */
+  transformer?: (functionCall: FunctionCall) => FunctionCall;
+};
+
+export const functionsMap: Record<string, FunctionMeta> = {
+  ...(functionsMapGenerated as any),
+
+  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: tex.FunctionCallExpression) => {
+      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" }],
+  },
+};
+
+export const tsFunctionsMap = Object.entries(functionsMap).reduce(
+  (acc, [name, fnInfo]) => {
+    // Swap the names around
+    acc[fnInfo.name] = { ...fnInfo, name: name };
+    return acc;
+  },
+  {} as Record<string, FunctionMeta>,
+);