@aws-cdk/core
Version:
AWS Cloud Development Kit Core Library
437 lines • 49.4 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.isNameOfCloudFormationIntrinsic = exports.minimalCloudFormationJoin = exports.CLOUDFORMATION_TOKEN_RESOLVER = exports.CloudFormationLang = void 0;
const lazy_1 = require("../lazy");
const resolvable_1 = require("../resolvable");
const stack_1 = require("../stack");
const token_1 = require("../token");
const cfn_utils_provider_1 = require("./cfn-utils-provider");
const resolve_1 = require("./resolve");
/**
* Routines that know how to do operations at the CloudFormation document language level
*/
class CloudFormationLang {
/**
* Turn an arbitrary structure potentially containing Tokens into a JSON string.
*
* Returns a Token which will evaluate to CloudFormation expression that
* will be evaluated by CloudFormation to the JSON representation of the
* input structure.
*
* All Tokens substituted in this way must return strings, or the evaluation
* in CloudFormation will fail.
*
* @param obj The object to stringify
* @param space Indentation to use (default: no pretty-printing)
*/
static toJSON(obj, space) {
return lazy_1.Lazy.uncachedString({
// We used to do this by hooking into `JSON.stringify()` by adding in objects
// with custom `toJSON()` functions, but it's ultimately simpler just to
// reimplement the `stringify()` function from scratch.
produce: (ctx) => tokenAwareStringify(obj, space ?? 0, ctx),
});
}
/**
* Produce a CloudFormation expression to concat two arbitrary expressions when resolving
*/
static concat(left, right) {
if (left === undefined && right === undefined) {
return '';
}
const parts = new Array();
if (left !== undefined) {
parts.push(left);
}
if (right !== undefined) {
parts.push(right);
}
// Some case analysis to produce minimal expressions
if (parts.length === 1) {
return parts[0];
}
if (parts.length === 2 && isConcatable(parts[0]) && isConcatable(parts[1])) {
return `${parts[0]}${parts[1]}`;
}
// Otherwise return a Join intrinsic (already in the target document language to avoid taking
// circular dependencies on FnJoin & friends)
return fnJoinConcat(parts);
}
}
exports.CloudFormationLang = CloudFormationLang;
/**
* Return a CFN intrinsic mass concatting any number of CloudFormation expressions
*/
function fnJoinConcat(parts) {
return { 'Fn::Join': ['', minimalCloudFormationJoin('', parts)] };
}
/**
* Perform a JSON.stringify()-like operation, except aware of Tokens and CloudFormation intrincics
*
* Tokens will be resolved and if any resolve to CloudFormation intrinsics, the intrinsics
* will be lifted to the top of a giant `{ Fn::Join }` expression.
*
* If Tokens resolve to primitive types (for example, by using Lazies), we'll
* use the primitive type to determine how to encode the value into the JSON.
*
* If Tokens resolve to CloudFormation intrinsics, we'll use the type of the encoded
* value as a type hint to determine how to encode the value into the JSON. The difference
* is that we add quotes (") around strings, and don't add anything around non-strings.
*
* The following structure:
*
* { SomeAttr: resource.someAttr }
*
* Will JSONify to either:
*
* '{ "SomeAttr": "' ++ { Fn::GetAtt: [Resource, SomeAttr] } ++ '" }'
* or '{ "SomeAttr": ' ++ { Fn::GetAtt: [Resource, SomeAttr] } ++ ' }'
*
* Depending on whether `someAttr` is type-hinted to be a string or not.
*
* (Where ++ is the CloudFormation string-concat operation (`{ Fn::Join }`).
*
* -----------------------
*
* This work requires 2 features from the `resolve()` function:
*
* - INTRINSICS TYPE HINTS: intrinsics are represented by values like
* `{ Ref: 'XYZ' }`. These values can reference either a string or a list/number at
* deploy time, and from the value alone there's no way to know which. We need
* to know the type to know whether to JSONify this reference to:
*
* '{ "referencedValue": "' ++ { Ref: XYZ } ++ '"}'
* or '{ "referencedValue": ' ++ { Ref: XYZ } ++ '}'
*
* I.e., whether or not we need to enclose the reference in quotes or not.
*
* We COULD have done this by resolving one token at a time, and looking at the
* type of the encoded token we were resolving to obtain a type hint. However,
* the `resolve()` and Token system resist a level-at-a-time resolve
* operation: because of the existence of post-processors, we must have done a
* complete recursive resolution of a token before we can look at its result
* (after which any type information about the sources of nested resolved
* values is lost).
*
* To fix this, "type hints" have been added to the `resolve()` function,
* giving an idea of the type of the source value for compplex result values.
* This only works for objects (not strings and numbers) but fortunately
* we only care about the types of intrinsics, which are always complex values.
*
* Type hinting could have been added to the `IResolvable` protocol as well,
* but for now we just use the type of an encoded value as a type hint. That way
* we don't need to annotate anything more at the L1 level--we will use the type
* encodings added by construct authors at the L2 levels. L1 users can escape the
* default decision of "string" by using `Token.asList()`.
*
* - COMPLEX KEYS: since tokens can be string-encoded, we can use string-encoded tokens
* as the keys in JavaScript objects. However, after resolution, those string-encoded
* tokens could resolve to intrinsics (`{ Ref: ... }`), which CANNOT be stored in
* JavaScript objects anymore.
*
* We therefore need a protocol to store the resolved values somewhere in the JavaScript
* type model, which can be returned by `resolve()`, and interpreted by `tokenAwareStringify()`
* to produce the correct JSON.
*
* And example will quickly show the point:
*
* User writes:
* { [resource.resourceName]: 'SomeValue' }
* ------ string actually looks like ------>
* { '${Token[1234]}': 'SomeValue' }
* ------ resolve ------->
* { '$IntrinsicKey$0': [ {Ref: Resource}, 'SomeValue' ] }
* ------ tokenAwareStringify ------->
* '{ "' ++ { Ref: Resource } ++ '": "SomeValue" }'
*/
function tokenAwareStringify(root, space, ctx) {
let indent = 0;
const ret = new Array();
// First completely resolve the tree, then encode to JSON while respecting the type
// hints we got for the resolved intrinsics.
recurse(ctx.resolve(root, { allowIntrinsicKeys: true }));
switch (ret.length) {
case 0: return undefined;
case 1: return renderSegment(ret[0]);
default:
return fnJoinConcat(ret.map(renderSegment));
}
/**
* Stringify a JSON element
*/
function recurse(obj) {
if (obj === undefined) {
return;
}
if (token_1.Token.isUnresolved(obj)) {
throw new Error('This shouldnt happen anymore');
}
if (Array.isArray(obj)) {
return renderCollection('[', ']', obj, recurse);
}
if (typeof obj === 'object' && obj != null && !(obj instanceof Date)) {
// Treat as an intrinsic if this LOOKS like a CFN intrinsic (`{ Ref: ... }`)
// AND it's the result of a token resolution. Otherwise, we just treat this
// value as a regular old JSON object (that happens to look a lot like an intrinsic).
if (isIntrinsic(obj) && resolve_1.resolvedTypeHint(obj)) {
renderIntrinsic(obj);
return;
}
return renderCollection('{', '}', definedEntries(obj), ([key, value]) => {
if (key.startsWith(resolve_1.INTRINSIC_KEY_PREFIX)) {
[key, value] = value;
}
recurse(key);
pushLiteral(prettyPunctuation(':'));
recurse(value);
});
}
// Otherwise we have a scalar, defer to JSON.stringify()s serialization
pushLiteral(JSON.stringify(obj));
}
/**
* Render an object or list
*/
function renderCollection(pre, post, xs, each) {
pushLiteral(pre);
indent += space;
let atLeastOne = false;
for (const [comma, item] of sepIter(xs)) {
if (comma) {
pushLiteral(',');
}
pushLineBreak();
each(item);
atLeastOne = true;
}
indent -= space;
if (atLeastOne) {
pushLineBreak();
}
pushLiteral(post);
}
function renderIntrinsic(intrinsic) {
switch (resolve_1.resolvedTypeHint(intrinsic)) {
case resolve_1.ResolutionTypeHint.STRING:
pushLiteral('"');
pushIntrinsic(deepQuoteStringLiterals(intrinsic));
pushLiteral('"');
return;
case resolve_1.ResolutionTypeHint.LIST:
// We need this to look like:
//
// '{"listValue":' ++ STRINGIFY(CFN_EVAL({ Ref: MyList })) ++ '}'
//
// However, STRINGIFY would need to execute at CloudFormation deployment time, and that doesn't exist.
//
// We could *ALMOST* use:
//
// '{"listValue":["' ++ JOIN('","', { Ref: MyList }) ++ '"]}'
//
// But that has the unfortunate side effect that if `CFN_EVAL({ Ref: MyList }) == []`, then it would
// evaluate to `[""]`, which is a different value. Since CloudFormation does not have arbitrary
// conditionals there's no way to deal with this case properly.
//
// Therefore, if we encounter lists we need to defer to a custom resource to handle
// them properly at deploy time.
const stack = stack_1.Stack.of(ctx.scope);
// Because this will be called twice (once during `prepare`, once during `resolve`),
// we need to make sure to be idempotent, so use a cache.
const stringifyResponse = stringifyCache.obtain(stack, JSON.stringify(intrinsic), () => cfn_utils_provider_1.CfnUtils.stringify(stack, `CdkJsonStringify${stringifyCounter++}`, intrinsic));
pushIntrinsic(stringifyResponse);
return;
case resolve_1.ResolutionTypeHint.NUMBER:
pushIntrinsic(intrinsic);
return;
}
throw new Error(`Unexpected type hint: ${resolve_1.resolvedTypeHint(intrinsic)}`);
}
/**
* Push a literal onto the current segment if it's also a literal, otherwise open a new Segment
*/
function pushLiteral(lit) {
let last = ret[ret.length - 1];
if (last?.type !== 'literal') {
last = { type: 'literal', parts: [] };
ret.push(last);
}
last.parts.push(lit);
}
/**
* Add a new intrinsic segment
*/
function pushIntrinsic(intrinsic) {
ret.push({ type: 'intrinsic', intrinsic });
}
/**
* Push a line break if we are pretty-printing, otherwise don't
*/
function pushLineBreak() {
if (space > 0) {
pushLiteral(`\n${' '.repeat(indent)}`);
}
}
/**
* Add a space after the punctuation if we are pretty-printing, no space if not
*/
function prettyPunctuation(punc) {
return space > 0 ? `${punc} ` : punc;
}
}
/**
* Render a segment
*/
function renderSegment(s) {
switch (s.type) {
case 'literal': return s.parts.join('');
case 'intrinsic': return s.intrinsic;
}
}
const CLOUDFORMATION_CONCAT = {
join(left, right) {
return CloudFormationLang.concat(left, right);
},
};
/**
* Default Token resolver for CloudFormation templates
*/
exports.CLOUDFORMATION_TOKEN_RESOLVER = new resolvable_1.DefaultTokenResolver(CLOUDFORMATION_CONCAT);
/**
* Do an intelligent CloudFormation join on the given values, producing a minimal expression
*/
function minimalCloudFormationJoin(delimiter, values) {
let i = 0;
while (i < values.length) {
const el = values[i];
if (isSplicableFnJoinIntrinsic(el)) {
values.splice(i, 1, ...el['Fn::Join'][1]);
}
else if (i > 0 && isConcatable(values[i - 1]) && isConcatable(values[i])) {
values[i - 1] = `${values[i - 1]}${delimiter}${values[i]}`;
values.splice(i, 1);
}
else {
i += 1;
}
}
return values;
function isSplicableFnJoinIntrinsic(obj) {
if (!isIntrinsic(obj)) {
return false;
}
if (Object.keys(obj)[0] !== 'Fn::Join') {
return false;
}
const [delim, list] = obj['Fn::Join'];
if (delim !== delimiter) {
return false;
}
if (token_1.Token.isUnresolved(list)) {
return false;
}
if (!Array.isArray(list)) {
return false;
}
return true;
}
}
exports.minimalCloudFormationJoin = minimalCloudFormationJoin;
function isConcatable(obj) {
return ['string', 'number'].includes(typeof obj) && !token_1.Token.isUnresolved(obj);
}
/**
* Return whether the given value represents a CloudFormation intrinsic
*/
function isIntrinsic(x) {
if (Array.isArray(x) || x === null || typeof x !== 'object') {
return false;
}
const keys = Object.keys(x);
if (keys.length !== 1) {
return false;
}
return keys[0] === 'Ref' || isNameOfCloudFormationIntrinsic(keys[0]);
}
function isNameOfCloudFormationIntrinsic(name) {
if (!name.startsWith('Fn::')) {
return false;
}
// these are 'fake' intrinsics, only usable inside the parameter overrides of a CFN CodePipeline Action
return name !== 'Fn::GetArtifactAtt' && name !== 'Fn::GetParam';
}
exports.isNameOfCloudFormationIntrinsic = isNameOfCloudFormationIntrinsic;
/**
* Separated iterator
*/
function* sepIter(xs) {
let comma = false;
for (const item of xs) {
yield [comma, item];
comma = true;
}
}
/**
* Object.entries() but skipping undefined values
*/
function* definedEntries(xs) {
for (const [key, value] of Object.entries(xs)) {
if (value !== undefined) {
yield [key, value];
}
}
}
/**
* Quote string literals inside an intrinsic
*
* Formally, this should only match string literals that will be interpreted as
* string literals. Fortunately, the strings that should NOT be quoted are
* Logical IDs and attribute names, which cannot contain quotes anyway. Hence,
* we can get away not caring about the distinction and just quoting everything.
*/
function deepQuoteStringLiterals(x) {
if (Array.isArray(x)) {
return x.map(deepQuoteStringLiterals);
}
if (typeof x === 'object' && x != null) {
const ret = {};
for (const [key, value] of Object.entries(x)) {
ret[deepQuoteStringLiterals(key)] = deepQuoteStringLiterals(value);
}
return ret;
}
if (typeof x === 'string') {
return quoteString(x);
}
return x;
}
/**
* Quote the characters inside a string, for use inside toJSON
*/
function quoteString(s) {
s = JSON.stringify(s);
return s.substring(1, s.length - 1);
}
let stringifyCounter = 1;
/**
* A cache scoped to object instances, that's maintained externally to the object instances
*/
class ScopedCache {
constructor() {
this.cache = new WeakMap();
}
obtain(object, key, init) {
let kvMap = this.cache.get(object);
if (!kvMap) {
kvMap = new Map();
this.cache.set(object, kvMap);
}
let ret = kvMap.get(key);
if (ret === undefined) {
ret = init();
kvMap.set(key, ret);
}
return ret;
}
}
const stringifyCache = new ScopedCache();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudformation-lang.js","sourceRoot":"","sources":["cloudformation-lang.ts"],"names":[],"mappings":"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","sourcesContent":["import { Lazy } from '../lazy';\nimport { DefaultTokenResolver, IFragmentConcatenator, IResolveContext } from '../resolvable';\nimport { Stack } from '../stack';\nimport { Token } from '../token';\nimport { CfnUtils } from './cfn-utils-provider';\nimport { INTRINSIC_KEY_PREFIX, ResolutionTypeHint, resolvedTypeHint } from './resolve';\n\n/**\n * Routines that know how to do operations at the CloudFormation document language level\n */\nexport class CloudFormationLang {\n  /**\n   * Turn an arbitrary structure potentially containing Tokens into a JSON string.\n   *\n   * Returns a Token which will evaluate to CloudFormation expression that\n   * will be evaluated by CloudFormation to the JSON representation of the\n   * input structure.\n   *\n   * All Tokens substituted in this way must return strings, or the evaluation\n   * in CloudFormation will fail.\n   *\n   * @param obj The object to stringify\n   * @param space Indentation to use (default: no pretty-printing)\n   */\n  public static toJSON(obj: any, space?: number): string {\n    return Lazy.uncachedString({\n      // We used to do this by hooking into `JSON.stringify()` by adding in objects\n      // with custom `toJSON()` functions, but it's ultimately simpler just to\n      // reimplement the `stringify()` function from scratch.\n      produce: (ctx) => tokenAwareStringify(obj, space ?? 0, ctx),\n    });\n  }\n\n  /**\n   * Produce a CloudFormation expression to concat two arbitrary expressions when resolving\n   */\n  public static concat(left: any | undefined, right: any | undefined): any {\n    if (left === undefined && right === undefined) { return ''; }\n\n    const parts = new Array<any>();\n    if (left !== undefined) { parts.push(left); }\n    if (right !== undefined) { parts.push(right); }\n\n    // Some case analysis to produce minimal expressions\n    if (parts.length === 1) { return parts[0]; }\n    if (parts.length === 2 && isConcatable(parts[0]) && isConcatable(parts[1])) {\n      return `${parts[0]}${parts[1]}`;\n    }\n\n    // Otherwise return a Join intrinsic (already in the target document language to avoid taking\n    // circular dependencies on FnJoin & friends)\n    return fnJoinConcat(parts);\n  }\n}\n\n/**\n * Return a CFN intrinsic mass concatting any number of CloudFormation expressions\n */\nfunction fnJoinConcat(parts: any[]) {\n  return { 'Fn::Join': ['', minimalCloudFormationJoin('', parts)] };\n}\n\n/**\n * Perform a JSON.stringify()-like operation, except aware of Tokens and CloudFormation intrincics\n *\n * Tokens will be resolved and if any resolve to CloudFormation intrinsics, the intrinsics\n * will be lifted to the top of a giant `{ Fn::Join }` expression.\n *\n * If Tokens resolve to primitive types (for example, by using Lazies), we'll\n * use the primitive type to determine how to encode the value into the JSON.\n *\n * If Tokens resolve to CloudFormation intrinsics, we'll use the type of the encoded\n * value as a type hint to determine how to encode the value into the JSON. The difference\n * is that we add quotes (\") around strings, and don't add anything around non-strings.\n *\n * The following structure:\n *\n *    { SomeAttr: resource.someAttr }\n *\n * Will JSONify to either:\n *\n *    '{ \"SomeAttr\": \"' ++ { Fn::GetAtt: [Resource, SomeAttr] } ++ '\" }'\n * or '{ \"SomeAttr\": ' ++ { Fn::GetAtt: [Resource, SomeAttr] } ++ ' }'\n *\n * Depending on whether `someAttr` is type-hinted to be a string or not.\n *\n * (Where ++ is the CloudFormation string-concat operation (`{ Fn::Join }`).\n *\n * -----------------------\n *\n * This work requires 2 features from the `resolve()` function:\n *\n * - INTRINSICS TYPE HINTS: intrinsics are represented by values like\n *   `{ Ref: 'XYZ' }`. These values can reference either a string or a list/number at\n *   deploy time, and from the value alone there's no way to know which. We need\n *   to know the type to know whether to JSONify this reference to:\n *\n *      '{ \"referencedValue\": \"' ++ { Ref: XYZ } ++ '\"}'\n *   or '{ \"referencedValue\": ' ++ { Ref: XYZ } ++ '}'\n *\n *   I.e., whether or not we need to enclose the reference in quotes or not.\n *\n *   We COULD have done this by resolving one token at a time, and looking at the\n *   type of the encoded token we were resolving to obtain a type hint. However,\n *   the `resolve()` and Token system resist a level-at-a-time resolve\n *   operation: because of the existence of post-processors, we must have done a\n *   complete recursive resolution of a token before we can look at its result\n *   (after which any type information about the sources of nested resolved\n *   values is lost).\n *\n *   To fix this, \"type hints\" have been added to the `resolve()` function,\n *   giving an idea of the type of the source value for compplex result values.\n *   This only works for objects (not strings and numbers) but fortunately\n *   we only care about the types of intrinsics, which are always complex values.\n *\n *   Type hinting could have been added to the `IResolvable` protocol as well,\n *   but for now we just use the type of an encoded value as a type hint. That way\n *   we don't need to annotate anything more at the L1 level--we will use the type\n *   encodings added by construct authors at the L2 levels. L1 users can escape the\n *   default decision of \"string\" by using `Token.asList()`.\n *\n * - COMPLEX KEYS: since tokens can be string-encoded, we can use string-encoded tokens\n *   as the keys in JavaScript objects. However, after resolution, those string-encoded\n *   tokens could resolve to intrinsics (`{ Ref: ... }`), which CANNOT be stored in\n *   JavaScript objects anymore.\n *\n *   We therefore need a protocol to store the resolved values somewhere in the JavaScript\n *   type model,  which can be returned by `resolve()`, and interpreted by `tokenAwareStringify()`\n *   to produce the correct JSON.\n *\n *   And example will quickly show the point:\n *\n *    User writes:\n *       { [resource.resourceName]: 'SomeValue' }\n *    ------ string actually looks like ------>\n *       { '${Token[1234]}': 'SomeValue' }\n *    ------ resolve ------->\n *       { '$IntrinsicKey$0': [ {Ref: Resource}, 'SomeValue' ] }\n *    ------ tokenAwareStringify ------->\n *       '{ \"' ++ { Ref: Resource } ++ '\": \"SomeValue\" }'\n */\nfunction tokenAwareStringify(root: any, space: number, ctx: IResolveContext) {\n  let indent = 0;\n\n  const ret = new Array<Segment>();\n\n  // First completely resolve the tree, then encode to JSON while respecting the type\n  // hints we got for the resolved intrinsics.\n  recurse(ctx.resolve(root, { allowIntrinsicKeys: true }));\n\n  switch (ret.length) {\n    case 0: return undefined;\n    case 1: return renderSegment(ret[0]);\n    default:\n      return fnJoinConcat(ret.map(renderSegment));\n  }\n\n  /**\n   * Stringify a JSON element\n   */\n  function recurse(obj: any): void {\n    if (obj === undefined) { return; }\n\n    if (Token.isUnresolved(obj)) {\n      throw new Error('This shouldnt happen anymore');\n    }\n    if (Array.isArray(obj)) {\n      return renderCollection('[', ']', obj, recurse);\n    }\n    if (typeof obj === 'object' && obj != null && !(obj instanceof Date)) {\n      // Treat as an intrinsic if this LOOKS like a CFN intrinsic (`{ Ref: ... }`)\n      // AND it's the result of a token resolution. Otherwise, we just treat this\n      // value as a regular old JSON object (that happens to look a lot like an intrinsic).\n      if (isIntrinsic(obj) && resolvedTypeHint(obj)) {\n        renderIntrinsic(obj);\n        return;\n      }\n\n      return renderCollection('{', '}', definedEntries(obj), ([key, value]) => {\n        if (key.startsWith(INTRINSIC_KEY_PREFIX)) {\n          [key, value] = value;\n        }\n\n        recurse(key);\n        pushLiteral(prettyPunctuation(':'));\n        recurse(value);\n      });\n    }\n    // Otherwise we have a scalar, defer to JSON.stringify()s serialization\n    pushLiteral(JSON.stringify(obj));\n  }\n\n  /**\n   * Render an object or list\n   */\n  function renderCollection<A>(pre: string, post: string, xs: Iterable<A>, each: (x: A) => void) {\n    pushLiteral(pre);\n    indent += space;\n    let atLeastOne = false;\n    for (const [comma, item] of sepIter(xs)) {\n      if (comma) { pushLiteral(','); }\n      pushLineBreak();\n      each(item);\n      atLeastOne = true;\n    }\n    indent -= space;\n    if (atLeastOne) { pushLineBreak(); }\n    pushLiteral(post);\n  }\n\n  function renderIntrinsic(intrinsic: any) {\n    switch (resolvedTypeHint(intrinsic)) {\n      case ResolutionTypeHint.STRING:\n        pushLiteral('\"');\n        pushIntrinsic(deepQuoteStringLiterals(intrinsic));\n        pushLiteral('\"');\n        return;\n\n      case ResolutionTypeHint.LIST:\n        // We need this to look like:\n        //\n        //    '{\"listValue\":' ++ STRINGIFY(CFN_EVAL({ Ref: MyList })) ++ '}'\n        //\n        // However, STRINGIFY would need to execute at CloudFormation deployment time, and that doesn't exist.\n        //\n        // We could *ALMOST* use:\n        //\n        //   '{\"listValue\":[\"' ++ JOIN('\",\"', { Ref: MyList }) ++ '\"]}'\n        //\n        // But that has the unfortunate side effect that if `CFN_EVAL({ Ref: MyList }) == []`, then it would\n        // evaluate to `[\"\"]`, which is a different value. Since CloudFormation does not have arbitrary\n        // conditionals there's no way to deal with this case properly.\n        //\n        // Therefore, if we encounter lists we need to defer to a custom resource to handle\n        // them properly at deploy time.\n        const stack = Stack.of(ctx.scope);\n\n        // Because this will be called twice (once during `prepare`, once during `resolve`),\n        // we need to make sure to be idempotent, so use a cache.\n        const stringifyResponse = stringifyCache.obtain(stack, JSON.stringify(intrinsic), () =>\n          CfnUtils.stringify(stack, `CdkJsonStringify${stringifyCounter++}`, intrinsic),\n        );\n\n        pushIntrinsic(stringifyResponse);\n        return;\n\n      case ResolutionTypeHint.NUMBER:\n        pushIntrinsic(intrinsic);\n        return;\n    }\n\n    throw new Error(`Unexpected type hint: ${resolvedTypeHint(intrinsic)}`);\n  }\n\n  /**\n   * Push a literal onto the current segment if it's also a literal, otherwise open a new Segment\n   */\n  function pushLiteral(lit: string) {\n    let last = ret[ret.length - 1];\n    if (last?.type !== 'literal') {\n      last = { type: 'literal', parts: [] };\n      ret.push(last);\n    }\n    last.parts.push(lit);\n  }\n\n  /**\n   * Add a new intrinsic segment\n   */\n  function pushIntrinsic(intrinsic: any) {\n    ret.push({ type: 'intrinsic', intrinsic });\n  }\n\n  /**\n   * Push a line break if we are pretty-printing, otherwise don't\n   */\n  function pushLineBreak() {\n    if (space > 0) {\n      pushLiteral(`\\n${' '.repeat(indent)}`);\n    }\n  }\n\n  /**\n   * Add a space after the punctuation if we are pretty-printing, no space if not\n   */\n  function prettyPunctuation(punc: string) {\n    return space > 0 ? `${punc} ` : punc;\n  }\n}\n\n/**\n * A Segment is either a literal string or a CloudFormation intrinsic\n */\ntype Segment = { type: 'literal'; parts: string[] } | { type: 'intrinsic'; intrinsic: any };\n\n/**\n * Render a segment\n */\nfunction renderSegment(s: Segment): NonNullable<any> {\n  switch (s.type) {\n    case 'literal': return s.parts.join('');\n    case 'intrinsic': return s.intrinsic;\n  }\n}\n\nconst CLOUDFORMATION_CONCAT: IFragmentConcatenator = {\n  join(left: any, right: any) {\n    return CloudFormationLang.concat(left, right);\n  },\n};\n\n/**\n * Default Token resolver for CloudFormation templates\n */\nexport const CLOUDFORMATION_TOKEN_RESOLVER = new DefaultTokenResolver(CLOUDFORMATION_CONCAT);\n\n/**\n * Do an intelligent CloudFormation join on the given values, producing a minimal expression\n */\nexport function minimalCloudFormationJoin(delimiter: string, values: any[]): any[] {\n  let i = 0;\n  while (i < values.length) {\n    const el = values[i];\n    if (isSplicableFnJoinIntrinsic(el)) {\n      values.splice(i, 1, ...el['Fn::Join'][1]);\n    } else if (i > 0 && isConcatable(values[i - 1]) && isConcatable(values[i])) {\n      values[i - 1] = `${values[i-1]}${delimiter}${values[i]}`;\n      values.splice(i, 1);\n    } else {\n      i += 1;\n    }\n  }\n\n  return values;\n\n  function isSplicableFnJoinIntrinsic(obj: any): boolean {\n    if (!isIntrinsic(obj)) { return false; }\n    if (Object.keys(obj)[0] !== 'Fn::Join') { return false; }\n\n    const [delim, list] = obj['Fn::Join'];\n    if (delim !== delimiter) { return false; }\n\n    if (Token.isUnresolved(list)) { return false; }\n    if (!Array.isArray(list)) { return false; }\n\n    return true;\n  }\n}\n\nfunction isConcatable(obj: any): boolean {\n  return ['string', 'number'].includes(typeof obj) && !Token.isUnresolved(obj);\n}\n\n\n/**\n * Return whether the given value represents a CloudFormation intrinsic\n */\nfunction isIntrinsic(x: any) {\n  if (Array.isArray(x) || x === null || typeof x !== 'object') { return false; }\n\n  const keys = Object.keys(x);\n  if (keys.length !== 1) { return false; }\n\n  return keys[0] === 'Ref' || isNameOfCloudFormationIntrinsic(keys[0]);\n}\n\nexport function isNameOfCloudFormationIntrinsic(name: string): boolean {\n  if (!name.startsWith('Fn::')) {\n    return false;\n  }\n  // these are 'fake' intrinsics, only usable inside the parameter overrides of a CFN CodePipeline Action\n  return name !== 'Fn::GetArtifactAtt' && name !== 'Fn::GetParam';\n}\n\n/**\n * Separated iterator\n */\nfunction* sepIter<A>(xs: Iterable<A>): IterableIterator<[boolean, A]> {\n  let comma = false;\n  for (const item of xs) {\n    yield [comma, item];\n    comma = true;\n  }\n}\n\n/**\n * Object.entries() but skipping undefined values\n */\nfunction* definedEntries<A extends object>(xs: A): IterableIterator<[string, any]> {\n  for (const [key, value] of Object.entries(xs)) {\n    if (value !== undefined) {\n      yield [key, value];\n    }\n  }\n}\n\n/**\n * Quote string literals inside an intrinsic\n *\n * Formally, this should only match string literals that will be interpreted as\n * string literals. Fortunately, the strings that should NOT be quoted are\n * Logical IDs and attribute names, which cannot contain quotes anyway. Hence,\n * we can get away not caring about the distinction and just quoting everything.\n */\nfunction deepQuoteStringLiterals(x: any): any {\n  if (Array.isArray(x)) {\n    return x.map(deepQuoteStringLiterals);\n  }\n  if (typeof x === 'object' && x != null) {\n    const ret: any = {};\n    for (const [key, value] of Object.entries(x)) {\n      ret[deepQuoteStringLiterals(key)] = deepQuoteStringLiterals(value);\n    }\n    return ret;\n  }\n  if (typeof x === 'string') {\n    return quoteString(x);\n  }\n  return x;\n}\n\n/**\n * Quote the characters inside a string, for use inside toJSON\n */\nfunction quoteString(s: string) {\n  s = JSON.stringify(s);\n  return s.substring(1, s.length - 1);\n}\n\nlet stringifyCounter = 1;\n\n/**\n * A cache scoped to object instances, that's maintained externally to the object instances\n */\nclass ScopedCache<O extends object, K, V> {\n  private cache = new WeakMap<O, Map<K, V>>();\n\n  public obtain(object: O, key: K, init: () => V): V {\n    let kvMap = this.cache.get(object);\n    if (!kvMap) {\n      kvMap = new Map();\n      this.cache.set(object, kvMap);\n    }\n\n    let ret = kvMap.get(key);\n    if (ret === undefined) {\n      ret = init();\n      kvMap.set(key, ret);\n    }\n    return ret;\n  }\n}\n\nconst stringifyCache = new ScopedCache<Stack, string, string>();"]}