@terra-graph/conventions-aws 1.0.0-rc.1

package/dist/cjs/plugins/AwsSns.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsSns = void 0;
+const core_1 = require("@terra-graph/core");
+const namespaces_js_1 = require("../namespaces.js");
+class AwsSns extends core_1.GraphPlugin {
+    static id = (0, namespaces_js_1.pluginId)(`aws.${AwsSns.name}`);
+    constructor() {
+        super(AwsSns.id);
+    }
+    build(_input) {
+        return {
+            phases: [
+                {
+                    phase: 'main',
+                    rules: [
+                        new core_1.EdgeReverse({
+                            edge: {
+                                from: {
+                                    attr: {
+                                        key: 'terraform.resource',
+                                        eq: 'aws_sns_topic',
+                                    },
+                                },
+                                to: {
+                                    attr: {
+                                        key: 'terraform.resource',
+                                        eq: 'aws_sns_topic_subscription',
+                                    },
+                                },
+                            },
+                        }),
+                    ],
+                },
+                {
+                    phase: 'main',
+                    rules: [
+                        new core_1.ConvertNodeToEdge({
+                            node: {
+                                attr: {
+                                    key: 'terraform.resource',
+                                    eq: 'aws_sns_topic_subscription',
+                                },
+                            },
+                        }),
+                    ],
+                },
+            ],
+        };
+    }
+}
+exports.AwsSns = AwsSns;

package/dist/cjs/plugins/AwsSns.test.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@terra-graph/core");
+const AwsSns_js_1 = require("./AwsSns.js");
+const buildPhases = () => {
+    const plugin = new AwsSns_js_1.AwsSns();
+    const result = plugin.build({
+        options: {},
+        namedRules: new core_1.NamedRuleRegistry(),
+        namedRuleSets: new core_1.NamedRuleSetRegistry(),
+    });
+    return (result.phases ?? []).map((phase) => ({
+        phase: phase.phase,
+        rules: phase.rules.map((rule) => rule.serialize()),
+    }));
+};
+describe('AwsSns.build', () => {
+    it('shoud reverse subscription edges and convert subscriptions into edges', () => {
+        const phases = buildPhases();
+        expect(phases).toHaveLength(2);
+        expect(phases.map((phase) => phase.phase)).toStrictEqual(['main', 'main']);
+        expect(phases[0]?.rules).toHaveLength(1);
+        expect(phases[0]?.rules[0]).toStrictEqual({
+            id: 'EdgeReverse',
+            config: {
+                edge: {
+                    from: {
+                        attr: {
+                            key: 'terraform.resource',
+                            eq: 'aws_sns_topic',
+                        },
+                    },
+                    to: {
+                        attr: {
+                            key: 'terraform.resource',
+                            eq: 'aws_sns_topic_subscription',
+                        },
+                    },
+                },
+            },
+        });
+        expect(phases[1]?.rules).toHaveLength(1);
+        expect(phases[1]?.rules[0]).toStrictEqual({
+            id: 'ConvertNodeToEdge',
+            config: {
+                node: {
+                    attr: {
+                        key: 'terraform.resource',
+                        eq: 'aws_sns_topic_subscription',
+                    },
+                },
+            },
+        });
+    });
+});

