cdktn 0.26.0-pre.20 → 0.26.0-pre.21

package/lib/functions/helpers.d.ts

@@ -5,19 +5,91 @@ type TFValue<T> = {
 };
 type TFValueValidator<T> = (value: T) => TFValue<T>;
 type ExecutableTfFunction = (...args: any[]) => IResolvable;
+/**
+ * Validator that accepts any value
+ * @param value Value to validate
+ * @returns The wrapped value
+ */
 export declare function anyValue<T>(value: T): TFValue<T>;
+/**
+ * Validator for map values; accepts any value without checking it
+ * @param value Value to validate
+ * @returns The wrapped value
+ */
 export declare function mapValue<T>(value: T): TFValue<T>;
+/**
+ * Validator that accepts a string or a token
+ * @param value Value to validate
+ * @returns The wrapped value
+ * @throws If the value is neither a string nor a token, or is a string containing unescaped double quotes
+ */
 export declare function stringValue<T extends string>(value: T): TFValue<T>;
+/**
+ * Validator that accepts a number or a token
+ * @param value Value to validate
+ * @returns The wrapped value
+ * @throws If the value is neither a number nor a token
+ */
 export declare function numericValue<T>(value: T): TFValue<T>;
+/**
+ * Creates a validator for lists whose elements are checked with the given element validator. Tokens and non-array
+ * values pass through unchanged; `null`/`undefined` elements are dropped, token elements are kept as-is and plain
+ * string elements are wrapped in double quotes.
+ * @param type Validator applied to each non-token element
+ * @returns A list validator that throws if an element fails the element validator
+ */
 export declare function listOf<T>(type: TFValueValidator<T>): TFValueValidator<T[]>;
+/**
+ * Creates a validator for a variadic argument: validates the value as a list and marks it to be expanded into
+ * separate arguments of the Terraform function call
+ * @param type Validator applied to each element
+ * @returns A validator for the variadic argument
+ */
 export declare function variadic<T>(type: TFValueValidator<T>): TFValueValidator<T[]>;
+/**
+ * Converts a resolvable into a string token
+ * @param value Resolvable to convert
+ * @returns String token
+ */
 export declare function asString(value: IResolvable): string;
+/**
+ * Converts a resolvable into a number token
+ * @param value Resolvable to convert
+ * @returns Number token
+ */
 export declare function asNumber(value: IResolvable): number;
+/**
+ * Converts a resolvable into a string list token
+ * @param value Resolvable to convert
+ * @returns String list token
+ */
 export declare function asList(value: IResolvable): string[];
+/**
+ * Converts a resolvable into a string map token
+ * @param value Resolvable to convert
+ * @returns String map token
+ */
 export declare function asStringMap(value: IResolvable): {
     [key: string]: string;
 };
+/**
+ * Returns the resolvable unchanged, as booleans can not be represented as a token
+ * @param value Resolvable to return
+ * @returns The same resolvable
+ */
 export declare function asBoolean(value: IResolvable): IResolvable;
+/**
+ * Converts a resolvable into a string token typed as `any`
+ * @param value Resolvable to convert
+ * @returns String token typed as `any`
+ */
 export declare function asAny(value: IResolvable): any;
+/**
+ * Creates a function that validates its arguments and returns a Terraform function call expression
+ * @param name Name of the Terraform function
+ * @param argValidators Validators for each positional argument
+ * @returns A function returning the call expression; it throws if the number of arguments does not match the
+ * validators or an argument fails validation
+ */
 export declare function terraformFunction(name: string, argValidators: TFValueValidator<any>[]): ExecutableTfFunction;
 export {};

package/lib/functions/helpers.js

