@aws-cdk/toolkit-lib 1.1.0 → 1.1.2

package/lib/api/refactoring/stack-definitions.js

@@ -0,0 +1,451 @@
+"use strict";
+/*
+ * The Cloudformation refactoring API needs, in addition to the mappings, the
+ * resulting templates for each affected stack. The resulting templates are
+ * basically the synthesis produced, but with some differences:
+ *
+ * - Resources that exist in the local stacks, but not in the remote stacks, are
+ *   not included.
+ * - Resources that exist in the remote stacks, but not in the local stacks, are
+ *   preserved.
+ * - For resources that exist in both stacks, but have different properties, the
+ *   deployed properties are used, but the references may need to be updated, if
+ *   the resources they reference were moved in the refactoring.
+ *
+ * Why does the last difference exist, to begin with? By default, to establish
+ * whether two given resources are the same, roughly speaking we compute the hash
+ * of their properties and compare them. But there is a better source of resource
+ * identity, that we can exploit when it is present: the physical name. In such
+ * cases, we can track a resource move even if the properties are different, as
+ * long as the physical name is the same.
+ *
+ * The process of computing the resulting templates consists in:
+ *
+ * 1. Computing a graph of deployed resources.
+ * 2. Mapping edges and nodes according to the mappings (that we either
+ *    computed or got directly from the user).
+ * 3. Computing the resulting templates by traversing the graph and
+ *    collecting the resources that are not mapped out, and updating the
+ *    references to the resources that were moved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStackDefinitions = generateStackDefinitions;
+const cloudformation_1 = require("./cloudformation");
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+function generateStackDefinitions(mappings, deployedStacks, localStacks) {
+    const localExports = indexExports(localStacks);
+    const deployedExports = indexExports(deployedStacks);
+    const edgeMapper = new EdgeMapper(mappings);
+    // Build a graph of the deployed stacks
+    const deployedGraph = graph(deployedStacks, deployedExports);
+    // Map all the edges, including their endpoints, to their new locations.
+    const edges = edgeMapper.mapEdges(deployedGraph.edges);
+    // All the edges have been mapped, which means that isolated nodes were left behind. Map them too.
+    const nodes = mapNodes(deployedGraph.isolatedNodes, mappings);
+    // Now we can generate the templates for each stack
+    const templates = generateTemplates(edges, nodes, edgeMapper.affectedStackNames, localExports, deployedStacks);
+    // Finally, generate the stack definitions, to be included in the refactor request.
+    return Object.entries(templates).map(([stackName, template]) => ({
+        StackName: stackName,
+        TemplateBody: JSON.stringify(template),
+    }));
+}
+function graph(deployedStacks, deployedExports) {
+    const deployedNodeMap = buildNodes(deployedStacks);
+    const deployedNodes = Array.from(deployedNodeMap.values());
+    const edges = buildEdges(deployedNodeMap, deployedExports);
+    const isolatedNodes = deployedNodes.filter((node) => {
+        return !edges.some((edge) => edge.source.location.equalTo(node.location) ||
+            edge.targets.some((target) => target.location.equalTo(node.location)));
+    });
+    return { edges, isolatedNodes };
+}
+function buildNodes(stacks) {
+    const result = new Map();
+    for (const stack of stacks) {
+        const template = stack.template;
+        for (const [logicalId, resource] of Object.entries(template.Resources ?? {})) {
+            const location = new cloudformation_1.ResourceLocation(stack, logicalId);
+            result.set(`${stack.stackName}.${logicalId}`, {
+                location,
+                rawValue: resource,
+            });
+        }
+    }
+    return result;
+}
+function buildEdges(nodeMap, exports) {
+    const nodes = Array.from(nodeMap.values());
+    return nodes.flatMap((node) => buildEdgesForResource(node, node.rawValue));
+    function buildEdgesForResource(source, value, path = []) {
+        if (!value || typeof value !== 'object')
+            return [];
+        if (Array.isArray(value)) {
+            return value.flatMap((x, index) => buildEdgesForResource(source, x, path.concat(String(index))));
+        }
+        if ('Ref' in value) {
+            return [makeRef(source.location.stack.stackName, value.Ref)];
+        }
+        if ('Fn::GetAtt' in value) {
+            return [makeGetAtt(source.location.stack.stackName, value['Fn::GetAtt'])];
+        }
+        if ('Fn::ImportValue' in value) {
+            const exportName = value['Fn::ImportValue'];
+            const x = exports[exportName];
+            if ('Ref' in x.value) {
+                return [
+                    {
+                        ...makeRef(x.stackName, x.value.Ref),
+                        reference: new ImportValue(Ref.INSTANCE),
+                    },
+                ];
+            }
+            if ('Fn::GetAtt' in x.value) {
+                const getAtt = makeGetAtt(x.stackName, x.value['Fn::GetAtt']);
+                return [
+                    {
+                        ...getAtt,
+                        reference: new ImportValue(getAtt.reference),
+                    },
+                ];
+            }
+            return [];
+        }
+        if ('Fn::Sub' in value) {
+            let inputString;
+            let variables;
+            const sub = value['Fn::Sub'];
+            if (typeof sub === 'string') {
+                inputString = sub;
+            }
+            else {
+                [inputString, variables] = sub;
+            }
+            let varNames = Array.from(inputString.matchAll(/\${([a-zA-Z0-9_.]+)}/g))
+                .map((x) => x[1])
+                .filter((varName) => (value['Fn::Sub'][1] ?? {})[varName] == null);
+            const edges = varNames.map((varName) => {
+                return varName.includes('.')
+                    ? makeGetAtt(source.location.stack.stackName, varName)
+                    : makeRef(source.location.stack.stackName, varName);
+            });
+            const edgesFromInputString = [
+                {
+                    source,
+                    targets: edges.flatMap((edge) => edge.targets),
+                    reference: new Sub(inputString, varNames),
+                    path: path.concat('Fn::Sub', '0'),
+                },
+            ];
+            const edgesFromVariables = buildEdgesForResource(source, variables, path.concat('Fn::Sub', '1'));
+            return [...edgesFromInputString, ...edgesFromVariables];
+        }
+        const edges = [];
+        // DependsOn is only handled at the top level of the resource
+        if ('DependsOn' in value && path.length === 0) {
+            if (typeof value.DependsOn === 'string') {
+                edges.push({
+                    ...makeRef(source.location.stack.stackName, value.DependsOn),
+                    reference: DependsOn.INSTANCE,
+                });
+            }
+            else if (Array.isArray(value.DependsOn)) {
+                edges.push({
+                    source,
+                    targets: value.DependsOn.flatMap((dependsOn) => makeRef(source.location.stack.stackName, dependsOn).targets),
+                    path: path.concat('DependsOn'),
+                    reference: DependsOn.INSTANCE,
+                });
+            }
+        }
+        edges.push(...Object.entries(value).flatMap(([k, v]) => buildEdgesForResource(source, v, path.concat(k))));
+        return edges;
+        function makeRef(stackName, logicalId) {
+            const key = `${stackName}.${logicalId}`;
+            const target = nodeMap.get(key);
+            return {
+                path,
+                source,
+                targets: [target],
+                reference: Ref.INSTANCE,
+            };
+        }
+        function makeGetAtt(stackName, att) {
+            let logicalId = '';
+            let attributeName = '';
+            if (typeof att === 'string') {
+                [logicalId, attributeName] = att.split(/\.(.*)/s);
+            }
+            else if (Array.isArray(att) && att.length === 2) {
+                [logicalId, attributeName] = att;
+            }
+            const key = `${stackName}.${logicalId}`;
+            const target = nodeMap.get(key);
+            return {
+                path,
+                source,
+                targets: [target],
+                reference: new GetAtt(attributeName),
+            };
+        }
+    }
+}
+function mapNodes(nodes, mappings) {
+    return nodes.map((node) => {
+        const newLocation = mapLocation(node.location, mappings);
+        return {
+            location: newLocation,
+            rawValue: node.rawValue,
+        };
+    });
+}
+function generateTemplates(edges, nodes, stackNames, exports, deployedStacks) {
+    updateReferences(edges, exports);
+    const templates = {};
+    // Take the CloudFormation raw value of each the node and put it into the appropriate template.
+    const allNodes = unique(edges.flatMap((e) => [e.source, ...e.targets]).concat(nodes));
+    allNodes.forEach((node) => {
+        const stackName = node.location.stack.stackName;
+        const logicalId = node.location.logicalResourceId;
+        if (templates[stackName] === undefined) {
+            templates[stackName] = {
+                Resources: {},
+            };
+        }
+        templates[stackName].Resources[logicalId] = node.rawValue;
+    });
+    // Add outputs to the templates
+    edges.forEach((edge) => {
+        if (edge.reference instanceof ImportValue) {
+            const stackName = edge.targets[0].location.stack.stackName;
+            const template = templates[stackName];
+            template.Outputs = {
+                ...(template.Outputs ?? {}),
+                ...edge.reference.output,
+            };
+        }
+    });
+    // The freshly generated templates contain only resources and outputs.
+    // Combine them with the existing templates to preserve metadata and other properties.
+    return Object.fromEntries(stackNames.map((stackName) => {
+        const oldTemplate = deployedStacks.find((s) => s.stackName === stackName)?.template ?? {};
+        const newTemplate = templates[stackName] ?? { Resources: {} };
+        const combinedTemplate = { ...oldTemplate, ...newTemplate };
+        sanitizeDependencies(combinedTemplate);
+        return [stackName, combinedTemplate];
+    }));
+}
+/**
+ * Update the CloudFormation resources based on information from the edges.
+ * Each edge corresponds to a path in some resource object. The value at that
+ * path is updated to the CloudFormation value represented by the edge's annotation.
+ */
+function updateReferences(edges, exports) {
+    edges.forEach((edge) => {
+        const cfnValue = edge.reference.toCfn(edge.targets, exports);
+        const obj = edge.path.slice(0, edge.path.length - 1).reduce(getPropValue, edge.source.rawValue);
+        setPropValue(obj, edge.path[edge.path.length - 1], cfnValue);
+    });
+    function getPropValue(obj, prop) {
+        const index = parseInt(prop);
+        return obj[Number.isNaN(index) ? prop : index];
+    }
+    function setPropValue(obj, prop, value) {
+        const index = parseInt(prop);
+        obj[Number.isNaN(index) ? prop : index] = value;
+    }
+}
+class EdgeMapper {
+    mappings;
+    affectedStacks = new Set();
+    nodeMap = new Map();
+    constructor(mappings) {
+        this.mappings = mappings;
+    }
+    /**
+     * For each input edge, produce an output edge such that:
+     *   - The source and targets are mapped to their new locations
+     *   - The annotation is converted between in-stack and cross-stack references, as appropriate
+     */
+    mapEdges(edges) {
+        return edges
+            .map((edge) => {
+            const oldSource = edge.source;
+            const oldTargets = edge.targets;
+            const newSource = this.mapNode(oldSource);
+            const newTargets = oldTargets.map((t) => this.mapNode(t));
+            const oldSourceStackName = oldSource.location.stack.stackName;
+            const oldTargetStackName = oldTargets[0].location.stack.stackName;
+            const newSourceStackName = newSource.location.stack.stackName;
+            const newTargetStackName = newTargets[0].location.stack.stackName;
+            this.affectedStacks.add(newSourceStackName);
+            this.affectedStacks.add(newTargetStackName);
+            this.affectedStacks.add(oldSourceStackName);
+            this.affectedStacks.add(oldTargetStackName);
+            let reference = edge.reference;
+            if (oldSourceStackName === oldTargetStackName && newSourceStackName !== newTargetStackName) {
+                if (edge.reference instanceof DependsOn) {
+                    return undefined;
+                }
+                // in-stack reference to cross-stack reference: wrap the old annotation
+                reference = new ImportValue(edge.reference);
+            }
+            else if (oldSourceStackName !== oldTargetStackName && newSourceStackName === newTargetStackName) {
+                // cross-stack reference to in-stack reference: unwrap the old annotation
+                if (edge.reference instanceof ImportValue) {
+                    reference = edge.reference.reference;
+                }
+            }
+            return {
+                path: edge.path,
+                source: newSource,
+                targets: newTargets,
+                reference,
+            };
+        })
+            .filter((edge) => edge !== undefined);
+    }
+    get affectedStackNames() {
+        const fromMappings = this.mappings.flatMap((m) => [m.source.stack.stackName, m.destination.stack.stackName]);
+        return unique([...this.affectedStacks, ...fromMappings]);
+    }
+    mapNode(node) {
+        const newLocation = mapLocation(node.location, this.mappings);
+        const key = `${newLocation.stack.stackName}.${newLocation.logicalResourceId}`;
+        if (!this.nodeMap.has(key)) {
+            this.nodeMap.set(key, {
+                location: newLocation,
+                rawValue: node.rawValue,
+            });
+        }
+        return this.nodeMap.get(key);
+    }
+}
+function mapLocation(location, mappings) {
+    const mapping = mappings.find((m) => m.source.equalTo(location));
+    if (mapping) {
+        return mapping.destination;
+    }
+    return location;
+}
+function indexExports(stacks) {
+    return Object.fromEntries(stacks.flatMap((s) => Object.entries(s.template.Outputs ?? {})
+        .filter(([_, o]) => typeof o.Export?.Name === 'string' && (o.Value.Ref != null || o.Value['Fn::GetAtt'] != null))
+        .map(([name, o]) => [o.Export.Name, { stackName: s.stackName, outputName: name, value: o.Value }])));
+}
+function unique(arr) {
+    return Array.from(new Set(arr));
+}
+/**
+ * Updates the DependsOn property of all resources, removing references
+ * to resources that do not exist in the template. Unlike Refs and GetAtts,
+ * which get transformed to ImportValues when the referenced resource is
+ * moved to another stack, DependsOn doesn't cross stack boundaries.
+ */
+function sanitizeDependencies(template) {
+    const resources = template.Resources ?? {};
+    for (const resource of Object.values(resources)) {
+        if (typeof resource.DependsOn === 'string' && resources[resource.DependsOn] == null) {
+            delete resource.DependsOn;
+        }
+        if (Array.isArray(resource.DependsOn)) {
+            resource.DependsOn = resource.DependsOn.filter((dep) => resources[dep] != null);
+            if (resource.DependsOn.length === 0) {
+                delete resource.DependsOn;
+            }
+        }
+    }
+}
+class Ref {
+    static INSTANCE = new Ref();
+    constructor() {
+    }
+    toCfn(targets) {
+        return { Ref: targets[0].location.logicalResourceId };
+    }
+}
+class GetAtt {
+    attributeName;
+    constructor(attributeName) {
+        this.attributeName = attributeName;
+    }
+    toCfn(targets) {
+        return {
+            'Fn::GetAtt': [targets[0].location.logicalResourceId, this.attributeName],
+        };
+    }
+}
+class ImportValue {
+    reference;
+    outputName;
+    outputContent;
+    constructor(reference) {
+        this.reference = reference;
+    }
+    toCfn(targets, exports) {
+        const exp = this.findExport(targets, exports);
+        if (exp) {
+            this.outputName = exp[1].outputName;
+            this.outputContent = {
+                Value: exp[1].value,
+                Export: {
+                    Name: exp[0],
+                },
+            };
+            return { 'Fn::ImportValue': exp[0] };
+        }
+        // TODO better message
+        throw new toolkit_error_1.ToolkitError('Unknown export for ImportValue: ' + JSON.stringify(this.reference));
+    }
+    findExport(targets, exports) {
+        const target = targets[0];
+        if (this.reference instanceof Ref) {
+            return Object.entries(exports).find(([_, exportValue]) => {
+                return (exportValue.stackName === target.location.stack.stackName &&
+                    exportValue.value.Ref === target.location.logicalResourceId);
+            });
+        }
+        else {
+            return Object.entries(exports).find(([_, exportValue]) => {
+                const getAtt = this.reference;
+                return (exportValue.stackName === target.location.stack.stackName &&
+                    exportValue.value['Fn::GetAtt'] &&
+                    ((exportValue.value['Fn::GetAtt'][0] === target.location.logicalResourceId &&
+                        exportValue.value['Fn::GetAtt'][1] === getAtt.attributeName) ||
+                        exportValue.value['Fn::GetAtt'] === `${target.location.logicalResourceId}.${getAtt.attributeName}`));
+            });
+        }
+    }
+    get output() {
+        if (this.outputName == null) {
+            throw new toolkit_error_1.ToolkitError('Cannot access output before calling toCfn');
+        }
+        return { [this.outputName]: this.outputContent };
+    }
+}
+class Sub {
+    inputString;
+    varNames;
+    constructor(inputString, varNames) {
+        this.inputString = inputString;
+        this.varNames = varNames;
+    }
+    toCfn(targets) {
+        let inputString = this.inputString;
+        this.varNames.forEach((varName, index) => {
+            const [_, attr] = varName.split(/\.(.*)/s);
+            const target = targets[index];
+            inputString = inputString.replace(`\${${varName}`, `\${${target.location.logicalResourceId}${attr ? `.${attr}` : ''}`);
+        });
+        return inputString;
+    }
+}
+class DependsOn {
+    static INSTANCE = new DependsOn();
+    constructor() {
+    }
+    toCfn(targets) {
+        return targets.map((t) => t.location.logicalResourceId);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-definitions.js","sourceRoot":"","sources":["stack-definitions.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * The Cloudformation refactoring API needs, in addition to the mappings, the\n * resulting templates for each affected stack. The resulting templates are\n * basically the synthesis produced, but with some differences:\n *\n * - Resources that exist in the local stacks, but not in the remote stacks, are\n *   not included.\n * - Resources that exist in the remote stacks, but not in the local stacks, are\n *   preserved.\n * - For resources that exist in both stacks, but have different properties, the\n *   deployed properties are used, but the references may need to be updated, if\n *   the resources they reference were moved in the refactoring.\n *\n * Why does the last difference exist, to begin with? By default, to establish\n * whether two given resources are the same, roughly speaking we compute the hash\n * of their properties and compare them. But there is a better source of resource\n * identity, that we can exploit when it is present: the physical name. In such\n * cases, we can track a resource move even if the properties are different, as\n * long as the physical name is the same.\n *\n * The process of computing the resulting templates consists in:\n *\n * 1. Computing a graph of deployed resources.\n * 2. Mapping edges and nodes according to the mappings (that we either\n *    computed or got directly from the user).\n * 3. Computing the resulting templates by traversing the graph and\n *    collecting the resources that are not mapped out, and updating the\n *    references to the resources that were moved.\n */\n\nimport type { StackDefinition } from '@aws-sdk/client-cloudformation';\nimport type { CloudFormationStack, CloudFormationTemplate, ResourceMapping } from './cloudformation';\nimport { ResourceLocation } from './cloudformation';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\n\nexport function generateStackDefinitions(\n  mappings: ResourceMapping[],\n  deployedStacks: CloudFormationStack[],\n  localStacks: CloudFormationStack[],\n): StackDefinition[] {\n  const localExports: Record<string, ScopedExport> = indexExports(localStacks);\n  const deployedExports: Record<string, ScopedExport> = indexExports(deployedStacks);\n  const edgeMapper = new EdgeMapper(mappings);\n\n  // Build a graph of the deployed stacks\n  const deployedGraph = graph(deployedStacks, deployedExports);\n\n  // Map all the edges, including their endpoints, to their new locations.\n  const edges = edgeMapper.mapEdges(deployedGraph.edges);\n\n  // All the edges have been mapped, which means that isolated nodes were left behind. Map them too.\n  const nodes = mapNodes(deployedGraph.isolatedNodes, mappings);\n\n  // Now we can generate the templates for each stack\n  const templates = generateTemplates(edges, nodes, edgeMapper.affectedStackNames, localExports, deployedStacks);\n\n  // Finally, generate the stack definitions, to be included in the refactor request.\n  return Object.entries(templates).map(([stackName, template]) => ({\n    StackName: stackName,\n    TemplateBody: JSON.stringify(template),\n  }));\n}\n\nfunction graph(deployedStacks: CloudFormationStack[], deployedExports: Record<string, ScopedExport>):\n{ edges: ResourceEdge[]; isolatedNodes: ResourceNode[] } {\n  const deployedNodeMap: Map<string, ResourceNode> = buildNodes(deployedStacks);\n  const deployedNodes = Array.from(deployedNodeMap.values());\n\n  const edges = buildEdges(deployedNodeMap, deployedExports);\n\n  const isolatedNodes = deployedNodes.filter((node) => {\n    return !edges.some(\n      (edge) =>\n        edge.source.location.equalTo(node.location) ||\n        edge.targets.some((target) => target.location.equalTo(node.location)),\n    );\n  });\n\n  return { edges, isolatedNodes };\n}\n\nfunction buildNodes(stacks: CloudFormationStack[]): Map<string, ResourceNode> {\n  const result = new Map<string, ResourceNode>();\n\n  for (const stack of stacks) {\n    const template = stack.template;\n    for (const [logicalId, resource] of Object.entries(template.Resources ?? {})) {\n      const location = new ResourceLocation(stack, logicalId);\n      result.set(`${stack.stackName}.${logicalId}`, {\n        location,\n        rawValue: resource,\n      });\n    }\n  }\n\n  return result;\n}\n\nfunction buildEdges(\n  nodeMap: Map<string, ResourceNode>,\n  exports: Record<\n    string,\n    {\n      stackName: string;\n      value: any;\n    }\n  >,\n): ResourceEdge[] {\n  const nodes = Array.from(nodeMap.values());\n  return nodes.flatMap((node) => buildEdgesForResource(node, node.rawValue));\n\n  function buildEdgesForResource(source: ResourceNode, value: any, path: string[] = []): ResourceEdge[] {\n    if (!value || typeof value !== 'object') return [];\n    if (Array.isArray(value)) {\n      return value.flatMap((x, index) => buildEdgesForResource(source, x, path.concat(String(index))));\n    }\n\n    if ('Ref' in value) {\n      return [makeRef(source.location.stack.stackName, value.Ref)];\n    }\n\n    if ('Fn::GetAtt' in value) {\n      return [makeGetAtt(source.location.stack.stackName, value['Fn::GetAtt'])];\n    }\n\n    if ('Fn::ImportValue' in value) {\n      const exportName = value['Fn::ImportValue'];\n      const x = exports[exportName]!;\n\n      if ('Ref' in x.value) {\n        return [\n          {\n            ...makeRef(x.stackName, x.value.Ref),\n            reference: new ImportValue(Ref.INSTANCE),\n          },\n        ];\n      }\n\n      if ('Fn::GetAtt' in x.value) {\n        const getAtt = makeGetAtt(x.stackName, x.value['Fn::GetAtt']);\n        return [\n          {\n            ...getAtt,\n            reference: new ImportValue(getAtt.reference),\n          },\n        ];\n      }\n\n      return [];\n    }\n\n    if ('Fn::Sub' in value) {\n      let inputString: string;\n      let variables: Record<string, any> | undefined;\n      const sub = value['Fn::Sub'];\n      if (typeof sub === 'string') {\n        inputString = sub;\n      } else {\n        [inputString, variables] = sub;\n      }\n\n      let varNames = Array.from(inputString.matchAll(/\\${([a-zA-Z0-9_.]+)}/g))\n        .map((x) => x[1])\n        .filter((varName) => (value['Fn::Sub'][1] ?? {})[varName] == null);\n\n      const edges = varNames.map((varName) => {\n        return varName.includes('.')\n          ? makeGetAtt(source.location.stack.stackName, varName)\n          : makeRef(source.location.stack.stackName, varName);\n      });\n\n      const edgesFromInputString = [\n        {\n          source,\n          targets: edges.flatMap((edge) => edge.targets),\n          reference: new Sub(inputString, varNames),\n          path: path.concat('Fn::Sub', '0'),\n        },\n      ];\n\n      const edgesFromVariables = buildEdgesForResource(source, variables, path.concat('Fn::Sub', '1'));\n\n      return [...edgesFromInputString, ...edgesFromVariables];\n    }\n\n    const edges: ResourceEdge[] = [];\n\n    // DependsOn is only handled at the top level of the resource\n    if ('DependsOn' in value && path.length === 0) {\n      if (typeof value.DependsOn === 'string') {\n        edges.push({\n          ...makeRef(source.location.stack.stackName, value.DependsOn),\n          reference: DependsOn.INSTANCE,\n        });\n      } else if (Array.isArray(value.DependsOn)) {\n        edges.push({\n          source,\n          targets: value.DependsOn.flatMap(\n            (dependsOn: string) => makeRef(source.location.stack.stackName, dependsOn).targets,\n          ),\n          path: path.concat('DependsOn'),\n          reference: DependsOn.INSTANCE,\n        });\n      }\n    }\n\n    edges.push(...Object.entries(value).flatMap(([k, v]) => buildEdgesForResource(source, v, path.concat(k))));\n\n    return edges;\n\n    function makeRef(stackName: string, logicalId: string): ResourceEdge {\n      const key = `${stackName}.${logicalId}`;\n      const target = nodeMap.get(key)!;\n\n      return {\n        path,\n        source,\n        targets: [target],\n        reference: Ref.INSTANCE,\n      };\n    }\n\n    function makeGetAtt(stackName: string, att: string | string[]): ResourceEdge {\n      let logicalId: string = '';\n      let attributeName: string = '';\n      if (typeof att === 'string') {\n        [logicalId, attributeName] = att.split(/\\.(.*)/s);\n      } else if (Array.isArray(att) && att.length === 2) {\n        [logicalId, attributeName] = att;\n      }\n\n      const key = `${stackName}.${logicalId}`;\n      const target = nodeMap.get(key)!;\n\n      return {\n        path,\n        source,\n        targets: [target],\n        reference: new GetAtt(attributeName),\n      };\n    }\n  }\n}\n\nfunction mapNodes(nodes: ResourceNode[], mappings: ResourceMapping[]): ResourceNode[] {\n  return nodes.map((node) => {\n    const newLocation = mapLocation(node.location, mappings);\n    return {\n      location: newLocation,\n      rawValue: node.rawValue,\n    } as ResourceNode;\n  });\n}\n\nfunction generateTemplates(\n  edges: ResourceEdge[],\n  nodes: ResourceNode[],\n  stackNames: string[],\n  exports: Record<string, ScopedExport>,\n  deployedStacks: CloudFormationStack[]): Record<string, CloudFormationTemplate> {\n  updateReferences(edges, exports);\n  const templates: Record<string, CloudFormationTemplate> = {};\n\n  // Take the CloudFormation raw value of each the node and put it into the appropriate template.\n  const allNodes = unique(edges.flatMap((e) => [e.source, ...e.targets]).concat(nodes));\n  allNodes.forEach((node) => {\n    const stackName = node.location.stack.stackName;\n    const logicalId = node.location.logicalResourceId;\n\n    if (templates[stackName] === undefined) {\n      templates[stackName] = {\n        Resources: {},\n      };\n    }\n    templates[stackName].Resources![logicalId] = node.rawValue;\n  });\n\n  // Add outputs to the templates\n  edges.forEach((edge) => {\n    if (edge.reference instanceof ImportValue) {\n      const stackName = edge.targets[0].location.stack.stackName;\n      const template = templates[stackName];\n      template.Outputs = {\n        ...(template.Outputs ?? {}),\n        ...edge.reference.output,\n      };\n    }\n  });\n\n  // The freshly generated templates contain only resources and outputs.\n  // Combine them with the existing templates to preserve metadata and other properties.\n  return Object.fromEntries(\n    stackNames.map((stackName) => {\n      const oldTemplate = deployedStacks.find((s) => s.stackName === stackName)?.template ?? {};\n      const newTemplate = templates[stackName] ?? { Resources: {} };\n      const combinedTemplate = { ...oldTemplate, ...newTemplate };\n\n      sanitizeDependencies(combinedTemplate);\n      return [stackName, combinedTemplate];\n    }),\n  );\n}\n\n/**\n * Update the CloudFormation resources based on information from the edges.\n * Each edge corresponds to a path in some resource object. The value at that\n * path is updated to the CloudFormation value represented by the edge's annotation.\n */\nfunction updateReferences(edges: ResourceEdge[], exports: Record<string, ScopedExport>) {\n  edges.forEach((edge) => {\n    const cfnValue = edge.reference.toCfn(edge.targets, exports);\n    const obj = edge.path.slice(0, edge.path.length - 1).reduce(getPropValue, edge.source.rawValue);\n    setPropValue(obj, edge.path[edge.path.length - 1], cfnValue);\n  });\n\n  function getPropValue(obj: any, prop: string): any {\n    const index = parseInt(prop);\n    return obj[Number.isNaN(index) ? prop : index];\n  }\n\n  function setPropValue(obj: any, prop: string, value: any) {\n    const index = parseInt(prop);\n    obj[Number.isNaN(index) ? prop : index] = value;\n  }\n}\n\nclass EdgeMapper {\n  public readonly affectedStacks: Set<string> = new Set();\n  private readonly nodeMap: Map<string, ResourceNode> = new Map();\n\n  constructor(private readonly mappings: ResourceMapping[]) {\n  }\n\n  /**\n   * For each input edge, produce an output edge such that:\n   *   - The source and targets are mapped to their new locations\n   *   - The annotation is converted between in-stack and cross-stack references, as appropriate\n   */\n  mapEdges(edges: ResourceEdge[]): ResourceEdge[] {\n    return edges\n      .map((edge) => {\n        const oldSource = edge.source;\n        const oldTargets = edge.targets;\n        const newSource = this.mapNode(oldSource);\n        const newTargets = oldTargets.map((t) => this.mapNode(t));\n\n        const oldSourceStackName = oldSource.location.stack.stackName;\n        const oldTargetStackName = oldTargets[0].location.stack.stackName;\n\n        const newSourceStackName = newSource.location.stack.stackName;\n        const newTargetStackName = newTargets[0].location.stack.stackName;\n\n        this.affectedStacks.add(newSourceStackName);\n        this.affectedStacks.add(newTargetStackName);\n        this.affectedStacks.add(oldSourceStackName);\n        this.affectedStacks.add(oldTargetStackName);\n\n        let reference: CloudFormationReference = edge.reference;\n        if (oldSourceStackName === oldTargetStackName && newSourceStackName !== newTargetStackName) {\n          if (edge.reference instanceof DependsOn) {\n            return undefined;\n          }\n\n          // in-stack reference to cross-stack reference: wrap the old annotation\n          reference = new ImportValue(edge.reference);\n        } else if (oldSourceStackName !== oldTargetStackName && newSourceStackName === newTargetStackName) {\n          // cross-stack reference to in-stack reference: unwrap the old annotation\n          if (edge.reference instanceof ImportValue) {\n            reference = edge.reference.reference;\n          }\n        }\n\n        return {\n          path: edge.path,\n          source: newSource,\n          targets: newTargets,\n          reference,\n        };\n      })\n      .filter((edge) => edge !== undefined);\n  }\n\n  get affectedStackNames(): string[] {\n    const fromMappings = this.mappings.flatMap((m) => [m.source.stack.stackName, m.destination.stack.stackName]);\n    return unique([...this.affectedStacks, ...fromMappings]);\n  }\n\n  private mapNode(node: ResourceNode): ResourceNode {\n    const newLocation = mapLocation(node.location, this.mappings);\n    const key = `${newLocation.stack.stackName}.${newLocation.logicalResourceId}`;\n    if (!this.nodeMap.has(key)) {\n      this.nodeMap.set(key, {\n        location: newLocation,\n        rawValue: node.rawValue,\n      });\n    }\n    return this.nodeMap.get(key)!;\n  }\n}\n\nfunction mapLocation(location: ResourceLocation, mappings: ResourceMapping[]): ResourceLocation {\n  const mapping = mappings.find((m) => m.source.equalTo(location));\n  if (mapping) {\n    return mapping.destination;\n  }\n  return location;\n}\n\nfunction indexExports(stacks: CloudFormationStack[]): Record<string, ScopedExport> {\n  return Object.fromEntries(\n    stacks.flatMap((s) =>\n      Object.entries(s.template.Outputs ?? {})\n        .filter(\n          ([_, o]) => typeof o.Export?.Name === 'string' && (o.Value.Ref != null || o.Value['Fn::GetAtt'] != null),\n        )\n        .map(([name, o]) => [o.Export.Name, { stackName: s.stackName, outputName: name, value: o.Value }]),\n    ),\n  );\n}\n\nfunction unique<T>(arr: Array<T>) {\n  return Array.from(new Set(arr));\n}\n\n/**\n * Updates the DependsOn property of all resources, removing references\n * to resources that do not exist in the template. Unlike Refs and GetAtts,\n * which get transformed to ImportValues when the referenced resource is\n * moved to another stack, DependsOn doesn't cross stack boundaries.\n */\nfunction sanitizeDependencies(template: CloudFormationTemplate) {\n  const resources = template.Resources ?? {};\n  for (const resource of Object.values(resources)) {\n    if (typeof resource.DependsOn === 'string' && resources[resource.DependsOn] == null) {\n      delete resource.DependsOn;\n    }\n\n    if (Array.isArray(resource.DependsOn)) {\n      resource.DependsOn = resource.DependsOn.filter((dep) => resources[dep] != null);\n      if (resource.DependsOn.length === 0) {\n        delete resource.DependsOn;\n      }\n    }\n  }\n}\n\ninterface ScopedExport {\n  stackName: string;\n  outputName: string;\n  value: any;\n}\n\ninterface ResourceNode {\n  location: ResourceLocation;\n  rawValue: any;\n}\n\n/**\n * An edge in the resource graph, representing a reference from one resource\n * to one or more target resources. (Technically, a hyperedge.)\n */\ninterface ResourceEdge {\n  /**\n   * The source resource of the edge.\n   */\n  source: ResourceNode;\n\n  /**\n   * The target resources of the edge. In case of DependsOn,\n   * this can be multiple resources.\n   */\n  targets: ResourceNode[];\n\n  /**\n   * The path in the source resource where the reference is located.\n   */\n  path: string[];\n\n  /**\n   * The CloudFormation reference that this edge represents.\n   */\n  reference: CloudFormationReference;\n}\n\ninterface CloudFormationReference {\n  toCfn(targets: ResourceNode[], exports: Record<string, ScopedExport>): any;\n}\n\nclass Ref implements CloudFormationReference {\n  public static INSTANCE = new Ref();\n\n  private constructor() {\n  }\n\n  toCfn(targets: ResourceNode[]): any {\n    return { Ref: targets[0].location.logicalResourceId };\n  }\n}\n\nclass GetAtt implements CloudFormationReference {\n  constructor(public readonly attributeName: string) {\n  }\n\n  toCfn(targets: ResourceNode[]): any {\n    return {\n      'Fn::GetAtt': [targets[0].location.logicalResourceId, this.attributeName],\n    };\n  }\n}\n\nclass ImportValue implements CloudFormationReference {\n  private outputName?: string;\n  private outputContent?: any;\n\n  constructor(public readonly reference: CloudFormationReference) {\n  }\n\n  toCfn(targets: ResourceNode[], exports: Record<string, ScopedExport>): any {\n    const exp = this.findExport(targets, exports);\n    if (exp) {\n      this.outputName = exp[1].outputName;\n      this.outputContent = {\n        Value: exp[1].value,\n        Export: {\n          Name: exp[0],\n        },\n      };\n      return { 'Fn::ImportValue': exp[0] };\n    }\n    // TODO better message\n    throw new ToolkitError('Unknown export for ImportValue: ' + JSON.stringify(this.reference));\n  }\n\n  private findExport(targets: ResourceNode[], exports: Record<string, ScopedExport>) {\n    const target = targets[0];\n    if (this.reference instanceof Ref) {\n      return Object.entries(exports).find(([_, exportValue]) => {\n        return (\n          exportValue.stackName === target.location.stack.stackName &&\n          exportValue.value.Ref === target.location.logicalResourceId\n        );\n      });\n    } else {\n      return Object.entries(exports).find(([_, exportValue]) => {\n        const getAtt = this.reference as GetAtt;\n\n        return (\n          exportValue.stackName === target.location.stack.stackName &&\n          exportValue.value['Fn::GetAtt'] &&\n          ((exportValue.value['Fn::GetAtt'][0] === target.location.logicalResourceId &&\n              exportValue.value['Fn::GetAtt'][1] === getAtt.attributeName) ||\n            exportValue.value['Fn::GetAtt'] === `${target.location.logicalResourceId}.${getAtt.attributeName}`)\n        );\n      });\n    }\n  }\n\n  get output(): Record<string, any> {\n    if (this.outputName == null) {\n      throw new ToolkitError('Cannot access output before calling toCfn');\n    }\n    return { [this.outputName]: this.outputContent };\n  }\n}\n\nclass Sub implements CloudFormationReference {\n  constructor(public readonly inputString: string, public readonly varNames: string[]) {\n  }\n\n  toCfn(targets: ResourceNode[]): any {\n    let inputString = this.inputString;\n\n    this.varNames.forEach((varName, index) => {\n      const [_, attr] = varName.split(/\\.(.*)/s);\n      const target = targets[index];\n      inputString = inputString.replace(`\\${${varName}`, `\\${${target.location.logicalResourceId}${attr ? `.${attr}` : ''}`,\n      );\n    });\n\n    return inputString;\n  }\n}\n\nclass DependsOn implements CloudFormationReference {\n  public static INSTANCE = new DependsOn();\n\n  private constructor() {\n  }\n\n  toCfn(targets: ResourceNode[]): any {\n    return targets.map((t) => t.location.logicalResourceId);\n  }\n}\n"]}

package/lib/api/resource-import/importer.d.ts

@@ -215,3 +215,4 @@ export interface DiscoverImportableResourcesResult {
 }
 export declare function removeNonImportResources(stack: cxapi.CloudFormationStackArtifact): any;
 export {};
+//# sourceMappingURL=importer.d.ts.map

package/lib/api/resource-import/index.d.ts

@@ -1,2 +1,3 @@
 export * from './importer';
 export * from './migrator';
+//# sourceMappingURL=index.d.ts.map

package/lib/api/resource-import/migrator.d.ts

@@ -24,3 +24,4 @@ export declare class ResourceMigrator {
     private performResourceMigration;
     tryGetResources(environment: cxapi.Environment): Promise<ResourcesToImport | undefined>;
 }
+//# sourceMappingURL=migrator.d.ts.map

package/lib/api/resource-metadata/index.d.ts

@@ -1 +1,2 @@
 export * from './resource-metadata';
+//# sourceMappingURL=index.d.ts.map

package/lib/api/resource-metadata/resource-metadata.d.ts

@@ -22,3 +22,4 @@ export interface ResourceMetadata {
  * @returns The resource metadata, or undefined if the resource was not found
  */
 export declare function resourceMetadata(stack: CloudFormationStackArtifact, logicalId: string): ResourceMetadata | undefined;
+//# sourceMappingURL=resource-metadata.d.ts.map

package/lib/api/rwlock.d.ts

@@ -58,3 +58,4 @@ export interface IWriteLock extends IReadLock {
      */
     convertToReaderLock(): Promise<IReadLock>;
 }
+//# sourceMappingURL=rwlock.d.ts.map

package/lib/api/settings.d.ts

@@ -24,3 +24,4 @@ export declare class Settings {
     set(path: string[], value: any): Settings;
     unset(path: string[]): void;
 }
+//# sourceMappingURL=settings.d.ts.map

package/lib/api/stack-events/index.d.ts

@@ -2,3 +2,4 @@ export * from './stack-activity-monitor';
 export * from './stack-event-poller';
 export * from './stack-status';
 export { StackProgressMonitor } from './stack-progress-monitor';
+//# sourceMappingURL=index.d.ts.map

package/lib/api/stack-events/stack-activity-monitor.d.ts

@@ -23,7 +23,7 @@ export interface StackActivityMonitorProps {
      *
      * Used to calculate a progress bar.
      *
-     * @default - No progress reporting.
+     * @default - No progress reporting
      */
     readonly resourcesTotal?: number;
     /**
@@ -35,7 +35,7 @@ export interface StackActivityMonitorProps {
      * It is recommended to use this, otherwise the filtering will be subject
      * to clock drift between local and cloud machines.
      *
-     * @default - local machine's current time
+     * @default - Local machine's current time
      */
     readonly changeSetCreationTime?: Date;
     /**
@@ -98,3 +98,4 @@ export declare class StackActivityMonitor {
     private formatActivity;
     private checkForErrors;
 }
+//# sourceMappingURL=stack-activity-monitor.d.ts.map