@dataparade/cli 0.0.1

package/dist/tests/unit/data-flow/drop-cross-section-flows.spec.d.ts

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

package/dist/tests/unit/data-flow/drop-cross-section-flows.spec.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const postprocess_1 = require("../../../src/data-flow/postprocess");
+const drop_cross_section_flows_1 = require("../../../src/data-flow/drop-cross-section-flows");
+const ensure_actor_flow_1 = require("../../../src/data-flow/ensure-actor-flow");
+describe("dropCrossSectionServiceFlows", () => {
+    it("removes flows between different concrete service sections", () => {
+        const components = [
+            {
+                id: "main_a",
+                name: "app-a",
+                type: "asset",
+                subType: "service",
+                confidence: 1,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {
+                    section_id: "packages/app-a",
+                    isMainApplication: true,
+                    sourceContext: "injected_project_placeholder",
+                },
+            },
+            {
+                id: "tp_k8s",
+                name: "Kubernetes",
+                type: "third_party",
+                confidence: 1,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {
+                    section_id: "packages/tf",
+                    terraform_address: "provider.kubernetes",
+                },
+            },
+        ];
+        const flows = [
+            {
+                id: "flow_1",
+                sourceComponentId: "main_a",
+                targetComponentId: "tp_k8s",
+                type: "api_call",
+                confidence: 0.72,
+            },
+        ];
+        const filtered = (0, drop_cross_section_flows_1.dropCrossSectionServiceFlows)(components, flows);
+        expect(filtered).toHaveLength(0);
+    });
+    it("keeps flows within the same section", () => {
+        const components = [
+            {
+                id: "main_tf",
+                name: "iac",
+                type: "asset",
+                subType: "application",
+                confidence: 1,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {
+                    section_id: "packages/tf",
+                    isMainApplication: true,
+                    sourceContext: "injected_project_placeholder",
+                },
+            },
+            {
+                id: "tp_k8s",
+                name: "Kubernetes",
+                type: "third_party",
+                confidence: 1,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {
+                    section_id: "packages/tf",
+                    terraform_address: "provider.kubernetes",
+                },
+            },
+        ];
+        const flows = [
+            {
+                id: "flow_1",
+                sourceComponentId: "main_tf",
+                targetComponentId: "tp_k8s",
+                type: "api_call",
+                confidence: 0.72,
+            },
+        ];
+        expect((0, drop_cross_section_flows_1.dropCrossSectionServiceFlows)(components, flows)).toHaveLength(1);
+    });
+});
+describe("postprocessDataFlows cross-section guard", () => {
+    it("does not emit monorepo package → remote Terraform hub edges", () => {
+        const components = [
+            {
+                id: "main_ox",
+                name: "twenty-oxlint-rules",
+                type: "asset",
+                subType: "service",
+                confidence: 1,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {
+                    section_id: "packages/twenty-oxlint-rules",
+                    isMainApplication: true,
+                    sourceContext: "injected_project_placeholder",
+                    is_primary_monorepo_package: true,
+                },
+            },
+            {
+                id: "tp_k8s",
+                name: "Kubernetes",
+                type: "third_party",
+                confidence: 1,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {
+                    section_id: "packages/twenty-docker/k8s/terraform",
+                    terraform_address: "provider.kubernetes",
+                },
+            },
+        ];
+        const bridged = (0, ensure_actor_flow_1.ensureInjectedProjectMainToTerraformProviderHub)(components, []);
+        expect(bridged).toHaveLength(0);
+        const out = (0, postprocess_1.postprocessDataFlows)(components, bridged);
+        const cross = out.filter((f) => {
+            const s = components.find((c) => c.id === f.sourceComponentId);
+            const t = components.find((c) => c.id === f.targetComponentId);
+            return (s &&
+                t &&
+                s.properties?.section_id !== t.properties?.section_id);
+        });
+        expect(cross).toHaveLength(0);
+    });
+});

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

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

