@dataparade/cli 0.0.1

package/dist/tests/unit/cli/config-command.spec.js

@@ -0,0 +1,51 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cli_1 = require("../../../src/cli");
+describe("cli config command", () => {
+    it("prints effective configuration as JSON", async () => {
+        const consoleSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        await (0, cli_1.run)(["node", "cli", "config"]);
+        expect(consoleSpy).toHaveBeenCalled();
+        consoleSpy.mockRestore();
+    });
+    it("redacts SCAN_BYOK_API_KEY in printed JSON", async () => {
+        const previous = process.env.SCAN_BYOK_API_KEY;
+        process.env.SCAN_BYOK_API_KEY = "sk-must-not-appear-in-output";
+        const consoleSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        try {
+            await (0, cli_1.run)(["node", "cli", "config"]);
+            const output = consoleSpy.mock.calls.map((c) => String(c[0])).join("\n");
+            expect(output).not.toContain("sk-must-not-appear-in-output");
+            expect(output).toContain("<redacted>");
+        }
+        finally {
+            consoleSpy.mockRestore();
+            if (previous === undefined) {
+                delete process.env.SCAN_BYOK_API_KEY;
+            }
+            else {
+                process.env.SCAN_BYOK_API_KEY = previous;
+            }
+        }
+    });
+    it("loads dataparade.config.json from the given project path", async () => {
+        const tempRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-cli-config-path-"));
+        const consoleSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+        try {
+            fs_1.default.writeFileSync(path_1.default.join(tempRoot, "dataparade.config.json"), JSON.stringify({ projectName: "config-path-fixture" }), "utf8");
+            await (0, cli_1.run)(["node", "cli", "config", tempRoot]);
+            const output = consoleSpy.mock.calls.map((c) => String(c[0])).join("\n");
+            expect(output).toContain("config-path-fixture");
+        }
+        finally {
+            consoleSpy.mockRestore();
+            fs_1.default.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/unit/cli/scan-command-ai-flags.spec.js

@@ -0,0 +1,149 @@
+"use strict";
+jest.mock("../../../src/config/resolve", () => ({
+    resolveScanConfiguration: jest.fn(() => ({ overrides: {}, warnings: [] })),
+}));
+jest.mock("../../../src/core/pipeline/orchestrator", () => ({
+    createDefaultScanConfiguration: jest.fn((overrides = {}) => ({
+        enableAPIDetection: true,
+        enableDatabaseDetection: true,
+        enableDataFlowDetection: true,
+        minimumConfidence: 0.5,
+        ...overrides,
+        enableAiInference: overrides.enableAiInference ?? false,
+    })),
+    scan: jest.fn(async () => ({
+        scanResult: {
+            components: [],
+            dataFlows: [],
+            filesScanned: 0,
+            filesSkipped: 0,
+            totalLines: 0,
+            scanDurationMs: 0,
+            warnings: [],
+            errors: [],
+            languageStats: undefined,
+        },
+    })),
+}));
+jest.mock("../../../src/core/pipeline/graph-mapping", () => ({
+    buildDiagramGraphFromScanResult: jest.fn(() => ({
+        nodes: [],
+        edges: [],
+        viewport: { x: 0, y: 0, zoom: 1 },
+    })),
+}));
+jest.mock("../../../src/output/json", () => ({
+    writeDataflowJson: jest.fn(() => { }),
+}));
+describe("cli scan command ai flags", () => {
+    let consoleLogSpy;
+    beforeEach(() => {
+        consoleLogSpy = jest.spyOn(console, "log").mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+    });
+    it("normalizes --ai-inference-scope third-party-only to third_party_only", async () => {
+        const { run } = require("../../../src/cli");
+        const configResolve = require("../../../src/config/resolve");
+        await run([
+            "node",
+            "cli",
+            "scan",
+            ".",
+            "--ai-inference-scope",
+            "third-party-only",
+        ]);
+        const firstCall = configResolve.resolveScanConfiguration.mock.calls[0];
+        expect(firstCall[0].flags.aiInferenceScope).toBe("third_party_only");
+        expect(firstCall[0].flags.aiVerbose).toBeUndefined();
+    });
+    it("passes --ai-verbose through to config resolution", async () => {
+        const { run } = require("../../../src/cli");
+        const configResolve = require("../../../src/config/resolve");
+        await run(["node", "cli", "scan", ".", "--ai-verbose"]);
+        const lastCall = configResolve.resolveScanConfiguration.mock.calls.at(-1);
+        expect(lastCall[0].flags.aiVerbose).toBe(true);
+    });
+    it("prints all proposal property changes one per line without truncation", async () => {
+        const { run } = require("../../../src/cli");
+        const orchestrator = require("../../../src/core/pipeline/orchestrator");
+        orchestrator.scan.mockResolvedValueOnce({
+            scanResult: {
+                components: [],
+                dataFlows: [],
+                filesScanned: 0,
+                filesSkipped: 0,
+                totalLines: 0,
+                scanDurationMs: 0,
+                warnings: [],
+                errors: [],
+                languageStats: undefined,
+                aiInferenceSummary: {
+                    ran: true,
+                    candidatesConsidered: 1,
+                    proposalsGenerated: 1,
+                    proposalsApplied: 1,
+                    proposalsRejected: 0,
+                    proposalsGeneratedHeuristic: 0,
+                    proposalsAppliedHeuristic: 0,
+                    proposalsGeneratedProvider: 1,
+                    proposalsAppliedProvider: 1,
+                    providerCalls: 1,
+                    inputTokens: 10,
+                    outputTokens: 10,
+                    totalTokens: 20,
+                    estimatedCostUsd: 0.001,
+                    aiProvider: "openai",
+                    aiModel: "gpt-4o-mini",
+                },
+                aiInferenceProposalDetails: [
+                    {
+                        id: "provider_1",
+                        source: "provider",
+                        status: "applied",
+                        kind: "component_patch",
+                        candidateType: "node_property",
+                        agent: "propertyAgent",
+                        provider: "openai",
+                        model: "gpt-4o-mini",
+                        confidence: 0.85,
+                        confidenceBand: "high",
+                        targetComponentId: "cmp_1",
+                        evidence: [
+                            {
+                                filePath: "file.ts",
+                                startLine: 1,
+                                endLine: 1,
+                                reason: "reason",
+                            },
+                        ],
+                        propertyChanges: [
+                            { key: "inference_status", from: undefined, to: "needs_review" },
+                            { key: "access_controls_for_delivery", from: null, to: null },
+                            { key: "api_versioning_strategy", from: null, to: "none" },
+                            { key: "analytics_sdks", from: [], to: null },
+                            { key: "cloud_services_used", from: [], to: ["aws"] },
+                            { key: "api_endpoint", from: null, to: "/api/ai-completion" },
+                            { key: "api_type", from: "rest", to: "rest" },
+                            { key: "api_key_management", from: null, to: null },
+                        ],
+                    },
+                ],
+            },
+        });
+        await run(["node", "cli", "scan", ".", "--ai-verbose"]);
+        const output = consoleLogSpy.mock.calls
+            .map((call) => call[0])
+            .filter((line) => typeof line === "string");
+        const changesLines = output.filter((line) => line.includes("[scan]       changes="));
+        const allChangesText = changesLines.join("\n");
+        expect(changesLines.length).toBe(8);
+        expect(allChangesText).toContain('cloud_services_used: [] -> ["aws"]');
+        expect(allChangesText).toContain('api_endpoint: null -> "/api/ai-completion"');
+        expect(allChangesText).toContain('inference_status: undefined -> "needs_review"');
+        expect(allChangesText).toContain("access_controls_for_delivery: null -> null");
+        expect(allChangesText).toContain('api_versioning_strategy: null -> "none"');
+        expect(output.some((line) => line.includes("changes=... +"))).toBe(false);
+    });
+});

package/dist/tests/unit/cli/scan-command-diagram-graph.spec.d.ts

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

package/dist/tests/unit/cli/scan-command-diagram-graph.spec.js

@@ -0,0 +1,26 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cli_1 = require("../../../src/cli");
+const dataflow_wrapper_schema_1 = require("../../../src/core/schema/dataflow-wrapper.schema");
+describe("cli scan command - DP-P0-CLI-402 integration", () => {
+    it("writes a valid dataflow.json wrapper to the output path", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const outputPath = path_1.default.join(os_1.default.tmpdir(), `dataparade-scan-${Date.now()}.json`);
+        await (0, cli_1.run)(["node", "cli", "scan", fixturesRoot, "--output", outputPath]);
+        const contents = fs_1.default.readFileSync(outputPath, "utf8");
+        const parsed = JSON.parse(contents);
+        const validation = (0, dataflow_wrapper_schema_1.validateDataflowJson)(parsed);
+        expect(validation.ok).toBe(true);
+        if (!validation.ok)
+            return;
+        expect(validation.value.graph.nodes.length).toBeGreaterThan(0);
+        expect(validation.value.graph.edges.length).toBeGreaterThan(0);
+        fs_1.default.unlinkSync(outputPath);
+    }, 15000);
+});

package/dist/tests/unit/cli/scan-command-e2e-monorepo-app-plus-terraform.spec.d.ts

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

package/dist/tests/unit/cli/scan-command-e2e-monorepo-app-plus-terraform.spec.js

@@ -0,0 +1,107 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cli_1 = require("../../../src/cli");
+const dataflow_wrapper_schema_1 = require("../../../src/core/schema/dataflow-wrapper.schema");
+const application_injection_1 = require("../../../src/classifier/application-injection");
+function nodeSourcePaths(node) {
+    const locs = node.data?.sourceLocations;
+    if (!Array.isArray(locs))
+        return [];
+    return locs
+        .map((loc) => typeof loc === "object" && loc && "filePath" in loc
+        ? String(loc.filePath ?? "")
+        : "")
+        .filter(Boolean);
+}
+describe("cli scan command - monorepo app plus terraform", () => {
+    it("keeps app API hub, reduces TF to provider and module shells, and lays out app left of TF hub", async () => {
+        const prevAiInference = process.env.DATAPARADE_AI_INFERENCE;
+        process.env.DATAPARADE_AI_INFERENCE = "false";
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "monorepo-app-plus-terraform");
+        const outputPath = path_1.default.join(os_1.default.tmpdir(), `dataparade-scan-e2e-monorepo-app-plus-terraform-${Date.now()}.json`);
+        try {
+            await (0, cli_1.run)(["node", "cli", "scan", fixturesRoot, "--output", outputPath]);
+            const contents = fs_1.default.readFileSync(outputPath, "utf8");
+            const parsed = JSON.parse(contents);
+            const validation = (0, dataflow_wrapper_schema_1.validateDataflowJson)(parsed);
+            expect(validation.ok).toBe(true);
+            if (!validation.ok)
+                return;
+            const { graph } = validation.value;
+            const nodes = graph.nodes;
+            const sectionApiNodes = nodes.filter((n) => n.data?.isSectionApiNode === true);
+            expect(sectionApiNodes.length).toBeGreaterThan(0);
+            expect(sectionApiNodes.some((n) => n.data?.section_id === "packages/app")).toBe(true);
+            const placeholderUnderTfModules = nodes.filter((n) => {
+                const inModuleTree = nodeSourcePaths(n).some((p) => p.replace(/\\/g, "/").includes("terraform/modules/"));
+                const sid = n.data?.section_id;
+                const inModuleSection = typeof sid === "string" && sid.includes("terraform/modules");
+                if (!inModuleTree && !inModuleSection)
+                    return false;
+                const sourceContext = n.data?.sourceContext;
+                const isMain = n.data?.isMainApplication === true ||
+                    n.data?.isMainApplication === "true";
+                const isActor = n.data?.componentType === "actor";
+                return (sourceContext === application_injection_1.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT &&
+                    (isMain || isActor));
+            });
+            expect(placeholderUnderTfModules).toHaveLength(0);
+            const tfHubNodes = nodes.filter((n) => {
+                const addr = n.data?.terraform_address;
+                return (typeof addr === "string" &&
+                    (addr.startsWith("provider.") || addr.startsWith("module.")) &&
+                    n.data?.section_id !== "packages/app");
+            });
+            expect(tfHubNodes.length).toBeGreaterThan(0);
+            const providerNodes = tfHubNodes.filter((n) => {
+                const addr = n.data?.terraform_address;
+                return (typeof addr === "string" &&
+                    addr.startsWith("provider.") &&
+                    n.data?.componentType === "third_party");
+            });
+            expect(providerNodes.length).toBeGreaterThan(0);
+            const moduleShellNodes = tfHubNodes.filter((n) => {
+                const addr = n.data?.terraform_address;
+                if (typeof addr !== "string" || !addr.startsWith("module.")) {
+                    return false;
+                }
+                const rt = n.data?.resource_type;
+                return (rt === undefined ||
+                    rt === null ||
+                    rt === "" ||
+                    rt === "unknown");
+            });
+            expect(moduleShellNodes.length).toBeGreaterThan(0);
+            const innerTfResourceNodes = nodes.filter((n) => {
+                const rt = n.data?.resource_type;
+                if (typeof rt !== "string" || !rt.trim() || rt === "unknown") {
+                    return false;
+                }
+                return (rt.startsWith("aws_db_") ||
+                    rt.startsWith("aws_subnet") ||
+                    rt === "aws_subnet");
+            });
+            expect(innerTfResourceNodes).toHaveLength(0);
+            const appNodes = nodes.filter((n) => n.data?.section_id === "packages/app");
+            expect(appNodes.length).toBeGreaterThan(0);
+            const maxAppX = Math.max(...appNodes.map((n) => n.position?.x ?? 0));
+            const minTfHubX = Math.min(...providerNodes.map((n) => n.position?.x ?? 0));
+            expect(maxAppX).toBeLessThan(minTfHubX);
+            fs_1.default.unlinkSync(outputPath);
+        }
+        finally {
+            if (prevAiInference === undefined) {
+                delete process.env.DATAPARADE_AI_INFERENCE;
+            }
+            else {
+                process.env.DATAPARADE_AI_INFERENCE = prevAiInference;
+            }
+        }
+    }, 20000);
+});

package/dist/tests/unit/cli/scan-command-e2e-monorepo-front-back-sections.spec.d.ts

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

package/dist/tests/unit/cli/scan-command-e2e-monorepo-front-back-sections.spec.js

@@ -0,0 +1,74 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cli_1 = require("../../../src/cli");
+const dataflow_wrapper_schema_1 = require("../../../src/core/schema/dataflow-wrapper.schema");
+describe("cli scan command - monorepo sections", () => {
+    it("tags nodes with section_id and avoids cross-section edges", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "monorepo-front-back-sections");
+        const outputPath = path_1.default.join(os_1.default.tmpdir(), `dataparade-scan-e2e-monorepo-front-back-sections-${Date.now()}.json`);
+        await (0, cli_1.run)(["node", "cli", "scan", fixturesRoot, "--output", outputPath]);
+        const contents = fs_1.default.readFileSync(outputPath, "utf8");
+        const parsed = JSON.parse(contents);
+        const validation = (0, dataflow_wrapper_schema_1.validateDataflowJson)(parsed);
+        expect(validation.ok).toBe(true);
+        if (!validation.ok)
+            return;
+        const { graph } = validation.value;
+        const sectionIds = new Set(graph.nodes
+            .map((n) => n?.data?.section_id)
+            .filter((v) => typeof v === "string" && v.trim().length > 0));
+        expect(sectionIds.size).toBeGreaterThanOrEqual(2);
+        // section_role is a user-facing hint: root vs service.
+        for (const node of graph.nodes) {
+            const sectionId = node?.data?.section_id;
+            if (typeof sectionId !== "string" || !sectionId.trim())
+                continue;
+            const sectionRole = node?.data?.section_role;
+            expect(sectionRole).toBeDefined();
+            if (sectionId === "root") {
+                expect(sectionRole).toBe("root");
+            }
+            else {
+                expect(sectionRole).toBe("service");
+            }
+        }
+        const hasGlobalNode = graph.nodes.some((n) => n?.data?.section_id === "global");
+        expect(hasGlobalNode).toBe(false);
+        const nodeSectionId = new Map(graph.nodes.map((n) => [n.id, n?.data?.section_id]));
+        const isConcreteServiceSection = (sid) => {
+            if (typeof sid !== "string")
+                return false;
+            if (!sid.trim())
+                return false;
+            if (sid === "root")
+                return false;
+            if (sid === "<unsectioned>")
+                return false;
+            if (sid === "global")
+                return false;
+            return true;
+        };
+        const hasCrossSectionEdge = graph.edges.some((e) => {
+            const src = nodeSectionId.get(e.source);
+            const tgt = nodeSectionId.get(e.target);
+            const srcConcrete = isConcreteServiceSection(src);
+            const tgtConcrete = isConcreteServiceSection(tgt);
+            return srcConcrete && tgtConcrete && src !== tgt;
+        });
+        expect(hasCrossSectionEdge).toBe(false);
+        const hasExpressRouteEvidence = graph.nodes.some((n) => Array.isArray(n?.data?.detectedFrom)
+            ? n.data.detectedFrom.some((ref) => ref?.pattern === "express_route")
+            : false);
+        const sectionApiNodes = graph.nodes.filter((n) => n?.data?.isSectionApiNode === true);
+        if (hasExpressRouteEvidence) {
+            expect(sectionApiNodes.length).toBeGreaterThan(0);
+        }
+        fs_1.default.unlinkSync(outputPath);
+    }, 20000);
+});

package/dist/tests/unit/cli/scan-command-e2e-python-basic.spec.d.ts

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

package/dist/tests/unit/cli/scan-command-e2e-python-basic.spec.js

@@ -0,0 +1,43 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cli_1 = require("../../../src/cli");
+const dataflow_wrapper_schema_1 = require("../../../src/core/schema/dataflow-wrapper.schema");
+describe("cli scan command - DP-P0-CLI-705 e2e Python basic", () => {
+    it("scans python-basic fixture and produces valid dataflow.json with route, database, third-party, and flows", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "python-basic");
+        const outputPath = path_1.default.join(os_1.default.tmpdir(), `dataparade-scan-e2e-python-basic-${Date.now()}.json`);
+        await (0, cli_1.run)(["node", "cli", "scan", fixturesRoot, "--output", outputPath]);
+        const contents = fs_1.default.readFileSync(outputPath, "utf8");
+        const parsed = JSON.parse(contents);
+        const validation = (0, dataflow_wrapper_schema_1.validateDataflowJson)(parsed);
+        expect(validation.ok).toBe(true);
+        if (!validation.ok)
+            return;
+        const { graph } = validation.value;
+        expect(Array.isArray(graph.nodes)).toBe(true);
+        expect(Array.isArray(graph.edges)).toBe(true);
+        expect(graph.nodes.length).toBeGreaterThan(1);
+        expect(graph.edges.length).toBeGreaterThan(0);
+        const dbNode = graph.nodes.find((node) => {
+            const data = node.data;
+            return (data &&
+                data.componentType === "asset" &&
+                data.componentSubType === "database");
+        });
+        const thirdPartyNode = graph.nodes.find((node) => {
+            const data = node.data;
+            return (data &&
+                data.componentType === "third_party" &&
+                data.serviceName === "openai");
+        });
+        expect(dbNode).toBeDefined();
+        expect(thirdPartyNode).toBeDefined();
+        fs_1.default.unlinkSync(outputPath);
+    }, 15000);
+});

