terraconstructs 0.0.10 → 0.0.12

package/lib/terra-func.js

@@ -0,0 +1,170 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fn = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v/packages/aws-cdk-lib/core/lib/cfn-fn.ts
+const cdktf_1 = require("cdktf");
+/**
+ * TerraConstructs helper functions.
+ */
+class Fn extends cdktf_1.Fn {
+    /**
+     * Split a string token into a token list of string values.
+     *
+     * Specify the location of splits with a delimiter such as ',' (a comma).
+     * Renders to the `split` intrinsic terraform function.
+     *
+     * Lists with unknown lengths (default)
+     * -------------------------------------
+     *
+     * Since this function is used to work with deploy-time values, if `assumedLength`
+     * is not given the CDK cannot know the length of the resulting list at synthesis time.
+     * This brings the following restrictions:
+     *
+     * - You must use `Fn.element(list, i)` to pick elements out of the list (you must not use
+     *   `list[i]`).
+     * - You cannot add elements to the list, remove elements from the list,
+     *   combine two such lists together, or take a slice of the list.
+     * - You cannot pass the list to constructs that do any of the above.
+     *
+     * The only valid operation with such a tokenized list is to pass it unmodified to a
+     * Terraform Resource construct.
+     *
+     * Lists with assumed lengths
+     * --------------------------
+     *
+     * Pass `assumedLength` if you know the length of the list that will be
+     * produced by splitting. The actual list length at deploy time may be
+     * *longer* than the number you pass, but not *shorter*.
+     *
+     * The returned list will look like:
+     *
+     * ```
+     * [Fn.element(split, 0), Fn.element(split, 1), Fn.element(split, 2), ...]
+     * ```
+     *
+     * The restrictions from the section "Lists with unknown lengths" will now be lifted,
+     * at the expense of having to know and fix the length of the list.
+     *
+     * @param delimiter A string value that determines where the source string is divided.
+     * @param source The string value that you want to split.
+     * @param assumedLength The length of the list that will be produced by splitting
+     * @returns a token represented as a string array
+     */
+    static splitv2(delimiter, source, assumedLength) {
+        // short-circuit if source is not a token
+        if (!cdktf_1.Token.isUnresolved(source)) {
+            return source.split(delimiter);
+        }
+        if (cdktf_1.Token.isUnresolved(delimiter)) {
+            throw new Error("Fn.splitv2: 'delimiter' may not be a token value");
+        }
+        const split = cdktf_1.Token.asList(cdktf_1.Fn.split(delimiter, source));
+        if (assumedLength === undefined) {
+            return split;
+        }
+        if (cdktf_1.Token.isUnresolved(assumedLength)) {
+            throw new Error("Fn.split: 'assumedLength' may not be a token value");
+        }
+        return range(assumedLength).map((i) => cdktf_1.Fn.element(split, i));
+    }
+    /**
+     * Similar to Fn.element, but with a shortcut if list is not unresolved
+     *
+     * The intrinsic function ``element`` returns a single object from a list of objects by index.
+     * @param index The index of the object to retrieve. This must be a value from zero to N-1, where N represents the number of elements in the array.
+     * @param array The list of objects to select from. This list must not be null, nor can it have null entries.
+     * @returns a token represented as a string
+     */
+    static select(index, array) {
+        // short-circuit if source is not a token
+        if (!cdktf_1.Token.isUnresolved(index) &&
+            !cdktf_1.Token.isUnresolved(array) &&
+            !array.some(cdktf_1.Token.isUnresolved)) {
+            return array[index];
+        }
+        return cdktf_1.Fn.element(array, index);
+    }
+    /**
+     * Given an url, parse the domain name
+     * @param url the url to parse
+     */
+    static parseDomainName(url) {
+        const noHttps = Fn.select(1, Fn.split("//", url));
+        return Fn.select(0, Fn.split("/", noHttps));
+    }
+    /**
+     * The intrinsic function ``Fn::ImportValue`` returns the value of an output
+     * exported by another stack. You typically use this function to create
+     * cross-stack references. In the following example template snippets, Stack A
+     * exports VPC security group values and Stack B imports them.
+     * @param id The stack output value that you want to import.
+     * @returns a token represented as a string
+     */
+    static importValue(scope, id, options = {}) {
+        // TODO: This should be a terraform remote state data source instead
+        const importVariable = new cdktf_1.TerraformVariable(scope, id, options);
+        return importVariable.stringValue;
+    }
+    /**
+     * Like `Fn.importValue`, but import a list with a known length
+     *
+     * If you explicitly want a list with an unknown length, call `Fn.splitv2(',',
+     * Fn.importValue(scope, exportName))`. See the documentation of `Fn.splitv2` to read
+     * more about the limitations of using lists of unknown length.
+     *
+     * `Fn.importListValue(scope, exportName, assumedLength)` is the same as
+     * `Fn.split(',', Fn.importValue(scope, exportName), assumedLength)`,
+     * but easier to read and impossible to forget to pass `assumedLength`.
+     */
+    static importListValue(scope, sharedValueToImport, assumedLength, delimiter = ",") {
+        return Fn.splitv2(delimiter, Fn.importValue(scope, sharedValueToImport), assumedLength);
+    }
+    /**
+     * The intrinsic function `Fn::Length` returns the number of elements within an array
+     * or an intrinsic function that returns an array.
+     *
+     * @param array The array you want to return the number of elements from
+     */
+    static len(array) {
+        // short-circuit if array is not a token
+        if (!cdktf_1.Token.isUnresolved(array)) {
+            if (!Array.isArray(array)) {
+                throw new Error("Fn.length() needs an array");
+            }
+            return array.length;
+        }
+        return cdktf_1.Fn.lengthOf(array);
+    }
+    /**
+     * {@link https://developer.hashicorp.com/terraform/language/functions/join join} produces a string by concatenating together all elements of a given list of strings with the given delimiter.
+     *
+     * If any of the values are unresolved, the intrinsic function will be used.
+     * if the list has only one element, the element will be returned.
+     * if the list has more than one element, the elements will be joined with the delimiter.
+     * @param {string} delimiter
+     * @param {Array<string>} values
+     */
+    static join(delimiter, values) {
+        if (cdktf_1.Token.isUnresolved(values)) {
+            // This is a list token, don't try to do smart things with it.
+            return cdktf_1.Fn.join(delimiter, values);
+        }
+        if (values.length === 1) {
+            return values[0];
+        }
+        return values.join(delimiter);
+    }
+}
+exports.Fn = Fn;
+_a = JSII_RTTI_SYMBOL_1;
+Fn[_a] = { fqn: "terraconstructs.Fn", version: "0.0.12" };
+function range(n) {
+    const ret = [];
+    for (let i = 0; i < n; i++) {
+        ret.push(i);
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terra-func.js","sourceRoot":"","sources":["../src/terra-func.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v/packages/aws-cdk-lib/core/lib/cfn-fn.ts\n\nimport {\n  TerraformVariable,\n  TerraformVariableConfig,\n  Token,\n  Fn as tfFn,\n} from \"cdktf\";\nimport { Construct } from \"constructs\";\n\n/**\n * TerraConstructs helper functions.\n */\nexport class Fn extends tfFn {\n  /**\n   * Split a string token into a token list of string values.\n   *\n   * Specify the location of splits with a delimiter such as ',' (a comma).\n   * Renders to the `split` intrinsic terraform function.\n   *\n   * Lists with unknown lengths (default)\n   * -------------------------------------\n   *\n   * Since this function is used to work with deploy-time values, if `assumedLength`\n   * is not given the CDK cannot know the length of the resulting list at synthesis time.\n   * This brings the following restrictions:\n   *\n   * - You must use `Fn.element(list, i)` to pick elements out of the list (you must not use\n   *   `list[i]`).\n   * - You cannot add elements to the list, remove elements from the list,\n   *   combine two such lists together, or take a slice of the list.\n   * - You cannot pass the list to constructs that do any of the above.\n   *\n   * The only valid operation with such a tokenized list is to pass it unmodified to a\n   * Terraform Resource construct.\n   *\n   * Lists with assumed lengths\n   * --------------------------\n   *\n   * Pass `assumedLength` if you know the length of the list that will be\n   * produced by splitting. The actual list length at deploy time may be\n   * *longer* than the number you pass, but not *shorter*.\n   *\n   * The returned list will look like:\n   *\n   * ```\n   * [Fn.element(split, 0), Fn.element(split, 1), Fn.element(split, 2), ...]\n   * ```\n   *\n   * The restrictions from the section \"Lists with unknown lengths\" will now be lifted,\n   * at the expense of having to know and fix the length of the list.\n   *\n   * @param delimiter A string value that determines where the source string is divided.\n   * @param source The string value that you want to split.\n   * @param assumedLength The length of the list that will be produced by splitting\n   * @returns a token represented as a string array\n   */\n  public static splitv2(\n    delimiter: string,\n    source: string,\n    assumedLength?: number,\n  ): string[] {\n    // short-circuit if source is not a token\n    if (!Token.isUnresolved(source)) {\n      return source.split(delimiter);\n    }\n\n    if (Token.isUnresolved(delimiter)) {\n      throw new Error(\"Fn.splitv2: 'delimiter' may not be a token value\");\n    }\n\n    const split = Token.asList(tfFn.split(delimiter, source));\n    if (assumedLength === undefined) {\n      return split;\n    }\n\n    if (Token.isUnresolved(assumedLength)) {\n      throw new Error(\"Fn.split: 'assumedLength' may not be a token value\");\n    }\n\n    return range(assumedLength).map((i) => tfFn.element(split, i));\n  }\n  /**\n   * Similar to Fn.element, but with a shortcut if list is not unresolved\n   *\n   * The intrinsic function ``element`` returns a single object from a list of objects by index.\n   * @param index The index of the object to retrieve. This must be a value from zero to N-1, where N represents the number of elements in the array.\n   * @param array The list of objects to select from. This list must not be null, nor can it have null entries.\n   * @returns a token represented as a string\n   */\n  public static select(index: number, array: string[]): string {\n    // short-circuit if source is not a token\n    if (\n      !Token.isUnresolved(index) &&\n      !Token.isUnresolved(array) &&\n      !array.some(Token.isUnresolved)\n    ) {\n      return array[index];\n    }\n\n    return tfFn.element(array, index);\n  }\n\n  /**\n   * Given an url, parse the domain name\n   * @param url the url to parse\n   */\n  public static parseDomainName(url: string): string {\n    const noHttps = Fn.select(1, Fn.split(\"//\", url));\n    return Fn.select(0, Fn.split(\"/\", noHttps));\n  }\n\n  /**\n   * The intrinsic function ``Fn::ImportValue`` returns the value of an output\n   * exported by another stack. You typically use this function to create\n   * cross-stack references. In the following example template snippets, Stack A\n   * exports VPC security group values and Stack B imports them.\n   * @param id The stack output value that you want to import.\n   * @returns a token represented as a string\n   */\n  public static importValue(\n    scope: Construct,\n    id: string,\n    options: TerraformVariableConfig = {},\n  ): string {\n    // TODO: This should be a terraform remote state data source instead\n    const importVariable = new TerraformVariable(scope, id, options);\n    return importVariable.stringValue;\n  }\n\n  /**\n   * Like `Fn.importValue`, but import a list with a known length\n   *\n   * If you explicitly want a list with an unknown length, call `Fn.splitv2(',',\n   * Fn.importValue(scope, exportName))`. See the documentation of `Fn.splitv2` to read\n   * more about the limitations of using lists of unknown length.\n   *\n   * `Fn.importListValue(scope, exportName, assumedLength)` is the same as\n   * `Fn.split(',', Fn.importValue(scope, exportName), assumedLength)`,\n   * but easier to read and impossible to forget to pass `assumedLength`.\n   */\n  public static importListValue(\n    scope: Construct,\n    sharedValueToImport: string,\n    assumedLength: number,\n    delimiter = \",\",\n  ): string[] {\n    return Fn.splitv2(\n      delimiter,\n      Fn.importValue(scope, sharedValueToImport),\n      assumedLength,\n    );\n  }\n  /**\n   * The intrinsic function `Fn::Length` returns the number of elements within an array\n   * or an intrinsic function that returns an array.\n   *\n   * @param array The array you want to return the number of elements from\n   */\n  public static len(array: any): number {\n    // short-circuit if array is not a token\n    if (!Token.isUnresolved(array)) {\n      if (!Array.isArray(array)) {\n        throw new Error(\"Fn.length() needs an array\");\n      }\n      return array.length;\n    }\n    return tfFn.lengthOf(array);\n  }\n\n  /**\n   * {@link https://developer.hashicorp.com/terraform/language/functions/join join} produces a string by concatenating together all elements of a given list of strings with the given delimiter.\n   *\n   * If any of the values are unresolved, the intrinsic function will be used.\n   * if the list has only one element, the element will be returned.\n   * if the list has more than one element, the elements will be joined with the delimiter.\n   * @param {string} delimiter\n   * @param {Array<string>} values\n   */\n  public static join(delimiter: string, values: string[]): string {\n    if (Token.isUnresolved(values)) {\n      // This is a list token, don't try to do smart things with it.\n      return tfFn.join(delimiter, values);\n    }\n    if (values.length === 1) {\n      return values[0];\n    }\n    return values.join(delimiter);\n  }\n}\n\nfunction range(n: number): number[] {\n  const ret = [];\n  for (let i = 0; i < n; i++) {\n    ret.push(i);\n  }\n  return ret;\n}\n"]}

