@aws-cdk/core - npm Package Compare versions

Comparing version 1.15.0 to 1.16.0

lib/cfn-resource.d.ts

@@ -68,6 +68,34 @@ import { CfnCondition } from './cfn-condition';
      *
-     * @param path  The path of the property, you can use dot notation to
+     * If the override is nested, separate each nested level using a dot (.) in the path parameter.
+     * If there is an array as part of the nesting, specify the index in the path.
+     *
+     * For example,
+     * ```typescript
+     * addOverride('Properties.GlobalSecondaryIndexes.0.Projection.NonKeyAttributes', ['myattribute'])
+     * addOverride('Properties.GlobalSecondaryIndexes.1.ProjectionType', 'INCLUDE')
+     * ```
+     * would add the overrides
+     * ```json
+     * "Properties": {
+     *   "GlobalSecondaryIndexes": [
+     *     {
+     *       "Projection": {
+     *         "NonKeyAttributes": [ "myattribute" ]
+     *         ...
+     *       }
+     *       ...
+     *     },
+     *     {
+     *       "ProjectionType": "INCLUDE"
+     *       ...
+     *     },
+     *   ]
+     *   ...
+     * }
+     * ```
+     *
+     * @param path - The path of the property, you can use dot notation to
      *        override values in complex types. Any intermdediate keys
      *        will be created as needed.
-     * @param value The value. Could be primitive or complex.
+     * @param value - The value. Could be primitive or complex.
      */
@@ -74,0 +102,0 @@ addOverride(path: string, value: any): void;

lib/cfn-resource.js

@@ -98,6 +98,34 @@ "use strict";
      *
-     * @param path  The path of the property, you can use dot notation to
+     * If the override is nested, separate each nested level using a dot (.) in the path parameter.
+     * If there is an array as part of the nesting, specify the index in the path.
+     *
+     * For example,
+     * ```typescript
+     * addOverride('Properties.GlobalSecondaryIndexes.0.Projection.NonKeyAttributes', ['myattribute'])
+     * addOverride('Properties.GlobalSecondaryIndexes.1.ProjectionType', 'INCLUDE')
+     * ```
+     * would add the overrides
+     * ```json
+     * "Properties": {
+     *   "GlobalSecondaryIndexes": [
+     *     {
+     *       "Projection": {
+     *         "NonKeyAttributes": [ "myattribute" ]
+     *         ...
+     *       }
+     *       ...
+     *     },
+     *     {
+     *       "ProjectionType": "INCLUDE"
+     *       ...
+     *     },
+     *   ]
+     *   ...
+     * }
+     * ```
+     *
+     * @param path - The path of the property, you can use dot notation to
      *        override values in complex types. Any intermdediate keys
      *        will be created as needed.
-     * @param value The value. Could be primitive or complex.
+     * @param value - The value. Could be primitive or complex.
      */
