@aws-cdk/core/lib/private/cfn-reference.js

AWS Cloud Development Kit Core Library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CfnReference = exports.ReferenceRendering = void 0;
const reference_1 = require("../reference");
const CFN_REFERENCE_SYMBOL = Symbol.for('@aws-cdk/core.CfnReference');
/**
 * An enum that allows controlling how will the created reference
 * be rendered in the resulting CloudFormation template.
 */
var ReferenceRendering;
(function (ReferenceRendering) {
    /**
     * Used for rendering a reference inside Fn::Sub expressions,
     * which mean these must resolve to "${Sth}" instead of { Ref: "Sth" }.
     */
    ReferenceRendering[ReferenceRendering["FN_SUB"] = 0] = "FN_SUB";
    /**
     * Used for rendering Fn::GetAtt with its arguments in string form
     * (as opposed to the more common arguments in array form, which we render by default).
     */
    ReferenceRendering[ReferenceRendering["GET_ATT_STRING"] = 1] = "GET_ATT_STRING";
})(ReferenceRendering = exports.ReferenceRendering || (exports.ReferenceRendering = {}));
/**
 * A Token that represents a CloudFormation reference to another resource
 *
 * If these references are used in a different stack from where they are
 * defined, appropriate CloudFormation `Export`s and `Fn::ImportValue`s will be
 * synthesized automatically instead of the regular CloudFormation references.
 *
 * Additionally, the dependency between the stacks will be recorded, and the toolkit
 * will make sure to deploy producing stack before the consuming stack.
 *
 * This magic happens in the prepare() phase, where consuming stacks will call
 * `consumeFromStack` on these Tokens and if they happen to be exported by a different
 * Stack, we'll register the dependency.
 */
class CfnReference extends reference_1.Reference {
    constructor(value, displayName, target) {
        // prepend scope path to display name
        super(value, target, displayName);
        this.replacementTokens = new Map();
        this.targetStack = stack_1.Stack.of(target);
        Object.defineProperty(this, CFN_REFERENCE_SYMBOL, { value: true });
    }
    /**
     * Check whether this is actually a Reference
     */
    static isCfnReference(x) {
        return CFN_REFERENCE_SYMBOL in x;
    }
    /**
     * Return the CfnReference for the indicated target
     *
     * Will make sure that multiple invocations for the same target and intrinsic
     * return the same CfnReference. Because CfnReferences accumulate state in
     * the prepare() phase (for the purpose of cross-stack references), it's
     * important that the state isn't lost if it's lazily created, like so:
     *
     *     Lazy.stringValue({ produce: () => new CfnReference(...) })
     *
     */
    static for(target, attribute, refRender) {
        return CfnReference.singletonReference(target, attribute, refRender, () => {
            const cfnIntrinsic = refRender === ReferenceRendering.FN_SUB
                ? ('${' + target.logicalId + (attribute === 'Ref' ? '' : `.${attribute}`) + '}')
                : (attribute === 'Ref'
                    ? { Ref: target.logicalId }
                    : {
                        'Fn::GetAtt': refRender === ReferenceRendering.GET_ATT_STRING
                            ? `${target.logicalId}.${attribute}`
                            : [target.logicalId, attribute],
                    });
            return new CfnReference(cfnIntrinsic, attribute, target);
        });
    }
    /**
     * Return a CfnReference that references a pseudo referencd
     */
    static forPseudo(pseudoName, scope) {
        return CfnReference.singletonReference(scope, `Pseudo:${pseudoName}`, undefined, () => {
            const cfnIntrinsic = { Ref: pseudoName };
            return new CfnReference(cfnIntrinsic, pseudoName, scope);
        });
    }
    /**
     * Get or create the table.
     * Passing fnSub = true allows cloudformation-include to correctly handle Fn::Sub.
     */
    static singletonReference(target, attribKey, refRender, fresh) {
        let attribs = CfnReference.referenceTable.get(target);
        if (!attribs) {
            attribs = new Map();
            CfnReference.referenceTable.set(target, attribs);
        }
        let cacheKey = attribKey;
        switch (refRender) {
            case ReferenceRendering.FN_SUB:
                cacheKey += 'Fn::Sub';
                break;
            case ReferenceRendering.GET_ATT_STRING:
                cacheKey += 'Fn::GetAtt::String';
                break;
        }
        let ref = attribs.get(cacheKey);
        if (!ref) {
            ref = fresh();
            attribs.set(cacheKey, ref);
        }
        return ref;
    }
    resolve(context) {
        // If we have a special token for this consuming stack, resolve that. Otherwise resolve as if
        // we are in the same stack.
        const consumingStack = stack_1.Stack.of(context.scope);
        const token = this.replacementTokens.get(consumingStack);
        // if (!token && this.isCrossStackReference(consumingStack) && !context.preparing) {
        // eslint-disable-next-line max-len
        //   throw new Error(`Cross-stack reference (${context.scope.node.path} -> ${this.target.node.path}) has not been assigned a value--call prepare() first`);
        // }
        if (token) {
            return token.resolve(context);
        }
        else {
            return super.resolve(context);
        }
    }
    hasValueForStack(stack) {
        if (stack === this.targetStack) {
            return true;
        }
        return this.replacementTokens.has(stack);
    }
    assignValueForStack(stack, value) {
        if (stack === this.targetStack) {
            throw new Error('cannot assign a value for the same stack');
        }
        if (this.hasValueForStack(stack)) {
            throw new Error('Cannot assign a reference value twice to the same stack. Use hasValueForStack to check first');
        }
        this.replacementTokens.set(stack, value);
    }
    /**
     * Implementation of toString() that will use the display name
     */
    toString() {
        return token_1.Token.asString(this, {
            displayHint: `${this.target.node.id}.${this.displayName}`,
        });
    }
}
exports.CfnReference = CfnReference;
/**
 * Static table where we keep singleton CfnReference instances
 */
