@aws-amplify/graphql-api-construct 1.18.2 → 1.18.3

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

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCondition = exports.Effect = exports.Targets = exports.parseLambdaPermission = exports.parseStatements = exports.Statement = void 0;
+const util_1 = require("../util");
+// namespace object imports won't work in the bundle for function exports
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const deepEqual = require('fast-deep-equal');
+class Statement {
+    constructor(statement) {
+        if (typeof statement === 'string') {
+            this.sid = undefined;
+            this.effect = Effect.Unknown;
+            this.resources = new Targets({}, '', '');
+            this.actions = new Targets({}, '', '');
+            this.principals = new Targets({}, '', '');
+            this.condition = undefined;
+            this.serializedIntrinsic = statement;
+        }
+        else {
+            this.sid = expectString(statement.Sid);
+            this.effect = expectEffect(statement.Effect);
+            this.resources = new Targets(statement, 'Resource', 'NotResource');
+            this.actions = new Targets(statement, 'Action', 'NotAction');
+            this.principals = new Targets(statement, 'Principal', 'NotPrincipal');
+            this.condition = statement.Condition;
+            this.serializedIntrinsic = undefined;
+        }
+    }
+    /**
+     * Whether this statement is equal to the other statement
+     */
+    equal(other) {
+        return (this.sid === other.sid
+            && this.effect === other.effect
+            && this.serializedIntrinsic === other.serializedIntrinsic
+            && this.resources.equal(other.resources)
+            && this.actions.equal(other.actions)
+            && this.principals.equal(other.principals)
+            && deepEqual(this.condition, other.condition));
+    }
+    render() {
+        return this.serializedIntrinsic
+            ? {
+                resource: this.serializedIntrinsic,
+                effect: '',
+                action: '',
+                principal: this.principals.render(),
+                condition: '',
+            }
+            : {
+                resource: this.resources.render(),
+                effect: this.effect,
+                action: this.actions.render(),
+                principal: this.principals.render(),
+                condition: renderCondition(this.condition),
+            };
+    }
+    /**
+     * Return a machine-readable version of the changes.
+     * This is only used in tests.
+     *
+     * @internal
+     */
+    _toJson() {
+        return this.serializedIntrinsic
+            ? this.serializedIntrinsic
+            : util_1.deepRemoveUndefined({
+                sid: this.sid,
+                effect: this.effect,
+                resources: this.resources._toJson(),
+                principals: this.principals._toJson(),
+                actions: this.actions._toJson(),
+                condition: this.condition,
+            });
+    }
+    /**
+     * Whether this is a negative statement
+     *
+     * A statement is negative if any of its targets are negative, inverted
+     * if the Effect is Deny.
+     */
+    get isNegativeStatement() {
+        const notTarget = this.actions.not || this.principals.not || this.resources.not;
+        return this.effect === Effect.Allow ? notTarget : !notTarget;
+    }
+}
+exports.Statement = Statement;
+/**
+ * Parse a list of statements from undefined, a Statement, or a list of statements
+ */
+function parseStatements(x) {
+    if (x === undefined) {
+        x = [];
+    }
+    if (!Array.isArray(x)) {
+        x = [x];
+    }
+    return x.map((s) => new Statement(s));
+}
+exports.parseStatements = parseStatements;
+/**
+ * Parse a Statement from a Lambda::Permission object
+ *
+ * This is actually what Lambda adds to the policy document if you call AddPermission.
+ */
+function parseLambdaPermission(x) {
+    // Construct a statement from
+    const statement = {
+        Effect: 'Allow',
+        Action: x.Action,
+        Resource: x.FunctionName,
+    };
+    if (x.Principal !== undefined) {
+        if (x.Principal === '*') {
+            // *
+            statement.Principal = '*';
+        }
+        else if (/^\d{12}$/.test(x.Principal)) {
+            // Account number
+            statement.Principal = { AWS: `arn:aws:iam::${x.Principal}:root` };
+        }
+        else {
+            // Assume it's a service principal
+            // We might get this wrong vs. the previous one for tokens. Nothing to be done
+            // about that. It's only for human readable consumption after all.
+            statement.Principal = { Service: x.Principal };
+        }
+    }
+    if (x.SourceArn !== undefined) {
+        if (statement.Condition === undefined) {
+            statement.Condition = {};
+        }
+        statement.Condition.ArnLike = { 'AWS:SourceArn': x.SourceArn };
+    }
+    if (x.SourceAccount !== undefined) {
+        if (statement.Condition === undefined) {
+            statement.Condition = {};
+        }
+        statement.Condition.StringEquals = { 'AWS:SourceAccount': x.SourceAccount };
+    }
+    if (x.EventSourceToken !== undefined) {
+        if (statement.Condition === undefined) {
+            statement.Condition = {};
+        }
+        statement.Condition.StringEquals = { 'lambda:EventSourceToken': x.EventSourceToken };
+    }
+    return new Statement(statement);
+}
+exports.parseLambdaPermission = parseLambdaPermission;
+/**
+ * Targets for a field
+ */
+class Targets {
+    constructor(statement, positiveKey, negativeKey) {
+        if (negativeKey in statement) {
+            this.values = forceListOfStrings(statement[negativeKey]);
+            this.not = true;
+        }
+        else {
+            this.values = forceListOfStrings(statement[positiveKey]);
+            this.not = false;
+        }
+        this.values.sort();
+    }
+    get empty() {
+        return this.values.length === 0;
+    }
+    /**
+     * Whether this set of targets is equal to the other set of targets
+     */
+    equal(other) {
+        return this.not === other.not && deepEqual(this.values.sort(), other.values.sort());
+    }
+    /**
+     * If the current value set is empty, put this in it
+     */
+    replaceEmpty(replacement) {
+        if (this.empty) {
+            this.values.push(replacement);
+        }
+    }
+    /**
+     * If the actions contains a '*', replace with this string.
+     */
+    replaceStar(replacement) {
+        for (let i = 0; i < this.values.length; i++) {
+            if (this.values[i] === '*') {
+                this.values[i] = replacement;
+            }
+        }
+        this.values.sort();
+    }
+    /**
+     * Render into a summary table cell
+     */
+    render() {
+        return this.not
+            ? this.values.map(s => `NOT ${s}`).join('\n')
+            : this.values.join('\n');
+    }
+    /**
+     * Return a machine-readable version of the changes.
+     * This is only used in tests.
+     *
+     * @internal
+     */
+    _toJson() {
+        return { not: this.not, values: this.values };
+    }
+}
+exports.Targets = Targets;
+var Effect;
+(function (Effect) {
+    Effect["Unknown"] = "Unknown";
+    Effect["Allow"] = "Allow";
+    Effect["Deny"] = "Deny";
+})(Effect = exports.Effect || (exports.Effect = {}));
+function expectString(x) {
+    return typeof x === 'string' ? x : undefined;
+}
+function expectEffect(x) {
+    if (x === Effect.Allow || x === Effect.Deny) {
+        return x;
+    }
+    return Effect.Unknown;
+}
+function forceListOfStrings(x) {
+    if (typeof x === 'string') {
+        return [x];
+    }
+    if (typeof x === 'undefined' || x === null) {
+        return [];
+    }
+    if (Array.isArray(x)) {
+        return x.map(e => forceListOfStrings(e).join(','));
+    }
+    if (typeof x === 'object' && x !== null) {
+        const ret = [];
+        for (const [key, value] of Object.entries(x)) {
+            ret.push(...forceListOfStrings(value).map(s => `${key}:${s}`));
+        }
+        return ret;
+    }
+    return [`${x}`];
+}
+/**
+ * Render the Condition column
+ */
+function renderCondition(condition) {
+    if (!condition || Object.keys(condition).length === 0) {
+        return '';
+    }
+    const jsonRepresentation = JSON.stringify(condition, undefined, 2);
+    // The JSON representation looks like this:
+    //
+    //  {
+    //    "ArnLike": {
+    //      "AWS:SourceArn": "${MyTopic86869434}"
+    //    }
+    //  }
+    //
+    // We can make it more compact without losing information by getting rid of the outermost braces
+    // and the indentation.
+    const lines = jsonRepresentation.split('\n');
+    return lines.slice(1, lines.length - 1).map(s => s.slice(2)).join('\n');
+}
+exports.renderCondition = renderCondition;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"statement.js","sourceRoot":"","sources":["statement.ts"],"names":[],"mappings":"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","sourcesContent":["import { deepRemoveUndefined } from '../util';\n\n// namespace object imports won't work in the bundle for function exports\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst deepEqual = require('fast-deep-equal');\n\nexport class Statement {\n  /**\n   * Statement ID\n   */\n  public readonly sid: string | undefined;\n\n  /**\n   * Statement effect\n   */\n  public readonly effect: Effect;\n\n  /**\n   * Resources\n   */\n  public readonly resources: Targets;\n\n  /**\n   * Principals\n   */\n  public readonly principals: Targets;\n\n  /**\n   * Actions\n   */\n  public readonly actions: Targets;\n\n  /**\n   * Object with conditions\n   */\n  public readonly condition?: any;\n\n  private readonly serializedIntrinsic: string | undefined;\n\n  constructor(statement: UnknownMap | string) {\n    if (typeof statement === 'string') {\n      this.sid = undefined;\n      this.effect = Effect.Unknown;\n      this.resources = new Targets({}, '', '');\n      this.actions = new Targets({}, '', '');\n      this.principals = new Targets({}, '', '');\n      this.condition = undefined;\n      this.serializedIntrinsic = statement;\n    } else {\n      this.sid = expectString(statement.Sid);\n      this.effect = expectEffect(statement.Effect);\n      this.resources = new Targets(statement, 'Resource', 'NotResource');\n      this.actions = new Targets(statement, 'Action', 'NotAction');\n      this.principals = new Targets(statement, 'Principal', 'NotPrincipal');\n      this.condition = statement.Condition;\n      this.serializedIntrinsic = undefined;\n    }\n  }\n\n  /**\n   * Whether this statement is equal to the other statement\n   */\n  public equal(other: Statement): boolean {\n    return (this.sid === other.sid\n      && this.effect === other.effect\n      && this.serializedIntrinsic === other.serializedIntrinsic\n      && this.resources.equal(other.resources)\n      && this.actions.equal(other.actions)\n      && this.principals.equal(other.principals)\n      && deepEqual(this.condition, other.condition));\n  }\n\n  public render(): RenderedStatement {\n    return this.serializedIntrinsic\n      ? {\n        resource: this.serializedIntrinsic,\n        effect: '',\n        action: '',\n        principal: this.principals.render(), // these will be replaced by the call to replaceEmpty() from IamChanges\n        condition: '',\n      }\n      : {\n        resource: this.resources.render(),\n        effect: this.effect,\n        action: this.actions.render(),\n        principal: this.principals.render(),\n        condition: renderCondition(this.condition),\n      };\n  }\n\n  /**\n   * Return a machine-readable version of the changes.\n   * This is only used in tests.\n   *\n   * @internal\n   */\n  public _toJson(): StatementJson {\n    return this.serializedIntrinsic\n      ? this.serializedIntrinsic\n      : deepRemoveUndefined({\n        sid: this.sid,\n        effect: this.effect,\n        resources: this.resources._toJson(),\n        principals: this.principals._toJson(),\n        actions: this.actions._toJson(),\n        condition: this.condition,\n      });\n  }\n\n  /**\n   * Whether this is a negative statement\n   *\n   * A statement is negative if any of its targets are negative, inverted\n   * if the Effect is Deny.\n   */\n  public get isNegativeStatement(): boolean {\n    const notTarget = this.actions.not || this.principals.not || this.resources.not;\n    return this.effect === Effect.Allow ? notTarget : !notTarget;\n  }\n}\n\nexport interface RenderedStatement {\n  readonly resource: string;\n  readonly effect: string;\n  readonly action: string;\n  readonly principal: string;\n  readonly condition: string;\n}\n\nexport interface StatementJson {\n  sid?: string;\n  effect: string;\n  resources: TargetsJson;\n  actions: TargetsJson;\n  principals: TargetsJson;\n  condition?: any;\n}\n\nexport interface TargetsJson {\n  not: boolean;\n  values: string[];\n}\n\n/**\n * Parse a list of statements from undefined, a Statement, or a list of statements\n */\nexport function parseStatements(x: any): Statement[] {\n  if (x === undefined) { x = []; }\n  if (!Array.isArray(x)) { x = [x]; }\n  return x.map((s: any) => new Statement(s));\n}\n\n/**\n * Parse a Statement from a Lambda::Permission object\n *\n * This is actually what Lambda adds to the policy document if you call AddPermission.\n */\nexport function parseLambdaPermission(x: any): Statement {\n  // Construct a statement from\n  const statement: any = {\n    Effect: 'Allow',\n    Action: x.Action,\n    Resource: x.FunctionName,\n  };\n\n  if (x.Principal !== undefined) {\n    if (x.Principal === '*') {\n      // *\n      statement.Principal = '*';\n    } else if (/^\\d{12}$/.test(x.Principal)) {\n      // Account number\n      statement.Principal = { AWS: `arn:aws:iam::${x.Principal}:root` };\n    } else {\n      // Assume it's a service principal\n      // We might get this wrong vs. the previous one for tokens. Nothing to be done\n      // about that. It's only for human readable consumption after all.\n      statement.Principal = { Service: x.Principal };\n    }\n  }\n  if (x.SourceArn !== undefined) {\n    if (statement.Condition === undefined) { statement.Condition = {}; }\n    statement.Condition.ArnLike = { 'AWS:SourceArn': x.SourceArn };\n  }\n  if (x.SourceAccount !== undefined) {\n    if (statement.Condition === undefined) { statement.Condition = {}; }\n    statement.Condition.StringEquals = { 'AWS:SourceAccount': x.SourceAccount };\n  }\n  if (x.EventSourceToken !== undefined) {\n    if (statement.Condition === undefined) { statement.Condition = {}; }\n    statement.Condition.StringEquals = { 'lambda:EventSourceToken': x.EventSourceToken };\n  }\n\n  return new Statement(statement);\n}\n\n/**\n * Targets for a field\n */\nexport class Targets {\n  /**\n   * The values of the targets\n   */\n  public readonly values: string[];\n\n  /**\n   * Whether positive or negative matchers\n   */\n  public readonly not: boolean;\n\n  constructor(statement: UnknownMap, positiveKey: string, negativeKey: string) {\n    if (negativeKey in statement) {\n      this.values = forceListOfStrings(statement[negativeKey]);\n      this.not = true;\n    } else {\n      this.values = forceListOfStrings(statement[positiveKey]);\n      this.not = false;\n    }\n    this.values.sort();\n  }\n\n  public get empty() {\n    return this.values.length === 0;\n  }\n\n  /**\n   * Whether this set of targets is equal to the other set of targets\n   */\n  public equal(other: Targets) {\n    return this.not === other.not && deepEqual(this.values.sort(), other.values.sort());\n  }\n\n  /**\n   * If the current value set is empty, put this in it\n   */\n  public replaceEmpty(replacement: string) {\n    if (this.empty) {\n      this.values.push(replacement);\n    }\n  }\n\n  /**\n   * If the actions contains a '*', replace with this string.\n   */\n  public replaceStar(replacement: string) {\n    for (let i = 0; i < this.values.length; i++) {\n      if (this.values[i] === '*') {\n        this.values[i] = replacement;\n      }\n    }\n    this.values.sort();\n  }\n\n  /**\n   * Render into a summary table cell\n   */\n  public render(): string {\n    return this.not\n      ? this.values.map(s => `NOT ${s}`).join('\\n')\n      : this.values.join('\\n');\n  }\n\n  /**\n   * Return a machine-readable version of the changes.\n   * This is only used in tests.\n   *\n   * @internal\n   */\n  public _toJson(): TargetsJson {\n    return { not: this.not, values: this.values };\n  }\n}\n\ntype UnknownMap = {[key: string]: unknown};\n\nexport enum Effect {\n  Unknown = 'Unknown',\n  Allow = 'Allow',\n  Deny = 'Deny',\n}\n\nfunction expectString(x: unknown): string | undefined {\n  return typeof x === 'string' ? x : undefined;\n}\n\nfunction expectEffect(x: unknown): Effect {\n  if (x === Effect.Allow || x === Effect.Deny) { return x as Effect; }\n  return Effect.Unknown;\n}\n\nfunction forceListOfStrings(x: unknown): string[] {\n  if (typeof x === 'string') { return [x]; }\n  if (typeof x === 'undefined' || x === null) { return []; }\n\n  if (Array.isArray(x)) {\n    return x.map(e => forceListOfStrings(e).join(','));\n  }\n\n  if (typeof x === 'object' && x !== null) {\n    const ret: string[] = [];\n    for (const [key, value] of Object.entries(x)) {\n      ret.push(...forceListOfStrings(value).map(s => `${key}:${s}`));\n    }\n    return ret;\n  }\n\n  return [`${x}`];\n}\n\n/**\n * Render the Condition column\n */\nexport function renderCondition(condition: any): string {\n  if (!condition || Object.keys(condition).length === 0) { return ''; }\n  const jsonRepresentation = JSON.stringify(condition, undefined, 2);\n\n  // The JSON representation looks like this:\n  //\n  //  {\n  //    \"ArnLike\": {\n  //      \"AWS:SourceArn\": \"${MyTopic86869434}\"\n  //    }\n  //  }\n  //\n  // We can make it more compact without losing information by getting rid of the outermost braces\n  // and the indentation.\n  const lines = jsonRepresentation.split('\\n');\n  return lines.slice(1, lines.length - 1).map(s => s.slice(2)).join('\\n');\n}\n"]}

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

