@dataparade/cli 0.0.1

package/dist/tests/unit/classifier/enhance.spec.d.ts

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

package/dist/tests/unit/classifier/enhance.spec.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const application_injection_1 = require("../../../src/classifier/application-injection");
+const enhance_1 = require("../../../src/classifier/enhance");
+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,
+    };
+}
+describe("classifier/enhance - DP-P0-CLI-203", () => {
+    it("applies all Engineering, Privacy, and Security property defaults for asset", () => {
+        const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+            id: "c1",
+            name: "postgres",
+            type: "asset",
+            subType: "database",
+            properties: {},
+        }));
+        expect(comp.properties.cloud_provider).toBeDefined();
+        expect(comp.properties.technology_stack).toBe("postgres");
+        expect(comp.properties.data_categories).toEqual([]);
+        expect(comp.properties.data_subject_categories).toEqual([]);
+        expect(comp.properties.encrypt_at_rest).toBeDefined();
+        expect(comp.properties.audit_logging_enabled).toBe(false);
+        expect(comp.properties.risk_rating).toBeDefined();
+    });
+    it("applies all Engineering, Privacy, and Security property defaults for third_party", () => {
+        const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+            id: "c1",
+            name: "Stripe",
+            type: "third_party",
+            subType: "payment_processor",
+            properties: {},
+        }));
+        expect(comp.properties.integration_method).toBe("api");
+        expect(comp.properties.hosting_type).toBe("saas");
+        expect(comp.properties.gdpr_role).toBeDefined();
+        expect(comp.properties.compliance_certifications).toEqual([]);
+        expect(comp.properties.risk_rating).toBeDefined();
+    });
+    it("applies all Engineering, Privacy, and Security property defaults for actor", () => {
+        const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+            id: "c1",
+            name: "Customer",
+            type: "actor",
+            subType: "customer",
+            properties: {},
+        }));
+        expect(comp.properties.actions).toEqual([]);
+        expect(comp.properties.processing_purpose).toEqual([]);
+        expect(comp.properties.isDataSubject).toBe(true);
+        expect(comp.properties.risk_rating).toBeDefined();
+    });
+    it("sets technology_stack from properties.databaseType when missing", () => {
+        const component = makeComponent({
+            id: "cmp_1",
+            name: "postgres",
+            type: "asset",
+            subType: "database",
+            properties: { databaseType: "postgres" },
+        });
+        const result = (0, enhance_1.enhanceComponent)(component);
+        expect(result.properties.technology_stack).toBe("postgres");
+    });
+    it("leaves technology_stack unset when only subType is database (no specific product)", () => {
+        const component = makeComponent({
+            id: "cmp_1",
+            name: "my-db",
+            type: "asset",
+            subType: "database",
+            properties: {},
+        });
+        const result = (0, enhance_1.enhanceComponent)(component);
+        expect(result.properties.technology_stack).toBeNull();
+    });
+    it("does not overwrite existing technology_stack", () => {
+        const component = makeComponent({
+            id: "cmp_1",
+            name: "db",
+            type: "asset",
+            subType: "database",
+            properties: { technology_stack: "postgres", databaseType: "postgres" },
+        });
+        const result = (0, enhance_1.enhanceComponent)(component);
+        expect(result.properties.technology_stack).toBe("postgres");
+    });
+    it("sets hosting_type for third_party when not set", () => {
+        const component = makeComponent({
+            id: "cmp_1",
+            name: "Stripe",
+            type: "third_party",
+            subType: "payment_processor",
+            properties: {},
+        });
+        const result = (0, enhance_1.enhanceComponent)(component);
+        expect(result.properties.hosting_type).toBe("saas");
+    });
+    it("does not overwrite existing hosting_type for third_party", () => {
+        const component = makeComponent({
+            id: "cmp_1",
+            name: "Stripe",
+            type: "third_party",
+            subType: "payment_processor",
+            properties: { hosting_type: "cloud" },
+        });
+        const result = (0, enhance_1.enhanceComponent)(component);
+        expect(result.properties.hosting_type).toBe("cloud");
+    });
+    it("sets isMainApplication on first api/service asset in enhanceComponents", () => {
+        const components = [
+            makeComponent({
+                id: "cmp_1",
+                name: "DB",
+                type: "asset",
+                subType: "database",
+                properties: {},
+            }),
+            makeComponent({
+                id: "cmp_2",
+                name: "App API",
+                type: "asset",
+                subType: "api",
+                properties: {},
+            }),
+            makeComponent({
+                id: "cmp_3",
+                name: "Other Service",
+                type: "asset",
+                subType: "service",
+                properties: {},
+            }),
+        ];
+        const result = (0, enhance_1.enhanceComponents)(components);
+        const apiComp = result.find((c) => c.id === "cmp_2");
+        const serviceComp = result.find((c) => c.id === "cmp_3");
+        expect(apiComp?.properties.isMainApplication).toBe(true);
+        expect(serviceComp?.properties.isMainApplication).toBeUndefined();
+    });
+    it("sets isMainApplication per section_id (not globally) when multiple api/service assets exist", () => {
+        const components = [
+            makeComponent({
+                id: "cmp_1",
+                name: "API A",
+                type: "asset",
+                subType: "api",
+                properties: { section_id: "s1" },
+            }),
+            makeComponent({
+                id: "cmp_2",
+                name: "API B",
+                type: "asset",
+                subType: "api",
+                properties: { section_id: "s2" },
+            }),
+        ];
+        const result = (0, enhance_1.enhanceComponents)(components);
+        const withMain = result.filter((c) => c.properties.isMainApplication === true);
+        expect(withMain.length).toBe(2);
+        expect(withMain.map((c) => c.id).sort()).toEqual(["cmp_1", "cmp_2"]);
+    });
+    it("prefers merged HTTP API (express) over outbound https URL api assets", () => {
+        const components = [
+            makeComponent({
+                id: "cmp_http",
+                name: "HTTP API",
+                type: "asset",
+                subType: "api",
+                properties: { framework: "express", path: ["/auth"] },
+            }),
+            makeComponent({
+                id: "cmp_vendor",
+                name: "https://vendor.example/v1",
+                type: "asset",
+                subType: "api",
+                properties: {
+                    url: "https://vendor.example/v1",
+                    client: "fetch",
+                },
+            }),
+        ];
+        const result = (0, enhance_1.enhanceComponents)(components);
+        const main = result.find((c) => c.properties.isMainApplication === true);
+        expect(main?.id).toBe("cmp_http");
+    });
+    it("does not promote Terraform module call shells to isMainApplication", () => {
+        const components = [
+            makeComponent({
+                id: "cmp_mod",
+                name: "Module · aurora",
+                type: "asset",
+                subType: "application",
+                properties: {
+                    section_id: "root",
+                    terraform_address: "module.aurora",
+                },
+            }),
+        ];
+        const result = (0, enhance_1.enhanceComponents)(components);
+        expect(result[0].properties.isMainApplication).toBeUndefined();
+    });
+    it("does not promote Terraform VPC networking to isMainApplication", () => {
+        const components = [
+            makeComponent({
+                id: "cmp_vpc",
+                name: "main (aws_vpc)",
+                type: "asset",
+                subType: "application",
+                properties: {
+                    section_id: "root",
+                    resource_type: "aws_vpc",
+                    terraform_address: "module.vpc.aws_vpc.main",
+                },
+            }),
+        ];
+        const result = (0, enhance_1.enhanceComponents)(components);
+        expect(result[0].properties.isMainApplication).toBeUndefined();
+    });
+    it("prefers injected project placeholder over other service assets in the same section", () => {
+        const components = [
+            makeComponent({
+                id: "cmp_ecs",
+                name: "API",
+                type: "asset",
+                subType: "service",
+                properties: { section_id: "root" },
+            }),
+            makeComponent({
+                id: "cmp_inj",
+                name: "MyProject",
+                type: "asset",
+                subType: "application",
+                properties: {
+                    section_id: "root",
+                    sourceContext: application_injection_1.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT,
+                },
+            }),
+        ];
+        const result = (0, enhance_1.enhanceComponents)(components);
+        const mains = result.filter((c) => c.properties.isMainApplication === true);
+        expect(mains.length).toBe(1);
+        expect(mains[0].id).toBe("cmp_inj");
+    });
+    it("does not set isMainApplication when no api/service asset exists", () => {
+        const components = [
+            makeComponent({
+                id: "cmp_1",
+                name: "DB",
+                type: "asset",
+                subType: "database",
+                properties: {},
+            }),
+        ];
+        const result = (0, enhance_1.enhanceComponents)(components);
+        expect(result[0].properties.isMainApplication).toBeUndefined();
+    });
+    it("normalizes generic api asset name to API in enhanceComponents", () => {
+        const components = [
+            makeComponent({
+                id: "cmp_1",
+                name: "Route Handler",
+                type: "asset",
+                subType: "api",
+                properties: {},
+            }),
+        ];
+        const result = (0, enhance_1.enhanceComponents)(components);
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe("API");
+    });
+    describe("asset: all properties", () => {
+        it("sets hosting_type to cloud for api/database assets", () => {
+            const apiComp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c1",
+                name: "api",
+                type: "asset",
+                subType: "api",
+                properties: {},
+            }));
+            const dbComp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c2",
+                name: "db",
+                type: "asset",
+                subType: "database",
+                properties: {},
+            }));
+            expect(apiComp.properties.hosting_type).toBe("cloud");
+            expect(dbComp.properties.hosting_type).toBe("cloud");
+        });
+        it("sets hosting_type to on_premise for config assets", () => {
+            const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c1",
+                name: "config",
+                type: "asset",
+                subType: "config",
+                properties: {},
+            }));
+            expect(comp.properties.hosting_type).toBe("on_premise");
+        });
+        it("sets database_engine from databaseType for database subType", () => {
+            const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c1",
+                name: "pg",
+                type: "asset",
+                subType: "database",
+                properties: { databaseType: "postgres" },
+            }));
+            expect(comp.properties.database_engine).toBe("Postgres");
+        });
+        it("sets supported_operations for database and api assets", () => {
+            const dbComp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c1",
+                name: "db",
+                type: "asset",
+                subType: "database",
+                properties: {},
+            }));
+            const apiComp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c2",
+                name: "api",
+                type: "asset",
+                subType: "api",
+                properties: {},
+            }));
+            expect(dbComp.properties.supported_operations).toEqual([
+                "read",
+                "write",
+                "query",
+            ]);
+            expect(apiComp.properties.supported_operations).toEqual([
+                "read",
+                "write",
+                "query",
+                "execute",
+            ]);
+        });
+    });
+    describe("third_party: all properties", () => {
+        it("sets integration_method to api", () => {
+            const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c1",
+                name: "Stripe",
+                type: "third_party",
+                subType: "payment_processor",
+                properties: {},
+            }));
+            expect(comp.properties.integration_method).toBe("api");
+        });
+        it("sets vendor from component name (title case)", () => {
+            const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c1",
+                name: "stripe",
+                type: "third_party",
+                subType: "payment_processor",
+                properties: {},
+            }));
+            expect(comp.properties.vendor).toBe("Stripe");
+        });
+        it("does not overwrite existing vendor", () => {
+            const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c1",
+                name: "stripe",
+                type: "third_party",
+                subType: "payment_processor",
+                properties: { vendor: "Stripe Inc." },
+            }));
+            expect(comp.properties.vendor).toBe("Stripe Inc.");
+        });
+    });
+    describe("actor: all properties", () => {
+        it("sets isDataSubject to true for customer subType", () => {
+            const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c1",
+                name: "Customer",
+                type: "actor",
+                subType: "customer",
+                properties: {},
+            }));
+            expect(comp.properties.isDataSubject).toBe(true);
+        });
+        it("does not set isDataSubject to true for non-customer actor (default remains false)", () => {
+            const comp = (0, enhance_1.enhanceComponent)(makeComponent({
+                id: "c1",
+                name: "Employee",
+                type: "actor",
+                subType: "employee",
+                properties: {},
+            }));
+            expect(comp.properties.isDataSubject).toBe(false);
+        });
+    });
+});

