@dataparade/cli 0.0.1

package/dist/tests/unit/analyzers/registry.spec.js

@@ -0,0 +1,234 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const registry_1 = require("../../../src/analyzers/registry");
+const file_system_1 = require("../../../src/ingest/file-system");
+describe("analyzers/registry - DP-P0-CLI-102", () => {
+    beforeEach(() => {
+        (0, registry_1.__clearAnalyzersForTest)();
+    });
+    it("dispatches files to analyzers by language and skips unsupported languages", () => {
+        const seenByTs = [];
+        const seenByJs = [];
+        const seenByPy = [];
+        const tsAnalyzer = {
+            detect(file) {
+                seenByTs.push(file.path);
+                return [
+                    {
+                        pattern: "express_route",
+                        name: `ts-${file.name}`,
+                        confidence: 0.9,
+                        location: {
+                            filePath: file.path,
+                            startLine: 1,
+                            endLine: 1,
+                        },
+                        properties: {},
+                    },
+                ];
+            },
+        };
+        const jsAnalyzer = {
+            detect(file) {
+                seenByJs.push(file.path);
+                return [
+                    {
+                        pattern: "external_api_call",
+                        name: `js-${file.name}`,
+                        confidence: 0.8,
+                        location: {
+                            filePath: file.path,
+                            startLine: 1,
+                            endLine: 1,
+                        },
+                        properties: {},
+                    },
+                ];
+            },
+        };
+        const pyAnalyzer = {
+            detect(file) {
+                seenByPy.push(file.path);
+                return [
+                    {
+                        pattern: "external_api_call",
+                        name: `py-${file.name}`,
+                        confidence: 0.85,
+                        location: {
+                            filePath: file.path,
+                            startLine: 1,
+                            endLine: 1,
+                        },
+                        properties: {},
+                    },
+                ];
+            },
+        };
+        (0, registry_1.registerAnalyzer)("typescript", tsAnalyzer);
+        (0, registry_1.registerAnalyzer)("javascript", jsAnalyzer);
+        (0, registry_1.registerAnalyzer)("python", pyAnalyzer);
+        const files = [
+            {
+                path: "src/index.ts",
+                name: "index.ts",
+                content: "console.log('ts');",
+                language: "typescript",
+                size: 10,
+            },
+            {
+                path: "src/app.jsx",
+                name: "app.jsx",
+                content: "console.log('js');",
+                language: "javascript",
+                size: 10,
+            },
+            {
+                path: "config/app.yaml",
+                name: "app.yaml",
+                content: "key: value",
+                language: "yaml",
+                size: 10,
+            },
+            {
+                path: "scripts/example.py",
+                name: "example.py",
+                content: "print('hi')",
+                language: "python",
+                size: 10,
+            },
+        ];
+        const findings = (0, registry_1.runAnalyzers)(files);
+        expect(seenByTs).toEqual(["src/index.ts"]);
+        expect(seenByJs).toEqual(["src/app.jsx"]);
+        expect(seenByPy).toEqual(["scripts/example.py"]);
+        const findingNames = findings.map((f) => f.name);
+        expect(findingNames).toContain("ts-index.ts");
+        expect(findingNames).toContain("js-app.jsx");
+        expect(findingNames).toContain("py-example.py");
+        expect(findingNames.length).toBe(3);
+    });
+    it("returns undefined for files without a registered analyzer", () => {
+        const file = {
+            path: "data/sample.json",
+            name: "sample.json",
+            content: '{"ok":true}',
+            language: "json",
+            size: 15,
+        };
+        expect((0, registry_1.getAnalyzerForFile)(file)).toBeUndefined();
+    });
+    it("processes files in a deterministic order", () => {
+        const calls = [];
+        const tsAnalyzer = {
+            detect(file) {
+                calls.push(`ts:${file.path}`);
+                return [];
+            },
+        };
+        (0, registry_1.registerAnalyzer)("typescript", tsAnalyzer);
+        const files = [
+            {
+                path: "b.ts",
+                name: "b.ts",
+                content: "",
+                language: "typescript",
+                size: 0,
+            },
+            {
+                path: "a.ts",
+                name: "a.ts",
+                content: "",
+                language: "typescript",
+                size: 0,
+            },
+        ];
+        (0, registry_1.runAnalyzers)(files);
+        expect(calls).toEqual(["ts:b.ts", "ts:a.ts"]);
+    });
+    it("integrates with ingest to analyze only supported languages", async () => {
+        const seenByTs = [];
+        const seenByJs = [];
+        const tsAnalyzer = {
+            detect(file) {
+                seenByTs.push(file.path);
+                return [];
+            },
+        };
+        const jsAnalyzer = {
+            detect(file) {
+                seenByJs.push(file.path);
+                return [];
+            },
+        };
+        (0, registry_1.registerAnalyzer)("typescript", tsAnalyzer);
+        (0, registry_1.registerAnalyzer)("javascript", jsAnalyzer);
+        const fixtureRoot = path.resolve(__dirname, "../../fixtures/ingest-basic");
+        const filesFromIngest = await (0, file_system_1.ingestFileSystem)(fixtureRoot);
+        const findings = (0, registry_1.runAnalyzers)(filesFromIngest);
+        expect(findings).toEqual([]);
+        expect(seenByTs.length).toBeGreaterThan(0);
+        expect(seenByJs.length).toBeGreaterThan(0);
+        const allSeen = [...seenByTs, ...seenByJs];
+        expect(allSeen.every((p) => p.endsWith(".ts") || p.endsWith(".jsx"))).toBe(true);
+    });
+    it("runs analyzers via runAnalyzersForRootPath helper", async () => {
+        const seen = [];
+        const tsAnalyzer = {
+            detect(file) {
+                seen.push(file.path);
+                return [
+                    {
+                        pattern: "express_route",
+                        name: `ts-${file.name}`,
+                        confidence: 1,
+                        location: {
+                            filePath: file.path,
+                            startLine: 1,
+                            endLine: 1,
+                        },
+                        properties: {},
+                    },
+                ];
+            },
+        };
+        (0, registry_1.registerAnalyzer)("typescript", tsAnalyzer);
+        const fixtureRoot = path.resolve(__dirname, "../../fixtures/ingest-basic");
+        const findings = await (0, registry_1.runAnalyzersForRootPath)(fixtureRoot);
+        expect(findings.length).toBeGreaterThan(0);
+        expect(seen.length).toBeGreaterThan(0);
+    });
+});