@@ -284,2 +312,2 @@ addOverride(path, value) {
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cfn-resource.js","sourceRoot":"","sources":["cfn-resource.ts"],"names":[],"mappings":"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","sourcesContent":["import cxapi = require('@aws-cdk/cx-api');\nimport { CfnCondition } from './cfn-condition';\n// import required to be here, otherwise causes a cycle when running the generated JavaScript\n// tslint:disable-next-line:ordered-imports\nimport { CfnRefElement } from './cfn-element';\nimport { CfnCreationPolicy, CfnDeletionPolicy, CfnUpdatePolicy } from './cfn-resource-policy';\nimport { Construct, IConstruct } from './construct';\nimport { CfnReference } from './private/cfn-reference';\nimport { Reference } from './reference';\nimport { RemovalPolicy, RemovalPolicyOptions } from './removal-policy';\nimport { TagManager } from './tag-manager';\nimport { capitalizePropertyNames, ignoreEmpty, PostResolveToken } from './util';\n\nexport interface CfnResourceProps {\n  /**\n   * CloudFormation resource type (e.g. `AWS::S3::Bucket`).\n   */\n  readonly type: string;\n\n  /**\n   * Resource properties.\n   *\n   * @default - No resource properties.\n   */\n  readonly properties?: { [name: string]: any };\n}\n\n/**\n * Represents a CloudFormation resource.\n */\nexport class CfnResource extends CfnRefElement {\n  /**\n   * Check whether the given construct is a CfnResource\n   */\n  public static isCfnResource(construct: IConstruct): construct is CfnResource {\n    return (construct as any).cfnResourceType !== undefined;\n  }\n\n  // MAINTAINERS NOTE: this class serves as the base class for the generated L1\n  // (\"CFN\") resources (such as `s3.CfnBucket`). These resources will have a\n  // property for each CloudFormation property of the resource. This means that\n  // if at some point in the future a property is introduced with a name similar\n  // to one of the properties here, it will be \"masked\" by the derived class. To\n  // that end, we prefix all properties in this class with `cfnXxx` with the\n  // hope to avoid those conflicts in the future.\n\n  /**\n   * Options for this resource, such as condition, update policy etc.\n   */\n  public readonly cfnOptions: ICfnResourceOptions = {};\n\n  /**\n   * AWS resource type.\n   */\n  public readonly cfnResourceType: string;\n\n  /**\n   * AWS CloudFormation resource properties.\n   *\n   * This object is returned via cfnProperties\n   * @internal\n   */\n  protected readonly _cfnProperties: any;\n\n  /**\n   * An object to be merged on top of the entire resource definition.\n   */\n  private readonly rawOverrides: any = {};\n\n  /**\n   * Logical IDs of dependencies.\n   *\n   * Is filled during prepare().\n   */\n  private readonly dependsOn = new Set<CfnResource>();\n\n  /**\n   * Creates a resource construct.\n   * @param cfnResourceType The CloudFormation type of this resource (e.g. AWS::DynamoDB::Table)\n   */\n  constructor(scope: Construct, id: string, props: CfnResourceProps) {\n    super(scope, id);\n\n    if (!props.type) {\n      throw new Error('The `type` property is required');\n    }\n\n    this.cfnResourceType = props.type;\n    this._cfnProperties = props.properties || {};\n\n    // if aws:cdk:enable-path-metadata is set, embed the current construct's\n    // path in the CloudFormation template, so it will be possible to trace\n    // back to the actual construct path.\n    if (this.node.tryGetContext(cxapi.PATH_METADATA_ENABLE_CONTEXT)) {\n      this.cfnOptions.metadata = {\n        [cxapi.PATH_METADATA_KEY]: this.node.path\n      };\n    }\n  }\n\n  /**\n   * Sets the deletion policy of the resource based on the removal policy specified.\n   */\n  public applyRemovalPolicy(policy: RemovalPolicy | undefined, options: RemovalPolicyOptions = {}) {\n    policy = policy || options.default || RemovalPolicy.RETAIN;\n\n    let deletionPolicy;\n\n    switch (policy) {\n      case RemovalPolicy.DESTROY:\n        deletionPolicy = CfnDeletionPolicy.DELETE;\n        break;\n\n      case RemovalPolicy.RETAIN:\n        deletionPolicy = CfnDeletionPolicy.RETAIN;\n        break;\n\n      default:\n        throw new Error(`Invalid removal policy: ${policy}`);\n    }\n\n    this.cfnOptions.deletionPolicy = deletionPolicy;\n    if (options.applyToUpdateReplacePolicy !== false) {\n      this.cfnOptions.updateReplacePolicy = deletionPolicy;\n    }\n  }\n\n  /**\n   * Returns a token for an runtime attribute of this resource.\n   * Ideally, use generated attribute accessors (e.g. `resource.arn`), but this can be used for future compatibility\n   * in case there is no generated attribute.\n   * @param attributeName The name of the attribute.\n   */\n  public getAtt(attributeName: string): Reference {\n    return CfnReference.for(this, attributeName);\n  }\n\n  /**\n   * Adds an override to the synthesized CloudFormation resource. To add a\n   * property override, either use `addPropertyOverride` or prefix `path` with\n   * \"Properties.\" (i.e. `Properties.TopicName`).\n   *\n   * @param path  The path of the property, you can use dot notation to\n   *        override values in complex types. Any intermdediate keys\n   *        will be created as needed.\n   * @param value The value. Could be primitive or complex.\n   */\n  public addOverride(path: string, value: any) {\n    const parts = path.split('.');\n    let curr: any = this.rawOverrides;\n\n    while (parts.length > 1) {\n      const key = parts.shift()!;\n\n      // if we can't recurse further or the previous value is not an\n      // object overwrite it with an object.\n      const isObject = curr[key] != null && typeof(curr[key]) === 'object' && !Array.isArray(curr[key]);\n      if (!isObject) {\n        curr[key] = {};\n      }\n\n      curr = curr[key];\n    }\n\n    const lastKey = parts.shift()!;\n    curr[lastKey] = value;\n  }\n\n  /**\n   * Syntactic sugar for `addOverride(path, undefined)`.\n   * @param path The path of the value to delete\n   */\n  public addDeletionOverride(path: string) {\n    this.addOverride(path, undefined);\n  }\n\n  /**\n   * Adds an override to a resource property.\n   *\n   * Syntactic sugar for `addOverride(\"Properties.<...>\", value)`.\n   *\n   * @param propertyPath The path of the property\n   * @param value The value\n   */\n  public addPropertyOverride(propertyPath: string, value: any) {\n    this.addOverride(`Properties.${propertyPath}`, value);\n  }\n\n  /**\n   * Adds an override that deletes the value of a property from the resource definition.\n   * @param propertyPath The path to the property.\n   */\n  public addPropertyDeletionOverride(propertyPath: string) {\n    this.addPropertyOverride(propertyPath, undefined);\n  }\n\n  /**\n   * Indicates that this resource depends on another resource and cannot be provisioned\n   * unless the other resource has been successfully provisioned.\n   */\n  public addDependsOn(resource: CfnResource) {\n    this.dependsOn.add(resource);\n  }\n\n  /**\n   * @returns a string representation of this resource\n   */\n  public toString() {\n    return `${super.toString()} [${this.cfnResourceType}]`;\n  }\n\n  /**\n   * Emits CloudFormation for this resource.\n   * @internal\n   */\n  public _toCloudFormation(): object {\n    try {\n      const ret = {\n        Resources: {\n          // Post-Resolve operation since otherwise deepMerge is going to mix values into\n          // the Token objects returned by ignoreEmpty.\n          [this.logicalId]: new PostResolveToken({\n            Type: this.cfnResourceType,\n            Properties: ignoreEmpty(this.cfnProperties),\n            DependsOn: ignoreEmpty(renderDependsOn(this.dependsOn)),\n            CreationPolicy:  capitalizePropertyNames(this, renderCreationPolicy(this.cfnOptions.creationPolicy)),\n            UpdatePolicy: capitalizePropertyNames(this, this.cfnOptions.updatePolicy),\n            UpdateReplacePolicy: capitalizePropertyNames(this, this.cfnOptions.updateReplacePolicy),\n            DeletionPolicy: capitalizePropertyNames(this, this.cfnOptions.deletionPolicy),\n            Metadata: ignoreEmpty(this.cfnOptions.metadata),\n            Condition: this.cfnOptions.condition && this.cfnOptions.condition.logicalId\n          }, props => {\n            const renderedProps = this.renderProperties(props.Properties || {});\n            props.Properties = renderedProps && (Object.values(renderedProps).find(v => !!v) ? renderedProps : undefined);\n            return deepMerge(props, this.rawOverrides);\n          })\n        }\n      };\n      return ret;\n    } catch (e) {\n      // Change message\n      e.message = `While synthesizing ${this.node.path}: ${e.message}`;\n      // Adjust stack trace (make it look like node built it, too...)\n      const trace = this.creationStack;\n      if (trace) {\n        const creationStack = ['--- resource created at ---', ...trace].join('\\n  at ');\n        const problemTrace = e.stack.substr(e.stack.indexOf(e.message) + e.message.length);\n        e.stack = `${e.message}\\n  ${creationStack}\\n  --- problem discovered at ---${problemTrace}`;\n      }\n\n      // Re-throw\n      throw e;\n    }\n\n    // returns the set of logical ID (tokens) this resource depends on\n    // sorted by construct paths to ensure test determinism\n    function renderDependsOn(dependsOn: Set<CfnResource>) {\n      return Array\n        .from(dependsOn)\n        .sort((x, y) => x.node.path.localeCompare(y.node.path))\n        .map(r => r.logicalId);\n    }\n\n    function renderCreationPolicy(policy: CfnCreationPolicy | undefined): any {\n      if (!policy) { return undefined; }\n      const result: any = { ...policy };\n      if (policy.resourceSignal && policy.resourceSignal.timeout) {\n        result.resourceSignal = policy.resourceSignal;\n      }\n      return result;\n    }\n  }\n\n  protected get cfnProperties(): { [key: string]: any } {\n    const tags = TagManager.isTaggable(this) ? this.tags.renderTags() : {};\n    return deepMerge(this._cfnProperties || {}, {tags});\n  }\n\n  protected renderProperties(props: {[key: string]: any}): { [key: string]: any } {\n    return props;\n  }\n\n  /**\n   * Return properties modified after initiation\n   *\n   * Resources that expose mutable properties should override this function to\n   * collect and return the properties object for this resource.\n   */\n  protected get updatedProperites(): { [key: string]: any } {\n    return this._cfnProperties;\n  }\n\n  protected validateProperties(_properties: any) {\n    // Nothing\n  }\n}\n\nexport enum TagType {\n  STANDARD = 'StandardTag',\n  AUTOSCALING_GROUP = 'AutoScalingGroupTag',\n  MAP = 'StringToStringMap',\n  KEY_VALUE = 'KeyValue',\n  NOT_TAGGABLE = 'NotTaggable',\n}\n\nexport interface ICfnResourceOptions {\n  /**\n   * A condition to associate with this resource. This means that only if the condition evaluates to 'true' when the stack\n   * is deployed, the resource will be included. This is provided to allow CDK projects to produce legacy templates, but noramlly\n   * there is no need to use it in CDK projects.\n   */\n  condition?: CfnCondition;\n\n  /**\n   * Associate the CreationPolicy attribute with a resource to prevent its status from reaching create complete until\n   * AWS CloudFormation receives a specified number of success signals or the timeout period is exceeded. To signal a\n   * resource, you can use the cfn-signal helper script or SignalResource API. AWS CloudFormation publishes valid signals\n   * to the stack events so that you track the number of signals sent.\n   */\n  creationPolicy?: CfnCreationPolicy;\n\n  /**\n   * With the DeletionPolicy attribute you can preserve or (in some cases) backup a resource when its stack is deleted.\n   * You specify a DeletionPolicy attribute for each resource that you want to control. If a resource has no DeletionPolicy\n   * attribute, AWS CloudFormation deletes the resource by default. Note that this capability also applies to update operations\n   * that lead to resources being removed.\n   */\n  deletionPolicy?: CfnDeletionPolicy;\n\n  /**\n   * Use the UpdatePolicy attribute to specify how AWS CloudFormation handles updates to the AWS::AutoScaling::AutoScalingGroup\n   * resource. AWS CloudFormation invokes one of three update policies depending on the type of change you make or whether a\n   * scheduled action is associated with the Auto Scaling group.\n   */\n  updatePolicy?: CfnUpdatePolicy;\n\n  /**\n   * Use the UpdateReplacePolicy attribute to retain or (in some cases) backup the existing physical instance of a resource\n   * when it is replaced during a stack update operation.\n   */\n  updateReplacePolicy?: CfnDeletionPolicy;\n\n  /**\n   * Metadata associated with the CloudFormation resource. This is not the same as the construct metadata which can be added\n   * using construct.addMetadata(), but would not appear in the CloudFormation template automatically.\n   */\n  metadata?: { [key: string]: any };\n}\n\n/**\n * Merges `source` into `target`, overriding any existing values.\n * `null`s will cause a value to be deleted.\n */\nfunction deepMerge(target: any, ...sources: any[]) {\n  for (const source of sources) {\n    if (typeof(source) !== 'object' || typeof(target) !== 'object') {\n      throw new Error(`Invalid usage. Both source (${JSON.stringify(source)}) and target (${JSON.stringify(target)}) must be objects`);\n    }\n\n    for (const key of Object.keys(source)) {\n      const value = source[key];\n      if (typeof(value) === 'object' && value != null && !Array.isArray(value)) {\n        // if the value at the target is not an object, override it with an\n        // object so we can continue the recursion\n        if (typeof(target[key]) !== 'object') {\n          target[key] = {};\n        }\n\n        deepMerge(target[key], value);\n\n        // if the result of the merge is an empty object, it's because the\n        // eventual value we assigned is `undefined`, and there are no\n        // sibling concrete values alongside, so we can delete this tree.\n        const output = target[key];\n        if (typeof(output) === 'object' && Object.keys(output).length === 0) {\n          delete target[key];\n        }\n      } else if (value === undefined) {\n        delete target[key];\n      } else {\n        target[key] = value;\n      }\n    }\n  }\n\n  return target;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cfn-resource.js","sourceRoot":"","sources":["cfn-resource.ts"],"names":[],"mappings":"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","sourcesContent":["import cxapi = require('@aws-cdk/cx-api');\nimport { CfnCondition } from './cfn-condition';\n// import required to be here, otherwise causes a cycle when running the generated JavaScript\n// tslint:disable-next-line:ordered-imports\nimport { CfnRefElement } from './cfn-element';\nimport { CfnCreationPolicy, CfnDeletionPolicy, CfnUpdatePolicy } from './cfn-resource-policy';\nimport { Construct, IConstruct } from './construct';\nimport { CfnReference } from './private/cfn-reference';\nimport { Reference } from './reference';\nimport { RemovalPolicy, RemovalPolicyOptions } from './removal-policy';\nimport { TagManager } from './tag-manager';\nimport { capitalizePropertyNames, ignoreEmpty, PostResolveToken } from './util';\n\nexport interface CfnResourceProps {\n  /**\n   * CloudFormation resource type (e.g. `AWS::S3::Bucket`).\n   */\n  readonly type: string;\n\n  /**\n   * Resource properties.\n   *\n   * @default - No resource properties.\n   */\n  readonly properties?: { [name: string]: any };\n}\n\n/**\n * Represents a CloudFormation resource.\n */\nexport class CfnResource extends CfnRefElement {\n  /**\n   * Check whether the given construct is a CfnResource\n   */\n  public static isCfnResource(construct: IConstruct): construct is CfnResource {\n    return (construct as any).cfnResourceType !== undefined;\n  }\n\n  // MAINTAINERS NOTE: this class serves as the base class for the generated L1\n  // (\"CFN\") resources (such as `s3.CfnBucket`). These resources will have a\n  // property for each CloudFormation property of the resource. This means that\n  // if at some point in the future a property is introduced with a name similar\n  // to one of the properties here, it will be \"masked\" by the derived class. To\n  // that end, we prefix all properties in this class with `cfnXxx` with the\n  // hope to avoid those conflicts in the future.\n\n  /**\n   * Options for this resource, such as condition, update policy etc.\n   */\n  public readonly cfnOptions: ICfnResourceOptions = {};\n\n  /**\n   * AWS resource type.\n   */\n  public readonly cfnResourceType: string;\n\n  /**\n   * AWS CloudFormation resource properties.\n   *\n   * This object is returned via cfnProperties\n   * @internal\n   */\n  protected readonly _cfnProperties: any;\n\n  /**\n   * An object to be merged on top of the entire resource definition.\n   */\n  private readonly rawOverrides: any = {};\n\n  /**\n   * Logical IDs of dependencies.\n   *\n   * Is filled during prepare().\n   */\n  private readonly dependsOn = new Set<CfnResource>();\n\n  /**\n   * Creates a resource construct.\n   * @param cfnResourceType The CloudFormation type of this resource (e.g. AWS::DynamoDB::Table)\n   */\n  constructor(scope: Construct, id: string, props: CfnResourceProps) {\n    super(scope, id);\n\n    if (!props.type) {\n      throw new Error('The `type` property is required');\n    }\n\n    this.cfnResourceType = props.type;\n    this._cfnProperties = props.properties || {};\n\n    // if aws:cdk:enable-path-metadata is set, embed the current construct's\n    // path in the CloudFormation template, so it will be possible to trace\n    // back to the actual construct path.\n    if (this.node.tryGetContext(cxapi.PATH_METADATA_ENABLE_CONTEXT)) {\n      this.cfnOptions.metadata = {\n        [cxapi.PATH_METADATA_KEY]: this.node.path\n      };\n    }\n  }\n\n  /**\n   * Sets the deletion policy of the resource based on the removal policy specified.\n   */\n  public applyRemovalPolicy(policy: RemovalPolicy | undefined, options: RemovalPolicyOptions = {}) {\n    policy = policy || options.default || RemovalPolicy.RETAIN;\n\n    let deletionPolicy;\n\n    switch (policy) {\n      case RemovalPolicy.DESTROY:\n        deletionPolicy = CfnDeletionPolicy.DELETE;\n        break;\n\n      case RemovalPolicy.RETAIN:\n        deletionPolicy = CfnDeletionPolicy.RETAIN;\n        break;\n\n      default:\n        throw new Error(`Invalid removal policy: ${policy}`);\n    }\n\n    this.cfnOptions.deletionPolicy = deletionPolicy;\n    if (options.applyToUpdateReplacePolicy !== false) {\n      this.cfnOptions.updateReplacePolicy = deletionPolicy;\n    }\n  }\n\n  /**\n   * Returns a token for an runtime attribute of this resource.\n   * Ideally, use generated attribute accessors (e.g. `resource.arn`), but this can be used for future compatibility\n   * in case there is no generated attribute.\n   * @param attributeName The name of the attribute.\n   */\n  public getAtt(attributeName: string): Reference {\n    return CfnReference.for(this, attributeName);\n  }\n\n  /**\n   * Adds an override to the synthesized CloudFormation resource. To add a\n   * property override, either use `addPropertyOverride` or prefix `path` with\n   * \"Properties.\" (i.e. `Properties.TopicName`).\n   *\n   * If the override is nested, separate each nested level using a dot (.) in the path parameter.\n   * If there is an array as part of the nesting, specify the index in the path.\n   *\n   * For example,\n   * ```typescript\n   * addOverride('Properties.GlobalSecondaryIndexes.0.Projection.NonKeyAttributes', ['myattribute'])\n   * addOverride('Properties.GlobalSecondaryIndexes.1.ProjectionType', 'INCLUDE')\n   * ```\n   * would add the overrides\n   * ```json\n   * \"Properties\": {\n   *   \"GlobalSecondaryIndexes\": [\n   *     {\n   *       \"Projection\": {\n   *         \"NonKeyAttributes\": [ \"myattribute\" ]\n   *         ...\n   *       }\n   *       ...\n   *     },\n   *     {\n   *       \"ProjectionType\": \"INCLUDE\"\n   *       ...\n   *     },\n   *   ]\n   *   ...\n   * }\n   * ```\n   *\n   * @param path - The path of the property, you can use dot notation to\n   *        override values in complex types. Any intermdediate keys\n   *        will be created as needed.\n   * @param value - The value. Could be primitive or complex.\n   */\n  public addOverride(path: string, value: any) {\n    const parts = path.split('.');\n    let curr: any = this.rawOverrides;\n\n    while (parts.length > 1) {\n      const key = parts.shift()!;\n\n      // if we can't recurse further or the previous value is not an\n      // object overwrite it with an object.\n      const isObject = curr[key] != null && typeof(curr[key]) === 'object' && !Array.isArray(curr[key]);\n      if (!isObject) {\n        curr[key] = {};\n      }\n\n      curr = curr[key];\n    }\n\n    const lastKey = parts.shift()!;\n    curr[lastKey] = value;\n  }\n\n  /**\n   * Syntactic sugar for `addOverride(path, undefined)`.\n   * @param path The path of the value to delete\n   */\n  public addDeletionOverride(path: string) {\n    this.addOverride(path, undefined);\n  }\n\n  /**\n   * Adds an override to a resource property.\n   *\n   * Syntactic sugar for `addOverride(\"Properties.<...>\", value)`.\n   *\n   * @param propertyPath The path of the property\n   * @param value The value\n   */\n  public addPropertyOverride(propertyPath: string, value: any) {\n    this.addOverride(`Properties.${propertyPath}`, value);\n  }\n\n  /**\n   * Adds an override that deletes the value of a property from the resource definition.\n   * @param propertyPath The path to the property.\n   */\n  public addPropertyDeletionOverride(propertyPath: string) {\n    this.addPropertyOverride(propertyPath, undefined);\n  }\n\n  /**\n   * Indicates that this resource depends on another resource and cannot be provisioned\n   * unless the other resource has been successfully provisioned.\n   */\n  public addDependsOn(resource: CfnResource) {\n    this.dependsOn.add(resource);\n  }\n\n  /**\n   * @returns a string representation of this resource\n   */\n  public toString() {\n    return `${super.toString()} [${this.cfnResourceType}]`;\n  }\n\n  /**\n   * Emits CloudFormation for this resource.\n   * @internal\n   */\n  public _toCloudFormation(): object {\n    try {\n      const ret = {\n        Resources: {\n          // Post-Resolve operation since otherwise deepMerge is going to mix values into\n          // the Token objects returned by ignoreEmpty.\n          [this.logicalId]: new PostResolveToken({\n            Type: this.cfnResourceType,\n            Properties: ignoreEmpty(this.cfnProperties),\n            DependsOn: ignoreEmpty(renderDependsOn(this.dependsOn)),\n            CreationPolicy:  capitalizePropertyNames(this, renderCreationPolicy(this.cfnOptions.creationPolicy)),\n            UpdatePolicy: capitalizePropertyNames(this, this.cfnOptions.updatePolicy),\n            UpdateReplacePolicy: capitalizePropertyNames(this, this.cfnOptions.updateReplacePolicy),\n            DeletionPolicy: capitalizePropertyNames(this, this.cfnOptions.deletionPolicy),\n            Metadata: ignoreEmpty(this.cfnOptions.metadata),\n            Condition: this.cfnOptions.condition && this.cfnOptions.condition.logicalId\n          }, props => {\n            const renderedProps = this.renderProperties(props.Properties || {});\n            props.Properties = renderedProps && (Object.values(renderedProps).find(v => !!v) ? renderedProps : undefined);\n            return deepMerge(props, this.rawOverrides);\n          })\n        }\n      };\n      return ret;\n    } catch (e) {\n      // Change message\n      e.message = `While synthesizing ${this.node.path}: ${e.message}`;\n      // Adjust stack trace (make it look like node built it, too...)\n      const trace = this.creationStack;\n      if (trace) {\n        const creationStack = ['--- resource created at ---', ...trace].join('\\n  at ');\n        const problemTrace = e.stack.substr(e.stack.indexOf(e.message) + e.message.length);\n        e.stack = `${e.message}\\n  ${creationStack}\\n  --- problem discovered at ---${problemTrace}`;\n      }\n\n      // Re-throw\n      throw e;\n    }\n\n    // returns the set of logical ID (tokens) this resource depends on\n    // sorted by construct paths to ensure test determinism\n    function renderDependsOn(dependsOn: Set<CfnResource>) {\n      return Array\n        .from(dependsOn)\n        .sort((x, y) => x.node.path.localeCompare(y.node.path))\n        .map(r => r.logicalId);\n    }\n\n    function renderCreationPolicy(policy: CfnCreationPolicy | undefined): any {\n      if (!policy) { return undefined; }\n      const result: any = { ...policy };\n      if (policy.resourceSignal && policy.resourceSignal.timeout) {\n        result.resourceSignal = policy.resourceSignal;\n      }\n      return result;\n    }\n  }\n\n  protected get cfnProperties(): { [key: string]: any } {\n    const tags = TagManager.isTaggable(this) ? this.tags.renderTags() : {};\n    return deepMerge(this._cfnProperties || {}, {tags});\n  }\n\n  protected renderProperties(props: {[key: string]: any}): { [key: string]: any } {\n    return props;\n  }\n\n  /**\n   * Return properties modified after initiation\n   *\n   * Resources that expose mutable properties should override this function to\n   * collect and return the properties object for this resource.\n   */\n  protected get updatedProperites(): { [key: string]: any } {\n    return this._cfnProperties;\n  }\n\n  protected validateProperties(_properties: any) {\n    // Nothing\n  }\n}\n\nexport enum TagType {\n  STANDARD = 'StandardTag',\n  AUTOSCALING_GROUP = 'AutoScalingGroupTag',\n  MAP = 'StringToStringMap',\n  KEY_VALUE = 'KeyValue',\n  NOT_TAGGABLE = 'NotTaggable',\n}\n\nexport interface ICfnResourceOptions {\n  /**\n   * A condition to associate with this resource. This means that only if the condition evaluates to 'true' when the stack\n   * is deployed, the resource will be included. This is provided to allow CDK projects to produce legacy templates, but noramlly\n   * there is no need to use it in CDK projects.\n   */\n  condition?: CfnCondition;\n\n  /**\n   * Associate the CreationPolicy attribute with a resource to prevent its status from reaching create complete until\n   * AWS CloudFormation receives a specified number of success signals or the timeout period is exceeded. To signal a\n   * resource, you can use the cfn-signal helper script or SignalResource API. AWS CloudFormation publishes valid signals\n   * to the stack events so that you track the number of signals sent.\n   */\n  creationPolicy?: CfnCreationPolicy;\n\n  /**\n   * With the DeletionPolicy attribute you can preserve or (in some cases) backup a resource when its stack is deleted.\n   * You specify a DeletionPolicy attribute for each resource that you want to control. If a resource has no DeletionPolicy\n   * attribute, AWS CloudFormation deletes the resource by default. Note that this capability also applies to update operations\n   * that lead to resources being removed.\n   */\n  deletionPolicy?: CfnDeletionPolicy;\n\n  /**\n   * Use the UpdatePolicy attribute to specify how AWS CloudFormation handles updates to the AWS::AutoScaling::AutoScalingGroup\n   * resource. AWS CloudFormation invokes one of three update policies depending on the type of change you make or whether a\n   * scheduled action is associated with the Auto Scaling group.\n   */\n  updatePolicy?: CfnUpdatePolicy;\n\n  /**\n   * Use the UpdateReplacePolicy attribute to retain or (in some cases) backup the existing physical instance of a resource\n   * when it is replaced during a stack update operation.\n   */\n  updateReplacePolicy?: CfnDeletionPolicy;\n\n  /**\n   * Metadata associated with the CloudFormation resource. This is not the same as the construct metadata which can be added\n   * using construct.addMetadata(), but would not appear in the CloudFormation template automatically.\n   */\n  metadata?: { [key: string]: any };\n}\n\n/**\n * Merges `source` into `target`, overriding any existing values.\n * `null`s will cause a value to be deleted.\n */\nfunction deepMerge(target: any, ...sources: any[]) {\n  for (const source of sources) {\n    if (typeof(source) !== 'object' || typeof(target) !== 'object') {\n      throw new Error(`Invalid usage. Both source (${JSON.stringify(source)}) and target (${JSON.stringify(target)}) must be objects`);\n    }\n\n    for (const key of Object.keys(source)) {\n      const value = source[key];\n      if (typeof(value) === 'object' && value != null && !Array.isArray(value)) {\n        // if the value at the target is not an object, override it with an\n        // object so we can continue the recursion\n        if (typeof(target[key]) !== 'object') {\n          target[key] = {};\n        }\n\n        deepMerge(target[key], value);\n\n        // if the result of the merge is an empty object, it's because the\n        // eventual value we assigned is `undefined`, and there are no\n        // sibling concrete values alongside, so we can delete this tree.\n        const output = target[key];\n        if (typeof(output) === 'object' && Object.keys(output).length === 0) {\n          delete target[key];\n        }\n      } else if (value === undefined) {\n        delete target[key];\n      } else {\n        target[key] = value;\n      }\n    }\n  }\n\n  return target;\n}\n"]}

lib/context-provider.js

@@ -80,2 +80,6 @@ "use strict";
     for (const key of Object.keys(props)) {
+        // skip undefined values
+        if (props[key] === undefined) {
+            continue;
+        }
         switch (typeof props[key]) {
@@ -99,2 +103,2 @@ case 'object': {
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-provider.js","sourceRoot":"","sources":["context-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import cxapi = require('@aws-cdk/cx-api');\nimport { Construct } from './construct';\nimport { Stack } from './stack';\nimport { Token } from './token';\n\n/**\n * @experimental\n */\nexport interface GetContextKeyOptions {\n  /**\n   * The context provider to query.\n   */\n  readonly provider: string;\n\n  /**\n   * Provider-specific properties.\n   */\n  readonly props?: { [key: string]: any };\n}\n\n/**\n * @experimental\n */\nexport interface GetContextValueOptions extends GetContextKeyOptions {\n  /**\n   * The value to return if the context value was not found and a missing\n   * context is reported. This should be a dummy value that should preferably\n   * fail during deployment since it represents an invalid state.\n   */\n  readonly dummyValue: any;\n}\n\n/**\n * @experimental\n */\nexport interface GetContextKeyResult {\n  readonly key: string;\n  readonly props: { [key: string]: any };\n}\n\n/**\n * @experimental\n */\nexport interface GetContextValueResult {\n  readonly value?: any;\n}\n\n/**\n * Base class for the model side of context providers\n *\n * Instances of this class communicate with context provider plugins in the 'cdk\n * toolkit' via context variables (input), outputting specialized queries for\n * more context variables (output).\n *\n * ContextProvider needs access to a Construct to hook into the context mechanism.\n *\n * @experimental\n */\nexport class ContextProvider {\n  /**\n   * @returns the context key or undefined if a key cannot be rendered (due to tokens used in any of the props)\n   */\n  public static getKey(scope: Construct, options: GetContextKeyOptions): GetContextKeyResult {\n    const stack = Stack.of(scope);\n\n    const props = {\n      account: stack.account,\n      region: stack.region,\n      ...options.props || {},\n    };\n\n    if (Object.values(props).find(x => Token.isUnresolved(x))) {\n      throw new Error(\n        `Cannot determine scope for context provider ${options.provider}.\\n` +\n        `This usually happens when one or more of the provider props have unresolved tokens`);\n    }\n\n    const propStrings = propsToArray(props);\n    return {\n      key: `${options.provider}:${propStrings.join(':')}`,\n      props\n    };\n  }\n\n  public static getValue(scope: Construct, options: GetContextValueOptions): GetContextValueResult {\n    const stack = Stack.of(scope);\n\n    if (Token.isUnresolved(stack.account) || Token.isUnresolved(stack.region)) {\n      throw new Error(`Cannot retrieve value from context provider ${options.provider} since account/region ` +\n                      `are not specified at the stack level. Either configure \"env\" with explicit account and region when ` +\n                      `you define your stack, or use the environment variables \"CDK_DEFAULT_ACCOUNT\" and \"CDK_DEFAULT_REGION\" ` +\n                      `to inherit environment information from the CLI (not recommended for production stacks)`);\n    }\n\n    const { key, props } = this.getKey(scope, options);\n    const value = scope.node.tryGetContext(key);\n    const providerError = extractProviderError(value);\n\n    // if context is missing or an error occurred during context retrieval,\n    // report and return a dummy value.\n    if (value === undefined || providerError !== undefined) {\n      stack.reportMissingContext({ key, props, provider: options.provider, });\n\n      if (providerError !== undefined) {\n        scope.node.addError(providerError);\n      }\n      return { value: options.dummyValue };\n    }\n\n    return { value };\n  }\n\n  private constructor() { }\n}\n\n/**\n * If the context value represents an error, return the error message\n */\nfunction extractProviderError(value: any): string | undefined {\n  if (typeof value === 'object' && value !== null) {\n    return value[cxapi.PROVIDER_ERROR_KEY];\n  }\n  return undefined;\n}\n\n/**\n * Quote colons in all strings so that we can undo the quoting at a later point\n *\n * We'll use $ as a quoting character, for no particularly good reason other\n * than that \\ is going to lead to quoting hell when the keys are stored in JSON.\n */\nfunction colonQuote(xs: string): string {\n  return xs.replace('$', '$$').replace(':', '$:');\n}\n\nfunction propsToArray(props: {[key: string]: any}, keyPrefix = ''): string[] {\n  const ret: string[] = [];\n\n  for (const key of Object.keys(props)) {\n    switch (typeof props[key]) {\n      case 'object': {\n        ret.push(...propsToArray(props[key], `${keyPrefix}${key}.`));\n        break;\n      }\n      case 'string': {\n        ret.push(`${keyPrefix}${key}=${colonQuote(props[key])}`);\n        break;\n      }\n      default: {\n        ret.push(`${keyPrefix}${key}=${JSON.stringify(props[key])}`);\n        break;\n      }\n    }\n  }\n\n  ret.sort();\n  return ret;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-provider.js","sourceRoot":"","sources":["context-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import cxapi = require('@aws-cdk/cx-api');\nimport { Construct } from './construct';\nimport { Stack } from './stack';\nimport { Token } from './token';\n\n/**\n * @experimental\n */\nexport interface GetContextKeyOptions {\n  /**\n   * The context provider to query.\n   */\n  readonly provider: string;\n\n  /**\n   * Provider-specific properties.\n   */\n  readonly props?: { [key: string]: any };\n}\n\n/**\n * @experimental\n */\nexport interface GetContextValueOptions extends GetContextKeyOptions {\n  /**\n   * The value to return if the context value was not found and a missing\n   * context is reported. This should be a dummy value that should preferably\n   * fail during deployment since it represents an invalid state.\n   */\n  readonly dummyValue: any;\n}\n\n/**\n * @experimental\n */\nexport interface GetContextKeyResult {\n  readonly key: string;\n  readonly props: { [key: string]: any };\n}\n\n/**\n * @experimental\n */\nexport interface GetContextValueResult {\n  readonly value?: any;\n}\n\n/**\n * Base class for the model side of context providers\n *\n * Instances of this class communicate with context provider plugins in the 'cdk\n * toolkit' via context variables (input), outputting specialized queries for\n * more context variables (output).\n *\n * ContextProvider needs access to a Construct to hook into the context mechanism.\n *\n * @experimental\n */\nexport class ContextProvider {\n  /**\n   * @returns the context key or undefined if a key cannot be rendered (due to tokens used in any of the props)\n   */\n  public static getKey(scope: Construct, options: GetContextKeyOptions): GetContextKeyResult {\n    const stack = Stack.of(scope);\n\n    const props = {\n      account: stack.account,\n      region: stack.region,\n      ...options.props || {},\n    };\n\n    if (Object.values(props).find(x => Token.isUnresolved(x))) {\n      throw new Error(\n        `Cannot determine scope for context provider ${options.provider}.\\n` +\n        `This usually happens when one or more of the provider props have unresolved tokens`);\n    }\n\n    const propStrings = propsToArray(props);\n    return {\n      key: `${options.provider}:${propStrings.join(':')}`,\n      props\n    };\n  }\n\n  public static getValue(scope: Construct, options: GetContextValueOptions): GetContextValueResult {\n    const stack = Stack.of(scope);\n\n    if (Token.isUnresolved(stack.account) || Token.isUnresolved(stack.region)) {\n      throw new Error(`Cannot retrieve value from context provider ${options.provider} since account/region ` +\n                      `are not specified at the stack level. Either configure \"env\" with explicit account and region when ` +\n                      `you define your stack, or use the environment variables \"CDK_DEFAULT_ACCOUNT\" and \"CDK_DEFAULT_REGION\" ` +\n                      `to inherit environment information from the CLI (not recommended for production stacks)`);\n    }\n\n    const { key, props } = this.getKey(scope, options);\n    const value = scope.node.tryGetContext(key);\n    const providerError = extractProviderError(value);\n\n    // if context is missing or an error occurred during context retrieval,\n    // report and return a dummy value.\n    if (value === undefined || providerError !== undefined) {\n      stack.reportMissingContext({ key, props, provider: options.provider, });\n\n      if (providerError !== undefined) {\n        scope.node.addError(providerError);\n      }\n      return { value: options.dummyValue };\n    }\n\n    return { value };\n  }\n\n  private constructor() { }\n}\n\n/**\n * If the context value represents an error, return the error message\n */\nfunction extractProviderError(value: any): string | undefined {\n  if (typeof value === 'object' && value !== null) {\n    return value[cxapi.PROVIDER_ERROR_KEY];\n  }\n  return undefined;\n}\n\n/**\n * Quote colons in all strings so that we can undo the quoting at a later point\n *\n * We'll use $ as a quoting character, for no particularly good reason other\n * than that \\ is going to lead to quoting hell when the keys are stored in JSON.\n */\nfunction colonQuote(xs: string): string {\n  return xs.replace('$', '$$').replace(':', '$:');\n}\n\nfunction propsToArray(props: {[key: string]: any}, keyPrefix = ''): string[] {\n  const ret: string[] = [];\n\n  for (const key of Object.keys(props)) {\n    // skip undefined values\n    if (props[key] === undefined) {\n      continue;\n    }\n\n    switch (typeof props[key]) {\n      case 'object': {\n        ret.push(...propsToArray(props[key], `${keyPrefix}${key}.`));\n        break;\n      }\n      case 'string': {\n        ret.push(`${keyPrefix}${key}=${colonQuote(props[key])}`);\n        break;\n      }\n      default: {\n        ret.push(`${keyPrefix}${key}=${JSON.stringify(props[key])}`);\n        break;\n      }\n    }\n  }\n\n  ret.sort();\n  return ret;\n}\n"]}

lib/index.d.ts

@@ -37,2 +37,3 @@ export * from './aspect';
 export * from './assets';
+export * from './tree';
 export * from './private/intrinsic';

lib/index.js

@@ -39,5 +39,6 @@ "use strict";
 __export(require("./assets"));
+__export(require("./tree"));
 // WARNING: Should not be exported, but currently is because of a bug. See the
 // class description for more information.
 __export(require("./private/intrinsic"));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

lib/private/encoding.d.ts

@@ -1,3 +0,2 @@
-import { IResolvable } from "../resolvable";
-import { IFragmentConcatenator } from "../resolvable";
+import { IFragmentConcatenator, IResolvable } from "../resolvable";
 import { TokenizedStringFragments } from "../string-fragments";
@@ -4,0 +3,0 @@ export declare const BEGIN_STRING_TOKEN_MARKER = "${Token[";

lib/private/encoding.js

@@ -201,2 +201,2 @@ "use strict";
 exports.extractTokenDouble = extractTokenDouble;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encoding.js","sourceRoot":"","sources":["encoding.ts"],"names":[],"mappings":";;AAEA,0DAA+D;AAC/D,oCAA8C;AAE9C,qFAAqF;AAExE,QAAA,yBAAyB,GAAG,UAAU,CAAC;AACvC,QAAA,uBAAuB,GAAG,UAAU,CAAC;AACrC,QAAA,gBAAgB,GAAG,IAAI,CAAC;AAExB,QAAA,eAAe,GAAG,eAAe,CAAC;AAE/C,MAAM,gCAAgC,GAAG,UAAU,CAAC,iCAAyB,CAAC,CAAC;AAC/E,MAAM,8BAA8B,GAAG,UAAU,CAAC,+BAAuB,CAAC,CAAC;AAC3E,MAAM,uBAAuB,GAAG,UAAU,CAAC,wBAAgB,CAAC,CAAC;AAE7D,MAAM,kBAAkB,GAAG,IAAI,MAAM,CAAC,GAAG,gCAAgC,KAAK,uBAAe,MAAM,uBAAuB,EAAE,EAAE,GAAG,CAAC,CAAC;AACnI,MAAM,gBAAgB,GAAG,IAAI,MAAM,CAAC,GAAG,8BAA8B,KAAK,uBAAe,MAAM,uBAAuB,EAAE,EAAE,GAAG,CAAC,CAAC;AAE/H;;GAEG;AACH,MAAa,WAAW;IAetB,YAA6B,GAAW,EAAmB,EAAU;QAAxC,QAAG,GAAH,GAAG,CAAQ;QAAmB,OAAE,GAAF,EAAE,CAAQ;IACrE,CAAC;IAfD;;OAEG;IACI,MAAM,CAAC,SAAS,CAAC,CAAS;QAC/B,OAAO,IAAI,WAAW,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,YAAY,CAAC,CAAS;QAClC,OAAO,IAAI,WAAW,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;IAC9C,CAAC;IAKD;;OAEG;IACI,KAAK,CAAC,MAAmC;QAC9C,MAAM,GAAG,GAAG,IAAI,2CAAwB,EAAE,CAAC;QAE3C,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,IAAI,CAAC,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,QAAQ;QAC/B,IAAI,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/B,OAAO,CAAC,EAAE;YACR,IAAI,CAAC,CAAC,KAAK,GAAG,IAAI,EAAE;gBAClB,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;aACnD;YAED,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAE3B,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC;YACzB,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SAC5B;QAED,IAAI,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE;YAC1B,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;SAC1C;QAED,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACI,IAAI;QACT,IAAI,CAAC,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,QAAQ;QAC/B,OAAO,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;CACF;AApDD,kCAoDC;AAED;;GAEG;AACH,SAAgB,UAAU,CAAC,CAAS;IAClC,OAAO,CAAC,CAAC,OAAO,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAAC;AACnD,CAAC;AAFD,gCAEC;AAED;;;;;GAKG;AACH,MAAa,UAAU;IACd,IAAI,CAAC,KAAsB,EAAE,MAAuB;QACzD,OAAO,SAAS,CAAC;IACnB,CAAC;CACF;AAJD,gCAIC;AAED,SAAgB,wBAAwB,CAAC,EAAS;IAChD,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,OAAM,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;AACpF,CAAC;AAFD,4DAEC;AAED;;;;;GAKG;AACH,SAAgB,UAAU,CAAC,GAAQ;IACjC,IAAI,OAAM,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE;QAC5B,OAAO,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;KAC1C;SAAM,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;QAClC,OAAO,kBAAkB,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC;KAC9C;SAAM,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;QACjD,OAAO,OAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,WAAW,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;KAC/E;SAAM;QACL,OAAO,0BAAkB,CAAC,GAAG,CAAC,CAAC;KAChC;AACH,CAAC;AAVD,gCAUC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,sCAAsC;AACtC,MAAM,wBAAwB,GAAG,MAAM,IAAI,EAAE,CAAC;AAE9C;;GAEG;AACH,MAAM,qBAAqB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAE/B;;;;GAIG;AACH,SAAgB,iBAAiB,CAAC,CAAS;IACzC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QAChC,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;KACtD;IACD,IAAI,CAAC,GAAG,qBAAqB,EAAE;QAC7B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,EAAE,CAAC,CAAC;KAC3D;IAED,MAAM,GAAG,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;IAC/B,MAAM,IAAI,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;IAElC,4BAA4B;IAC5B,IAAI,CAAC,CAAC,CAAC,GAAI,CAAC,GAAG,cAAc,CAAC,CAAC,2BAA2B;IAE1D,wEAAwE;IACxE,sBAAsB;IACtB,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,wBAAwB,CAAC,CAAC,qCAAqC;IAC/F,2BAA2B;IAE3B,OAAO,CAAC,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACpC,CAAC;AApBD,8CAoBC;AAED;;GAEG;AACH,SAAS,KAAK,CAAC,CAAS;IACtB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,SAAS,KAAK,CAAC,CAAS;IACtB,OAAO,CAAC,GAAG,MAAM,CAAC;AACpB,CAAC;AAED;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,OAAe;IAChD,MAAM,GAAG,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;IAC/B,CAAC,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAErC,MAAM,IAAI,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;IAElC,4BAA4B;IAC5B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,KAAK,wBAAwB,EAAE;QACvD,OAAO,SAAS,CAAC;KAClB;IAED,mDAAmD;IACnD,sDAAsD;IACtD,OAAO,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;IACzC,2BAA2B;AAC7B,CAAC;AAfD,gDAeC","sourcesContent":["import { IResolvable } from \"../resolvable\";\nimport { IFragmentConcatenator } from \"../resolvable\";\nimport { TokenizedStringFragments } from \"../string-fragments\";\nimport { isResolvableObject } from \"../token\";\n\n// Details for encoding and decoding Tokens into native types; should not be exported\n\nexport const BEGIN_STRING_TOKEN_MARKER = '${Token[';\nexport const BEGIN_LIST_TOKEN_MARKER = '#{Token[';\nexport const END_TOKEN_MARKER = ']}';\n\nexport const VALID_KEY_CHARS = 'a-zA-Z0-9:._-';\n\nconst QUOTED_BEGIN_STRING_TOKEN_MARKER = regexQuote(BEGIN_STRING_TOKEN_MARKER);\nconst QUOTED_BEGIN_LIST_TOKEN_MARKER = regexQuote(BEGIN_LIST_TOKEN_MARKER);\nconst QUOTED_END_TOKEN_MARKER = regexQuote(END_TOKEN_MARKER);\n\nconst STRING_TOKEN_REGEX = new RegExp(`${QUOTED_BEGIN_STRING_TOKEN_MARKER}([${VALID_KEY_CHARS}]+)${QUOTED_END_TOKEN_MARKER}`, 'g');\nconst LIST_TOKEN_REGEX = new RegExp(`${QUOTED_BEGIN_LIST_TOKEN_MARKER}([${VALID_KEY_CHARS}]+)${QUOTED_END_TOKEN_MARKER}`, 'g');\n\n/**\n * A string with markers in it that can be resolved to external values\n */\nexport class TokenString {\n  /**\n   * Returns a `TokenString` for this string.\n   */\n  public static forString(s: string) {\n    return new TokenString(s, STRING_TOKEN_REGEX);\n  }\n\n  /**\n   * Returns a `TokenString` for this string (must be the first string element of the list)\n   */\n  public static forListToken(s: string) {\n    return new TokenString(s, LIST_TOKEN_REGEX);\n  }\n\n  constructor(private readonly str: string, private readonly re: RegExp) {\n  }\n\n  /**\n   * Split string on markers, substituting markers with Tokens\n   */\n  public split(lookup: (id: string) => IResolvable): TokenizedStringFragments {\n    const ret = new TokenizedStringFragments();\n\n    let rest = 0;\n    this.re.lastIndex = 0; // Reset\n    let m = this.re.exec(this.str);\n    while (m) {\n      if (m.index > rest) {\n        ret.addLiteral(this.str.substring(rest, m.index));\n      }\n\n      ret.addToken(lookup(m[1]));\n\n      rest = this.re.lastIndex;\n      m = this.re.exec(this.str);\n    }\n\n    if (rest < this.str.length) {\n      ret.addLiteral(this.str.substring(rest));\n    }\n\n    return ret;\n  }\n\n  /**\n   * Indicates if this string includes tokens.\n   */\n  public test(): boolean {\n    this.re.lastIndex = 0; // Reset\n    return this.re.test(this.str);\n  }\n}\n\n/**\n * Quote a string for use in a regex\n */\nexport function regexQuote(s: string) {\n  return s.replace(/[.?*+^$[\\]\\\\(){}|-]/g, \"\\\\$&\");\n}\n\n/**\n * Concatenator that disregards the input\n *\n * Can be used when traversing the tokens is important, but the\n * result isn't.\n */\nexport class NullConcat implements IFragmentConcatenator {\n  public join(_left: any | undefined, _right: any | undefined): any {\n    return undefined;\n  }\n}\n\nexport function containsListTokenElement(xs: any[]) {\n  return xs.some(x => typeof(x) === 'string' && TokenString.forListToken(x).test());\n}\n\n/**\n * Returns true if obj is a token (i.e. has the resolve() method or is a string\n * that includes token markers), or it's a listifictaion of a Token string.\n *\n * @param obj The object to test.\n */\nexport function unresolved(obj: any): boolean {\n  if (typeof(obj) === 'string') {\n    return TokenString.forString(obj).test();\n  } else if (typeof obj === 'number') {\n    return extractTokenDouble(obj) !== undefined;\n  } else if (Array.isArray(obj) && obj.length === 1) {\n    return typeof(obj[0]) === 'string' && TokenString.forListToken(obj[0]).test();\n  } else {\n    return isResolvableObject(obj);\n  }\n}\n\n/**\n * Bit pattern in the top 16 bits of a double to indicate a Token\n *\n * An IEEE double in LE memory order looks like this (grouped\n * into octets, then grouped into 32-bit words):\n *\n * mmmmmmmm.mmmmmmmm.mmmmmmmm.mmmmmmmm | mmmmmmmm.mmmmmmmm.EEEEmmmm.sEEEEEEE\n *\n * - m: mantissa (52 bits)\n * - E: exponent (11 bits)\n * - s: sign (1 bit)\n *\n * We put the following marker into the top 16 bits (exponent and sign), and\n * use the mantissa part to encode the token index. To save some bit twiddling\n * we use all top 16 bits for the tag. That loses us 4 mantissa bits to store\n * information in but we still have 48, which is going to be plenty for any\n * number of tokens to be created during the lifetime of any CDK application.\n *\n * Can't have all bits set because that makes a NaN, so unset the least\n * significant exponent bit.\n *\n * Currently not supporting BE architectures.\n */\n// tslint:disable-next-line:no-bitwise\nconst DOUBLE_TOKEN_MARKER_BITS = 0xFBFF << 16;\n\n/**\n * Highest encodable number\n */\nconst MAX_ENCODABLE_INTEGER = Math.pow(2, 48) - 1;\n\n/**\n * Get 2^32 as a number, so we can do multiplication and div instead of bit shifting\n *\n * Necessary because in JavaScript, bit operations implicitly convert\n * to int32 and we need them to work on \"int64\"s.\n *\n * So instead of x >> 32, we do Math.floor(x / 2^32), and vice versa.\n */\nconst BITS32 = Math.pow(2, 32);\n\n/**\n * Return a special Double value that encodes the given nonnegative integer\n *\n * We use this to encode Token ordinals.\n */\nexport function createTokenDouble(x: number) {\n  if (Math.floor(x) !== x || x < 0) {\n    throw new Error('Can only encode positive integers');\n  }\n  if (x > MAX_ENCODABLE_INTEGER) {\n    throw new Error(`Got an index too large to encode: ${x}`);\n  }\n\n  const buf = new ArrayBuffer(8);\n  const ints = new Uint32Array(buf);\n\n  // tslint:disable:no-bitwise\n  ints[0] =  x & 0x0000FFFFFFFF; // Bottom 32 bits of number\n\n  // This needs an \"x >> 32\" but that will make it a 32-bit number instead\n  // of a 64-bit number.\n  ints[1] = (shr32(x) & 0xFFFF) | DOUBLE_TOKEN_MARKER_BITS; // Top 16 bits of number and the mask\n  // tslint:enable:no-bitwise\n\n  return (new Float64Array(buf))[0];\n}\n\n/**\n * Shift a 64-bit int right 32 bits\n */\nfunction shr32(x: number) {\n  return Math.floor(x / BITS32);\n}\n\n/**\n * Shift a 64-bit left 32 bits\n */\nfunction shl32(x: number) {\n  return x * BITS32;\n}\n\n/**\n * Extract the encoded integer out of the special Double value\n *\n * Returns undefined if the float is a not an encoded token.\n */\nexport function extractTokenDouble(encoded: number): number | undefined {\n  const buf = new ArrayBuffer(8);\n  (new Float64Array(buf))[0] = encoded;\n\n  const ints = new Uint32Array(buf);\n\n  // tslint:disable:no-bitwise\n  if ((ints[1] & 0xFFFF0000) !== DOUBLE_TOKEN_MARKER_BITS) {\n    return undefined;\n  }\n\n  // Must use + instead of | here (bitwise operations\n  // will force 32-bits integer arithmetic, + will not).\n  return ints[0] + shl32(ints[1] & 0xFFFF);\n  // tslint:enable:no-bitwise\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encoding.js","sourceRoot":"","sources":["encoding.ts"],"names":[],"mappings":"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","sourcesContent":["import { IFragmentConcatenator, IResolvable } from \"../resolvable\";\nimport { TokenizedStringFragments } from \"../string-fragments\";\nimport { isResolvableObject } from \"../token\";\n\n// Details for encoding and decoding Tokens into native types; should not be exported\n\nexport const BEGIN_STRING_TOKEN_MARKER = '${Token[';\nexport const BEGIN_LIST_TOKEN_MARKER = '#{Token[';\nexport const END_TOKEN_MARKER = ']}';\n\nexport const VALID_KEY_CHARS = 'a-zA-Z0-9:._-';\n\nconst QUOTED_BEGIN_STRING_TOKEN_MARKER = regexQuote(BEGIN_STRING_TOKEN_MARKER);\nconst QUOTED_BEGIN_LIST_TOKEN_MARKER = regexQuote(BEGIN_LIST_TOKEN_MARKER);\nconst QUOTED_END_TOKEN_MARKER = regexQuote(END_TOKEN_MARKER);\n\nconst STRING_TOKEN_REGEX = new RegExp(`${QUOTED_BEGIN_STRING_TOKEN_MARKER}([${VALID_KEY_CHARS}]+)${QUOTED_END_TOKEN_MARKER}`, 'g');\nconst LIST_TOKEN_REGEX = new RegExp(`${QUOTED_BEGIN_LIST_TOKEN_MARKER}([${VALID_KEY_CHARS}]+)${QUOTED_END_TOKEN_MARKER}`, 'g');\n\n/**\n * A string with markers in it that can be resolved to external values\n */\nexport class TokenString {\n  /**\n   * Returns a `TokenString` for this string.\n   */\n  public static forString(s: string) {\n    return new TokenString(s, STRING_TOKEN_REGEX);\n  }\n\n  /**\n   * Returns a `TokenString` for this string (must be the first string element of the list)\n   */\n  public static forListToken(s: string) {\n    return new TokenString(s, LIST_TOKEN_REGEX);\n  }\n\n  constructor(private readonly str: string, private readonly re: RegExp) {\n  }\n\n  /**\n   * Split string on markers, substituting markers with Tokens\n   */\n  public split(lookup: (id: string) => IResolvable): TokenizedStringFragments {\n    const ret = new TokenizedStringFragments();\n\n    let rest = 0;\n    this.re.lastIndex = 0; // Reset\n    let m = this.re.exec(this.str);\n    while (m) {\n      if (m.index > rest) {\n        ret.addLiteral(this.str.substring(rest, m.index));\n      }\n\n      ret.addToken(lookup(m[1]));\n\n      rest = this.re.lastIndex;\n      m = this.re.exec(this.str);\n    }\n\n    if (rest < this.str.length) {\n      ret.addLiteral(this.str.substring(rest));\n    }\n\n    return ret;\n  }\n\n  /**\n   * Indicates if this string includes tokens.\n   */\n  public test(): boolean {\n    this.re.lastIndex = 0; // Reset\n    return this.re.test(this.str);\n  }\n}\n\n/**\n * Quote a string for use in a regex\n */\nexport function regexQuote(s: string) {\n  return s.replace(/[.?*+^$[\\]\\\\(){}|-]/g, \"\\\\$&\");\n}\n\n/**\n * Concatenator that disregards the input\n *\n * Can be used when traversing the tokens is important, but the\n * result isn't.\n */\nexport class NullConcat implements IFragmentConcatenator {\n  public join(_left: any | undefined, _right: any | undefined): any {\n    return undefined;\n  }\n}\n\nexport function containsListTokenElement(xs: any[]) {\n  return xs.some(x => typeof(x) === 'string' && TokenString.forListToken(x).test());\n}\n\n/**\n * Returns true if obj is a token (i.e. has the resolve() method or is a string\n * that includes token markers), or it's a listifictaion of a Token string.\n *\n * @param obj The object to test.\n */\nexport function unresolved(obj: any): boolean {\n  if (typeof(obj) === 'string') {\n    return TokenString.forString(obj).test();\n  } else if (typeof obj === 'number') {\n    return extractTokenDouble(obj) !== undefined;\n  } else if (Array.isArray(obj) && obj.length === 1) {\n    return typeof(obj[0]) === 'string' && TokenString.forListToken(obj[0]).test();\n  } else {\n    return isResolvableObject(obj);\n  }\n}\n\n/**\n * Bit pattern in the top 16 bits of a double to indicate a Token\n *\n * An IEEE double in LE memory order looks like this (grouped\n * into octets, then grouped into 32-bit words):\n *\n * mmmmmmmm.mmmmmmmm.mmmmmmmm.mmmmmmmm | mmmmmmmm.mmmmmmmm.EEEEmmmm.sEEEEEEE\n *\n * - m: mantissa (52 bits)\n * - E: exponent (11 bits)\n * - s: sign (1 bit)\n *\n * We put the following marker into the top 16 bits (exponent and sign), and\n * use the mantissa part to encode the token index. To save some bit twiddling\n * we use all top 16 bits for the tag. That loses us 4 mantissa bits to store\n * information in but we still have 48, which is going to be plenty for any\n * number of tokens to be created during the lifetime of any CDK application.\n *\n * Can't have all bits set because that makes a NaN, so unset the least\n * significant exponent bit.\n *\n * Currently not supporting BE architectures.\n */\n// tslint:disable-next-line:no-bitwise\nconst DOUBLE_TOKEN_MARKER_BITS = 0xFBFF << 16;\n\n/**\n * Highest encodable number\n */\nconst MAX_ENCODABLE_INTEGER = Math.pow(2, 48) - 1;\n\n/**\n * Get 2^32 as a number, so we can do multiplication and div instead of bit shifting\n *\n * Necessary because in JavaScript, bit operations implicitly convert\n * to int32 and we need them to work on \"int64\"s.\n *\n * So instead of x >> 32, we do Math.floor(x / 2^32), and vice versa.\n */\nconst BITS32 = Math.pow(2, 32);\n\n/**\n * Return a special Double value that encodes the given nonnegative integer\n *\n * We use this to encode Token ordinals.\n */\nexport function createTokenDouble(x: number) {\n  if (Math.floor(x) !== x || x < 0) {\n    throw new Error('Can only encode positive integers');\n  }\n  if (x > MAX_ENCODABLE_INTEGER) {\n    throw new Error(`Got an index too large to encode: ${x}`);\n  }\n\n  const buf = new ArrayBuffer(8);\n  const ints = new Uint32Array(buf);\n\n  // tslint:disable:no-bitwise\n  ints[0] =  x & 0x0000FFFFFFFF; // Bottom 32 bits of number\n\n  // This needs an \"x >> 32\" but that will make it a 32-bit number instead\n  // of a 64-bit number.\n  ints[1] = (shr32(x) & 0xFFFF) | DOUBLE_TOKEN_MARKER_BITS; // Top 16 bits of number and the mask\n  // tslint:enable:no-bitwise\n\n  return (new Float64Array(buf))[0];\n}\n\n/**\n * Shift a 64-bit int right 32 bits\n */\nfunction shr32(x: number) {\n  return Math.floor(x / BITS32);\n}\n\n/**\n * Shift a 64-bit left 32 bits\n */\nfunction shl32(x: number) {\n  return x * BITS32;\n}\n\n/**\n * Extract the encoded integer out of the special Double value\n *\n * Returns undefined if the float is a not an encoded token.\n */\nexport function extractTokenDouble(encoded: number): number | undefined {\n  const buf = new ArrayBuffer(8);\n  (new Float64Array(buf))[0] = encoded;\n\n  const ints = new Uint32Array(buf);\n\n  // tslint:disable:no-bitwise\n  if ((ints[1] & 0xFFFF0000) !== DOUBLE_TOKEN_MARKER_BITS) {\n    return undefined;\n  }\n\n  // Must use + instead of | here (bitwise operations\n  // will force 32-bits integer arithmetic, + will not).\n  return ints[0] + shl32(ints[1] & 0xFFFF);\n  // tslint:enable:no-bitwise\n}\n"]}

lib/private/tree-metadata.d.ts

@@ -12,2 +12,3 @@ import { Construct, ISynthesisSession } from '../construct';
     protected synthesize(session: ISynthesisSession): void;
+    private getAttributes;
 }

lib/private/tree-metadata.js

@@ -7,2 +7,3 @@ "use strict";
 const construct_1 = require("../construct");
+const tree_1 = require("../tree");
 const FILE_PATH = 'tree.json';
@@ -24,6 +25,8 @@ /**
             const children = construct.node.children.map(visit);
+            const childrenMap = children.reduce((map, child) => Object.assign(map, { [child.id]: child }), {});
             const node = {
                 id: construct.node.id || 'App',
                 path: construct.node.path,
-                children: children.length === 0 ? undefined : children,
+                children: children.length === 0 ? undefined : childrenMap,
+                attributes: this.getAttributes(construct)
             };
@@ -46,4 +49,17 @@ lookup[node.path] = node;
     }
+    getAttributes(construct) {
+        // check if a construct implements IInspectable
+        function canInspect(inspectable) {
+            return inspectable.inspect !== undefined;
+        }
+        const inspector = new tree_1.TreeInspector();
+        // get attributes from the inspector
+        if (canInspect(construct)) {
+            construct.inspect(inspector);
+            return inspector.attributes;
+        }
+        return undefined;
+    }
 }
 exports.TreeMetadata = TreeMetadata;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

lib/stack.d.ts

@@ -134,2 +134,6 @@ import cxapi = require('@aws-cdk/cx-api');
     /**
+     * The ID of the cloud assembly artifact for this stack.
+     */
+    readonly artifactId: string;
+    /**
      * Logical ID generation strategy
@@ -158,6 +162,8 @@ */
      * @param scope Parent of this stack, usually a Program instance.
-     * @param name The name of the CloudFormation stack. Defaults to "Stack".
+     * @param id The construct ID of this stack. If `stackName` is not explicitly
+     * defined, this id (and any parent IDs) will be used to determine the
+     * physical ID of the stack.
      * @param props Stack properties.
      */
-    constructor(scope?: Construct, name?: string, props?: StackProps);
+    constructor(scope?: Construct, id?: string, props?: StackProps);
     /**
@@ -392,3 +398,3 @@ * Resolve a tokenized value in the context of the current stack.
      */
-    private calculateStackName;
+    private generateUniqueStackName;
     private generateExportName;
@@ -395,0 +401,0 @@ private readonly assetParameters;

lib/token.d.ts

@@ -88,2 +88,6 @@ import { IConstruct } from "./construct";
     static isResolvable(obj: any): obj is IResolvable;
+    /**
+     * Stringify a number directly or lazily if it's a Token. If it is an object (i.e., { Ref: 'SomeLogicalId' }), return it as-is.
+     */
+    static stringifyNumber(x: number): string;
     private constructor();
@@ -90,0 +94,0 @@ }

lib/token.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const lazy_1 = require("./lazy");
 const encoding_1 = require("./private/encoding");
@@ -126,2 +127,17 @@ const intrinsic_1 = require("./private/intrinsic");
     }
+    /**
+     * Stringify a number directly or lazily if it's a Token. If it is an object (i.e., { Ref: 'SomeLogicalId' }), return it as-is.
+     */
+    static stringifyNumber(x) {
+        // only convert numbers to strings so that Refs, conditions, and other things don't end up synthesizing as [object object]
+        if (Token.isUnresolved(x)) {
+            return lazy_1.Lazy.stringValue({ produce: context => {
+                    const resolved = context.resolve(x);
+                    return typeof resolved !== 'number' ? resolved : `${resolved}`;
+                } });
+        }
+        else {
+            return typeof x !== 'number' ? x : `${x}`;
+        }
+    }
     constructor() {
@@ -146,2 +162,2 @@ }
 exports.withResolved = withResolved;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token.js","sourceRoot":"","sources":["token.ts"],"names":[],"mappings":"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","sourcesContent":["import { IConstruct } from \"./construct\";\nimport { unresolved } from \"./private/encoding\";\nimport { Intrinsic } from \"./private/intrinsic\";\nimport { resolve } from \"./private/resolve\";\nimport { TokenMap } from \"./private/token-map\";\nimport { IResolvable, ITokenResolver } from \"./resolvable\";\nimport { TokenizedStringFragments } from \"./string-fragments\";\n\n/**\n * Represents a special or lazily-evaluated value.\n *\n * Can be used to delay evaluation of a certain value in case, for example,\n * that it requires some context or late-bound data. Can also be used to\n * mark values that need special processing at document rendering time.\n *\n * Tokens can be embedded into strings while retaining their original\n * semantics.\n */\nexport class Token {\n  /**\n   * Returns true if obj represents an unresolved value\n   *\n   * One of these must be true:\n   *\n   * - `obj` is an IResolvable\n   * - `obj` is a string containing at least one encoded `IResolvable`\n   * - `obj` is either an encoded number or list\n   *\n   * This does NOT recurse into lists or objects to see if they\n   * containing resolvables.\n   *\n   * @param obj The object to test.\n   */\n  public static isUnresolved(obj: any): boolean {\n    return unresolved(obj);\n  }\n\n  /**\n   * Return a reversible string representation of this token\n   *\n   * If the Token is initialized with a literal, the stringified value of the\n   * literal is returned. Otherwise, a special quoted string representation\n   * of the Token is returned that can be embedded into other strings.\n   *\n   * Strings with quoted Tokens in them can be restored back into\n   * complex values with the Tokens restored by calling `resolve()`\n   * on the string.\n   */\n  public static asString(value: any, options: EncodingOptions = {}): string {\n    if (typeof value === 'string') { return value; }\n    return TokenMap.instance().registerString(Token.asAny(value), options.displayHint);\n  }\n\n  /**\n   * Return a reversible number representation of this token\n   */\n  public static asNumber(value: any): number {\n    if (typeof value === 'number') { return value; }\n    return TokenMap.instance().registerNumber(Token.asAny(value));\n  }\n\n  /**\n   * Return a reversible list representation of this token\n   */\n  public static asList(value: any, options: EncodingOptions = {}): string[] {\n    if (Array.isArray(value) && value.every(x => typeof x === 'string')) { return value; }\n    return TokenMap.instance().registerList(Token.asAny(value), options.displayHint);\n  }\n\n  /**\n   * Return a resolvable representation of the given value\n   */\n  public static asAny(value: any): IResolvable {\n    return isResolvableObject(value) ? value : new Intrinsic(value);\n  }\n\n  private constructor() {\n  }\n}\n\n/**\n * Less oft-needed functions to manipulate Tokens\n */\nexport class Tokenization {\n  /**\n   * Un-encode a string potentially containing encoded tokens\n   */\n  public static reverseString(s: string): TokenizedStringFragments {\n    return TokenMap.instance().splitString(s);\n  }\n\n  /**\n   * Un-encode a Tokenized value from a number\n   */\n  public static reverseNumber(n: number): IResolvable | undefined {\n    return TokenMap.instance().lookupNumberToken(n);\n  }\n\n  /**\n   * Un-encode a Tokenized value from a list\n   */\n  public static reverseList(l: string[]): IResolvable | undefined {\n    return TokenMap.instance().lookupList(l);\n  }\n\n  /**\n   * Resolves an object by evaluating all tokens and removing any undefined or empty objects or arrays.\n   * Values can only be primitives, arrays or tokens. Other objects (i.e. with methods) will be rejected.\n   *\n   * @param obj The object to resolve.\n   * @param options Prefix key path components for diagnostics.\n   */\n  public static resolve(obj: any, options: ResolveOptions): any {\n    return resolve(obj, {\n      scope: options.scope,\n      resolver: options.resolver,\n      preparing: (options.preparing !== undefined ? options.preparing : false)\n    });\n  }\n\n  /**\n   * Return whether the given object is an IResolvable object\n   *\n   * This is different from Token.isUnresolved() which will also check for\n   * encoded Tokens, whereas this method will only do a type check on the given\n   * object.\n   */\n  public static isResolvable(obj: any): obj is IResolvable {\n    return isResolvableObject(obj);\n  }\n\n  private constructor() {\n  }\n}\n\n/**\n * Options to the resolve() operation\n *\n * NOT the same as the ResolveContext; ResolveContext is exposed to Token\n * implementors and resolution hooks, whereas this struct is just to bundle\n * a number of things that would otherwise be arguments to resolve() in a\n * readable way.\n */\nexport interface ResolveOptions {\n  /**\n   * The scope from which resolution is performed\n   */\n  readonly scope: IConstruct;\n\n  /**\n   * The resolver to apply to any resolvable tokens found\n   */\n  readonly resolver: ITokenResolver;\n\n  /**\n   * Whether the resolution is being executed during the prepare phase or not.\n   * @default false\n   */\n  readonly preparing?: boolean;\n}\n\n/**\n * Properties to string encodings\n */\nexport interface EncodingOptions {\n  /**\n   * A hint for the Token's purpose when stringifying it\n   */\n  readonly displayHint?: string;\n}\n\nexport function isResolvableObject(x: any): x is IResolvable {\n  return typeof(x) === 'object' && x !== null && typeof x.resolve === 'function';\n}\n\n/**\n * Call the given function only if all given values are resolved\n *\n * Exported as a function since it will be used by TypeScript modules, but\n * can't be exposed via JSII because of the generics.\n */\nexport function withResolved<A>(a: A, fn: (a: A) => void): void;\nexport function withResolved<A, B>(a: A, b: B, fn: (a: A, b: B) => void): void;\nexport function withResolved<A, B, C>(a: A, b: B, c: C, fn: (a: A, b: B, c: C) => void): void;\nexport function withResolved(...args: any[]) {\n  if (args.length < 2) { return; }\n  const argArray = args.slice(0, args.length - 1);\n  if (argArray.some(Token.isUnresolved)) { return; }\n  args[args.length - 1].apply(arguments, argArray);\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token.js","sourceRoot":"","sources":["token.ts"],"names":[],"mappings":";;AACA,iCAA8B;AAC9B,iDAAgD;AAChD,mDAAgD;AAChD,+CAA4C;AAC5C,mDAA+C;AAI/C;;;;;;;;;GASG;AACH,MAAa,KAAK;IAChB;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAC,YAAY,CAAC,GAAQ;QACjC,OAAO,qBAAU,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,QAAQ,CAAC,KAAU,EAAE,UAA2B,EAAE;QAC9D,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAAE,OAAO,KAAK,CAAC;SAAE;QAChD,OAAO,oBAAQ,CAAC,QAAQ,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IACrF,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,QAAQ,CAAC,KAAU;QAC/B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAAE,OAAO,KAAK,CAAC;SAAE;QAChD,OAAO,oBAAQ,CAAC,QAAQ,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IAChE,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,MAAM,CAAC,KAAU,EAAE,UAA2B,EAAE;QAC5D,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,EAAE;YAAE,OAAO,KAAK,CAAC;SAAE;QACtF,OAAO,oBAAQ,CAAC,QAAQ,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IACnF,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,KAAK,CAAC,KAAU;QAC5B,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,qBAAS,CAAC,KAAK,CAAC,CAAC;IAClE,CAAC;IAED;IACA,CAAC;CACF;AA5DD,sBA4DC;AAED;;GAEG;AACH,MAAa,YAAY;IACvB;;OAEG;IACI,MAAM,CAAC,aAAa,CAAC,CAAS;QACnC,OAAO,oBAAQ,CAAC,QAAQ,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,aAAa,CAAC,CAAS;QACnC,OAAO,oBAAQ,CAAC,QAAQ,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,WAAW,CAAC,CAAW;QACnC,OAAO,oBAAQ,CAAC,QAAQ,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,OAAO,CAAC,GAAQ,EAAE,OAAuB;QACrD,OAAO,iBAAO,CAAC,GAAG,EAAE;YAClB,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,SAAS,EAAE,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC;SACzE,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,YAAY,CAAC,GAAQ;QACjC,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,eAAe,CAAC,CAAS;QACrC,0HAA0H;QAE1H,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE;YACzB,OAAO,WAAI,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;oBACzC,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;oBACpC,OAAO,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,EAAE,CAAC;gBACjE,CAAC,EAAE,CAAC,CAAC;SACR;aAAM;YACL,OAAO,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;SAC3C;IACH,CAAC;IAED;IACA,CAAC;CACF;AAlED,oCAkEC;AAsCD,SAAgB,kBAAkB,CAAC,CAAM;IACvC,OAAO,OAAM,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,UAAU,CAAC;AACjF,CAAC;AAFD,gDAEC;AAWD,SAAgB,YAAY,CAAC,GAAG,IAAW;IACzC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;QAAE,OAAO;KAAE;IAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChD,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE;QAAE,OAAO;KAAE;IAClD,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;AACnD,CAAC;AALD,oCAKC","sourcesContent":["import { IConstruct } from \"./construct\";\nimport { Lazy } from \"./lazy\";\nimport { unresolved } from \"./private/encoding\";\nimport { Intrinsic } from \"./private/intrinsic\";\nimport { resolve } from \"./private/resolve\";\nimport { TokenMap } from \"./private/token-map\";\nimport { IResolvable, ITokenResolver } from \"./resolvable\";\nimport { TokenizedStringFragments } from \"./string-fragments\";\n\n/**\n * Represents a special or lazily-evaluated value.\n *\n * Can be used to delay evaluation of a certain value in case, for example,\n * that it requires some context or late-bound data. Can also be used to\n * mark values that need special processing at document rendering time.\n *\n * Tokens can be embedded into strings while retaining their original\n * semantics.\n */\nexport class Token {\n  /**\n   * Returns true if obj represents an unresolved value\n   *\n   * One of these must be true:\n   *\n   * - `obj` is an IResolvable\n   * - `obj` is a string containing at least one encoded `IResolvable`\n   * - `obj` is either an encoded number or list\n   *\n   * This does NOT recurse into lists or objects to see if they\n   * containing resolvables.\n   *\n   * @param obj The object to test.\n   */\n  public static isUnresolved(obj: any): boolean {\n    return unresolved(obj);\n  }\n\n  /**\n   * Return a reversible string representation of this token\n   *\n   * If the Token is initialized with a literal, the stringified value of the\n   * literal is returned. Otherwise, a special quoted string representation\n   * of the Token is returned that can be embedded into other strings.\n   *\n   * Strings with quoted Tokens in them can be restored back into\n   * complex values with the Tokens restored by calling `resolve()`\n   * on the string.\n   */\n  public static asString(value: any, options: EncodingOptions = {}): string {\n    if (typeof value === 'string') { return value; }\n    return TokenMap.instance().registerString(Token.asAny(value), options.displayHint);\n  }\n\n  /**\n   * Return a reversible number representation of this token\n   */\n  public static asNumber(value: any): number {\n    if (typeof value === 'number') { return value; }\n    return TokenMap.instance().registerNumber(Token.asAny(value));\n  }\n\n  /**\n   * Return a reversible list representation of this token\n   */\n  public static asList(value: any, options: EncodingOptions = {}): string[] {\n    if (Array.isArray(value) && value.every(x => typeof x === 'string')) { return value; }\n    return TokenMap.instance().registerList(Token.asAny(value), options.displayHint);\n  }\n\n  /**\n   * Return a resolvable representation of the given value\n   */\n  public static asAny(value: any): IResolvable {\n    return isResolvableObject(value) ? value : new Intrinsic(value);\n  }\n\n  private constructor() {\n  }\n}\n\n/**\n * Less oft-needed functions to manipulate Tokens\n */\nexport class Tokenization {\n  /**\n   * Un-encode a string potentially containing encoded tokens\n   */\n  public static reverseString(s: string): TokenizedStringFragments {\n    return TokenMap.instance().splitString(s);\n  }\n\n  /**\n   * Un-encode a Tokenized value from a number\n   */\n  public static reverseNumber(n: number): IResolvable | undefined {\n    return TokenMap.instance().lookupNumberToken(n);\n  }\n\n  /**\n   * Un-encode a Tokenized value from a list\n   */\n  public static reverseList(l: string[]): IResolvable | undefined {\n    return TokenMap.instance().lookupList(l);\n  }\n\n  /**\n   * Resolves an object by evaluating all tokens and removing any undefined or empty objects or arrays.\n   * Values can only be primitives, arrays or tokens. Other objects (i.e. with methods) will be rejected.\n   *\n   * @param obj The object to resolve.\n   * @param options Prefix key path components for diagnostics.\n   */\n  public static resolve(obj: any, options: ResolveOptions): any {\n    return resolve(obj, {\n      scope: options.scope,\n      resolver: options.resolver,\n      preparing: (options.preparing !== undefined ? options.preparing : false)\n    });\n  }\n\n  /**\n   * Return whether the given object is an IResolvable object\n   *\n   * This is different from Token.isUnresolved() which will also check for\n   * encoded Tokens, whereas this method will only do a type check on the given\n   * object.\n   */\n  public static isResolvable(obj: any): obj is IResolvable {\n    return isResolvableObject(obj);\n  }\n\n  /**\n   * Stringify a number directly or lazily if it's a Token. If it is an object (i.e., { Ref: 'SomeLogicalId' }), return it as-is.\n   */\n  public static stringifyNumber(x: number) {\n    // only convert numbers to strings so that Refs, conditions, and other things don't end up synthesizing as [object object]\n\n    if (Token.isUnresolved(x)) {\n      return Lazy.stringValue({ produce: context => {\n          const resolved = context.resolve(x);\n          return typeof resolved !== 'number' ? resolved : `${resolved}`;\n        } });\n    } else {\n      return typeof x !== 'number' ? x : `${x}`;\n    }\n  }\n\n  private constructor() {\n  }\n}\n\n/**\n * Options to the resolve() operation\n *\n * NOT the same as the ResolveContext; ResolveContext is exposed to Token\n * implementors and resolution hooks, whereas this struct is just to bundle\n * a number of things that would otherwise be arguments to resolve() in a\n * readable way.\n */\nexport interface ResolveOptions {\n  /**\n   * The scope from which resolution is performed\n   */\n  readonly scope: IConstruct;\n\n  /**\n   * The resolver to apply to any resolvable tokens found\n   */\n  readonly resolver: ITokenResolver;\n\n  /**\n   * Whether the resolution is being executed during the prepare phase or not.\n   * @default false\n   */\n  readonly preparing?: boolean;\n}\n\n/**\n * Properties to string encodings\n */\nexport interface EncodingOptions {\n  /**\n   * A hint for the Token's purpose when stringifying it\n   */\n  readonly displayHint?: string;\n}\n\nexport function isResolvableObject(x: any): x is IResolvable {\n  return typeof(x) === 'object' && x !== null && typeof x.resolve === 'function';\n}\n\n/**\n * Call the given function only if all given values are resolved\n *\n * Exported as a function since it will be used by TypeScript modules, but\n * can't be exposed via JSII because of the generics.\n */\nexport function withResolved<A>(a: A, fn: (a: A) => void): void;\nexport function withResolved<A, B>(a: A, b: B, fn: (a: A, b: B) => void): void;\nexport function withResolved<A, B, C>(a: A, b: B, c: C, fn: (a: A, b: B, c: C) => void): void;\nexport function withResolved(...args: any[]) {\n  if (args.length < 2) { return; }\n  const argArray = args.slice(0, args.length - 1);\n  if (argArray.some(Token.isUnresolved)) { return; }\n  args[args.length - 1].apply(arguments, argArray);\n}\n"]}

package.json

 {
   "name": "@aws-cdk/core",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "AWS Cloud Development Kit Core Library",
@@ -44,3 +44,78 @@ "main": "lib/index.js",
       "props-no-cfn-types:@aws-cdk/core.CfnRuleProps.assertions",
-      "construct-ctor:@aws-cdk/core.Stack.<initializer>.params[1]"
+      "construct-ctor:@aws-cdk/core.Stack.<initializer>.params[1]",
+      "docs-public-apis:@aws-cdk/core.ScopedAws.urlSuffix",
+      "docs-public-apis:@aws-cdk/core.TagType.NOT_TAGGABLE",
+      "docs-public-apis:@aws-cdk/core.TagType.KEY_VALUE",
+      "docs-public-apis:@aws-cdk/core.TagType.MAP",
+      "docs-public-apis:@aws-cdk/core.TagType.AUTOSCALING_GROUP",
+      "docs-public-apis:@aws-cdk/core.Arn",
+      "docs-public-apis:@aws-cdk/core.Aws.ACCOUNT_ID",
+      "docs-public-apis:@aws-cdk/core.Aws.NO_VALUE",
+      "docs-public-apis:@aws-cdk/core.Aws.NOTIFICATION_ARNS",
+      "docs-public-apis:@aws-cdk/core.Aws.PARTITION",
+      "docs-public-apis:@aws-cdk/core.Aws.REGION",
+      "docs-public-apis:@aws-cdk/core.Aws.STACK_ID",
+      "docs-public-apis:@aws-cdk/core.Aws.STACK_NAME",
+      "docs-public-apis:@aws-cdk/core.Aws.URL_SUFFIX",
+      "docs-public-apis:@aws-cdk/core.ConstructNode.root",
+      "docs-public-apis:@aws-cdk/core.ContextProvider.getKey",
+      "docs-public-apis:@aws-cdk/core.ContextProvider.getValue",
+      "docs-public-apis:@aws-cdk/core.Duration.days",
+      "docs-public-apis:@aws-cdk/core.Duration.hours",
+      "docs-public-apis:@aws-cdk/core.Duration.millis",
+      "docs-public-apis:@aws-cdk/core.Duration.minutes",
+      "docs-public-apis:@aws-cdk/core.Duration.seconds",
+      "docs-public-apis:@aws-cdk/core.Duration.toDays",
+      "docs-public-apis:@aws-cdk/core.Duration.toHours",
+      "docs-public-apis:@aws-cdk/core.Duration.toISOString",
+      "docs-public-apis:@aws-cdk/core.Duration.toMilliseconds",
+      "docs-public-apis:@aws-cdk/core.Duration.toMinutes",
+      "docs-public-apis:@aws-cdk/core.Duration.toSeconds",
+      "docs-public-apis:@aws-cdk/core.Lazy.anyValue",
+      "docs-public-apis:@aws-cdk/core.Lazy.listValue",
+      "docs-public-apis:@aws-cdk/core.Lazy.numberValue",
+      "docs-public-apis:@aws-cdk/core.Lazy.stringValue",
+      "docs-public-apis:@aws-cdk/core.Reference.displayName",
+      "docs-public-apis:@aws-cdk/core.Reference.target",
+      "docs-public-apis:@aws-cdk/core.ScopedAws.accountId",
+      "docs-public-apis:@aws-cdk/core.ScopedAws.notificationArns",
+      "docs-public-apis:@aws-cdk/core.ScopedAws.partition",
+      "docs-public-apis:@aws-cdk/core.ScopedAws.region",
+      "docs-public-apis:@aws-cdk/core.ScopedAws.stackId",
+      "docs-public-apis:@aws-cdk/core.ScopedAws.stackName",
+      "docs-public-apis:@aws-cdk/core.TagType.STANDARD",
+      "docs-public-apis:@aws-cdk/core.Stack.addDockerImageAsset",
+      "docs-public-apis:@aws-cdk/core.Stack.addFileAsset",
+      "docs-public-apis:@aws-cdk/core.TagManager.applyTagAspectHere",
+      "docs-public-apis:@aws-cdk/core.TokenizedStringFragments.firstValue",
+      "docs-public-apis:@aws-cdk/core.TokenizedStringFragments.length",
+      "docs-public-apis:@aws-cdk/core.TokenizedStringFragments.firstToken",
+      "docs-public-apis:@aws-cdk/core.TokenizedStringFragments.addIntrinsic",
+      "docs-public-apis:@aws-cdk/core.TokenizedStringFragments.addLiteral",
+      "docs-public-apis:@aws-cdk/core.TokenizedStringFragments.addToken",
+      "docs-public-apis:@aws-cdk/core.ValidationResult.errorMessage",
+      "docs-public-apis:@aws-cdk/core.ValidationResult.isSuccess",
+      "docs-public-apis:@aws-cdk/core.ValidationResult.results",
+      "docs-public-apis:@aws-cdk/core.ValidationResults.isSuccess",
+      "docs-public-apis:@aws-cdk/core.ValidationResults.results",
+      "docs-public-apis:@aws-cdk/core.ValidationResults.collect",
+      "docs-public-apis:@aws-cdk/core.ValidationResults.errorTreeList",
+      "docs-public-apis:@aws-cdk/core.ArnComponents",
+      "props-default-doc:@aws-cdk/core.ArnComponents.resourceName",
+      "docs-public-apis:@aws-cdk/core.DockerImageAssetSource",
+      "props-default-doc:@aws-cdk/core.EncodingOptions.displayHint",
+      "docs-public-apis:@aws-cdk/core.GetContextKeyOptions",
+      "props-default-doc:@aws-cdk/core.GetContextKeyOptions.props",
+      "docs-public-apis:@aws-cdk/core.GetContextKeyResult",
+      "docs-public-apis:@aws-cdk/core.GetContextKeyResult.key",
+      "docs-public-apis:@aws-cdk/core.GetContextKeyResult.props",
+      "docs-public-apis:@aws-cdk/core.GetContextValueOptions",
+      "docs-public-apis:@aws-cdk/core.GetContextValueResult",
+      "docs-public-apis:@aws-cdk/core.GetContextValueResult.value",
+      "props-default-doc:@aws-cdk/core.GetContextValueResult.value",
+      "docs-public-apis:@aws-cdk/core.ICfnResourceOptions",
+      "docs-public-apis:@aws-cdk/core.RemovalPolicyOptions",
+      "docs-public-apis:@aws-cdk/core.StackProps",
+      "docs-public-apis:@aws-cdk/core.RemovalPolicy",
+      "docs-public-apis:@aws-cdk/core.TagType"
     ]
@@ -57,3 +132,4 @@ },
     "build+test+package": "npm run build+test && npm run package",
