@dataparade/cli 0.0.1

package/dist/tests/unit/core/terraform-minimal-services.spec.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const application_injection_1 = require("../../../src/classifier/application-injection");
+const terraform_minimal_services_1 = require("../../../src/core/pipeline/terraform-minimal-services");
+const scan_result_builders_1 = require("../../helpers/scan-result-builders");
+describe("terraform-minimal-services", () => {
+    it("ecsModuleServiceLabel formats module.ecs_*", () => {
+        expect((0, terraform_minimal_services_1.ecsModuleServiceLabel)("module.ecs_frontend")).toBe("ECS Frontend");
+        expect((0, terraform_minimal_services_1.ecsModuleServiceLabel)("module.ecs_backend")).toBe("ECS Backend");
+    });
+    it("terraformMinimalLayoutBucket classifies hub and services", () => {
+        expect((0, terraform_minimal_services_1.terraformMinimalLayoutBucket)({
+            id: "a",
+            name: "User",
+            type: "actor",
+            subType: "customer",
+            confidence: 0.5,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: {},
+        })).toBe("actor");
+        expect((0, terraform_minimal_services_1.terraformMinimalLayoutBucket)((0, scan_result_builders_1.testAsset)("m", "App", {
+            sourceContext: application_injection_1.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT,
+        }))).toBe("main");
+        expect((0, terraform_minimal_services_1.terraformMinimalLayoutBucket)({
+            id: "p",
+            name: "AWS",
+            type: "third_party",
+            subType: "cloud_provider",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: { terraform_address: "provider.aws" },
+        })).toBe("provider");
+        expect((0, terraform_minimal_services_1.terraformMinimalLayoutBucket)((0, scan_result_builders_1.testAsset)("e", "ECS", { terraform_address: "module.ecs_frontend" }))).toBe("ecs");
+        expect((0, terraform_minimal_services_1.terraformMinimalLayoutBucket)((0, scan_result_builders_1.testAsset)("s", "S3", {
+            terraform_address: "aws_s3_bucket.x",
+            managed_by_provider: "tp_aws",
+        }))).toBe("managed");
+    });
+    it("isTerraformPrimaryScan is false when a non-Terraform api asset exists", () => {
+        const components = [
+            (0, scan_result_builders_1.testAsset)("s3", "b", { terraform_address: "aws_s3_bucket.x" }),
+            (0, scan_result_builders_1.testAsset)("api", "API", {}, "api"),
+        ];
+        expect((0, terraform_minimal_services_1.isTerraformPrimaryScan)(components)).toBe(false);
+    });
+    it("isMixedAppTerraformScan is true when app packages and Terraform coexist", () => {
+        const components = [
+            (0, scan_result_builders_1.testAsset)("api", "API", { section_id: "reedy" }, "api"),
+            (0, scan_result_builders_1.testAsset)("rds", "RDS", {
+                section_id: "terraform/modules/aurora",
+                terraform_address: "module.aurora.aws_rds_cluster.this",
+                resource_type: "aws_rds_cluster",
+            }),
+            {
+                id: "aws",
+                name: "Amazon Web Services",
+                type: "third_party",
+                subType: "cloud_provider",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { terraform_address: "provider.aws", section_id: "root" },
+            },
+        ];
+        expect((0, terraform_minimal_services_1.isMixedAppTerraformScan)(components)).toBe(true);
+        expect((0, terraform_minimal_services_1.isTerraformPrimaryScan)(components)).toBe(false);
+        expect((0, terraform_minimal_services_1.shouldKeepComponentInMixedAppTerraformScan)((0, scan_result_builders_1.testAsset)("rds", "RDS", {
+            terraform_address: "module.aurora.aws_rds_cluster.this",
+            resource_type: "aws_rds_cluster",
+        }))).toBe(false);
+        expect((0, terraform_minimal_services_1.shouldKeepComponentInMixedAppTerraformScan)((0, scan_result_builders_1.testAsset)("mod", "Module · aurora", {
+            terraform_address: "module.aurora",
+            section_id: "root",
+        }))).toBe(true);
+    });
+    it("isMixedAppTerraformScan is true for root-scoped API with app signals and Terraform shells", () => {
+        const components = [
+            (0, scan_result_builders_1.testAsset)("api", "API", { section_id: "root", isSectionApiNode: true }, "api"),
+            (0, scan_result_builders_1.testAsset)("rds", "RDS", {
+                section_id: "terraform",
+                terraform_address: "aws_db_instance.main",
+                resource_type: "aws_db_instance",
+            }),
+            (0, scan_result_builders_1.testAsset)("mod", "Module · db", {
+                terraform_address: "module.db",
+                section_id: "terraform",
+            }),
+            {
+                id: "aws",
+                name: "Amazon Web Services",
+                type: "third_party",
+                subType: "cloud_provider",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { terraform_address: "provider.aws", section_id: "terraform" },
+            },
+        ];
+        expect((0, terraform_minimal_services_1.isMixedAppTerraformScan)(components)).toBe(true);
+        expect((0, terraform_minimal_services_1.isTerraformPrimaryScan)(components)).toBe(false);
+    });
+    it("isMixedAppTerraformScan is false for root-scoped API without app signals", () => {
+        const components = [
+            (0, scan_result_builders_1.testAsset)("api", "API", { section_id: "root" }, "api"),
+            (0, scan_result_builders_1.testAsset)("mod", "Module · db", {
+                terraform_address: "module.db",
+                section_id: "terraform",
+            }),
+            {
+                id: "aws",
+                name: "AWS",
+                type: "third_party",
+                subType: "cloud_provider",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { terraform_address: "provider.aws", section_id: "terraform" },
+            },
+        ];
+        expect((0, terraform_minimal_services_1.isMixedAppTerraformScan)(components)).toBe(false);
+    });
+    it("applyMixedAppTerraformScanResult drops inner TF resources for root-scoped app + terraform section", () => {
+        const scanResult = {
+            components: [
+                (0, scan_result_builders_1.testAsset)("api", "API", { section_id: "root", isSectionApiNode: true }, "api"),
+                (0, scan_result_builders_1.testAsset)("rds", "RDS", {
+                    section_id: "terraform",
+                    terraform_address: "module.db.aws_db_instance.main",
+                    resource_type: "aws_db_instance",
+                }),
+                (0, scan_result_builders_1.testAsset)("mod", "Module · db", {
+                    terraform_address: "module.db",
+                    section_id: "terraform",
+                }),
+                {
+                    id: "aws",
+                    name: "Amazon Web Services",
+                    type: "third_party",
+                    subType: "cloud_provider",
+                    confidence: 0.9,
+                    detectedFrom: [],
+                    sourceLocations: [],
+                    properties: { terraform_address: "provider.aws", section_id: "terraform" },
+                },
+                (0, scan_result_builders_1.testAsset)("subnet", "Subnet", {
+                    section_id: "terraform",
+                    terraform_address: "aws_subnet.private",
+                    resource_type: "aws_subnet",
+                }),
+            ],
+            dataFlows: [
+                {
+                    id: "f1",
+                    sourceComponentId: "aws",
+                    targetComponentId: "rds",
+                    type: "database_query",
+                    confidence: 0.8,
+                },
+            ],
+            filesScanned: 1,
+            filesSkipped: 0,
+            totalLines: 1,
+            scanDurationMs: 1,
+            warnings: [],
+            errors: [],
+        };
+        const out = (0, terraform_minimal_services_1.applyMixedAppTerraformScanResult)(scanResult);
+        const ids = out.components.map((c) => c.id).sort();
+        expect(ids).toEqual(["api", "aws", "mod"]);
+        expect(out.components.some((c) => c.id === "rds")).toBe(false);
+        expect(out.components.some((c) => c.id === "subnet")).toBe(false);
+        expect(out.dataFlows.some((f) => f.sourceComponentId === "aws" && f.targetComponentId === "mod")).toBe(true);
+    });
+    it("applyMixedAppTerraformScanResult drops module-internal resources but keeps app nodes", () => {
+        const scanResult = {
+            components: [
+                (0, scan_result_builders_1.testAsset)("api", "API", { section_id: "reedy" }, "api"),
+                (0, scan_result_builders_1.testAsset)("rds", "RDS", {
+                    section_id: "terraform/modules/aurora",
+                    terraform_address: "module.aurora.aws_rds_cluster.this",
+                    resource_type: "aws_rds_cluster",
+                }),
+                (0, scan_result_builders_1.testAsset)("mod", "Module · aurora", {
+                    terraform_address: "module.aurora",
+                    section_id: "root",
+                }),
+                {
+                    id: "aws",
+                    name: "Amazon Web Services",
+                    type: "third_party",
+                    subType: "cloud_provider",
+                    confidence: 0.9,
+                    detectedFrom: [],
+                    sourceLocations: [],
+                    properties: { terraform_address: "provider.aws", section_id: "root" },
+                },
+                (0, scan_result_builders_1.testAsset)("az", "AZ", {
+                    section_id: "root",
+                    terraform_address: "data.aws_availability_zones.available",
+                    resource_type: "aws_availability_zones",
+                }),
+            ],
+            dataFlows: [
+                {
+                    id: "f1",
+                    sourceComponentId: "aws",
+                    targetComponentId: "rds",
+                    type: "database_query",
+                    confidence: 0.8,
+                },
+            ],
+            filesScanned: 1,
+            filesSkipped: 0,
+            totalLines: 1,
+            scanDurationMs: 1,
+            warnings: [],
+            errors: [],
+        };
+        const out = (0, terraform_minimal_services_1.applyMixedAppTerraformScanResult)(scanResult);
+        const ids = out.components.map((c) => c.id).sort();
+        expect(ids).toEqual(["api", "aws", "mod"]);
+        expect(out.dataFlows.some((f) => f.sourceComponentId === "aws" && f.targetComponentId === "mod")).toBe(true);
+        expect(out.dataFlows.some((f) => f.sourceComponentId === "aws" && f.targetComponentId === "rds")).toBe(false);
+    });
+    it("applyTerraformMinimalServiceScanResult keeps hub, ECS modules, and managed services", () => {
+        const scanResult = {
+            components: [
+                {
+                    id: "actor1",
+                    name: "User",
+                    type: "actor",
+                    subType: "customer",
+                    confidence: 0.5,
+                    detectedFrom: [],
+                    sourceLocations: [],
+                    properties: { section_id: "root" },
+                },
+                (0, scan_result_builders_1.testAsset)("main1", "aws_fullstack_terraform", {
+                    section_id: "root",
+                    isMainApplication: true,
+                    sourceContext: application_injection_1.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT,
+                }),
+                {
+                    id: "aws",
+                    name: "Amazon Web Services",
+                    type: "third_party",
+                    subType: "cloud_provider",
+                    confidence: 0.9,
+                    detectedFrom: [],
+                    sourceLocations: [],
+                    properties: { terraform_address: "provider.aws", section_id: "root" },
+                },
+                (0, scan_result_builders_1.testAsset)("ecs_f", "Module · ecs_frontend", {
+                    terraform_address: "module.ecs_frontend",
+                    section_id: "root",
+                }),
+                (0, scan_result_builders_1.testAsset)("s3", "Aws S3", {
+                    terraform_address: "aws_s3_bucket.x",
+                    managed_by_provider: "aws",
+                    managed_service_key: "s3",
+                    section_id: "root",
+                }),
+                (0, scan_result_builders_1.testAsset)("vpc", "Module · vpc", { terraform_address: "module.vpc", section_id: "root" }),
+            ],
+            dataFlows: [
+                {
+                    id: "f1",
+                    sourceComponentId: "ecs_f",
+                    targetComponentId: "s3",
+                    type: "file_transfer",
+                    confidence: 0.8,
+                },
+            ],
+            filesScanned: 1,
+            filesSkipped: 0,
+            totalLines: 1,
+            scanDurationMs: 1,
+            warnings: [],
+            errors: [],
+        };
+        const out = (0, terraform_minimal_services_1.applyTerraformMinimalServiceScanResult)(scanResult);
+        const ids = out.components.map((c) => c.id).sort();
+        expect(ids).toEqual(["actor1", "aws", "ecs_f", "main1", "s3"]);
+        const has = (a, b) => out.dataFlows.some((f) => f.sourceComponentId === a && f.targetComponentId === b);
+        expect(has("actor1", "main1")).toBe(true);
+        expect(has("main1", "ecs_f")).toBe(true);
+        expect(has("ecs_f", "aws")).toBe(true);
+        expect(has("main1", "aws")).toBe(false);
+        expect(has("aws", "s3")).toBe(true);
+    });
+    it("removes forced main→provider when ECS-mediated hub edges exist", () => {
+        const scanResult = {
+            components: [
+                {
+                    id: "actor1",
+                    name: "User",
+                    type: "actor",
+                    subType: "customer",
+                    confidence: 0.5,
+                    detectedFrom: [],
+                    sourceLocations: [],
+                    properties: { section_id: "root" },
+                },
+                (0, scan_result_builders_1.testAsset)("main1", "app", {
+                    section_id: "root",
+                    isMainApplication: true,
+                    sourceContext: application_injection_1.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT,
+                }),
+                {
+                    id: "aws",
+                    name: "Amazon Web Services",
+                    type: "third_party",
+                    subType: "cloud_provider",
+                    confidence: 0.9,
+                    detectedFrom: [],
+                    sourceLocations: [],
+                    properties: { terraform_address: "provider.aws", section_id: "root" },
+                },
+                (0, scan_result_builders_1.testAsset)("ecs_f", "ECS Frontend", {
+                    terraform_address: "module.ecs_frontend",
+                    section_id: "root",
+                }),
+                (0, scan_result_builders_1.testAsset)("s3", "Aws S3", {
+                    terraform_address: "aws_s3_bucket.x",
+                    managed_by_provider: "aws",
+                    managed_service_key: "s3",
+                    section_id: "root",
+                }),
+            ],
+            dataFlows: [
+                {
+                    id: "flow_forced",
+                    sourceComponentId: "main1",
+                    targetComponentId: "aws",
+                    type: "api_call",
+                    confidence: 0.72,
+                },
+                {
+                    id: "f1",
+                    sourceComponentId: "ecs_f",
+                    targetComponentId: "s3",
+                    type: "file_transfer",
+                    confidence: 0.8,
+                },
+            ],
+            filesScanned: 1,
+            filesSkipped: 0,
+            totalLines: 1,
+            scanDurationMs: 1,
+            warnings: [],
+            errors: [],
+        };
+        const out = (0, terraform_minimal_services_1.applyTerraformMinimalServiceScanResult)(scanResult);
+        const direct = out.dataFlows.filter((f) => f.sourceComponentId === "main1" && f.targetComponentId === "aws");
+        expect(direct).toHaveLength(0);
+        const has = (a, b) => out.dataFlows.some((f) => f.sourceComponentId === a && f.targetComponentId === b);
+        expect(has("main1", "ecs_f")).toBe(true);
+        expect(has("ecs_f", "aws")).toBe(true);
+    });
+    it("leaves scan unchanged when fewer than two ECS/managed service nodes", () => {
+        const scanResult = {
+            components: [
+                (0, scan_result_builders_1.testAsset)("ecs_f", "m", { terraform_address: "module.ecs_frontend" }),
+            ],
+            dataFlows: [],
+            filesScanned: 1,
+            filesSkipped: 0,
+            totalLines: 1,
+            scanDurationMs: 1,
+            warnings: [],
+            errors: [],
+        };
+        const out = (0, terraform_minimal_services_1.applyTerraformMinimalServiceScanResult)(scanResult);
+        expect(out.components).toHaveLength(1);
+    });
+});