package/dist/cjs/plugins/AwsTransferFamily.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsTransferFamily = void 0;
+const core_1 = require("@terra-graph/core");
+const namespaces_js_1 = require("../namespaces.js");
+const DEFAULT_EVENT_BUS_ADDRESS = 'aws_cloudwatch_event_bus.default';
+const DEFAULT_EVENT_BUS_NODE_ID = (0, core_1.tgNodeIdFrom)('resource', DEFAULT_EVENT_BUS_ADDRESS);
+const ensureDefaultEventBus = (graph) => {
+    return graph.setNodeAttributes(DEFAULT_EVENT_BUS_NODE_ID, {
+        terraform: {
+            kind: 'resource',
+            address: DEFAULT_EVENT_BUS_ADDRESS,
+            resource: 'aws_cloudwatch_event_bus',
+            name: 'default',
+        },
+    });
+};
+class ConnectTransferConnectorToDefaultEventBus extends core_1.NodeRule {
+    constructor() {
+        super({
+            node: {
+                attr: {
+                    key: 'terraform.resource',
+                    eq: 'aws_transfer_connector',
+                },
+            },
+        });
+    }
+    apply(nodeId, _node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        const updated = ensureDefaultEventBus(graph);
+        return updated.setEdge((0, core_1.edgeIdFrom)(nodeId, DEFAULT_EVENT_BUS_NODE_ID, 'transfer:connector-bus'), nodeId, DEFAULT_EVENT_BUS_NODE_ID, {});
+    }
+}
+class RewireTransferEventRuleToDefaultEventBus extends core_1.NodeRule {
+    constructor() {
+        super({
+            node: {
+                attr: {
+                    key: 'terraform.resource',
+                    eq: 'aws_cloudwatch_event_rule',
+                },
+            },
+        });
+    }
+    apply(nodeId, _node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        const outEdges = graph.outEdges(nodeId);
+        let updated = ensureDefaultEventBus(graph);
+        if (outEdges.length === 0) {
+            return updated.setEdge((0, core_1.edgeIdFrom)(DEFAULT_EVENT_BUS_NODE_ID, nodeId, 'transfer:rule-bus'), DEFAULT_EVENT_BUS_NODE_ID, nodeId, {});
+        }
+        let didRewire = false;
+        for (const outEdgeId of outEdges) {
+            const targetNodeId = graph.edgeTarget(outEdgeId);
+            const targetNode = graph.getNodeAttributes(targetNodeId);
+            if (targetNode?.terraform?.resource !== 'aws_transfer_connector') {
+                continue;
+            }
+            updated = updated.removeEdge(outEdgeId);
+            didRewire = true;
+        }
+        if (!didRewire) {
+            return updated;
+        }
+        return updated.setEdge((0, core_1.edgeIdFrom)(DEFAULT_EVENT_BUS_NODE_ID, nodeId, 'transfer:rule-bus'), DEFAULT_EVENT_BUS_NODE_ID, nodeId, {});
+    }
+}
+class AwsTransferFamily extends core_1.GraphPlugin {
+    static id = (0, namespaces_js_1.pluginId)(`aws.${AwsTransferFamily.name}`);
+    constructor() {
+        super(AwsTransferFamily.id);
+    }
+    build(_input) {
+        return {
+            phases: [
+                {
+                    phase: 'main',
+                    rules: [
+                        new core_1.RemoveNode({
+                            node: {
+                                attr: {
+                                    key: 'terraform.resource',
+                                    eq: 'aws_transfer_tag',
+                                },
+                            },
+                        }),
+                    ],
+                },
+                {
+                    phase: 'main',
+                    rules: [
+                        new ConnectTransferConnectorToDefaultEventBus(),
+                        new RewireTransferEventRuleToDefaultEventBus(),
+                    ],
+                },
+            ],
+        };
+    }
+}
+exports.AwsTransferFamily = AwsTransferFamily;