package/lib/token.js

@@ -1,8 +1,10 @@
 "use strict";
+// https://github.com/aws/aws-cdk/blob/v2.150.0/packages/aws-cdk-lib/core/lib/token.ts
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withResolved = exports.tokenCompareStrings = exports.TokenComparison = void 0;
+exports.TokenComparison = void 0;
+exports.tokenCompareStrings = tokenCompareStrings;
+exports.withResolved = withResolved;
 const cdktf_1 = require("cdktf");
-// https://github.com/aws/aws-cdk/blob/v2.150.0/packages/aws-cdk-lib/core/lib/token.ts
 /**
  * An enum-like class that represents the result of comparing two Tokens.
  * The return type of `Token.compareStrings`.
@@ -39,7 +41,6 @@ function tokenCompareStrings(possibleToken1, possibleToken2) {
         ? TokenComparison.SAME
         : TokenComparison.DIFFERENT;
 }
-exports.tokenCompareStrings = tokenCompareStrings;
 function withResolved(...args) {
     if (args.length < 2) {
         return;
@@ -50,5 +51,4 @@ function withResolved(...args) {
     }
     args[args.length - 1].apply(arguments, argArray);
 }
-exports.withResolved = withResolved;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -10,13 +10,15 @@
     "organization": false
   },
   "devDependencies": {
-    "@cdktf/provider-aws": "19.34.0",
+    "@cdktf/provider-aws": "19.54.0",
+    "@cdktf/provider-cloudinit": "10.0.3",
     "@cdktf/provider-time": "10.2.1",
+    "@cdktf/provider-tls": "10.0.1",
     "@jsii/spec": "^1.102.0",
     "@mrgrain/jsii-struct-builder": "^0.7.43",
     "@types/jest": "^29.5.13",
     "@types/mime-types": "^2.1.4",
-    "@types/node": "ts5.4",
+    "@types/node": "ts5.7",
     "@typescript-eslint/eslint-plugin": "^7",
     "@typescript-eslint/parser": "^7",
     "cdktf": "0.20.8",
@@ -29,19 +31,21 @@
     "eslint-plugin-prettier": "^5.2.1",
     "jest": "^29.7.0",
     "jest-junit": "^15",
-    "jsii": "~5.4",
+    "jsii": "~5.7",
     "jsii-diff": "^1.103.1",
     "jsii-pacmak": "^1.103.1",
-    "jsii-rosetta": "~5.4",
+    "jsii-rosetta": "~5.7",
     "prettier": "^3.3.3",
     "projen": "^0.88.0",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
-    "typescript": "~5.4"
+    "typescript": "~5.7"
   },
   "peerDependencies": {
-    "@cdktf/provider-aws": "^19.34.0",
+    "@cdktf/provider-aws": "^19.54.0",
+    "@cdktf/provider-cloudinit": "10.0.3",
     "@cdktf/provider-time": "^10.2.1",
+    "@cdktf/provider-tls": "10.0.1",
     "cdktf": "^0.20.8",
     "constructs": "^10.3.0"
   },
@@ -66,12 +70,14 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.10",
+  "version": "0.0.12",
   "jest": {
     "coverageProvider": "v8",
     "setupFilesAfterEnv": [
       "<rootDir>/setup.js"
     ],
+    "maxWorkers": "50%",
+    "testEnvironment": "node",
     "testMatch": [
       "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
       "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
@@ -110,7 +116,8 @@
       "^.+\\.[t]sx?$": [
         "ts-jest",
         {
-          "tsconfig": "tsconfig.dev.json"
+          "tsconfig": "tsconfig.dev.json",
+          "isolatedModules": true
         }
       ]
     }