@@ -28,15 +28,28 @@ function hasUnescapedDoubleQuotes(str) {
     return /(^|[^\\])([\\]{2})*"/.test(str);
 }
 // Validators
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Validator that accepts any value
+ * @param value Value to validate
+ * @returns The wrapped value
+ */
 function anyValue(value) {
     return { value };
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Validator for map values; accepts any value without checking it
+ * @param value Value to validate
+ * @returns The wrapped value
+ */
 function mapValue(value) {
     return { value };
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Validator that accepts a string or a token
+ * @param value Value to validate
+ * @returns The wrapped value
+ * @throws If the value is neither a string nor a token, or is a string containing unescaped double quotes
+ */
 function stringValue(value) {
     if (typeof value !== "string" && !token_1.Tokenization.isResolvable(value)) {
         throw (0, errors_1.valueIsInvalidStringOrToken)(value);
@@ -46,14 +59,25 @@ function stringValue(value) {
     }
     return { value };
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Validator that accepts a number or a token
+ * @param value Value to validate
+ * @returns The wrapped value
+ * @throws If the value is neither a number nor a token
+ */
 function numericValue(value) {
     if (typeof value !== "number" && !token_1.Tokenization.isResolvable(value)) {
         throw (0, errors_1.valueIsInvalidNumberOrToken)(value);
     }
     return { value };
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Creates a validator for lists whose elements are checked with the given element validator. Tokens and non-array
+ * values pass through unchanged; `null`/`undefined` elements are dropped, token elements are kept as-is and plain
+ * string elements are wrapped in double quotes.
+ * @param type Validator applied to each non-token element
+ * @returns A list validator that throws if an element fails the element validator
+ */
 function listOf(type) {
     return (value) => {
         if (token_1.Tokenization.isResolvable(value)) {
@@ -97,7 +121,12 @@ function listOf(type) {
         };
     };
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Creates a validator for a variadic argument: validates the value as a list and marks it to be expanded into
+ * separate arguments of the Terraform function call
+ * @param type Validator applied to each element
+ * @returns A validator for the variadic argument
+ */
 function variadic(type) {
     return (value) => {
         // we use the list validator and set variadic to true in order to have it expanded in the args passed to the TF function
@@ -105,27 +134,51 @@ function variadic(type) {
     };
 }
 // Tokenization
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Converts a resolvable into a string token
+ * @param value Resolvable to convert
+ * @returns String token
+ */
 function asString(value) {
     return token_1.Token.asString(value);
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Converts a resolvable into a number token
+ * @param value Resolvable to convert
+ * @returns Number token
+ */
 function asNumber(value) {
     return token_1.Token.asNumber(value);
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Converts a resolvable into a string list token
+ * @param value Resolvable to convert
+ * @returns String list token
+ */
 function asList(value) {
     return token_1.Token.asList(value);
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Converts a resolvable into a string map token
+ * @param value Resolvable to convert
+ * @returns String map token
+ */
 function asStringMap(value) {
     return token_1.Token.asStringMap(value);
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Returns the resolvable unchanged, as booleans can not be represented as a token
+ * @param value Resolvable to return
+ * @returns The same resolvable
+ */
 function asBoolean(value) {
     return value; // Booleans can not be represented as a token
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Converts a resolvable into a string token typed as `any`
+ * @param value Resolvable to convert
+ * @returns String token typed as `any`
+ */
 function asAny(value) {
     // Ordinarily casting to any can cause issues, but
     // in this case it makes using functions a bit easier in TS
@@ -134,7 +187,13 @@ function asAny(value) {
     // so wrap as a string.
     return asString(value);
 }
-// eslint-disable-next-line jsdoc/require-jsdoc
+/**
+ * Creates a function that validates its arguments and returns a Terraform function call expression
+ * @param name Name of the Terraform function
+ * @param argValidators Validators for each positional argument
+ * @returns A function returning the call expression; it throws if the number of arguments does not match the
+ * validators or an argument fails validation
+ */
 function terraformFunction(name, argValidators) {
     return function (...args) {
         if (args.length !== argValidators.length) {
@@ -157,4 +216,4 @@ function terraformFunction(name, argValidators) {
         }, []));
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/functions/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { Tokenization, Token } from \"../tokens/token\";\nimport { call } from \"../tfExpression\";\nimport { IResolvable } from \"../tokens/resolvable\";\nimport { TokenString, extractTokenDouble } from \"../tokens/private/encoding\";\nimport {\n  functionArgumentValidationFailure,\n  functionReceivedWrongNumberOfArgs,\n  listElementIsOfWrongType,\n  valueContainsUnescapedQuotes,\n  valueIsInvalidNumberOrToken,\n  valueIsInvalidStringOrToken,\n} from \"../errors\";\n\ntype TFValue<T> = { variadic?: boolean; value: T };\ntype TFValueValidator<T> = (value: T) => TFValue<T>;\n\ntype ExecutableTfFunction = (...args: any[]) => IResolvable;\n\n/**\n * Determines if given str has unescaped double quotes\n * @param str String to test\n * @returns Boolean\n */\nfunction hasUnescapedDoubleQuotes(str: string) {\n  return /(^|[^\\\\])([\\\\]{2})*\"/.test(str);\n}\n\n// Validators\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function anyValue<T>(value: T): TFValue<T> {\n  return { value };\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function mapValue<T>(value: T): TFValue<T> {\n  return { value };\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function stringValue<T extends string>(value: T): TFValue<T> {\n  if (typeof value !== \"string\" && !Tokenization.isResolvable(value)) {\n    throw valueIsInvalidStringOrToken(value);\n  }\n\n  if (typeof value === \"string\" && hasUnescapedDoubleQuotes(value)) {\n    throw valueContainsUnescapedQuotes(value);\n  }\n\n  return { value };\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function numericValue<T>(value: T): TFValue<T> {\n  if (typeof value !== \"number\" && !Tokenization.isResolvable(value)) {\n    throw valueIsInvalidNumberOrToken(value as string);\n  }\n  return { value };\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function listOf<T>(type: TFValueValidator<T>): TFValueValidator<T[]> {\n  return (value: any) => {\n    if (Tokenization.isResolvable(value)) {\n      return { value };\n    }\n\n    if (!Array.isArray(value)) {\n      //   throw new Error(`${value} is not a valid list`);\n      return { value };\n    }\n\n    return {\n      value: value\n        .filter((item) => item !== undefined && item !== null)\n        .map((item, i) => {\n          if (Tokenization.isResolvable(item)) {\n            return item;\n          }\n\n          if (TokenString.forListToken(item).test()) {\n            return item;\n          }\n\n          if (extractTokenDouble(item, true) !== undefined) {\n            return item;\n          }\n\n          if (TokenString.forMapToken(item).test()) {\n            return item;\n          }\n\n          if (typeof item === \"string\") {\n            const tokenList = Tokenization.reverseString(item);\n            const numberOfTokens =\n              tokenList.tokens.length + tokenList.intrinsic.length;\n            if (numberOfTokens === 1 && tokenList.literals.length === 0) {\n              return item;\n            }\n          }\n\n          try {\n            type(item);\n            return typeof item === \"string\" ? `\"${item}\"` : item;\n          } catch (error) {\n            throw listElementIsOfWrongType(value, i, error);\n          }\n        }),\n    };\n  };\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function variadic<T>(type: TFValueValidator<T>): TFValueValidator<T[]> {\n  return (value: any) => {\n    // we use the list validator and set variadic to true in order to have it expanded in the args passed to the TF function\n    return { value: listOf(type)(value).value, variadic: true };\n  };\n}\n\n// Tokenization\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function asString(value: IResolvable) {\n  return Token.asString(value);\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function asNumber(value: IResolvable) {\n  return Token.asNumber(value);\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function asList(value: IResolvable) {\n  return Token.asList(value);\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function asStringMap(value: IResolvable) {\n  return Token.asStringMap(value);\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function asBoolean(value: IResolvable) {\n  return value; // Booleans can not be represented as a token\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function asAny(value: IResolvable) {\n  // Ordinarily casting to any can cause issues, but\n  // in this case it makes using functions a bit easier in TS\n  // and doesn't really harm other languages.\n  // Jsii has issues when returning the value directly,\n  // so wrap as a string.\n  return asString(value) as any;\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function terraformFunction(\n  name: string,\n  argValidators: TFValueValidator<any>[],\n): ExecutableTfFunction {\n  return function (...args: any[]) {\n    if (args.length !== argValidators.length) {\n      throw functionReceivedWrongNumberOfArgs(\n        name,\n        argValidators.length,\n        args.length,\n      );\n    }\n    return call(\n      name,\n      // We use flatMap now, since listOf() wraps everything in an extra array but variadic() does not\n      // This enables us to have variadic pass multiple args into the call() from a single array\n      args.reduce((carry, arg, i) => {\n        try {\n          const val = argValidators[i](arg);\n          if (val.variadic) return [...carry, ...val.value];\n          else return [...carry, val.value];\n        } catch (error) {\n          throw functionArgumentValidationFailure(i, name, error);\n        }\n      }, []),\n    );\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/functions/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { Tokenization, Token } from \"../tokens/token\";\nimport { call } from \"../tfExpression\";\nimport { IResolvable } from \"../tokens/resolvable\";\nimport { TokenString, extractTokenDouble } from \"../tokens/private/encoding\";\nimport {\n  functionArgumentValidationFailure,\n  functionReceivedWrongNumberOfArgs,\n  listElementIsOfWrongType,\n  valueContainsUnescapedQuotes,\n  valueIsInvalidNumberOrToken,\n  valueIsInvalidStringOrToken,\n} from \"../errors\";\n\ntype TFValue<T> = { variadic?: boolean; value: T };\ntype TFValueValidator<T> = (value: T) => TFValue<T>;\n\ntype ExecutableTfFunction = (...args: any[]) => IResolvable;\n\n/**\n * Determines if given str has unescaped double quotes\n * @param str String to test\n * @returns Boolean\n */\nfunction hasUnescapedDoubleQuotes(str: string) {\n  return /(^|[^\\\\])([\\\\]{2})*\"/.test(str);\n}\n\n// Validators\n/**\n * Validator that accepts any value\n * @param value Value to validate\n * @returns The wrapped value\n */\nexport function anyValue<T>(value: T): TFValue<T> {\n  return { value };\n}\n\n/**\n * Validator for map values; accepts any value without checking it\n * @param value Value to validate\n * @returns The wrapped value\n */\nexport function mapValue<T>(value: T): TFValue<T> {\n  return { value };\n}\n\n/**\n * Validator that accepts a string or a token\n * @param value Value to validate\n * @returns The wrapped value\n * @throws If the value is neither a string nor a token, or is a string containing unescaped double quotes\n */\nexport function stringValue<T extends string>(value: T): TFValue<T> {\n  if (typeof value !== \"string\" && !Tokenization.isResolvable(value)) {\n    throw valueIsInvalidStringOrToken(value);\n  }\n\n  if (typeof value === \"string\" && hasUnescapedDoubleQuotes(value)) {\n    throw valueContainsUnescapedQuotes(value);\n  }\n\n  return { value };\n}\n\n/**\n * Validator that accepts a number or a token\n * @param value Value to validate\n * @returns The wrapped value\n * @throws If the value is neither a number nor a token\n */\nexport function numericValue<T>(value: T): TFValue<T> {\n  if (typeof value !== \"number\" && !Tokenization.isResolvable(value)) {\n    throw valueIsInvalidNumberOrToken(value as string);\n  }\n  return { value };\n}\n\n/**\n * Creates a validator for lists whose elements are checked with the given element validator. Tokens and non-array\n * values pass through unchanged; `null`/`undefined` elements are dropped, token elements are kept as-is and plain\n * string elements are wrapped in double quotes.\n * @param type Validator applied to each non-token element\n * @returns A list validator that throws if an element fails the element validator\n */\nexport function listOf<T>(type: TFValueValidator<T>): TFValueValidator<T[]> {\n  return (value: any) => {\n    if (Tokenization.isResolvable(value)) {\n      return { value };\n    }\n\n    if (!Array.isArray(value)) {\n      //   throw new Error(`${value} is not a valid list`);\n      return { value };\n    }\n\n    return {\n      value: value\n        .filter((item) => item !== undefined && item !== null)\n        .map((item, i) => {\n          if (Tokenization.isResolvable(item)) {\n            return item;\n          }\n\n          if (TokenString.forListToken(item).test()) {\n            return item;\n          }\n\n          if (extractTokenDouble(item, true) !== undefined) {\n            return item;\n          }\n\n          if (TokenString.forMapToken(item).test()) {\n            return item;\n          }\n\n          if (typeof item === \"string\") {\n            const tokenList = Tokenization.reverseString(item);\n            const numberOfTokens =\n              tokenList.tokens.length + tokenList.intrinsic.length;\n            if (numberOfTokens === 1 && tokenList.literals.length === 0) {\n              return item;\n            }\n          }\n\n          try {\n            type(item);\n            return typeof item === \"string\" ? `\"${item}\"` : item;\n          } catch (error) {\n            throw listElementIsOfWrongType(value, i, error);\n          }\n        }),\n    };\n  };\n}\n\n/**\n * Creates a validator for a variadic argument: validates the value as a list and marks it to be expanded into\n * separate arguments of the Terraform function call\n * @param type Validator applied to each element\n * @returns A validator for the variadic argument\n */\nexport function variadic<T>(type: TFValueValidator<T>): TFValueValidator<T[]> {\n  return (value: any) => {\n    // we use the list validator and set variadic to true in order to have it expanded in the args passed to the TF function\n    return { value: listOf(type)(value).value, variadic: true };\n  };\n}\n\n// Tokenization\n/**\n * Converts a resolvable into a string token\n * @param value Resolvable to convert\n * @returns String token\n */\nexport function asString(value: IResolvable) {\n  return Token.asString(value);\n}\n\n/**\n * Converts a resolvable into a number token\n * @param value Resolvable to convert\n * @returns Number token\n */\nexport function asNumber(value: IResolvable) {\n  return Token.asNumber(value);\n}\n\n/**\n * Converts a resolvable into a string list token\n * @param value Resolvable to convert\n * @returns String list token\n */\nexport function asList(value: IResolvable) {\n  return Token.asList(value);\n}\n\n/**\n * Converts a resolvable into a string map token\n * @param value Resolvable to convert\n * @returns String map token\n */\nexport function asStringMap(value: IResolvable) {\n  return Token.asStringMap(value);\n}\n\n/**\n * Returns the resolvable unchanged, as booleans can not be represented as a token\n * @param value Resolvable to return\n * @returns The same resolvable\n */\nexport function asBoolean(value: IResolvable) {\n  return value; // Booleans can not be represented as a token\n}\n\n/**\n * Converts a resolvable into a string token typed as `any`\n * @param value Resolvable to convert\n * @returns String token typed as `any`\n */\nexport function asAny(value: IResolvable) {\n  // Ordinarily casting to any can cause issues, but\n  // in this case it makes using functions a bit easier in TS\n  // and doesn't really harm other languages.\n  // Jsii has issues when returning the value directly,\n  // so wrap as a string.\n  return asString(value) as any;\n}\n\n/**\n * Creates a function that validates its arguments and returns a Terraform function call expression\n * @param name Name of the Terraform function\n * @param argValidators Validators for each positional argument\n * @returns A function returning the call expression; it throws if the number of arguments does not match the\n * validators or an argument fails validation\n */\nexport function terraformFunction(\n  name: string,\n  argValidators: TFValueValidator<any>[],\n): ExecutableTfFunction {\n  return function (...args: any[]) {\n    if (args.length !== argValidators.length) {\n      throw functionReceivedWrongNumberOfArgs(\n        name,\n        argValidators.length,\n        args.length,\n      );\n    }\n    return call(\n      name,\n      // We use flatMap now, since listOf() wraps everything in an extra array but variadic() does not\n      // This enables us to have variadic pass multiple args into the call() from a single array\n      args.reduce((carry, arg, i) => {\n        try {\n          const val = argValidators[i](arg);\n          if (val.variadic) return [...carry, ...val.value];\n          else return [...carry, val.value];\n        } catch (error) {\n          throw functionArgumentValidationFailure(i, name, error);\n        }\n      }, []),\n    );\n  };\n}\n"]}

package/lib/functions/provider-function.js

@@ -10,7 +10,7 @@ const helpers_1 = require("./helpers");
  * through which every provider-defined function call flows.
  */
 class TerraformProviderFunction {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.TerraformProviderFunction", version: "0.26.0-pre.20" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdktn.TerraformProviderFunction", version: "0.26.0-pre.21" };
     /**
      * Invokes a provider-defined function (Terraform's
      * `provider::<providerLocalName>::<functionName>(...)` syntax).

package/lib/functions/terraform-functions.generated.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Bindings for the Terraform and OpenTofu built-in functions, generated from the function availability matrix.
+ */
 export declare class FnGenerated {
     /**
      * {@link https://developer.hashicorp.com/terraform/language/functions/abs abs} returns the absolute value of the given number. In other words, if the number is zero or positive then it is returned as-is, but if it is negative then it is multiplied by -1 to make it positive before returning it.