package/dist/cjs/plugins/AwsTransferFamily.test.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@terra-graph/core");
+const AwsTransferFamily_js_1 = require("./AwsTransferFamily.js");
+const buildPhases = () => {
+    const plugin = new AwsTransferFamily_js_1.AwsTransferFamily();
+    const result = plugin.build({
+        options: {},
+        namedRules: new core_1.NamedRuleRegistry(),
+        namedRuleSets: new core_1.NamedRuleSetRegistry(),
+    });
+    return (result.phases ?? []).map((phase) => ({
+        phase: phase.phase,
+        rules: phase.rules.map((rule) => rule.serialize()),
+    }));
+};
+const buildMainRules = () => {
+    const plugin = new AwsTransferFamily_js_1.AwsTransferFamily();
+    const result = plugin.build({
+        options: {},
+        namedRules: new core_1.NamedRuleRegistry(),
+        namedRuleSets: new core_1.NamedRuleSetRegistry(),
+    });
+    return (result.phases?.[1]?.rules ?? []).map((rule) => rule);
+};
+const getConnectorRule = () => {
+    const rule = buildMainRules()[0];
+    if (!rule) {
+        throw new Error('Missing ConnectTransferConnectorToDefaultEventBus rule');
+    }
+    return rule;
+};
+const getRewireRule = () => {
+    const rule = buildMainRules()[1];
+    if (!rule) {
+        throw new Error('Missing RewireTransferEventRuleToDefaultEventBus rule');
+    }
+    return rule;
+};
+const defaultBusId = (0, core_1.tgNodeIdFrom)('resource', 'aws_cloudwatch_event_bus.default');
+const buildAdapter = (graph) => {
+    return new core_1.GraphologyAdapter().withTgGraph(graph);
+};
+describe('AwsTransferFamily.build', () => {
+    it('shoud remove transfer tags and connect transfer eventing to a default bus', () => {
+        const phases = buildPhases();
+        expect(phases).toHaveLength(2);
+        expect(phases.map((phase) => phase.phase)).toStrictEqual(['main', 'main']);
+        expect(phases[0]?.rules[0]).toStrictEqual({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    attr: {
+                        key: 'terraform.resource',
+                        eq: 'aws_transfer_tag',
+                    },
+                },
+            },
+        });
+        expect(phases[1]?.rules).toHaveLength(2);
+        expect(phases[1]?.rules[0]?.id).toBe('ConnectTransferConnectorToDefaultEventBus');
+        expect(phases[1]?.rules[1]?.id).toBe('RewireTransferEventRuleToDefaultEventBus');
+    });
+    it('shoud connect aws_transfer_connector nodes to the implicit default event bus', () => {
+        const connectorId = (0, core_1.asNodeId)('resource.aws_transfer_connector.main');
+        const adapter = buildAdapter({
+            schemaVersion: core_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [connectorId]: {
+                    id: connectorId,
+                    label: 'connector',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_transfer_connector.main',
+                        resource: 'aws_transfer_connector',
+                        name: 'main',
+                    },
+                },
+            },
+            edges: [],
+        });
+        const connectorRule = getConnectorRule();
+        const connectorNode = adapter.getNodeAttributes(connectorId);
+        if (!connectorNode) {
+            throw new Error('Missing aws_transfer_connector node');
+        }
+        connectorRule.match(connectorId, connectorNode, adapter);
+        const updated = connectorRule.apply(connectorId, connectorNode, adapter);
+        const busNode = updated.getNodeAttributes(defaultBusId);
+        expect(busNode?.terraform?.resource).toBe('aws_cloudwatch_event_bus');
+        expect(updated.edgesBetween(connectorId, defaultBusId)).toHaveLength(1);
+    });
+    it('shoud rewire event rule edges to the default bus when rule has no outbound edges', () => {
+        const ruleId = (0, core_1.asNodeId)('resource.aws_cloudwatch_event_rule.primary');
+        const adapter = buildAdapter({
+            schemaVersion: core_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [ruleId]: {
+                    id: ruleId,
+                    label: 'event_rule',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_cloudwatch_event_rule.primary',
+                        resource: 'aws_cloudwatch_event_rule',
+                        name: 'primary',
+                    },
+                },
+            },
+            edges: [],
+        });
+        const rewireRule = getRewireRule();
+        const ruleNode = adapter.getNodeAttributes(ruleId);
+        if (!ruleNode) {
+            throw new Error('Missing aws_cloudwatch_event_rule node');
+        }
+        rewireRule.match(ruleId, ruleNode, adapter);
+        const updated = rewireRule.apply(ruleId, ruleNode, adapter);
+        const busNode = updated.getNodeAttributes(defaultBusId);
+        expect(busNode?.terraform?.resource).toBe('aws_cloudwatch_event_bus');
+        expect(updated.edgesBetween(defaultBusId, ruleId)).toHaveLength(1);
+        const outboundToDefaultBus = updated
+            .outEdges(ruleId)
+            .filter((edgeId) => updated.edgeTarget(edgeId) === defaultBusId);
+        expect(outboundToDefaultBus).toHaveLength(0);
+    });
+    it('shoud replace event rule to connector edges with default bus edges', () => {
+        const ruleId = (0, core_1.asNodeId)('resource.aws_cloudwatch_event_rule.forward');
+        const connectorId = (0, core_1.asNodeId)('resource.aws_transfer_connector.main');
+        const adapter = buildAdapter({
+            schemaVersion: core_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [ruleId]: {
+                    id: ruleId,
+                    label: 'event_rule',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_cloudwatch_event_rule.forward',
+                        resource: 'aws_cloudwatch_event_rule',
+                        name: 'forward',
+                    },
+                },
+                [connectorId]: {
+                    id: connectorId,
+                    label: 'connector',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_transfer_connector.main',
+                        resource: 'aws_transfer_connector',
+                        name: 'main',
+                    },
+                },
+            },
+            edges: [
+                {
+                    id: (0, core_1.asEdgeId)('edge-rule-connector'),
+                    from: ruleId,
+                    to: connectorId,
+                    attributes: {},
+                },
+            ],
+        });
+        const rewireRule = getRewireRule();
+        const ruleNode = adapter.getNodeAttributes(ruleId);
+        if (!ruleNode) {
+            throw new Error('Missing aws_cloudwatch_event_rule node');
+        }
+        rewireRule.match(ruleId, ruleNode, adapter);
+        const updated = rewireRule.apply(ruleId, ruleNode, adapter);
+        expect(updated.edgesBetween(ruleId, connectorId)).toHaveLength(0);
+        expect(updated.edgesBetween(defaultBusId, ruleId)).toHaveLength(1);
+    });
+    it('shoud preserve non-connector event rule edges and still create the default bus', () => {
+        const ruleId = (0, core_1.asNodeId)('resource.aws_cloudwatch_event_rule.unchanged');
+        const targetId = (0, core_1.asNodeId)('resource.aws_lambda_function.handler');
+        const adapter = buildAdapter({
+            schemaVersion: core_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [ruleId]: {
+                    id: ruleId,
+                    label: 'event_rule',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_cloudwatch_event_rule.unchanged',
+                        resource: 'aws_cloudwatch_event_rule',
+                        name: 'unchanged',
+                    },
+                },
+                [targetId]: {
+                    id: targetId,
+                    label: 'target',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_lambda_function.handler',
+                        resource: 'aws_lambda_function',
+                        name: 'handler',
+                    },
+                },
+            },
+            edges: [
+                {
+                    id: (0, core_1.asEdgeId)('edge-rule-target'),
+                    from: ruleId,
+                    to: targetId,
+                    attributes: {},
+                },
+            ],
+        });
+        const rewireRule = getRewireRule();
+        const ruleNode = adapter.getNodeAttributes(ruleId);
+        if (!ruleNode) {
+            throw new Error('Missing aws_cloudwatch_event_rule node');
+        }
+        rewireRule.match(ruleId, ruleNode, adapter);
+        const updated = rewireRule.apply(ruleId, ruleNode, adapter);
+        expect(updated.edgesBetween(ruleId, targetId)).toHaveLength(1);
+        expect(updated.edgesBetween(defaultBusId, ruleId)).toHaveLength(0);
+        expect(updated.getNodeAttributes(defaultBusId)).toBeDefined();
+    });
+    it('shoud do nothing when connector rule does not match', () => {
+        const eventRuleId = (0, core_1.asNodeId)('resource.aws_cloudwatch_event_rule.primary');
+        const adapter = buildAdapter({
+            schemaVersion: core_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [eventRuleId]: {
+                    id: eventRuleId,
+                    label: 'event_rule',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_cloudwatch_event_rule.primary',
+                        resource: 'aws_cloudwatch_event_rule',
+                        name: 'primary',
+                    },
+                },
+            },
+            edges: [],
+        });
+        const connectorRule = getConnectorRule();
+        const eventRuleNode = adapter.getNodeAttributes(eventRuleId);
+        if (!eventRuleNode) {
+            throw new Error('Missing aws_cloudwatch_event_rule node');
+        }
+        const updated = connectorRule.apply(eventRuleId, eventRuleNode, adapter);
+        expect(updated).toBe(adapter);
+        expect(updated.getNodeAttributes(defaultBusId)).toBeUndefined();
+    });
+    it('shoud do nothing when rewire rule does not match', () => {
+        const eventRuleId = (0, core_1.asNodeId)('resource.aws_cloudwatch_event_rule.primary');
+        const adapter = buildAdapter({
+            schemaVersion: core_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [eventRuleId]: {
+                    id: eventRuleId,
+                    label: 'event_rule',
+                    terraform: {
+                        kind: 'resource',
+                        address: 'aws_cloudwatch_event_rule.primary',
+                        resource: 'aws_cloudwatch_event_rule',
+                        name: 'primary',
+                    },
+                },
+            },
+            edges: [],
+        });
+        const rewireRule = getRewireRule();
+        const eventRuleNode = adapter.getNodeAttributes(eventRuleId);
+        if (!eventRuleNode) {
+            throw new Error('Missing aws_cloudwatch_event_rule node');
+        }
+        const updated = rewireRule.apply(eventRuleId, eventRuleNode, adapter);
+        expect(updated).toBe(adapter);
+        expect(updated.getNodeAttributes(defaultBusId)).toBeUndefined();
+    });
+});

