@trafficgroup/knex-rel 0.1.3 → 0.1.5

package/src/dao/VideoMinuteResultDAO.ts

@@ -615,11 +615,11 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
 
       // Aggregate vehicle counts by class and lane
       if (results.vehicles) {
-        for (const [rawVehicleClass, lanes] of Object.entries(
-          results.vehicles,
-        )) {
-          // Normalize vehicle class names to standard format for frontend compatibility
-          const vehicleClass = this.normalizeATRVehicleClass(rawVehicleClass);
+        for (const [vehicleClass, lanes] of Object.entries(results.vehicles)) {
+          // Skip 'total' pseudo-class if present
+          if (vehicleClass === "total") {
+            continue;
+          }
 
           if (!aggregated.vehicles[vehicleClass]) {
             aggregated.vehicles[vehicleClass] = {};
@@ -645,12 +645,9 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
       // Aggregate total count
       aggregated.total_count += results.total_count || 0;
 
-      // Aggregate detected classes with normalized names
+      // Aggregate detected classes (use raw detection labels)
       if (results.detected_classes) {
-        for (const [rawCls, count] of Object.entries(
-          results.detected_classes,
-        )) {
-          const cls = this.normalizeATRVehicleClass(rawCls);
+        for (const [cls, count] of Object.entries(results.detected_classes)) {
           aggregated.detected_classes[cls] =
             (aggregated.detected_classes[cls] || 0) + ((count as number) || 0);
         }
@@ -715,60 +712,6 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
     return cloned;
   }
 
-  /**
-   * Normalize ATR vehicle class names to standard format for frontend compatibility
-   */
-  private normalizeATRVehicleClass(rawVehicleClass: string): string {
-    const normalized = rawVehicleClass.toLowerCase().replace(/[_\s-]/g, "");
-
-    // Map raw vehicle classes to standard classes
-    if (
-      normalized.includes("car") ||
-      normalized === "vehicle" ||
-      normalized === "automobiles"
-    ) {
-      return "cars";
-    }
-    if (
-      normalized.includes("medium") ||
-      normalized.includes("pickup") ||
-      (normalized.includes("truck") && !normalized.includes("heavy"))
-    ) {
-      return "mediums";
-    }
-    if (
-      normalized.includes("heavy") ||
-      normalized.includes("largetruck") ||
-      normalized.includes("bigtruck")
-    ) {
-      return "heavy_trucks";
-    }
-    if (
-      normalized.includes("pedestrian") ||
-      normalized.includes("person") ||
-      normalized.includes("people")
-    ) {
-      return "pedestrians";
-    }
-    if (
-      normalized.includes("bicycle") ||
-      normalized.includes("bike") ||
-      normalized.includes("cyclist")
-    ) {
-      return "bicycles";
-    }
-    if (normalized.includes("total") || normalized.includes("all")) {
-      return "total";
-    }
-
-    // Handle specific known ATR classes
-    if (rawVehicleClass === "mediums") return "mediums";
-    if (rawVehicleClass === "heavy_trucks") return "heavy_trucks";
-
-    // Default fallback for unknown classes
-    return "cars";
-  }
-
   /**
    * Format time label for display (HH:MM:SS format)
    */

package/src/dao/camera/camera.dao.ts

@@ -1,6 +1,7 @@
 import { Knex } from "knex";
 import { IBaseDAO, IDataPaginator } from "../../d.types";
 import { ICamera } from "../../interfaces/camera/camera.interfaces";
+import { IVideo } from "../../interfaces/video/video.interfaces";
 import KnexManager from "../../KnexConnection";
 
 export class CameraDAO implements IBaseDAO<ICamera> {
@@ -77,6 +78,9 @@ export class CameraDAO implements IBaseDAO<ICamera> {
     return cameras;
   }
 
+  /**
+   * Get all cameras with optional search filter by name (case-insensitive partial match)
+   */
   async getAllWithSearch(
     page: number,
     limit: number,
@@ -84,15 +88,21 @@ export class CameraDAO implements IBaseDAO<ICamera> {
   ): Promise<IDataPaginator<ICamera>> {
     const offset = (page - 1) * limit;
 
-    const query = this._knex("cameras");
+    let query = this._knex("cameras");
 
-    if (name && name.trim() !== "") {
-      query.where("name", "ilike", `%${name.trim()}%`);
+    // Apply search filter if name provided (escape special chars to prevent pattern injection)
+    if (name && name.trim().length > 0) {
+      const escapedName = name.trim().replace(/[%_\\]/g, "\\$&");
+      query = query.where("name", "ilike", `%${escapedName}%`);
     }
 
     const [countResult] = await query.clone().count("* as count");
     const totalCount = +countResult.count;
-    const cameras = await query.clone().limit(limit).offset(offset);
+    const cameras = await query
+      .clone()
+      .limit(limit)
+      .offset(offset)
+      .orderBy("name", "asc");
 
     return {
       success: true,
@@ -105,21 +115,31 @@ export class CameraDAO implements IBaseDAO<ICamera> {
     };
   }
 
+  /**
+   * Get paginated videos for a specific camera with folder data included
+   */
   async getVideosByCamera(
     cameraId: number,
     page: number,
     limit: number,
-  ): Promise<IDataPaginator<any>> {
+  ): Promise<IDataPaginator<IVideo>> {
     const offset = (page - 1) * limit;
 
-    const query = this._knex("videos as v")
+    const query = this._knex("video as v")
       .innerJoin("folders as f", "v.folderId", "f.id")
-      .where("v.cameraId", cameraId)
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"));
+      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+      .where("v.cameraId", cameraId);
 
-    const [countResult] = await query.clone().clearSelect().count("* as count");
+    // Optimized count query without JOIN
+    const [countResult] = await this._knex("video as v")
+      .where("v.cameraId", cameraId)
+      .count("* as count");
     const totalCount = +countResult.count;
-    const videos = await query.clone().limit(limit).offset(offset);
+    const videos = await query
+      .clone()
+      .limit(limit)
+      .offset(offset)
+      .orderBy("v.created_at", "desc");
 
     return {
       success: true,

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

@@ -0,0 +1,402 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import {
+  IReportConfiguration,
+  IReportConfigurationData,
+  IReportConfigurationInput,
+  IValidationResult,
+} from "../../interfaces/report-configuration/report-configuration.interfaces";
+import KnexManager from "../../KnexConnection";
+
+/**
+ * Mapping from detection labels to FHWA vehicle classes (1-13)
+ *
+ * FHWA Classes:
+ * - Class 1: Motorcycles
+ * - Class 2: Cars (passenger cars)
+ * - Class 3: Pickup trucks, vans, motorized vehicles
+ * - Class 4: Buses
+ * - Class 5: Work vans (2-axle, 6-tire single units)
+ * - Classes 6-8: Single unit trucks
+ * - Classes 9-13: Articulated trucks (semi-trailers, multi-trailers)
+ *
+ * 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
+};
+
+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);
+  }
+
+  /**
+   * 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(", ")}`,
+        );
+      }
+    }
+
+    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.",
+      );
+    }
+
+    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");
+    }
+
+    // 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.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 };
+  }
+
+  /**
+   * 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 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;
+          }
+        }
+      }
+    }
+
+    // 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,
+      );
+    }
+
+    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 = {};
+    }
+
+    // Recursively merge each key in source
+    for (const [key, value] of Object.entries(source)) {
+      target[key] = this._deepMergeNumericData(target[key], value);
+    }
+
+    return target;
+  }
+
+  /**
+   * 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,
+    };
+  }
+}

package/src/dao/video/video.dao.ts

@@ -222,13 +222,13 @@ export class VideoDAO implements IBaseDAO<IVideo> {
         // Check if metadata has at least one key with pt1 and pt2 properties
         query = query.whereRaw(`
                     EXISTS (
-                        SELECT 1 
+                        SELECT 1
                         FROM jsonb_each(metadata) as entry(key, value)
-                        WHERE key != 'lanes' 
+                        WHERE key != 'lanes'
                         AND key != 'finish_line'
                         AND jsonb_typeof(value) = 'object'
-                        AND value ? 'pt1' 
-                        AND value ? 'pt2'
+                        AND jsonb_exists(value, 'pt1')
+                        AND jsonb_exists(value, 'pt2')
                         AND jsonb_typeof(value->'pt1') = 'array'
                         AND jsonb_typeof(value->'pt2') = 'array'
                         AND jsonb_array_length(value->'pt1') = 2
@@ -246,26 +246,47 @@ export class VideoDAO implements IBaseDAO<IVideo> {
     }
   }
 
+  /**
+   * Get all video IDs for a specific folder (used for cascade operations)
+   */
   async getVideoIdsByFolderId(folderId: number): Promise<number[]> {
-    const videos = await this._knex("video")
-      .where("folderId", folderId)
-      .select("id");
-    return videos.map((video) => video.id);
+    const rows = await this._knex("video")
+      .where({ folderId })
+      .select("id")
+      .orderBy("id", "asc");
+
+    return rows.map((row) => row.id);
   }
 
+  /**
+   * Bulk update camera assignment for multiple videos
+   * Supports optional transaction for service-level transaction management
+   */
   async bulkUpdateCamera(
     videoIds: number[],
     cameraId: number | null,
     trx?: Knex.Transaction,
   ): Promise<number> {
-    const knexInstance = trx || this._knex;
-    const result = await knexInstance("video").whereIn("id", videoIds).update({
-      cameraId: cameraId,
-      updated_at: knexInstance.fn.now(),
-    });
-    return result;
+    if (!videoIds || videoIds.length === 0) {
+      return 0;
+    }
+
+    const query = trx || this._knex;
+
+    const result = await query("video")
+      .whereIn("id", videoIds)
+      .update({
+        cameraId: cameraId,
+        updated_at: query.fn.now(),
+      })
+      .returning("id");
+
+    return result.length;
   }
 
+  /**
+   * Get videos by camera ID with folder information (paginated)
+   */
   async getVideosByCameraIdWithFolder(
     cameraId: number,
     page: number,
@@ -275,12 +296,19 @@ export class VideoDAO implements IBaseDAO<IVideo> {
 
     const query = this._knex("video as v")
       .innerJoin("folders as f", "v.folderId", "f.id")
-      .where("v.cameraId", cameraId)
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"));
+      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+      .where("v.cameraId", cameraId);
 
-    const [countResult] = await query.clone().clearSelect().count("* as count");
+    // Optimized count query without JOIN
+    const [countResult] = await this._knex("video as v")
+      .where("v.cameraId", cameraId)
+      .count("* as count");
     const totalCount = +countResult.count;
-    const videos = await query.clone().limit(limit).offset(offset);
+    const videos = await query
+      .clone()
+      .limit(limit)
+      .offset(offset)
+      .orderBy("v.created_at", "desc");
 
     return {
       success: true,