CfnReference.referenceTable = new Map();
const stack_1 = require("../stack");
const token_1 = require("../token");
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cfn-reference.js","sourceRoot":"","sources":["cfn-reference.ts"],"names":[],"mappings":"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","sourcesContent":["import { Reference } from '../reference';\n\nconst CFN_REFERENCE_SYMBOL = Symbol.for('@aws-cdk/core.CfnReference');\n\n/**\n * An enum that allows controlling how will the created reference\n * be rendered in the resulting CloudFormation template.\n */\nexport enum ReferenceRendering {\n  /**\n   * Used for rendering a reference inside Fn::Sub expressions,\n   * which mean these must resolve to \"${Sth}\" instead of { Ref: \"Sth\" }.\n   */\n  FN_SUB,\n\n  /**\n   * Used for rendering Fn::GetAtt with its arguments in string form\n   * (as opposed to the more common arguments in array form, which we render by default).\n   */\n  GET_ATT_STRING,\n}\n\n/**\n * A Token that represents a CloudFormation reference to another resource\n *\n * If these references are used in a different stack from where they are\n * defined, appropriate CloudFormation `Export`s and `Fn::ImportValue`s will be\n * synthesized automatically instead of the regular CloudFormation references.\n *\n * Additionally, the dependency between the stacks will be recorded, and the toolkit\n * will make sure to deploy producing stack before the consuming stack.\n *\n * This magic happens in the prepare() phase, where consuming stacks will call\n * `consumeFromStack` on these Tokens and if they happen to be exported by a different\n * Stack, we'll register the dependency.\n */\nexport class CfnReference extends Reference {\n  /**\n   * Check whether this is actually a Reference\n   */\n  public static isCfnReference(x: IResolvable): x is CfnReference {\n    return CFN_REFERENCE_SYMBOL in x;\n  }\n\n  /**\n   * Return the CfnReference for the indicated target\n   *\n   * Will make sure that multiple invocations for the same target and intrinsic\n   * return the same CfnReference. Because CfnReferences accumulate state in\n   * the prepare() phase (for the purpose of cross-stack references), it's\n   * important that the state isn't lost if it's lazily created, like so:\n   *\n   *     Lazy.stringValue({ produce: () => new CfnReference(...) })\n   *\n   */\n  public static for(target: CfnElement, attribute: string, refRender?: ReferenceRendering) {\n    return CfnReference.singletonReference(target, attribute, refRender, () => {\n      const cfnIntrinsic = refRender === ReferenceRendering.FN_SUB\n        ? ('${' + target.logicalId + (attribute === 'Ref' ? '' : `.${attribute}`) + '}')\n        : (attribute === 'Ref'\n          ? { Ref: target.logicalId }\n          : {\n            'Fn::GetAtt': refRender === ReferenceRendering.GET_ATT_STRING\n              ? `${target.logicalId}.${attribute}`\n              : [target.logicalId, attribute],\n          }\n        );\n      return new CfnReference(cfnIntrinsic, attribute, target);\n    });\n  }\n\n  /**\n   * Return a CfnReference that references a pseudo referencd\n   */\n  public static forPseudo(pseudoName: string, scope: Construct) {\n    return CfnReference.singletonReference(scope, `Pseudo:${pseudoName}`, undefined, () => {\n      const cfnIntrinsic = { Ref: pseudoName };\n      return new CfnReference(cfnIntrinsic, pseudoName, scope);\n    });\n  }\n\n  /**\n   * Static table where we keep singleton CfnReference instances\n   */\n  private static referenceTable = new Map<Construct, Map<string, CfnReference>>();\n\n  /**\n   * Get or create the table.\n   * Passing fnSub = true allows cloudformation-include to correctly handle Fn::Sub.\n   */\n  private static singletonReference(target: Construct, attribKey: string, refRender: ReferenceRendering | undefined, fresh: () => CfnReference) {\n    let attribs = CfnReference.referenceTable.get(target);\n    if (!attribs) {\n      attribs = new Map();\n      CfnReference.referenceTable.set(target, attribs);\n    }\n    let cacheKey = attribKey;\n    switch (refRender) {\n      case ReferenceRendering.FN_SUB:\n        cacheKey += 'Fn::Sub';\n        break;\n      case ReferenceRendering.GET_ATT_STRING:\n        cacheKey += 'Fn::GetAtt::String';\n        break;\n    }\n    let ref = attribs.get(cacheKey);\n    if (!ref) {\n      ref = fresh();\n      attribs.set(cacheKey, ref);\n    }\n    return ref;\n  }\n\n  /**\n   * The Tokens that should be returned for each consuming stack (as decided by the producing Stack)\n   */\n  private readonly replacementTokens: Map<Stack, IResolvable>;\n  private readonly targetStack: Stack;\n\n  protected constructor(value: any, displayName: string, target: IConstruct) {\n    // prepend scope path to display name\n    super(value, target, displayName);\n\n    this.replacementTokens = new Map<Stack, IResolvable>();\n    this.targetStack = Stack.of(target);\n\n    Object.defineProperty(this, CFN_REFERENCE_SYMBOL, { value: true });\n  }\n\n  public resolve(context: IResolveContext): any {\n    // If we have a special token for this consuming stack, resolve that. Otherwise resolve as if\n    // we are in the same stack.\n    const consumingStack = Stack.of(context.scope);\n    const token = this.replacementTokens.get(consumingStack);\n\n    // if (!token && this.isCrossStackReference(consumingStack) && !context.preparing) {\n    // eslint-disable-next-line max-len\n    //   throw new Error(`Cross-stack reference (${context.scope.node.path} -> ${this.target.node.path}) has not been assigned a value--call prepare() first`);\n    // }\n\n    if (token) {\n      return token.resolve(context);\n    } else {\n      return super.resolve(context);\n    }\n  }\n\n  public hasValueForStack(stack: Stack) {\n    if (stack === this.targetStack) {\n      return true;\n    }\n\n    return this.replacementTokens.has(stack);\n  }\n\n  public assignValueForStack(stack: Stack, value: IResolvable) {\n    if (stack === this.targetStack) {\n      throw new Error('cannot assign a value for the same stack');\n    }\n\n    if (this.hasValueForStack(stack)) {\n      throw new Error('Cannot assign a reference value twice to the same stack. Use hasValueForStack to check first');\n    }\n\n    this.replacementTokens.set(stack, value);\n  }\n  /**\n   * Implementation of toString() that will use the display name\n   */\n  public toString(): string {\n    return Token.asString(this, {\n      displayHint: `${this.target.node.id}.${this.displayName}`,\n    });\n  }\n}\n\nimport { CfnElement } from '../cfn-element';\nimport { Construct, IConstruct } from '../construct-compat';\nimport { IResolvable, IResolveContext } from '../resolvable';\nimport { Stack } from '../stack';\nimport { Token } from '../token';\n"]}