package/dist/tests/unit/data-flow/ensure-actor-flow.spec.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ensure_actor_flow_1 = require("../../../src/data-flow/ensure-actor-flow");
+function makeComponent(overrides) {
+    return {
+        id: overrides.id,
+        name: overrides.name,
+        type: overrides.type,
+        subType: overrides.subType,
+        confidence: overrides.confidence ?? 0.9,
+        detectedFrom: overrides.detectedFrom ?? [],
+        sourceLocations: overrides.sourceLocations ?? [],
+        properties: overrides.properties ?? {},
+        description: overrides.description,
+        dataFlowIds: overrides.dataFlowIds,
+    };
+}
+function makeFlow(flow) {
+    return {
+        confidence: 0.8,
+        ...flow,
+    };
+}
+describe("data-flow/ensure-actor-flow - ensureActorToAppFlow", () => {
+    it("adds actor→app flow when app and actor exist but no flow connects them", () => {
+        const components = [
+            makeComponent({
+                id: "app_1",
+                name: "Application",
+                type: "asset",
+                subType: "api",
+                properties: { isMainApplication: true },
+            }),
+            makeComponent({
+                id: "actor_1",
+                name: "User",
+                type: "actor",
+                subType: "customer",
+            }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "flow_1",
+                sourceComponentId: "app_1",
+                targetComponentId: "db_1",
+                type: "database_query",
+            }),
+        ];
+        const result = (0, ensure_actor_flow_1.ensureActorToAppFlow)(components, flows);
+        const actorToApp = result.filter((f) => f.sourceComponentId === "actor_1" && f.targetComponentId === "app_1");
+        expect(actorToApp).toHaveLength(1);
+        expect(actorToApp[0].type).toBe("api_call");
+        expect(actorToApp[0].confidence).toBe(0.5);
+        expect(result).toHaveLength(2);
+    });
+    it("does not add flow when actor→app already exists", () => {
+        const components = [
+            makeComponent({
+                id: "app_1",
+                name: "Application",
+                type: "asset",
+                subType: "api",
+                properties: { isMainApplication: true },
+            }),
+            makeComponent({
+                id: "actor_1",
+                name: "User",
+                type: "actor",
+            }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "flow_1",
+                sourceComponentId: "actor_1",
+                targetComponentId: "app_1",
+                type: "api_call",
+            }),
+        ];
+        const result = (0, ensure_actor_flow_1.ensureActorToAppFlow)(components, flows);
+        expect(result).toHaveLength(1);
+    });
+    it("does not add flow when app→actor already exists", () => {
+        const components = [
+            makeComponent({
+                id: "app_1",
+                name: "Application",
+                type: "asset",
+                subType: "api",
+                properties: { isMainApplication: true },
+            }),
+            makeComponent({
+                id: "actor_1",
+                name: "User",
+                type: "actor",
+            }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "flow_1",
+                sourceComponentId: "app_1",
+                targetComponentId: "actor_1",
+                type: "api_call",
+            }),
+        ];
+        const result = (0, ensure_actor_flow_1.ensureActorToAppFlow)(components, flows);
+        expect(result).toHaveLength(1);
+    });
+    it("returns flows unchanged when no app exists", () => {
+        const components = [
+            makeComponent({
+                id: "actor_1",
+                name: "User",
+                type: "actor",
+            }),
+        ];
+        const flows = [];
+        const result = (0, ensure_actor_flow_1.ensureActorToAppFlow)(components, flows);
+        expect(result).toEqual([]);
+    });
+    it("returns flows unchanged when no actors exist", () => {
+        const components = [
+            makeComponent({
+                id: "app_1",
+                name: "Application",
+                type: "asset",
+                subType: "api",
+                properties: { isMainApplication: true },
+            }),
+        ];
+        const flows = [];
+        const result = (0, ensure_actor_flow_1.ensureActorToAppFlow)(components, flows);
+        expect(result).toEqual([]);
+    });
+    it("uses first actor in section when multiple actors exist and none have app flow", () => {
+        const components = [
+            makeComponent({
+                id: "app_1",
+                name: "Application",
+                type: "asset",
+                subType: "api",
+                properties: { isMainApplication: true },
+            }),
+            makeComponent({
+                id: "actor_1",
+                name: "Customer",
+                type: "actor",
+            }),
+            makeComponent({
+                id: "actor_2",
+                name: "Admin",
+                type: "actor",
+            }),
+        ];
+        const flows = [];
+        const result = (0, ensure_actor_flow_1.ensureActorToAppFlow)(components, flows);
+        const actorToApp = result.filter((f) => f.targetComponentId === "app_1");
+        expect(actorToApp).toHaveLength(1);
+        expect(actorToApp[0].sourceComponentId).toBe("actor_1");
+    });
+    it("adds one actor→app flow per section without an actor-app connection", () => {
+        const components = [
+            makeComponent({
+                id: "app_a",
+                name: "Section A",
+                type: "asset",
+                subType: "application",
+                properties: { isMainApplication: true, section_id: "a" },
+            }),
+            makeComponent({
+                id: "app_b",
+                name: "Section B",
+                type: "asset",
+                subType: "application",
+                properties: { isMainApplication: true, section_id: "b" },
+            }),
+            makeComponent({
+                id: "actor_a",
+                name: "User A",
+                type: "actor",
+                properties: { section_id: "a" },
+            }),
+            makeComponent({
+                id: "actor_b",
+                name: "User B",
+                type: "actor",
+                properties: { section_id: "b" },
+            }),
+        ];
+        const result = (0, ensure_actor_flow_1.ensureActorToAppFlow)(components, []);
+        const links = result.filter((f) => f.type === "api_call");
+        expect(links).toHaveLength(2);
+        expect(links.some((f) => f.sourceComponentId === "actor_a" && f.targetComponentId === "app_a")).toBe(true);
+        expect(links.some((f) => f.sourceComponentId === "actor_b" && f.targetComponentId === "app_b")).toBe(true);
+    });
+    it("ensureInjectedProjectMainToTerraformProviderHub adds main → provider.aws", () => {
+        const components = [
+            makeComponent({
+                id: "main_1",
+                name: "my-iac-root",
+                type: "asset",
+                subType: "application",
+                properties: {
+                    isMainApplication: true,
+                    sourceContext: "injected_project_placeholder",
+                    section_id: "root",
+                },
+            }),
+            makeComponent({
+                id: "tp_aws",
+                name: "Amazon Web Services",
+                type: "third_party",
+                properties: {
+                    terraform_address: "provider.aws",
+                    section_id: "root",
+                },
+            }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "flow_1",
+                sourceComponentId: "actor_1",
+                targetComponentId: "main_1",
+                type: "api_call",
+            }),
+        ];
+        const result = (0, ensure_actor_flow_1.ensureInjectedProjectMainToTerraformProviderHub)(components, flows);
+        const mainToAws = result.find((f) => f.sourceComponentId === "main_1" &&
+            f.targetComponentId === "tp_aws" &&
+            f.type === "api_call");
+        expect(mainToAws).toBeDefined();
+        expect(mainToAws?.confidence).toBe(0.72);
+    });
+});