-    "build+test": "npm run build && npm test"
+    "build+test": "npm run build && npm test",
+    "compat": "cdk-compat"
   },
@@ -78,15 +154,15 @@ "nyc": {
   "devDependencies": {
-    "@types/lodash": "^4.14.144",
-    "cdk-build-tools": "file:../../../tools/cdk-build-tools",
-    "cfn2ts": "file:../../../tools/cfn2ts",
+    "@types/lodash": "^4.14.146",
+    "cdk-build-tools": "1.16.0",
+    "cfn2ts": "1.16.0",
     "fast-check": "^1.18.1",
     "lodash": "^4.17.15",
-    "pkglint": "file:../../../tools/pkglint"
+    "pkglint": "1.16.0"
   },
   "dependencies": {
-    "@aws-cdk/cx-api": "1.15.0"
+    "@aws-cdk/cx-api": "1.16.0"
   },
   "homepage": "https://github.com/aws/aws-cdk",
   "peerDependencies": {
-    "@aws-cdk/cx-api": "1.15.0"
+    "@aws-cdk/cx-api": "1.16.0"
   },
@@ -97,2 +173,2 @@ "engines": {
   "stability": "stable"
-}
+}

test/private/test.tree-metadata.d.ts

 import { Test } from 'nodeunit';
 declare const _default: {
     'tree metadata is generated as expected'(test: Test): void;
+    'tree metadata for a Cfn resource'(test: Test): void;
 };
 export = _default;

