@dataparade/cli 0.0.1

package/dist/src/classifier/main-application-selection.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREFERRED_WEB_APP_FRAMEWORKS = void 0;
+exports.isSingleRouteApiAsset = isSingleRouteApiAsset;
+exports.isOutboundExternalHttpApiAsset = isOutboundExternalHttpApiAsset;
+exports.isTerraformUtilityInfrastructureAsset = isTerraformUtilityInfrastructureAsset;
+exports.isTerraformStructuralInfrastructureAsset = isTerraformStructuralInfrastructureAsset;
+exports.isTerraformGraphResourceAsset = isTerraformGraphResourceAsset;
+exports.isTerraformModuleCallShellAsset = isTerraformModuleCallShellAsset;
+exports.isExcludedFromMainApplicationHub = isExcludedFromMainApplicationHub;
+exports.pickMainApplicationAssetIndex = pickMainApplicationAssetIndex;
+const terraform_utility_resource_1 = require("../analyzers/terraform/terraform-utility-resource");
+const property_detection_config_1 = require("../config/property-detection-config");
+const frontend_frameworks_1 = require("../patterns/frontend-frameworks");
+Object.defineProperty(exports, "PREFERRED_WEB_APP_FRAMEWORKS", { enumerable: true, get: function () { return frontend_frameworks_1.PREFERRED_WEB_APP_FRAMEWORKS; } });
+/**
+ * Thin / single-endpoint API surfaces that should not be treated as the primary
+ * application hub (e.g. one handler named "POST /foo").
+ */
+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;
+}
+/**
+ * Outbound HTTP client calls to absolute URLs (e.g. fetch("https://api.vendor/..."))
+ * classified as api assets — not the project's own HTTP API surface.
+ */
+function isOutboundExternalHttpApiAsset(component) {
+    if (component.type !== "asset" || component.subType !== "api") {
+        return false;
+    }
+    const url = typeof component.properties?.url === "string"
+        ? component.properties.url.trim()
+        : "";
+    if (!/^https?:\/\//i.test(url)) {
+        return false;
+    }
+    const fw = component.properties?.framework;
+    if (typeof fw === "string" && fw.trim().length > 0) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Terraform resources from utility providers (names, time sleeps, etc.) are not
+ * application entrypoints; they should not win isMainApplication when that is
+ * the only "application" subtype asset in a section.
+ */
+function isTerraformUtilityInfrastructureAsset(component) {
+    const rt = component.properties?.resource_type;
+    if (typeof rt !== "string" || !rt.trim())
+        return false;
+    return (0, terraform_utility_resource_1.isTerraformUtilityResourceType)(rt);
+}
+/** Exact Terraform resource types that must never win "main application" in IaC scans. */
+const TERRAFORM_STRUCTURAL_RESOURCE_TYPES = new Set([
+    "aws_vpc",
+    "aws_subnet",
+    "aws_default_subnet",
+    "aws_default_vpc",
+    "aws_default_network_acl",
+    "aws_default_route_table",
+    "aws_default_security_group",
+    "aws_internet_gateway",
+    "aws_egress_only_internet_gateway",
+    "aws_nat_gateway",
+    "aws_route_table",
+    "aws_route",
+    "aws_network_acl",
+    "aws_security_group",
+    "aws_network_interface",
+    "aws_vpc_endpoint",
+    "aws_vpc_peering_connection",
+    "aws_flow_log",
+    "aws_db_subnet_group",
+    "aws_elasticache_subnet_group",
+    "aws_cloudwatch_log_group",
+    "aws_cloudwatch_log_stream",
+    "aws_ecs_cluster",
+    "aws_ecs_task_definition",
+    "aws_lb_target_group",
+    "aws_alb_target_group",
+    "aws_lb_listener",
+    "aws_alb_listener",
+    "aws_lb",
+    "aws_alb",
+    "aws_appautoscaling_target",
+    "aws_appautoscaling_policy",
+    "aws_db_instance",
+    "aws_rds_cluster",
+    "aws_rds_cluster_instance",
+]);
+const TERRAFORM_STRUCTURAL_RESOURCE_PREFIXES = [
+    "aws_iam_",
+    "aws_default_",
+];
+/**
+ * Networking / IAM / orchestration / data-plane stores from Terraform should not
+ * become the product "main app" when no real service code exists — use the injected
+ * placeholder instead.
+ */
+function isTerraformStructuralInfrastructureAsset(component) {
+    const rt = component.properties?.resource_type;
+    if (typeof rt !== "string" || !rt.trim())
+        return false;
+    const t = rt.trim().toLowerCase();
+    if (TERRAFORM_STRUCTURAL_RESOURCE_TYPES.has(t))
+        return true;
+    return TERRAFORM_STRUCTURAL_RESOURCE_PREFIXES.some((p) => t.startsWith(p));
+}
+/**
+ * Terraform resource/data blocks in the diagram are infrastructure, not the
+ * product application hub (e.g. `kubernetes_deployment.*`, `aws_s3_bucket.*`).
+ */
+function isTerraformGraphResourceAsset(component) {
+    if (component.type !== "asset")
+        return false;
+    const addr = component.properties?.terraform_address;
+    if (typeof addr !== "string" || !addr.trim())
+        return false;
+    return !addr.trim().startsWith("provider.");
+}
+/**
+ * `module.vpc` / `module.frontend` call shells: not the product application.
+ */
+function isTerraformModuleCallShellAsset(component) {
+    if (component.type !== "asset")
+        return false;
+    const addr = component.properties?.terraform_address;
+    if (typeof addr !== "string" || !addr.trim() || !addr.startsWith("module.")) {
+        return false;
+    }
+    const rt = component.properties?.resource_type;
+    if (typeof rt === "string" && rt.trim() && rt.trim() !== "unknown") {
+        return false;
+    }
+    return true;
+}
+function isExcludedFromMainApplicationHub(component) {
+    return (isSingleRouteApiAsset(component) ||
+        isOutboundExternalHttpApiAsset(component) ||
+        isTerraformGraphResourceAsset(component) ||
+        isTerraformUtilityInfrastructureAsset(component) ||
+        isTerraformStructuralInfrastructureAsset(component) ||
+        isTerraformModuleCallShellAsset(component));
+}
+function getFrameworkPriorityForMainSelection(component) {
+    const value = component.properties.framework;
+    const frameworks = [];
+    if (typeof value === "string") {
+        frameworks.push(value);
+    }
+    else if (Array.isArray(value)) {
+        for (const v of value) {
+            if (typeof v === "string") {
+                frameworks.push(v);
+            }
+        }
+    }
+    if (frameworks.length === 0)
+        return 100;
+    let best = 100;
+    for (const raw of frameworks) {
+        const fw = raw.toLowerCase();
+        if (frontend_frameworks_1.PREFERRED_WEB_APP_FRAMEWORKS.has(fw)) {
+            best = Math.min(best, 0);
+        }
+        else if (frontend_frameworks_1.SERVER_FRAMEWORK_HINTS.has(fw)) {
+            best = Math.min(best, 1);
+        }
+        else {
+            best = Math.min(best, 2);
+        }
+    }
+    return best;
+}
+/**
+ * Index of the asset that should be the main application hub, or -1 if none.
+ * Uses the same rules as enhanceComponents (subtype allowlist, exclusions, then
+ * framework priority).
+ */
+function pickMainApplicationAssetIndex(components) {
+    const { mainAppSubtypes } = (0, property_detection_config_1.loadPropertyDetectionConfig)().enhance;
+    const candidates = [];
+    for (let i = 0; i < components.length; i++) {
+        const c = components[i];
+        if (c.type === "asset" &&
+            c.subType !== undefined &&
+            mainAppSubtypes.has(c.subType) &&
+            !isExcludedFromMainApplicationHub(c)) {
+            candidates.push({
+                index: i,
+                frameworkPriority: getFrameworkPriorityForMainSelection(c),
+            });
+        }
+    }
+    if (candidates.length === 0) {
+        return -1;
+    }
+    candidates.sort((a, b) => {
+        if (a.frameworkPriority !== b.frameworkPriority) {
+            return a.frameworkPriority - b.frameworkPriority;
+        }
+        return a.index - b.index;
+    });
+    return candidates[0].index;
+}

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

@@ -0,0 +1,4 @@
+import type { NameNormalizationConfig } from "./config";
+export declare function normalizeComponentName(rawName: string, rules: NameNormalizationConfig): string;
+export declare function toDisplayName(normalized: string, fallback: string): string;
+export declare function normalizeApiDisplayName(rawName: string, properties: Record<string, unknown> | undefined): string;

package/dist/src/classifier/naming.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeComponentName = normalizeComponentName;
+exports.toDisplayName = toDisplayName;
+exports.normalizeApiDisplayName = normalizeApiDisplayName;
+function escapeForCharClass(input) {
+    return input.replace(/[-\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+function normalizeComponentName(rawName, rules) {
+    let name = rawName.trim();
+    if (!name) {
+        return "";
+    }
+    let lower = name.toLowerCase();
+    // Remove simple suffix tokens (case-insensitive).
+    for (const suffix of rules.removeSuffixes) {
+        if (!suffix)
+            continue;
+        if (lower === suffix) {
+            lower = "";
+            break;
+        }
+        if (lower.endsWith(suffix)) {
+            lower = lower.slice(0, -suffix.length).trim();
+        }
+    }
+    // Apply regex-based suffix removals.
+    for (const regex of rules.removeSuffixPatterns) {
+        lower = lower.replace(regex, "").trim();
+    }
+    // Trim configured characters from start/end.
+    if (rules.trimChars && rules.trimChars.length > 0) {
+        const escaped = escapeForCharClass(rules.trimChars);
+        const boundaryRegex = new RegExp(`^[${escaped}]+|[${escaped}]+$`, "g");
+        lower = lower.replace(boundaryRegex, "").trim();
+    }
+    // Collapse common separators to a single space.
+    lower = lower.replace(/[\s_\-]+/g, " ").trim();
+    if (!lower) {
+        return rawName.trim().toLowerCase();
+    }
+    return lower;
+}
+function toDisplayName(normalized, fallback) {
+    const base = normalized || fallback.trim();
+    if (!base)
+        return "<unknown>";
+    return base
+        .split(/\s+/)
+        .map((part) => part.length === 0
+        ? part
+        : part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function normalizeApiDisplayName(rawName, properties) {
+    const name = (rawName || "").trim();
+    if (!name)
+        return name;
+    const lower = name.toLowerCase();
+    const isGenericApiName = lower === "route handler" ||
+        lower.startsWith("nest_controller") ||
+        /^(get|post|put|delete|patch|options|head)\s+/.test(lower);
+    if (!isGenericApiName)
+        return name;
+    const sectionLabel = properties?.section_label;
+    if (typeof sectionLabel === "string" && sectionLabel.trim()) {
+        return `${sectionLabel.trim()} API`;
+    }
+    const sectionId = properties?.section_id;
+    if (typeof sectionId === "string" &&
+        sectionId.trim() &&
+        sectionId !== "root" &&
+        sectionId !== "global" &&
+        sectionId !== "<unsectioned>") {
+        return `${sectionId.trim()} API`;
+    }
+    return "API";
+}

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

@@ -0,0 +1,12 @@
+import type { DetectedComponent, DetectedFromRef } from "../core/types/component";
+import type { SourceLocation } from "../core/types/file";
+export declare function mergeProperties(target: Record<string, unknown>, source: Record<string, unknown>): void;
+export declare function dedupeSourceLocations(locations: SourceLocation[]): SourceLocation[];
+export declare function compareSourceLocations(a: SourceLocation, b: SourceLocation): number;
+export declare function compareDetectedFromRefs(a: DetectedFromRef, b: DetectedFromRef): number;
+/** Map client/database identifiers to a canonical key for merging same logical DB per project. */
+export declare function getDatabaseCanonicalKey(component: DetectedComponent): string;
+export declare function dedupeComponents(components: DetectedComponent[]): DetectedComponent[];
+export declare function mergeGlobalIdentityProviderThirdParties(components: DetectedComponent[]): DetectedComponent[];
+export declare function mergeDatabaseAssetsByType(components: DetectedComponent[]): DetectedComponent[];
+export declare function compactAuthServiceComponents(components: DetectedComponent[]): DetectedComponent[];