package/dist/tests/unit/classifier/external-url-third-party.spec.d.ts

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

package/dist/tests/unit/classifier/external-url-third-party.spec.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const external_url_third_party_1 = require("../../../src/classifier/external-url-third-party");
+function makeExternalFinding(props, name = "x") {
+    return {
+        pattern: "external_api_call",
+        name,
+        confidence: 0.9,
+        location: {
+            filePath: "svc.js",
+            startLine: 1,
+            endLine: 1,
+        },
+        properties: props,
+    };
+}
+describe("classifier/external-url-third-party", () => {
+    it("shouldIgnoreExternalHttpUrl ignores placeholders and accepts public hosts", () => {
+        expect((0, external_url_third_party_1.shouldIgnoreExternalHttpUrl)(undefined)).toBe(true);
+        expect((0, external_url_third_party_1.shouldIgnoreExternalHttpUrl)("https://...")).toBe(true);
+        expect((0, external_url_third_party_1.shouldIgnoreExternalHttpUrl)("http://localhost:3000/")).toBe(true);
+        expect((0, external_url_third_party_1.shouldIgnoreExternalHttpUrl)("https://api.example.com/v1")).toBe(false);
+    });
+    it("shouldIgnoreExternalHttpUrl ignores null hostname without throwing", () => {
+        const url = new URL("https://api.example.com/v1");
+        Object.defineProperty(url, "hostname", { get: () => null });
+        const parseSpy = jest.spyOn(globalThis, "URL").mockImplementation(() => url);
+        try {
+            expect((0, external_url_third_party_1.shouldIgnoreExternalHttpUrl)("https://api.example.com/v1")).toBe(true);
+        }
+        finally {
+            parseSpy.mockRestore();
+        }
+    });
+    it("defaultServiceNameFromLiteralPublicUrl derives registrable host without YAML", () => {
+        expect((0, external_url_third_party_1.defaultServiceNameFromLiteralPublicUrl)("https://api.weirdvendor.example.net/v1")).toBe("example.net");
+        expect((0, external_url_third_party_1.defaultServiceNameFromLiteralPublicUrl)("https://clipdrop-api.co/remove-background/v1")).toBe("clipdrop-api.co");
+    });
+    it("defaultServiceNameFromLiteralPublicUrl returns undefined for placeholder template URLs", () => {
+        expect((0, external_url_third_party_1.defaultServiceNameFromLiteralPublicUrl)("https://...")).toBeUndefined();
+        expect((0, external_url_third_party_1.inferThirdPartyFromLiteralHttpUrl)(makeExternalFinding({ url: "https://...", client: "fetch" }))).toBeUndefined();
+    });
+    it("defaultServiceNameFromLiteralPublicUrl returns undefined for env or local URLs", () => {
+        expect((0, external_url_third_party_1.defaultServiceNameFromLiteralPublicUrl)("https://x.com${process.env.BASE}")).toBeUndefined();
+        expect((0, external_url_third_party_1.defaultServiceNameFromLiteralPublicUrl)("http://localhost:3000/")).toBeUndefined();
+    });
+    it("urlHostMatchKeys includes hostname and registrable domain", () => {
+        const keys = (0, external_url_third_party_1.urlHostMatchKeys)("https://api.thenextleg.io/v2/message/123");
+        expect(keys.has("api.thenextleg.io")).toBe(true);
+        expect(keys.has("thenextleg.io")).toBe(true);
+    });
+    it("infers third_party from literal https url property (catalog subType)", () => {
+        const out = (0, external_url_third_party_1.inferThirdPartyFromLiteralHttpUrl)(makeExternalFinding({
+            url: "https://clipdrop-api.co/remove-background/v1",
+            client: "fetch",
+        }));
+        expect(out?.serviceName).toBe("clipdrop-api.co");
+        expect(out?.subType).toBe("ai_provider");
+    });
+    it("infers ai_provider subType from catalog match on hostname (e.g. OpenAI)", () => {
+        const out = (0, external_url_third_party_1.inferThirdPartyFromLiteralHttpUrl)(makeExternalFinding({
+            url: "https://api.openai.com/v1/chat/completions",
+            client: "fetch",
+        }));
+        expect(out?.serviceName).toBe("openai.com");
+        expect(out?.subType).toBe("ai_provider");
+    });
+    it("returns undefined when url references process.env", () => {
+        expect((0, external_url_third_party_1.inferThirdPartyFromLiteralHttpUrl)(makeExternalFinding({
+            url: 'https://api.example.com${process.env.FOO}',
+        }))).toBeUndefined();
+    });
+    it("returns undefined for localhost", () => {
+        expect((0, external_url_third_party_1.inferThirdPartyFromLiteralHttpUrl)(makeExternalFinding({ url: "http://localhost:3021/v1" }))).toBeUndefined();
+    });
+    it("infers saas_service for generic vendor host", () => {
+        const out = (0, external_url_third_party_1.inferThirdPartyFromLiteralHttpUrl)(makeExternalFinding({
+            url: "https://payments.example-saas.io/v1/charges",
+        }));
+        expect(out?.serviceName).toBe("example-saas.io");
+        expect(out?.subType).toBe("saas_service");
+    });
+});