test/private/test.tree-metadata.js

@@ -5,7 +5,2 @@ "use strict";
 const index_1 = require("../../lib/index");
-class MyResource extends index_1.Resource {
-    constructor(scope, id) {
-        super(scope, id);
-    }
-}
 function readJson(outdir, file) {
@@ -18,5 +13,3 @@ return JSON.parse(fs.readFileSync(path.join(outdir, file), 'utf-8'));
         const stack = new index_1.Stack(app, 'mystack');
-        new index_1.Construct(stack, 'group1');
-        const group2 = new index_1.Construct(stack, 'group2');
-        new MyResource(group2, 'resource3');
+        new index_1.Construct(stack, 'myconstruct');
         const assembly = app.synth();
@@ -30,30 +23,87 @@ const treeArtifact = assembly.tree();
                 path: '',
-                children: [
-                    {
+                children: {
+                    Tree: {
                         id: 'Tree',
                         path: 'Tree'
                     },
-                    {
+                    mystack: {
                         id: 'mystack',
                         path: 'mystack',
-                        children: [
-                            {
-                                id: 'group1',
-                                path: 'mystack/group1'
-                            },
-                            {
-                                id: 'group2',
-                                path: 'mystack/group2',
-                                children: [
-                                    { id: 'resource3', path: 'mystack/group2/resource3' }
-                                ]
+                        children: {
+                            myconstruct: {
+                                id: 'myconstruct',
+                                path: 'mystack/myconstruct'
                             }
-                        ]
+                        }
+                    }
+                }
+            }
+        });
+        test.done();
+    },
+    'tree metadata for a Cfn resource'(test) {
+        class MyCfnResource extends index_1.CfnResource {
+            constructor(scope, id) {
+                super(scope, id, {
+                    type: 'CDK::UnitTest::MyCfnResource'
+                });
+            }
+            inspect(inspector) {
+                inspector.addAttribute('aws:cdk:cloudformation:type', 'CDK::UnitTest::MyCfnResource');
+                inspector.addAttribute('aws:cdk:cloudformation:props', this.cfnProperties);
+            }
+            get cfnProperties() {
+                return {
+                    mystringpropkey: 'mystringpropval',
+                    mylistpropkey: ['listitem1'],
+                    mystructpropkey: {
+                        myboolpropkey: true,
+                        mynumpropkey: 50
+                    }
+                };
+            }
+        }
+        const app = new index_1.App();
+        const stack = new index_1.Stack(app, 'mystack');
+        new MyCfnResource(stack, 'mycfnresource');
+        const assembly = app.synth();
+        const treeArtifact = assembly.tree();
+        test.ok(treeArtifact);
+        test.deepEqual(readJson(assembly.directory, treeArtifact.file), {
+            version: 'tree-0.1',
+            tree: {
+                id: 'App',
+                path: '',
+                children: {
+                    Tree: {
+                        id: 'Tree',
+                        path: 'Tree'
                     },
-                ]
+                    mystack: {
+                        id: 'mystack',
+                        path: 'mystack',
+                        children: {
+                            mycfnresource: {
+                                id: 'mycfnresource',
+                                path: 'mystack/mycfnresource',
+                                attributes: {
+                                    'aws:cdk:cloudformation:type': 'CDK::UnitTest::MyCfnResource',
+                                    'aws:cdk:cloudformation:props': {
+                                        mystringpropkey: 'mystringpropval',
+                                        mylistpropkey: ['listitem1'],
+                                        mystructpropkey: {
+                                            myboolpropkey: true,
+                                            mynumpropkey: 50
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
         });
         test.done();
-    },
+    }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

test/test.app.js

@@ -28,3 +28,3 @@ "use strict";
     const response = synth(context);
-    const stack = response.getStack(name);
+    const stack = response.getStackByName(name);
     if (!includeMetadata) {
@@ -48,3 +48,4 @@ delete stack.metadata;
         const stack1 = response.stacks[0];
-        test.deepEqual(stack1.name, 'stack1');
+        test.deepEqual(stack1.stackName, 'stack1');
+        test.deepEqual(stack1.id, 'stack1');
         test.deepEqual(stack1.environment.account, 12345);
@@ -63,3 +64,4 @@ test.deepEqual(stack1.environment.region, 'us-east-1');
         const stack2 = response.stacks[1];
-        test.deepEqual(stack2.name, 'stack2');
+        test.deepEqual(stack2.stackName, 'stack2');
+        test.deepEqual(stack2.id, 'stack2');
         test.deepEqual(stack2.environment.name, 'aws://unknown-account/unknown-region');
@@ -258,3 +260,3 @@ test.deepEqual(stack2.template, { Resources: { s2c1: { Type: 'DummyResource', Properties: { Prog2: 'Prog2' } },
         // THEN
-        test.deepEqual(response.stacks.map(s => ({ name: s.name, template: s.template })), [
+        test.deepEqual(response.stacks.map(s => ({ name: s.stackName, template: s.template })), [
             {
@@ -272,2 +274,2 @@ name: 'Stack',
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.app.js","sourceRoot":"","sources":["test.app.ts"],"names":[],"mappings":"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","sourcesContent":["import cxapi = require('@aws-cdk/cx-api');\nimport { Test } from 'nodeunit';\nimport { CfnResource, Construct, Stack, StackProps } from '../lib';\nimport { App, AppProps } from '../lib/app';\n\nfunction withApp(props: AppProps, block: (app: App) => void): cxapi.CloudAssembly {\n  const app = new App({\n    runtimeInfo: false,\n    stackTraces: false,\n    ...props,\n  });\n\n  block(app);\n\n  return app.synth();\n}\n\nfunction synth(context?: { [key: string]: any }): cxapi.CloudAssembly {\n  return withApp({ context }, app => {\n    const stack1 = new Stack(app, 'stack1', { env: { account: '12345', region: 'us-east-1' } });\n    new CfnResource(stack1, 's1c1', { type: 'DummyResource', properties: { Prop1: 'Prop1' } });\n    const r2 = new CfnResource(stack1, 's1c2', { type: 'DummyResource', properties: { Foo: 123 } });\n\n    const stack2 = new Stack(app, 'stack2');\n    new CfnResource(stack2, 's2c1', { type: 'DummyResource', properties: { Prog2: 'Prog2' } });\n    const c1 = new MyConstruct(stack2, 's1c2');\n\n    // add some metadata\n    stack1.node.addMetadata('meta', 111);\n    r2.node.addWarning('warning1');\n    r2.node.addWarning('warning2');\n    c1.node.addMetadata('meta', { key: 'value' });\n    app.node.addMetadata('applevel', 123); // apps can also have metadata\n  });\n}\n\nfunction synthStack(name: string, includeMetadata: boolean = false, context?: any): cxapi.CloudFormationStackArtifact {\n  const response = synth(context);\n  const stack = response.getStack(name);\n\n  if (!includeMetadata) {\n    delete (stack as any).metadata;\n  }\n\n  return stack;\n}\n\nexport = {\n  'synthesizes all stacks and returns synthesis result'(test: Test) {\n    const response = synth();\n    delete (response as any).dir;\n\n    test.deepEqual(response.stacks.length, 2);\n\n    const stack1 = response.stacks[0];\n    test.deepEqual(stack1.name, 'stack1');\n    test.deepEqual(stack1.environment.account, 12345);\n    test.deepEqual(stack1.environment.region, 'us-east-1');\n    test.deepEqual(stack1.environment.name, 'aws://12345/us-east-1');\n    test.deepEqual(stack1.template, { Resources:\n      { s1c1: { Type: 'DummyResource', Properties: { Prop1: 'Prop1' } },\n        s1c2: { Type: 'DummyResource', Properties: { Foo: 123 } } } });\n    test.deepEqual(stack1.manifest.metadata, {\n      '/stack1': [{ type: 'meta', data: 111 }],\n      '/stack1/s1c1': [{ type: 'aws:cdk:logicalId', data: 's1c1' }],\n      '/stack1/s1c2':\n        [{ type: 'aws:cdk:logicalId', data: 's1c2' },\n        { type: 'aws:cdk:warning', data: 'warning1' },\n        { type: 'aws:cdk:warning', data: 'warning2' }],\n    });\n\n    const stack2 = response.stacks[1];\n    test.deepEqual(stack2.name, 'stack2');\n    test.deepEqual(stack2.environment.name, 'aws://unknown-account/unknown-region');\n    test.deepEqual(stack2.template, { Resources:\n      { s2c1: { Type: 'DummyResource', Properties: { Prog2: 'Prog2' } },\n        s1c2r1D1791C01: { Type: 'ResourceType1' },\n        s1c2r25F685FFF: { Type: 'ResourceType2' } } });\n    test.deepEqual(stack2.manifest.metadata, {\n      '/stack2/s2c1': [{ type: 'aws:cdk:logicalId', data: 's2c1' }],\n      '/stack2/s1c2': [{ type: 'meta', data: { key: 'value' } }],\n      '/stack2/s1c2/r1':\n        [{ type: 'aws:cdk:logicalId', data: 's1c2r1D1791C01' }],\n      '/stack2/s1c2/r2':\n        [{ type: 'aws:cdk:logicalId', data: 's1c2r25F685FFF' }],\n    });\n\n    test.done();\n},\n\n'context can be passed through CDK_CONTEXT'(test: Test) {\n  process.env[cxapi.CONTEXT_ENV] = JSON.stringify({\n    key1: 'val1',\n    key2: 'val2'\n  });\n  const prog = new App();\n  test.deepEqual(prog.node.tryGetContext('key1'), 'val1');\n  test.deepEqual(prog.node.tryGetContext('key2'), 'val2');\n  test.done();\n},\n\n'context passed through CDK_CONTEXT has precedence'(test: Test) {\n  process.env[cxapi.CONTEXT_ENV] = JSON.stringify({\n    key1: 'val1',\n    key2: 'val2'\n  });\n  const prog = new App({\n    context: {\n      key1: 'val3',\n      key2: 'val4'\n    }\n  });\n  test.deepEqual(prog.node.tryGetContext('key1'), 'val1');\n  test.deepEqual(prog.node.tryGetContext('key2'), 'val2');\n  test.done();\n},\n\n'context from the command line can be used when creating the stack'(test: Test) {\n  const output = synthStack('stack2', false, { ctx1: 'HELLO' });\n\n  test.deepEqual(output.template, {\n    Resources: {\n      s2c1: {\n        Type: \"DummyResource\",\n        Properties: {\n          Prog2: \"Prog2\"\n        }\n      },\n      s1c2r1D1791C01: {\n        Type: \"ResourceType1\"\n      },\n      s1c2r25F685FFF: {\n        Type: \"ResourceType2\",\n        Properties: {\n          FromContext: \"HELLO\"\n        }\n      }\n    }\n  });\n  test.done();\n},\n\n'setContext(k,v) can be used to set context programmatically'(test: Test) {\n  const prog = new App({\n    context: {\n      foo: 'bar'\n    }\n  });\n  test.deepEqual(prog.node.tryGetContext('foo'), 'bar');\n  test.done();\n},\n\n'setContext(k,v) cannot be called after stacks have been added because stacks may use the context'(test: Test) {\n  const prog = new App();\n  new Stack(prog, 's1');\n  test.throws(() => prog.node.setContext('foo', 'bar'));\n  test.done();\n},\n\n'app.synth() performs validation first and if there are errors, it returns the errors'(test: Test) {\n\n  class Child extends Construct {\n    protected validate() {\n      return [`Error from ${this.node.id}`];\n    }\n  }\n\n  class Parent extends Stack {\n\n  }\n\n  const app = new App();\n\n  const parent = new Parent(app, 'Parent');\n  new Child(parent, 'C1');\n  new Child(parent, 'C2');\n\n  test.throws(() => app.synth(), /Validation failed with the following errors/);\n\n  test.done();\n},\n\n'app.synthesizeStack(stack) will return a list of missing contextual information'(test: Test) {\n  class MyStack extends Stack {\n    constructor(scope: App, id: string, props?: StackProps) {\n      super(scope, id, props);\n\n      this.reportMissingContext({\n        key: 'missing-context-key',\n        provider: 'fake',\n        props: {\n          account: '12345689012',\n          region: 'ab-north-1',\n        },\n      },\n      );\n\n      this.reportMissingContext({\n        key: 'missing-context-key-2',\n        provider: 'fake2',\n        props: {\n          foo: 'bar',\n          account: '12345689012',\n          region: 'ab-south-1',\n        },\n      },\n      );\n    }\n  }\n\n  const assembly = withApp({}, app => {\n    new MyStack(app, 'MyStack');\n  });\n\n  test.deepEqual(assembly.manifest.missing, [\n    {\n      key: \"missing-context-key\",\n      provider: 'fake',\n      props: {\n        account: '12345689012',\n        region: 'ab-north-1',\n      },\n    },\n    {\n      key: \"missing-context-key-2\",\n      provider: 'fake2',\n      props: {\n        account: '12345689012',\n        region: 'ab-south-1',\n        foo: 'bar',\n      },\n    }\n  ]);\n\n  test.done();\n},\n\n'runtime library versions disabled'(test: Test) {\n  const context: any = {};\n  context[cxapi.DISABLE_VERSION_REPORTING] = true;\n\n  const assembly = withApp(context, app => {\n    const stack = new Stack(app, 'stack1');\n    new CfnResource(stack, 'MyResource', { type: 'Resource::Type' });\n  });\n\n  test.deepEqual(assembly.runtime, { libraries: {} });\n  test.done();\n},\n\n'runtime library versions'(test: Test) {\n  const response = withApp({ runtimeInfo: true }, app => {\n    const stack = new Stack(app, 'stack1');\n    new CfnResource(stack, 'MyResource', { type: 'Resource::Type' });\n  });\n\n  const libs = (response.runtime && response.runtime.libraries) || {};\n\n  const version = require('../package.json').version;\n  test.deepEqual(libs['@aws-cdk/core'], version);\n  test.deepEqual(libs['@aws-cdk/cx-api'], version);\n  test.deepEqual(libs['jsii-runtime'], `node.js/${process.version}`);\n  test.done();\n},\n\n'jsii-runtime version loaded from JSII_AGENT'(test: Test) {\n  process.env.JSII_AGENT = 'Java/1.2.3.4';\n\n  const response = withApp({ runtimeInfo: true }, app => {\n    const stack = new Stack(app, 'stack1');\n    new CfnResource(stack, 'MyResource', { type: 'Resource::Type' });\n  });\n\n  const libs = (response.runtime && response.runtime.libraries) || {};\n  test.deepEqual(libs['jsii-runtime'], `Java/1.2.3.4`);\n\n  delete process.env.JSII_AGENT;\n  test.done();\n},\n\n'version reporting includes only @aws-cdk, aws-cdk and jsii libraries'(test: Test) {\n  const response = withApp({ runtimeInfo: true }, app => {\n    const stack = new Stack(app, 'stack1');\n    new CfnResource(stack, 'MyResource', { type: 'Resource::Type' });\n  });\n\n  const libs = (response.runtime && response.runtime.libraries) || {};\n\n  const version = require('../package.json').version;\n  test.deepEqual(libs, {\n    '@aws-cdk/core': version,\n    '@aws-cdk/cx-api': version,\n    'jsii-runtime': `node.js/${process.version}`\n  });\n\n  test.done();\n},\n\n'deep stack is shown and synthesized properly'(test: Test) {\n  // WHEN\n  const response = withApp({}, (app) => {\n    const topStack = new Stack(app, 'Stack');\n    const topResource = new CfnResource(topStack, 'Res', { type: 'CDK::TopStack::Resource' });\n\n    const bottomStack = new Stack(topResource, 'Stack');\n    new CfnResource(bottomStack, 'Res', { type: 'CDK::BottomStack::Resource' });\n  });\n\n  // THEN\n  test.deepEqual(response.stacks.map(s => ({ name: s.name, template: s.template })), [\n    {\n      name: 'Stack',\n      template: { Resources: { Res: { Type: 'CDK::TopStack::Resource' } } },\n    },\n    {\n      name: 'StackResStack7E4AFA86',\n      template: { Resources: { Res: { Type: 'CDK::BottomStack::Resource' } } },\n    },\n  ]);\n\n  test.done();\n},\n};\n\nclass MyConstruct extends Construct {\n  constructor(scope: Construct, id: string) {\n    super(scope, id);\n\n    new CfnResource(this, 'r1', { type: 'ResourceType1' });\n    new CfnResource(this, 'r2', { type: 'ResourceType2', properties: { FromContext: this.node.tryGetContext('ctx1') } });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.app.js","sourceRoot":"","sources":["test.app.ts"],"names":[],"mappings":"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","sourcesContent":["import cxapi = require('@aws-cdk/cx-api');\nimport { Test } from 'nodeunit';\nimport { CfnResource, Construct, Stack, StackProps } from '../lib';\nimport { App, AppProps } from '../lib/app';\n\nfunction withApp(props: AppProps, block: (app: App) => void): cxapi.CloudAssembly {\n  const app = new App({\n    runtimeInfo: false,\n    stackTraces: false,\n    ...props,\n  });\n\n  block(app);\n\n  return app.synth();\n}\n\nfunction synth(context?: { [key: string]: any }): cxapi.CloudAssembly {\n  return withApp({ context }, app => {\n    const stack1 = new Stack(app, 'stack1', { env: { account: '12345', region: 'us-east-1' } });\n    new CfnResource(stack1, 's1c1', { type: 'DummyResource', properties: { Prop1: 'Prop1' } });\n    const r2 = new CfnResource(stack1, 's1c2', { type: 'DummyResource', properties: { Foo: 123 } });\n\n    const stack2 = new Stack(app, 'stack2');\n    new CfnResource(stack2, 's2c1', { type: 'DummyResource', properties: { Prog2: 'Prog2' } });\n    const c1 = new MyConstruct(stack2, 's1c2');\n\n    // add some metadata\n    stack1.node.addMetadata('meta', 111);\n    r2.node.addWarning('warning1');\n    r2.node.addWarning('warning2');\n    c1.node.addMetadata('meta', { key: 'value' });\n    app.node.addMetadata('applevel', 123); // apps can also have metadata\n  });\n}\n\nfunction synthStack(name: string, includeMetadata: boolean = false, context?: any): cxapi.CloudFormationStackArtifact {\n  const response = synth(context);\n  const stack = response.getStackByName(name);\n\n  if (!includeMetadata) {\n    delete (stack as any).metadata;\n  }\n\n  return stack;\n}\n\nexport = {\n  'synthesizes all stacks and returns synthesis result'(test: Test) {\n    const response = synth();\n    delete (response as any).dir;\n\n    test.deepEqual(response.stacks.length, 2);\n\n    const stack1 = response.stacks[0];\n    test.deepEqual(stack1.stackName, 'stack1');\n    test.deepEqual(stack1.id, 'stack1');\n    test.deepEqual(stack1.environment.account, 12345);\n    test.deepEqual(stack1.environment.region, 'us-east-1');\n    test.deepEqual(stack1.environment.name, 'aws://12345/us-east-1');\n    test.deepEqual(stack1.template, { Resources:\n      { s1c1: { Type: 'DummyResource', Properties: { Prop1: 'Prop1' } },\n        s1c2: { Type: 'DummyResource', Properties: { Foo: 123 } } } });\n    test.deepEqual(stack1.manifest.metadata, {\n      '/stack1': [{ type: 'meta', data: 111 }],\n      '/stack1/s1c1': [{ type: 'aws:cdk:logicalId', data: 's1c1' }],\n      '/stack1/s1c2':\n        [{ type: 'aws:cdk:logicalId', data: 's1c2' },\n        { type: 'aws:cdk:warning', data: 'warning1' },\n        { type: 'aws:cdk:warning', data: 'warning2' }],\n    });\n\n    const stack2 = response.stacks[1];\n    test.deepEqual(stack2.stackName, 'stack2');\n    test.deepEqual(stack2.id, 'stack2');\n    test.deepEqual(stack2.environment.name, 'aws://unknown-account/unknown-region');\n    test.deepEqual(stack2.template, { Resources:\n      { s2c1: { Type: 'DummyResource', Properties: { Prog2: 'Prog2' } },\n        s1c2r1D1791C01: { Type: 'ResourceType1' },\n        s1c2r25F685FFF: { Type: 'ResourceType2' } } });\n    test.deepEqual(stack2.manifest.metadata, {\n      '/stack2/s2c1': [{ type: 'aws:cdk:logicalId', data: 's2c1' }],\n      '/stack2/s1c2': [{ type: 'meta', data: { key: 'value' } }],\n      '/stack2/s1c2/r1':\n        [{ type: 'aws:cdk:logicalId', data: 's1c2r1D1791C01' }],\n      '/stack2/s1c2/r2':\n        [{ type: 'aws:cdk:logicalId', data: 's1c2r25F685FFF' }],\n    });\n\n    test.done();\n},\n\n'context can be passed through CDK_CONTEXT'(test: Test) {\n  process.env[cxapi.CONTEXT_ENV] = JSON.stringify({\n    key1: 'val1',\n    key2: 'val2'\n  });\n  const prog = new App();\n  test.deepEqual(prog.node.tryGetContext('key1'), 'val1');\n  test.deepEqual(prog.node.tryGetContext('key2'), 'val2');\n  test.done();\n},\n\n'context passed through CDK_CONTEXT has precedence'(test: Test) {\n  process.env[cxapi.CONTEXT_ENV] = JSON.stringify({\n    key1: 'val1',\n    key2: 'val2'\n  });\n  const prog = new App({\n    context: {\n      key1: 'val3',\n      key2: 'val4'\n    }\n  });\n  test.deepEqual(prog.node.tryGetContext('key1'), 'val1');\n  test.deepEqual(prog.node.tryGetContext('key2'), 'val2');\n  test.done();\n},\n\n'context from the command line can be used when creating the stack'(test: Test) {\n  const output = synthStack('stack2', false, { ctx1: 'HELLO' });\n\n  test.deepEqual(output.template, {\n    Resources: {\n      s2c1: {\n        Type: \"DummyResource\",\n        Properties: {\n          Prog2: \"Prog2\"\n        }\n      },\n      s1c2r1D1791C01: {\n        Type: \"ResourceType1\"\n      },\n      s1c2r25F685FFF: {\n        Type: \"ResourceType2\",\n        Properties: {\n          FromContext: \"HELLO\"\n        }\n      }\n    }\n  });\n  test.done();\n},\n\n'setContext(k,v) can be used to set context programmatically'(test: Test) {\n  const prog = new App({\n    context: {\n      foo: 'bar'\n    }\n  });\n  test.deepEqual(prog.node.tryGetContext('foo'), 'bar');\n  test.done();\n},\n\n'setContext(k,v) cannot be called after stacks have been added because stacks may use the context'(test: Test) {\n  const prog = new App();\n  new Stack(prog, 's1');\n  test.throws(() => prog.node.setContext('foo', 'bar'));\n  test.done();\n},\n\n'app.synth() performs validation first and if there are errors, it returns the errors'(test: Test) {\n\n  class Child extends Construct {\n    protected validate() {\n      return [`Error from ${this.node.id}`];\n    }\n  }\n\n  class Parent extends Stack {\n\n  }\n\n  const app = new App();\n\n  const parent = new Parent(app, 'Parent');\n  new Child(parent, 'C1');\n  new Child(parent, 'C2');\n\n  test.throws(() => app.synth(), /Validation failed with the following errors/);\n\n  test.done();\n},\n\n'app.synthesizeStack(stack) will return a list of missing contextual information'(test: Test) {\n  class MyStack extends Stack {\n    constructor(scope: App, id: string, props?: StackProps) {\n      super(scope, id, props);\n\n      this.reportMissingContext({\n        key: 'missing-context-key',\n        provider: 'fake',\n        props: {\n          account: '12345689012',\n          region: 'ab-north-1',\n        },\n      },\n      );\n\n      this.reportMissingContext({\n        key: 'missing-context-key-2',\n        provider: 'fake2',\n        props: {\n          foo: 'bar',\n          account: '12345689012',\n          region: 'ab-south-1',\n        },\n      },\n      );\n    }\n  }\n\n  const assembly = withApp({}, app => {\n    new MyStack(app, 'MyStack');\n  });\n\n  test.deepEqual(assembly.manifest.missing, [\n    {\n      key: \"missing-context-key\",\n      provider: 'fake',\n      props: {\n        account: '12345689012',\n        region: 'ab-north-1',\n      },\n    },\n    {\n      key: \"missing-context-key-2\",\n      provider: 'fake2',\n      props: {\n        account: '12345689012',\n        region: 'ab-south-1',\n        foo: 'bar',\n      },\n    }\n  ]);\n\n  test.done();\n},\n\n'runtime library versions disabled'(test: Test) {\n  const context: any = {};\n  context[cxapi.DISABLE_VERSION_REPORTING] = true;\n\n  const assembly = withApp(context, app => {\n    const stack = new Stack(app, 'stack1');\n    new CfnResource(stack, 'MyResource', { type: 'Resource::Type' });\n  });\n\n  test.deepEqual(assembly.runtime, { libraries: {} });\n  test.done();\n},\n\n'runtime library versions'(test: Test) {\n  const response = withApp({ runtimeInfo: true }, app => {\n    const stack = new Stack(app, 'stack1');\n    new CfnResource(stack, 'MyResource', { type: 'Resource::Type' });\n  });\n\n  const libs = (response.runtime && response.runtime.libraries) || {};\n\n  const version = require('../package.json').version;\n  test.deepEqual(libs['@aws-cdk/core'], version);\n  test.deepEqual(libs['@aws-cdk/cx-api'], version);\n  test.deepEqual(libs['jsii-runtime'], `node.js/${process.version}`);\n  test.done();\n},\n\n'jsii-runtime version loaded from JSII_AGENT'(test: Test) {\n  process.env.JSII_AGENT = 'Java/1.2.3.4';\n\n  const response = withApp({ runtimeInfo: true }, app => {\n    const stack = new Stack(app, 'stack1');\n    new CfnResource(stack, 'MyResource', { type: 'Resource::Type' });\n  });\n\n  const libs = (response.runtime && response.runtime.libraries) || {};\n  test.deepEqual(libs['jsii-runtime'], `Java/1.2.3.4`);\n\n  delete process.env.JSII_AGENT;\n  test.done();\n},\n\n'version reporting includes only @aws-cdk, aws-cdk and jsii libraries'(test: Test) {\n  const response = withApp({ runtimeInfo: true }, app => {\n    const stack = new Stack(app, 'stack1');\n    new CfnResource(stack, 'MyResource', { type: 'Resource::Type' });\n  });\n\n  const libs = (response.runtime && response.runtime.libraries) || {};\n\n  const version = require('../package.json').version;\n  test.deepEqual(libs, {\n    '@aws-cdk/core': version,\n    '@aws-cdk/cx-api': version,\n    'jsii-runtime': `node.js/${process.version}`\n  });\n\n  test.done();\n},\n\n'deep stack is shown and synthesized properly'(test: Test) {\n  // WHEN\n  const response = withApp({}, (app) => {\n    const topStack = new Stack(app, 'Stack');\n    const topResource = new CfnResource(topStack, 'Res', { type: 'CDK::TopStack::Resource' });\n\n    const bottomStack = new Stack(topResource, 'Stack');\n    new CfnResource(bottomStack, 'Res', { type: 'CDK::BottomStack::Resource' });\n  });\n\n  // THEN\n  test.deepEqual(response.stacks.map(s => ({ name: s.stackName, template: s.template })), [\n    {\n      name: 'Stack',\n      template: { Resources: { Res: { Type: 'CDK::TopStack::Resource' } } },\n    },\n    {\n      name: 'StackResStack7E4AFA86',\n      template: { Resources: { Res: { Type: 'CDK::BottomStack::Resource' } } },\n    },\n  ]);\n\n  test.done();\n},\n};\n\nclass MyConstruct extends Construct {\n  constructor(scope: Construct, id: string) {\n    super(scope, id);\n\n    new CfnResource(this, 'r1', { type: 'ResourceType1' });\n    new CfnResource(this, 'r2', { type: 'ResourceType2', properties: { FromContext: this.node.tryGetContext('ctx1') } });\n  }\n}\n"]}

test/test.cfn-resource.js

@@ -15,3 +15,3 @@ "use strict";
             };
-            test.deepEqual(app.synth().getStack(stack.stackName).template, {
+            test.deepEqual(app.synth().getStackByName(stack.stackName).template, {
                 Resources: {
@@ -35,3 +35,3 @@ DefaultResource: {
         // THEN
-        test.deepEqual(app.synth().getStack(stack.stackName).template, {
+        test.deepEqual(app.synth().getStackByName(stack.stackName).template, {
             Resources: {
@@ -57,3 +57,3 @@ DefaultResource: {
         // THEN
-        test.deepEqual(app.synth().getStack(stack.stackName).template, {
+        test.deepEqual(app.synth().getStackByName(stack.stackName).template, {
             Resources: {
@@ -69,2 +69,2 @@ DefaultResource: {
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

test/test.cloudformation-json.js

@@ -175,3 +175,3 @@ "use strict";
         const asm = app.synth();
-        test.deepEqual(asm.getStack('Stack2').template, {
+        test.deepEqual(asm.getStackByName('Stack2').template, {
             Outputs: {
@@ -194,2 +194,2 @@ Stack1Id: {
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.cloudformation-json.js","sourceRoot":"","sources":["test.cloudformation-json.ts"],"names":[],"mappings":"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","sourcesContent":["import { Test } from 'nodeunit';\nimport { App, CfnOutput, Fn, Lazy, Stack, Token } from '../lib';\nimport { Intrinsic } from '../lib/private/intrinsic';\nimport { evaluateCFN } from './evaluate-cfn';\n\nexport = {\n  'string tokens can be JSONified and JSONification can be reversed'(test: Test) {\n    const stack = new Stack();\n\n    for (const token of tokensThatResolveTo('woof woof')) {\n      // GIVEN\n      const fido = { name: 'Fido', speaks: token };\n\n      // WHEN\n      const resolved = stack.resolve(stack.toJsonString(fido));\n\n      // THEN\n      test.deepEqual(evaluateCFN(resolved), '{\"name\":\"Fido\",\"speaks\":\"woof woof\"}');\n    }\n\n    test.done();\n  },\n\n  'string tokens can be embedded while being JSONified'(test: Test) {\n    const stack = new Stack();\n\n    for (const token of tokensThatResolveTo('woof woof')) {\n      // GIVEN\n      const fido = { name: 'Fido', speaks: `deep ${token}` };\n\n      // WHEN\n      const resolved = stack.resolve(stack.toJsonString(fido));\n\n      // THEN\n      test.deepEqual(evaluateCFN(resolved), '{\"name\":\"Fido\",\"speaks\":\"deep woof woof\"}');\n    }\n\n    test.done();\n  },\n\n  'constant string has correct amount of quotes applied'(test: Test) {\n    const stack = new Stack();\n\n    const inputString = 'Hello, \"world\"';\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString(inputString));\n\n    // THEN\n    test.deepEqual(evaluateCFN(resolved), JSON.stringify(inputString));\n\n    test.done();\n  },\n\n  'integer Tokens behave correctly in stringification and JSONification'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const num = new Intrinsic(1);\n    const embedded = `the number is ${num}`;\n\n    // WHEN\n    test.equal(evaluateCFN(stack.resolve(embedded)), \"the number is 1\");\n    test.equal(evaluateCFN(stack.resolve(stack.toJsonString({ embedded }))), \"{\\\"embedded\\\":\\\"the number is 1\\\"}\");\n    test.equal(evaluateCFN(stack.resolve(stack.toJsonString({ num }))), \"{\\\"num\\\":1}\");\n\n    test.done();\n  },\n\n  'tokens in strings survive additional TokenJSON.stringification()'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    for (const token of tokensThatResolveTo('pong!')) {\n      // WHEN\n      const stringified = stack.toJsonString(`ping? ${token}`);\n\n      // THEN\n      test.equal(evaluateCFN(stack.resolve(stringified)), '\"ping? pong!\"');\n    }\n\n    test.done();\n  },\n\n  'intrinsic Tokens embed correctly in JSONification'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const bucketName = new Intrinsic({ Ref: 'MyBucket' });\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({ theBucket: bucketName }));\n\n    // THEN\n    const context = {MyBucket: 'TheName'};\n    test.equal(evaluateCFN(resolved, context), '{\"theBucket\":\"TheName\"}');\n\n    test.done();\n  },\n\n  'fake intrinsics are serialized to objects'(test: Test) {\n    const stack = new Stack();\n    const fakeIntrinsics = new Intrinsic({\n      a: {\n        'Fn::GetArtifactAtt': {\n          key: 'val',\n        },\n      },\n      b: {\n        'Fn::GetParam': [\n          'val1',\n          'val2',\n        ],\n      },\n    });\n\n    const stringified = stack.toJsonString(fakeIntrinsics);\n    test.equal(evaluateCFN(stack.resolve(stringified)),\n        '{\"a\":{\"Fn::GetArtifactAtt\":{\"key\":\"val\"}},\"b\":{\"Fn::GetParam\":[\"val1\",\"val2\"]}}');\n\n    test.done();\n  },\n\n  'embedded string literals in intrinsics are escaped when calling TokenJSON.stringify()'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const token = Fn.join('', [ 'Hello', 'This\\nIs', 'Very \"cool\"' ]);\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({\n      literal: 'I can also \"contain\" quotes',\n      token\n    }));\n\n    // THEN\n    const expected = '{\"literal\":\"I can also \\\\\"contain\\\\\" quotes\",\"token\":\"HelloThis\\\\nIsVery \\\\\"cool\\\\\"\"}';\n    test.equal(evaluateCFN(resolved), expected);\n\n    test.done();\n  },\n\n  'Tokens in Tokens are handled correctly'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const bucketName = new Intrinsic({ Ref: 'MyBucket' });\n    const combinedName = Fn.join('', [ 'The bucket name is ', bucketName.toString() ]);\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({ theBucket: combinedName }));\n\n    // THEN\n    const context = {MyBucket: 'TheName'};\n    test.equal(evaluateCFN(resolved, context), '{\"theBucket\":\"The bucket name is TheName\"}');\n\n    test.done();\n  },\n\n  'Doubly nested strings evaluate correctly in JSON context'(test: Test) {\n    // WHEN\n    const stack = new Stack();\n    const fidoSays = Lazy.stringValue({ produce: () => 'woof' });\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({\n      information: `Did you know that Fido says: ${fidoSays}`\n    }));\n\n    // THEN\n    test.deepEqual(evaluateCFN(resolved), '{\"information\":\"Did you know that Fido says: woof\"}');\n\n    test.done();\n  },\n\n  'Doubly nested intrinsics evaluate correctly in JSON context'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const fidoSays = Lazy.anyValue({ produce: () => ({ Ref: 'Something' }) });\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({\n      information: `Did you know that Fido says: ${fidoSays}`\n    }));\n\n    // THEN\n    const context = {Something: 'woof woof'};\n    test.deepEqual(evaluateCFN(resolved, context), '{\"information\":\"Did you know that Fido says: woof woof\"}');\n\n    test.done();\n  },\n\n  'Quoted strings in embedded JSON context are escaped'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const fidoSays = Lazy.stringValue({ produce: () => '\"woof\"' });\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({\n      information: `Did you know that Fido says: ${fidoSays}`\n    }));\n\n    // THEN\n    test.deepEqual(evaluateCFN(resolved), '{\"information\":\"Did you know that Fido says: \\\\\"woof\\\\\"\"}');\n\n    test.done();\n  },\n\n  'cross-stack references are also properly converted by toJsonString()'(test: Test) {\n    // GIVEN\n    const app = new App();\n    const stack1 = new Stack(app, 'Stack1');\n    const stack2 = new Stack(app, 'Stack2');\n\n    // WHEN\n    new CfnOutput(stack2, 'Stack1Id', { value: stack2.toJsonString({\n      Stack1Id: stack1.stackId,\n      Stack2Id: stack2.stackId,\n    })});\n\n    // THEN\n    const asm = app.synth();\n    test.deepEqual(asm.getStack('Stack2').template, {\n      Outputs: {\n        Stack1Id: {\n          Value: {\n            'Fn::Join': [ '', [\n              '{\"Stack1Id\":\"',\n              { 'Fn::ImportValue': 'Stack1:ExportsOutputRefAWSStackIdB2DD5BAA' },\n              '\",\"Stack2Id\":\"',\n              { Ref: 'AWS::StackId' },\n              '\"}'\n            ] ]\n          }\n        }\n      }\n    });\n\n    test.done();\n  },\n};\n\n/**\n * Return two Tokens, one of which evaluates to a Token directly, one which evaluates to it lazily\n */\nfunction tokensThatResolveTo(value: any): Token[] {\n  return [\n    new Intrinsic(value),\n    Lazy.anyValue({ produce: () => value })\n  ];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.cloudformation-json.js","sourceRoot":"","sources":["test.cloudformation-json.ts"],"names":[],"mappings":"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","sourcesContent":["import { Test } from 'nodeunit';\nimport { App, CfnOutput, Fn, Lazy, Stack, Token } from '../lib';\nimport { Intrinsic } from '../lib/private/intrinsic';\nimport { evaluateCFN } from './evaluate-cfn';\n\nexport = {\n  'string tokens can be JSONified and JSONification can be reversed'(test: Test) {\n    const stack = new Stack();\n\n    for (const token of tokensThatResolveTo('woof woof')) {\n      // GIVEN\n      const fido = { name: 'Fido', speaks: token };\n\n      // WHEN\n      const resolved = stack.resolve(stack.toJsonString(fido));\n\n      // THEN\n      test.deepEqual(evaluateCFN(resolved), '{\"name\":\"Fido\",\"speaks\":\"woof woof\"}');\n    }\n\n    test.done();\n  },\n\n  'string tokens can be embedded while being JSONified'(test: Test) {\n    const stack = new Stack();\n\n    for (const token of tokensThatResolveTo('woof woof')) {\n      // GIVEN\n      const fido = { name: 'Fido', speaks: `deep ${token}` };\n\n      // WHEN\n      const resolved = stack.resolve(stack.toJsonString(fido));\n\n      // THEN\n      test.deepEqual(evaluateCFN(resolved), '{\"name\":\"Fido\",\"speaks\":\"deep woof woof\"}');\n    }\n\n    test.done();\n  },\n\n  'constant string has correct amount of quotes applied'(test: Test) {\n    const stack = new Stack();\n\n    const inputString = 'Hello, \"world\"';\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString(inputString));\n\n    // THEN\n    test.deepEqual(evaluateCFN(resolved), JSON.stringify(inputString));\n\n    test.done();\n  },\n\n  'integer Tokens behave correctly in stringification and JSONification'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const num = new Intrinsic(1);\n    const embedded = `the number is ${num}`;\n\n    // WHEN\n    test.equal(evaluateCFN(stack.resolve(embedded)), \"the number is 1\");\n    test.equal(evaluateCFN(stack.resolve(stack.toJsonString({ embedded }))), \"{\\\"embedded\\\":\\\"the number is 1\\\"}\");\n    test.equal(evaluateCFN(stack.resolve(stack.toJsonString({ num }))), \"{\\\"num\\\":1}\");\n\n    test.done();\n  },\n\n  'tokens in strings survive additional TokenJSON.stringification()'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    for (const token of tokensThatResolveTo('pong!')) {\n      // WHEN\n      const stringified = stack.toJsonString(`ping? ${token}`);\n\n      // THEN\n      test.equal(evaluateCFN(stack.resolve(stringified)), '\"ping? pong!\"');\n    }\n\n    test.done();\n  },\n\n  'intrinsic Tokens embed correctly in JSONification'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const bucketName = new Intrinsic({ Ref: 'MyBucket' });\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({ theBucket: bucketName }));\n\n    // THEN\n    const context = {MyBucket: 'TheName'};\n    test.equal(evaluateCFN(resolved, context), '{\"theBucket\":\"TheName\"}');\n\n    test.done();\n  },\n\n  'fake intrinsics are serialized to objects'(test: Test) {\n    const stack = new Stack();\n    const fakeIntrinsics = new Intrinsic({\n      a: {\n        'Fn::GetArtifactAtt': {\n          key: 'val',\n        },\n      },\n      b: {\n        'Fn::GetParam': [\n          'val1',\n          'val2',\n        ],\n      },\n    });\n\n    const stringified = stack.toJsonString(fakeIntrinsics);\n    test.equal(evaluateCFN(stack.resolve(stringified)),\n        '{\"a\":{\"Fn::GetArtifactAtt\":{\"key\":\"val\"}},\"b\":{\"Fn::GetParam\":[\"val1\",\"val2\"]}}');\n\n    test.done();\n  },\n\n  'embedded string literals in intrinsics are escaped when calling TokenJSON.stringify()'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const token = Fn.join('', [ 'Hello', 'This\\nIs', 'Very \"cool\"' ]);\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({\n      literal: 'I can also \"contain\" quotes',\n      token\n    }));\n\n    // THEN\n    const expected = '{\"literal\":\"I can also \\\\\"contain\\\\\" quotes\",\"token\":\"HelloThis\\\\nIsVery \\\\\"cool\\\\\"\"}';\n    test.equal(evaluateCFN(resolved), expected);\n\n    test.done();\n  },\n\n  'Tokens in Tokens are handled correctly'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const bucketName = new Intrinsic({ Ref: 'MyBucket' });\n    const combinedName = Fn.join('', [ 'The bucket name is ', bucketName.toString() ]);\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({ theBucket: combinedName }));\n\n    // THEN\n    const context = {MyBucket: 'TheName'};\n    test.equal(evaluateCFN(resolved, context), '{\"theBucket\":\"The bucket name is TheName\"}');\n\n    test.done();\n  },\n\n  'Doubly nested strings evaluate correctly in JSON context'(test: Test) {\n    // WHEN\n    const stack = new Stack();\n    const fidoSays = Lazy.stringValue({ produce: () => 'woof' });\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({\n      information: `Did you know that Fido says: ${fidoSays}`\n    }));\n\n    // THEN\n    test.deepEqual(evaluateCFN(resolved), '{\"information\":\"Did you know that Fido says: woof\"}');\n\n    test.done();\n  },\n\n  'Doubly nested intrinsics evaluate correctly in JSON context'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const fidoSays = Lazy.anyValue({ produce: () => ({ Ref: 'Something' }) });\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({\n      information: `Did you know that Fido says: ${fidoSays}`\n    }));\n\n    // THEN\n    const context = {Something: 'woof woof'};\n    test.deepEqual(evaluateCFN(resolved, context), '{\"information\":\"Did you know that Fido says: woof woof\"}');\n\n    test.done();\n  },\n\n  'Quoted strings in embedded JSON context are escaped'(test: Test) {\n    // GIVEN\n    const stack = new Stack();\n    const fidoSays = Lazy.stringValue({ produce: () => '\"woof\"' });\n\n    // WHEN\n    const resolved = stack.resolve(stack.toJsonString({\n      information: `Did you know that Fido says: ${fidoSays}`\n    }));\n\n    // THEN\n    test.deepEqual(evaluateCFN(resolved), '{\"information\":\"Did you know that Fido says: \\\\\"woof\\\\\"\"}');\n\n    test.done();\n  },\n\n  'cross-stack references are also properly converted by toJsonString()'(test: Test) {\n    // GIVEN\n    const app = new App();\n    const stack1 = new Stack(app, 'Stack1');\n    const stack2 = new Stack(app, 'Stack2');\n\n    // WHEN\n    new CfnOutput(stack2, 'Stack1Id', { value: stack2.toJsonString({\n      Stack1Id: stack1.stackId,\n      Stack2Id: stack2.stackId,\n    })});\n\n    // THEN\n    const asm = app.synth();\n    test.deepEqual(asm.getStackByName('Stack2').template, {\n      Outputs: {\n        Stack1Id: {\n          Value: {\n            'Fn::Join': [ '', [\n              '{\"Stack1Id\":\"',\n              { 'Fn::ImportValue': 'Stack1:ExportsOutputRefAWSStackIdB2DD5BAA' },\n              '\",\"Stack2Id\":\"',\n              { Ref: 'AWS::StackId' },\n              '\"}'\n            ] ]\n          }\n        }\n      }\n    });\n\n    test.done();\n  },\n};\n\n/**\n * Return two Tokens, one of which evaluates to a Token directly, one which evaluates to it lazily\n */\nfunction tokensThatResolveTo(value: any): Token[] {\n  return [\n    new Intrinsic(value),\n    Lazy.anyValue({ produce: () => value })\n  ];\n}\n"]}

test/test.context.d.ts

@@ -8,4 +8,5 @@ import { Test } from 'nodeunit';
     'Key generation can contain arbitrarily deep structures'(test: Test): void;
+    'Keys with undefined values are not serialized'(test: Test): void;
     'context provider errors are attached to tree'(test: Test): void;
 };
 export = _default;

test/test.context.js

@@ -105,2 +105,25 @@ "use strict";
     },
+    'Keys with undefined values are not serialized'(test) {
+        // GIVEN
+        const stack = new lib_1.Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });
+        // WHEN
+        const result = context_provider_1.ContextProvider.getKey(stack, {
+            provider: 'provider',
+            props: {
+                p1: 42,
+                p2: undefined,
+            },
+        });
+        // THEN
+        test.deepEqual(result, {
+            key: 'provider:account=12345:p1=42:region=us-east-1',
+            props: {
+                account: '12345',
+                region: 'us-east-1',
+                p1: 42,
+                p2: undefined,
+            },
+        });
+        test.done();
+    },
     'context provider errors are attached to tree'(test) {
@@ -125,2 +148,2 @@ const contextProps = { provider: 'bloop' };
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.context.js","sourceRoot":"","sources":["test.context.ts"],"names":[],"mappings":"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","sourcesContent":["import { Test } from 'nodeunit';\nimport { Construct, ConstructNode, Stack } from '../lib';\nimport { ContextProvider } from '../lib/context-provider';\n\nexport = {\n  'AvailabilityZoneProvider returns a list with dummy values if the context is not available'(test: Test) {\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n    const azs = stack.availabilityZones;\n\n    test.deepEqual(azs, ['dummy1a', 'dummy1b', 'dummy1c']);\n    test.done();\n  },\n\n  'AvailabilityZoneProvider will return context list if available'(test: Test) {\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n    const before = stack.availabilityZones;\n    test.deepEqual(before, [ 'dummy1a', 'dummy1b', 'dummy1c' ]);\n    const key = expectedContextKey(stack);\n\n    stack.node.setContext(key, ['us-east-1a', 'us-east-1b']);\n\n    const azs = stack.availabilityZones;\n    test.deepEqual(azs, ['us-east-1a', 'us-east-1b']);\n\n    test.done();\n  },\n\n  'AvailabilityZoneProvider will complain if not given a list'(test: Test) {\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n    const before = stack.availabilityZones;\n    test.deepEqual(before, [ 'dummy1a', 'dummy1b', 'dummy1c' ]);\n    const key = expectedContextKey(stack);\n\n    stack.node.setContext(key, 'not-a-list');\n\n    test.throws(\n      () => stack.availabilityZones\n    );\n\n    test.done();\n  },\n\n  'ContextProvider consistently generates a key'(test: Test) {\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n    const key = ContextProvider.getKey(stack, {\n      provider: 'ssm',\n      props: {\n        parameterName: 'foo',\n        anyStringParam: 'bar'\n      },\n    });\n\n    test.deepEqual(key, {\n      key: 'ssm:account=12345:anyStringParam=bar:parameterName=foo:region=us-east-1',\n      props: {\n        account: '12345',\n        region: 'us-east-1',\n        parameterName: 'foo',\n        anyStringParam: 'bar'\n      }\n    });\n\n    const complexKey = ContextProvider.getKey(stack, {\n      provider: 'vpc',\n      props: {\n        cidrBlock: '192.168.0.16',\n        tags: { Name: 'MyVPC', Env: 'Preprod' },\n        igw: false,\n      }\n    });\n    test.deepEqual(complexKey, {\n      key: 'vpc:account=12345:cidrBlock=192.168.0.16:igw=false:region=us-east-1:tags.Env=Preprod:tags.Name=MyVPC',\n      props: {\n        account: '12345',\n        region: 'us-east-1',\n        cidrBlock: '192.168.0.16',\n        tags: { Name: 'MyVPC', Env: 'Preprod' },\n        igw: false,\n      }\n    });\n    test.done();\n  },\n\n  'Key generation can contain arbitrarily deep structures'(test: Test) {\n    // GIVEN\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n\n    // WHEN\n    const key = ContextProvider.getKey(stack, {\n      provider: 'provider',\n      props: {\n        list: [\n          { key: 'key1', value: 'value1' },\n          { key: 'key2', value: 'value2' },\n        ],\n      }\n    });\n\n    // THEN\n    test.deepEqual(key, {\n      key: 'provider:account=12345:list.0.key=key1:list.0.value=value1:list.1.key=key2:list.1.value=value2:region=us-east-1',\n      props: {\n        account: '12345',\n        region: 'us-east-1',\n        list: [\n          { key: 'key1', value: 'value1' },\n          { key: 'key2', value: 'value2' },\n        ],\n      }\n    });\n\n    test.done();\n  },\n\n  'context provider errors are attached to tree'(test: Test) {\n    const contextProps = { provider: 'bloop' };\n    const contextKey = 'bloop:account=12345:region=us-east-1';  // Depends on the mangling algo\n\n    // GIVEN\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n\n    // NOTE: error key is inlined here because it's part of the CX-API\n    // compatibility surface.\n    stack.node.setContext(contextKey, { $providerError: 'I had a boo-boo' });\n    const construct = new Construct(stack, 'Child');\n\n    // Verify that we got the right hardcoded key above, give a descriptive error if not\n    test.equals(ContextProvider.getKey(construct, contextProps).key, contextKey);\n\n    // WHEN\n    ContextProvider.getValue(construct, {\n      ...contextProps,\n      dummyValue: undefined,\n    });\n\n    // THEN\n    const error = construct.node.metadata.find(m => m.type === 'aws:cdk:error');\n    test.equals(error && error.data, 'I had a boo-boo');\n\n    test.done();\n  },\n};\n\n/**\n * Get the expected context key from a stack with missing parameters\n */\nfunction expectedContextKey(stack: Stack): string {\n  const missing = ConstructNode.synth(stack.node).manifest.missing;\n  if (!missing || missing.length !== 1) {\n    throw new Error(`Expecting assembly to include a single missing context report`);\n  }\n  return missing[0].key;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.context.js","sourceRoot":"","sources":["test.context.ts"],"names":[],"mappings":"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","sourcesContent":["import { Test } from 'nodeunit';\nimport { Construct, ConstructNode, Stack } from '../lib';\nimport { ContextProvider } from '../lib/context-provider';\n\nexport = {\n  'AvailabilityZoneProvider returns a list with dummy values if the context is not available'(test: Test) {\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n    const azs = stack.availabilityZones;\n\n    test.deepEqual(azs, ['dummy1a', 'dummy1b', 'dummy1c']);\n    test.done();\n  },\n\n  'AvailabilityZoneProvider will return context list if available'(test: Test) {\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n    const before = stack.availabilityZones;\n    test.deepEqual(before, [ 'dummy1a', 'dummy1b', 'dummy1c' ]);\n    const key = expectedContextKey(stack);\n\n    stack.node.setContext(key, ['us-east-1a', 'us-east-1b']);\n\n    const azs = stack.availabilityZones;\n    test.deepEqual(azs, ['us-east-1a', 'us-east-1b']);\n\n    test.done();\n  },\n\n  'AvailabilityZoneProvider will complain if not given a list'(test: Test) {\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n    const before = stack.availabilityZones;\n    test.deepEqual(before, [ 'dummy1a', 'dummy1b', 'dummy1c' ]);\n    const key = expectedContextKey(stack);\n\n    stack.node.setContext(key, 'not-a-list');\n\n    test.throws(\n      () => stack.availabilityZones\n    );\n\n    test.done();\n  },\n\n  'ContextProvider consistently generates a key'(test: Test) {\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n    const key = ContextProvider.getKey(stack, {\n      provider: 'ssm',\n      props: {\n        parameterName: 'foo',\n        anyStringParam: 'bar'\n      },\n    });\n\n    test.deepEqual(key, {\n      key: 'ssm:account=12345:anyStringParam=bar:parameterName=foo:region=us-east-1',\n      props: {\n        account: '12345',\n        region: 'us-east-1',\n        parameterName: 'foo',\n        anyStringParam: 'bar'\n      }\n    });\n\n    const complexKey = ContextProvider.getKey(stack, {\n      provider: 'vpc',\n      props: {\n        cidrBlock: '192.168.0.16',\n        tags: { Name: 'MyVPC', Env: 'Preprod' },\n        igw: false,\n      }\n    });\n    test.deepEqual(complexKey, {\n      key: 'vpc:account=12345:cidrBlock=192.168.0.16:igw=false:region=us-east-1:tags.Env=Preprod:tags.Name=MyVPC',\n      props: {\n        account: '12345',\n        region: 'us-east-1',\n        cidrBlock: '192.168.0.16',\n        tags: { Name: 'MyVPC', Env: 'Preprod' },\n        igw: false,\n      }\n    });\n    test.done();\n  },\n\n  'Key generation can contain arbitrarily deep structures'(test: Test) {\n    // GIVEN\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n\n    // WHEN\n    const key = ContextProvider.getKey(stack, {\n      provider: 'provider',\n      props: {\n        list: [\n          { key: 'key1', value: 'value1' },\n          { key: 'key2', value: 'value2' },\n        ],\n      }\n    });\n\n    // THEN\n    test.deepEqual(key, {\n      key: 'provider:account=12345:list.0.key=key1:list.0.value=value1:list.1.key=key2:list.1.value=value2:region=us-east-1',\n      props: {\n        account: '12345',\n        region: 'us-east-1',\n        list: [\n          { key: 'key1', value: 'value1' },\n          { key: 'key2', value: 'value2' },\n        ],\n      }\n    });\n\n    test.done();\n  },\n\n  'Keys with undefined values are not serialized'(test: Test) {\n    // GIVEN\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n\n    // WHEN\n    const result = ContextProvider.getKey(stack, {\n      provider: 'provider',\n      props: {\n        p1: 42,\n        p2: undefined,\n      },\n    });\n\n    // THEN\n    test.deepEqual(result, {\n      key: 'provider:account=12345:p1=42:region=us-east-1',\n      props: {\n        account: '12345',\n        region: 'us-east-1',\n        p1: 42,\n        p2: undefined,\n      },\n    });\n\n    test.done();\n  },\n\n  'context provider errors are attached to tree'(test: Test) {\n    const contextProps = { provider: 'bloop' };\n    const contextKey = 'bloop:account=12345:region=us-east-1';  // Depends on the mangling algo\n\n    // GIVEN\n    const stack = new Stack(undefined, 'TestStack', { env: { account: '12345', region: 'us-east-1' } });\n\n    // NOTE: error key is inlined here because it's part of the CX-API\n    // compatibility surface.\n    stack.node.setContext(contextKey, { $providerError: 'I had a boo-boo' });\n    const construct = new Construct(stack, 'Child');\n\n    // Verify that we got the right hardcoded key above, give a descriptive error if not\n    test.equals(ContextProvider.getKey(construct, contextProps).key, contextKey);\n\n    // WHEN\n    ContextProvider.getValue(construct, {\n      ...contextProps,\n      dummyValue: undefined,\n    });\n\n    // THEN\n    const error = construct.node.metadata.find(m => m.type === 'aws:cdk:error');\n    test.equals(error && error.data, 'I had a boo-boo');\n\n    test.done();\n  },\n};\n\n/**\n * Get the expected context key from a stack with missing parameters\n */\nfunction expectedContextKey(stack: Stack): string {\n  const missing = ConstructNode.synth(stack.node).manifest.missing;\n  if (!missing || missing.length !== 1) {\n    throw new Error(`Expecting assembly to include a single missing context report`);\n  }\n  return missing[0].key;\n}\n"]}

test/test.cross-environment-token.js

@@ -208,3 +208,3 @@ "use strict";
         const assembly = app.synth();
-        test.deepEqual(assembly.getStack(parentStack.stackName).template, {
+        test.deepEqual(assembly.getStackByName(parentStack.stackName).template, {
             Resources: {
@@ -219,3 +219,3 @@ ParentResource: {
         });
-        test.deepEqual(assembly.getStack(childStack.stackName).template, {
+        test.deepEqual(assembly.getStackByName(childStack.stackName).template, {
             Resources: {
@@ -233,2 +233,2 @@ ChildResource8C37244D: {
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.cross-environment-token.js","sourceRoot":"","sources":["test.cross-environment-token.ts"],"names":[],"mappings":"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","sourcesContent":["import { Test } from 'nodeunit';\nimport { App, CfnOutput, CfnResource, Construct, PhysicalName, Resource, Stack } from '../lib';\nimport { toCloudFormation } from './util';\n\n// tslint:disable:object-literal-key-quotes\n\nexport = {\n  'CrossEnvironmentToken': {\n    'can reference an ARN with a fixed physical name directly in a different account'(test: Test) {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1', {\n        env: {\n          account: '123456789012',\n          region: 'bermuda-triangle-1337',\n        },\n      });\n      const myResource = new MyResource(stack1, 'MyResource', 'PhysicalName');\n\n      const stack2 = new Stack(app, 'Stack2', {\n        env: {\n          account: '234567890123',\n          region: 'bermuda-triangle-42',\n        },\n      });\n\n      // WHEN\n      new CfnOutput(stack2, 'Output', {\n        value: myResource.arn,\n      });\n\n      // THEN\n      test.deepEqual(toCloudFormation(stack2), {\n        Outputs: {\n          Output: {\n            Value: {\n              'Fn::Join': [\n                '',\n                [\n                  'arn:',\n                  {\n                    Ref: 'AWS::Partition',\n                  },\n                  ':myservice:::my-resource/PhysicalName',\n                ],\n              ],\n            },\n          },\n        },\n      });\n\n      test.done();\n    },\n\n    'can reference a fixed physical name directly in a different account'(test: Test) {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1', {\n        env: {\n          account: '123456789012',\n          region: 'bermuda-triangle-1337',\n        },\n      });\n      const stack2 = new Stack(app, 'Stack2', {\n        env: {\n          account: '234567890123',\n          region: 'bermuda-triangle-42',\n        },\n      });\n\n      // WHEN\n      const myResource = new MyResource(stack1, 'MyResource', 'PhysicalName');\n      new CfnOutput(stack2, 'Output', {\n        value: myResource.name,\n      });\n\n      // THEN\n      test.deepEqual(toCloudFormation(stack2), {\n        Outputs: {\n          Output: {\n            Value: 'PhysicalName',\n          },\n        },\n      });\n\n      test.done();\n    },\n\n    'can reference an ARN with an assigned physical name directly in a different account'(test: Test) {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1', {\n        env: {\n          account: '123456789012',\n          region: 'bermuda-triangle-1337',\n        },\n      });\n      const myResource = new MyResource(stack1, 'MyResource', PhysicalName.GENERATE_IF_NEEDED);\n\n      const stack2 = new Stack(app, 'Stack2', {\n        env: {\n          account: '234567890123',\n          region: 'bermuda-triangle-42',\n        },\n      });\n\n      // WHEN\n      new CfnOutput(stack2, 'Output', {\n        value: myResource.arn,\n      });\n\n      // THEN\n      test.deepEqual(toCloudFormation(stack2), {\n        Outputs: {\n          Output: {\n            Value: {\n              'Fn::Join': [\n                '',\n                [\n                  'arn:',\n                  {\n                    Ref: 'AWS::Partition',\n                  },\n                  ':myservice:::my-resource/stack1stack1myresourcec54ced43683ebf9a3c4c',\n                ],\n              ],\n            },\n          },\n        },\n      });\n\n      test.done();\n    },\n\n    'can reference an assigned physical name directly in a different account'(test: Test) {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1', {\n        env: {\n          account: '123456789012',\n          region: 'bermuda-triangle-1337',\n        },\n      });\n      const stack2 = new Stack(app, 'Stack2', {\n        env: {\n          account: '234567890123',\n          region: 'bermuda-triangle-42',\n        },\n      });\n\n      // WHEN\n      const myResource = new MyResource(stack1, 'MyResource', PhysicalName.GENERATE_IF_NEEDED);\n      new CfnOutput(stack2, 'Output', {\n        value: myResource.name,\n      });\n\n      // THEN\n      test.deepEqual(toCloudFormation(stack2), {\n        Outputs: {\n          Output: {\n            Value: 'stack1stack1myresourcec54ced43683ebf9a3c4c',\n          },\n        },\n      });\n\n      test.done();\n    },\n  },\n\n  'cannot reference a deploy-time physical name across environments'(test: Test) {\n    // GIVEN\n    const app = new App();\n    const stack1 = new Stack(app, 'Stack1', {\n      env: {\n        account: '123456789012',\n        region: 'bermuda-triangle-1337',\n      },\n    });\n    const stack2 = new Stack(app, 'Stack2', {\n      env: {\n        account: '234567890123',\n        region: 'bermuda-triangle-42',\n      },\n    });\n\n    // WHEN\n    const myResource = new MyResource(stack1, 'MyResource');\n    new CfnOutput(stack2, 'Output', {\n      value: myResource.name,\n    });\n\n    // THEN\n    test.throws(() => toCloudFormation(stack2),\n      /Cannot use resource 'Stack1\\/MyResource' in a cross-environment fashion/);\n\n    test.done();\n  },\n\n  'cross environment when stack is a substack'(test: Test) {\n    const app = new App();\n\n    const parentStack = new Stack(app, 'ParentStack', {\n      env: { account: '112233', region: 'us-east-1' }\n    });\n\n    const childStack = new Stack(parentStack, 'ChildStack', {\n      env: { account: '998877', region: 'eu-west-2' }\n    });\n\n    const childResource = new MyResource(childStack, 'ChildResource', PhysicalName.GENERATE_IF_NEEDED);\n\n    new CfnResource(parentStack, 'ParentResource', {\n      type: 'Parent::Resource',\n      properties: {\n        RefToChildResource: childResource.name\n      }\n    });\n\n    const assembly = app.synth();\n\n    test.deepEqual(assembly.getStack(parentStack.stackName).template, {\n      Resources: {\n        ParentResource: {\n          Type: 'Parent::Resource',\n          Properties: {\n            RefToChildResource: 'parentstackchildstack83c5ackchildresource852877eeb919bda2008e'\n          }\n        }\n      }\n    });\n\n    test.deepEqual(assembly.getStack(childStack.stackName).template, {\n      Resources: {\n        ChildResource8C37244D: {\n          Type: 'My::Resource',\n          Properties: {\n            resourceName: 'parentstackchildstack83c5ackchildresource852877eeb919bda2008e'\n          }\n        }\n      }\n    });\n\n    test.done();\n  }\n};\n\nclass MyResource extends Resource {\n  public readonly arn: string;\n  public readonly name: string;\n\n  constructor(scope: Construct, id: string, physicalName?: string) {\n    super(scope, id, { physicalName });\n\n    this.arn = this.getResourceArnAttribute('simple-arn', {\n      region: '',\n      account: '',\n      resource:  'my-resource',\n      resourceName: this.physicalName,\n      service: 'myservice',\n    });\n    this.name = this.getResourceNameAttribute('simple-name');\n\n    new CfnResource(this, 'Resource', {\n      type: 'My::Resource',\n      properties: {\n        resourceName: this.physicalName\n      }\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.cross-environment-token.js","sourceRoot":"","sources":["test.cross-environment-token.ts"],"names":[],"mappings":"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","sourcesContent":["import { Test } from 'nodeunit';\nimport { App, CfnOutput, CfnResource, Construct, PhysicalName, Resource, Stack } from '../lib';\nimport { toCloudFormation } from './util';\n\n// tslint:disable:object-literal-key-quotes\n\nexport = {\n  'CrossEnvironmentToken': {\n    'can reference an ARN with a fixed physical name directly in a different account'(test: Test) {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1', {\n        env: {\n          account: '123456789012',\n          region: 'bermuda-triangle-1337',\n        },\n      });\n      const myResource = new MyResource(stack1, 'MyResource', 'PhysicalName');\n\n      const stack2 = new Stack(app, 'Stack2', {\n        env: {\n          account: '234567890123',\n          region: 'bermuda-triangle-42',\n        },\n      });\n\n      // WHEN\n      new CfnOutput(stack2, 'Output', {\n        value: myResource.arn,\n      });\n\n      // THEN\n      test.deepEqual(toCloudFormation(stack2), {\n        Outputs: {\n          Output: {\n            Value: {\n              'Fn::Join': [\n                '',\n                [\n                  'arn:',\n                  {\n                    Ref: 'AWS::Partition',\n                  },\n                  ':myservice:::my-resource/PhysicalName',\n                ],\n              ],\n            },\n          },\n        },\n      });\n\n      test.done();\n    },\n\n    'can reference a fixed physical name directly in a different account'(test: Test) {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1', {\n        env: {\n          account: '123456789012',\n          region: 'bermuda-triangle-1337',\n        },\n      });\n      const stack2 = new Stack(app, 'Stack2', {\n        env: {\n          account: '234567890123',\n          region: 'bermuda-triangle-42',\n        },\n      });\n\n      // WHEN\n      const myResource = new MyResource(stack1, 'MyResource', 'PhysicalName');\n      new CfnOutput(stack2, 'Output', {\n        value: myResource.name,\n      });\n\n      // THEN\n      test.deepEqual(toCloudFormation(stack2), {\n        Outputs: {\n          Output: {\n            Value: 'PhysicalName',\n          },\n        },\n      });\n\n      test.done();\n    },\n\n    'can reference an ARN with an assigned physical name directly in a different account'(test: Test) {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1', {\n        env: {\n          account: '123456789012',\n          region: 'bermuda-triangle-1337',\n        },\n      });\n      const myResource = new MyResource(stack1, 'MyResource', PhysicalName.GENERATE_IF_NEEDED);\n\n      const stack2 = new Stack(app, 'Stack2', {\n        env: {\n          account: '234567890123',\n          region: 'bermuda-triangle-42',\n        },\n      });\n\n      // WHEN\n      new CfnOutput(stack2, 'Output', {\n        value: myResource.arn,\n      });\n\n      // THEN\n      test.deepEqual(toCloudFormation(stack2), {\n        Outputs: {\n          Output: {\n            Value: {\n              'Fn::Join': [\n                '',\n                [\n                  'arn:',\n                  {\n                    Ref: 'AWS::Partition',\n                  },\n                  ':myservice:::my-resource/stack1stack1myresourcec54ced43683ebf9a3c4c',\n                ],\n              ],\n            },\n          },\n        },\n      });\n\n      test.done();\n    },\n\n    'can reference an assigned physical name directly in a different account'(test: Test) {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1', {\n        env: {\n          account: '123456789012',\n          region: 'bermuda-triangle-1337',\n        },\n      });\n      const stack2 = new Stack(app, 'Stack2', {\n        env: {\n          account: '234567890123',\n          region: 'bermuda-triangle-42',\n        },\n      });\n\n      // WHEN\n      const myResource = new MyResource(stack1, 'MyResource', PhysicalName.GENERATE_IF_NEEDED);\n      new CfnOutput(stack2, 'Output', {\n        value: myResource.name,\n      });\n\n      // THEN\n      test.deepEqual(toCloudFormation(stack2), {\n        Outputs: {\n          Output: {\n            Value: 'stack1stack1myresourcec54ced43683ebf9a3c4c',\n          },\n        },\n      });\n\n      test.done();\n    },\n  },\n\n  'cannot reference a deploy-time physical name across environments'(test: Test) {\n    // GIVEN\n    const app = new App();\n    const stack1 = new Stack(app, 'Stack1', {\n      env: {\n        account: '123456789012',\n        region: 'bermuda-triangle-1337',\n      },\n    });\n    const stack2 = new Stack(app, 'Stack2', {\n      env: {\n        account: '234567890123',\n        region: 'bermuda-triangle-42',\n      },\n    });\n\n    // WHEN\n    const myResource = new MyResource(stack1, 'MyResource');\n    new CfnOutput(stack2, 'Output', {\n      value: myResource.name,\n    });\n\n    // THEN\n    test.throws(() => toCloudFormation(stack2),\n      /Cannot use resource 'Stack1\\/MyResource' in a cross-environment fashion/);\n\n    test.done();\n  },\n\n  'cross environment when stack is a substack'(test: Test) {\n    const app = new App();\n\n    const parentStack = new Stack(app, 'ParentStack', {\n      env: { account: '112233', region: 'us-east-1' }\n    });\n\n    const childStack = new Stack(parentStack, 'ChildStack', {\n      env: { account: '998877', region: 'eu-west-2' }\n    });\n\n    const childResource = new MyResource(childStack, 'ChildResource', PhysicalName.GENERATE_IF_NEEDED);\n\n    new CfnResource(parentStack, 'ParentResource', {\n      type: 'Parent::Resource',\n      properties: {\n        RefToChildResource: childResource.name\n      }\n    });\n\n    const assembly = app.synth();\n\n    test.deepEqual(assembly.getStackByName(parentStack.stackName).template, {\n      Resources: {\n        ParentResource: {\n          Type: 'Parent::Resource',\n          Properties: {\n            RefToChildResource: 'parentstackchildstack83c5ackchildresource852877eeb919bda2008e'\n          }\n        }\n      }\n    });\n\n    test.deepEqual(assembly.getStackByName(childStack.stackName).template, {\n      Resources: {\n        ChildResource8C37244D: {\n          Type: 'My::Resource',\n          Properties: {\n            resourceName: 'parentstackchildstack83c5ackchildresource852877eeb919bda2008e'\n          }\n        }\n      }\n    });\n\n    test.done();\n  }\n};\n\nclass MyResource extends Resource {\n  public readonly arn: string;\n  public readonly name: string;\n\n  constructor(scope: Construct, id: string, physicalName?: string) {\n    super(scope, id, { physicalName });\n\n    this.arn = this.getResourceArnAttribute('simple-arn', {\n      region: '',\n      account: '',\n      resource:  'my-resource',\n      resourceName: this.physicalName,\n      service: 'myservice',\n    });\n    this.name = this.getResourceNameAttribute('simple-name');\n\n    new CfnResource(this, 'Resource', {\n      type: 'My::Resource',\n      properties: {\n        resourceName: this.physicalName\n      }\n    });\n  }\n}\n"]}

test/test.environment.js

@@ -31,3 +31,3 @@ "use strict";
             test.deepEqual(stack.resolve(stack.region), { Ref: 'AWS::Region' });
-            test.deepEqual(app.synth().getStack(stack.stackName).environment, {
+            test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {
                 account: 'unknown-account',
@@ -47,3 +47,3 @@ region: 'unknown-region',
             test.deepEqual(stack.resolve(stack.region), 'explicit-region');
-            test.deepEqual(app.synth().getStack(stack.stackName).environment, {
+            test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {
                 account: 'unknown-account',
@@ -66,3 +66,3 @@ region: 'explicit-region',
             test.deepEqual(stack.resolve(stack.region), 'explicit-region');
-            test.deepEqual(app.synth().getStack(stack.stackName).environment, {
+            test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {
                 account: 'explicit-account',
@@ -87,3 +87,3 @@ region: 'explicit-region',
             test.deepEqual(stack.resolve(stack.region), { Ref: 'AWS::Region' });
-            test.deepEqual(app.synth().getStack(stack.stackName).environment, {
+            test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {
                 account: 'unknown-account',
@@ -108,3 +108,3 @@ region: 'unknown-region',
             test.deepEqual(stack.resolve(stack.region), 'us-east-2');
-            test.deepEqual(app.synth().getStack(stack.stackName).environment, {
+            test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {
                 account: 'unknown-account',
@@ -118,2 +118,2 @@ region: 'us-east-2',
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.environment.js","sourceRoot":"","sources":["test.environment.ts"],"names":[],"mappings":"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","sourcesContent":["import { Test } from 'nodeunit';\nimport { App, Aws, Stack, Token } from '../lib';\n\nexport = {\n  'By default, environment region and account are not defined and resolve to intrinsics'(test: Test) {\n    const stack = new Stack();\n    test.ok(Token.isUnresolved(stack.account));\n    test.ok(Token.isUnresolved(stack.region));\n    test.deepEqual(stack.resolve(stack.account), { Ref: \"AWS::AccountId\" });\n    test.deepEqual(stack.resolve(stack.region), { Ref: \"AWS::Region\" });\n    test.done();\n  },\n\n  'If only `env.region` or `env.account` are specified, Refs will be used for the other'(test: Test) {\n    const app = new App();\n\n    const stack1 = new Stack(app, 'S1', { env: { region: 'only-region' } });\n    const stack2 = new Stack(app, 'S2', { env: { account: 'only-account' } });\n\n    test.deepEqual(stack1.resolve(stack1.account), { Ref: 'AWS::AccountId' });\n    test.deepEqual(stack1.resolve(stack1.region), 'only-region');\n\n    test.deepEqual(stack2.resolve(stack2.account), 'only-account');\n    test.deepEqual(stack2.resolve(stack2.region), { Ref: 'AWS::Region' });\n\n    test.done();\n  },\n\n  'environment defaults': {\n    'if \"env\" is not specified, it implies account/region agnostic'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack');\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), { Ref: 'AWS::AccountId' });\n      test.deepEqual(stack.resolve(stack.region), { Ref: 'AWS::Region' });\n      test.deepEqual(app.synth().getStack(stack.stackName).environment, {\n        account: 'unknown-account',\n        region: 'unknown-region',\n        name: 'aws://unknown-account/unknown-region'\n      });\n\n      test.done();\n    },\n\n    'only region is set'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack', { env: { region: 'explicit-region' }});\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), { Ref: 'AWS::AccountId' });\n      test.deepEqual(stack.resolve(stack.region), 'explicit-region');\n      test.deepEqual(app.synth().getStack(stack.stackName).environment, {\n        account: 'unknown-account',\n        region: 'explicit-region',\n        name: 'aws://unknown-account/explicit-region'\n      });\n\n      test.done();\n    },\n\n    'both \"region\" and \"account\" are set'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack', { env: {\n        account: 'explicit-account',\n        region: 'explicit-region'\n      }});\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), 'explicit-account');\n      test.deepEqual(stack.resolve(stack.region), 'explicit-region');\n      test.deepEqual(app.synth().getStack(stack.stackName).environment, {\n        account: 'explicit-account',\n        region: 'explicit-region',\n        name: 'aws://explicit-account/explicit-region'\n      });\n\n      test.done();\n    },\n\n    'token-account and token-region'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack', {\n        env: {\n          account: Aws.ACCOUNT_ID,\n          region: Aws.REGION\n        }\n      });\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), { Ref: 'AWS::AccountId' });\n      test.deepEqual(stack.resolve(stack.region), { Ref: 'AWS::Region' });\n      test.deepEqual(app.synth().getStack(stack.stackName).environment, {\n        account: 'unknown-account',\n        region: 'unknown-region',\n        name: 'aws://unknown-account/unknown-region'\n      });\n\n      test.done();\n    },\n\n    'token-account explicit region'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack', {\n        env: {\n          account: Aws.ACCOUNT_ID,\n          region: 'us-east-2'\n        }\n      });\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), { Ref: 'AWS::AccountId' });\n      test.deepEqual(stack.resolve(stack.region), 'us-east-2');\n      test.deepEqual(app.synth().getStack(stack.stackName).environment, {\n        account: 'unknown-account',\n        region: 'us-east-2',\n        name: 'aws://unknown-account/us-east-2'\n      });\n\n      test.done();\n    }\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.environment.js","sourceRoot":"","sources":["test.environment.ts"],"names":[],"mappings":"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","sourcesContent":["import { Test } from 'nodeunit';\nimport { App, Aws, Stack, Token } from '../lib';\n\nexport = {\n  'By default, environment region and account are not defined and resolve to intrinsics'(test: Test) {\n    const stack = new Stack();\n    test.ok(Token.isUnresolved(stack.account));\n    test.ok(Token.isUnresolved(stack.region));\n    test.deepEqual(stack.resolve(stack.account), { Ref: \"AWS::AccountId\" });\n    test.deepEqual(stack.resolve(stack.region), { Ref: \"AWS::Region\" });\n    test.done();\n  },\n\n  'If only `env.region` or `env.account` are specified, Refs will be used for the other'(test: Test) {\n    const app = new App();\n\n    const stack1 = new Stack(app, 'S1', { env: { region: 'only-region' } });\n    const stack2 = new Stack(app, 'S2', { env: { account: 'only-account' } });\n\n    test.deepEqual(stack1.resolve(stack1.account), { Ref: 'AWS::AccountId' });\n    test.deepEqual(stack1.resolve(stack1.region), 'only-region');\n\n    test.deepEqual(stack2.resolve(stack2.account), 'only-account');\n    test.deepEqual(stack2.resolve(stack2.region), { Ref: 'AWS::Region' });\n\n    test.done();\n  },\n\n  'environment defaults': {\n    'if \"env\" is not specified, it implies account/region agnostic'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack');\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), { Ref: 'AWS::AccountId' });\n      test.deepEqual(stack.resolve(stack.region), { Ref: 'AWS::Region' });\n      test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {\n        account: 'unknown-account',\n        region: 'unknown-region',\n        name: 'aws://unknown-account/unknown-region'\n      });\n\n      test.done();\n    },\n\n    'only region is set'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack', { env: { region: 'explicit-region' }});\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), { Ref: 'AWS::AccountId' });\n      test.deepEqual(stack.resolve(stack.region), 'explicit-region');\n      test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {\n        account: 'unknown-account',\n        region: 'explicit-region',\n        name: 'aws://unknown-account/explicit-region'\n      });\n\n      test.done();\n    },\n\n    'both \"region\" and \"account\" are set'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack', { env: {\n        account: 'explicit-account',\n        region: 'explicit-region'\n      }});\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), 'explicit-account');\n      test.deepEqual(stack.resolve(stack.region), 'explicit-region');\n      test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {\n        account: 'explicit-account',\n        region: 'explicit-region',\n        name: 'aws://explicit-account/explicit-region'\n      });\n\n      test.done();\n    },\n\n    'token-account and token-region'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack', {\n        env: {\n          account: Aws.ACCOUNT_ID,\n          region: Aws.REGION\n        }\n      });\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), { Ref: 'AWS::AccountId' });\n      test.deepEqual(stack.resolve(stack.region), { Ref: 'AWS::Region' });\n      test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {\n        account: 'unknown-account',\n        region: 'unknown-region',\n        name: 'aws://unknown-account/unknown-region'\n      });\n\n      test.done();\n    },\n\n    'token-account explicit region'(test: Test) {\n      // GIVEN\n      const app = new App();\n\n      // WHEN\n      const stack = new Stack(app, 'stack', {\n        env: {\n          account: Aws.ACCOUNT_ID,\n          region: 'us-east-2'\n        }\n      });\n\n      // THEN\n      test.deepEqual(stack.resolve(stack.account), { Ref: 'AWS::AccountId' });\n      test.deepEqual(stack.resolve(stack.region), 'us-east-2');\n      test.deepEqual(app.synth().getStackByName(stack.stackName).environment, {\n        account: 'unknown-account',\n        region: 'us-east-2',\n        name: 'aws://unknown-account/us-east-2'\n      });\n\n      test.done();\n    }\n  },\n};\n"]}

test/test.fn.js

@@ -116,3 +116,3 @@ "use strict";
             // THEN
-            const template = app.synth().getStack('Stack2').template;
+            const template = app.synth().getStackByName('Stack2').template;
             test.deepEqual(template, {
@@ -133,2 +133,2 @@ Outputs: {
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.fn.js","sourceRoot":"","sources":["test.fn.ts"],"names":[],"mappings":"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","sourcesContent":["import fc = require('fast-check');\nimport _ = require('lodash');\nimport nodeunit = require('nodeunit');\nimport { App, CfnOutput, Fn, Stack, Token } from '../lib';\nimport { Intrinsic } from '../lib/private/intrinsic';\n\nfunction asyncTest(cb: (test: nodeunit.Test) => Promise<void>): (test: nodeunit.Test) => void {\n  return async (test: nodeunit.Test) => {\n    let error: Error;\n    try {\n      await cb(test);\n    } catch (e) {\n      error = e;\n    } finally {\n      test.doesNotThrow(() => {\n        if (error) { throw error; }\n      });\n      test.done();\n    }\n  };\n}\n\nconst nonEmptyString = fc.string(1, 16);\nconst tokenish = fc.array(nonEmptyString, 2, 2).map(arr => ({ [arr[0]]: arr[1] }));\nconst anyValue = fc.oneof<any>(nonEmptyString, tokenish);\n\nexport = nodeunit.testCase({\n  'eager resolution for non-tokens': {\n    'Fn.select'(test: nodeunit.Test) {\n      test.deepEqual(Fn.select(2, [ 'hello', 'you', 'dude' ]), 'dude');\n      test.done();\n    },\n    'Fn.split'(test: nodeunit.Test) {\n      test.deepEqual(Fn.split(':', 'hello:world:yeah'), [ 'hello', 'world', 'yeah' ]);\n      test.done();\n    }\n  },\n  'FnJoin': {\n    'rejects empty list of arguments to join'(test: nodeunit.Test) {\n      test.throws(() => Fn.join('.', []));\n      test.done();\n    },\n    'collapse nested FnJoins even if they contain tokens'(test: nodeunit.Test) {\n      const stack = new Stack();\n\n      const obj = Fn.join('', [\n        'a',\n        Fn.join('', [Fn.getAtt('a', 'bc').toString(), 'c']),\n        'd'\n      ]);\n\n      test.deepEqual(stack.resolve(obj), { 'Fn::Join': [ \"\",\n        [\n          \"a\",\n          { 'Fn::GetAtt': ['a', 'bc'] },\n          'cd',\n        ]\n      ]});\n\n      test.done();\n    },\n    'resolves to the value if only one value is joined': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), anyValue,\n          (delimiter, value) => _.isEqual(stack.resolve(Fn.join(delimiter, [value])), value)\n        ),\n        { verbose: true }\n      );\n    }),\n    'pre-concatenates string literals': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), fc.array(nonEmptyString, 1, 15),\n          (delimiter, values) => stack.resolve(Fn.join(delimiter, values)) === values.join(delimiter)\n        ),\n        { verbose: true }\n      );\n    }),\n    'pre-concatenates around tokens': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), fc.array(nonEmptyString, 1, 3), tokenish, fc.array(nonEmptyString, 1, 3),\n          (delimiter, prefix, obj, suffix) =>\n            _.isEqual(stack.resolve(Fn.join(delimiter, [...prefix, stringToken(obj), ...suffix])),\n                      { 'Fn::Join': [delimiter, [prefix.join(delimiter), obj, suffix.join(delimiter)]] })\n        ),\n        { verbose: true, seed: 1539874645005, path: \"0:0:0:0:0:0:0:0:0\" }\n      );\n    }),\n    'flattens joins nested under joins with same delimiter': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), fc.array(anyValue),\n                      fc.array(anyValue, 1, 3),\n                      fc.array(anyValue),\n          (delimiter, prefix, nested, suffix) =>\n            // Gonna test\n            _.isEqual(stack.resolve(Fn.join(delimiter, [...prefix, Fn.join(delimiter, nested), ...suffix])),\n                      stack.resolve(Fn.join(delimiter, [...prefix, ...nested, ...suffix])))\n        ),\n        { verbose: true }\n      );\n    }),\n    'does not flatten joins nested under joins with different delimiter': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), fc.string(),\n          fc.array(anyValue, 1, 3),\n          fc.array(tokenish, 2, 3),\n          fc.array(anyValue, 3),\n          (delimiter1, delimiter2, prefix,  nested, suffix) => {\n            fc.pre(delimiter1 !== delimiter2);\n            const join = Fn.join(delimiter1, [...prefix, Fn.join(delimiter2, stringListToken(nested)), ...suffix]);\n            const resolved = stack.resolve(join);\n            return resolved['Fn::Join'][1].find((e: any) => typeof e === 'object'\n                                                        && ('Fn::Join' in e)\n                                                        && e['Fn::Join'][0] === delimiter2) != null;\n          }\n        ),\n        { verbose: true }\n      );\n    }),\n    'Fn::EachMemberIn': asyncTest(async (test) => {\n      const stack = new Stack();\n      const eachMemberIn = Fn.conditionEachMemberIn(\n        Fn.valueOfAll('AWS::EC2::Subnet::Id', 'VpcId'),\n        Fn.refAll('AWS::EC2::VPC::Id')\n      );\n      test.deepEqual(stack.resolve(eachMemberIn), {\n        'Fn::EachMemberIn': [\n          { 'Fn::ValueOfAll': ['AWS::EC2::Subnet::Id', 'VpcId'] },\n          { 'Fn::RefAll': 'AWS::EC2::VPC::Id'}\n        ]\n      });\n    }),\n\n    'cross-stack FnJoin elements are properly resolved': asyncTest(async (test) => {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1');\n      const stack2 = new Stack(app, 'Stack2');\n\n      // WHEN\n      new CfnOutput(stack2, 'Stack1Id', {\n        value: Fn.join(' = ', [ 'Stack1Id', stack1.stackId ])\n      });\n\n      // THEN\n      const template = app.synth().getStack('Stack2').template;\n\n      test.deepEqual(template, {\n        Outputs: {\n          Stack1Id: {\n            Value: {\n              'Fn::Join': [' = ', [\n                'Stack1Id',\n                { 'Fn::ImportValue': 'Stack1:ExportsOutputRefAWSStackIdB2DD5BAA' }\n              ]]\n            }\n          }\n        }\n      });\n    }),\n  },\n});\n\nfunction stringListToken(o: any): string[] {\n  return Token.asList(new Intrinsic(o));\n}\nfunction stringToken(o: any): string {\n  return Token.asString(new Intrinsic(o));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.fn.js","sourceRoot":"","sources":["test.fn.ts"],"names":[],"mappings":";AAAA,iCAAkC;AAClC,4BAA6B;AAC7B,qCAAsC;AACtC,gCAA0D;AAC1D,wDAAqD;AAErD,SAAS,SAAS,CAAC,EAA0C;IAC3D,OAAO,KAAK,EAAE,IAAmB,EAAE,EAAE;QACnC,IAAI,KAAY,CAAC;QACjB,IAAI;YACF,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC;SAChB;QAAC,OAAO,CAAC,EAAE;YACV,KAAK,GAAG,CAAC,CAAC;SACX;gBAAS;YACR,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE;gBACrB,IAAI,KAAK,EAAE;oBAAE,MAAM,KAAK,CAAC;iBAAE;YAC7B,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,IAAI,EAAE,CAAC;SACb;IACH,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,cAAc,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACxC,MAAM,QAAQ,GAAG,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACnF,MAAM,QAAQ,GAAG,EAAE,CAAC,KAAK,CAAM,cAAc,EAAE,QAAQ,CAAC,CAAC;AAoJzD,SAAS,eAAe,CAAC,CAAM;IAC7B,OAAO,WAAK,CAAC,MAAM,CAAC,IAAI,qBAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AACxC,CAAC;AACD,SAAS,WAAW,CAAC,CAAM;IACzB,OAAO,WAAK,CAAC,QAAQ,CAAC,IAAI,qBAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1C,CAAC;AAvJD,iBAAS,QAAQ,CAAC,QAAQ,CAAC;IACzB,iCAAiC,EAAE;QACjC,WAAW,CAAC,IAAmB;YAC7B,IAAI,CAAC,SAAS,CAAC,QAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAE,CAAC,EAAE,MAAM,CAAC,CAAC;YACjE,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;QACD,UAAU,CAAC,IAAmB;YAC5B,IAAI,CAAC,SAAS,CAAC,QAAE,CAAC,KAAK,CAAC,GAAG,EAAE,kBAAkB,CAAC,EAAE,CAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAE,CAAC,CAAC;YAChF,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;KACF;IACD,QAAQ,EAAE;QACR,yCAAyC,CAAC,IAAmB;YAC3D,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,QAAE,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;YACpC,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;QACD,qDAAqD,CAAC,IAAmB;YACvE,MAAM,KAAK,GAAG,IAAI,WAAK,EAAE,CAAC;YAE1B,MAAM,GAAG,GAAG,QAAE,CAAC,IAAI,CAAC,EAAE,EAAE;gBACtB,GAAG;gBACH,QAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,QAAE,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,GAAG,CAAC,CAAC;gBACnD,GAAG;aACJ,CAAC,CAAC;YAEH,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,UAAU,EAAE,CAAE,EAAE;oBACnD;wBACE,GAAG;wBACH,EAAE,YAAY,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE;wBAC7B,IAAI;qBACL;iBACF,EAAC,CAAC,CAAC;YAEJ,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC;QACD,mDAAmD,EAAE,SAAS,CAAC,KAAK,IAAI,EAAE;YACxE,MAAM,KAAK,GAAG,IAAI,WAAK,EAAE,CAAC;YAC1B,MAAM,EAAE,CAAC,MAAM,CACb,EAAE,CAAC,QAAQ,CACT,EAAE,CAAC,MAAM,EAAE,EAAE,QAAQ,EACrB,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,QAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CACnF,EACD,EAAE,OAAO,EAAE,IAAI,EAAE,CAClB,CAAC;QACJ,CAAC,CAAC;QACF,kCAAkC,EAAE,SAAS,CAAC,KAAK,IAAI,EAAE;YACvD,MAAM,KAAK,GAAG,IAAI,WAAK,EAAE,CAAC;YAC1B,MAAM,EAAE,CAAC,MAAM,CACb,EAAE,CAAC,QAAQ,CACT,EAAE,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC,EAAE,EAAE,CAAC,EAC5C,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,QAAE,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAC5F,EACD,EAAE,OAAO,EAAE,IAAI,EAAE,CAClB,CAAC;QACJ,CAAC,CAAC;QACF,gCAAgC,EAAE,SAAS,CAAC,KAAK,IAAI,EAAE;YACrD,MAAM,KAAK,GAAG,IAAI,WAAK,EAAE,CAAC;YAC1B,MAAM,EAAE,CAAC,MAAM,CACb,EAAE,CAAC,QAAQ,CACT,EAAE,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC,CAAC,EACrF,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,CACjC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,QAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,GAAG,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EAC3E,EAAE,UAAU,EAAE,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAChG,EACD,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAClE,CAAC;QACJ,CAAC,CAAC;QACF,uDAAuD,EAAE,SAAS,CAAC,KAAK,IAAI,EAAE;YAC5E,MAAM,KAAK,GAAG,IAAI,WAAK,EAAE,CAAC;YAC1B,MAAM,EAAE,CAAC,MAAM,CACb,EAAE,CAAC,QAAQ,CACT,EAAE,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,EACnB,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,EACxB,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,EAC9B,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;YACpC,aAAa;YACb,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,QAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,GAAG,MAAM,EAAE,QAAE,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EACrF,KAAK,CAAC,OAAO,CAAC,QAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAClF,EACD,EAAE,OAAO,EAAE,IAAI,EAAE,CAClB,CAAC;QACJ,CAAC,CAAC;QACF,oEAAoE,EAAE,SAAS,CAAC,KAAK,IAAI,EAAE;YACzF,MAAM,KAAK,GAAG,IAAI,WAAK,EAAE,CAAC;YAC1B,MAAM,EAAE,CAAC,MAAM,CACb,EAAE,CAAC,QAAQ,CACT,EAAE,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,EACxB,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,EACxB,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,EACxB,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,EACrB,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,EAAG,MAAM,EAAE,MAAM,EAAE,EAAE;gBAClD,EAAE,CAAC,GAAG,CAAC,UAAU,KAAK,UAAU,CAAC,CAAC;gBAClC,MAAM,IAAI,GAAG,QAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,GAAG,MAAM,EAAE,QAAE,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC;gBACvG,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBACrC,OAAO,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ;uBACtB,CAAC,UAAU,IAAI,CAAC,CAAC;uBACjB,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,IAAI,IAAI,CAAC;YAC1F,CAAC,CACF,EACD,EAAE,OAAO,EAAE,IAAI,EAAE,CAClB,CAAC;QACJ,CAAC,CAAC;QACF,kBAAkB,EAAE,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;YAC3C,MAAM,KAAK,GAAG,IAAI,WAAK,EAAE,CAAC;YAC1B,MAAM,YAAY,GAAG,QAAE,CAAC,qBAAqB,CAC3C,QAAE,CAAC,UAAU,CAAC,sBAAsB,EAAE,OAAO,CAAC,EAC9C,QAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAC/B,CAAC;YACF,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;gBAC1C,kBAAkB,EAAE;oBAClB,EAAE,gBAAgB,EAAE,CAAC,sBAAsB,EAAE,OAAO,CAAC,EAAE;oBACvD,EAAE,YAAY,EAAE,mBAAmB,EAAC;iBACrC;aACF,CAAC,CAAC;QACL,CAAC,CAAC;QAEF,mDAAmD,EAAE,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;YAC5E,QAAQ;YACR,MAAM,GAAG,GAAG,IAAI,SAAG,EAAE,CAAC;YACtB,MAAM,MAAM,GAAG,IAAI,WAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;YACxC,MAAM,MAAM,GAAG,IAAI,WAAK,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;YAExC,OAAO;YACP,IAAI,eAAS,CAAC,MAAM,EAAE,UAAU,EAAE;gBAChC,KAAK,EAAE,QAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAE,UAAU,EAAE,MAAM,CAAC,OAAO,CAAE,CAAC;aACtD,CAAC,CAAC;YAEH,OAAO;YACP,MAAM,QAAQ,GAAG,GAAG,CAAC,KAAK,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC;YAE/D,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE;gBACvB,OAAO,EAAE;oBACP,QAAQ,EAAE;wBACR,KAAK,EAAE;4BACL,UAAU,EAAE,CAAC,KAAK,EAAE;oCAClB,UAAU;oCACV,EAAE,iBAAiB,EAAE,2CAA2C,EAAE;iCACnE,CAAC;yBACH;qBACF;iBACF;aACF,CAAC,CAAC;QACL,CAAC,CAAC;KACH;CACF,CAAC,CAAC","sourcesContent":["import fc = require('fast-check');\nimport _ = require('lodash');\nimport nodeunit = require('nodeunit');\nimport { App, CfnOutput, Fn, Stack, Token } from '../lib';\nimport { Intrinsic } from '../lib/private/intrinsic';\n\nfunction asyncTest(cb: (test: nodeunit.Test) => Promise<void>): (test: nodeunit.Test) => void {\n  return async (test: nodeunit.Test) => {\n    let error: Error;\n    try {\n      await cb(test);\n    } catch (e) {\n      error = e;\n    } finally {\n      test.doesNotThrow(() => {\n        if (error) { throw error; }\n      });\n      test.done();\n    }\n  };\n}\n\nconst nonEmptyString = fc.string(1, 16);\nconst tokenish = fc.array(nonEmptyString, 2, 2).map(arr => ({ [arr[0]]: arr[1] }));\nconst anyValue = fc.oneof<any>(nonEmptyString, tokenish);\n\nexport = nodeunit.testCase({\n  'eager resolution for non-tokens': {\n    'Fn.select'(test: nodeunit.Test) {\n      test.deepEqual(Fn.select(2, [ 'hello', 'you', 'dude' ]), 'dude');\n      test.done();\n    },\n    'Fn.split'(test: nodeunit.Test) {\n      test.deepEqual(Fn.split(':', 'hello:world:yeah'), [ 'hello', 'world', 'yeah' ]);\n      test.done();\n    }\n  },\n  'FnJoin': {\n    'rejects empty list of arguments to join'(test: nodeunit.Test) {\n      test.throws(() => Fn.join('.', []));\n      test.done();\n    },\n    'collapse nested FnJoins even if they contain tokens'(test: nodeunit.Test) {\n      const stack = new Stack();\n\n      const obj = Fn.join('', [\n        'a',\n        Fn.join('', [Fn.getAtt('a', 'bc').toString(), 'c']),\n        'd'\n      ]);\n\n      test.deepEqual(stack.resolve(obj), { 'Fn::Join': [ \"\",\n        [\n          \"a\",\n          { 'Fn::GetAtt': ['a', 'bc'] },\n          'cd',\n        ]\n      ]});\n\n      test.done();\n    },\n    'resolves to the value if only one value is joined': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), anyValue,\n          (delimiter, value) => _.isEqual(stack.resolve(Fn.join(delimiter, [value])), value)\n        ),\n        { verbose: true }\n      );\n    }),\n    'pre-concatenates string literals': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), fc.array(nonEmptyString, 1, 15),\n          (delimiter, values) => stack.resolve(Fn.join(delimiter, values)) === values.join(delimiter)\n        ),\n        { verbose: true }\n      );\n    }),\n    'pre-concatenates around tokens': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), fc.array(nonEmptyString, 1, 3), tokenish, fc.array(nonEmptyString, 1, 3),\n          (delimiter, prefix, obj, suffix) =>\n            _.isEqual(stack.resolve(Fn.join(delimiter, [...prefix, stringToken(obj), ...suffix])),\n                      { 'Fn::Join': [delimiter, [prefix.join(delimiter), obj, suffix.join(delimiter)]] })\n        ),\n        { verbose: true, seed: 1539874645005, path: \"0:0:0:0:0:0:0:0:0\" }\n      );\n    }),\n    'flattens joins nested under joins with same delimiter': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), fc.array(anyValue),\n                      fc.array(anyValue, 1, 3),\n                      fc.array(anyValue),\n          (delimiter, prefix, nested, suffix) =>\n            // Gonna test\n            _.isEqual(stack.resolve(Fn.join(delimiter, [...prefix, Fn.join(delimiter, nested), ...suffix])),\n                      stack.resolve(Fn.join(delimiter, [...prefix, ...nested, ...suffix])))\n        ),\n        { verbose: true }\n      );\n    }),\n    'does not flatten joins nested under joins with different delimiter': asyncTest(async () => {\n      const stack = new Stack();\n      await fc.assert(\n        fc.property(\n          fc.string(), fc.string(),\n          fc.array(anyValue, 1, 3),\n          fc.array(tokenish, 2, 3),\n          fc.array(anyValue, 3),\n          (delimiter1, delimiter2, prefix,  nested, suffix) => {\n            fc.pre(delimiter1 !== delimiter2);\n            const join = Fn.join(delimiter1, [...prefix, Fn.join(delimiter2, stringListToken(nested)), ...suffix]);\n            const resolved = stack.resolve(join);\n            return resolved['Fn::Join'][1].find((e: any) => typeof e === 'object'\n                                                        && ('Fn::Join' in e)\n                                                        && e['Fn::Join'][0] === delimiter2) != null;\n          }\n        ),\n        { verbose: true }\n      );\n    }),\n    'Fn::EachMemberIn': asyncTest(async (test) => {\n      const stack = new Stack();\n      const eachMemberIn = Fn.conditionEachMemberIn(\n        Fn.valueOfAll('AWS::EC2::Subnet::Id', 'VpcId'),\n        Fn.refAll('AWS::EC2::VPC::Id')\n      );\n      test.deepEqual(stack.resolve(eachMemberIn), {\n        'Fn::EachMemberIn': [\n          { 'Fn::ValueOfAll': ['AWS::EC2::Subnet::Id', 'VpcId'] },\n          { 'Fn::RefAll': 'AWS::EC2::VPC::Id'}\n        ]\n      });\n    }),\n\n    'cross-stack FnJoin elements are properly resolved': asyncTest(async (test) => {\n      // GIVEN\n      const app = new App();\n      const stack1 = new Stack(app, 'Stack1');\n      const stack2 = new Stack(app, 'Stack2');\n\n      // WHEN\n      new CfnOutput(stack2, 'Stack1Id', {\n        value: Fn.join(' = ', [ 'Stack1Id', stack1.stackId ])\n      });\n\n      // THEN\n      const template = app.synth().getStackByName('Stack2').template;\n\n      test.deepEqual(template, {\n        Outputs: {\n          Stack1Id: {\n            Value: {\n              'Fn::Join': [' = ', [\n                'Stack1Id',\n                { 'Fn::ImportValue': 'Stack1:ExportsOutputRefAWSStackIdB2DD5BAA' }\n              ]]\n            }\n          }\n        }\n      });\n    }),\n  },\n});\n\nfunction stringListToken(o: any): string[] {\n  return Token.asList(new Intrinsic(o));\n}\nfunction stringToken(o: any): string {\n  return Token.asString(new Intrinsic(o));\n}\n"]}

test/test.stack.d.ts

@@ -37,5 +37,7 @@ import { Test } from 'nodeunit';
     'stack.availabilityZones falls back to Fn::GetAZ[0],[2] if region is not specified'(test: Test): void;
-    'stack.templateFile contains the name of the cloudformation output'(test: Test): void;
+    'stack.templateFile is the name of the template file emitted to the cloud assembly (default is to use the stack name)'(test: Test): void;
+    'when feature flag is enabled we will use the artifact id as the template name'(test: Test): void;
+    'allow using the same stack name for two stacks (i.e. in different regions)'(test: Test): void;
     'metadata is collected at the stack boundary'(test: Test): void;
 };
 export = _default;

test/test.synthesis.js

@@ -44,5 +44,5 @@ "use strict";
                 path: '',
-                children: [
-                    { id: 'Tree', path: 'Tree' }
-                ]
+                children: {
+                    Tree: { id: 'Tree', path: 'Tree' }
+                }
             }
@@ -146,3 +146,3 @@ });
         test.deepEqual(calls, ['prepare', 'validate', 'synthesize']);
-        const stack = assembly.getStack('art');
+        const stack = assembly.getStackByName('art');
         test.deepEqual(stack.template, { hello: 123 });
@@ -155,2 +155,2 @@ test.deepEqual(stack.templateFile, 'hey.json');
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.synthesis.js","sourceRoot":"","sources":["test.synthesis.ts"],"names":[],"mappings":"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","sourcesContent":["import cxapi = require('@aws-cdk/cx-api');\nimport fs = require('fs');\nimport { Test } from 'nodeunit';\nimport os = require('os');\nimport path = require('path');\nimport cdk = require('../lib');\nimport { Construct, ConstructNode, ISynthesisSession } from '../lib';\n\nfunction createModernApp() {\n  return new cdk.App({\n    context: {\n      [cxapi.DISABLE_VERSION_REPORTING]: 'true', // for test reproducibility\n    }\n  });\n}\n\nexport = {\n  'synthesis with an empty app'(test: Test) {\n    // GIVEN\n    const app = createModernApp();\n\n    // WHEN\n    const session = app.synth();\n\n    // THEN\n    test.same(app.synth(), session); // same session if we synth() again\n    test.deepEqual(list(session.directory), [ 'cdk.out', 'manifest.json', 'tree.json' ]);\n    test.deepEqual(readJson(session.directory, 'manifest.json').artifacts, {\n      Tree: {\n        type: 'cdk:tree',\n        properties: { file: 'tree.json' }\n      }\n    });\n    test.deepEqual(readJson(session.directory, 'tree.json'), {\n      version: 'tree-0.1',\n      tree: {\n        id: 'App',\n        path: '',\n        children: [\n          { id: 'Tree', path: 'Tree' }\n        ]\n      }\n    });\n    test.done();\n  },\n\n  'synthesis respects disabling tree metadata'(test: Test) {\n    const app = new cdk.App({\n      treeMetadata: false,\n    });\n    const assembly = app.synth();\n    test.deepEqual(list(assembly.directory), [ 'cdk.out', 'manifest.json' ]);\n    test.done();\n  },\n\n  'single empty stack'(test: Test) {\n    // GIVEN\n    const app = createModernApp();\n    new cdk.Stack(app, 'one-stack');\n\n    // WHEN\n    const session = app.synth();\n\n    // THEN\n    test.ok(list(session.directory).includes('one-stack.template.json'));\n    test.done();\n  },\n\n  'some random construct implements \"synthesize\"'(test: Test) {\n    // GIVEN\n    const app = createModernApp();\n    const stack = new cdk.Stack(app, 'one-stack');\n\n    class MyConstruct extends cdk.Construct {\n      protected synthesize(s: ISynthesisSession) {\n        writeJson(s.assembly.outdir, 'foo.json', { bar: 123 });\n        s.assembly.addArtifact('my-random-construct', {\n          type: cxapi.ArtifactType.AWS_CLOUDFORMATION_STACK,\n          environment: 'aws://12345/bar',\n          properties: {\n            templateFile: 'foo.json'\n          }\n        });\n      }\n    }\n\n    new MyConstruct(stack, 'MyConstruct');\n\n    // WHEN\n    const session = app.synth();\n\n    // THEN\n    test.ok(list(session.directory).includes('one-stack.template.json'));\n    test.ok(list(session.directory).includes('foo.json'));\n\n    test.deepEqual(readJson(session.directory, 'foo.json'), { bar: 123 });\n    test.deepEqual(session.manifest, {\n      version: cxapi.CLOUD_ASSEMBLY_VERSION,\n      artifacts: {\n        'Tree': {\n          type: 'cdk:tree',\n          properties: { file: 'tree.json' }\n        },\n        'my-random-construct': {\n          type: 'aws:cloudformation:stack',\n          environment: 'aws://12345/bar',\n          properties: { templateFile: 'foo.json' }\n        },\n        'one-stack': {\n          type: 'aws:cloudformation:stack',\n          environment: 'aws://unknown-account/unknown-region',\n          properties: { templateFile: 'one-stack.template.json' },\n        }\n      },\n    });\n    test.done();\n  },\n\n  'it should be possible to synthesize without an app'(test: Test) {\n    const calls = new Array<string>();\n\n    class SynthesizeMe extends Construct {\n      constructor() {\n        super(undefined as any, 'id');\n      }\n\n      protected synthesize(session: ISynthesisSession) {\n        calls.push('synthesize');\n\n        session.assembly.addArtifact('art', {\n          type: cxapi.ArtifactType.AWS_CLOUDFORMATION_STACK,\n          properties: {\n            templateFile: 'hey.json',\n            parameters: {\n              paramId: 'paramValue',\n              paramId2: 'paramValue2'\n            }\n          },\n          environment: 'aws://unknown-account/us-east-1'\n        });\n\n        writeJson(session.assembly.outdir, 'hey.json', { hello: 123 });\n      }\n\n      protected validate(): string[] {\n        calls.push('validate');\n        return [];\n      }\n\n      protected prepare(): void {\n        calls.push('prepare');\n      }\n    }\n\n    const root = new SynthesizeMe();\n    const assembly = ConstructNode.synth(root.node, { outdir: fs.mkdtempSync(path.join(os.tmpdir(), 'outdir')) });\n\n    test.deepEqual(calls, [ 'prepare', 'validate', 'synthesize' ]);\n    const stack = assembly.getStack('art');\n    test.deepEqual(stack.template, { hello: 123 });\n    test.deepEqual(stack.templateFile, 'hey.json');\n    test.deepEqual(stack.parameters, { paramId: 'paramValue', paramId2: 'paramValue2' });\n    test.deepEqual(stack.environment, { region: 'us-east-1', account: 'unknown-account', name: 'aws://unknown-account/us-east-1' });\n    test.done();\n  },\n};\n\nfunction list(outdir: string) {\n  return fs.readdirSync(outdir).sort();\n}\n\nfunction readJson(outdir: string, file: string) {\n  return JSON.parse(fs.readFileSync(path.join(outdir, file), 'utf-8'));\n}\n\nfunction writeJson(outdir: string, file: string, data: any) {\n  fs.writeFileSync(path.join(outdir, file), JSON.stringify(data, undefined, 2));\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.synthesis.js","sourceRoot":"","sources":["test.synthesis.ts"],"names":[],"mappings":"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","sourcesContent":["import cxapi = require('@aws-cdk/cx-api');\nimport fs = require('fs');\nimport { Test } from 'nodeunit';\nimport os = require('os');\nimport path = require('path');\nimport cdk = require('../lib');\nimport { Construct, ConstructNode, ISynthesisSession } from '../lib';\n\nfunction createModernApp() {\n  return new cdk.App({\n    context: {\n      [cxapi.DISABLE_VERSION_REPORTING]: 'true', // for test reproducibility\n    }\n  });\n}\n\nexport = {\n  'synthesis with an empty app'(test: Test) {\n    // GIVEN\n    const app = createModernApp();\n\n    // WHEN\n    const session = app.synth();\n\n    // THEN\n    test.same(app.synth(), session); // same session if we synth() again\n    test.deepEqual(list(session.directory), [ 'cdk.out', 'manifest.json', 'tree.json' ]);\n    test.deepEqual(readJson(session.directory, 'manifest.json').artifacts, {\n      Tree: {\n        type: 'cdk:tree',\n        properties: { file: 'tree.json' }\n      }\n    });\n    test.deepEqual(readJson(session.directory, 'tree.json'), {\n      version: 'tree-0.1',\n      tree: {\n        id: 'App',\n        path: '',\n        children: {\n          Tree: { id: 'Tree', path: 'Tree' }\n        }\n      }\n    });\n    test.done();\n  },\n\n  'synthesis respects disabling tree metadata'(test: Test) {\n    const app = new cdk.App({\n      treeMetadata: false,\n    });\n    const assembly = app.synth();\n    test.deepEqual(list(assembly.directory), [ 'cdk.out', 'manifest.json' ]);\n    test.done();\n  },\n\n  'single empty stack'(test: Test) {\n    // GIVEN\n    const app = createModernApp();\n    new cdk.Stack(app, 'one-stack');\n\n    // WHEN\n    const session = app.synth();\n\n    // THEN\n    test.ok(list(session.directory).includes('one-stack.template.json'));\n    test.done();\n  },\n\n  'some random construct implements \"synthesize\"'(test: Test) {\n    // GIVEN\n    const app = createModernApp();\n    const stack = new cdk.Stack(app, 'one-stack');\n\n    class MyConstruct extends cdk.Construct {\n      protected synthesize(s: ISynthesisSession) {\n        writeJson(s.assembly.outdir, 'foo.json', { bar: 123 });\n        s.assembly.addArtifact('my-random-construct', {\n          type: cxapi.ArtifactType.AWS_CLOUDFORMATION_STACK,\n          environment: 'aws://12345/bar',\n          properties: {\n            templateFile: 'foo.json'\n          }\n        });\n      }\n    }\n\n    new MyConstruct(stack, 'MyConstruct');\n\n    // WHEN\n    const session = app.synth();\n\n    // THEN\n    test.ok(list(session.directory).includes('one-stack.template.json'));\n    test.ok(list(session.directory).includes('foo.json'));\n\n    test.deepEqual(readJson(session.directory, 'foo.json'), { bar: 123 });\n    test.deepEqual(session.manifest, {\n      version: cxapi.CLOUD_ASSEMBLY_VERSION,\n      artifacts: {\n        'Tree': {\n          type: 'cdk:tree',\n          properties: { file: 'tree.json' }\n        },\n        'my-random-construct': {\n          type: 'aws:cloudformation:stack',\n          environment: 'aws://12345/bar',\n          properties: { templateFile: 'foo.json' }\n        },\n        'one-stack': {\n          type: 'aws:cloudformation:stack',\n          environment: 'aws://unknown-account/unknown-region',\n          properties: { templateFile: 'one-stack.template.json' },\n        }\n      },\n    });\n    test.done();\n  },\n\n  'it should be possible to synthesize without an app'(test: Test) {\n    const calls = new Array<string>();\n\n    class SynthesizeMe extends Construct {\n      constructor() {\n        super(undefined as any, 'id');\n      }\n\n      protected synthesize(session: ISynthesisSession) {\n        calls.push('synthesize');\n\n        session.assembly.addArtifact('art', {\n          type: cxapi.ArtifactType.AWS_CLOUDFORMATION_STACK,\n          properties: {\n            templateFile: 'hey.json',\n            parameters: {\n              paramId: 'paramValue',\n              paramId2: 'paramValue2'\n            }\n          },\n          environment: 'aws://unknown-account/us-east-1'\n        });\n\n        writeJson(session.assembly.outdir, 'hey.json', { hello: 123 });\n      }\n\n      protected validate(): string[] {\n        calls.push('validate');\n        return [];\n      }\n\n      protected prepare(): void {\n        calls.push('prepare');\n      }\n    }\n\n    const root = new SynthesizeMe();\n    const assembly = ConstructNode.synth(root.node, { outdir: fs.mkdtempSync(path.join(os.tmpdir(), 'outdir')) });\n\n    test.deepEqual(calls, [ 'prepare', 'validate', 'synthesize' ]);\n    const stack = assembly.getStackByName('art');\n    test.deepEqual(stack.template, { hello: 123 });\n    test.deepEqual(stack.templateFile, 'hey.json');\n    test.deepEqual(stack.parameters, { paramId: 'paramValue', paramId2: 'paramValue2' });\n    test.deepEqual(stack.environment, { region: 'us-east-1', account: 'unknown-account', name: 'aws://unknown-account/us-east-1' });\n    test.done();\n  },\n};\n\nfunction list(outdir: string) {\n  return fs.readdirSync(outdir).sort();\n}\n\nfunction readJson(outdir: string, file: string) {\n  return JSON.parse(fs.readFileSync(path.join(outdir, file), 'utf-8'));\n}\n\nfunction writeJson(outdir: string, file: string, data: any) {\n  fs.writeFileSync(path.join(outdir, file), JSON.stringify(data, undefined, 2));\n}"]}

test/test.tokens.d.ts

@@ -44,3 +44,11 @@ import { Test } from 'nodeunit';
     'creation stack is attached to errors emitted during resolve'(test: Test): void;
+    'stringifyNumber': {
+        'converts number to string'(test: Test): void;
+        'converts tokenized number to string'(test: Test): void;
+        'string remains the same'(test: Test): void;
+        'Ref remains the same'(test: Test): void;
+        'lazy Ref remains the same'(test: Test): void;
+        'tokenized Ref remains the same'(test: Test): void;
+    };
 };
 export = _default;

test/util.js

@@ -5,5 +5,5 @@ "use strict";
 function toCloudFormation(stack) {
-    return lib_1.ConstructNode.synth(stack.node, { skipValidation: true }).getStack(stack.stackName).template;
+    return lib_1.ConstructNode.synth(stack.node, { skipValidation: true }).getStackByName(stack.stackName).template;
 }
 exports.toCloudFormation = toCloudFormation;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxnQ0FBOEM7QUFFOUMsU0FBZ0IsZ0JBQWdCLENBQUMsS0FBWTtJQUMzQyxPQUFPLG1CQUFhLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsRUFBRSxjQUFjLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDLFFBQVEsQ0FBQztBQUN0RyxDQUFDO0FBRkQsNENBRUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb25zdHJ1Y3ROb2RlLCBTdGFjayB9IGZyb20gJy4uL2xpYic7XG5cbmV4cG9ydCBmdW5jdGlvbiB0b0Nsb3VkRm9ybWF0aW9uKHN0YWNrOiBTdGFjayk6IGFueSB7XG4gIHJldHVybiBDb25zdHJ1Y3ROb2RlLnN5bnRoKHN0YWNrLm5vZGUsIHsgc2tpcFZhbGlkYXRpb246IHRydWUgfSkuZ2V0U3RhY2soc3RhY2suc3RhY2tOYW1lKS50ZW1wbGF0ZTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxnQ0FBOEM7QUFFOUMsU0FBZ0IsZ0JBQWdCLENBQUMsS0FBWTtJQUMzQyxPQUFPLG1CQUFhLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsRUFBRSxjQUFjLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDLFFBQVEsQ0FBQztBQUM1RyxDQUFDO0FBRkQsNENBRUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb25zdHJ1Y3ROb2RlLCBTdGFjayB9IGZyb20gJy4uL2xpYic7XG5cbmV4cG9ydCBmdW5jdGlvbiB0b0Nsb3VkRm9ybWF0aW9uKHN0YWNrOiBTdGFjayk6IGFueSB7XG4gIHJldHVybiBDb25zdHJ1Y3ROb2RlLnN5bnRoKHN0YWNrLm5vZGUsIHsgc2tpcFZhbGlkYXRpb246IHRydWUgfSkuZ2V0U3RhY2tCeU5hbWUoc3RhY2suc3RhY2tOYW1lKS50ZW1wbGF0ZTtcbn1cbiJdfQ==

tsconfig.json

@@ -42,2 +42,5 @@ {
     {
+      "path": "../../../tools/cfn2ts"
+    },
+    {
       "path": "../../../tools/pkglint"
@@ -44,0 +47,0 @@ }

No alert changes

Improved metrics

Total package byte prevSize

2146892

increased by2.14%

Number of package files

174

increased by1.16%

Lines of code

15977

increased by2.15%

Number of low supply chain risk alerts

14

decreased by-12.5%

Dependency changes

• + Added@aws-cdk/cx-api@1.16.0(transitive)

• - Removed@aws-cdk/cx-api@1.15.0(transitive)

• Updated@aws-cdk/cx-api@1.16.0