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

package/dist/cjs/rulesets/dot.js

@@ -0,0 +1,25 @@
+"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.NamedRuleSetRegistry({
+    [(0, namespaces_js_1.ruleSetName)('dot.sqs.dlq')]: new core_1.RuleSet({
+        rules: [
+            { namedRule: (0, namespaces_js_1.ruleName)('dot.sqs.dlq.align') },
+            new core_1.EdgeLegend({
+                options: {
+                    colour: '#c20202',
+                    title: 'SQS dead letters / failures',
+                },
+                edge: {
+                    from: {
+                        attr: { key: 'terraform.resource', eq: 'aws_sqs_queue' },
+                    },
+                    to: {
+                        attr: { key: 'terraform.resource', eq: 'aws_sqs_queue' },
+                    },
+                },
+            }),
+        ],
+    }),
+});

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

@@ -0,0 +1,48 @@
+"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("../rules/dot.js"));
+const dot_js_2 = __importDefault(require("./dot.js"));
+describe('dot rule sets', () => {
+    it('shoud expose the SQS dead-letter rule set', () => {
+        const name = (0, namespaces_js_1.ruleSetName)('dot.sqs.dlq');
+        expect(dot_js_2.default.names()).toEqual([name]);
+        const resolved = dot_js_2.default.resolve(name);
+        const phases = resolved.resolvePhases(dot_js_1.default);
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(2);
+        expect(phases[0][0].serialize()).toStrictEqual({
+            id: 'AlignNodes',
+            config: {
+                edge: {
+                    from: {
+                        attr: { key: 'terraform.resource', eq: 'aws_sqs_queue' },
+                    },
+                    to: {
+                        attr: { key: 'terraform.resource', eq: 'aws_sqs_queue' },
+                    },
+                },
+            },
+        });
+        expect(phases[0][1]).toMatchObject({
+            serialize: expect.any(Function),
+        });
+        expect(phases[0][1].serialize().id).toBe('EdgeLegend');
+        expect(phases[0][1].serialize().config.options).toMatchObject({
+            colour: '#c20202',
+            title: 'SQS dead letters / failures',
+        });
+        const edgeLegend = phases[0][1].serialize();
+        if (!('edge' in edgeLegend.config)) {
+            throw new Error('Expected EdgeLegend to provide an edge config');
+        }
+        expect(edgeLegend.config.edge).toMatchObject({
+            from: {
+                attr: { key: 'terraform.resource', eq: 'aws_sqs_queue' },
+            },
+        });
+    });
+});

package/dist/esm/conventions/dataflow/profiles/base.d.ts

@@ -0,0 +1,4 @@
+import { Profile } from '@terra-graph/core';
+export declare const conventionDataFlowBaseProfileName: string;
+declare const _default: Profile<Record<string, unknown>>;
+export default _default;

package/dist/esm/conventions/dataflow/profiles/base.js

@@ -0,0 +1,86 @@
+import { coreBase } from '@terra-graph/conventions-core';
+import { Profile, RemoveNode } from '@terra-graph/core';
+import { conventionName, profileName, ruleName, ruleSetName } from '../../../namespaces.js';
+import { AwsIamGraphPlugin } from '../../../plugins/AwsIam.js';
+import { AwsS3 } from '../../../plugins/AwsS3.js';
+import { Convention } from '../../index.js';
+export const conventionDataFlowBaseProfileName = conventionName(Convention.DataFlow, profileName('base'));
+export default new Profile(conventionDataFlowBaseProfileName, {
+    usesProfiles: [coreBase],
+    phases: [
+        {
+            phase: 'pre',
+            rules: [
+                new RemoveNode({
+                    node: {
+                        or: [
+                            {
+                                attr: {
+                                    key: 'terraform.resource',
+                                    startsWith: ['aws_kms_', 'aws_ssm_'],
+                                },
+                            },
+                            {
+                                attr: {
+                                    key: 'terraform.resource',
+                                    in: ['external', 'aws_caller_identity'],
+                                },
+                            },
+                        ],
+                    },
+                }),
+                // { namedRule: ruleName('log_groups.only_event_bridge') },
+                { namedRule: ruleName('lambda.only_event_source_mapping') },
+            ],
+        },
+        {
+            phase: 'semantics',
+            rules: [{ namedRuleSet: conventionName(Convention.DataFlow, ruleSetName('semantics')) }],
+        },
+        {
+            phase: 'cleanup',
+            rules: [
+                // not sure this semantics re-run is needed?
+                { namedRuleSet: conventionName(Convention.DataFlow, ruleSetName('semantics')) },
+                { namedRuleSet: conventionName(Convention.DataFlow, ruleSetName('cleanup')) },
+            ],
+        },
+        {
+            phase: 'main',
+            rules: [
+            // TODO: ConvertNodeToEdge probably should apply some hints to the edge (converted node etc)
+            // new ConvertNodeToEdge({
+            //   node: {
+            //     attr: {
+            //       key: 'terraform.resource',
+            //       in: [
+            //         'aws_lambda_event_source_mapping',
+            //         'aws_cloudwatch_event_target',
+            //         'aws_cloudwatch_log_destination',
+            //       ],
+            //     },
+            //   },
+            // }),
+            ],
+        },
+    ],
+    plugins: [
+        { plugin: AwsS3.id },
+        {
+            plugin: AwsIamGraphPlugin.id,
+            options: { mode: 'full', removeOrphans: true },
+        },
+        // { plugin: 'aws.iam', options: { mode: 'full' } },
+        // {
+        //   plugin: 'aws.iam',
+        //   options: { mode: 'roles_policies', attachments: 'convert_to_edge' },
+        // }, // can't see any difference
+        // { plugin: 'aws.iam', options: { mode: 'full' } }, // shows everything as expected
+        // {
+        //   plugin: 'aws.iam',
+        //   options: {
+        //     mode: 'full',
+        //   },
+        // },
+    ],
+});