package/dist/tests/unit/analyzers/terraform/classifier-subtype-parity.spec.d.ts

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

package/dist/tests/unit/analyzers/terraform/classifier-subtype-parity.spec.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const terraform_detection_config_1 = require("../../../../src/analyzers/terraform/terraform-detection-config");
+const cliRoot = path_1.default.join(__dirname, "..", "..", "..", "..");
+function readYaml(file) {
+    const text = fs_1.default.readFileSync(file, "utf8");
+    return yaml_1.default.parse(text);
+}
+function collectClassifierAssetSubtypes(raw) {
+    const out = new Set();
+    if (!raw || typeof raw !== "object")
+        return out;
+    const doc = raw;
+    const defaults = doc.pattern_defaults;
+    if (defaults && typeof defaults === "object") {
+        for (const row of Object.values(defaults)) {
+            if (!row || typeof row !== "object")
+                continue;
+            const st = row.subType;
+            if (typeof st === "string" && st.trim())
+                out.add(st.trim());
+        }
+    }
+    const dbMap = doc.database_type_mapping;
+    if (dbMap && typeof dbMap === "object") {
+        for (const row of Object.values(dbMap)) {
+            if (!row || typeof row !== "object")
+                continue;
+            const st = row.subType;
+            if (typeof st === "string" && st.trim())
+                out.add(st.trim());
+        }
+    }
+    return out;
+}
+function collectPropertyEnhanceSubtypes(raw) {
+    const out = new Set();
+    if (!raw || typeof raw !== "object")
+        return out;
+    const enhance = raw.enhance;
+    if (!enhance || typeof enhance !== "object")
+        return out;
+    const e = enhance;
+    const pushList = (key) => {
+        const v = e[key];
+        if (!Array.isArray(v))
+            return;
+        for (const item of v) {
+            if (typeof item === "string" && item.trim())
+                out.add(item.trim());
+        }
+    };
+    pushList("main_app_subtypes");
+    pushList("cloud_asset_subtypes");
+    pushList("on_prem_asset_subtypes");
+    const ops = e.supported_operations;
+    if (ops && typeof ops === "object") {
+        for (const k of Object.keys(ops)) {
+            if (k.trim())
+                out.add(k.trim());
+        }
+    }
+    return out;
+}
+/** Subtypes that come from code classification but are not modeled as Terraform resource hints. */
+const EXCLUDED_FROM_RESOURCE_HINT_PARITY = new Set(["cloud_provider"]);
+describe("Terraform resource_type_hints vs classifier/property subTypes", () => {
+    it("every TS/Python asset subType used in classifier or enhance config has at least one terraform hint", () => {
+        const classifierPath = path_1.default.join(cliRoot, "patterns", "classifier", "components.classifier.yaml");
+        const propertyPath = path_1.default.join(cliRoot, "patterns", "property.patterns.yaml");
+        const classifierSubs = collectClassifierAssetSubtypes(readYaml(classifierPath));
+        const propertySubs = collectPropertyEnhanceSubtypes(readYaml(propertyPath));
+        const required = new Set([...classifierSubs, ...propertySubs]);
+        for (const ex of EXCLUDED_FROM_RESOURCE_HINT_PARITY)
+            required.delete(ex);
+        const tfConfig = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+        const hinted = new Set(tfConfig.resourceTypeHints.map((h) => h.componentSubType));
+        const missing = [...required].filter((s) => !hinted.has(s)).sort();
+        expect(missing).toEqual([]);
+    });
+});