package/dist/tests/unit/data-flow/ensure-manifest-declared-flows.spec.d.ts

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

package/dist/tests/unit/data-flow/ensure-manifest-declared-flows.spec.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const application_injection_1 = require("../../../src/classifier/application-injection");
+const ensure_manifest_declared_flows_1 = require("../../../src/data-flow/ensure-manifest-declared-flows");
+function makeComponent(overrides) {
+    return {
+        subType: overrides.subType,
+        confidence: overrides.confidence ?? 0.9,
+        detectedFrom: overrides.detectedFrom ?? [],
+        sourceLocations: overrides.sourceLocations ?? [],
+        properties: overrides.properties ?? {},
+        ...overrides,
+    };
+}
+describe("ensure-manifest-declared-flows", () => {
+    it("isManifestOnlyThirdPartyComponent matches dependency_manifest third parties", () => {
+        const tp = makeComponent({
+            id: "tp_1",
+            name: "Anthropic",
+            type: "third_party",
+            subType: "ai_provider",
+            properties: {
+                sourceContext: "dependency_manifest",
+                section_id: "packages/twenty-companion",
+            },
+            detectedFrom: [
+                {
+                    pattern: "external_api_call",
+                    sourceLocation: {
+                        filePath: "packages/twenty-companion/package.json",
+                        startLine: 1,
+                        endLine: 1,
+                    },
+                },
+            ],
+        });
+        expect((0, ensure_manifest_declared_flows_1.isManifestOnlyThirdPartyComponent)(tp)).toBe(true);
+    });
+    it("adds hub → manifest third_party when package section has a main app", () => {
+        const components = [
+            makeComponent({
+                id: "hub_1",
+                name: "twenty-companion",
+                type: "asset",
+                subType: "service",
+                properties: {
+                    isMainApplication: true,
+                    section_id: "packages/twenty-companion",
+                    sourceContext: application_injection_1.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT,
+                },
+            }),
+            makeComponent({
+                id: "tp_1",
+                name: "Anthropic",
+                type: "third_party",
+                subType: "ai_provider",
+                properties: {
+                    sourceContext: "dependency_manifest",
+                    section_id: "packages/twenty-companion",
+                    serviceName: "anthropic",
+                },
+                detectedFrom: [
+                    {
+                        pattern: "external_api_call",
+                        sourceLocation: {
+                            filePath: "packages/twenty-companion/package.json",
+                            startLine: 1,
+                            endLine: 1,
+                        },
+                    },
+                ],
+            }),
+        ];
+        const result = (0, ensure_manifest_declared_flows_1.ensureManifestDeclaredThirdPartyFlows)(components, []);
+        expect(result).toHaveLength(1);
+        expect(result[0].sourceComponentId).toBe("hub_1");
+        expect(result[0].targetComponentId).toBe("tp_1");
+        expect(result[0].type).toBe("api_call");
+        expect(result[0].enrichmentNotes).toBe("declared_dependency");
+    });
+    it("does not duplicate an existing hub → third_party flow", () => {
+        const components = [
+            makeComponent({
+                id: "hub_1",
+                name: "twenty-companion",
+                type: "asset",
+                subType: "service",
+                properties: {
+                    isMainApplication: true,
+                    section_id: "packages/twenty-companion",
+                },
+            }),
+            makeComponent({
+                id: "tp_1",
+                name: "Anthropic",
+                type: "third_party",
+                properties: {
+                    sourceContext: "dependency_manifest",
+                    section_id: "packages/twenty-companion",
+                },
+                detectedFrom: [
+                    {
+                        pattern: "external_api_call",
+                        sourceLocation: {
+                            filePath: "packages/twenty-companion/package.json",
+                            startLine: 1,
+                            endLine: 1,
+                        },
+                    },
+                ],
+            }),
+        ];
+        const flows = [
+            {
+                id: "flow_1",
+                sourceComponentId: "hub_1",
+                targetComponentId: "tp_1",
+                type: "api_call",
+                confidence: 0.9,
+            },
+        ];
+        const result = (0, ensure_manifest_declared_flows_1.ensureManifestDeclaredThirdPartyFlows)(components, flows);
+        expect(result).toHaveLength(1);
+    });
+});