package/dist/esm/conventions/dataflow/profiles/dot.d.ts

@@ -0,0 +1,4 @@
+import { Profile } from '@terra-graph/core';
+export declare const conventionDataFlowDotProfileName: string;
+declare const _default: Profile<Record<string, unknown>>;
+export default _default;

package/dist/esm/conventions/dataflow/profiles/dot.js

@@ -0,0 +1,38 @@
+import { DotAdapter, Profile } from '@terra-graph/core';
+import { conventionName, profileName, ruleName, ruleSetName } from '../../../namespaces.js';
+import { Convention } from '../../index.js';
+import base from './base.js';
+export const conventionDataFlowDotProfileName = conventionName(Convention.DataFlow, profileName('dot'));
+const baseDotProfile = new Profile('overview.dot', {
+    supports: DotAdapter,
+    render: {
+        options: {
+            graph: {
+                rankdir: 'LR',
+                ranksep: 2.5,
+                nodesep: 0.6,
+                pad: 1,
+            },
+        },
+    },
+    phases: [
+        {
+            phase: 'normalize',
+            rules: [{ namedRule: 'dot.normalise_modules' }],
+        },
+    ],
+});
+export default new Profile(conventionDataFlowDotProfileName, {
+    supports: DotAdapter,
+    usesProfiles: [base, baseDotProfile],
+    phases: [
+        {
+            phase: 'main',
+            rules: [
+                { namedRuleSet: ruleSetName('dot.sqs.dlq') },
+                { namedRule: ruleName('dot.schedule.align') },
+                { namedRule: ruleName('dot.iam_role.align') },
+            ],
+        },
+    ],
+});

package/dist/esm/conventions/dataflow/profiles/dot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/conventions/dataflow/profiles/dot.test.js