package/dist/tests/unit/data-flow/application-hub.spec.d.ts

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

package/dist/tests/unit/data-flow/application-hub.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const application_hub_1 = require("../../../src/data-flow/application-hub");
+function asset(id, props, subType = "application") {
+    return {
+        id,
+        name: id,
+        type: "asset",
+        subType,
+        confidence: 0.9,
+        detectedFrom: [],
+        sourceLocations: [],
+        properties: props,
+    };
+}
+describe("findApplicationHubForFlows", () => {
+    it("prefers non-Terraform main over heroku_app for the same section", () => {
+        const expressMain = asset("express", { section_id: "root", isMainApplication: true }, "api");
+        const herokuApp = asset("heroku", {
+            section_id: "root",
+            isMainApplication: true,
+            terraform_address: "heroku_app.example",
+            resource_type: "heroku_app",
+        }, "application");
+        const components = [expressMain, herokuApp];
+        expect((0, application_hub_1.findApplicationHubForFlows)(components, "root")?.id).toBe("express");
+    });
+    it("for Terraform-only section, picks Express main in another section before heroku_app", () => {
+        const herokuApp = asset("heroku", {
+            section_id: "root",
+            isMainApplication: true,
+            terraform_address: "heroku_app.example",
+            resource_type: "heroku_app",
+        }, "application");
+        const expressMain = asset("app", { section_id: "app", isMainApplication: true }, "api");
+        const components = [herokuApp, expressMain];
+        expect((0, application_hub_1.findApplicationHubForFlows)(components, "root")?.id).toBe("app");
+    });
+    it("falls back to heroku_app when it is the only main", () => {
+        const herokuApp = asset("heroku", {
+            section_id: "root",
+            isMainApplication: true,
+            terraform_address: "heroku_app.example",
+            resource_type: "heroku_app",
+        }, "application");
+        expect((0, application_hub_1.findApplicationHubForFlows)([herokuApp], "root")?.id).toBe("heroku");
+    });
+});