package/dist/tests/unit/cli/scan-command-e2e-terraform-basic.spec.d.ts

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

package/dist/tests/unit/cli/scan-command-e2e-terraform-basic.spec.js

@@ -0,0 +1,62 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cli_1 = require("../../../src/cli");
+const dataflow_wrapper_schema_1 = require("../../../src/core/schema/dataflow-wrapper.schema");
+describe("cli scan command - terraform-basic fixture", () => {
+    it("scans terraform-basic fixture and produces valid dataflow.json with nodes and edges", async () => {
+        const prevAiInference = process.env.DATAPARADE_AI_INFERENCE;
+        process.env.DATAPARADE_AI_INFERENCE = "false";
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "terraform-basic");
+        const outputPath = path_1.default.join(os_1.default.tmpdir(), `dataparade-scan-e2e-terraform-basic-${Date.now()}.json`);
+        try {
+            await (0, cli_1.run)(["node", "cli", "scan", fixturesRoot, "--output", outputPath]);
+            const contents = fs_1.default.readFileSync(outputPath, "utf8");
+            const parsed = JSON.parse(contents);
+            const validation = (0, dataflow_wrapper_schema_1.validateDataflowJson)(parsed);
+            expect(validation.ok).toBe(true);
+            if (!validation.ok)
+                return;
+            const { graph } = validation.value;
+            expect(Array.isArray(graph.nodes)).toBe(true);
+            expect(Array.isArray(graph.edges)).toBe(true);
+            expect(graph.nodes.length).toBeGreaterThan(1);
+            expect(graph.edges.length).toBeGreaterThan(0);
+            const dbNode = graph.nodes.find((node) => {
+                const data = node.data;
+                return (data &&
+                    data.componentType === "asset" &&
+                    data.componentSubType === "database");
+            });
+            expect(dbNode).toBeDefined();
+            const lambdaNode = graph.nodes.find((node) => {
+                const data = node.data;
+                return (data &&
+                    data.componentType === "asset" &&
+                    (data.managed_service_key === "lambda" ||
+                        data.resource_type === "aws_lambda_function"));
+            });
+            expect(lambdaNode).toBeDefined();
+            const iamNode = graph.nodes.find((node) => {
+                const data = node.data;
+                return (typeof data.resource_type === "string" &&
+                    data.resource_type.startsWith("aws_iam_"));
+            });
+            expect(iamNode).toBeUndefined();
+            fs_1.default.unlinkSync(outputPath);
+        }
+        finally {
+            if (prevAiInference === undefined) {
+                delete process.env.DATAPARADE_AI_INFERENCE;
+            }
+            else {
+                process.env.DATAPARADE_AI_INFERENCE = prevAiInference;
+            }
+        }
+    }, 15000);
+});

