@dataparade/cli 0.0.1

package/dist/src/classifier/application-injection.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT = void 0;
+exports.injectApplicationAssetsPerSectionIfMissing = injectApplicationAssetsPerSectionIfMissing;
+exports.injectApplicationAssetIfMissing = injectApplicationAssetIfMissing;
+exports.injectActorIfMissing = injectActorIfMissing;
+exports.synthesizeSectionApiNodes = synthesizeSectionApiNodes;
+const property_detection_config_1 = require("../config/property-detection-config");
+const main_application_selection_1 = require("./main-application-selection");
+const section_runtime_1 = require("../core/sectioning/section-runtime");
+const sectioning_1 = require("./sectioning");
+const postprocessing_1 = require("./postprocessing");
+/** Synthetic main app created when no code hub exists (e.g. IaC-only scan). */
+exports.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT = "injected_project_placeholder";
+function isLikelyUserEntrypoint(mainApp) {
+    const subType = mainApp.subType;
+    if (subType === "application")
+        return true;
+    const framework = mainApp.properties?.framework;
+    const frameworks = [];
+    if (typeof framework === "string")
+        frameworks.push(framework);
+    if (Array.isArray(framework)) {
+        for (const v of framework) {
+            if (typeof v === "string")
+                frameworks.push(v);
+        }
+    }
+    return frameworks.some((f) => {
+        const lower = f.toLowerCase();
+        if (main_application_selection_1.PREFERRED_WEB_APP_FRAMEWORKS.has(lower))
+            return true;
+        return Array.from(main_application_selection_1.PREFERRED_WEB_APP_FRAMEWORKS).some((fw) => lower.includes(fw));
+    });
+}
+function isLikelyBackendEntrypoint(mainApp) {
+    const framework = mainApp.properties?.framework;
+    const frameworks = [];
+    if (typeof framework === "string")
+        frameworks.push(framework);
+    if (Array.isArray(framework)) {
+        for (const v of framework) {
+            if (typeof v === "string")
+                frameworks.push(v);
+        }
+    }
+    const backendHints = new Set([
+        "express",
+        "nest",
+        "fastapi",
+        "flask",
+        "django",
+        "drf",
+        "starlette",
+        "bottle",
+        "serverless",
+    ]);
+    if (frameworks.some((f) => {
+        const lower = f.toLowerCase();
+        return (backendHints.has(lower) ||
+            lower.includes("backend") ||
+            lower.includes("api"));
+    })) {
+        return true;
+    }
+    const sectionId = (0, sectioning_1.getSectionIdFromProperties)(mainApp.properties).toLowerCase();
+    return sectionId.includes("backend") || sectionId.endsWith("-api");
+}
+function getInjectedUserActorSubtype(mainApp) {
+    return isLikelyBackendEntrypoint(mainApp) ? "api_consumer" : "customer";
+}
+function getNextComponentId(components) {
+    let maxNumericId = 0;
+    for (const component of components) {
+        const match = /^cmp_(\d+)$/.exec(component.id);
+        if (match) {
+            const num = Number.parseInt(match[1], 10);
+            if (!Number.isNaN(num) && num > maxNumericId) {
+                maxNumericId = num;
+            }
+        }
+    }
+    const next = maxNumericId + 1;
+    return `cmp_${next}`;
+}
+function isSingleRouteApiAsset(component) {
+    if (component.type !== "asset" || component.subType !== "api") {
+        return false;
+    }
+    const name = (component.name || "").trim();
+    if (!name)
+        return false;
+    const lower = name.toLowerCase();
+    if (lower === "route handler") {
+        return true;
+    }
+    if (lower.startsWith("nest_controller")) {
+        return true;
+    }
+    if (/^(get|post|put|delete|patch|options|head)\s+/.test(lower)) {
+        return true;
+    }
+    return false;
+}
+function chooseMainAppSubType(mainAppSubtypes) {
+    if (mainAppSubtypes.has("application"))
+        return "application";
+    if (mainAppSubtypes.has("service"))
+        return "service";
+    if (mainAppSubtypes.has("api"))
+        return "api";
+    const first = mainAppSubtypes.values().next();
+    return first.done ? "service" : first.value;
+}
+function injectApplicationAssetsPerSectionIfMissing(components, sections, opts) {
+    if (!components || components.length === 0)
+        return [];
+    if (!sections || sections.length === 0)
+        return components;
+    const { mainAppSubtypes } = (0, property_detection_config_1.loadPropertyDetectionConfig)().enhance;
+    const chosenSubType = chooseMainAppSubType(mainAppSubtypes);
+    const hasCandidateInSection = new Map();
+    for (const c of components) {
+        if (c.type !== "asset" || c.subType === undefined)
+            continue;
+        if (!mainAppSubtypes.has(c.subType))
+            continue;
+        if ((0, main_application_selection_1.isExcludedFromMainApplicationHub)(c))
+            continue;
+        const sid = (0, sectioning_1.getSectionIdFromProperties)(c.properties);
+        hasCandidateInSection.set(sid, true);
+    }
+    const synthetic = [];
+    const hasPrimaryMonorepo = sections.some((s) => s.isPrimaryMonorepoPackage === true);
+    const eligibleSections = sections.filter((s) => {
+        if (s.role !== "service")
+            return false;
+        if (hasPrimaryMonorepo)
+            return s.isPrimaryMonorepoPackage === true;
+        return true;
+    });
+    for (const section of eligibleSections) {
+        const sid = section.id;
+        if (!(0, section_runtime_1.sectionQualifiesForSyntheticApplication)(section, components))
+            continue;
+        if (hasCandidateInSection.get(sid) === true)
+            continue;
+        const name = section.label.trim() || sid;
+        synthetic.push({
+            id: getNextComponentId([...components, ...synthetic]),
+            name,
+            type: "asset",
+            subType: chosenSubType,
+            confidence: 1,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: {
+                section_id: sid,
+                section_label: section.label,
+                section_role: section.role,
+                ...(section.packageName
+                    ? { package_name: section.packageName }
+                    : {}),
+                ...(section.isPrimaryMonorepoPackage === true
+                    ? { is_primary_monorepo_package: true }
+                    : {}),
+                sourceContext: exports.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT,
+            },
+            description: undefined,
+            dataFlowIds: undefined,
+        });
+    }
+    return synthetic.length > 0 ? [...components, ...synthetic] : components;
+}
+function injectApplicationAssetIfMissing(components, opts) {
+    if (!components || components.length === 0) {
+        return [];
+    }
+    const appIndex = (0, main_application_selection_1.pickMainApplicationAssetIndex)(components);
+    if (appIndex !== -1) {
+        const cloned = [...components];
+        const app = cloned[appIndex];
+        if (app.name === "Route Handler" ||
+            app.name === "route handler") {
+            const projectName = (opts?.projectName && opts.projectName.trim()) || "Application";
+            cloned[appIndex] = {
+                ...app,
+                name: projectName,
+            };
+        }
+        return cloned;
+    }
+    const name = (opts?.projectName && opts.projectName.trim()) || "Application";
+    const { mainAppSubtypes } = (0, property_detection_config_1.loadPropertyDetectionConfig)().enhance;
+    let chosenSubType;
+    if (mainAppSubtypes.has("application")) {
+        chosenSubType = "application";
+    }
+    else if (mainAppSubtypes.has("service")) {
+        chosenSubType = "service";
+    }
+    else if (mainAppSubtypes.has("api")) {
+        chosenSubType = "api";
+    }
+    else {
+        const first = mainAppSubtypes.values().next();
+        chosenSubType = first.value;
+    }
+    const defaultSectionId = (0, sectioning_1.pickDefaultSectionId)(components);
+    const defaultSectionRole = (0, sectioning_1.pickSectionRoleForSectionId)(components, defaultSectionId);
+    const synthetic = {
+        id: getNextComponentId(components),
+        name,
+        type: "asset",
+        subType: chosenSubType,
+        confidence: 1,
+        detectedFrom: [],
+        sourceLocations: [],
+        properties: {
+            section_id: defaultSectionId,
+            section_role: defaultSectionRole,
+            sourceContext: exports.INJECTED_PROJECT_PLACEHOLDER_SOURCE_CONTEXT,
+        },
+    };
+    return [...components, synthetic];
+}
+function injectActorIfMissing(components) {
+    if (!components || components.length === 0) {
+        return [];
+    }
+    const actorsBySection = new Set(components
+        .filter((c) => c.type === "actor")
+        .map((c) => (0, sectioning_1.getSectionIdFromProperties)(c.properties)));
+    const mainApps = components.filter((c) => c.type === "asset" &&
+        (c.properties?.isMainApplication === true ||
+            c.properties?.isMainApplication === "true"));
+    const synthetic = [];
+    for (const mainApp of mainApps) {
+        if (!isLikelyUserEntrypoint(mainApp))
+            continue;
+        if (!(0, section_runtime_1.shouldInjectUserActorForMainApp)(mainApp, components))
+            continue;
+        const mainAppSectionId = (0, sectioning_1.getSectionIdFromProperties)(mainApp.properties);
+        const fallbackSectionId = (0, sectioning_1.pickDefaultSectionId)(components);
+        const sectionId = mainAppSectionId !== "<unsectioned>"
+            ? mainAppSectionId
+            : fallbackSectionId;
+        if (actorsBySection.has(sectionId))
+            continue;
+        actorsBySection.add(sectionId);
+        const sectionRole = (0, sectioning_1.pickSectionRoleForSectionId)(components, sectionId);
+        synthetic.push({
+            id: getNextComponentId([...components, ...synthetic]),
+            name: "User",
+            type: "actor",
+            subType: getInjectedUserActorSubtype(mainApp),
+            confidence: 0.5,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: {
+                sourceContext: "injected_default",
+                section_id: sectionId,
+                section_role: sectionRole,
+            },
+        });
+    }
+    return synthetic.length > 0 ? [...components, ...synthetic] : components;
+}
+function synthesizeSectionApiNodes(components) {
+    if (!components?.length)
+        return [];
+    const bySection = new Map();
+    for (const component of components) {
+        const sectionId = (0, sectioning_1.getSectionIdFromProperties)(component.properties);
+        const list = bySection.get(sectionId);
+        if (list)
+            list.push(component);
+        else
+            bySection.set(sectionId, [component]);
+    }
+    const synthetic = [];
+    for (const [sectionId, sectionComponents] of bySection.entries()) {
+        const routeEvidenceRefs = [];
+        let hasNonManifestRouteEvidence = false;
+        for (const c of sectionComponents) {
+            for (const ref of c.detectedFrom) {
+                if (ref.pattern === "express_route") {
+                    routeEvidenceRefs.push(ref);
+                    const fp = ref.sourceLocation?.filePath?.replace(/\\/g, "/");
+                    if (fp && !fp.endsWith("package.json")) {
+                        hasNonManifestRouteEvidence = true;
+                    }
+                }
+            }
+        }
+        if (routeEvidenceRefs.length === 0 || !hasNonManifestRouteEvidence)
+            continue;
+        routeEvidenceRefs.sort(postprocessing_1.compareDetectedFromRefs);
+        const existingApi = sectionComponents.find((c) => {
+            if (c.type !== "asset" || c.subType !== "api")
+                return false;
+            const isMainApp = c.properties?.isMainApplication === true ||
+                c.properties?.isMainApplication === "true";
+            const hasRouteEvidence = c.detectedFrom.some((ref) => ref.pattern === "express_route");
+            if (hasRouteEvidence && !isMainApp)
+                return true;
+            return (c.properties?.isSectionApiNode === true ||
+                c.properties?.isSectionApiNode === "true");
+        });
+        if (existingApi)
+            continue;
+        const sectionLabel = (0, sectioning_1.getSectionLabelFromProperties)(sectionComponents[0]?.properties) ?? sectionId;
+        const sourceLocations = (0, postprocessing_1.dedupeSourceLocations)(routeEvidenceRefs
+            .map((ref) => ref.sourceLocation)
+            .filter((loc) => loc !== undefined)).sort(postprocessing_1.compareSourceLocations);
+        synthetic.push({
+            id: getNextComponentId([...components, ...synthetic]),
+            name: "API",
+            type: "asset",
+            subType: "api",
+            confidence: 1,
+            detectedFrom: routeEvidenceRefs,
+            sourceLocations,
+            properties: {
+                section_id: sectionId,
+                section_label: sectionLabel,
+                section_role: (0, sectioning_1.pickSectionRoleForSectionId)(components, sectionId),
+                isSectionApiNode: true,
+            },
+        });
+    }
+    if (synthetic.length === 0)
+        return components;
+    return [...components, ...synthetic];
+}