@@ -0,0 +1,109 @@
+import { DotAdapter, NamedRuleRegistry, NamedRuleSetRegistry, NodeDotProperties, RemoveNode, RemoveNodeAndReconnectEdges, } from '@terra-graph/core';
+import createRuntimeProvider from '../../../index.js';
+import { conventionName, profileName, ruleName, ruleSetName } from '../../../namespaces.js';
+import { AwsIamGraphPlugin } from '../../../plugins/AwsIam.js';
+import { AwsS3 } from '../../../plugins/AwsS3.js';
+import { Convention } from '../../index.js';
+import dataFlowConventionRules from '../rules.js';
+import dataFlowConventionRuleSet from '../rulesets.js';
+import conventionDataFlowDotProfile, { conventionDataFlowDotProfileName } from './dot.js';
+const baseNamedRules = new NamedRuleRegistry({
+    'remove.tfconfig': new RemoveNode({
+        node: {
+            or: [
+                {
+                    attr: {
+                        key: 'terraform.kind',
+                        in: ['local', 'var', 'terraform_data'],
+                    },
+                },
+                {
+                    attr: {
+                        key: 'terraform.resource',
+                        in: ['null_resource', 'local_file'],
+                    },
+                },
+            ],
+        },
+    }),
+    'reconnect.time_sleep': new RemoveNodeAndReconnectEdges({
+        node: {
+            attr: {
+                key: 'terraform.resource',
+                eq: 'time_sleep',
+            },
+        },
+    }),
+    'remove.childless_modules': new RemoveNode({
+        node: {
+            and: [{ attr: { key: 'terraform.kind', eq: 'module' } }, { children: { exists: false } }],
+        },
+    }),
+    'dot.normalise_modules': new NodeDotProperties({
+        options: {
+            peripheries: 0,
+            label: '',
+            height: 0,
+            width: 0,
+        },
+        node: {
+            attr: {
+                key: 'terraform.kind',
+                eq: 'module',
+            },
+        },
+    }),
+});
+const baseNamedRuleSets = new NamedRuleSetRegistry({});
+describe('data flow dot profile', () => {
+    it('shoud expose namespaced profile metadata and plugin refs', () => {
+        const serialized = conventionDataFlowDotProfile.serialize();
+        expect(serialized.name).toBe(conventionDataFlowDotProfileName);
+        expect(serialized.supports).toBe(DotAdapter.name);
+        expect(serialized.phases?.map((phase) => phase.phase)).toStrictEqual(['main']);
+        const baseProfile = serialized.usesProfiles?.[0];
+        expect(baseProfile?.phases?.map((phase) => phase.phase)).toStrictEqual([
+            'pre',
+            'semantics',
+            'cleanup',
+            'main',
+        ]);
+        expect(baseProfile?.plugins).toEqual([
+            { plugin: AwsS3.id },
+            {
+                plugin: AwsIamGraphPlugin.id,
+                options: { mode: 'full', removeOrphans: true },
+            },
+        ]);
+        expect(conventionDataFlowDotProfileName).toBe(conventionName(Convention.DataFlow, profileName('dot')));
+    });
+    it('shoud resolve phase plan with runtime provider registries', () => {
+        const runtime = createRuntimeProvider();
+        const runtimeNamedRules = runtime.namedRules;
+        const runtimeNamedRuleSets = runtime.namedRuleSets;
+        const runtimePlugins = runtime.plugins;
+        if (!runtimeNamedRules || !runtimeNamedRuleSets || !runtimePlugins) {
+            throw new Error('Runtime provider missing expected registries');
+        }
+        const namedRules = NamedRuleRegistry.from([baseNamedRules, runtimeNamedRules]);
+        const namedRuleSets = NamedRuleSetRegistry.from([baseNamedRuleSets, runtimeNamedRuleSets]);
+        const phases = conventionDataFlowDotProfile.resolvePhases(namedRules, namedRuleSets, runtimePlugins);
+        expect(phases.length).toBeGreaterThan(4);
+        expect(phases.map((rules) => rules.some((rule) => rule.serialize().id === 'EdgeLegend'))).toContain(true);
+    });
+    it('shoud reference conventions rules and rule sets from the dataflow profile', () => {
+        const baseProfile = conventionDataFlowDotProfile.serialize().usesProfiles?.[0];
+        const preRules = baseProfile?.phases?.[0]?.rules;
+        const mainRules = conventionDataFlowDotProfile.serialize().phases?.[0]?.rules;
+        expect(preRules).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'RemoveNode' }),
+            { namedRule: ruleName('lambda.only_event_source_mapping') },
+        ]));
+        expect(mainRules).toEqual(expect.arrayContaining([
+            { namedRuleSet: ruleSetName('dot.sqs.dlq') },
+            { namedRule: ruleName('dot.schedule.align') },
+        ]));
+        expect(dataFlowConventionRuleSet.names()).toContain(conventionName(Convention.DataFlow, ruleSetName('semantics')));
+        expect(dataFlowConventionRules.names()).toEqual([]);
+    });
+});

package/dist/esm/conventions/dataflow/rules.d.ts

@@ -0,0 +1,3 @@
+import { NamedRuleRegistry } from '@terra-graph/core';
+declare const _default: NamedRuleRegistry;
+export default _default;

package/dist/esm/conventions/dataflow/rules.js

@@ -0,0 +1,2 @@
+import { NamedRuleRegistry } from '@terra-graph/core';
+export default new NamedRuleRegistry({});

package/dist/esm/conventions/dataflow/rules.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/conventions/dataflow/rules.test.js

@@ -0,0 +1,6 @@
+import dataFlowConventionRules from './rules.js';
+describe('dataflow convention rules', () => {
+    it('shoud export an empty registry', () => {
+        expect(dataFlowConventionRules.names()).toEqual([]);
+    });
+});

package/dist/esm/conventions/dataflow/rulesets.d.ts

@@ -0,0 +1,3 @@
+import { NamedRuleSetRegistry } from '@terra-graph/core';
+declare const _default: NamedRuleSetRegistry;
+export default _default;