terraconstructs 0.0.8

package/lib/stack-base.d.ts

@@ -0,0 +1,188 @@
+import { TerraformStack, TerraformElement, HttpBackendConfig, HttpBackend } from "cdktf";
+import { Construct, IConstruct, Node } from "constructs";
+/**
+ * Options for creating a unique resource name_prefix.
+ */
+export interface UniqueResourceNamePrefixOptions extends UniqueResourceNameOptions {
+    /**
+     * Length of the random generated suffix added by some Terraform providers.
+     *
+     * NOTE: https://github.com/hashicorp/terraform-provider-aws/issues/625
+     * @default - 26
+     */
+    readonly suffixLength?: number;
+}
+/**
+ * Options for creating a unique resource name.
+ */
+export interface UniqueResourceNameOptions {
+    /**
+     * The maximum length of the unique resource name.
+     *
+     * @default - 256
+     */
+    readonly maxLength?: number;
+    /**
+     * The separator used between the path components.
+     *
+     * @default - none
+     */
+    readonly separator?: string;
+    /**
+     * Non-alphanumeric characters allowed in the unique resource name.
+     *
+     * @default - none
+     */
+    readonly allowedSpecialCharacters?: string;
+    /**
+     * Prefix to be added into the stack name
+     *
+     * @default - none
+     */
+    readonly prefix?: string;
+    /**
+     * Whether to convert the resource name to lowercase.
+     *
+     * @default - false
+     */
+    readonly lowerCase?: boolean;
+}
+export interface StackBaseProps {
+    /**
+     * TerraConstruct UUID within the grid.
+     *
+     * UUID is generated by the CLI and ensures resource Identity
+     * is decoupled from resource tagging for consistency.
+     *
+     * UUID may be user provided for imported resources
+     */
+    readonly gridUUID: string;
+    /**
+     * The environment name passed in from the CLI
+     */
+    readonly environmentName: string;
+    /**
+     * Stores the state using a simple REST client.
+     *
+     * State will be fetched via GET, updated via POST, and purged with DELETE.
+     * The method used for updating is configurable.
+     *
+     * This backend optionally supports state locking.
+     * When locking support is enabled it will use LOCK and UNLOCK requests providing the lock info in the body.
+     * The endpoint should return a 423: Locked or 409: Conflict with the holding lock info when
+     * it's already taken, 200: OK for success. Any other status will be considered an error.
+     * The ID of the holding lock info will be added as a query parameter to state updates requests.
+     *
+     * Read more about this backend in the Terraform docs:
+     * https://developer.hashicorp.com/terraform/language/settings/backends/http
+     */
+    readonly gridBackendConfig?: HttpBackendConfig;
+}
+export interface IStack extends IConstruct {
+    /**
+     * Environment Name passed in from the CLI
+     */
+    readonly environmentName: string;
+    readonly gridUUID: string;
+    readonly gridBackend?: HttpBackend;
+    resolve(obj: any, preparing?: boolean): any;
+    uniqueResourceName(tfElement: TerraformElement | Node, options: UniqueResourceNameOptions): string;
+    uniqueResourceNamePrefix(tfElement: TerraformElement | Node, options: UniqueResourceNamePrefixOptions): string;
+}
+/**
+ * Base class for all TerraConstructs stacks
+ *
+ * Provides a reference to the grid UUID and environment name
+ */
+export declare abstract class StackBase extends TerraformStack implements IStack {
+    /**
+     * Return whether the given object is a Stack.
+     *
+     * attribute detection since as 'instanceof' potentially fails across Library releases.
+     */
+    static isTerraStack(x: any): x is IStack;
+    /**
+     * Looks up the first stack scope in which `construct` is defined. Fails if there is no stack up the tree or the stack is not an IStack.
+     * @param construct The construct to start the search from.
+     */
+    static ofTerraConstruct(construct: IConstruct): IStack;
+    /**
+     * Returns a unique identifier for a construct based on its path within
+     * a TerraformStack. see uniqueResourceName, but with no separator, maximum length 255 and allows
+     *  "_" and "-" on top of alphanumerical characters.
+     *
+     * @param construct The construct
+     * @returns a unique resource name based on the construct path
+     */
+    static uniqueId(construct: IConstruct | Node): string;
+    /**
+     * Returns a unique identifier for a construct based
+     * on its path within a TerraformStack.
+     *
+     * Throws if no TerraformStack is found within it's construct path.
+     *
+     * This function finds the id of the parent stack (non-nested)
+     * to the construct, and the ids of the components in the construct path.
+     *
+     * The user can define allowed special characters, a separator between the elements,
+     * and the maximum length of the resource name. The name includes a human readable portion rendered
+     * from the path components, with or without user defined separators, and a hash suffix.
+     * If the resource name is longer than the maximum length, it is trimmed in the middle.
+     *
+     * @param construct The construct
+     * @param options Options for defining the unique resource name
+     * @returns a unique resource name based on the construct path
+     */
+    private static uniqueResourceName;
+    /**
+     * Stack unique grid identifier
+     */
+    readonly gridUUID: string;
+    /**
+     * Environment Name passed in from the CLI
+     */
+    readonly environmentName: string;
+    /**
+     * The grid provided backend for state storage
+     */
+    readonly gridBackend?: HttpBackend;
+    constructor(scope: Construct, id: string, props: StackBaseProps);
+    /**
+     * Returns a Terraform-compatible unique identifier for a Terraform Element based
+     * on its path. This function finds the stackName of the parent stack (non-nested)
+     * to the construct, and the ids of the components in the construct path.
+     *
+     * The user can define allowed special characters, a separator between the elements,
+     * and the maximum length of the resource name. The name includes a human readable portion rendered
+     * from the path components, with or without user defined separators, and a hash suffix.
+     * If the resource name is longer than the maximum length, it is trimmed in the middle.
+     *
+     * @param tfElement The construct
+     * @param options Options for defining the unique resource name
+     * @returns a unique resource name based on the construct path
+     */
+    uniqueResourceName(tfElement: TerraformElement | Node, options: UniqueResourceNameOptions): string;
+    /**
+     * Returns a Terraform-compatible unique identifier for a Terraform Element based
+     * on its path. This function finds the stackName of the parent stack (non-nested)
+     * to the construct, and the ids of the components in the construct path.
+     *
+     * The user can define allowed special characters, a separator between the elements,
+     * and the maximum length of the resource name. The name includes a human readable portion rendered
+     * from the path components, with or without user defined separators, and depends on the
+     * resource provider to generate the random suffix.
+     *
+     * If the resource name is longer than the maximum length - suffixLength, it is trimmed in the middle.
+     *
+     * @param tfElement The construct
+     * @param options Options for defining the unique resource name
+     * @returns a unique resource name based on the construct path
+     */
+    uniqueResourceNamePrefix(tfElement: TerraformElement | Node, options: UniqueResourceNamePrefixOptions): string;
+    /** Resolve IResolvable in scope of this AwsStack */
+    resolve(obj: any, preparing?: boolean): any;
+    /**
+     * Convert an object, potentially containing tokens, to a JSON string
+     */
+    toJsonString(obj: any, space?: number): string;
+}