package/dist/tests/unit/data-flow/ensure-section-api-flows.spec.d.ts

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

package/dist/tests/unit/data-flow/ensure-section-api-flows.spec.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ensure_section_api_flows_1 = require("../../../src/data-flow/ensure-section-api-flows");
+function comp(partial) {
+    return {
+        subType: partial.subType,
+        confidence: 0.9,
+        detectedFrom: [],
+        sourceLocations: [],
+        properties: partial.properties ?? {},
+        ...partial,
+    };
+}
+describe("ensure-section-api-flows", () => {
+    it("links main app to orphan API asset in the same section", () => {
+        const components = [
+            comp({
+                id: "main_1",
+                name: "twenty-apps",
+                type: "asset",
+                subType: "service",
+                properties: {
+                    isMainApplication: true,
+                    section_id: "packages/twenty-apps",
+                },
+            }),
+            comp({
+                id: "api_1",
+                name: "twenty-apps API",
+                type: "asset",
+                subType: "api",
+                properties: { section_id: "packages/twenty-apps" },
+            }),
+        ];
+        const flows = (0, ensure_section_api_flows_1.ensureMainToUnlinkedSectionApiFlows)(components, []);
+        expect(flows).toHaveLength(1);
+        expect(flows[0].sourceComponentId).toBe("main_1");
+        expect(flows[0].targetComponentId).toBe("api_1");
+    });
+});

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

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

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const postprocess_1 = require("../../../src/data-flow/postprocess");
+function makeComponent(overrides) {
+    return {
+        id: overrides.id,
+        name: overrides.name,
+        type: overrides.type,
+        subType: overrides.subType,
+        confidence: overrides.confidence ?? 1,
+        detectedFrom: overrides.detectedFrom ?? [],
+        sourceLocations: overrides.sourceLocations ?? [],
+        properties: overrides.properties ?? {},
+    };
+}
+function makeFlow(overrides) {
+    return {
+        id: overrides.id,
+        sourceComponentId: overrides.sourceComponentId,
+        targetComponentId: overrides.targetComponentId,
+        type: overrides.type,
+        confidence: overrides.confidence ?? 1,
+    };
+}
+describe("data-flow/postprocess", () => {
+    it("removes duplicate section-api outbound flows when main app has same target", () => {
+        const components = [
+            makeComponent({
+                id: "frontend-main",
+                name: "frontend",
+                type: "asset",
+                subType: "api",
+                properties: {
+                    section_id: "frontend",
+                    isMainApplication: true,
+                },
+            }),
+            makeComponent({
+                id: "frontend-api",
+                name: "API",
+                type: "asset",
+                subType: "api",
+                properties: {
+                    section_id: "frontend",
+                    isSectionApiNode: true,
+                },
+            }),
+            makeComponent({
+                id: "auth0",
+                name: "Auth0",
+                type: "third_party",
+                subType: "identity_provider",
+                properties: {
+                    section_id: "frontend",
+                    serviceName: "auth0",
+                },
+            }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "flow_1",
+                sourceComponentId: "frontend-main",
+                targetComponentId: "auth0",
+                type: "api_call",
+            }),
+            makeFlow({
+                id: "flow_2",
+                sourceComponentId: "frontend-api",
+                targetComponentId: "auth0",
+                type: "api_call",
+            }),
+        ];
+        const out = (0, postprocess_1.postprocessDataFlows)(components, flows);
+        const auth0Calls = out.filter((f) => f.targetComponentId === "auth0" && f.type === "api_call");
+        expect(auth0Calls).toHaveLength(1);
+        expect(auth0Calls[0].sourceComponentId).toBe("frontend-main");
+    });
+});

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

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