package/dist/tests/unit/classifier/frontend-framework-grouping.spec.d.ts

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

package/dist/tests/unit/classifier/frontend-framework-grouping.spec.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const classify_1 = require("../../../src/classifier/classify");
+describe("classifier frontend framework grouping", () => {
+    it("keeps dependency-manifest frontend framework separate from route API group", () => {
+        const findings = [
+            {
+                pattern: "express_route",
+                name: "POST /api/ai-completion",
+                confidence: 0.9,
+                location: {
+                    filePath: "dev-server.js",
+                    startLine: 10,
+                    endLine: 10,
+                },
+                properties: {
+                    framework: "express",
+                    section_id: "root",
+                },
+            },
+            {
+                pattern: "express_route",
+                name: "Frontend Application",
+                confidence: 0.75,
+                location: {
+                    filePath: "package.json",
+                    startLine: 1,
+                    endLine: 1,
+                },
+                properties: {
+                    framework: "react",
+                    section_id: "root",
+                    sourceContext: "dependency_manifest",
+                },
+            },
+        ];
+        const components = (0, classify_1.classifyRawFindings)(findings);
+        const routeApi = components.find((c) => c.name === "HTTP API");
+        const frontend = components.find((c) => c.name === "React");
+        expect(routeApi).toBeDefined();
+        expect(frontend).toBeDefined();
+        expect(components.length).toBe(2);
+    });
+});