package/dist/cjs/rules/dot.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@terra-graph/core");
+const namespaces_js_1 = require("../namespaces.js");
+exports.default = new core_1.NamedRuleRegistry({
+    [(0, namespaces_js_1.ruleName)('dot.sqs.dlq.align')]: new core_1.AlignNodes({
+        edge: {
+            from: {
+                attr: { key: 'terraform.resource', eq: 'aws_sqs_queue' },
+            },
+            to: {
+                attr: { key: 'terraform.resource', eq: 'aws_sqs_queue' },
+            },
+        },
+    }),
+    [(0, namespaces_js_1.ruleName)('dot.schedule.align')]: new core_1.AlignNodes({
+        edge: {
+            from: {
+                attr: { key: 'terraform.resource', eq: 'aws_scheduler_schedule' },
+            },
+            to: {
+                any: true,
+            },
+        },
+    }),
+    [(0, namespaces_js_1.ruleName)('dot.iam_role.align')]: new core_1.AlignNodes({
+        edge: {
+            from: {
+                attr: { key: 'terraform.resource', eq: 'aws_iam_role' },
+            },
+            to: {
+                any: true,
+            },
+        },
+    }),
+});

package/dist/cjs/rules/dot.test.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const namespaces_js_1 = require("../namespaces.js");
+const dot_js_1 = __importDefault(require("./dot.js"));
+const serialize = (name) => {
+    return dot_js_1.default.resolve(name).serialize();
+};
+describe('dot rules', () => {
+    it('shoud expose all dot named rules', () => {
+        expect(dot_js_1.default.names().sort()).toStrictEqual([
+            (0, namespaces_js_1.ruleName)('dot.sqs.dlq.align'),
+            (0, namespaces_js_1.ruleName)('dot.schedule.align'),
+            (0, namespaces_js_1.ruleName)('dot.iam_role.align'),
+        ].sort());
+    });
+    it('shoud align SQS DLQ edges and AWS scheduling/identity edges', () => {
+        expect(serialize((0, namespaces_js_1.ruleName)('dot.sqs.dlq.align'))).toStrictEqual({
+            id: 'AlignNodes',
+            config: {
+                edge: {
+                    from: {
+                        attr: {
+                            key: 'terraform.resource',
+                            eq: 'aws_sqs_queue',
+                        },
+                    },
+                    to: {
+                        attr: {
+                            key: 'terraform.resource',
+                            eq: 'aws_sqs_queue',
+                        },
+                    },
+                },
+            },
+        });
+        expect(serialize((0, namespaces_js_1.ruleName)('dot.schedule.align')).id).toBe('AlignNodes');
+        expect(serialize((0, namespaces_js_1.ruleName)('dot.iam_role.align')).id).toBe('AlignNodes');
+    });
+});