@@ -0,0 +1,4 @@
+export * from './diff-template';
+export * from './format';
+export * from './format-table';
+export { deepEqual } from './diff/util';

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./diff-template"), exports);
+__exportStar(require("./format"), exports);
+__exportStar(require("./format-table"), exports);
+var util_1 = require("./diff/util");
+Object.defineProperty(exports, "deepEqual", { enumerable: true, get: function () { return util_1.deepEqual; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxrREFBZ0M7QUFDaEMsMkNBQXlCO0FBQ3pCLGlEQUErQjtBQUMvQixvQ0FBd0M7QUFBL0IsaUdBQUEsU0FBUyxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaWZmLXRlbXBsYXRlJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybWF0JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybWF0LXRhYmxlJztcbmV4cG9ydCB7IGRlZXBFcXVhbCB9IGZyb20gJy4vZGlmZi91dGlsJztcbiJdfQ==

package/node_modules/@aws-cdk/cloudformation-diff/lib/network/security-group-changes.d.ts

@@ -0,0 +1,32 @@
+import { RuleJson, SecurityGroupRule } from './security-group-rule';
+import { PropertyChange, ResourceChange } from '../diff/types';
+import { DiffableCollection } from '../diffable';
+export interface SecurityGroupChangesProps {
+    ingressRulePropertyChanges: PropertyChange[];
+    ingressRuleResourceChanges: ResourceChange[];
+    egressRuleResourceChanges: ResourceChange[];
+    egressRulePropertyChanges: PropertyChange[];
+}
+/**
+ * Changes to IAM statements
+ */
+export declare class SecurityGroupChanges {
+    readonly ingress: DiffableCollection<SecurityGroupRule>;
+    readonly egress: DiffableCollection<SecurityGroupRule>;
+    constructor(props: SecurityGroupChangesProps);
+    get hasChanges(): boolean;
+    /**
+     * Return a summary table of changes
+     */
+    summarize(): string[][];
+    toJson(): SecurityGroupChangesJson;
+    get rulesAdded(): boolean;
+    private readInlineRules;
+    private readRuleResource;
+}
+export interface SecurityGroupChangesJson {
+    ingressRuleAdditions?: RuleJson[];
+    ingressRuleRemovals?: RuleJson[];
+    egressRuleAdditions?: RuleJson[];
+    egressRuleRemovals?: RuleJson[];
+}

package/node_modules/@aws-cdk/cloudformation-diff/lib/network/security-group-changes.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityGroupChanges = void 0;
+const chalk = require("chalk");
+const security_group_rule_1 = require("./security-group-rule");
+const diffable_1 = require("../diffable");
+const render_intrinsics_1 = require("../render-intrinsics");
+const util_1 = require("../util");
+/**
+ * Changes to IAM statements
+ */
+class SecurityGroupChanges {
+    constructor(props) {
+        this.ingress = new diffable_1.DiffableCollection();
+        this.egress = new diffable_1.DiffableCollection();
+        // Group rules
+        for (const ingressProp of props.ingressRulePropertyChanges) {
+            this.ingress.addOld(...this.readInlineRules(ingressProp.oldValue, ingressProp.resourceLogicalId));
+            this.ingress.addNew(...this.readInlineRules(ingressProp.newValue, ingressProp.resourceLogicalId));
+        }
+        for (const egressProp of props.egressRulePropertyChanges) {
+            this.egress.addOld(...this.readInlineRules(egressProp.oldValue, egressProp.resourceLogicalId));
+            this.egress.addNew(...this.readInlineRules(egressProp.newValue, egressProp.resourceLogicalId));
+        }
+        // Rule resources
+        for (const ingressRes of props.ingressRuleResourceChanges) {
+            this.ingress.addOld(...this.readRuleResource(ingressRes.oldProperties));
+            this.ingress.addNew(...this.readRuleResource(ingressRes.newProperties));
+        }
+        for (const egressRes of props.egressRuleResourceChanges) {
+            this.egress.addOld(...this.readRuleResource(egressRes.oldProperties));
+            this.egress.addNew(...this.readRuleResource(egressRes.newProperties));
+        }
+        this.ingress.calculateDiff();
+        this.egress.calculateDiff();
+    }
+    get hasChanges() {
+        return this.ingress.hasChanges || this.egress.hasChanges;
+    }
+    /**
+     * Return a summary table of changes
+     */
+    summarize() {
+        const ret = [];
+        const header = ['', 'Group', 'Dir', 'Protocol', 'Peer'];
+        const inWord = 'In';
+        const outWord = 'Out';
+        // Render a single rule to the table (curried function so we can map it across rules easily--thank you JavaScript!)
+        const renderRule = (plusMin, inOut) => (rule) => [
+            plusMin,
+            rule.groupId,
+            inOut,
+            rule.describeProtocol(),
+            rule.describePeer(),
+        ].map(s => plusMin === '+' ? chalk.green(s) : chalk.red(s));
+        // First generate all lines, sort later
+        ret.push(...this.ingress.additions.map(renderRule('+', inWord)));
+        ret.push(...this.egress.additions.map(renderRule('+', outWord)));
+        ret.push(...this.ingress.removals.map(renderRule('-', inWord)));
+        ret.push(...this.egress.removals.map(renderRule('-', outWord)));
+        // Sort by group name then ingress/egress (ingress first)
+        ret.sort(util_1.makeComparator((row) => [row[1], row[2].indexOf(inWord) > -1 ? 0 : 1]));
+        ret.splice(0, 0, header);
+        return ret;
+    }
+    toJson() {
+        return util_1.deepRemoveUndefined({
+            ingressRuleAdditions: util_1.dropIfEmpty(this.ingress.additions.map(s => s.toJson())),
+            ingressRuleRemovals: util_1.dropIfEmpty(this.ingress.removals.map(s => s.toJson())),
+            egressRuleAdditions: util_1.dropIfEmpty(this.egress.additions.map(s => s.toJson())),
+            egressRuleRemovals: util_1.dropIfEmpty(this.egress.removals.map(s => s.toJson())),
+        });
+    }
+    get rulesAdded() {
+        return this.ingress.hasAdditions
+            || this.egress.hasAdditions;
+    }
+    readInlineRules(rules, logicalId) {
+        if (!rules) {
+            return [];
+        }
+        // UnCloudFormation so the parser works in an easier domain
+        const ref = '${' + logicalId + '.GroupId}';
+        return rules.map((r) => new security_group_rule_1.SecurityGroupRule(render_intrinsics_1.renderIntrinsics(r), ref));
+    }
+    readRuleResource(resource) {
+        if (!resource) {
+            return [];
+        }
+        // UnCloudFormation so the parser works in an easier domain
+        return [new security_group_rule_1.SecurityGroupRule(render_intrinsics_1.renderIntrinsics(resource))];
+    }
+}
+exports.SecurityGroupChanges = SecurityGroupChanges;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-group-changes.js","sourceRoot":"","sources":["security-group-changes.ts"],"names":[],"mappings":";;;AAAA,+BAA+B;AAC/B,+DAAoE;AAEpE,0CAAiD;AACjD,4DAAwD;AACxD,kCAA2E;AAS3E;;GAEG;AACH,MAAa,oBAAoB;IAI/B,YAAY,KAAgC;QAH5B,YAAO,GAAG,IAAI,6BAAkB,EAAqB,CAAC;QACtD,WAAM,GAAG,IAAI,6BAAkB,EAAqB,CAAC;QAGnE,cAAc;QACd,KAAK,MAAM,WAAW,IAAI,KAAK,CAAC,0BAA0B,EAAE;YAC1D,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,QAAQ,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC;YAClG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,QAAQ,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC;SACnG;QACD,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,yBAAyB,EAAE;YACxD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC;YAC/F,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC;SAChG;QAED,iBAAiB;QACjB,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,0BAA0B,EAAE;YACzD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;YACxE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;SACzE;QACD,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,yBAAyB,EAAE;YACvD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC;YACtE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC;SACvE;QAED,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;IAC3D,CAAC;IAED;;OAEG;IACI,SAAS;QACd,MAAM,GAAG,GAAe,EAAE,CAAC;QAE3B,MAAM,MAAM,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;QAExD,MAAM,MAAM,GAAG,IAAI,CAAC;QACpB,MAAM,OAAO,GAAG,KAAK,CAAC;QAEtB,mHAAmH;QACnH,MAAM,UAAU,GAAG,CAAC,OAAe,EAAE,KAAa,EAAE,EAAE,CAAC,CAAC,IAAuB,EAAE,EAAE,CAAC;YAClF,OAAO;YACP,IAAI,CAAC,OAAO;YACZ,KAAK;YACL,IAAI,CAAC,gBAAgB,EAAE;YACvB,IAAI,CAAC,YAAY,EAAE;SACpB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAE5D,uCAAuC;QACvC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;QACjE,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;QACjE,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;QAChE,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;QAEhE,yDAAyD;QACzD,GAAG,CAAC,IAAI,CAAC,qBAAc,CAAC,CAAC,GAAa,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE3F,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;QAEzB,OAAO,GAAG,CAAC;IACb,CAAC;IAEM,MAAM;QACX,OAAO,0BAAmB,CAAC;YACzB,oBAAoB,EAAE,kBAAW,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;YAC9E,mBAAmB,EAAE,kBAAW,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;YAC5E,mBAAmB,EAAE,kBAAW,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;YAC5E,kBAAkB,EAAE,kBAAW,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;SAC3E,CAAC,CAAC;IACL,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY;eACzB,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC;IAClC,CAAC;IAEO,eAAe,CAAC,KAAU,EAAE,SAAiB;QACnD,IAAI,CAAC,KAAK,EAAE;YAAE,OAAO,EAAE,CAAC;SAAE;QAE1B,2DAA2D;QAE3D,MAAM,GAAG,GAAG,IAAI,GAAG,SAAS,GAAG,WAAW,CAAC;QAC3C,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,uCAAiB,CAAC,oCAAgB,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IAChF,CAAC;IAEO,gBAAgB,CAAC,QAAa;QACpC,IAAI,CAAC,QAAQ,EAAE;YAAE,OAAO,EAAE,CAAC;SAAE;QAE7B,2DAA2D;QAE3D,OAAO,CAAC,IAAI,uCAAiB,CAAC,oCAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC7D,CAAC;CACF;AAjGD,oDAiGC","sourcesContent":["import * as chalk from 'chalk';\nimport { RuleJson, SecurityGroupRule } from './security-group-rule';\nimport { PropertyChange, ResourceChange } from '../diff/types';\nimport { DiffableCollection } from '../diffable';\nimport { renderIntrinsics } from '../render-intrinsics';\nimport { deepRemoveUndefined, dropIfEmpty, makeComparator } from '../util';\n\nexport interface SecurityGroupChangesProps {\n  ingressRulePropertyChanges: PropertyChange[];\n  ingressRuleResourceChanges: ResourceChange[];\n  egressRuleResourceChanges: ResourceChange[];\n  egressRulePropertyChanges: PropertyChange[];\n}\n\n/**\n * Changes to IAM statements\n */\nexport class SecurityGroupChanges {\n  public readonly ingress = new DiffableCollection<SecurityGroupRule>();\n  public readonly egress = new DiffableCollection<SecurityGroupRule>();\n\n  constructor(props: SecurityGroupChangesProps) {\n    // Group rules\n    for (const ingressProp of props.ingressRulePropertyChanges) {\n      this.ingress.addOld(...this.readInlineRules(ingressProp.oldValue, ingressProp.resourceLogicalId));\n      this.ingress.addNew(...this.readInlineRules(ingressProp.newValue, ingressProp.resourceLogicalId));\n    }\n    for (const egressProp of props.egressRulePropertyChanges) {\n      this.egress.addOld(...this.readInlineRules(egressProp.oldValue, egressProp.resourceLogicalId));\n      this.egress.addNew(...this.readInlineRules(egressProp.newValue, egressProp.resourceLogicalId));\n    }\n\n    // Rule resources\n    for (const ingressRes of props.ingressRuleResourceChanges) {\n      this.ingress.addOld(...this.readRuleResource(ingressRes.oldProperties));\n      this.ingress.addNew(...this.readRuleResource(ingressRes.newProperties));\n    }\n    for (const egressRes of props.egressRuleResourceChanges) {\n      this.egress.addOld(...this.readRuleResource(egressRes.oldProperties));\n      this.egress.addNew(...this.readRuleResource(egressRes.newProperties));\n    }\n\n    this.ingress.calculateDiff();\n    this.egress.calculateDiff();\n  }\n\n  public get hasChanges() {\n    return this.ingress.hasChanges || this.egress.hasChanges;\n  }\n\n  /**\n   * Return a summary table of changes\n   */\n  public summarize(): string[][] {\n    const ret: string[][] = [];\n\n    const header = ['', 'Group', 'Dir', 'Protocol', 'Peer'];\n\n    const inWord = 'In';\n    const outWord = 'Out';\n\n    // Render a single rule to the table (curried function so we can map it across rules easily--thank you JavaScript!)\n    const renderRule = (plusMin: string, inOut: string) => (rule: SecurityGroupRule) => [\n      plusMin,\n      rule.groupId,\n      inOut,\n      rule.describeProtocol(),\n      rule.describePeer(),\n    ].map(s => plusMin === '+' ? chalk.green(s) : chalk.red(s));\n\n    // First generate all lines, sort later\n    ret.push(...this.ingress.additions.map(renderRule('+', inWord)));\n    ret.push(...this.egress.additions.map(renderRule('+', outWord)));\n    ret.push(...this.ingress.removals.map(renderRule('-', inWord)));\n    ret.push(...this.egress.removals.map(renderRule('-', outWord)));\n\n    // Sort by group name then ingress/egress (ingress first)\n    ret.sort(makeComparator((row: string[]) => [row[1], row[2].indexOf(inWord) > -1 ? 0 : 1]));\n\n    ret.splice(0, 0, header);\n\n    return ret;\n  }\n\n  public toJson(): SecurityGroupChangesJson {\n    return deepRemoveUndefined({\n      ingressRuleAdditions: dropIfEmpty(this.ingress.additions.map(s => s.toJson())),\n      ingressRuleRemovals: dropIfEmpty(this.ingress.removals.map(s => s.toJson())),\n      egressRuleAdditions: dropIfEmpty(this.egress.additions.map(s => s.toJson())),\n      egressRuleRemovals: dropIfEmpty(this.egress.removals.map(s => s.toJson())),\n    });\n  }\n\n  public get rulesAdded(): boolean {\n    return this.ingress.hasAdditions\n        || this.egress.hasAdditions;\n  }\n\n  private readInlineRules(rules: any, logicalId: string): SecurityGroupRule[] {\n    if (!rules) { return []; }\n\n    // UnCloudFormation so the parser works in an easier domain\n\n    const ref = '${' + logicalId + '.GroupId}';\n    return rules.map((r: any) => new SecurityGroupRule(renderIntrinsics(r), ref));\n  }\n\n  private readRuleResource(resource: any): SecurityGroupRule[] {\n    if (!resource) { return []; }\n\n    // UnCloudFormation so the parser works in an easier domain\n\n    return [new SecurityGroupRule(renderIntrinsics(resource))];\n  }\n}\n\nexport interface SecurityGroupChangesJson {\n  ingressRuleAdditions?: RuleJson[];\n  ingressRuleRemovals?: RuleJson[];\n  egressRuleAdditions?: RuleJson[];\n  egressRuleRemovals?: RuleJson[];\n}\n"]}

package/node_modules/@aws-cdk/cloudformation-diff/lib/network/security-group-rule.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A single security group rule, either egress or ingress
+ */
+export declare class SecurityGroupRule {
+    /**
+     * Group ID of the group this rule applies to
+     */
+    readonly groupId: string;
+    /**
+     * IP protocol this rule applies to
+     */
+    readonly ipProtocol: string;
+    /**
+     * Start of port range this rule applies to, or ICMP type
+     */
+    readonly fromPort?: number;
+    /**
+     * End of port range this rule applies to, or ICMP code
+     */
+    readonly toPort?: number;
+    /**
+     * Peer of this rule
+     */
+    readonly peer?: RulePeer;
+    constructor(ruleObject: any, groupRef?: string);
+    equal(other: SecurityGroupRule): boolean;
+    describeProtocol(): string;
+    describePeer(): string;
+    toJson(): RuleJson;
+}
+export interface CidrIpPeer {
+    kind: 'cidr-ip';
+    ip: string;
+}
+export interface SecurityGroupPeer {
+    kind: 'security-group';
+    securityGroupId: string;
+}
+export interface PrefixListPeer {
+    kind: 'prefix-list';
+    prefixListId: string;
+}
+export declare type RulePeer = CidrIpPeer | SecurityGroupPeer | PrefixListPeer;
+export interface RuleJson {
+    groupId: string;
+    ipProtocol: string;
+    fromPort?: number;
+    toPort?: number;
+    peer?: RulePeer;
+}

package/node_modules/@aws-cdk/cloudformation-diff/lib/network/security-group-rule.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityGroupRule = void 0;
+/**
+ * A single security group rule, either egress or ingress
+ */
+class SecurityGroupRule {
+    constructor(ruleObject, groupRef) {
+        this.ipProtocol = ruleObject.IpProtocol || '*unknown*';
+        this.fromPort = ruleObject.FromPort;
+        this.toPort = ruleObject.ToPort;
+        this.groupId = ruleObject.GroupId || groupRef || '*unknown*'; // In case of an inline rule
+        this.peer =
+            findFirst(ruleObject, ['CidrIp', 'CidrIpv6'], (ip) => ({ kind: 'cidr-ip', ip }))
+                ||
+                    findFirst(ruleObject, ['DestinationSecurityGroupId', 'SourceSecurityGroupId'], (securityGroupId) => ({ kind: 'security-group', securityGroupId }))
+                ||
+                    findFirst(ruleObject, ['DestinationPrefixListId', 'SourcePrefixListId'], (prefixListId) => ({ kind: 'prefix-list', prefixListId }));
+    }
+    equal(other) {
+        return this.ipProtocol === other.ipProtocol
+            && this.fromPort === other.fromPort
+            && this.toPort === other.toPort
+            && peerEqual(this.peer, other.peer);
+    }
+    describeProtocol() {
+        if (this.ipProtocol === '-1') {
+            return 'Everything';
+        }
+        const ipProtocol = this.ipProtocol.toUpperCase();
+        if (this.fromPort === -1) {
+            return `All ${ipProtocol}`;
+        }
+        if (this.fromPort === this.toPort) {
+            return `${ipProtocol} ${this.fromPort}`;
+        }
+        return `${ipProtocol} ${this.fromPort}-${this.toPort}`;
+    }
+    describePeer() {
+        if (this.peer) {
+            switch (this.peer.kind) {
+                case 'cidr-ip':
+                    if (this.peer.ip === '0.0.0.0/0') {
+                        return 'Everyone (IPv4)';
+                    }
+                    if (this.peer.ip === '::/0') {
+                        return 'Everyone (IPv6)';
+                    }
+                    return `${this.peer.ip}`;
+                case 'prefix-list': return `${this.peer.prefixListId}`;
+                case 'security-group': return `${this.peer.securityGroupId}`;
+            }
+        }
+        return '?';
+    }
+    toJson() {
+        return {
+            groupId: this.groupId,
+            ipProtocol: this.ipProtocol,
+            fromPort: this.fromPort,
+            toPort: this.toPort,
+            peer: this.peer,
+        };
+    }
+}
+exports.SecurityGroupRule = SecurityGroupRule;
+function peerEqual(a, b) {
+    if ((a === undefined) !== (b === undefined)) {
+        return false;
+    }
+    if (a === undefined) {
+        return true;
+    }
+    if (a.kind !== b.kind) {
+        return false;
+    }
+    switch (a.kind) {
+        case 'cidr-ip': return a.ip === b.ip;
+        case 'security-group': return a.securityGroupId === b.securityGroupId;
+        case 'prefix-list': return a.prefixListId === b.prefixListId;
+    }
+}
+function findFirst(obj, keys, fn) {
+    for (const key of keys) {
+        if (key in obj) {
+            return fn(obj[key]);
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-group-rule.js","sourceRoot":"","sources":["security-group-rule.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A single security group rule, either egress or ingress\n */\nexport class SecurityGroupRule {\n  /**\n   * Group ID of the group this rule applies to\n   */\n  public readonly groupId: string;\n\n  /**\n   * IP protocol this rule applies to\n   */\n  public readonly ipProtocol: string;\n\n  /**\n   * Start of port range this rule applies to, or ICMP type\n   */\n  public readonly fromPort?: number;\n\n  /**\n   * End of port range this rule applies to, or ICMP code\n   */\n  public readonly toPort?: number;\n\n  /**\n   * Peer of this rule\n   */\n  public readonly peer?: RulePeer;\n\n  constructor(ruleObject: any, groupRef?: string) {\n    this.ipProtocol = ruleObject.IpProtocol || '*unknown*';\n    this.fromPort = ruleObject.FromPort;\n    this.toPort = ruleObject.ToPort;\n    this.groupId = ruleObject.GroupId || groupRef || '*unknown*'; // In case of an inline rule\n\n    this.peer =\n        findFirst(ruleObject,\n          ['CidrIp', 'CidrIpv6'],\n          (ip) => ({ kind: 'cidr-ip', ip } as CidrIpPeer))\n        ||\n        findFirst(ruleObject,\n          ['DestinationSecurityGroupId', 'SourceSecurityGroupId'],\n          (securityGroupId) => ({ kind: 'security-group', securityGroupId } as SecurityGroupPeer))\n        ||\n        findFirst(ruleObject,\n          ['DestinationPrefixListId', 'SourcePrefixListId'],\n          (prefixListId) => ({ kind: 'prefix-list', prefixListId } as PrefixListPeer));\n  }\n\n  public equal(other: SecurityGroupRule) {\n    return this.ipProtocol === other.ipProtocol\n        && this.fromPort === other.fromPort\n        && this.toPort === other.toPort\n        && peerEqual(this.peer, other.peer);\n  }\n\n  public describeProtocol() {\n    if (this.ipProtocol === '-1') { return 'Everything'; }\n\n    const ipProtocol = this.ipProtocol.toUpperCase();\n\n    if (this.fromPort === -1) { return `All ${ipProtocol}`; }\n    if (this.fromPort === this.toPort) { return `${ipProtocol} ${this.fromPort}`; }\n    return `${ipProtocol} ${this.fromPort}-${this.toPort}`;\n  }\n\n  public describePeer() {\n    if (this.peer) {\n      switch (this.peer.kind) {\n        case 'cidr-ip':\n          if (this.peer.ip === '0.0.0.0/0') { return 'Everyone (IPv4)'; }\n          if (this.peer.ip === '::/0') { return 'Everyone (IPv6)'; }\n          return `${this.peer.ip}`;\n        case 'prefix-list': return `${this.peer.prefixListId}`;\n        case 'security-group': return `${this.peer.securityGroupId}`;\n      }\n    }\n\n    return '?';\n  }\n\n  public toJson(): RuleJson {\n    return {\n      groupId: this.groupId,\n      ipProtocol: this.ipProtocol,\n      fromPort: this.fromPort,\n      toPort: this.toPort,\n      peer: this.peer,\n    };\n  }\n}\n\nexport interface CidrIpPeer {\n  kind: 'cidr-ip';\n  ip: string;\n}\n\nexport interface SecurityGroupPeer {\n  kind: 'security-group';\n  securityGroupId: string;\n}\n\nexport interface PrefixListPeer {\n  kind: 'prefix-list';\n  prefixListId: string;\n}\n\nexport type RulePeer = CidrIpPeer | SecurityGroupPeer | PrefixListPeer;\n\nfunction peerEqual(a?: RulePeer, b?: RulePeer) {\n  if ((a === undefined) !== (b === undefined)) { return false; }\n  if (a === undefined) { return true; }\n\n  if (a.kind !== b!.kind) { return false; }\n  switch (a.kind) {\n    case 'cidr-ip': return a.ip === (b as typeof a).ip;\n    case 'security-group': return a.securityGroupId === (b as typeof a).securityGroupId;\n    case 'prefix-list': return a.prefixListId === (b as typeof a).prefixListId;\n  }\n}\n\nfunction findFirst<T>(obj: any, keys: string[], fn: (x: string) => T): T | undefined {\n  for (const key of keys) {\n    if (key in obj) {\n      return fn(obj[key]);\n    }\n  }\n  return undefined;\n}\n\nexport interface RuleJson {\n  groupId: string;\n  ipProtocol: string;\n  fromPort?: number;\n  toPort?: number;\n  peer?: RulePeer;\n}"]}