package/dist/tests/unit/classifier/terraform-grouping.spec.d.ts

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

package/dist/tests/unit/classifier/terraform-grouping.spec.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const component_factory_1 = require("../../../src/classifier/component-factory");
+const enhance_1 = require("../../../src/classifier/enhance");
+function tfResource(address, resourceType, blockName, subType) {
+    return {
+        pattern: "terraform_resource",
+        name: address,
+        confidence: 0.9,
+        location: { filePath: "main.tf", startLine: 1, endLine: 5 },
+        properties: {
+            terraform_address: address,
+            terraform_block_kind: "resource",
+            resource_type: resourceType,
+            block_name: blockName,
+            componentSubType: subType,
+            cloud_provider: "aws",
+            section_id: "root",
+            section_label: "root",
+            terraform_references: [],
+        },
+    };
+}
+describe("classifier terraform grouping", () => {
+    it("groups each terraform address separately (no merge on normalized labels)", () => {
+        const findings = [
+            tfResource("aws_s3_bucket.lambda_bucket", "aws_s3_bucket", "lambda_bucket", "storage"),
+            tfResource("aws_lambda_function.lambda_bucket", "aws_lambda_function", "lambda_bucket", "function"),
+        ];
+        const components = (0, component_factory_1.classifyRawFindings)(findings);
+        expect(components).toHaveLength(2);
+        const labels = components.map((c) => c.name).sort();
+        expect(labels).toEqual([
+            "lambda_bucket (aws_lambda_function)",
+            "lambda_bucket (aws_s3_bucket)",
+        ]);
+    });
+    it("uses block_name (resource_type) labels so lambda_* bucket names are not confused with Lambda compute", () => {
+        const components = (0, component_factory_1.classifyRawFindings)([
+            tfResource("aws_s3_bucket.lambda_bucket", "aws_s3_bucket", "lambda_bucket", "storage"),
+        ]);
+        expect(components[0]?.name).toBe("lambda_bucket (aws_s3_bucket)");
+    });
+    it("classifies terraform_provider findings as third_party cloud providers", () => {
+        const components = (0, component_factory_1.classifyRawFindings)([
+            {
+                pattern: "terraform_provider",
+                name: "provider:kubernetes",
+                confidence: 0.92,
+                location: {
+                    filePath: "packages/acme/k8s/terraform/main.tf",
+                    startLine: 4,
+                    endLine: 6,
+                },
+                properties: {
+                    terraform_address: "provider.kubernetes",
+                    provider_name: "kubernetes",
+                    serviceName: "Kubernetes",
+                    section_id: "packages/acme/k8s/terraform",
+                    section_label: "terraform",
+                },
+            },
+        ]);
+        expect(components).toHaveLength(1);
+        expect(components[0]?.type).toBe("third_party");
+        expect(components[0]?.subType).toBe("cloud_provider");
+        expect(components[0]?.name).toBe("Kubernetes");
+        expect(components[0]?.properties?.terraform_address).toBe("provider.kubernetes");
+    });
+    it("drops utility terraform resources (random_pet) from classified components", () => {
+        const components = (0, component_factory_1.classifyRawFindings)([
+            {
+                pattern: "terraform_resource",
+                name: "random_pet.lambda_bucket_name",
+                confidence: 0.9,
+                location: { filePath: "main.tf", startLine: 1, endLine: 3 },
+                properties: {
+                    terraform_address: "random_pet.lambda_bucket_name",
+                    terraform_block_kind: "resource",
+                    resource_type: "random_pet",
+                    block_name: "lambda_bucket_name",
+                    componentSubType: "application",
+                    cloud_provider: "terraform",
+                    section_id: "root",
+                    section_label: "root",
+                    terraform_references: [],
+                },
+            },
+            tfResource("aws_s3_bucket.lambda_bucket", "aws_s3_bucket", "lambda_bucket", "storage"),
+        ]);
+        expect(components).toHaveLength(1);
+        expect(components[0]?.properties?.terraform_address).toBe("aws_s3_bucket.lambda_bucket");
+        const enhanced = (0, enhance_1.enhanceComponents)(components);
+        expect(enhanced.some((c) => c.properties.isMainApplication === true)).toBe(false);
+    });
+});

package/dist/tests/unit/cli/config-command.spec.d.ts

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