package/dist/tests/unit/analyzers/terraform/detector.spec.d.ts

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

package/dist/tests/unit/analyzers/terraform/detector.spec.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const detector_1 = require("../../../../src/analyzers/terraform/detector");
+const terraform_detection_config_1 = require("../../../../src/analyzers/terraform/terraform-detection-config");
+describe("analyzers/terraform/detector", () => {
+    const tfConfig = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+    it("emits terraform_resource and terraform_provider findings for fixture", () => {
+        const root = path_1.default.join(__dirname, "../../../fixtures/terraform-basic");
+        const mainPath = path_1.default.join(root, "main.tf");
+        const provPath = path_1.default.join(root, "providers.tf");
+        const mainContent = fs_1.default.readFileSync(mainPath, "utf8");
+        const provContent = fs_1.default.readFileSync(provPath, "utf8");
+        const mainFindings = (0, detector_1.detectTerraformPatterns)({
+            path: "main.tf",
+            name: "main.tf",
+            content: mainContent,
+            language: "terraform",
+            size: mainContent.length,
+        }, tfConfig);
+        const res = mainFindings.filter((f) => f.pattern === "terraform_resource");
+        expect(res.length).toBeGreaterThanOrEqual(3);
+        const lambda = res.find((f) => f.properties.terraform_address === "aws_lambda_function.api");
+        expect(lambda).toBeDefined();
+        const refs = lambda?.properties.terraform_references;
+        expect(Array.isArray(refs)).toBe(true);
+        expect(refs).toContain("aws_db_instance.main");
+        expect(refs).not.toContain("aws_iam_role.lambda_exec");
+        expect(res.some((f) => f.properties?.resource_type === "aws_iam_role")).toBe(false);
+        const provFindings = (0, detector_1.detectTerraformPatterns)({
+            path: "providers.tf",
+            name: "providers.tf",
+            content: provContent,
+            language: "terraform",
+            size: provContent.length,
+        }, tfConfig);
+        expect(provFindings.some((f) => f.pattern === "terraform_provider")).toBe(true);
+    });
+    it("returns empty for non-terraform language", () => {
+        expect((0, detector_1.detectTerraformPatterns)({
+            path: "x.ts",
+            name: "x.ts",
+            content: "export {}",
+            language: "typescript",
+            size: 10,
+        }, tfConfig)).toEqual([]);
+    });
+    it("merges S3 ACL and ownership satellite resources into the bucket finding", () => {
+        const content = `
+resource "aws_s3_bucket" "app_data" {
+  bucket = "example-app-data"
+}
+
+resource "aws_s3_bucket_ownership_controls" "app_data" {
+  bucket = aws_s3_bucket.app_data.id
+  rule {
+    object_ownership = "BucketOwnerPreferred"
+  }
+}
+
+resource "aws_s3_bucket_acl" "app_data" {
+  bucket = aws_s3_bucket.app_data.id
+  acl    = "private"
+}
+`;
+        const findings = (0, detector_1.detectTerraformPatterns)({
+            path: "storage.tf",
+            name: "storage.tf",
+            content,
+            language: "terraform",
+            size: content.length,
+        }, tfConfig);
+        const resources = findings.filter((f) => f.pattern === "terraform_resource");
+        expect(resources).toHaveLength(1);
+        expect(resources[0]?.properties?.terraform_address).toBe("aws_s3_bucket.app_data");
+        const sats = resources[0]?.properties?.terraform_satellites;
+        expect(Array.isArray(sats)).toBe(true);
+        expect(sats?.length).toBe(2);
+        const satAddrs = new Set(sats?.map((s) => s.terraform_address));
+        expect(satAddrs.has("aws_s3_bucket_ownership_controls.app_data")).toBe(true);
+        expect(satAddrs.has("aws_s3_bucket_acl.app_data")).toBe(true);
+    });
+    it("does not emit a terraform_resource finding for random_pet utility resources", () => {
+        const content = `
+resource "random_pet" "lambda_bucket_name" {
+  length = 4
+}
+
+resource "aws_s3_bucket" "lambda_bucket" {
+  bucket = random_pet.lambda_bucket_name.id
+}
+`;
+        const findings = (0, detector_1.detectTerraformPatterns)({
+            path: "main.tf",
+            name: "main.tf",
+            content,
+            language: "terraform",
+            size: content.length,
+        }, tfConfig);
+        const resources = findings.filter((f) => f.pattern === "terraform_resource");
+        expect(resources).toHaveLength(1);
+        expect(resources[0]?.properties?.terraform_address).toBe("aws_s3_bucket.lambda_bucket");
+        const refs = resources[0]?.properties?.terraform_references;
+        expect(refs).toEqual([]);
+    });
+});

