@dataparade/cli 0.0.1

package/dist/src/classifier/config.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearClassifierConfigCacheForTest = clearClassifierConfigCacheForTest;
+exports.loadClassifierConfig = loadClassifierConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const zod_1 = require("zod");
+const detection_1 = require("../core/types/detection");
+const thirdPartyEntrySchema = zod_1.z.object({
+    serviceName: zod_1.z.string(),
+    matchKeys: zod_1.z.array(zod_1.z.string()).default([]),
+    type: zod_1.z.literal("third_party"),
+    subType: zod_1.z.string(),
+});
+const rawClassifierConfigSchema = zod_1.z.object({
+    name_normalization: zod_1.z
+        .object({
+        remove_suffixes: zod_1.z.array(zod_1.z.string()).default([]),
+        remove_suffix_patterns: zod_1.z.array(zod_1.z.string()).default([]),
+        trim_chars: zod_1.z.string().default(" _-"),
+    })
+        .default({
+        remove_suffixes: [],
+        remove_suffix_patterns: [],
+        trim_chars: " _-",
+    }),
+    pattern_defaults: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+        type: zod_1.z.enum(["asset", "actor", "third_party"]),
+        subType: zod_1.z.string().optional(),
+        priority: zod_1.z.number().int().optional(),
+    })),
+    database_type_mapping: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.object({
+        subType: zod_1.z.string(),
+    }))
+        .default({}),
+    third_parties: zod_1.z.array(thirdPartyEntrySchema).default([]),
+    resolution: zod_1.z
+        .object({
+        prefer_third_party_over_asset: zod_1.z.boolean().default(true),
+        confidence_aggregation: zod_1.z.enum(["max", "average"]).default("max"),
+    })
+        .default({
+        prefer_third_party_over_asset: true,
+        confidence_aggregation: "max",
+    }),
+    env_variable_exclude_keys: zod_1.z.array(zod_1.z.string()).default([]),
+});
+const rawActorPatternDefaultsSchema = zod_1.z.object({
+    pattern_defaults: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+        type: zod_1.z.enum(["asset", "actor", "third_party"]),
+        subType: zod_1.z.string().optional(),
+        priority: zod_1.z.number().int().optional(),
+    })),
+});
+const thirdPartyCatalogSchema = zod_1.z.object({
+    third_parties: zod_1.z.array(thirdPartyEntrySchema).default([]),
+});
+function validatePatternId(rawValue, context) {
+    const id = String(rawValue);
+    if (!detection_1.PATTERN_IDS.includes(id)) {
+        throw new Error(`Invalid patternId '${rawValue}' in ${context}`);
+    }
+    return id;
+}
+function compileRegex(pattern) {
+    try {
+        return new RegExp(pattern, "i");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown regex compilation error";
+        throw new Error(`Invalid regex pattern '${pattern}': ${message}`);
+    }
+}
+function normalizeRawConfig(raw, actorPatterns) {
+    const nn = raw.name_normalization;
+    const nameNormalization = {
+        removeSuffixes: nn.remove_suffixes.map((s) => s.toLowerCase()),
+        removeSuffixPatterns: nn.remove_suffix_patterns.map((p) => compileRegex(p)),
+        trimChars: nn.trim_chars,
+    };
+    const patternDefaults = [];
+    for (const [patternKey, def] of Object.entries(raw.pattern_defaults)) {
+        const patternId = validatePatternId(patternKey, `pattern_defaults['${patternKey}']`);
+        patternDefaults.push({
+            patternId,
+            type: def.type,
+            subType: def.subType,
+            priority: def.priority ?? 100,
+        });
+    }
+    if (actorPatterns) {
+        for (const [patternKey, def] of Object.entries(actorPatterns.pattern_defaults)) {
+            const patternId = validatePatternId(patternKey, `actor.pattern_defaults['${patternKey}']`);
+            patternDefaults.push({
+                patternId,
+                type: def.type,
+                subType: def.subType,
+                priority: def.priority ?? 100,
+            });
+        }
+    }
+    const databaseTypeMapping = {};
+    for (const [key, value] of Object.entries(raw.database_type_mapping)) {
+        const normalizedKey = key.toLowerCase();
+        databaseTypeMapping[normalizedKey] = {
+            subType: value.subType,
+        };
+    }
+    const thirdParties = normalizeThirdParties(raw.third_parties);
+    const resolution = {
+        preferThirdPartyOverAsset: raw.resolution.prefer_third_party_over_asset ?? true,
+        confidenceAggregation: raw.resolution.confidence_aggregation ?? "max",
+    };
+    const envVariableExcludeKeys = new Set((raw.env_variable_exclude_keys ?? []).map((k) => k.toUpperCase()));
+    return {
+        nameNormalization,
+        patternDefaults,
+        databaseTypeMapping,
+        thirdParties,
+        resolution,
+        envVariableExcludeKeys,
+    };
+}
+function normalizeThirdParties(rawThirdParties) {
+    return rawThirdParties.map((tp) => ({
+        serviceName: tp.serviceName,
+        matchKeys: tp.matchKeys.map((k) => k.toLowerCase()),
+        type: "third_party",
+        subType: tp.subType,
+    }));
+}
+let cachedConfig;
+function clearClassifierConfigCacheForTest() {
+    cachedConfig = undefined;
+}
+function getPatternsFilePath() {
+    const parts = __dirname.split(path_1.default.sep);
+    const distIndex = parts.lastIndexOf("dist");
+    let cliRoot;
+    if (distIndex !== -1) {
+        // e.g. /path/to/cli/dist/src/classifier -> /path/to/cli
+        cliRoot = parts.slice(0, distIndex).join(path_1.default.sep);
+    }
+    else {
+        // e.g. /path/to/cli/src/classifier -> /path/to/cli
+        cliRoot = path_1.default.resolve(__dirname, "..", "..");
+    }
+    return path_1.default.join(cliRoot, "patterns", "classifier", "components.classifier.yaml");
+}
+function loadClassifierConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const configPath = getPatternsFilePath();
+    const thirdPartyConfigPath = (() => {
+        const parts = __dirname.split(path_1.default.sep);
+        const distIndex = parts.lastIndexOf("dist");
+        let cliRoot;
+        if (distIndex !== -1) {
+            cliRoot = parts.slice(0, distIndex).join(path_1.default.sep);
+        }
+        else {
+            cliRoot = path_1.default.resolve(__dirname, "..", "..");
+        }
+        return path_1.default.join(cliRoot, "patterns", "classifier", "third-party.classifier.yaml");
+    })();
+    const actorPatternsPath = (() => {
+        const parts = __dirname.split(path_1.default.sep);
+        const distIndex = parts.lastIndexOf("dist");
+        let cliRoot;
+        if (distIndex !== -1) {
+            cliRoot = parts.slice(0, distIndex).join(path_1.default.sep);
+        }
+        else {
+            cliRoot = path_1.default.resolve(__dirname, "..", "..");
+        }
+        return path_1.default.join(cliRoot, "patterns", "classifier", "actors.classifier.yaml");
+    })();
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(configPath, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Classifier config is required but could not be read from '${configPath}': ${message}`);
+    }
+    let parsed;
+    try {
+        parsed = yaml_1.default.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Classifier config at '${configPath}' could not be parsed as YAML: ${message}`);
+    }
+    let rawConfig;
+    try {
+        rawConfig = rawClassifierConfigSchema.parse(parsed);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Classifier config at '${configPath}' failed schema validation: ${message}`);
+    }
+    let actorPatterns;
+    try {
+        const rawActors = fs_1.default.readFileSync(actorPatternsPath, "utf8");
+        const parsedActors = yaml_1.default.parse(rawActors);
+        actorPatterns = rawActorPatternDefaultsSchema.parse(parsedActors);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Classifier actor config at '${actorPatternsPath}' could not be loaded or validated: ${message}`);
+    }
+    let normalized;
+    try {
+        normalized = normalizeRawConfig(rawConfig, actorPatterns);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Classifier config at '${configPath}' is invalid: ${message}`);
+    }
+    let thirdPartyRaw;
+    try {
+        thirdPartyRaw = fs_1.default.readFileSync(thirdPartyConfigPath, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Third-party classifier catalog is required but could not be read from '${thirdPartyConfigPath}': ${message}`);
+    }
+    let thirdPartyParsed;
+    try {
+        thirdPartyParsed = yaml_1.default.parse(thirdPartyRaw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Third-party classifier catalog at '${thirdPartyConfigPath}' could not be parsed as YAML: ${message}`);
+    }
+    let thirdPartyRawConfig;
+    try {
+        thirdPartyRawConfig = thirdPartyCatalogSchema.parse(thirdPartyParsed);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Third-party classifier catalog at '${thirdPartyConfigPath}' failed schema validation: ${message}`);
+    }
+    try {
+        const extraThirdParties = normalizeThirdParties(thirdPartyRawConfig.third_parties);
+        normalized.thirdParties = [...normalized.thirdParties, ...extraThirdParties];
+        cachedConfig = normalized;
+        return normalized;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Third-party classifier catalog at '${thirdPartyConfigPath}' is invalid: ${message}`);
+    }
+}

package/dist/src/classifier/enhance-defaults.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Default values for all Engineering, Privacy, and Security properties
+ * per DataParade property models (Asset, Third Party, Actor).
+ *
+ * Property keys use snake_case to match backend DB column names
+ * (e.g. diagram_asset_contexts.hosting_type, technology_stack, encrypt_at_rest).
+ * Frontend API mappers accept both snake_case and camelCase when reading.
+ *
+ * Pattern detection (patterns/property.patterns.yaml + property-detection.ts) can set
+ * a subset of these from code/env/config; see DETECTABLE_PROPERTY_KEYS below.
+ * The rest are defaults-only (e.g. technical_owner, dpa_expiry_date) until we add
+ * detection rules or user input. Total: Asset ~115, Third Party ~90, Actor ~35 keys.
+ */
+export type PropertyDefaults = Record<string, unknown>;
+/** Property keys that can be set by pattern detection (findings → component properties). */
+export declare const DETECTABLE_PROPERTY_KEYS: ReadonlySet<string>;
+/** All Asset properties (Engineering + Privacy + Security) from ASSET_PROPERTY_MODEL. */
+export declare const ASSET_PROPERTY_DEFAULTS: PropertyDefaults;
+/** Backend DB column names (snake_case) for asset context - align property keys with these where applicable. */
+export declare const ASSET_CONTEXT_DB_COLUMNS: readonly ["hosting_type", "technology_stack", "cloud_provider", "region", "programming_language", "repository_url", "encrypt_at_rest", "access_controls", "access_control", "audit_logging_enabled", "data_categories", "data_retention_period_days", "data_deletion_process", "anonymization_capabilities", "pseudonymization_capabilities", "data_subject_categories", "processing_purpose", "supported_operations"];
+/** All Third Party properties (Engineering + Privacy + Security) from THIRD_PARTY_PROPERTY_MODEL. */
+export declare const THIRD_PARTY_PROPERTY_DEFAULTS: PropertyDefaults;
+/** All Actor properties (Engineering + Privacy + Security) from ACTOR_PROPERTY_MODEL. */
+export declare const ACTOR_PROPERTY_DEFAULTS: PropertyDefaults;
+/**
+ * Returns the full property defaults for the given component type.
+ */
+export declare function getDefaultsForType(type: "asset" | "actor" | "third_party"): PropertyDefaults;

package/dist/src/classifier/enhance-defaults.js

@@ -0,0 +1,369 @@
+"use strict";
+/**
+ * Default values for all Engineering, Privacy, and Security properties
+ * per DataParade property models (Asset, Third Party, Actor).
+ *
+ * Property keys use snake_case to match backend DB column names
+ * (e.g. diagram_asset_contexts.hosting_type, technology_stack, encrypt_at_rest).
+ * Frontend API mappers accept both snake_case and camelCase when reading.
+ *
+ * Pattern detection (patterns/property.patterns.yaml + property-detection.ts) can set
+ * a subset of these from code/env/config; see DETECTABLE_PROPERTY_KEYS below.
+ * The rest are defaults-only (e.g. technical_owner, dpa_expiry_date) until we add
+ * detection rules or user input. Total: Asset ~115, Third Party ~90, Actor ~35 keys.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTOR_PROPERTY_DEFAULTS = exports.THIRD_PARTY_PROPERTY_DEFAULTS = exports.ASSET_CONTEXT_DB_COLUMNS = exports.ASSET_PROPERTY_DEFAULTS = exports.DETECTABLE_PROPERTY_KEYS = void 0;
+exports.getDefaultsForType = getDefaultsForType;
+/** Property keys that can be set by pattern detection (findings → component properties). */
+exports.DETECTABLE_PROPERTY_KEYS = new Set([
+    "mfa_required",
+    "authentication_method",
+    "audit_logging_enabled",
+    "cloud_provider",
+    "encrypt_at_rest",
+    "connection_encryption",
+    "integration_method",
+    "request_validation",
+    "region_location",
+    "key_rotation_period",
+    "backup_frequency",
+    "backup_encryption",
+    "sso_integration",
+    "https_enforced",
+    "api_type",
+    "request_logging_level",
+    "data_retention_period_days",
+    "ip_allowlisting",
+    "vendor_jurisdiction",
+    "documentation_url",
+    "api_version",
+    "integration_status",
+    "service_url_api_endpoint",
+    "sdk_available",
+    "code_reference_package",
+]);
+/** All Asset properties (Engineering + Privacy + Security) from ASSET_PROPERTY_MODEL. */
+exports.ASSET_PROPERTY_DEFAULTS = {
+    // Engineering (common + database, application, service, api, config, etc.)
+    cloud_provider: null,
+    region_location: null,
+    technical_owner: null,
+    technology_stack: null,
+    hosting_type: null,
+    vendor: null,
+    version: null,
+    network_zone: null,
+    programming_language: null,
+    repository_url: null,
+    sdk_third_party_libraries: [],
+    database_engine: null,
+    high_availability_configuration: null,
+    read_replicas: false,
+    data_catalog_integration: null,
+    schema_enforcement: null,
+    infrastructure_type: null,
+    physical_deployment_location: null,
+    remote_access_capability: false,
+    service_tier_plan: null,
+    api_endpoint: null,
+    integration_method: [],
+    vendor_support_contact: null,
+    website_type: null,
+    cdn_provider: null,
+    static_vs_dynamic: null,
+    api_type: null,
+    api_versioning_strategy: null,
+    api_documentation_url: null,
+    rate_limiting: null,
+    api_visibility: null,
+    storage_service: null,
+    storage_class: null,
+    object_naming_convention: null,
+    app_store_urls: null,
+    distribution_method: null,
+    minimum_os_version: null,
+    disaster_recovery_setup: null,
+    failover_configuration: null,
+    waf_provider: null,
+    api_gateway: null,
+    backup_frequency: null,
+    backup_location: null,
+    default_credentials_changed: false,
+    network_segmentation: false,
+    intrusion_detection: false,
+    ddos_protection: false,
+    physical_security_measures: null,
+    vendor_soc2_iso27001: [],
+    // Privacy (common)
+    data_categories: [],
+    data_subject_categories: [],
+    processing_purpose: [],
+    supported_operations: null,
+    data_retention_period_days: null,
+    data_deletion_process: null,
+    anonymization_capabilities: false,
+    pseudonymization_capabilities: false,
+    vendor_jurisdiction: null,
+    data_residency_options: null,
+    data_processing_agreement_dpa: false,
+    dpa_expiry_date: null,
+    row_level_security: false,
+    column_level_encryption: false,
+    audit_table_exists: false,
+    data_classification: false,
+    sensitive_data_masking: false,
+    request_logging_level: null,
+    pii_in_request_response: false,
+    temporary_storage: false,
+    temporary_storage_duration: null,
+    cookie_usage: [],
+    cookie_consent_banner: false,
+    analytics_tools: [],
+    third_party_embeds: [],
+    user_accounts_required: false,
+    app_permissions_requested: [],
+    offline_functionality: false,
+    background_data_collection: false,
+    analytics_sdks: [],
+    local_data_storage: false,
+    // Security (common)
+    encrypt_at_rest: null,
+    key_rotation_period: null,
+    key_rotation: null,
+    pen_testing: false,
+    pen_test_frequency: null,
+    audit_logging_enabled: false,
+    access_control: null,
+    risk_rating: null,
+    backup_encryption: false,
+    point_in_time_recovery: false,
+    multi_region_replication: false,
+    database_firewall_rules: null,
+    connection_encryption: false,
+    ip_allowlisting: false,
+    sso_integration: false,
+    session_timeout_configuration: null,
+    request_validation: false,
+    response_filtering: false,
+    authentication_methods: [],
+    waf_web_application_firewall: false,
+    content_security_policy: false,
+    https_enforced: false,
+    security_headers: [],
+    cors_configuration: null,
+    access_logging: false,
+    versioning_enabled: false,
+    bucket_container_public_access: null,
+    lifecycle_policies: false,
+    cross_region_replication: false,
+    object_lock_immutability: false,
+    certificate_pinning: false,
+    jailbreak_root_detection: false,
+    code_obfuscation: false,
+    // isMainApplication omitted: only set to true on first api/service in enhanceComponents; others stay undefined
+};
+/** Backend DB column names (snake_case) for asset context - align property keys with these where applicable. */
+exports.ASSET_CONTEXT_DB_COLUMNS = [
+    "hosting_type",
+    "technology_stack",
+    "cloud_provider",
+    "region",
+    "programming_language",
+    "repository_url",
+    "encrypt_at_rest",
+    "access_controls",
+    "access_control",
+    "audit_logging_enabled",
+    "data_categories",
+    "data_retention_period_days",
+    "data_deletion_process",
+    "anonymization_capabilities",
+    "pseudonymization_capabilities",
+    "data_subject_categories",
+    "processing_purpose",
+    "supported_operations",
+];
+/** All Third Party properties (Engineering + Privacy + Security) from THIRD_PARTY_PROPERTY_MODEL. */
+exports.THIRD_PARTY_PROPERTY_DEFAULTS = {
+    // Engineering
+    technical_owner_team: null,
+    integration_method: null,
+    service_url_api_endpoint: null,
+    authentication_method: null,
+    integration_status: null,
+    documentation_url: null,
+    api_version: null,
+    technical_function: null,
+    service_tier_plan: null,
+    vendor: null,
+    rate_limits: null,
+    code_reference_package: null,
+    sla_uptime_guarantee: null,
+    vendor_support_contact: null,
+    customer_tier_plan: null,
+    customer_environment: null,
+    supported_export_formats: [],
+    webhook_endpoints_configured: false,
+    onboarding_status: null,
+    payment_methods_supported: [],
+    settlement_currency: [],
+    sandbox_test_environment: false,
+    webhook_events_configured: [],
+    cloud_services_used: [],
+    regions_availability_zones: [],
+    account_id: null,
+    support_plan: null,
+    resource_tagging_policy: false,
+    infrastructure_as_code: false,
+    api_type: null,
+    sdk_available: false,
+    response_format: [],
+    average_latency: null,
+    data_delivery_method: null,
+    update_frequency: null,
+    data_format: [],
+    data_volume: null,
+    etl_pipeline: null,
+    submission_method: null,
+    submission_frequency: null,
+    portal_url: null,
+    required_formats: [],
+    automated_submission: false,
+    // Privacy
+    gdpr_role: null,
+    processing_purpose: [],
+    data_processing_agreement_dpa: false,
+    dpa_expiry_date: null,
+    data_transfer_mechanism: null,
+    vendor_jurisdiction_country: null,
+    adequacy_decision_country: false,
+    privacy_policy_url: null,
+    customer_jurisdiction: null,
+    end_user_data_involved: false,
+    data_portability_obligations: false,
+    data_retention_period_days: null,
+    data_residency: null,
+    sub_processors: [],
+    right_to_deletion_support: false,
+    data_export_capability: false,
+    data_minimization_practices: null,
+    pci_scope: null,
+    cardholder_data_stored: false,
+    tokenization_used: false,
+    processing_locations: [],
+    data_encryption_managed_by: null,
+    mandatory_reporting_requirements: null,
+    legal_basis: null,
+    data_minimization_required: false,
+    retention_requirements_imposed: null,
+    pii_in_requests: false,
+    pii_in_responses: false,
+    temporary_data_storage_by_provider: false,
+    temporary_storage_duration: null,
+    source_data_collection_method: null,
+    legal_basis_for_provider_collection: null,
+    data_accuracy_guarantee: false,
+    data_categories_received: [],
+    // Security
+    encrypt_at_rest: null,
+    key_rotation_period: null,
+    compliance_certifications: [],
+    risk_rating: null,
+    last_assessment_date: null,
+    security_questionnaire_completed: false,
+    pen_testing: false,
+    pen_test_frequency: null,
+    audit_logging_enabled: false,
+    customer_security_requirements: null,
+    data_isolation_level: null,
+    tenant_isolation_type: null,
+    customer_compliance_requirements: [],
+    vendor_soc2_iso27001: [],
+    sso_integration: false,
+    ip_allowlisting: false,
+    session_timeout_configuration: null,
+    vendor_security_contact: null,
+    pci_dss_level: null,
+    pci_dss_validated: false,
+    fraud_detection_capabilities: false,
+    three_d_secure_support: false,
+    shared_responsibility_model_documented: false,
+    iam_configuration: null,
+    network_controls: [],
+    compliance_programs: [],
+    api_key_management: null,
+    mtls_support: false,
+    request_signing: false,
+    https_enforced: false,
+    delivery_encryption: false,
+    data_integrity_checks: false,
+    access_controls_for_delivery: null,
+    secure_submission_channel: false,
+    authentication_required: false,
+    audit_trail_required: false,
+    encryption_in_transit: false,
+    digital_signature_required: false,
+    hosting_type: null,
+};
+/** All Actor properties (Engineering + Privacy + Security) from ACTOR_PROPERTY_MODEL. */
+exports.ACTOR_PROPERTY_DEFAULTS = {
+    // Engineering
+    actions: [],
+    authentication_method: null,
+    access_method: [],
+    session_duration: null,
+    customer_tier: null,
+    connected_asset: null,
+    access_role: null,
+    department_team: null,
+    authorization_model: null,
+    access_granularity: null,
+    provisioning_method: null,
+    access_frequency: null,
+    access_environment: [],
+    ip_restriction: false,
+    acl_reference: null,
+    privileged_access: false,
+    breakglass_access: false,
+    temporary_access: false,
+    emergency_access_procedure: null,
+    deprovisioning_process: null,
+    // Privacy
+    isDataSubject: false,
+    data_categories_provided: [],
+    processing_purpose: [],
+    consent_required: false,
+    jurisdiction_location: null,
+    data_view_filtering: null,
+    purpose_limitation_enforced: false,
+    data_minimization_applied: false,
+    privacy_training_completed: false,
+    data_access_scope: null,
+    cross_border_access: false,
+    // Security
+    risk_rating: null,
+    mfa_required: false,
+    account_expiry: false,
+    account_expiry_date: null,
+    least_privilege_enforced: false,
+    separation_of_duties: false,
+    need_to_know: false,
+    access_review_frequency: null,
+    last_access_review_date: null,
+    security_training_completed: false,
+    background_check_completed: false,
+};
+/**
+ * Returns the full property defaults for the given component type.
+ */
+function getDefaultsForType(type) {
+    switch (type) {
+        case "asset":
+            return { ...exports.ASSET_PROPERTY_DEFAULTS };
+        case "third_party":
+            return { ...exports.THIRD_PARTY_PROPERTY_DEFAULTS };
+        case "actor":
+            return { ...exports.ACTOR_PROPERTY_DEFAULTS };
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { DetectedComponent } from "../core/types/component";
+/**
+ * Enhances a single component with defaults for all inferrable properties
+ * per node type (asset, actor, third_party). Does not set isMainApplication
+ * (that is applied in enhanceComponents).
+ */
+export declare function enhanceComponent(component: DetectedComponent): DetectedComponent;
+/**
+ * Enhances all components with defaults for all node types, then sets
+ * isMainApplication on a "primary" app asset per section_id (framework-aware),
+ * and normalizes generic API display names.
+ */
+export declare function enhanceComponents(components: DetectedComponent[]): DetectedComponent[];