package/lib/stack-base.js

@@ -0,0 +1,183 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackBase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const private_1 = require("./private");
+const TOKEN_RESOLVER = new cdktf_1.DefaultTokenResolver(new cdktf_1.StringConcat());
+const TERRASTACK_SYMBOL = Symbol.for("terraconstructs/lib.Stack");
+/**
+ * Base class for all TerraConstructs stacks
+ *
+ * Provides a reference to the grid UUID and environment name
+ */
+class StackBase extends cdktf_1.TerraformStack {
+    /**
+     * Return whether the given object is a Stack.
+     *
+     * attribute detection since as 'instanceof' potentially fails across Library releases.
+     */
+    static isTerraStack(x) {
+        return x !== null && typeof x === "object" && TERRASTACK_SYMBOL in x;
+    }
+    /**
+     * Looks up the first stack scope in which `construct` is defined. Fails if there is no stack up the tree or the stack is not an IStack.
+     * @param construct The construct to start the search from.
+     */
+    static ofTerraConstruct(construct) {
+        const s = cdktf_1.TerraformStack.of(construct);
+        if (StackBase.isTerraStack(s)) {
+            return s;
+        }
+        throw new Error(`Resource '${construct.constructor?.name}' at '${construct.node.path}' should be created in the scope of TerraConstruct IStack, but no IStack found`);
+    }
+    /**
+     * Returns a unique identifier for a construct based on its path within
+     * a TerraformStack. see uniqueResourceName, but with no separator, maximum length 255 and allows
+     *  "_" and "-" on top of alphanumerical characters.
+     *
+     * @param construct The construct
+     * @returns a unique resource name based on the construct path
+     */
+    static uniqueId(construct) {
+        return StackBase.uniqueResourceName(construct, {
+            maxLength: 255,
+            // avoid https://github.com/aws/aws-cdk/issues/6421
+            allowedSpecialCharacters: "_-",
+        });
+    }
+    /**
+     * Returns a unique identifier for a construct based
+     * on its path within a TerraformStack.
+     *
+     * Throws if no TerraformStack is found within it's construct path.
+     *
+     * This function finds the id of the parent stack (non-nested)
+     * to the construct, and the ids of the components in the construct path.
+     *
+     * The user can define allowed special characters, a separator between the elements,
+     * and the maximum length of the resource name. The name includes a human readable portion rendered
+     * from the path components, with or without user defined separators, and a hash suffix.
+     * If the resource name is longer than the maximum length, it is trimmed in the middle.
+     *
+     * @param construct The construct
+     * @param options Options for defining the unique resource name
+     * @returns a unique resource name based on the construct path
+     */
+    static uniqueResourceName(construct, options) {
+        const node = constructs_1.Construct.isConstruct(construct) ? construct.node : construct;
+        const stack = node.scopes
+            .reverse()
+            .find((component) => cdktf_1.TerraformStack.isStack(component));
+        if (!stack) {
+            throw new Error("Unable to calculate a unique id without a stack in the construct path");
+        }
+        const specIndex = node.scopes.indexOf(stack);
+        const componentsPath = node.scopes
+            .slice(specIndex)
+            .map((component) => component.node.id);
+        return (0, private_1.makeUniqueResourceName)(componentsPath, options);
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.gridUUID = props.gridUUID;
+        this.environmentName = props.environmentName;
+        Object.defineProperty(this, TERRASTACK_SYMBOL, { value: true });
+        if (props.gridBackendConfig) {
+            this.gridBackend = new cdktf_1.HttpBackend(this, props.gridBackendConfig);
+        }
+        // Map construct tree dependencies to ITerraformDependables
+        // ref: https://github.com/hashicorp/terraform-cdk/issues/2727#issuecomment-1473321075
+        cdktf_1.Aspects.of(this).add(new private_1.TerraformDependencyAspect());
+        // Aspects are invoked in synth after stack has been prepared
+        // this should ensure any resources added during `prepareStack()` are included in the dependency tree
+        // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/synthesize/synthesizer.ts#L121
+    }
+    /**
+     * Returns a Terraform-compatible unique identifier for a Terraform Element based
+     * on its path. This function finds the stackName of the parent stack (non-nested)
+     * to the construct, and the ids of the components in the construct path.
+     *
+     * The user can define allowed special characters, a separator between the elements,
+     * and the maximum length of the resource name. The name includes a human readable portion rendered
+     * from the path components, with or without user defined separators, and a hash suffix.
+     * If the resource name is longer than the maximum length, it is trimmed in the middle.
+     *
+     * @param tfElement The construct
+     * @param options Options for defining the unique resource name
+     * @returns a unique resource name based on the construct path
+     */
+    uniqueResourceName(tfElement, options) {
+        const node = constructs_1.Construct.isConstruct(tfElement) ? tfElement.node : tfElement;
+        const stack = cdktf_1.TerraformElement.isTerraformElement(tfElement)
+            ? tfElement.cdktfStack
+            : this;
+        const stackIndex = node.scopes.indexOf(stack);
+        const componentsPath = node.scopes
+            .slice(stackIndex)
+            .map((component) => component.node.id);
+        return (0, private_1.makeUniqueResourceName)(componentsPath, options);
+    }
+    /**
+     * Returns a Terraform-compatible unique identifier for a Terraform Element based
+     * on its path. This function finds the stackName of the parent stack (non-nested)
+     * to the construct, and the ids of the components in the construct path.
+     *
+     * The user can define allowed special characters, a separator between the elements,
+     * and the maximum length of the resource name. The name includes a human readable portion rendered
+     * from the path components, with or without user defined separators, and depends on the
+     * resource provider to generate the random suffix.
+     *
+     * If the resource name is longer than the maximum length - suffixLength, it is trimmed in the middle.
+     *
+     * @param tfElement The construct
+     * @param options Options for defining the unique resource name
+     * @returns a unique resource name based on the construct path
+     */
+    uniqueResourceNamePrefix(tfElement, options) {
+        const node = constructs_1.Construct.isConstruct(tfElement) ? tfElement.node : tfElement;
+        const stack = cdktf_1.TerraformElement.isTerraformElement(tfElement)
+            ? tfElement.cdktfStack
+            : this;
+        const stackIndex = node.scopes.indexOf(stack);
+        const componentsPath = node.scopes
+            .slice(stackIndex)
+            .map((component) => component.node.id);
+        return (0, private_1.makeUniqueResourceNamePrefix)(componentsPath, options);
+    }
+    /** Resolve IResolvable in scope of this AwsStack */
+    resolve(obj, preparing = false) {
+        return cdktf_1.Tokenization.resolve(obj, {
+            scope: this,
+            preparing,
+            resolver: TOKEN_RESOLVER,
+        });
+    }
+    /**
+     * Convert an object, potentially containing tokens, to a JSON string
+     */
+    toJsonString(obj, space) {
+        return cdktf_1.Lazy.stringValue({
+            produce: (ctx) => {
+                // First resolve Token objects with string concat... then JSON.stringify the resulting object
+                //
+                // unlike cloudformation, Terraform does not need an intrinsic wrapper?
+                // https://github.com/aws/aws-cdk/blob/8dca5079e1893122057f9e2c54c0da0ba644926e/packages/%40aws-cdk/core/lib/private/cloudformation-lang.ts#L73
+                // intrinsic wrapper without cross stack ref
+                // https://github.com/aws/aws-cdk/blob/14e4bc91ed5f0f8cb7c8ac9ee8a6de4da54e6585/packages/%40aws-cdk/core/lib/private/cloudformation-lang.ts#L50
+                const resolved = cdktf_1.Tokenization.resolve(obj, {
+                    preparing: ctx.preparing,
+                    scope: ctx.scope,
+                    resolver: TOKEN_RESOLVER,
+                });
+                return JSON.stringify(resolved, undefined, space);
+            },
+        });
+    }
+}
+exports.StackBase = StackBase;
+_a = JSII_RTTI_SYMBOL_1;
+StackBase[_a] = { fqn: "terraconstructs.StackBase", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-base.js","sourceRoot":"","sources":["../src/stack-base.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  TerraformStack,\n  TerraformElement,\n  HttpBackendConfig,\n  HttpBackend,\n  Tokenization,\n  DefaultTokenResolver, // https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/resolvable.ts#L176\n  StringConcat, // https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/resolvable.ts#L156\n  Aspects,\n  IResolveContext,\n  Lazy,\n} from \"cdktf\";\nimport { Construct, IConstruct, Node } from \"constructs\";\nimport {\n  makeUniqueResourceName,\n  makeUniqueResourceNamePrefix,\n  TerraformDependencyAspect,\n} from \"./private\";\n\nconst TOKEN_RESOLVER = new DefaultTokenResolver(new StringConcat());\n\nconst TERRASTACK_SYMBOL = Symbol.for(\"terraconstructs/lib.Stack\");\n\n// https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/core/lib/names.ts\n\n/**\n * Options for creating a unique resource name_prefix.\n */\nexport interface UniqueResourceNamePrefixOptions\n  extends UniqueResourceNameOptions {\n  /**\n   * Length of the random generated suffix added by some Terraform providers.\n   *\n   * NOTE: https://github.com/hashicorp/terraform-provider-aws/issues/625\n   * @default - 26\n   */\n  readonly suffixLength?: number;\n}\n\n/**\n * Options for creating a unique resource name.\n */\nexport interface UniqueResourceNameOptions {\n  /**\n   * The maximum length of the unique resource name.\n   *\n   * @default - 256\n   */\n  readonly maxLength?: number;\n\n  /**\n   * The separator used between the path components.\n   *\n   * @default - none\n   */\n  readonly separator?: string;\n\n  /**\n   * Non-alphanumeric characters allowed in the unique resource name.\n   *\n   * @default - none\n   */\n  readonly allowedSpecialCharacters?: string;\n\n  /**\n   * Prefix to be added into the stack name\n   *\n   * @default - none\n   */\n  readonly prefix?: string;\n\n  /**\n   * Whether to convert the resource name to lowercase.\n   *\n   * @default - false\n   */\n  readonly lowerCase?: boolean;\n}\n\nexport interface StackBaseProps {\n  /**\n   * TerraConstruct UUID within the grid.\n   *\n   * UUID is generated by the CLI and ensures resource Identity\n   * is decoupled from resource tagging for consistency.\n   *\n   * UUID may be user provided for imported resources\n   */\n  readonly gridUUID: string;\n\n  /**\n   * The environment name passed in from the CLI\n   */\n  readonly environmentName: string;\n\n  /**\n   * Stores the state using a simple REST client.\n   *\n   * State will be fetched via GET, updated via POST, and purged with DELETE.\n   * The method used for updating is configurable.\n   *\n   * This backend optionally supports state locking.\n   * When locking support is enabled it will use LOCK and UNLOCK requests providing the lock info in the body.\n   * The endpoint should return a 423: Locked or 409: Conflict with the holding lock info when\n   * it's already taken, 200: OK for success. Any other status will be considered an error.\n   * The ID of the holding lock info will be added as a query parameter to state updates requests.\n   *\n   * Read more about this backend in the Terraform docs:\n   * https://developer.hashicorp.com/terraform/language/settings/backends/http\n   */\n  readonly gridBackendConfig?: HttpBackendConfig;\n}\n\nexport interface IStack extends IConstruct {\n  /**\n   * Environment Name passed in from the CLI\n   */\n  readonly environmentName: string;\n  readonly gridUUID: string;\n  readonly gridBackend?: HttpBackend;\n  resolve(obj: any, preparing?: boolean): any;\n  uniqueResourceName(\n    tfElement: TerraformElement | Node,\n    options: UniqueResourceNameOptions,\n  ): string;\n  uniqueResourceNamePrefix(\n    tfElement: TerraformElement | Node,\n    options: UniqueResourceNamePrefixOptions,\n  ): string;\n  // toJsonString(obj: any, space?: number): string;\n}\n\n/**\n * Base class for all TerraConstructs stacks\n *\n * Provides a reference to the grid UUID and environment name\n */\nexport abstract class StackBase extends TerraformStack implements IStack {\n  /**\n   * Return whether the given object is a Stack.\n   *\n   * attribute detection since as 'instanceof' potentially fails across Library releases.\n   */\n  public static isTerraStack(x: any): x is IStack {\n    return x !== null && typeof x === \"object\" && TERRASTACK_SYMBOL in x;\n  }\n\n  /**\n   * Looks up the first stack scope in which `construct` is defined. Fails if there is no stack up the tree or the stack is not an IStack.\n   * @param construct The construct to start the search from.\n   */\n  public static ofTerraConstruct(construct: IConstruct): IStack {\n    const s = TerraformStack.of(construct);\n    if (StackBase.isTerraStack(s)) {\n      return s;\n    }\n    throw new Error(\n      `Resource '${construct.constructor?.name}' at '${construct.node.path}' should be created in the scope of TerraConstruct IStack, but no IStack found`,\n    );\n  }\n\n  /**\n   * Returns a unique identifier for a construct based on its path within\n   * a TerraformStack. see uniqueResourceName, but with no separator, maximum length 255 and allows\n   *  \"_\" and \"-\" on top of alphanumerical characters.\n   *\n   * @param construct The construct\n   * @returns a unique resource name based on the construct path\n   */\n  public static uniqueId(construct: IConstruct | Node) {\n    return StackBase.uniqueResourceName(construct, {\n      maxLength: 255,\n      // avoid https://github.com/aws/aws-cdk/issues/6421\n      allowedSpecialCharacters: \"_-\",\n    });\n  }\n\n  /**\n   * Returns a unique identifier for a construct based\n   * on its path within a TerraformStack.\n   *\n   * Throws if no TerraformStack is found within it's construct path.\n   *\n   * This function finds the id of the parent stack (non-nested)\n   * to the construct, and the ids of the components in the construct path.\n   *\n   * The user can define allowed special characters, a separator between the elements,\n   * and the maximum length of the resource name. The name includes a human readable portion rendered\n   * from the path components, with or without user defined separators, and a hash suffix.\n   * If the resource name is longer than the maximum length, it is trimmed in the middle.\n   *\n   * @param construct The construct\n   * @param options Options for defining the unique resource name\n   * @returns a unique resource name based on the construct path\n   */\n  private static uniqueResourceName(\n    construct: IConstruct | Node,\n    options: UniqueResourceNameOptions,\n  ) {\n    const node = Construct.isConstruct(construct) ? construct.node : construct;\n    const stack = node.scopes\n      .reverse()\n      .find((component) => TerraformStack.isStack(component));\n\n    if (!stack) {\n      throw new Error(\n        \"Unable to calculate a unique id without a stack in the construct path\",\n      );\n    }\n\n    const specIndex = node.scopes.indexOf(stack);\n    const componentsPath = node.scopes\n      .slice(specIndex)\n      .map((component) => component.node.id);\n\n    return makeUniqueResourceName(componentsPath, options);\n  }\n\n  /**\n   * Stack unique grid identifier\n   */\n  public readonly gridUUID: string;\n\n  /**\n   * Environment Name passed in from the CLI\n   */\n  public readonly environmentName: string;\n\n  /**\n   * The grid provided backend for state storage\n   */\n  public readonly gridBackend?: HttpBackend;\n\n  constructor(scope: Construct, id: string, props: StackBaseProps) {\n    super(scope, id);\n    this.gridUUID = props.gridUUID;\n    this.environmentName = props.environmentName;\n    Object.defineProperty(this, TERRASTACK_SYMBOL, { value: true });\n    if (props.gridBackendConfig) {\n      this.gridBackend = new HttpBackend(this, props.gridBackendConfig);\n    }\n\n    // Map construct tree dependencies to ITerraformDependables\n    // ref: https://github.com/hashicorp/terraform-cdk/issues/2727#issuecomment-1473321075\n    Aspects.of(this).add(new TerraformDependencyAspect());\n    // Aspects are invoked in synth after stack has been prepared\n    // this should ensure any resources added during `prepareStack()` are included in the dependency tree\n    // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/synthesize/synthesizer.ts#L121\n  }\n\n  /**\n   * Returns a Terraform-compatible unique identifier for a Terraform Element based\n   * on its path. This function finds the stackName of the parent stack (non-nested)\n   * to the construct, and the ids of the components in the construct path.\n   *\n   * The user can define allowed special characters, a separator between the elements,\n   * and the maximum length of the resource name. The name includes a human readable portion rendered\n   * from the path components, with or without user defined separators, and a hash suffix.\n   * If the resource name is longer than the maximum length, it is trimmed in the middle.\n   *\n   * @param tfElement The construct\n   * @param options Options for defining the unique resource name\n   * @returns a unique resource name based on the construct path\n   */\n  public uniqueResourceName(\n    tfElement: TerraformElement | Node,\n    options: UniqueResourceNameOptions,\n  ): string {\n    const node = Construct.isConstruct(tfElement) ? tfElement.node : tfElement;\n    const stack = TerraformElement.isTerraformElement(tfElement)\n      ? tfElement.cdktfStack\n      : this;\n    const stackIndex = node.scopes.indexOf(stack);\n    const componentsPath = node.scopes\n      .slice(stackIndex)\n      .map((component) => component.node.id);\n\n    return makeUniqueResourceName(componentsPath, options);\n  }\n\n  /**\n   * Returns a Terraform-compatible unique identifier for a Terraform Element based\n   * on its path. This function finds the stackName of the parent stack (non-nested)\n   * to the construct, and the ids of the components in the construct path.\n   *\n   * The user can define allowed special characters, a separator between the elements,\n   * and the maximum length of the resource name. The name includes a human readable portion rendered\n   * from the path components, with or without user defined separators, and depends on the\n   * resource provider to generate the random suffix.\n   *\n   * If the resource name is longer than the maximum length - suffixLength, it is trimmed in the middle.\n   *\n   * @param tfElement The construct\n   * @param options Options for defining the unique resource name\n   * @returns a unique resource name based on the construct path\n   */\n  public uniqueResourceNamePrefix(\n    tfElement: TerraformElement | Node,\n    options: UniqueResourceNamePrefixOptions,\n  ): string {\n    const node = Construct.isConstruct(tfElement) ? tfElement.node : tfElement;\n    const stack = TerraformElement.isTerraformElement(tfElement)\n      ? tfElement.cdktfStack\n      : this;\n    const stackIndex = node.scopes.indexOf(stack);\n    const componentsPath = node.scopes\n      .slice(stackIndex)\n      .map((component) => component.node.id);\n\n    return makeUniqueResourceNamePrefix(componentsPath, options);\n  }\n\n  /** Resolve IResolvable in scope of this AwsStack */\n  public resolve(obj: any, preparing = false): any {\n    return Tokenization.resolve(obj, {\n      scope: this,\n      preparing,\n      resolver: TOKEN_RESOLVER,\n    });\n  }\n\n  /**\n   * Convert an object, potentially containing tokens, to a JSON string\n   */\n  public toJsonString(obj: any, space?: number): string {\n    return Lazy.stringValue({\n      produce: (ctx: IResolveContext) => {\n        // First resolve Token objects with string concat... then JSON.stringify the resulting object\n        //\n        // unlike cloudformation, Terraform does not need an intrinsic wrapper?\n        // https://github.com/aws/aws-cdk/blob/8dca5079e1893122057f9e2c54c0da0ba644926e/packages/%40aws-cdk/core/lib/private/cloudformation-lang.ts#L73\n        // intrinsic wrapper without cross stack ref\n        // https://github.com/aws/aws-cdk/blob/14e4bc91ed5f0f8cb7c8ac9ee8a6de4da54e6585/packages/%40aws-cdk/core/lib/private/cloudformation-lang.ts#L50\n        const resolved = Tokenization.resolve(obj, {\n          preparing: ctx.preparing,\n          scope: ctx.scope,\n          resolver: TOKEN_RESOLVER,\n        });\n        return JSON.stringify(resolved, undefined, space);\n      },\n    });\n  }\n}\n"]}

package/lib/token.d.ts

@@ -0,0 +1,32 @@
+/**
+ * An enum-like class that represents the result of comparing two Tokens.
+ * The return type of `Token.compareStrings`.
+ */
+export declare class TokenComparison {
+    /**
+     * This means we're certain the two components are NOT
+     * Tokens, and identical.
+     */
+    static readonly SAME: TokenComparison;
+    /**
+     * This means we're certain the two components are NOT
+     * Tokens, and different.
+     */
+    static readonly DIFFERENT: TokenComparison;
+    /** This means exactly one of the components is a Token. */
+    static readonly ONE_UNRESOLVED: TokenComparison;
+    /** This means both components are Tokens. */
+    static readonly BOTH_UNRESOLVED: TokenComparison;
+    private constructor();
+}
+/** Compare two strings that might contain Tokens with each other. */
+export declare function tokenCompareStrings(possibleToken1: string, possibleToken2: string): TokenComparison;
+/**
+ * Call the given function only if all given values are resolved
+ *
+ * Exported as a function since it will be used by TypeScript modules, but
+ * can't be exposed via JSII because of the generics.
+ */
+export declare function withResolved<A>(a: A, fn: (a: A) => void): void;
+export declare function withResolved<A, B>(a: A, b: B, fn: (a: A, b: B) => void): void;
+export declare function withResolved<A, B, C>(a: A, b: B, c: C, fn: (a: A, b: B, c: C) => void): void;

package/lib/token.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withResolved = exports.tokenCompareStrings = exports.TokenComparison = void 0;
+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`.
+ */
+class TokenComparison {
+    constructor() { }
+}
+exports.TokenComparison = TokenComparison;
+/**
+ * This means we're certain the two components are NOT
+ * Tokens, and identical.
+ */
+TokenComparison.SAME = new TokenComparison();
+/**
+ * This means we're certain the two components are NOT
+ * Tokens, and different.
+ */
+TokenComparison.DIFFERENT = new TokenComparison();
+/** This means exactly one of the components is a Token. */
+TokenComparison.ONE_UNRESOLVED = new TokenComparison();
+/** This means both components are Tokens. */
+TokenComparison.BOTH_UNRESOLVED = new TokenComparison();
+/** Compare two strings that might contain Tokens with each other. */
+function tokenCompareStrings(possibleToken1, possibleToken2) {
+    const firstIsUnresolved = cdktf_1.Token.isUnresolved(possibleToken1);
+    const secondIsUnresolved = cdktf_1.Token.isUnresolved(possibleToken2);
+    if (firstIsUnresolved && secondIsUnresolved) {
+        return TokenComparison.BOTH_UNRESOLVED;
+    }
+    if (firstIsUnresolved || secondIsUnresolved) {
+        return TokenComparison.ONE_UNRESOLVED;
+    }
+    return possibleToken1 === possibleToken2
+        ? TokenComparison.SAME
+        : TokenComparison.DIFFERENT;
+}
+exports.tokenCompareStrings = tokenCompareStrings;
+function withResolved(...args) {
+    if (args.length < 2) {
+        return;
+    }
+    const argArray = args.slice(0, args.length - 1);
+    if (argArray.some(cdktf_1.Token.isUnresolved)) {
+        return;
+    }
+    args[args.length - 1].apply(arguments, argArray);
+}
+exports.withResolved = withResolved;
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/camel-case/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/camel-case/README.md

@@ -0,0 +1,47 @@
+# Camel Case
+
+[![NPM version][npm-image]][npm-url]
+[![NPM downloads][downloads-image]][downloads-url]
+[![Bundle size][bundlephobia-image]][bundlephobia-url]
+
+> Transform into a string with the separator denoted by the next word capitalized.
+
+## Installation
+
+```
+npm install camel-case --save
+```
+
+## Usage
+
+```js
+import { camelCase } from "camel-case";
+
+camelCase("string"); //=> "string"
+camelCase("dot.case"); //=> "dotCase"
+camelCase("PascalCase"); //=> "pascalCase"
+camelCase("version 1.2.10"); //=> "version_1_2_10"
+```
+
+The function also accepts [`options`](https://github.com/blakeembrey/change-case#options).
+
+### Merge Numbers
+
+If you'd like to remove the behavior prefixing `_` before numbers, you can use `camelCaseTransformMerge`:
+
+```js
+import { camelCaseTransformMerge } from "camel-case";
+
+camelCase("version 12", { transform: camelCaseTransformMerge }); //=> "version12"
+```
+
+## License
+
+MIT
+
+[npm-image]: https://img.shields.io/npm/v/camel-case.svg?style=flat
+[npm-url]: https://npmjs.org/package/camel-case
+[downloads-image]: https://img.shields.io/npm/dm/camel-case.svg?style=flat
+[downloads-url]: https://npmjs.org/package/camel-case
+[bundlephobia-image]: https://img.shields.io/bundlephobia/minzip/camel-case.svg
+[bundlephobia-url]: https://bundlephobia.com/result?p=camel-case

package/node_modules/camel-case/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { Options } from "pascal-case";
+export { Options };
+export declare function camelCaseTransform(input: string, index: number): string;
+export declare function camelCaseTransformMerge(input: string, index: number): string;
+export declare function camelCase(input: string, options?: Options): string;

package/node_modules/camel-case/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelCase = exports.camelCaseTransformMerge = exports.camelCaseTransform = void 0;
+var tslib_1 = require("tslib");
+var pascal_case_1 = require("pascal-case");
+function camelCaseTransform(input, index) {
+    if (index === 0)
+        return input.toLowerCase();
+    return pascal_case_1.pascalCaseTransform(input, index);
+}
+exports.camelCaseTransform = camelCaseTransform;
+function camelCaseTransformMerge(input, index) {
+    if (index === 0)
+        return input.toLowerCase();
+    return pascal_case_1.pascalCaseTransformMerge(input);
+}
+exports.camelCaseTransformMerge = camelCaseTransformMerge;
+function camelCase(input, options) {
+    if (options === void 0) { options = {}; }
+    return pascal_case_1.pascalCase(input, tslib_1.__assign({ transform: camelCaseTransform }, options));
+}
+exports.camelCase = camelCase;
+//# sourceMappingURL=index.js.map

package/node_modules/camel-case/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;AAAA,2CAKqB;AAIrB,SAAgB,kBAAkB,CAAC,KAAa,EAAE,KAAa;IAC7D,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,iCAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC3C,CAAC;AAHD,gDAGC;AAED,SAAgB,uBAAuB,CAAC,KAAa,EAAE,KAAa;IAClE,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;IAC5C,OAAO,sCAAwB,CAAC,KAAK,CAAC,CAAC;AACzC,CAAC;AAHD,0DAGC;AAED,SAAgB,SAAS,CAAC,KAAa,EAAE,OAAqB;IAArB,wBAAA,EAAA,YAAqB;IAC5D,OAAO,wBAAU,CAAC,KAAK,qBACrB,SAAS,EAAE,kBAAkB,IAC1B,OAAO,EACV,CAAC;AACL,CAAC;AALD,8BAKC","sourcesContent":["import {\n  pascalCase,\n  pascalCaseTransform,\n  pascalCaseTransformMerge,\n  Options,\n} from \"pascal-case\";\n\nexport { Options };\n\nexport function camelCaseTransform(input: string, index: number) {\n  if (index === 0) return input.toLowerCase();\n  return pascalCaseTransform(input, index);\n}\n\nexport function camelCaseTransformMerge(input: string, index: number) {\n  if (index === 0) return input.toLowerCase();\n  return pascalCaseTransformMerge(input);\n}\n\nexport function camelCase(input: string, options: Options = {}) {\n  return pascalCase(input, {\n    transform: camelCaseTransform,\n    ...options,\n  });\n}\n"]}

package/node_modules/camel-case/dist/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/camel-case/dist/index.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var _1 = require(".");
+var TEST_CASES = [
+    ["", ""],
+    ["test", "test"],
+    ["test string", "testString"],
+    ["Test String", "testString"],
+    ["TestV2", "testV2"],
+    ["_foo_bar_", "fooBar"],
+    ["version 1.2.10", "version_1_2_10"],
+    ["version 1.21.0", "version_1_21_0"],
+    ["version 1.2.10", "version1210", { transform: _1.camelCaseTransformMerge }],
+];
+describe("camel case", function () {
+    var _loop_1 = function (input, result, options) {
+        it(input + " -> " + result, function () {
+            expect(_1.camelCase(input, options)).toEqual(result);
+        });
+    };
+    for (var _i = 0, TEST_CASES_1 = TEST_CASES; _i < TEST_CASES_1.length; _i++) {
+        var _a = TEST_CASES_1[_i], input = _a[0], result = _a[1], options = _a[2];
+        _loop_1(input, result, options);
+    }
+});
+//# sourceMappingURL=index.spec.js.map

package/node_modules/camel-case/dist/index.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.spec.js","sourceRoot":"","sources":["../src/index.spec.ts"],"names":[],"mappings":";;AAAA,sBAAgE;AAEhE,IAAM,UAAU,GAAiC;IAC/C,CAAC,EAAE,EAAE,EAAE,CAAC;IACR,CAAC,MAAM,EAAE,MAAM,CAAC;IAChB,CAAC,aAAa,EAAE,YAAY,CAAC;IAC7B,CAAC,aAAa,EAAE,YAAY,CAAC;IAC7B,CAAC,QAAQ,EAAE,QAAQ,CAAC;IACpB,CAAC,WAAW,EAAE,QAAQ,CAAC;IACvB,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IACpC,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IACpC,CAAC,gBAAgB,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,0BAAuB,EAAE,CAAC;CAC1E,CAAC;AAEF,QAAQ,CAAC,YAAY,EAAE;4BACT,KAAK,EAAE,MAAM,EAAE,OAAO;QAChC,EAAE,CAAI,KAAK,YAAO,MAAQ,EAAE;YAC1B,MAAM,CAAC,YAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;;IAHL,KAAuC,UAAU,EAAV,yBAAU,EAAV,wBAAU,EAAV,IAAU;QAAtC,IAAA,qBAAwB,EAAvB,KAAK,QAAA,EAAE,MAAM,QAAA,EAAE,OAAO,QAAA;gBAAtB,KAAK,EAAE,MAAM,EAAE,OAAO;KAIjC;AACH,CAAC,CAAC,CAAC","sourcesContent":["import { camelCase, camelCaseTransformMerge, Options } from \".\";\n\nconst TEST_CASES: [string, string, Options?][] = [\n  [\"\", \"\"],\n  [\"test\", \"test\"],\n  [\"test string\", \"testString\"],\n  [\"Test String\", \"testString\"],\n  [\"TestV2\", \"testV2\"],\n  [\"_foo_bar_\", \"fooBar\"],\n  [\"version 1.2.10\", \"version_1_2_10\"],\n  [\"version 1.21.0\", \"version_1_21_0\"],\n  [\"version 1.2.10\", \"version1210\", { transform: camelCaseTransformMerge }],\n];\n\ndescribe(\"camel case\", () => {\n  for (const [input, result, options] of TEST_CASES) {\n    it(`${input} -> ${result}`, () => {\n      expect(camelCase(input, options)).toEqual(result);\n    });\n  }\n});\n"]}