package/dist/tests/unit/analyzers/terraform/generated-provider-hints.spec.d.ts

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

package/dist/tests/unit/analyzers/terraform/generated-provider-hints.spec.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const terraform_detection_config_1 = require("../../../../src/analyzers/terraform/terraform-detection-config");
+describe("terraform CDKTF-generated service-prefix hints", () => {
+    beforeEach(() => {
+        (0, terraform_detection_config_1.clearTerraformPatternConfigCache)();
+    });
+    describe("AWS (@cdktf/provider-aws)", () => {
+        it("classifies a resource only covered by generated aws_<svc>_ hints", () => {
+            const cfg = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+            const h = (0, terraform_detection_config_1.lookupTerraformResourceHints)("aws_accessanalyzer_analyzer", cfg);
+            expect(h.cloud_provider).toBe("aws");
+            expect(h.componentSubType).toBe("service");
+        });
+        it("still prefers hand-written rules before generated + aws_default", () => {
+            const cfg = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+            const h = (0, terraform_detection_config_1.lookupTerraformResourceHints)("aws_s3_bucket", cfg);
+            expect(h.componentSubType).toBe("storage");
+        });
+    });
+    describe("Azure (@cdktf/provider-azurerm)", () => {
+        it("classifies a resource only covered by generated azurerm_<svc>_ hints", () => {
+            const cfg = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+            const h = (0, terraform_detection_config_1.lookupTerraformResourceHints)("azurerm_analysis_services_server", cfg);
+            expect(h.cloud_provider).toBe("azure");
+            expect(h.componentSubType).toBe("database");
+        });
+        it("still prefers hand-written rules before generated + azurerm_default", () => {
+            const cfg = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+            const h = (0, terraform_detection_config_1.lookupTerraformResourceHints)("azurerm_storage_account", cfg);
+            expect(h.componentSubType).toBe("storage");
+        });
+    });
+    describe("Kubernetes (@cdktf/provider-kubernetes)", () => {
+        it("classifies a resource only covered by generated kubernetes_<svc>_ hints", () => {
+            const cfg = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+            const h = (0, terraform_detection_config_1.lookupTerraformResourceHints)("kubernetes_horizontal_pod_autoscaler_v2", cfg);
+            expect(h.cloud_provider).toBe("kubernetes");
+            expect(h.componentSubType).toBe("service");
+        });
+        it("still prefers hand-written rules before generated + kubernetes_default", () => {
+            const cfg = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+            const h = (0, terraform_detection_config_1.lookupTerraformResourceHints)("kubernetes_deployment", cfg);
+            expect(h.componentSubType).toBe("service");
+            expect(h.cloud_provider).toBe("kubernetes");
+        });
+        it("classifies kubernetes_service as api via hand-written rule", () => {
+            const cfg = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+            const h = (0, terraform_detection_config_1.lookupTerraformResourceHints)("kubernetes_service", cfg);
+            expect(h.componentSubType).toBe("api");
+        });
+    });
+});