package/dist/cjs/rules/general.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@terra-graph/core");
+const namespaces_js_1 = require("../namespaces.js");
+exports.default = new core_1.NamedRuleRegistry({
+    [(0, namespaces_js_1.ruleName)('data.remove')]: new core_1.RemoveNode({
+        node: {
+            or: [
+                {
+                    and: [
+                        { attr: { key: 'terraform.kind', eq: 'data' } },
+                        {
+                            not: {
+                                attr: {
+                                    key: 'terraform.resource',
+                                    in: ['aws_iam_policy_document', 'aws_iam_policy'],
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        },
+    }),
+    [(0, namespaces_js_1.ruleName)('log_groups.only_event_bridge')]: new core_1.RemoveNode({
+        node: {
+            and: [
+                {
+                    attr: {
+                        key: 'terraform.resource',
+                        eq: 'aws_cloudwatch_log_group',
+                    },
+                },
+                {
+                    not: {
+                        edge: {
+                            in: {
+                                attr: {
+                                    key: 'terraform.resource',
+                                    eq: 'aws_cloudwatch_event_target',
+                                },
+                            },
+                        },
+                    },
+                },
+            ],
+        },
+    }),
+    // TODO: this should probably be part of the convention too?
+    [(0, namespaces_js_1.ruleName)('lambda.only_event_source_mapping')]: new core_1.RemoveNode({
+        node: {
+            and: [
+                { attr: { key: 'terraform.resource', startsWith: 'aws_lambda' } },
+                {
+                    not: {
+                        attr: {
+                            key: 'terraform.resource',
+                            in: [
+                                'aws_lambda_function',
+                                'aws_lambda_event_source_mapping',
+                                'aws_lambda_permission',
+                            ],
+                        },
+                    },
+                },
+            ],
+        },
+    }),
+});

package/dist/cjs/rules/general.test.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const namespaces_js_1 = require("../namespaces.js");
+const general_js_1 = __importDefault(require("./general.js"));
+const serialize = (name) => {
+    return general_js_1.default.resolve(name).serialize();
+};
+describe('general rules', () => {
+    it('shoud expose all general named rules', () => {
+        expect(general_js_1.default.names().sort()).toStrictEqual([
+            (0, namespaces_js_1.ruleName)('data.remove'),
+            (0, namespaces_js_1.ruleName)('lambda.only_event_source_mapping'),
+            (0, namespaces_js_1.ruleName)('log_groups.only_event_bridge'),
+        ].sort());
+    });
+    it('shoud remove data nodes except policy artifacts by default', () => {
+        expect(serialize((0, namespaces_js_1.ruleName)('data.remove'))).toStrictEqual({
+            id: 'RemoveNode',
+            config: {
+                node: {
+                    or: [
+                        {
+                            and: [
+                                { attr: { key: 'terraform.kind', eq: 'data' } },
+                                {
+                                    not: {
+                                        attr: {
+                                            key: 'terraform.resource',
+                                            in: ['aws_iam_policy_document', 'aws_iam_policy'],
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        });
+    });
+    it('shoud remove non-event-bridge log groups and non-core lambda resources by query', () => {
+        expect(serialize((0, namespaces_js_1.ruleName)('log_groups.only_event_bridge')).id).toBe('RemoveNode');
+        expect(serialize((0, namespaces_js_1.ruleName)('lambda.only_event_source_mapping')).id).toBe('RemoveNode');
+    });
+});