cdk-common 0.0.67 → 2.0.2

package/node_modules/@aws-cdk/cloudformation-diff/lib/diff/types.js

@@ -0,0 +1,456 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPropertyDifference = exports.ResourceDifference = exports.ResourceImpact = exports.ParameterDifference = exports.OutputDifference = exports.MetadataDifference = exports.MappingDifference = exports.ConditionDifference = exports.DifferenceCollection = exports.PropertyDifference = exports.Difference = exports.TemplateDiff = void 0;
+const assert_1 = require("assert");
+const cfnspec = require("@aws-cdk/cfnspec");
+const iam_changes_1 = require("../iam/iam-changes");
+const security_group_changes_1 = require("../network/security-group-changes");
+const util_1 = require("./util");
+/** Semantic differences between two CloudFormation templates. */
+class TemplateDiff {
+    constructor(args) {
+        if (args.awsTemplateFormatVersion !== undefined) {
+            this.awsTemplateFormatVersion = args.awsTemplateFormatVersion;
+        }
+        if (args.description !== undefined) {
+            this.description = args.description;
+        }
+        if (args.transform !== undefined) {
+            this.transform = args.transform;
+        }
+        this.conditions = args.conditions || new DifferenceCollection({});
+        this.mappings = args.mappings || new DifferenceCollection({});
+        this.metadata = args.metadata || new DifferenceCollection({});
+        this.outputs = args.outputs || new DifferenceCollection({});
+        this.parameters = args.parameters || new DifferenceCollection({});
+        this.resources = args.resources || new DifferenceCollection({});
+        this.unknown = args.unknown || new DifferenceCollection({});
+        this.iamChanges = new iam_changes_1.IamChanges({
+            propertyChanges: this.scrutinizablePropertyChanges(iam_changes_1.IamChanges.IamPropertyScrutinies),
+            resourceChanges: this.scrutinizableResourceChanges(iam_changes_1.IamChanges.IamResourceScrutinies),
+        });
+        this.securityGroupChanges = new security_group_changes_1.SecurityGroupChanges({
+            egressRulePropertyChanges: this.scrutinizablePropertyChanges([cfnspec.schema.PropertyScrutinyType.EgressRules]),
+            ingressRulePropertyChanges: this.scrutinizablePropertyChanges([cfnspec.schema.PropertyScrutinyType.IngressRules]),
+            egressRuleResourceChanges: this.scrutinizableResourceChanges([cfnspec.schema.ResourceScrutinyType.EgressRuleResource]),
+            ingressRuleResourceChanges: this.scrutinizableResourceChanges([cfnspec.schema.ResourceScrutinyType.IngressRuleResource]),
+        });
+    }
+    get differenceCount() {
+        let count = 0;
+        if (this.awsTemplateFormatVersion !== undefined) {
+            count += 1;
+        }
+        if (this.description !== undefined) {
+            count += 1;
+        }
+        if (this.transform !== undefined) {
+            count += 1;
+        }
+        count += this.conditions.differenceCount;
+        count += this.mappings.differenceCount;
+        count += this.metadata.differenceCount;
+        count += this.outputs.differenceCount;
+        count += this.parameters.differenceCount;
+        count += this.resources.differenceCount;
+        count += this.unknown.differenceCount;
+        return count;
+    }
+    get isEmpty() {
+        return this.differenceCount === 0;
+    }
+    /**
+     * Return true if any of the permissions objects involve a broadening of permissions
+     */
+    get permissionsBroadened() {
+        return this.iamChanges.permissionsBroadened || this.securityGroupChanges.rulesAdded;
+    }
+    /**
+     * Return true if any of the permissions objects have changed
+     */
+    get permissionsAnyChanges() {
+        return this.iamChanges.hasChanges || this.securityGroupChanges.hasChanges;
+    }
+    /**
+     * Return all property changes of a given scrutiny type
+     *
+     * We don't just look at property updates; we also look at resource additions and deletions (in which
+     * case there is no further detail on property values), and resource type changes.
+     */
+    scrutinizablePropertyChanges(scrutinyTypes) {
+        const ret = new Array();
+        for (const [resourceLogicalId, resourceChange] of Object.entries(this.resources.changes)) {
+            if (!resourceChange) {
+                continue;
+            }
+            const props = cfnspec.scrutinizablePropertyNames(resourceChange.newResourceType, scrutinyTypes);
+            for (const propertyName of props) {
+                ret.push({
+                    resourceLogicalId,
+                    propertyName,
+                    resourceType: resourceChange.resourceType,
+                    scrutinyType: cfnspec.propertySpecification(resourceChange.resourceType, propertyName).ScrutinyType,
+                    oldValue: resourceChange.oldProperties && resourceChange.oldProperties[propertyName],
+                    newValue: resourceChange.newProperties && resourceChange.newProperties[propertyName],
+                });
+            }
+        }
+        return ret;
+    }
+    /**
+     * Return all resource changes of a given scrutiny type
+     *
+     * We don't just look at resource updates; we also look at resource additions and deletions (in which
+     * case there is no further detail on property values), and resource type changes.
+     */
+    scrutinizableResourceChanges(scrutinyTypes) {
+        const ret = new Array();
+        const scrutinizableTypes = new Set(cfnspec.scrutinizableResourceTypes(scrutinyTypes));
+        for (const [resourceLogicalId, resourceChange] of Object.entries(this.resources.changes)) {
+            if (!resourceChange) {
+                continue;
+            }
+            const commonProps = {
+                oldProperties: resourceChange.oldProperties,
+                newProperties: resourceChange.newProperties,
+                resourceLogicalId,
+            };
+            // Even though it's not physically possible in CFN, let's pretend to handle a change of 'Type'.
+            if (resourceChange.resourceTypeChanged) {
+                // Treat as DELETE+ADD
+                if (scrutinizableTypes.has(resourceChange.oldResourceType)) {
+                    ret.push({
+                        ...commonProps,
+                        newProperties: undefined,
+                        resourceType: resourceChange.oldResourceType,
+                        scrutinyType: cfnspec.resourceSpecification(resourceChange.oldResourceType).ScrutinyType,
+                    });
+                }
+                if (scrutinizableTypes.has(resourceChange.newResourceType)) {
+                    ret.push({
+                        ...commonProps,
+                        oldProperties: undefined,
+                        resourceType: resourceChange.newResourceType,
+                        scrutinyType: cfnspec.resourceSpecification(resourceChange.newResourceType).ScrutinyType,
+                    });
+                }
+            }
+            else {
+                if (scrutinizableTypes.has(resourceChange.resourceType)) {
+                    ret.push({
+                        ...commonProps,
+                        resourceType: resourceChange.resourceType,
+                        scrutinyType: cfnspec.resourceSpecification(resourceChange.resourceType).ScrutinyType,
+                    });
+                }
+            }
+        }
+        return ret;
+    }
+}
+exports.TemplateDiff = TemplateDiff;
+/**
+ * Models an entity that changed between two versions of a CloudFormation template.
+ */
+class Difference {
+    /**
+     * @param oldValue the old value, cannot be equal (to the sense of +deepEqual+) to +newValue+.
+     * @param newValue the new value, cannot be equal (to the sense of +deepEqual+) to +oldValue+.
+     */
+    constructor(oldValue, newValue) {
+        this.oldValue = oldValue;
+        this.newValue = newValue;
+        if (oldValue === undefined && newValue === undefined) {
+            throw new assert_1.AssertionError({ message: 'oldValue and newValue are both undefined!' });
+        }
+        this.isDifferent = !util_1.deepEqual(oldValue, newValue);
+    }
+    /** @returns +true+ if the element is new to the template. */
+    get isAddition() {
+        return this.oldValue === undefined;
+    }
+    /** @returns +true+ if the element was removed from the template. */
+    get isRemoval() {
+        return this.newValue === undefined;
+    }
+    /** @returns +true+ if the element was already in the template and is updated. */
+    get isUpdate() {
+        return this.oldValue !== undefined
+            && this.newValue !== undefined;
+    }
+}
+exports.Difference = Difference;
+class PropertyDifference extends Difference {
+    constructor(oldValue, newValue, args) {
+        super(oldValue, newValue);
+        this.changeImpact = args.changeImpact;
+    }
+}
+exports.PropertyDifference = PropertyDifference;
+class DifferenceCollection {
+    constructor(diffs) {
+        this.diffs = diffs;
+    }
+    get changes() {
+        return onlyChanges(this.diffs);
+    }
+    get differenceCount() {
+        return Object.values(this.changes).length;
+    }
+    get(logicalId) {
+        const ret = this.diffs[logicalId];
+        if (!ret) {
+            throw new Error(`No object with logical ID '${logicalId}'`);
+        }
+        return ret;
+    }
+    get logicalIds() {
+        return Object.keys(this.changes);
+    }
+    /**
+     * Returns a new TemplateDiff which only contains changes for which `predicate`
+     * returns `true`.
+     */
+    filter(predicate) {
+        const newChanges = {};
+        for (const id of Object.keys(this.changes)) {
+            const diff = this.changes[id];
+            if (predicate(diff)) {
+                newChanges[id] = diff;
+            }
+        }
+        return new DifferenceCollection(newChanges);
+    }
+    /**
+     * Invokes `cb` for all changes in this collection.
+     *
+     * Changes will be sorted as follows:
+     *  - Removed
+     *  - Added
+     *  - Updated
+     *  - Others
+     *
+     * @param cb
+     */
+    forEachDifference(cb) {
+        const removed = new Array();
+        const added = new Array();
+        const updated = new Array();
+        const others = new Array();
+        for (const logicalId of this.logicalIds) {
+            const change = this.changes[logicalId];
+            if (change.isAddition) {
+                added.push({ logicalId, change });
+            }
+            else if (change.isRemoval) {
+                removed.push({ logicalId, change });
+            }
+            else if (change.isUpdate) {
+                updated.push({ logicalId, change });
+            }
+            else if (change.isDifferent) {
+                others.push({ logicalId, change });
+            }
+        }
+        removed.forEach(v => cb(v.logicalId, v.change));
+        added.forEach(v => cb(v.logicalId, v.change));
+        updated.forEach(v => cb(v.logicalId, v.change));
+        others.forEach(v => cb(v.logicalId, v.change));
+    }
+}
+exports.DifferenceCollection = DifferenceCollection;
+class ConditionDifference extends Difference {
+}
+exports.ConditionDifference = ConditionDifference;
+class MappingDifference extends Difference {
+}
+exports.MappingDifference = MappingDifference;
+class MetadataDifference extends Difference {
+}
+exports.MetadataDifference = MetadataDifference;
+class OutputDifference extends Difference {
+}
+exports.OutputDifference = OutputDifference;
+class ParameterDifference extends Difference {
+}
+exports.ParameterDifference = ParameterDifference;
+var ResourceImpact;
+(function (ResourceImpact) {
+    /** The existing physical resource will be updated */
+    ResourceImpact["WILL_UPDATE"] = "WILL_UPDATE";
+    /** A new physical resource will be created */
+    ResourceImpact["WILL_CREATE"] = "WILL_CREATE";
+    /** The existing physical resource will be replaced */
+    ResourceImpact["WILL_REPLACE"] = "WILL_REPLACE";
+    /** The existing physical resource may be replaced */
+    ResourceImpact["MAY_REPLACE"] = "MAY_REPLACE";
+    /** The existing physical resource will be destroyed */
+    ResourceImpact["WILL_DESTROY"] = "WILL_DESTROY";
+    /** The existing physical resource will be removed from CloudFormation supervision */
+    ResourceImpact["WILL_ORPHAN"] = "WILL_ORPHAN";
+    /** There is no change in this resource */
+    ResourceImpact["NO_CHANGE"] = "NO_CHANGE";
+})(ResourceImpact = exports.ResourceImpact || (exports.ResourceImpact = {}));
+/**
+ * This function can be used as a reducer to obtain the resource-level impact of a list
+ * of property-level impacts.
+ * @param one the current worst impact so far.
+ * @param two the new impact being considered (can be undefined, as we may not always be
+ *      able to determine some peroperty's impact).
+ */
+function worstImpact(one, two) {
+    if (!two) {
+        return one;
+    }
+    const badness = {
+        [ResourceImpact.NO_CHANGE]: 0,
+        [ResourceImpact.WILL_UPDATE]: 1,
+        [ResourceImpact.WILL_CREATE]: 2,
+        [ResourceImpact.WILL_ORPHAN]: 3,
+        [ResourceImpact.MAY_REPLACE]: 4,
+        [ResourceImpact.WILL_REPLACE]: 5,
+        [ResourceImpact.WILL_DESTROY]: 6,
+    };
+    return badness[one] > badness[two] ? one : two;
+}
+/**
+ * Change to a single resource between two CloudFormation templates
+ *
+ * This class can be mutated after construction.
+ */
+class ResourceDifference {
+    constructor(oldValue, newValue, args) {
+        this.oldValue = oldValue;
+        this.newValue = newValue;
+        this.resourceTypes = args.resourceType;
+        this.propertyDiffs = args.propertyDiffs;
+        this.otherDiffs = args.otherDiffs;
+        this.isAddition = oldValue === undefined;
+        this.isRemoval = newValue === undefined;
+    }
+    get oldProperties() {
+        return this.oldValue && this.oldValue.Properties;
+    }
+    get newProperties() {
+        return this.newValue && this.newValue.Properties;
+    }
+    /**
+     * Whether this resource was modified at all
+     */
+    get isDifferent() {
+        return this.differenceCount > 0 || this.oldResourceType !== this.newResourceType;
+    }
+    /**
+     * Whether the resource was updated in-place
+     */
+    get isUpdate() {
+        return this.isDifferent && !this.isAddition && !this.isRemoval;
+    }
+    get oldResourceType() {
+        return this.resourceTypes.oldType;
+    }
+    get newResourceType() {
+        return this.resourceTypes.newType;
+    }
+    /**
+     * All actual property updates
+     */
+    get propertyUpdates() {
+        return onlyChanges(this.propertyDiffs);
+    }
+    /**
+     * All actual "other" updates
+     */
+    get otherChanges() {
+        return onlyChanges(this.otherDiffs);
+    }
+    /**
+     * Return whether the resource type was changed in this diff
+     *
+     * This is not a valid operation in CloudFormation but to be defensive we're going
+     * to be aware of it anyway.
+     */
+    get resourceTypeChanged() {
+        return (this.resourceTypes.oldType !== undefined
+            && this.resourceTypes.newType !== undefined
+            && this.resourceTypes.oldType !== this.resourceTypes.newType);
+    }
+    /**
+     * Return the resource type if it was unchanged
+     *
+     * If the resource type was changed, it's an error to call this.
+     */
+    get resourceType() {
+        if (this.resourceTypeChanged) {
+            throw new Error('Cannot get .resourceType, because the type was changed');
+        }
+        return this.resourceTypes.oldType || this.resourceTypes.newType;
+    }
+    /**
+     * Replace a PropertyChange in this object
+     *
+     * This affects the property diff as it is summarized to users, but it DOES
+     * NOT affect either the "oldValue" or "newValue" values; those still contain
+     * the actual template values as provided by the user (they might still be
+     * used for downstream processing).
+     */
+    setPropertyChange(propertyName, change) {
+        this.propertyDiffs[propertyName] = change;
+    }
+    get changeImpact() {
+        // Check the Type first
+        if (this.resourceTypes.oldType !== this.resourceTypes.newType) {
+            if (this.resourceTypes.oldType === undefined) {
+                return ResourceImpact.WILL_CREATE;
+            }
+            if (this.resourceTypes.newType === undefined) {
+                return this.oldValue.DeletionPolicy === 'Retain'
+                    ? ResourceImpact.WILL_ORPHAN
+                    : ResourceImpact.WILL_DESTROY;
+            }
+            return ResourceImpact.WILL_REPLACE;
+        }
+        // Base impact (before we mix in the worst of the property impacts);
+        // WILL_UPDATE if we have "other" changes, NO_CHANGE if there are no "other" changes.
+        const baseImpact = Object.keys(this.otherChanges).length > 0 ? ResourceImpact.WILL_UPDATE : ResourceImpact.NO_CHANGE;
+        return Object.values(this.propertyDiffs)
+            .map(elt => elt.changeImpact)
+            .reduce(worstImpact, baseImpact);
+    }
+    /**
+     * Count of actual differences (not of elements)
+     */
+    get differenceCount() {
+        return Object.values(this.propertyUpdates).length
+            + Object.values(this.otherChanges).length;
+    }
+    /**
+     * Invoke a callback for each actual difference
+     */
+    forEachDifference(cb) {
+        for (const key of Object.keys(this.propertyUpdates).sort()) {
+            cb('Property', key, this.propertyUpdates[key]);
+        }
+        for (const key of Object.keys(this.otherChanges).sort()) {
+            cb('Other', key, this.otherDiffs[key]);
+        }
+    }
+}
+exports.ResourceDifference = ResourceDifference;
+function isPropertyDifference(diff) {
+    return diff.changeImpact !== undefined;
+}
+exports.isPropertyDifference = isPropertyDifference;
+/**
+ * Filter a map of IDifferences down to only retain the actual changes
+ */
+function onlyChanges(xs) {
+    const ret = {};
+    for (const [key, diff] of Object.entries(xs)) {
+        if (diff.isDifferent) {
+            ret[key] = diff;
+        }
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"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","sourcesContent":["import { AssertionError } from 'assert';\nimport * as cfnspec from '@aws-cdk/cfnspec';\nimport { IamChanges } from '../iam/iam-changes';\nimport { SecurityGroupChanges } from '../network/security-group-changes';\nimport { deepEqual } from './util';\n\nexport type PropertyMap = {[key: string]: any };\n\n/** Semantic differences between two CloudFormation templates. */\nexport class TemplateDiff implements ITemplateDiff {\n  public awsTemplateFormatVersion?: Difference<string>;\n  public description?: Difference<string>;\n  public transform?: Difference<string>;\n  public conditions: DifferenceCollection<Condition, ConditionDifference>;\n  public mappings: DifferenceCollection<Mapping, MappingDifference>;\n  public metadata: DifferenceCollection<Metadata, MetadataDifference>;\n  public outputs: DifferenceCollection<Output, OutputDifference>;\n  public parameters: DifferenceCollection<Parameter, ParameterDifference>;\n  public resources: DifferenceCollection<Resource, ResourceDifference>;\n  /** The differences in unknown/unexpected parts of the template */\n  public unknown: DifferenceCollection<any, Difference<any>>;\n\n  /**\n   * Changes to IAM policies\n   */\n  public readonly iamChanges: IamChanges;\n\n  /**\n   * Changes to Security Group ingress and egress rules\n   */\n  public readonly securityGroupChanges: SecurityGroupChanges;\n\n  constructor(args: ITemplateDiff) {\n    if (args.awsTemplateFormatVersion !== undefined) {\n      this.awsTemplateFormatVersion = args.awsTemplateFormatVersion;\n    }\n    if (args.description !== undefined) {\n      this.description = args.description;\n    }\n    if (args.transform !== undefined) {\n      this.transform = args.transform;\n    }\n\n    this.conditions = args.conditions || new DifferenceCollection({});\n    this.mappings = args.mappings || new DifferenceCollection({});\n    this.metadata = args.metadata || new DifferenceCollection({});\n    this.outputs = args.outputs || new DifferenceCollection({});\n    this.parameters = args.parameters || new DifferenceCollection({});\n    this.resources = args.resources || new DifferenceCollection({});\n    this.unknown = args.unknown || new DifferenceCollection({});\n\n    this.iamChanges = new IamChanges({\n      propertyChanges: this.scrutinizablePropertyChanges(IamChanges.IamPropertyScrutinies),\n      resourceChanges: this.scrutinizableResourceChanges(IamChanges.IamResourceScrutinies),\n    });\n\n    this.securityGroupChanges = new SecurityGroupChanges({\n      egressRulePropertyChanges: this.scrutinizablePropertyChanges([cfnspec.schema.PropertyScrutinyType.EgressRules]),\n      ingressRulePropertyChanges: this.scrutinizablePropertyChanges([cfnspec.schema.PropertyScrutinyType.IngressRules]),\n      egressRuleResourceChanges: this.scrutinizableResourceChanges([cfnspec.schema.ResourceScrutinyType.EgressRuleResource]),\n      ingressRuleResourceChanges: this.scrutinizableResourceChanges([cfnspec.schema.ResourceScrutinyType.IngressRuleResource]),\n    });\n  }\n\n  public get differenceCount() {\n    let count = 0;\n\n    if (this.awsTemplateFormatVersion !== undefined) {\n      count += 1;\n    }\n    if (this.description !== undefined) {\n      count += 1;\n    }\n    if (this.transform !== undefined) {\n      count += 1;\n    }\n\n    count += this.conditions.differenceCount;\n    count += this.mappings.differenceCount;\n    count += this.metadata.differenceCount;\n    count += this.outputs.differenceCount;\n    count += this.parameters.differenceCount;\n    count += this.resources.differenceCount;\n    count += this.unknown.differenceCount;\n\n    return count;\n  }\n\n  public get isEmpty(): boolean {\n    return this.differenceCount === 0;\n  }\n\n  /**\n   * Return true if any of the permissions objects involve a broadening of permissions\n   */\n  public get permissionsBroadened(): boolean {\n    return this.iamChanges.permissionsBroadened || this.securityGroupChanges.rulesAdded;\n  }\n\n  /**\n   * Return true if any of the permissions objects have changed\n   */\n  public get permissionsAnyChanges(): boolean {\n    return this.iamChanges.hasChanges || this.securityGroupChanges.hasChanges;\n  }\n\n  /**\n   * Return all property changes of a given scrutiny type\n   *\n   * We don't just look at property updates; we also look at resource additions and deletions (in which\n   * case there is no further detail on property values), and resource type changes.\n   */\n  private scrutinizablePropertyChanges(scrutinyTypes: cfnspec.schema.PropertyScrutinyType[]): PropertyChange[] {\n    const ret = new Array<PropertyChange>();\n\n    for (const [resourceLogicalId, resourceChange] of Object.entries(this.resources.changes)) {\n      if (!resourceChange) { continue; }\n\n      const props = cfnspec.scrutinizablePropertyNames(resourceChange.newResourceType!, scrutinyTypes);\n      for (const propertyName of props) {\n        ret.push({\n          resourceLogicalId,\n          propertyName,\n          resourceType: resourceChange.resourceType,\n          scrutinyType: cfnspec.propertySpecification(resourceChange.resourceType, propertyName).ScrutinyType!,\n          oldValue: resourceChange.oldProperties && resourceChange.oldProperties[propertyName],\n          newValue: resourceChange.newProperties && resourceChange.newProperties[propertyName],\n        });\n      }\n    }\n\n    return ret;\n  }\n\n  /**\n   * Return all resource changes of a given scrutiny type\n   *\n   * We don't just look at resource updates; we also look at resource additions and deletions (in which\n   * case there is no further detail on property values), and resource type changes.\n   */\n  private scrutinizableResourceChanges(scrutinyTypes: cfnspec.schema.ResourceScrutinyType[]): ResourceChange[] {\n    const ret = new Array<ResourceChange>();\n\n    const scrutinizableTypes = new Set(cfnspec.scrutinizableResourceTypes(scrutinyTypes));\n\n    for (const [resourceLogicalId, resourceChange] of Object.entries(this.resources.changes)) {\n      if (!resourceChange) { continue; }\n\n      const commonProps = {\n        oldProperties: resourceChange.oldProperties,\n        newProperties: resourceChange.newProperties,\n        resourceLogicalId,\n      };\n\n      // Even though it's not physically possible in CFN, let's pretend to handle a change of 'Type'.\n      if (resourceChange.resourceTypeChanged) {\n        // Treat as DELETE+ADD\n        if (scrutinizableTypes.has(resourceChange.oldResourceType!)) {\n          ret.push({\n            ...commonProps,\n            newProperties: undefined,\n            resourceType: resourceChange.oldResourceType!,\n            scrutinyType: cfnspec.resourceSpecification(resourceChange.oldResourceType!).ScrutinyType!,\n          });\n        }\n        if (scrutinizableTypes.has(resourceChange.newResourceType!)) {\n          ret.push({\n            ...commonProps,\n            oldProperties: undefined,\n            resourceType: resourceChange.newResourceType!,\n            scrutinyType: cfnspec.resourceSpecification(resourceChange.newResourceType!).ScrutinyType!,\n          });\n        }\n      } else {\n        if (scrutinizableTypes.has(resourceChange.resourceType)) {\n          ret.push({\n            ...commonProps,\n            resourceType: resourceChange.resourceType,\n            scrutinyType: cfnspec.resourceSpecification(resourceChange.resourceType).ScrutinyType!,\n          });\n        }\n      }\n    }\n\n    return ret;\n  }\n}\n\n/**\n * A change in property values\n *\n * Not necessarily an update, it could be that there used to be no value there\n * because there was no resource, and now there is (or vice versa).\n *\n * Therefore, we just contain plain values and not a PropertyDifference<any>.\n */\nexport interface PropertyChange {\n  /**\n   * Logical ID of the resource where this property change was found\n   */\n  resourceLogicalId: string;\n\n  /**\n   * Type of the resource\n   */\n  resourceType: string;\n\n  /**\n   * Scrutiny type for this property change\n   */\n  scrutinyType: cfnspec.schema.PropertyScrutinyType;\n\n  /**\n   * Name of the property that is changing\n   */\n  propertyName: string;\n\n  /**\n   * The old property value\n   */\n  oldValue?: any;\n\n  /**\n   * The new property value\n   */\n  newValue?: any;\n}\n\n/**\n * A resource change\n *\n * Either a creation, deletion or update.\n */\nexport interface ResourceChange {\n  /**\n   * Logical ID of the resource where this property change was found\n   */\n  resourceLogicalId: string;\n\n  /**\n   * Scrutiny type for this resource change\n   */\n  scrutinyType: cfnspec.schema.ResourceScrutinyType;\n\n  /**\n   * The type of the resource\n   */\n  resourceType: string;\n\n  /**\n   * The old properties value (might be undefined in case of creation)\n   */\n  oldProperties?: PropertyMap;\n\n  /**\n   * The new properties value (might be undefined in case of deletion)\n   */\n  newProperties?: PropertyMap;\n}\n\nexport interface IDifference<ValueType> {\n  readonly oldValue: ValueType | undefined;\n  readonly newValue: ValueType | undefined;\n  readonly isDifferent: boolean;\n  readonly isAddition: boolean;\n  readonly isRemoval: boolean;\n  readonly isUpdate: boolean;\n}\n\n/**\n * Models an entity that changed between two versions of a CloudFormation template.\n */\nexport class Difference<ValueType> implements IDifference<ValueType> {\n  /**\n   * Whether this is an actual different or the values are actually the same\n   *\n   * isDifferent => (isUpdate | isRemoved | isUpdate)\n   */\n  public readonly isDifferent: boolean;\n\n  /**\n   * @param oldValue the old value, cannot be equal (to the sense of +deepEqual+) to +newValue+.\n   * @param newValue the new value, cannot be equal (to the sense of +deepEqual+) to +oldValue+.\n   */\n  constructor(public readonly oldValue: ValueType | undefined, public readonly newValue: ValueType | undefined) {\n    if (oldValue === undefined && newValue === undefined) {\n      throw new AssertionError({ message: 'oldValue and newValue are both undefined!' });\n    }\n    this.isDifferent = !deepEqual(oldValue, newValue);\n  }\n\n  /** @returns +true+ if the element is new to the template. */\n  public get isAddition(): boolean {\n    return this.oldValue === undefined;\n  }\n\n  /** @returns +true+ if the element was removed from the template. */\n  public get isRemoval(): boolean {\n    return this.newValue === undefined;\n  }\n\n  /** @returns +true+ if the element was already in the template and is updated. */\n  public get isUpdate(): boolean {\n    return this.oldValue !== undefined\n      && this.newValue !== undefined;\n  }\n}\n\nexport class PropertyDifference<ValueType> extends Difference<ValueType> {\n  public readonly changeImpact?: ResourceImpact;\n\n  constructor(oldValue: ValueType | undefined, newValue: ValueType | undefined, args: { changeImpact?: ResourceImpact }) {\n    super(oldValue, newValue);\n    this.changeImpact = args.changeImpact;\n  }\n}\n\nexport class DifferenceCollection<V, T extends IDifference<V>> {\n  constructor(private readonly diffs: { [logicalId: string]: T }) {}\n\n  public get changes(): { [logicalId: string]: T } {\n    return onlyChanges(this.diffs);\n  }\n\n  public get differenceCount(): number {\n    return Object.values(this.changes).length;\n  }\n\n  public get(logicalId: string): T {\n    const ret = this.diffs[logicalId];\n    if (!ret) { throw new Error(`No object with logical ID '${logicalId}'`); }\n    return ret;\n  }\n\n  public get logicalIds(): string[] {\n    return Object.keys(this.changes);\n  }\n\n  /**\n   * Returns a new TemplateDiff which only contains changes for which `predicate`\n   * returns `true`.\n   */\n  public filter(predicate: (diff: T | undefined) => boolean): DifferenceCollection<V, T> {\n    const newChanges: { [logicalId: string]: T } = { };\n    for (const id of Object.keys(this.changes)) {\n      const diff = this.changes[id];\n\n      if (predicate(diff)) {\n        newChanges[id] = diff;\n      }\n    }\n\n    return new DifferenceCollection<V, T>(newChanges);\n  }\n\n  /**\n   * Invokes `cb` for all changes in this collection.\n   *\n   * Changes will be sorted as follows:\n   *  - Removed\n   *  - Added\n   *  - Updated\n   *  - Others\n   *\n   * @param cb\n   */\n  public forEachDifference(cb: (logicalId: string, change: T) => any): void {\n    const removed = new Array<{ logicalId: string, change: T }>();\n    const added = new Array<{ logicalId: string, change: T }>();\n    const updated = new Array<{ logicalId: string, change: T }>();\n    const others = new Array<{ logicalId: string, change: T }>();\n\n    for (const logicalId of this.logicalIds) {\n      const change: T = this.changes[logicalId]!;\n      if (change.isAddition) {\n        added.push({ logicalId, change });\n      } else if (change.isRemoval) {\n        removed.push({ logicalId, change });\n      } else if (change.isUpdate) {\n        updated.push({ logicalId, change });\n      } else if (change.isDifferent) {\n        others.push({ logicalId, change });\n      }\n    }\n\n    removed.forEach(v => cb(v.logicalId, v.change));\n    added.forEach(v => cb(v.logicalId, v.change));\n    updated.forEach(v => cb(v.logicalId, v.change));\n    others.forEach(v => cb(v.logicalId, v.change));\n  }\n}\n\n/**\n * Arguments expected by the constructor of +TemplateDiff+, extracted as an interface for the sake\n * of (relative) conciseness of the constructor's signature.\n */\nexport interface ITemplateDiff {\n  awsTemplateFormatVersion?: IDifference<string>;\n  description?: IDifference<string>;\n  transform?: IDifference<string>;\n\n  conditions?: DifferenceCollection<Condition, ConditionDifference>;\n  mappings?: DifferenceCollection<Mapping, MappingDifference>;\n  metadata?: DifferenceCollection<Metadata, MetadataDifference>;\n  outputs?: DifferenceCollection<Output, OutputDifference>;\n  parameters?: DifferenceCollection<Parameter, ParameterDifference>;\n  resources?: DifferenceCollection<Resource, ResourceDifference>;\n\n  unknown?: DifferenceCollection<any, IDifference<any>>;\n}\n\nexport type Condition = any;\nexport class ConditionDifference extends Difference<Condition> {\n  // TODO: define specific difference attributes\n}\n\nexport type Mapping = any;\nexport class MappingDifference extends Difference<Mapping> {\n  // TODO: define specific difference attributes\n}\n\nexport type Metadata = any;\nexport class MetadataDifference extends Difference<Metadata> {\n  // TODO: define specific difference attributes\n}\n\nexport type Output = any;\nexport class OutputDifference extends Difference<Output> {\n  // TODO: define specific difference attributes\n}\n\nexport type Parameter = any;\nexport class ParameterDifference extends Difference<Parameter> {\n  // TODO: define specific difference attributes\n}\n\nexport enum ResourceImpact {\n  /** The existing physical resource will be updated */\n  WILL_UPDATE = 'WILL_UPDATE',\n  /** A new physical resource will be created */\n  WILL_CREATE = 'WILL_CREATE',\n  /** The existing physical resource will be replaced */\n  WILL_REPLACE = 'WILL_REPLACE',\n  /** The existing physical resource may be replaced */\n  MAY_REPLACE = 'MAY_REPLACE',\n  /** The existing physical resource will be destroyed */\n  WILL_DESTROY = 'WILL_DESTROY',\n  /** The existing physical resource will be removed from CloudFormation supervision */\n  WILL_ORPHAN = 'WILL_ORPHAN',\n  /** There is no change in this resource */\n  NO_CHANGE = 'NO_CHANGE',\n}\n\n/**\n * This function can be used as a reducer to obtain the resource-level impact of a list\n * of property-level impacts.\n * @param one the current worst impact so far.\n * @param two the new impact being considered (can be undefined, as we may not always be\n *      able to determine some peroperty's impact).\n */\nfunction worstImpact(one: ResourceImpact, two?: ResourceImpact): ResourceImpact {\n  if (!two) { return one; }\n  const badness = {\n    [ResourceImpact.NO_CHANGE]: 0,\n    [ResourceImpact.WILL_UPDATE]: 1,\n    [ResourceImpact.WILL_CREATE]: 2,\n    [ResourceImpact.WILL_ORPHAN]: 3,\n    [ResourceImpact.MAY_REPLACE]: 4,\n    [ResourceImpact.WILL_REPLACE]: 5,\n    [ResourceImpact.WILL_DESTROY]: 6,\n  };\n  return badness[one] > badness[two] ? one : two;\n}\n\nexport interface Resource {\n  Type: string;\n  Properties?: { [name: string]: any };\n\n  [key: string]: any;\n}\n\n/**\n * Change to a single resource between two CloudFormation templates\n *\n * This class can be mutated after construction.\n */\nexport class ResourceDifference implements IDifference<Resource> {\n  /**\n   * Whether this resource was added\n   */\n  public readonly isAddition: boolean;\n\n  /**\n   * Whether this resource was removed\n   */\n  public readonly isRemoval: boolean;\n\n  /** Property-level changes on the resource */\n  private readonly propertyDiffs: { [key: string]: PropertyDifference<any> };\n\n  /** Changes to non-property level attributes of the resource */\n  private readonly otherDiffs: { [key: string]: Difference<any> };\n\n  /** The resource type (or old and new type if it has changed) */\n  private readonly resourceTypes: { readonly oldType?: string, readonly newType?: string };\n\n  constructor(\n    public readonly oldValue: Resource | undefined,\n    public readonly newValue: Resource | undefined,\n    args: {\n      resourceType: { oldType?: string, newType?: string },\n      propertyDiffs: { [key: string]: PropertyDifference<any> },\n      otherDiffs: { [key: string]: Difference<any> }\n    },\n  ) {\n    this.resourceTypes = args.resourceType;\n    this.propertyDiffs = args.propertyDiffs;\n    this.otherDiffs = args.otherDiffs;\n\n    this.isAddition = oldValue === undefined;\n    this.isRemoval = newValue === undefined;\n  }\n\n  public get oldProperties(): PropertyMap | undefined {\n    return this.oldValue && this.oldValue.Properties;\n  }\n\n  public get newProperties(): PropertyMap | undefined {\n    return this.newValue && this.newValue.Properties;\n  }\n\n  /**\n   * Whether this resource was modified at all\n   */\n  public get isDifferent(): boolean {\n    return this.differenceCount > 0 || this.oldResourceType !== this.newResourceType;\n  }\n\n  /**\n   * Whether the resource was updated in-place\n   */\n  public get isUpdate(): boolean {\n    return this.isDifferent && !this.isAddition && !this.isRemoval;\n  }\n\n  public get oldResourceType(): string | undefined {\n    return this.resourceTypes.oldType;\n  }\n\n  public get newResourceType(): string | undefined {\n    return this.resourceTypes.newType;\n  }\n\n  /**\n   * All actual property updates\n   */\n  public get propertyUpdates(): { [key: string]: PropertyDifference<any> } {\n    return onlyChanges(this.propertyDiffs);\n  }\n\n  /**\n   * All actual \"other\" updates\n   */\n  public get otherChanges(): { [key: string]: Difference<any> } {\n    return onlyChanges(this.otherDiffs);\n  }\n\n  /**\n   * Return whether the resource type was changed in this diff\n   *\n   * This is not a valid operation in CloudFormation but to be defensive we're going\n   * to be aware of it anyway.\n   */\n  public get resourceTypeChanged(): boolean {\n    return (this.resourceTypes.oldType !== undefined\n        && this.resourceTypes.newType !== undefined\n        && this.resourceTypes.oldType !== this.resourceTypes.newType);\n  }\n\n  /**\n   * Return the resource type if it was unchanged\n   *\n   * If the resource type was changed, it's an error to call this.\n   */\n  public get resourceType(): string {\n    if (this.resourceTypeChanged) {\n      throw new Error('Cannot get .resourceType, because the type was changed');\n    }\n    return this.resourceTypes.oldType || this.resourceTypes.newType!;\n  }\n\n  /**\n   * Replace a PropertyChange in this object\n   *\n   * This affects the property diff as it is summarized to users, but it DOES\n   * NOT affect either the \"oldValue\" or \"newValue\" values; those still contain\n   * the actual template values as provided by the user (they might still be\n   * used for downstream processing).\n   */\n  public setPropertyChange(propertyName: string, change: PropertyDifference<any>) {\n    this.propertyDiffs[propertyName] = change;\n  }\n\n  public get changeImpact(): ResourceImpact {\n    // Check the Type first\n    if (this.resourceTypes.oldType !== this.resourceTypes.newType) {\n      if (this.resourceTypes.oldType === undefined) { return ResourceImpact.WILL_CREATE; }\n      if (this.resourceTypes.newType === undefined) {\n        return this.oldValue!.DeletionPolicy === 'Retain'\n          ? ResourceImpact.WILL_ORPHAN\n          : ResourceImpact.WILL_DESTROY;\n      }\n      return ResourceImpact.WILL_REPLACE;\n    }\n\n    // Base impact (before we mix in the worst of the property impacts);\n    // WILL_UPDATE if we have \"other\" changes, NO_CHANGE if there are no \"other\" changes.\n    const baseImpact = Object.keys(this.otherChanges).length > 0 ? ResourceImpact.WILL_UPDATE : ResourceImpact.NO_CHANGE;\n\n    return Object.values(this.propertyDiffs)\n      .map(elt => elt.changeImpact)\n      .reduce(worstImpact, baseImpact);\n  }\n\n  /**\n   * Count of actual differences (not of elements)\n   */\n  public get differenceCount(): number {\n    return Object.values(this.propertyUpdates).length\n      + Object.values(this.otherChanges).length;\n  }\n\n  /**\n   * Invoke a callback for each actual difference\n   */\n  public forEachDifference(cb: (type: 'Property' | 'Other', name: string, value: Difference<any> | PropertyDifference<any>) => any) {\n    for (const key of Object.keys(this.propertyUpdates).sort()) {\n      cb('Property', key, this.propertyUpdates[key]);\n    }\n    for (const key of Object.keys(this.otherChanges).sort()) {\n      cb('Other', key, this.otherDiffs[key]);\n    }\n  }\n}\n\nexport function isPropertyDifference<T>(diff: Difference<T>): diff is PropertyDifference<T> {\n  return (diff as PropertyDifference<T>).changeImpact !== undefined;\n}\n\n/**\n * Filter a map of IDifferences down to only retain the actual changes\n */\nfunction onlyChanges<V, T extends IDifference<V>>(xs: {[key: string]: T}): {[key: string]: T} {\n  const ret: { [key: string]: T } = {};\n  for (const [key, diff] of Object.entries(xs)) {\n    if (diff.isDifferent) {\n      ret[key] = diff;\n    }\n  }\n  return ret;\n}\n"]}

package/node_modules/@aws-cdk/cloudformation-diff/lib/diff/util.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ */
+export declare function deepEqual(lvalue: any, rvalue: any): boolean;
+/**
+ * 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+.
+ */
+export declare function diffKeyedEntities<T>(oldValue: {
+    [key: string]: any;
+} | undefined, newValue: {
+    [key: string]: any;
+} | undefined, elementDiff: (oldElement: any, newElement: any, key: string) => T): {
+    [name: string]: T;
+};
+/**
+ * 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.
+ */
+export declare function unionOf(lv: string[] | Set<string>, rv: string[] | Set<string>): string[];