package/dist/tests/unit/analyzers/terraform/parser.spec.d.ts

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

package/dist/tests/unit/analyzers/terraform/parser.spec.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const parser_1 = require("../../../../src/analyzers/terraform/parser");
+const terraform_detection_config_1 = require("../../../../src/analyzers/terraform/terraform-detection-config");
+describe("analyzers/terraform/parser", () => {
+    const tfConfig = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+    it("lineBraceDelta ignores braces inside double-quoted strings", () => {
+        expect((0, parser_1.lineBraceDelta)('x = "{}"')).toBe(0);
+        expect((0, parser_1.lineBraceDelta)("outer {")).toBe(1);
+        expect((0, parser_1.lineBraceDelta)("}")).toBe(-1);
+    });
+    it("parses resource, module, and provider blocks from terraform-basic fixture", () => {
+        const root = path_1.default.join(__dirname, "../../../fixtures/terraform-basic");
+        const mainPath = path_1.default.join(root, "main.tf");
+        const content = fs_1.default.readFileSync(mainPath, "utf8");
+        const { blocks, warnings } = (0, parser_1.parseTerraformFile)({
+            path: "main.tf",
+            name: "main.tf",
+            content,
+            language: "terraform",
+            size: content.length,
+        }, tfConfig);
+        expect(warnings).toEqual([]);
+        const addresses = blocks.map((b) => b.address).sort();
+        expect(addresses).toContain("aws_db_instance.main");
+        expect(addresses).toContain("aws_lambda_function.api");
+        expect(addresses).toContain("aws_s3_bucket.data");
+        expect(addresses).toContain("aws_iam_role.lambda_exec");
+    });
+    it("extracts cross-resource references from lambda environment", () => {
+        const root = path_1.default.join(__dirname, "../../../fixtures/terraform-basic");
+        const mainPath = path_1.default.join(root, "main.tf");
+        const content = fs_1.default.readFileSync(mainPath, "utf8");
+        const { blocks } = (0, parser_1.parseTerraformFile)({
+            path: "main.tf",
+            name: "main.tf",
+            content,
+            language: "terraform",
+            size: content.length,
+        }, tfConfig);
+        const lambda = blocks.find((b) => b.address === "aws_lambda_function.api");
+        expect(lambda).toBeDefined();
+        const refs = (0, parser_1.extractTerraformReferences)(lambda.bodyText, tfConfig);
+        expect(refs).toContain("aws_db_instance.main");
+        expect(refs).toContain("aws_iam_role.lambda_exec");
+    });
+    it("sectionIdFromFilePath normalizes directory", () => {
+        expect((0, parser_1.sectionIdFromFilePath)("infra/main.tf")).toBe("infra");
+        expect((0, parser_1.sectionIdFromFilePath)("main.tf")).toBe("root");
+    });
+});

package/dist/tests/unit/analyzers/terraform/terraform-module-manifest.spec.d.ts

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

