@trafficgroup/knex-rel 0.1.21 → 0.1.23-rc.0

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";
 
@@ -21,407 +21,418 @@ import KnexManager from "../../KnexConnection";
  * - Classes 9-13: Articulated trucks (semi-trailers, multi-trailers)
  *
  * Non-motorized vehicles (pedestrian, bicycle, non_motorized_vehicle) are EXCLUDED
+ * from FHWA mapping but can be included via specialClasses
  */
 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 from FHWA
 };
 
+/**
+ * Valid special class names that bypass FHWA mapping
+ * These map directly from detection label to custom class
+ */
+const VALID_SPECIAL_CLASSES = ['bicycle'];
+
 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(", ")}`);
+    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);
     }
 
-    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 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 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 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 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");
+    /**
+     * 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;
     }
 
-    // Validate custom classes array
-    if (!config.customClasses || !Array.isArray(config.customClasses)) {
-      errors.push("customClasses must be an array");
-      return { valid: false, errors };
+    /**
+     * 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;
     }
 
-    // Min 2, max 7 custom classes
-    if (config.customClasses.length < 2) {
-      errors.push("Minimum 2 custom classes required");
+    /**
+     * 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;
     }
-    if (config.customClasses.length > 7) {
-      errors.push("Maximum 7 custom classes allowed");
+
+    /**
+     * 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),
+        };
     }
 
-    // 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);
+    /**
+     * 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`);
+            }
+
+            const hasFhwa = Array.isArray(cls.fhwaClasses) && cls.fhwaClasses.length > 0;
+            const hasSpecial = Array.isArray(cls.specialClasses) && cls.specialClasses.length > 0;
+
+            // A custom class must have at least one FHWA class OR one specialClass
+            if (!hasFhwa && !hasSpecial) {
+                errors.push(`Custom class ${idx + 1}: must have at least one FHWA class or one special class`);
+            }
+
+            if (hasFhwa) {
+                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);
+                });
+            }
+
+            // Validate specialClasses entries
+            if (hasSpecial) {
+                cls.specialClasses!.forEach(sc => {
+                    if (!VALID_SPECIAL_CLASSES.includes(sc)) {
+                        errors.push(`Custom class ${idx + 1}: invalid special class "${sc}". Allowed: ${VALID_SPECIAL_CLASSES.join(', ')}`);
+                    }
+                });
+            }
         });
-      }
-    });
-
-    // 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.`,
-      );
+
+        // 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 };
     }
 
-    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;
+    /**
+     * 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 and not in specialClasses are silently ignored
+        }
+
+        // Step 2: FHWA classes → Custom classes + specialClasses direct mapping
+        const customClassCounts: Record<string, number> = {};
+
+        config.configuration.customClasses.forEach(customClass => {
+            let total = 0;
+
+            // Sum FHWA-based counts
+            customClass.fhwaClasses.forEach(fhwaClass => {
+                total += fhwaClassCounts[fhwaClass] || 0;
+            });
+
+            // Sum specialClasses direct mapping (detection label === special class name)
+            if (Array.isArray(customClass.specialClasses)) {
+                customClass.specialClasses.forEach(specialClass => {
+                    total += detectionResults[specialClass] || 0;
+                });
+            }
+
+            customClassCounts[customClass.name] = total;
         });
-      }
-      // Labels not in DETECTION_LABEL_TO_FHWA are silently ignored (e.g., pedestrian, bicycle)
+
+        return customClassCounts;
     }
 
-    // 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;
-          }
+    /**
+     * 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;
+                    }
+                }
+            }
+
+            // Map specialClasses directly (detection label === special class name)
+            if (Array.isArray(customClass.specialClasses)) {
+                for (const specialClass of customClass.specialClasses) {
+                    detectionToCustomClass[specialClass] = customClass.name;
+                }
+            }
         }
-      }
-    }
 
-    // Initialize empty structure for each custom class
-    const result: Record<string, any> = {};
-    for (const customClass of config.configuration.customClasses) {
-      result[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,
-      );
-    }
+        // Iterate through detection labels in input structure
+        for (const [detectionLabel, nestedData] of Object.entries(vehiclesStructure)) {
+            const customClassName = detectionToCustomClass[detectionLabel];
 
-    // 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;
-    }
+            // Skip labels not mapped to any custom class
+            if (!customClassName) {
+                continue;
+            }
+
+            // Deep merge nested data into custom class accumulator
+            result[customClassName] = this._deepMergeNumericData(
+                result[customClassName],
+                nestedData
+            );
+        }
+
+        // Add "Total" class that aggregates all custom classes
+        result["Total"] = this._createTotalClass(result);
 
-    // If source is not an object, return target unchanged
-    if (typeof source !== "object" || source === null) {
-      return target;
+        return result;
     }
 
-    // Ensure target is an object
-    if (typeof target !== "object" || target === null) {
-      target = {};
+    /**
+     * 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 = {};
+        }
+
+        // Recursively merge each key in source
+        for (const [key, value] of Object.entries(source)) {
+            target[key] = this._deepMergeNumericData(target[key], value);
+        }
+
+        return target;
     }
 
-    // Recursively merge each key in source
-    for (const [key, value] of Object.entries(source)) {
-      target[key] = this._deepMergeNumericData(target[key], value);
+    /**
+     * 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;
     }
 
-    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);
+    /**
+     * Get the FHWA mapping constant (for reference/debugging)
+     */
+    getDetectionLabelToFhwaMapping(): Record<string, number[]> {
+        return { ...DETECTION_LABEL_TO_FHWA };
     }
 
-    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,
-    };
-  }
+    /**
+     * 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
+        };
+    }
 }