package/dist/tests/unit/cli/scan-command-e2e-ts-sample.spec.d.ts

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

package/dist/tests/unit/cli/scan-command-e2e-ts-sample.spec.js

@@ -0,0 +1,41 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cli_1 = require("../../../src/cli");
+const dataflow_wrapper_schema_1 = require("../../../src/core/schema/dataflow-wrapper.schema");
+describe("cli scan command - DP-P0-CLI-404 e2e TypeScript sample", () => {
+    it("scans the e2e-ts-sample fixture and produces a valid dataflow.json with database and third-party components and flows", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "e2e-ts-sample");
+        const outputPath = path_1.default.join(os_1.default.tmpdir(), `dataparade-scan-e2e-ts-sample-${Date.now()}.json`);
+        await (0, cli_1.run)(["node", "cli", "scan", fixturesRoot, "--output", outputPath]);
+        const contents = fs_1.default.readFileSync(outputPath, "utf8");
+        const parsed = JSON.parse(contents);
+        const validation = (0, dataflow_wrapper_schema_1.validateDataflowJson)(parsed);
+        expect(validation.ok).toBe(true);
+        if (!validation.ok)
+            return;
+        const { graph } = validation.value;
+        expect(Array.isArray(graph.nodes)).toBe(true);
+        expect(Array.isArray(graph.edges)).toBe(true);
+        expect(graph.nodes.length).toBeGreaterThan(1);
+        expect(graph.edges.length).toBeGreaterThan(0);
+        const dbNode = graph.nodes.find((node) => {
+            const data = node.data;
+            return (data &&
+                data.componentType === "asset" &&
+                data.componentSubType === "database");
+        });
+        const thirdPartyNode = graph.nodes.find((node) => {
+            const data = node.data;
+            return data && data.componentType === "third_party";
+        });
+        expect(dbNode).toBeDefined();
+        expect(thirdPartyNode).toBeDefined();
+        fs_1.default.unlinkSync(outputPath);
+    }, 15000);
+});

package/dist/tests/unit/cli/scan-command-e2e-ts-sentry-route-env.spec.d.ts

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