package/dist/tests/unit/data-flow/cross-section-terraform-bridge.spec.d.ts

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

package/dist/tests/unit/data-flow/cross-section-terraform-bridge.spec.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ensure_actor_flow_1 = require("../../../src/data-flow/ensure-actor-flow");
+function makeComponent(partial) {
+    return {
+        name: partial.id,
+        type: "asset",
+        confidence: 1,
+        detectedFrom: [],
+        sourceLocations: [],
+        properties: {},
+        ...partial,
+    };
+}
+describe("ensureInjectedProjectMainToTerraformProviderHub — cross-section scope", () => {
+    it("does not bridge tooling packages to the global Terraform hub", () => {
+        const components = [
+            makeComponent({
+                id: "main_cli",
+                name: "twenty-cli",
+                subType: "application",
+                properties: {
+                    isMainApplication: true,
+                    sourceContext: "injected_project_placeholder",
+                    section_id: "packages/twenty-cli",
+                },
+            }),
+            makeComponent({
+                id: "k8s",
+                name: "Kubernetes",
+                type: "third_party",
+                properties: {
+                    terraform_address: "provider.kubernetes",
+                    section_id: "packages/twenty-docker/k8s/terraform",
+                },
+            }),
+        ];
+        const flows = [];
+        const result = (0, ensure_actor_flow_1.ensureInjectedProjectMainToTerraformProviderHub)(components, flows);
+        expect(result).toHaveLength(0);
+    });
+    it("does not bridge primary monorepo main to Terraform hub in another section", () => {
+        const components = [
+            makeComponent({
+                id: "main_server",
+                name: "api",
+                subType: "application",
+                properties: {
+                    isMainApplication: true,
+                    sourceContext: "injected_project_placeholder",
+                    section_id: "packages/api",
+                    is_primary_monorepo_package: true,
+                },
+            }),
+            makeComponent({
+                id: "k8s",
+                name: "Kubernetes",
+                type: "third_party",
+                properties: {
+                    terraform_address: "provider.kubernetes",
+                    section_id: "packages/twenty-docker/k8s/terraform",
+                },
+            }),
+        ];
+        const result = (0, ensure_actor_flow_1.ensureInjectedProjectMainToTerraformProviderHub)(components, []);
+        expect(result).toHaveLength(0);
+    });
+    it("bridges injected main to provider hub in the same section only", () => {
+        const components = [
+            makeComponent({
+                id: "main_iac",
+                name: "iac-root",
+                subType: "application",
+                properties: {
+                    isMainApplication: true,
+                    sourceContext: "injected_project_placeholder",
+                    section_id: "packages/acme/k8s/terraform",
+                },
+            }),
+            makeComponent({
+                id: "k8s",
+                name: "Kubernetes",
+                type: "third_party",
+                properties: {
+                    terraform_address: "provider.kubernetes",
+                    section_id: "packages/acme/k8s/terraform",
+                },
+            }),
+        ];
+        const result = (0, ensure_actor_flow_1.ensureInjectedProjectMainToTerraformProviderHub)(components, []);
+        expect(result).toHaveLength(1);
+        expect(result[0]?.sourceComponentId).toBe("main_iac");
+        expect(result[0]?.targetComponentId).toBe("k8s");
+    });
+});

