@aws-cdk/cloudformation-diff 0.0.0

package/lib/diff/util.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEqual = deepEqual;
+exports.diffKeyedEntities = diffKeyedEntities;
+exports.unionOf = unionOf;
+exports.mangleLikeCloudFormation = mangleLikeCloudFormation;
+exports.loadResourceModel = loadResourceModel;
+const aws_service_spec_1 = require("@aws-cdk/aws-service-spec");
+/**
+ * Compares two objects for equality, deeply. The function handles arguments that are
+ * +null+, +undefined+, arrays and objects. For objects, the function will not take the
+ * object prototype into account for the purpose of the comparison, only the values of
+ * properties reported by +Object.keys+.
+ *
+ * If both operands can be parsed to equivalent numbers, will return true.
+ * This makes diff consistent with CloudFormation, where a numeric 10 and a literal "10"
+ * are considered equivalent.
+ *
+ * @param lvalue the left operand of the equality comparison.
+ * @param rvalue the right operand of the equality comparison.
+ *
+ * @returns +true+ if both +lvalue+ and +rvalue+ are equivalent to each other.
+ */
+function deepEqual(lvalue, rvalue) {
+    if (lvalue === rvalue) {
+        return true;
+    }
+    // CloudFormation allows passing strings into boolean-typed fields
+    if (((typeof lvalue === 'string' && typeof rvalue === 'boolean') ||
+        (typeof lvalue === 'boolean' && typeof rvalue === 'string')) &&
+        lvalue.toString() === rvalue.toString()) {
+        return true;
+    }
+    // allows a numeric 10 and a literal "10" to be equivalent;
+    // this is consistent with CloudFormation.
+    if ((typeof lvalue === 'string' || typeof rvalue === 'string') &&
+        safeParseFloat(lvalue) === safeParseFloat(rvalue)) {
+        return true;
+    }
+    if (typeof lvalue !== typeof rvalue) {
+        return false;
+    }
+    if (Array.isArray(lvalue) !== Array.isArray(rvalue)) {
+        return false;
+    }
+    if (Array.isArray(lvalue) /* && Array.isArray(rvalue) */) {
+        if (lvalue.length !== rvalue.length) {
+            return false;
+        }
+        for (let i = 0; i < lvalue.length; i++) {
+            if (!deepEqual(lvalue[i], rvalue[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (typeof lvalue === 'object' /* && typeof rvalue === 'object' */) {
+        if (lvalue === null || rvalue === null) {
+            // If both were null, they'd have been ===
+            return false;
+        }
+        const keys = Object.keys(lvalue);
+        if (keys.length !== Object.keys(rvalue).length) {
+            return false;
+        }
+        for (const key of keys) {
+            if (!rvalue.hasOwnProperty(key)) {
+                return false;
+            }
+            if (key === 'DependsOn') {
+                if (!dependsOnEqual(lvalue[key], rvalue[key])) {
+                    return false;
+                }
+                // check differences other than `DependsOn`
+                continue;
+            }
+            if (!deepEqual(lvalue[key], rvalue[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Neither object, nor array: I deduce this is primitive type
+    // Primitive type and not ===, so I deduce not deepEqual
+    return false;
+}
+/**
+ * Compares two arguments to DependsOn for equality.
+ *
+ * @param lvalue the left operand of the equality comparison.
+ * @param rvalue the right operand of the equality comparison.
+ *
+ * @returns +true+ if both +lvalue+ and +rvalue+ are equivalent to each other.
+ */
+function dependsOnEqual(lvalue, rvalue) {
+    // allows ['Value'] and 'Value' to be equal
+    if (Array.isArray(lvalue) !== Array.isArray(rvalue)) {
+        const array = Array.isArray(lvalue) ? lvalue : rvalue;
+        const nonArray = Array.isArray(lvalue) ? rvalue : lvalue;
+        if (array.length === 1 && deepEqual(array[0], nonArray)) {
+            return true;
+        }
+        return false;
+    }
+    // allows arrays passed to DependsOn to be equivalent irrespective of element order
+    if (Array.isArray(lvalue) && Array.isArray(rvalue)) {
+        if (lvalue.length !== rvalue.length) {
+            return false;
+        }
+        for (let i = 0; i < lvalue.length; i++) {
+            for (let j = 0; j < lvalue.length; j++) {
+                if ((!deepEqual(lvalue[i], rvalue[j])) && (j === lvalue.length - 1)) {
+                    return false;
+                }
+                break;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Produce the differences between two maps, as a map, using a specified diff function.
+ *
+ * @param oldValue  the old map.
+ * @param newValue  the new map.
+ * @param elementDiff the diff function.
+ *
+ * @returns a map representing the differences between +oldValue+ and +newValue+.
+ */
+function diffKeyedEntities(oldValue, newValue, elementDiff) {
+    const result = {};
+    for (const logicalId of unionOf(Object.keys(oldValue || {}), Object.keys(newValue || {}))) {
+        const oldElement = oldValue && oldValue[logicalId];
+        const newElement = newValue && newValue[logicalId];
+        if (oldElement === undefined && newElement === undefined) {
+            // Shouldn't happen in reality, but may happen in tests. Skip.
+            continue;
+        }
+        result[logicalId] = elementDiff(oldElement, newElement, logicalId);
+    }
+    return result;
+}
+/**
+ * Computes the union of two sets of strings.
+ *
+ * @param lv the left set of strings.
+ * @param rv the right set of strings.
+ *
+ * @returns a new array containing all elemebts from +lv+ and +rv+, with no duplicates.
+ */
+function unionOf(lv, rv) {
+    const result = new Set(lv);
+    for (const v of rv) {
+        result.add(v);
+    }
+    return new Array(...result);
+}
+/**
+ * GetStackTemplate flattens any codepoint greater than "\u7f" to "?". This is
+ * true even for codepoints in the supplemental planes which are represented
+ * in JS as surrogate pairs, all the way up to "\u{10ffff}".
+ *
+ * This function implements the same mangling in order to provide diagnostic
+ * information in `cdk diff`.
+ */
+function mangleLikeCloudFormation(payload) {
+    return payload.replace(/[\u{80}-\u{10ffff}]/gu, '?');
+}
+/**
+ * A parseFloat implementation that does the right thing for
+ * strings like '0.0.0'
+ * (for which JavaScript's parseFloat() returns 0).
+ * We return NaN for all of these strings that do not represent numbers,
+ * and so comparing them fails,
+ * and doesn't short-circuit the diff logic.
+ */
+function safeParseFloat(str) {
+    return Number(str);
+}
+/**
+ * Lazily load the service spec database and cache the loaded db
+ */
+let DATABASE;
+function database() {
+    if (!DATABASE) {
+        DATABASE = (0, aws_service_spec_1.loadAwsServiceSpecSync)();
+    }
+    return DATABASE;
+}
+/**
+ * Load a Resource model from the Service Spec Database
+ *
+ * The database is loaded lazily and cached across multiple calls to `loadResourceModel`.
+ */
+function loadResourceModel(type) {
+    return database().lookup('resource', 'cloudFormationType', 'equals', type)[0];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["util.ts"],"names":[],"mappings":"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","sourcesContent":["import { loadAwsServiceSpecSync } from '@aws-cdk/aws-service-spec';\nimport { Resource, SpecDatabase } from '@aws-cdk/service-spec-types';\n\n/**\n * Compares two objects for equality, deeply. The function handles arguments that are\n * +null+, +undefined+, arrays and objects. For objects, the function will not take the\n * object prototype into account for the purpose of the comparison, only the values of\n * properties reported by +Object.keys+.\n *\n * If both operands can be parsed to equivalent numbers, will return true.\n * This makes diff consistent with CloudFormation, where a numeric 10 and a literal \"10\"\n * are considered equivalent.\n *\n * @param lvalue the left operand of the equality comparison.\n * @param rvalue the right operand of the equality comparison.\n *\n * @returns +true+ if both +lvalue+ and +rvalue+ are equivalent to each other.\n */\nexport function deepEqual(lvalue: any, rvalue: any): boolean {\n  if (lvalue === rvalue) { return true; }\n  // CloudFormation allows passing strings into boolean-typed fields\n  if (((typeof lvalue === 'string' && typeof rvalue === 'boolean') ||\n      (typeof lvalue === 'boolean' && typeof rvalue === 'string')) &&\n      lvalue.toString() === rvalue.toString()) {\n    return true;\n  }\n  // allows a numeric 10 and a literal \"10\" to be equivalent;\n  // this is consistent with CloudFormation.\n  if ((typeof lvalue === 'string' || typeof rvalue === 'string') &&\n      safeParseFloat(lvalue) === safeParseFloat(rvalue)) {\n    return true;\n  }\n  if (typeof lvalue !== typeof rvalue) { return false; }\n  if (Array.isArray(lvalue) !== Array.isArray(rvalue)) { return false; }\n  if (Array.isArray(lvalue) /* && Array.isArray(rvalue) */) {\n    if (lvalue.length !== rvalue.length) { return false; }\n    for (let i = 0 ; i < lvalue.length ; i++) {\n      if (!deepEqual(lvalue[i], rvalue[i])) { return false; }\n    }\n    return true;\n  }\n  if (typeof lvalue === 'object' /* && typeof rvalue === 'object' */) {\n    if (lvalue === null || rvalue === null) {\n      // If both were null, they'd have been ===\n      return false;\n    }\n    const keys = Object.keys(lvalue);\n    if (keys.length !== Object.keys(rvalue).length) { return false; }\n    for (const key of keys) {\n      if (!rvalue.hasOwnProperty(key)) { return false; }\n      if (key === 'DependsOn') {\n        if (!dependsOnEqual(lvalue[key], rvalue[key])) { return false; }\n        // check differences other than `DependsOn`\n        continue;\n      }\n      if (!deepEqual(lvalue[key], rvalue[key])) { return false; }\n    }\n    return true;\n  }\n  // Neither object, nor array: I deduce this is primitive type\n  // Primitive type and not ===, so I deduce not deepEqual\n  return false;\n}\n\n/**\n * Compares two arguments to DependsOn for equality.\n *\n * @param lvalue the left operand of the equality comparison.\n * @param rvalue the right operand of the equality comparison.\n *\n * @returns +true+ if both +lvalue+ and +rvalue+ are equivalent to each other.\n */\nfunction dependsOnEqual(lvalue: any, rvalue: any): boolean {\n  // allows ['Value'] and 'Value' to be equal\n  if (Array.isArray(lvalue) !== Array.isArray(rvalue)) {\n    const array = Array.isArray(lvalue) ? lvalue : rvalue;\n    const nonArray = Array.isArray(lvalue) ? rvalue : lvalue;\n\n    if (array.length === 1 && deepEqual(array[0], nonArray)) {\n      return true;\n    }\n    return false;\n  }\n\n  // allows arrays passed to DependsOn to be equivalent irrespective of element order\n  if (Array.isArray(lvalue) && Array.isArray(rvalue)) {\n    if (lvalue.length !== rvalue.length) { return false; }\n    for (let i = 0 ; i < lvalue.length ; i++) {\n      for (let j = 0 ; j < lvalue.length ; j++) {\n        if ((!deepEqual(lvalue[i], rvalue[j])) && (j === lvalue.length - 1)) {\n          return false;\n        }\n        break;\n      }\n    }\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Produce the differences between two maps, as a map, using a specified diff function.\n *\n * @param oldValue  the old map.\n * @param newValue  the new map.\n * @param elementDiff the diff function.\n *\n * @returns a map representing the differences between +oldValue+ and +newValue+.\n */\nexport function diffKeyedEntities<T>(\n  oldValue: { [key: string]: any } | undefined,\n  newValue: { [key: string]: any } | undefined,\n  elementDiff: (oldElement: any, newElement: any, key: string) => T): { [name: string]: T } {\n  const result: { [name: string]: T } = {};\n  for (const logicalId of unionOf(Object.keys(oldValue || {}), Object.keys(newValue || {}))) {\n    const oldElement = oldValue && oldValue[logicalId];\n    const newElement = newValue && newValue[logicalId];\n\n    if (oldElement === undefined && newElement === undefined) {\n      // Shouldn't happen in reality, but may happen in tests. Skip.\n      continue;\n    }\n\n    result[logicalId] = elementDiff(oldElement, newElement, logicalId);\n  }\n  return result;\n}\n\n/**\n * Computes the union of two sets of strings.\n *\n * @param lv the left set of strings.\n * @param rv the right set of strings.\n *\n * @returns a new array containing all elemebts from +lv+ and +rv+, with no duplicates.\n */\nexport function unionOf(lv: string[] | Set<string>, rv: string[] | Set<string>): string[] {\n  const result = new Set(lv);\n  for (const v of rv) {\n    result.add(v);\n  }\n  return new Array(...result);\n}\n\n/**\n * GetStackTemplate flattens any codepoint greater than \"\\u7f\" to \"?\". This is\n * true even for codepoints in the supplemental planes which are represented\n * in JS as surrogate pairs, all the way up to \"\\u{10ffff}\".\n *\n * This function implements the same mangling in order to provide diagnostic\n * information in `cdk diff`.\n */\nexport function mangleLikeCloudFormation(payload: string) {\n  return payload.replace(/[\\u{80}-\\u{10ffff}]/gu, '?');\n}\n\n/**\n * A parseFloat implementation that does the right thing for\n * strings like '0.0.0'\n * (for which JavaScript's parseFloat() returns 0).\n * We return NaN for all of these strings that do not represent numbers,\n * and so comparing them fails,\n * and doesn't short-circuit the diff logic.\n */\nfunction safeParseFloat(str: string): number {\n  return Number(str);\n}\n\n/**\n * Lazily load the service spec database and cache the loaded db\n */\nlet DATABASE: SpecDatabase | undefined;\nfunction database(): SpecDatabase {\n  if (!DATABASE) {\n    DATABASE = loadAwsServiceSpecSync();\n  }\n  return DATABASE;\n}\n\n/**\n * Load a Resource model from the Service Spec Database\n *\n * The database is loaded lazily and cached across multiple calls to `loadResourceModel`.\n */\nexport function loadResourceModel(type: string): Resource | undefined {\n  return database().lookup('resource', 'cloudFormationType', 'equals', type)[0];\n}\n"]}

package/lib/diff-template.d.ts

@@ -0,0 +1,25 @@
+import type { DescribeChangeSetOutput as DescribeChangeSet } from '@aws-sdk/client-cloudformation';
+import * as types from './diff/types';
+export * from './diff/types';
+export type DescribeChangeSetOutput = DescribeChangeSet;
+/**
+ * Compare two CloudFormation templates and return semantic differences between them.
+ *
+ * @param currentTemplate the current state of the stack.
+ * @param newTemplate     the target state of the stack.
+ * @param changeSet       the change set for this stack.
+ *
+ * @returns a +types.TemplateDiff+ object that represents the changes that will happen if
+ *      a stack which current state is described by +currentTemplate+ is updated with
+ *      the template +newTemplate+.
+ */
+export declare function fullDiff(currentTemplate: {
+    [key: string]: any;
+}, newTemplate: {
+    [key: string]: any;
+}, changeSet?: DescribeChangeSetOutput, isImport?: boolean): types.TemplateDiff;
+export declare function diffTemplate(currentTemplate: {
+    [key: string]: any;
+}, newTemplate: {
+    [key: string]: any;
+}): types.TemplateDiff;

package/lib/diff-template.js

@@ -0,0 +1,212 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullDiff = fullDiff;
+exports.diffTemplate = diffTemplate;
+const impl = require("./diff");
+const template_and_changeset_diff_merger_1 = require("./diff/template-and-changeset-diff-merger");
+const types = require("./diff/types");
+const util_1 = require("./diff/util");
+__exportStar(require("./diff/types"), exports);
+const DIFF_HANDLERS = {
+    AWSTemplateFormatVersion: (diff, oldValue, newValue) => diff.awsTemplateFormatVersion = impl.diffAttribute(oldValue, newValue),
+    Description: (diff, oldValue, newValue) => diff.description = impl.diffAttribute(oldValue, newValue),
+    Metadata: (diff, oldValue, newValue) => diff.metadata = new types.DifferenceCollection((0, util_1.diffKeyedEntities)(oldValue, newValue, impl.diffMetadata)),
+    Parameters: (diff, oldValue, newValue) => diff.parameters = new types.DifferenceCollection((0, util_1.diffKeyedEntities)(oldValue, newValue, impl.diffParameter)),
+    Mappings: (diff, oldValue, newValue) => diff.mappings = new types.DifferenceCollection((0, util_1.diffKeyedEntities)(oldValue, newValue, impl.diffMapping)),
+    Conditions: (diff, oldValue, newValue) => diff.conditions = new types.DifferenceCollection((0, util_1.diffKeyedEntities)(oldValue, newValue, impl.diffCondition)),
+    Transform: (diff, oldValue, newValue) => diff.transform = impl.diffAttribute(oldValue, newValue),
+    Resources: (diff, oldValue, newValue) => diff.resources = new types.DifferenceCollection((0, util_1.diffKeyedEntities)(oldValue, newValue, impl.diffResource)),
+    Outputs: (diff, oldValue, newValue) => diff.outputs = new types.DifferenceCollection((0, util_1.diffKeyedEntities)(oldValue, newValue, impl.diffOutput)),
+};
+/**
+ * Compare two CloudFormation templates and return semantic differences between them.
+ *
+ * @param currentTemplate the current state of the stack.
+ * @param newTemplate     the target state of the stack.
+ * @param changeSet       the change set for this stack.
+ *
+ * @returns a +types.TemplateDiff+ object that represents the changes that will happen if
+ *      a stack which current state is described by +currentTemplate+ is updated with
+ *      the template +newTemplate+.
+ */
+function fullDiff(currentTemplate, newTemplate, changeSet, isImport) {
+    normalize(currentTemplate);
+    normalize(newTemplate);
+    const theDiff = diffTemplate(currentTemplate, newTemplate);
+    if (changeSet) {
+        // These methods mutate the state of theDiff, using the changeSet.
+        const changeSetDiff = new template_and_changeset_diff_merger_1.TemplateAndChangeSetDiffMerger({ changeSet });
+        theDiff.resources.forEachDifference((logicalId, change) => changeSetDiff.overrideDiffResourceChangeImpactWithChangeSetChangeImpact(logicalId, change));
+        changeSetDiff.addImportInformationFromChangeset(theDiff.resources);
+    }
+    else if (isImport) {
+        makeAllResourceChangesImports(theDiff);
+    }
+    return theDiff;
+}
+function diffTemplate(currentTemplate, newTemplate) {
+    // Base diff
+    const theDiff = calculateTemplateDiff(currentTemplate, newTemplate);
+    // We're going to modify this in-place
+    const newTemplateCopy = deepCopy(newTemplate);
+    let didPropagateReferenceChanges;
+    let diffWithReplacements;
+    do {
+        diffWithReplacements = calculateTemplateDiff(currentTemplate, newTemplateCopy);
+        // Propagate replacements for replaced resources
+        didPropagateReferenceChanges = false;
+        if (diffWithReplacements.resources) {
+            diffWithReplacements.resources.forEachDifference((logicalId, change) => {
+                if (change.changeImpact === types.ResourceImpact.WILL_REPLACE) {
+                    if (propagateReplacedReferences(newTemplateCopy, logicalId)) {
+                        didPropagateReferenceChanges = true;
+                    }
+                }
+            });
+        }
+    } while (didPropagateReferenceChanges);
+    // Copy "replaced" states from `diffWithReplacements` to `theDiff`.
+    diffWithReplacements.resources
+        .filter(r => isReplacement(r.changeImpact))
+        .forEachDifference((logicalId, downstreamReplacement) => {
+        const resource = theDiff.resources.get(logicalId);
+        if (resource.changeImpact !== downstreamReplacement.changeImpact) {
+            propagatePropertyReplacement(downstreamReplacement, resource);
+        }
+    });
+    return theDiff;
+}
+function isReplacement(impact) {
+    return impact === types.ResourceImpact.MAY_REPLACE || impact === types.ResourceImpact.WILL_REPLACE;
+}
+/**
+ * For all properties in 'source' that have a "replacement" impact, propagate that impact to "dest"
+ */
+function propagatePropertyReplacement(source, dest) {
+    for (const [propertyName, diff] of Object.entries(source.propertyUpdates)) {
+        if (diff.changeImpact && isReplacement(diff.changeImpact)) {
+            // Use the propertydiff of source in target. The result of this happens to be clear enough.
+            dest.setPropertyChange(propertyName, diff);
+        }
+    }
+}
+function calculateTemplateDiff(currentTemplate, newTemplate) {
+    const differences = {};
+    const unknown = {};
+    for (const key of (0, util_1.unionOf)(Object.keys(currentTemplate), Object.keys(newTemplate)).sort()) {
+        const oldValue = currentTemplate[key];
+        const newValue = newTemplate[key];
+        if ((0, util_1.deepEqual)(oldValue, newValue)) {
+            continue;
+        }
+        const handler = DIFF_HANDLERS[key]
+            || ((_diff, oldV, newV) => unknown[key] = impl.diffUnknown(oldV, newV));
+        handler(differences, oldValue, newValue);
+    }
+    if (Object.keys(unknown).length > 0) {
+        differences.unknown = new types.DifferenceCollection(unknown);
+    }
+    return new types.TemplateDiff(differences);
+}
+/**
+ * Replace all references to the given logicalID on the given template, in-place
+ *
+ * Returns true if any references were replaced.
+ */
+function propagateReplacedReferences(template, logicalId) {
+    let ret = false;
+    function recurse(obj) {
+        if (Array.isArray(obj)) {
+            obj.forEach(recurse);
+        }
+        if (typeof obj === 'object' && obj !== null) {
+            if (!replaceReference(obj)) {
+                Object.values(obj).forEach(recurse);
+            }
+        }
+    }
+    function replaceReference(obj) {
+        const keys = Object.keys(obj);
+        if (keys.length !== 1) {
+            return false;
+        }
+        const key = keys[0];
+        if (key === 'Ref') {
+            if (obj.Ref === logicalId) {
+                obj.Ref = logicalId + ' (replaced)';
+                ret = true;
+            }
+            return true;
+        }
+        if (key.startsWith('Fn::')) {
+            if (Array.isArray(obj[key]) && obj[key].length > 0 && obj[key][0] === logicalId) {
+                obj[key][0] = logicalId + '(replaced)';
+                ret = true;
+            }
+            return true;
+        }
+        return false;
+    }
+    recurse(template);
+    return ret;
+}
+function deepCopy(x) {
+    if (Array.isArray(x)) {
+        return x.map(deepCopy);
+    }
+    if (typeof x === 'object' && x !== null) {
+        const ret = {};
+        for (const key of Object.keys(x)) {
+            ret[key] = deepCopy(x[key]);
+        }
+        return ret;
+    }
+    return x;
+}
+function makeAllResourceChangesImports(diff) {
+    diff.resources.forEachDifference((_logicalId, change) => {
+        change.isImport = true;
+    });
+}
+function normalize(template) {
+    if (typeof template === 'object') {
+        for (const key of (Object.keys(template !== null && template !== void 0 ? template : {}))) {
+            if (key === 'Fn::GetAtt' && typeof template[key] === 'string') {
+                template[key] = template[key].split('.');
+                continue;
+            }
+            else if (key === 'DependsOn') {
+                if (typeof template[key] === 'string') {
+                    template[key] = [template[key]];
+                }
+                else if (Array.isArray(template[key])) {
+                    template[key] = template[key].sort();
+                }
+                continue;
+            }
+            if (Array.isArray(template[key])) {
+                for (const element of (template[key])) {
+                    normalize(element);
+                }
+            }
+            else {
+                normalize(template[key]);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diff-template.js","sourceRoot":"","sources":["diff-template.ts"],"names":[],"mappings":"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","sourcesContent":["// The SDK is only used to reference `DescribeChangeSetOutput`, so the SDK is added as a devDependency.\n// The SDK should not make network calls here\nimport type { DescribeChangeSetOutput as DescribeChangeSet } from '@aws-sdk/client-cloudformation';\nimport * as impl from './diff';\nimport { TemplateAndChangeSetDiffMerger } from './diff/template-and-changeset-diff-merger';\nimport * as types from './diff/types';\nimport { deepEqual, diffKeyedEntities, unionOf } from './diff/util';\n\nexport * from './diff/types';\n\nexport type DescribeChangeSetOutput = DescribeChangeSet;\n\ntype DiffHandler = (diff: types.ITemplateDiff, oldValue: any, newValue: any) => void;\ntype HandlerRegistry = { [section: string]: DiffHandler };\n\nconst DIFF_HANDLERS: HandlerRegistry = {\n  AWSTemplateFormatVersion: (diff, oldValue, newValue) =>\n    diff.awsTemplateFormatVersion = impl.diffAttribute(oldValue, newValue),\n  Description: (diff, oldValue, newValue) =>\n    diff.description = impl.diffAttribute(oldValue, newValue),\n  Metadata: (diff, oldValue, newValue) =>\n    diff.metadata = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffMetadata)),\n  Parameters: (diff, oldValue, newValue) =>\n    diff.parameters = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffParameter)),\n  Mappings: (diff, oldValue, newValue) =>\n    diff.mappings = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffMapping)),\n  Conditions: (diff, oldValue, newValue) =>\n    diff.conditions = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffCondition)),\n  Transform: (diff, oldValue, newValue) =>\n    diff.transform = impl.diffAttribute(oldValue, newValue),\n  Resources: (diff, oldValue, newValue) =>\n    diff.resources = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffResource)),\n  Outputs: (diff, oldValue, newValue) =>\n    diff.outputs = new types.DifferenceCollection(diffKeyedEntities(oldValue, newValue, impl.diffOutput)),\n};\n\n/**\n * Compare two CloudFormation templates and return semantic differences between them.\n *\n * @param currentTemplate the current state of the stack.\n * @param newTemplate     the target state of the stack.\n * @param changeSet       the change set for this stack.\n *\n * @returns a +types.TemplateDiff+ object that represents the changes that will happen if\n *      a stack which current state is described by +currentTemplate+ is updated with\n *      the template +newTemplate+.\n */\nexport function fullDiff(\n  currentTemplate: { [key: string]: any },\n  newTemplate: { [key: string]: any },\n  changeSet?: DescribeChangeSetOutput,\n  isImport?: boolean,\n): types.TemplateDiff {\n  normalize(currentTemplate);\n  normalize(newTemplate);\n  const theDiff = diffTemplate(currentTemplate, newTemplate);\n  if (changeSet) {\n    // These methods mutate the state of theDiff, using the changeSet.\n    const changeSetDiff = new TemplateAndChangeSetDiffMerger({ changeSet });\n    theDiff.resources.forEachDifference((logicalId: string, change: types.ResourceDifference) =>\n      changeSetDiff.overrideDiffResourceChangeImpactWithChangeSetChangeImpact(logicalId, change),\n    );\n    changeSetDiff.addImportInformationFromChangeset(theDiff.resources);\n  } else if (isImport) {\n    makeAllResourceChangesImports(theDiff);\n  }\n\n  return theDiff;\n}\n\nexport function diffTemplate(\n  currentTemplate: { [key: string]: any },\n  newTemplate: { [key: string]: any },\n): types.TemplateDiff {\n  // Base diff\n  const theDiff = calculateTemplateDiff(currentTemplate, newTemplate);\n\n  // We're going to modify this in-place\n  const newTemplateCopy = deepCopy(newTemplate);\n\n  let didPropagateReferenceChanges;\n  let diffWithReplacements;\n  do {\n    diffWithReplacements = calculateTemplateDiff(currentTemplate, newTemplateCopy);\n\n    // Propagate replacements for replaced resources\n    didPropagateReferenceChanges = false;\n    if (diffWithReplacements.resources) {\n      diffWithReplacements.resources.forEachDifference((logicalId, change) => {\n        if (change.changeImpact === types.ResourceImpact.WILL_REPLACE) {\n          if (propagateReplacedReferences(newTemplateCopy, logicalId)) {\n            didPropagateReferenceChanges = true;\n          }\n        }\n      });\n    }\n  } while (didPropagateReferenceChanges);\n\n  // Copy \"replaced\" states from `diffWithReplacements` to `theDiff`.\n  diffWithReplacements.resources\n    .filter(r => isReplacement(r!.changeImpact))\n    .forEachDifference((logicalId, downstreamReplacement) => {\n      const resource = theDiff.resources.get(logicalId);\n\n      if (resource.changeImpact !== downstreamReplacement.changeImpact) {\n        propagatePropertyReplacement(downstreamReplacement, resource);\n      }\n    });\n\n  return theDiff;\n}\n\nfunction isReplacement(impact: types.ResourceImpact) {\n  return impact === types.ResourceImpact.MAY_REPLACE || impact === types.ResourceImpact.WILL_REPLACE;\n}\n\n/**\n * For all properties in 'source' that have a \"replacement\" impact, propagate that impact to \"dest\"\n */\nfunction propagatePropertyReplacement(source: types.ResourceDifference, dest: types.ResourceDifference) {\n  for (const [propertyName, diff] of Object.entries(source.propertyUpdates)) {\n    if (diff.changeImpact && isReplacement(diff.changeImpact)) {\n      // Use the propertydiff of source in target. The result of this happens to be clear enough.\n      dest.setPropertyChange(propertyName, diff);\n    }\n  }\n}\n\nfunction calculateTemplateDiff(currentTemplate: { [key: string]: any }, newTemplate: { [key: string]: any }): types.TemplateDiff {\n  const differences: types.ITemplateDiff = {};\n  const unknown: { [key: string]: types.Difference<any> } = {};\n  for (const key of unionOf(Object.keys(currentTemplate), Object.keys(newTemplate)).sort()) {\n    const oldValue = currentTemplate[key];\n    const newValue = newTemplate[key];\n    if (deepEqual(oldValue, newValue)) {\n      continue;\n    }\n    const handler: DiffHandler = DIFF_HANDLERS[key]\n                  || ((_diff, oldV, newV) => unknown[key] = impl.diffUnknown(oldV, newV));\n    handler(differences, oldValue, newValue);\n  }\n  if (Object.keys(unknown).length > 0) {\n    differences.unknown = new types.DifferenceCollection(unknown);\n  }\n\n  return new types.TemplateDiff(differences);\n}\n\n/**\n * Replace all references to the given logicalID on the given template, in-place\n *\n * Returns true if any references were replaced.\n */\nfunction propagateReplacedReferences(template: object, logicalId: string): boolean {\n  let ret = false;\n\n  function recurse(obj: any) {\n    if (Array.isArray(obj)) {\n      obj.forEach(recurse);\n    }\n\n    if (typeof obj === 'object' && obj !== null) {\n      if (!replaceReference(obj)) {\n        Object.values(obj).forEach(recurse);\n      }\n    }\n  }\n\n  function replaceReference(obj: any) {\n    const keys = Object.keys(obj);\n    if (keys.length !== 1) { return false; }\n    const key = keys[0];\n\n    if (key === 'Ref') {\n      if (obj.Ref === logicalId) {\n        obj.Ref = logicalId + ' (replaced)';\n        ret = true;\n      }\n      return true;\n    }\n\n    if (key.startsWith('Fn::')) {\n      if (Array.isArray(obj[key]) && obj[key].length > 0 && obj[key][0] === logicalId) {\n        obj[key][0] = logicalId + '(replaced)';\n        ret = true;\n      }\n      return true;\n    }\n\n    return false;\n  }\n\n  recurse(template);\n  return ret;\n}\n\nfunction deepCopy(x: any): any {\n  if (Array.isArray(x)) {\n    return x.map(deepCopy);\n  }\n\n  if (typeof x === 'object' && x !== null) {\n    const ret: any = {};\n    for (const key of Object.keys(x)) {\n      ret[key] = deepCopy(x[key]);\n    }\n    return ret;\n  }\n\n  return x;\n}\n\nfunction makeAllResourceChangesImports(diff: types.TemplateDiff) {\n  diff.resources.forEachDifference((_logicalId: string, change: types.ResourceDifference) => {\n    change.isImport = true;\n  });\n}\n\nfunction normalize(template: any) {\n  if (typeof template === 'object') {\n    for (const key of (Object.keys(template ?? {}))) {\n      if (key === 'Fn::GetAtt' && typeof template[key] === 'string') {\n        template[key] = template[key].split('.');\n        continue;\n      } else if (key === 'DependsOn') {\n        if (typeof template[key] === 'string') {\n          template[key] = [template[key]];\n        } else if (Array.isArray(template[key])) {\n          template[key] = template[key].sort();\n        }\n        continue;\n      }\n\n      if (Array.isArray(template[key])) {\n        for (const element of (template[key])) {\n          normalize(element);\n        }\n      } else {\n        normalize(template[key]);\n      }\n    }\n  }\n}\n"]}

package/lib/diffable.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Calculate differences of immutable elements
+ */
+export declare class DiffableCollection<T extends Eq<T>> {
+    readonly additions: T[];
+    readonly removals: T[];
+    private readonly oldElements;
+    private readonly newElements;
+    addOld(...elements: T[]): void;
+    addNew(...elements: T[]): void;
+    calculateDiff(): void;
+    get hasChanges(): boolean;
+    get hasAdditions(): boolean;
+    get hasRemovals(): boolean;
+}
+/**
+ * Things that can be compared to themselves (by value)
+ */
+interface Eq<T> {
+    equal(other: T): boolean;
+}
+export {};

package/lib/diffable.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffableCollection = void 0;
+/**
+ * Calculate differences of immutable elements
+ */
+class DiffableCollection {
+    constructor() {
+        this.additions = [];
+        this.removals = [];
+        this.oldElements = [];
+        this.newElements = [];
+    }
+    addOld(...elements) {
+        this.oldElements.push(...elements);
+    }
+    addNew(...elements) {
+        this.newElements.push(...elements);
+    }
+    calculateDiff() {
+        this.additions.push(...difference(this.newElements, this.oldElements));
+        this.removals.push(...difference(this.oldElements, this.newElements));
+    }
+    get hasChanges() {
+        return this.additions.length + this.removals.length > 0;
+    }
+    get hasAdditions() {
+        return this.additions.length > 0;
+    }
+    get hasRemovals() {
+        return this.removals.length > 0;
+    }
+}
+exports.DiffableCollection = DiffableCollection;
+/**
+ * Whether a collection contains some element (by value)
+ */
+function contains(element, xs) {
+    return xs.some(x => x.equal(element));
+}
+/**
+ * Return collection except for elements
+ */
+function difference(collection, elements) {
+    return collection.filter(x => !contains(x, elements));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/format-table.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Render a two-dimensional array to a visually attractive table
+ *
+ * First row is considered the table header.
+ */
+export declare function formatTable(cells: string[][], columns: number | undefined): string;