package/dist/tests/unit/analyzers/terraform/terraform-module-manifest.spec.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const terraform_module_manifest_1 = require("../../../../src/analyzers/terraform/terraform-module-manifest");
+function file(rel, content) {
+    return {
+        path: rel.replace(/\\/g, "/"),
+        name: path_1.default.basename(rel),
+        content,
+        language: "terraform",
+        size: content.length,
+    };
+}
+describe("terraform-module-manifest", () => {
+    const root = "/repo/aws_fullstack_terraform";
+    it("indexes module instance addresses by resolved filesystem module source", () => {
+        const files = [
+            file("environments/dev/main.tf", `
+module "vpc" {
+  source = "../../modules/vpc"
+}
+module "ecs_frontend" {
+  source = "../../modules/ecs-service"
+}
+module "ecs_backend" {
+  source = "../../modules/ecs-service"
+}
+`),
+        ];
+        const manifest = (0, terraform_module_manifest_1.buildTerraformModuleCallManifest)(root, files);
+        const vpcInstances = manifest.instancesByModuleSourceDir.get("modules/vpc");
+        expect(vpcInstances).toEqual(["module.vpc"]);
+        const ecsInstances = manifest.instancesByModuleSourceDir.get("modules/ecs-service");
+        expect(ecsInstances).toEqual(["module.ecs_backend", "module.ecs_frontend"]);
+    });
+    it("moduleInstancePrefixesForFile returns callers for a shared module directory", () => {
+        const manifest = (0, terraform_module_manifest_1.buildTerraformModuleCallManifest)(root, [
+            file("environments/dev/main.tf", `
+module "a" {
+  source = "../../modules/m"
+}
+module "b" {
+  source = "../../modules/m"
+}
+`),
+        ]);
+        const prefixes = (0, terraform_module_manifest_1.moduleInstancePrefixesForFile)(manifest, root, "modules/m/main.tf");
+        expect(prefixes).toEqual(["module.a", "module.b"]);
+    });
+    it("ignores registry module sources", () => {
+        const manifest = (0, terraform_module_manifest_1.buildTerraformModuleCallManifest)(root, [
+            file("root/main.tf", `
+module "x" {
+  source = "terraform-aws-modules/vpc/aws"
+}
+`),
+        ]);
+        expect(manifest.instancesByModuleSourceDir.size).toBe(0);
+    });
+});

package/dist/tests/unit/analyzers/terraform/terraform-utility-resource.spec.d.ts

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

package/dist/tests/unit/analyzers/terraform/terraform-utility-resource.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const terraform_utility_resource_1 = require("../../../../src/analyzers/terraform/terraform-utility-resource");
+describe("terraform-utility-resource", () => {
+    it("treats random_* as utility", () => {
+        expect((0, terraform_utility_resource_1.isTerraformUtilityResourceType)("random_string.x")).toBe(true);
+        expect((0, terraform_utility_resource_1.isTerraformUtilityResourceType)("aws_s3_bucket.x")).toBe(false);
+    });
+    it("treats aws_iam_* as identity (not service nodes)", () => {
+        expect((0, terraform_utility_resource_1.isTerraformIdentityInfrastructureResourceType)("aws_iam_role")).toBe(true);
+        expect((0, terraform_utility_resource_1.isTerraformIdentityInfrastructureResourceType)("aws_iam_role_policy")).toBe(true);
+        expect((0, terraform_utility_resource_1.isTerraformIdentityInfrastructureResourceType)("aws_lambda_function")).toBe(false);
+    });
+    it("omits utilities and IAM from service graph", () => {
+        expect((0, terraform_utility_resource_1.isTerraformOmittedFromServiceGraphResourceType)("random_id.x")).toBe(true);
+        expect((0, terraform_utility_resource_1.isTerraformOmittedFromServiceGraphResourceType)("aws_iam_role.x")).toBe(true);
+        expect((0, terraform_utility_resource_1.isTerraformOmittedFromServiceGraphResourceType)("aws_ecs_service.x")).toBe(false);
+    });
+});

package/dist/tests/unit/analyzers/terraform-exec.spec.d.ts

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