package/dist/tests/unit/data-flow/dedupe.spec.d.ts

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

package/dist/tests/unit/data-flow/dedupe.spec.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dedupe_1 = require("../../../src/data-flow/dedupe");
+function makeFlow(overrides) {
+    return {
+        id: overrides.id,
+        sourceComponentId: overrides.sourceComponentId,
+        targetComponentId: overrides.targetComponentId,
+        type: overrides.type,
+        confidence: overrides.confidence ?? 0.5,
+        sourceLocation: overrides.sourceLocation,
+        sourceLocations: overrides.sourceLocations,
+        description: overrides.description,
+        method: overrides.method,
+        endpoint: overrides.endpoint,
+        dataCategories: overrides.dataCategories,
+        dataSubjectCategories: overrides.dataSubjectCategories,
+        processingPurpose: overrides.processingPurpose,
+        actions: overrides.actions,
+        transformation: overrides.transformation,
+        enrichmentConfidence: overrides.enrichmentConfidence,
+        enrichmentNotes: overrides.enrichmentNotes,
+    };
+}
+describe("data-flow/dedupe - DP-P0-CLI-302", () => {
+    it("merges duplicate flows by sourceComponentId, targetComponentId, and type", () => {
+        const flows = [
+            makeFlow({
+                id: "flow_1",
+                sourceComponentId: "app",
+                targetComponentId: "db",
+                type: "database_query",
+                confidence: 0.7,
+                sourceLocation: {
+                    filePath: "src/db.ts",
+                    startLine: 10,
+                    endLine: 12,
+                },
+                method: "GET",
+                endpoint: "/db-1",
+            }),
+            makeFlow({
+                id: "flow_2",
+                sourceComponentId: "app",
+                targetComponentId: "db",
+                type: "database_query",
+                confidence: 0.9,
+                sourceLocation: {
+                    filePath: "src/db.ts",
+                    startLine: 20,
+                    endLine: 22,
+                },
+                method: "GET",
+                endpoint: "/db-1",
+            }),
+        ];
+        const deduped = (0, dedupe_1.dedupeDataFlows)(flows);
+        expect(deduped).toHaveLength(1);
+        const [merged] = deduped;
+        // Base flow selection is deterministic: highest confidence wins (tie-broken by id).
+        expect(merged.id).toBe("flow_2");
+        expect(merged.sourceComponentId).toBe("app");
+        expect(merged.targetComponentId).toBe("db");
+        expect(merged.type).toBe("database_query");
+        expect(merged.confidence).toBe(0.9);
+        expect(merged.sourceLocations).toBeDefined();
+        expect(merged.sourceLocations.length).toBe(2);
+        const paths = merged.sourceLocations.map((l) => l.startLine).sort((a, b) => a - b);
+        expect(paths).toEqual([10, 20]);
+        // Primary sourceLocation should be one of the contributing locations.
+        expect(merged.sourceLocation).toBeDefined();
+        expect(merged.sourceLocations.some((loc) => loc.filePath === merged.sourceLocation.filePath &&
+            loc.startLine === merged.sourceLocation.startLine &&
+            loc.endLine === merged.sourceLocation.endLine)).toBe(true);
+        // Non-location metadata should come from the base flow.
+        expect(merged.method).toBe("GET");
+        expect(merged.endpoint).toBe("/db-1");
+    });
+    it("does not merge flows with different structural keys", () => {
+        const flows = [
+            makeFlow({
+                id: "flow_1",
+                sourceComponentId: "app",
+                targetComponentId: "db",
+                type: "database_query",
+                confidence: 0.8,
+            }),
+            makeFlow({
+                id: "flow_2",
+                sourceComponentId: "app",
+                targetComponentId: "db",
+                type: "api_call",
+                confidence: 0.9,
+            }),
+            makeFlow({
+                id: "flow_3",
+                sourceComponentId: "app",
+                targetComponentId: "cache",
+                type: "database_query",
+                confidence: 0.7,
+            }),
+        ];
+        const deduped = (0, dedupe_1.dedupeDataFlows)(flows);
+        expect(deduped).toHaveLength(3);
+    });
+    it("preserves existing sourceLocations when present on a single flow", () => {
+        const flows = [
+            makeFlow({
+                id: "flow_1",
+                sourceComponentId: "app",
+                targetComponentId: "db",
+                type: "database_query",
+                confidence: 0.8,
+                sourceLocations: [
+                    {
+                        filePath: "src/db.ts",
+                        startLine: 5,
+                        endLine: 7,
+                    },
+                ],
+            }),
+        ];
+        const deduped = (0, dedupe_1.dedupeDataFlows)(flows);
+        expect(deduped).toHaveLength(1);
+        const [merged] = deduped;
+        expect(merged.sourceLocations).toBeDefined();
+        expect(merged.sourceLocations.length).toBe(1);
+        expect(merged.sourceLocations[0]).toEqual({
+            filePath: "src/db.ts",
+            startLine: 5,
+            endLine: 7,
+        });
+    });
+});

package/dist/tests/unit/data-flow/detector.spec.d.ts

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