@trafficgroup/knex-rel 0.1.11 → 0.1.12

package/src/dao/report-configuration/report-configuration.dao.ts

@@ -1,10 +1,10 @@
 import { Knex } from "knex";
 import { IBaseDAO, IDataPaginator } from "../../d.types";
 import {
-    IReportConfiguration,
-    IReportConfigurationData,
-    IReportConfigurationInput,
-    IValidationResult
+  IReportConfiguration,
+  IReportConfigurationData,
+  IReportConfigurationInput,
+  IValidationResult,
 } from "../../interfaces/report-configuration/report-configuration.interfaces";
 import KnexManager from "../../KnexConnection";
 
@@ -23,377 +23,405 @@ import KnexManager from "../../KnexConnection";
  * Non-motorized vehicles (pedestrian, bicycle, non_motorized_vehicle) are EXCLUDED
  */
 const DETECTION_LABEL_TO_FHWA: Record<string, number[]> = {
-    'motorcycle': [1],
-    'car': [2],
-    'pickup_truck': [3],
-    'motorized_vehicle': [3],  // Maps to Class 3 (same as pickup_truck)
-    'bus': [4],
-    'work_van': [5],
-    'single_unit_truck': [6, 7, 8],      // Classes 6-8
-    'articulated_truck': [9, 10, 11, 12, 13]  // Classes 9-13
-    // pedestrian, bicycle, non_motorized_vehicle are EXCLUDED
+  motorcycle: [1],
+  car: [2],
+  pickup_truck: [3],
+  motorized_vehicle: [3], // Maps to Class 3 (same as pickup_truck)
+  bus: [4],
+  work_van: [5],
+  single_unit_truck: [6, 7, 8], // Classes 6-8
+  articulated_truck: [9, 10, 11, 12, 13], // Classes 9-13
+  // pedestrian, bicycle, non_motorized_vehicle are EXCLUDED
 };
 
 export class ReportConfigurationDAO implements IBaseDAO<IReportConfiguration> {
-    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
-    private tableName = "report_configurations";
-
-    /**
-     * Create a new report configuration
-     */
-    async create(item: IReportConfigurationInput): Promise<IReportConfiguration> {
-        // Validate configuration before creating
-        const validation = this.validateConfiguration(item.configuration);
-        if (!validation.valid) {
-            throw new Error(`Invalid configuration: ${validation.errors.join(', ')}`);
-        }
-
-        const [createdConfig] = await this._knex(this.tableName)
-            .insert({
-                name: item.name,
-                description: item.description,
-                configuration: JSON.stringify(item.configuration)
-            })
-            .returning("*");
-
-        return this._deserialize(createdConfig);
+  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+  private tableName = "report_configurations";
+
+  /**
+   * Create a new report configuration
+   */
+  async create(item: IReportConfigurationInput): Promise<IReportConfiguration> {
+    // Validate configuration before creating
+    const validation = this.validateConfiguration(item.configuration);
+    if (!validation.valid) {
+      throw new Error(`Invalid configuration: ${validation.errors.join(", ")}`);
     }
 
-    /**
-     * Get configuration by numeric ID
-     */
-    async getById(id: number): Promise<IReportConfiguration | null> {
-        const config = await this._knex(this.tableName).where({ id }).first();
-        return config ? this._deserialize(config) : null;
+    const [createdConfig] = await this._knex(this.tableName)
+      .insert({
+        name: item.name,
+        description: item.description,
+        configuration: JSON.stringify(item.configuration),
+      })
+      .returning("*");
+
+    return this._deserialize(createdConfig);
+  }
+
+  /**
+   * Get configuration by numeric ID
+   */
+  async getById(id: number): Promise<IReportConfiguration | null> {
+    const config = await this._knex(this.tableName).where({ id }).first();
+    return config ? this._deserialize(config) : null;
+  }
+
+  /**
+   * Get configuration by UUID
+   */
+  async getByUuid(uuid: string): Promise<IReportConfiguration | null> {
+    const config = await this._knex(this.tableName).where({ uuid }).first();
+    return config ? this._deserialize(config) : null;
+  }
+
+  /**
+   * Get configuration by name
+   */
+  async getByName(name: string): Promise<IReportConfiguration | null> {
+    const config = await this._knex(this.tableName)
+      .whereRaw("LOWER(name) = LOWER(?)", [name])
+      .first();
+    return config ? this._deserialize(config) : null;
+  }
+
+  /**
+   * Update a configuration
+   */
+  async update(
+    id: number,
+    item: Partial<IReportConfigurationInput>,
+  ): Promise<IReportConfiguration | null> {
+    // If configuration is being updated, validate it
+    if (item.configuration) {
+      const validation = this.validateConfiguration(item.configuration);
+      if (!validation.valid) {
+        throw new Error(
+          `Invalid configuration: ${validation.errors.join(", ")}`,
+        );
+      }
     }
 
-    /**
-     * Get configuration by UUID
-     */
-    async getByUuid(uuid: string): Promise<IReportConfiguration | null> {
-        const config = await this._knex(this.tableName).where({ uuid }).first();
-        return config ? this._deserialize(config) : null;
+    const updateData: any = {};
+    if (item.name !== undefined) updateData.name = item.name;
+    if (item.description !== undefined)
+      updateData.description = item.description;
+    if (item.configuration !== undefined)
+      updateData.configuration = JSON.stringify(item.configuration);
+
+    const [updatedConfig] = await this._knex(this.tableName)
+      .where({ id })
+      .update(updateData)
+      .returning("*");
+
+    return updatedConfig ? this._deserialize(updatedConfig) : null;
+  }
+
+  /**
+   * Delete a configuration
+   * Prevents deletion of the last configuration (business logic protection)
+   */
+  async delete(id: number): Promise<boolean> {
+    // Count total configurations
+    const [{ count }] = await this._knex(this.tableName).count("* as count");
+
+    if (parseInt(count as string) <= 1) {
+      throw new Error(
+        "Cannot delete the last configuration. At least one configuration must exist.",
+      );
     }
 
-    /**
-     * Get configuration by name
-     */
-    async getByName(name: string): Promise<IReportConfiguration | null> {
-        const config = await this._knex(this.tableName)
-            .whereRaw("LOWER(name) = LOWER(?)", [name])
-            .first();
-        return config ? this._deserialize(config) : null;
+    const result = await this._knex(this.tableName).where({ id }).del();
+    return result > 0;
+  }
+
+  /**
+   * Get all configurations with pagination
+   */
+  async getAll(
+    page: number,
+    limit: number,
+  ): Promise<IDataPaginator<IReportConfiguration>> {
+    const offset = (page - 1) * limit;
+
+    const [countResult] = await this._knex(this.tableName).count("* as count");
+    const totalCount = +countResult.count;
+    const configs = await this._knex(this.tableName)
+      .limit(limit)
+      .offset(offset)
+      .orderBy("created_at", "desc");
+
+    return {
+      success: true,
+      data: configs.map((c) => this._deserialize(c)),
+      page,
+      limit,
+      count: configs.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
+
+  /**
+   * Validate a report configuration
+   *
+   * Rules:
+   * - Minimum 2, maximum 7 custom classes
+   * - Custom class names must be 1-30 characters
+   * - FHWA classes must be in range 1-13
+   * - Each FHWA class can only be mapped to one custom class (no duplicates)
+   * - Each custom class must have at least one FHWA class
+   */
+  validateConfiguration(config: IReportConfigurationData): IValidationResult {
+    const errors: string[] = [];
+
+    // Validate version exists
+    if (!config.version) {
+      errors.push("Configuration version is required");
     }
 
-    /**
-     * Update a configuration
-     */
-    async update(id: number, item: Partial<IReportConfigurationInput>): Promise<IReportConfiguration | null> {
-        // If configuration is being updated, validate it
-        if (item.configuration) {
-            const validation = this.validateConfiguration(item.configuration);
-            if (!validation.valid) {
-                throw new Error(`Invalid configuration: ${validation.errors.join(', ')}`);
-            }
-        }
-
-        const updateData: any = {};
-        if (item.name !== undefined) updateData.name = item.name;
-        if (item.description !== undefined) updateData.description = item.description;
-        if (item.configuration !== undefined) updateData.configuration = JSON.stringify(item.configuration);
-
-        const [updatedConfig] = await this._knex(this.tableName)
-            .where({ id })
-            .update(updateData)
-            .returning("*");
-
-        return updatedConfig ? this._deserialize(updatedConfig) : null;
+    // Validate custom classes array
+    if (!config.customClasses || !Array.isArray(config.customClasses)) {
+      errors.push("customClasses must be an array");
+      return { valid: false, errors };
     }
 
-    /**
-     * Delete a configuration
-     * Prevents deletion of the last configuration (business logic protection)
-     */
-    async delete(id: number): Promise<boolean> {
-        // Count total configurations
-        const [{ count }] = await this._knex(this.tableName).count('* as count');
-
-        if (parseInt(count as string) <= 1) {
-            throw new Error('Cannot delete the last configuration. At least one configuration must exist.');
-        }
-
-        const result = await this._knex(this.tableName).where({ id }).del();
-        return result > 0;
+    // Min 2, max 7 custom classes
+    if (config.customClasses.length < 2) {
+      errors.push("Minimum 2 custom classes required");
     }
-
-    /**
-     * Get all configurations with pagination
-     */
-    async getAll(page: number, limit: number): Promise<IDataPaginator<IReportConfiguration>> {
-        const offset = (page - 1) * limit;
-
-        const [countResult] = await this._knex(this.tableName).count("* as count");
-        const totalCount = +countResult.count;
-        const configs = await this._knex(this.tableName)
-            .limit(limit)
-            .offset(offset)
-            .orderBy("created_at", "desc");
-
-        return {
-            success: true,
-            data: configs.map(c => this._deserialize(c)),
-            page,
-            limit,
-            count: configs.length,
-            totalCount,
-            totalPages: Math.ceil(totalCount / limit),
-        };
+    if (config.customClasses.length > 7) {
+      errors.push("Maximum 7 custom classes allowed");
     }
 
-    /**
-     * Validate a report configuration
-     *
-     * Rules:
-     * - Minimum 2, maximum 7 custom classes
-     * - Custom class names must be 1-30 characters
-     * - FHWA classes must be in range 1-13
-     * - Each FHWA class can only be mapped to one custom class (no duplicates)
-     * - Each custom class must have at least one FHWA class
-     */
-    validateConfiguration(config: IReportConfigurationData): IValidationResult {
-        const errors: string[] = [];
-
-        // Validate version exists
-        if (!config.version) {
-            errors.push('Configuration version is required');
-        }
-
-        // Validate custom classes array
-        if (!config.customClasses || !Array.isArray(config.customClasses)) {
-            errors.push('customClasses must be an array');
-            return { valid: false, errors };
-        }
-
-        // Min 2, max 7 custom classes
-        if (config.customClasses.length < 2) {
-            errors.push('Minimum 2 custom classes required');
-        }
-        if (config.customClasses.length > 7) {
-            errors.push('Maximum 7 custom classes allowed');
-        }
-
-        // Check name length (max 30 chars) and FHWA classes validity
-        const allFhwaClasses: number[] = [];
-        config.customClasses.forEach((cls, idx) => {
-            if (!cls.name || cls.name.length === 0) {
-                errors.push(`Custom class ${idx + 1}: name cannot be empty`);
-            }
-            if (cls.name && cls.name.toLowerCase() === 'total') {
-                errors.push(`Custom class ${idx + 1}: "Total" is a reserved name and cannot be used`);
-            }
-            if (cls.name && cls.name.length > 30) {
-                errors.push(`Custom class ${idx + 1}: name exceeds 30 characters`);
-            }
-
-            if (!Array.isArray(cls.fhwaClasses) || cls.fhwaClasses.length === 0) {
-                errors.push(`Custom class ${idx + 1}: must have at least one FHWA class`);
-            } else {
-                cls.fhwaClasses.forEach(fhwa => {
-                    if (!Number.isInteger(fhwa) || fhwa < 1 || fhwa > 13) {
-                        errors.push(`Custom class ${idx + 1}: FHWA class ${fhwa} is invalid (must be 1-13)`);
-                    }
-                    allFhwaClasses.push(fhwa);
-                });
-            }
+    // Check name length (max 30 chars) and FHWA classes validity
+    const allFhwaClasses: number[] = [];
+    config.customClasses.forEach((cls, idx) => {
+      if (!cls.name || cls.name.length === 0) {
+        errors.push(`Custom class ${idx + 1}: name cannot be empty`);
+      }
+      if (cls.name && cls.name.toLowerCase() === "total") {
+        errors.push(
+          `Custom class ${idx + 1}: "Total" is a reserved name and cannot be used`,
+        );
+      }
+      if (cls.name && cls.name.length > 30) {
+        errors.push(`Custom class ${idx + 1}: name exceeds 30 characters`);
+      }
+
+      if (!Array.isArray(cls.fhwaClasses) || cls.fhwaClasses.length === 0) {
+        errors.push(
+          `Custom class ${idx + 1}: must have at least one FHWA class`,
+        );
+      } else {
+        cls.fhwaClasses.forEach((fhwa) => {
+          if (!Number.isInteger(fhwa) || fhwa < 1 || fhwa > 13) {
+            errors.push(
+              `Custom class ${idx + 1}: FHWA class ${fhwa} is invalid (must be 1-13)`,
+            );
+          }
+          allFhwaClasses.push(fhwa);
         });
-
-        // Check for duplicate FHWA classes (many-to-one only)
-        const uniqueFhwaClasses = new Set(allFhwaClasses);
-        if (uniqueFhwaClasses.size !== allFhwaClasses.length) {
-            const duplicates = allFhwaClasses.filter((item, index) => allFhwaClasses.indexOf(item) !== index);
-            errors.push(`Duplicate FHWA classes detected: ${[...new Set(duplicates)].join(', ')}. Each FHWA class can only be mapped to one custom class.`);
-        }
-
-        return { valid: errors.length === 0, errors };
+      }
+    });
+
+    // Check for duplicate FHWA classes (many-to-one only)
+    const uniqueFhwaClasses = new Set(allFhwaClasses);
+    if (uniqueFhwaClasses.size !== allFhwaClasses.length) {
+      const duplicates = allFhwaClasses.filter(
+        (item, index) => allFhwaClasses.indexOf(item) !== index,
+      );
+      errors.push(
+        `Duplicate FHWA classes detected: ${[...new Set(duplicates)].join(", ")}. Each FHWA class can only be mapped to one custom class.`,
+      );
     }
 
-    /**
-     * Apply configuration transformation to detection results
-     *
-     * Two-step transformation:
-     * 1. Detection labels → FHWA classes (using DETECTION_LABEL_TO_FHWA mapping)
-     * 2. FHWA classes → Custom classes (using configuration)
-     *
-     * @param detectionResults - Raw detection results with labels as keys and counts as values
-     *                          Example: { 'car': 150, 'articulated_truck': 23, 'motorcycle': 5 }
-     * @param config - The report configuration to apply
-     * @returns Transformed results with custom class names as keys and counts as values
-     *          Example: { 'Cars': 155, 'Heavy Trucks': 23 }
-     */
-    applyConfiguration(
-        detectionResults: Record<string, number>,
-        config: IReportConfiguration
-    ): Record<string, number> {
-        // Step 1: Detection labels → FHWA classes
-        const fhwaClassCounts: Record<number, number> = {};
-
-        for (const [label, count] of Object.entries(detectionResults)) {
-            const fhwaClasses = DETECTION_LABEL_TO_FHWA[label];
-            if (fhwaClasses && fhwaClasses.length > 0) {
-                fhwaClasses.forEach(fhwaClass => {
-                    fhwaClassCounts[fhwaClass] = (fhwaClassCounts[fhwaClass] || 0) + count;
-                });
-            }
-            // Labels not in DETECTION_LABEL_TO_FHWA are silently ignored (e.g., pedestrian, bicycle)
-        }
-
-        // Step 2: FHWA classes → Custom classes
-        const customClassCounts: Record<string, number> = {};
-
-        config.configuration.customClasses.forEach(customClass => {
-            let total = 0;
-            customClass.fhwaClasses.forEach(fhwaClass => {
-                total += fhwaClassCounts[fhwaClass] || 0;
-            });
-            customClassCounts[customClass.name] = total;
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Apply configuration transformation to detection results
+   *
+   * Two-step transformation:
+   * 1. Detection labels → FHWA classes (using DETECTION_LABEL_TO_FHWA mapping)
+   * 2. FHWA classes → Custom classes (using configuration)
+   *
+   * @param detectionResults - Raw detection results with labels as keys and counts as values
+   *                          Example: { 'car': 150, 'articulated_truck': 23, 'motorcycle': 5 }
+   * @param config - The report configuration to apply
+   * @returns Transformed results with custom class names as keys and counts as values
+   *          Example: { 'Cars': 155, 'Heavy Trucks': 23 }
+   */
+  applyConfiguration(
+    detectionResults: Record<string, number>,
+    config: IReportConfiguration,
+  ): Record<string, number> {
+    // Step 1: Detection labels → FHWA classes
+    const fhwaClassCounts: Record<number, number> = {};
+
+    for (const [label, count] of Object.entries(detectionResults)) {
+      const fhwaClasses = DETECTION_LABEL_TO_FHWA[label];
+      if (fhwaClasses && fhwaClasses.length > 0) {
+        fhwaClasses.forEach((fhwaClass) => {
+          fhwaClassCounts[fhwaClass] =
+            (fhwaClassCounts[fhwaClass] || 0) + count;
         });
-
-        return customClassCounts;
+      }
+      // Labels not in DETECTION_LABEL_TO_FHWA are silently ignored (e.g., pedestrian, bicycle)
     }
 
-    /**
-     * Transform nested vehicle structure with custom class mapping
-     *
-     * Handles both ATR (lane-based) and TMC (direction/turn-based) formats
-     * Preserves all nesting levels while transforming detection labels to custom classes
-     *
-     * @param vehiclesStructure - Nested vehicles object with detection labels as keys
-     *                           ATR: { "car": { "0": 45, "1": 50 }, ... }
-     *                           TMC: { "car": { "NORTH": { "straight": 10 }, ... }, ... }
-     * @param config - Report configuration with custom class mappings
-     * @returns Transformed structure with custom class names as keys
-     */
-    applyConfigurationToNestedStructure(
-        vehiclesStructure: Record<string, any>,
-        config: IReportConfiguration
-    ): Record<string, any> {
-        // Build reverse mapping: detection label → custom class name
-        const detectionToCustomClass: Record<string, string> = {};
-
-        for (const customClass of config.configuration.customClasses) {
-            // For each FHWA class in this custom class
-            for (const fhwaClass of customClass.fhwaClasses) {
-                // Find all detection labels that map to this FHWA class
-                for (const [label, fhwaClasses] of Object.entries(DETECTION_LABEL_TO_FHWA)) {
-                    if (fhwaClasses.includes(fhwaClass)) {
-                        detectionToCustomClass[label] = customClass.name;
-                    }
-                }
-            }
-        }
-
-        // Initialize empty structure for each custom class
-        const result: Record<string, any> = {};
-        for (const customClass of config.configuration.customClasses) {
-            result[customClass.name] = {};
-        }
-
-        // Iterate through detection labels in input structure
-        for (const [detectionLabel, nestedData] of Object.entries(vehiclesStructure)) {
-            const customClassName = detectionToCustomClass[detectionLabel];
-
-            // Skip labels not mapped to any custom class (e.g., pedestrian, bicycle)
-            if (!customClassName) {
-                continue;
-            }
-
-            // Deep merge nested data into custom class accumulator
-            result[customClassName] = this._deepMergeNumericData(
-                result[customClassName],
-                nestedData
-            );
+    // Step 2: FHWA classes → Custom classes
+    const customClassCounts: Record<string, number> = {};
+
+    config.configuration.customClasses.forEach((customClass) => {
+      let total = 0;
+      customClass.fhwaClasses.forEach((fhwaClass) => {
+        total += fhwaClassCounts[fhwaClass] || 0;
+      });
+      customClassCounts[customClass.name] = total;
+    });
+
+    return customClassCounts;
+  }
+
+  /**
+   * Transform nested vehicle structure with custom class mapping
+   *
+   * Handles both ATR (lane-based) and TMC (direction/turn-based) formats
+   * Preserves all nesting levels while transforming detection labels to custom classes
+   *
+   * @param vehiclesStructure - Nested vehicles object with detection labels as keys
+   *                           ATR: { "car": { "0": 45, "1": 50 }, ... }
+   *                           TMC: { "car": { "NORTH": { "straight": 10 }, ... }, ... }
+   * @param config - Report configuration with custom class mappings
+   * @returns Transformed structure with custom class names as keys
+   */
+  applyConfigurationToNestedStructure(
+    vehiclesStructure: Record<string, any>,
+    config: IReportConfiguration,
+  ): Record<string, any> {
+    // Build reverse mapping: detection label → custom class name
+    const detectionToCustomClass: Record<string, string> = {};
+
+    for (const customClass of config.configuration.customClasses) {
+      // For each FHWA class in this custom class
+      for (const fhwaClass of customClass.fhwaClasses) {
+        // Find all detection labels that map to this FHWA class
+        for (const [label, fhwaClasses] of Object.entries(
+          DETECTION_LABEL_TO_FHWA,
+        )) {
+          if (fhwaClasses.includes(fhwaClass)) {
+            detectionToCustomClass[label] = customClass.name;
+          }
         }
-
-        // Add "Total" class that aggregates all custom classes
-        result["Total"] = this._createTotalClass(result);
-
-        return result;
+      }
     }
 
-    /**
-     * Deep merge numeric data at arbitrary nesting levels
-     *
-     * Recursively merges two nested structures, summing numeric leaf values
-     * Handles ATR format (2 levels: vehicle → lane → count)
-     * Handles TMC format (3 levels: vehicle → direction → turn → count)
-     *
-     * @param target - Target accumulator object
-     * @param source - Source data to merge into target
-     * @returns Merged object with summed numeric values
-     */
-    private _deepMergeNumericData(target: any, source: any): any {
-        // Base case: if source is a number, add it to target
-        if (typeof source === 'number') {
-            return (typeof target === 'number' ? target : 0) + source;
-        }
-
-        // If source is not an object, return target unchanged
-        if (typeof source !== 'object' || source === null) {
-            return target;
-        }
-
-        // Ensure target is an object
-        if (typeof target !== 'object' || target === null) {
-            target = {};
-        }
+    // Initialize empty structure for each custom class
+    const result: Record<string, any> = {};
+    for (const customClass of config.configuration.customClasses) {
+      result[customClass.name] = {};
+    }
 
-        // Recursively merge each key in source
-        for (const [key, value] of Object.entries(source)) {
-            target[key] = this._deepMergeNumericData(target[key], value);
-        }
+    // Iterate through detection labels in input structure
+    for (const [detectionLabel, nestedData] of Object.entries(
+      vehiclesStructure,
+    )) {
+      const customClassName = detectionToCustomClass[detectionLabel];
+
+      // Skip labels not mapped to any custom class (e.g., pedestrian, bicycle)
+      if (!customClassName) {
+        continue;
+      }
+
+      // Deep merge nested data into custom class accumulator
+      result[customClassName] = this._deepMergeNumericData(
+        result[customClassName],
+        nestedData,
+      );
+    }
 
-        return target;
+    // Add "Total" class that aggregates all custom classes
+    result["Total"] = this._createTotalClass(result);
+
+    return result;
+  }
+
+  /**
+   * Deep merge numeric data at arbitrary nesting levels
+   *
+   * Recursively merges two nested structures, summing numeric leaf values
+   * Handles ATR format (2 levels: vehicle → lane → count)
+   * Handles TMC format (3 levels: vehicle → direction → turn → count)
+   *
+   * @param target - Target accumulator object
+   * @param source - Source data to merge into target
+   * @returns Merged object with summed numeric values
+   */
+  private _deepMergeNumericData(target: any, source: any): any {
+    // Base case: if source is a number, add it to target
+    if (typeof source === "number") {
+      return (typeof target === "number" ? target : 0) + source;
     }
 
-    /**
-     * Create "Total" vehicle class by summing all custom classes
-     * Works for both ATR and TMC formats through structure-agnostic deep merge
-     *
-     * @param customClassesData - Object with custom class names as keys
-     * @returns Aggregated nested structure summing all classes
-     */
-    private _createTotalClass(customClassesData: Record<string, any>): any {
-        let total: any = {};
-
-        for (const [className, nestedData] of Object.entries(customClassesData)) {
-            total = this._deepMergeNumericData(total, nestedData);
-        }
+    // If source is not an object, return target unchanged
+    if (typeof source !== "object" || source === null) {
+      return target;
+    }
 
-        return total;
+    // Ensure target is an object
+    if (typeof target !== "object" || target === null) {
+      target = {};
     }
 
-    /**
-     * Get the FHWA mapping constant (for reference/debugging)
-     */
-    getDetectionLabelToFhwaMapping(): Record<string, number[]> {
-        return { ...DETECTION_LABEL_TO_FHWA };
+    // Recursively merge each key in source
+    for (const [key, value] of Object.entries(source)) {
+      target[key] = this._deepMergeNumericData(target[key], value);
     }
 
-    /**
-     * Deserialize database row to IReportConfiguration interface
-     * Converts snake_case to camelCase and parses JSONB
-     */
-    private _deserialize(row: any): IReportConfiguration {
-        return {
-            id: row.id,
-            uuid: row.uuid,
-            name: row.name,
-            description: row.description,
-            configuration: typeof row.configuration === 'string'
-                ? JSON.parse(row.configuration)
-                : row.configuration,
-            created_at: row.created_at,
-            updated_at: row.updated_at
-        };
+    return target;
+  }
+
+  /**
+   * Create "Total" vehicle class by summing all custom classes
+   * Works for both ATR and TMC formats through structure-agnostic deep merge
+   *
+   * @param customClassesData - Object with custom class names as keys
+   * @returns Aggregated nested structure summing all classes
+   */
+  private _createTotalClass(customClassesData: Record<string, any>): any {
+    let total: any = {};
+
+    for (const [className, nestedData] of Object.entries(customClassesData)) {
+      total = this._deepMergeNumericData(total, nestedData);
     }
+
+    return total;
+  }
+
+  /**
+   * Get the FHWA mapping constant (for reference/debugging)
+   */
+  getDetectionLabelToFhwaMapping(): Record<string, number[]> {
+    return { ...DETECTION_LABEL_TO_FHWA };
+  }
+
+  /**
+   * Deserialize database row to IReportConfiguration interface
+   * Converts snake_case to camelCase and parses JSONB
+   */
+  private _deserialize(row: any): IReportConfiguration {
+    return {
+      id: row.id,
+      uuid: row.uuid,
+      name: row.name,
+      description: row.description,
+      configuration:
+        typeof row.configuration === "string"
+          ? JSON.parse(row.configuration)
+          : row.configuration,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+    };
+  }
 }