package/dist/src/classifier/classify.d.ts

@@ -0,0 +1,3 @@
+export { classifyRawFindings } from "./component-factory";
+export { dedupeComponents, mergeDatabaseAssetsByType, compactAuthServiceComponents, mergeGlobalIdentityProviderThirdParties, } from "./postprocessing";
+export { injectApplicationAssetsPerSectionIfMissing, injectApplicationAssetIfMissing, injectActorIfMissing, synthesizeSectionApiNodes, } from "./application-injection";

package/dist/src/classifier/classify.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeSectionApiNodes = exports.injectActorIfMissing = exports.injectApplicationAssetIfMissing = exports.injectApplicationAssetsPerSectionIfMissing = exports.mergeGlobalIdentityProviderThirdParties = exports.compactAuthServiceComponents = exports.mergeDatabaseAssetsByType = exports.dedupeComponents = exports.classifyRawFindings = void 0;
+var component_factory_1 = require("./component-factory");
+Object.defineProperty(exports, "classifyRawFindings", { enumerable: true, get: function () { return component_factory_1.classifyRawFindings; } });
+var postprocessing_1 = require("./postprocessing");
+Object.defineProperty(exports, "dedupeComponents", { enumerable: true, get: function () { return postprocessing_1.dedupeComponents; } });
+Object.defineProperty(exports, "mergeDatabaseAssetsByType", { enumerable: true, get: function () { return postprocessing_1.mergeDatabaseAssetsByType; } });
+Object.defineProperty(exports, "compactAuthServiceComponents", { enumerable: true, get: function () { return postprocessing_1.compactAuthServiceComponents; } });
+Object.defineProperty(exports, "mergeGlobalIdentityProviderThirdParties", { enumerable: true, get: function () { return postprocessing_1.mergeGlobalIdentityProviderThirdParties; } });
+var application_injection_1 = require("./application-injection");
+Object.defineProperty(exports, "injectApplicationAssetsPerSectionIfMissing", { enumerable: true, get: function () { return application_injection_1.injectApplicationAssetsPerSectionIfMissing; } });
+Object.defineProperty(exports, "injectApplicationAssetIfMissing", { enumerable: true, get: function () { return application_injection_1.injectApplicationAssetIfMissing; } });
+Object.defineProperty(exports, "injectActorIfMissing", { enumerable: true, get: function () { return application_injection_1.injectActorIfMissing; } });
+Object.defineProperty(exports, "synthesizeSectionApiNodes", { enumerable: true, get: function () { return application_injection_1.synthesizeSectionApiNodes; } });

package/dist/src/classifier/component-factory.d.ts

@@ -0,0 +1,3 @@
+import type { RawFinding } from "../core/types/detection";
+import type { DetectedComponent } from "../core/types/component";
+export declare function classifyRawFindings(rawFindings: RawFinding[]): DetectedComponent[];