@trafficgroup/knex-rel 0.1.11 → 0.1.12

package/src/dao/VideoMinuteResultDAO.ts

@@ -69,15 +69,15 @@ interface IGroupedResponse {
 }
 
 interface IStudyTimeGroupResult {
-  absoluteTime: string;      // ISO 8601 start of bucket
+  absoluteTime: string; // ISO 8601 start of bucket
   groupIndex: number;
-  startMinute: number;        // Start minute number (0-based from video start)
-  endMinute: number;          // End minute number (0-based from video start)
-  label: string;              // Formatted label
+  startMinute: number; // Start minute number (0-based from video start)
+  endMinute: number; // End minute number (0-based from video start)
+  label: string; // Formatted label
   results: ITMCResult | IATRResult;
   minuteCount: number;
   videoCount: number;
-  contributingVideos: string[];  // Video UUIDs
+  contributingVideos: string[]; // Video UUIDs
 }
 
 interface IGroupedStudyResponse {
@@ -87,7 +87,7 @@ interface IGroupedStudyResponse {
   study: {
     uuid: string;
     name: string;
-    type: 'TMC' | 'ATR';
+    type: "TMC" | "ATR";
     status: string;
   };
   videoCount: number;
@@ -423,37 +423,41 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
     // Use Knex query builder for safe parameter binding
     const groupingQuery = this.knex(this.tableName)
       .select(
-        this.knex.raw('FLOOR(minute_number / ?) as group_index', [groupingMinutes]),
-        this.knex.raw('MIN(minute_number) as start_minute'),
-        this.knex.raw('MAX(minute_number) as end_minute'),
-        this.knex.raw('COUNT(*) as minute_count'),
-        this.knex.raw('array_agg(results ORDER BY minute_number) as all_results')
+        this.knex.raw("FLOOR(minute_number / ?) as group_index", [
+          groupingMinutes,
+        ]),
+        this.knex.raw("MIN(minute_number) as start_minute"),
+        this.knex.raw("MAX(minute_number) as end_minute"),
+        this.knex.raw("COUNT(*) as minute_count"),
+        this.knex.raw(
+          "array_agg(results ORDER BY minute_number) as all_results",
+        ),
       )
-      .where('video_id', video.id);
+      .where("video_id", video.id);
 
     if (startMinute !== undefined) {
-      groupingQuery.where('minute_number', '>=', startMinute);
+      groupingQuery.where("minute_number", ">=", startMinute);
     }
 
     if (endMinute !== undefined) {
-      groupingQuery.where('minute_number', '<=', endMinute);
+      groupingQuery.where("minute_number", "<=", endMinute);
     }
 
     const rows = await groupingQuery
-      .groupBy('group_index')
-      .orderBy('group_index');
+      .groupBy("group_index")
+      .orderBy("group_index");
 
     // Aggregate the results in TypeScript based on video type
     const aggregatedGroups: IGroupedResult[] = rows.map((row: any) => {
-      if (!row || typeof row !== 'object') {
-        throw new Error('Invalid row data received from database query');
+      if (!row || typeof row !== "object") {
+        throw new Error("Invalid row data received from database query");
       }
 
       const allResults = Array.isArray(row.all_results) ? row.all_results : [];
-      
+
       // Determine video type based on multiple factors
-      let studyType = video.videoType || 'ATR'; // Default fallback to ATR
-      
+      let studyType = video.videoType || "ATR"; // Default fallback to ATR
+
       // Check if minute data has study_type field (ATR usually does)
       if (allResults.length > 0 && allResults[0].study_type) {
         studyType = allResults[0].study_type;
@@ -465,20 +469,24 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
           const vehicleKeys = Object.keys(sampleResult.vehicles);
           if (vehicleKeys.length > 0) {
             const firstVehicleType = sampleResult.vehicles[vehicleKeys[0]];
-            if (firstVehicleType && typeof firstVehicleType === 'object') {
+            if (firstVehicleType && typeof firstVehicleType === "object") {
               const directions = Object.keys(firstVehicleType);
-              if (directions.includes('NORTH') || directions.includes('SOUTH') || 
-                  directions.includes('EAST') || directions.includes('WEST')) {
-                studyType = 'TMC';
+              if (
+                directions.includes("NORTH") ||
+                directions.includes("SOUTH") ||
+                directions.includes("EAST") ||
+                directions.includes("WEST")
+              ) {
+                studyType = "TMC";
               }
             }
           }
         }
       }
-      
+
       // Aggregate based on determined video type
       let aggregatedResult;
-      if (studyType === 'TMC') {
+      if (studyType === "TMC") {
         aggregatedResult = this.aggregateTMCResults(allResults);
       } else {
         aggregatedResult = this.aggregateATRResults(allResults);
@@ -569,8 +577,8 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
         "v.uuid as videoUuid",
         "v.recordingStartedAt",
         this.knex.raw(
-          '"v"."recordingStartedAt" + (vmr.minute_number || \' minutes\')::INTERVAL as "absoluteTime"'
-        )
+          '"v"."recordingStartedAt" + (vmr.minute_number || \' minutes\')::INTERVAL as "absoluteTime"',
+        ),
       )
       .whereIn("v.id", videoIds)
       .orderBy("absoluteTime", "asc");
@@ -608,7 +616,7 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
     for (const minute of minuteResults) {
       const absoluteTime = new Date(minute.absoluteTime);
       const minutesSinceEarliest = Math.floor(
-        (absoluteTime.getTime() - earliestTime.getTime()) / (1000 * 60)
+        (absoluteTime.getTime() - earliestTime.getTime()) / (1000 * 60),
       );
       const bucketIndex = Math.floor(minutesSinceEarliest / groupingMinutes);
 
@@ -616,7 +624,7 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
         // Calculate bucket start time
         const bucketStartMinutes = bucketIndex * groupingMinutes;
         const bucketStartTime = new Date(
-          earliestTime.getTime() + bucketStartMinutes * 60 * 1000
+          earliestTime.getTime() + bucketStartMinutes * 60 * 1000,
         );
 
         buckets.set(bucketIndex, {
@@ -633,12 +641,14 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
     }
 
     // Step 5: Aggregate using existing methods based on study type
-    const aggregatedGroups: IStudyTimeGroupResult[] = Array.from(buckets.values())
+    const aggregatedGroups: IStudyTimeGroupResult[] = Array.from(
+      buckets.values(),
+    )
       .sort((a, b) => a.groupIndex - b.groupIndex)
       .map((bucket) => {
         let aggregatedResult: ITMCResult | IATRResult;
 
-        if (study.type === 'TMC') {
+        if (study.type === "TMC") {
           aggregatedResult = this.aggregateTMCResults(bucket.results);
         } else {
           aggregatedResult = this.aggregateATRResults(bucket.results);
@@ -649,7 +659,10 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
           groupIndex: bucket.groupIndex,
           startMinute: bucket.groupIndex * groupingMinutes,
           endMinute: (bucket.groupIndex + 1) * groupingMinutes - 1,
-          label: this.formatStudyTimeLabel(bucket.absoluteTime, groupingMinutes),
+          label: this.formatStudyTimeLabel(
+            bucket.absoluteTime,
+            groupingMinutes,
+          ),
           results: aggregatedResult,
           minuteCount: bucket.results.length,
           videoCount: bucket.videoUuids.size,
@@ -712,25 +725,27 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
       vehicles: {},
       counts: {
         total_vehicles: 0,
-        entry_vehicles: 0
+        entry_vehicles: 0,
       },
       total: 0,
       totalcount: 0,
       detected_classes: {},
-      study_type: "TMC"
+      study_type: "TMC",
     };
 
     for (const minute of minutes) {
       const results = minute; // minute is already the results object from array_agg
 
       // Aggregate vehicle movements by class and direction
-      if (results.vehicles && typeof results.vehicles === 'object') {
-        for (const [vehicleClass, directions] of Object.entries(results.vehicles)) {
+      if (results.vehicles && typeof results.vehicles === "object") {
+        for (const [vehicleClass, directions] of Object.entries(
+          results.vehicles,
+        )) {
           // Skip the 'total' pseudo vehicle class - validate it's actually aggregate data
-          if (vehicleClass === 'total' && typeof directions === 'number') {
+          if (vehicleClass === "total" && typeof directions === "number") {
             continue; // This is aggregate total data, not a vehicle class
           }
-          
+
           if (!aggregated.vehicles[vehicleClass]) {
             aggregated.vehicles[vehicleClass] = {};
           }
@@ -753,11 +768,12 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
               for (const [turnType, count] of Object.entries(turns)) {
                 const turnCount = (count as number) || 0;
                 aggregated.vehicles[vehicleClass][direction][turnType] =
-                  (aggregated.vehicles[vehicleClass][direction][turnType] || 0) + turnCount;
-                
+                  (aggregated.vehicles[vehicleClass][direction][turnType] ||
+                    0) + turnCount;
+
                 // Add to detected_classes count for this vehicle type
                 aggregated.detected_classes[vehicleClass] += turnCount;
-                
+
                 // Add to total counts
                 aggregated.total += turnCount;
                 aggregated.totalcount += turnCount;
@@ -765,10 +781,12 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
             }
           }
         }
-        
+
         // Also process the 'total' entry for validation but don't count it as a vehicle class
         if (results.vehicles.total) {
-          for (const [direction, turns] of Object.entries(results.vehicles.total as any)) {
+          for (const [direction, turns] of Object.entries(
+            results.vehicles.total as any,
+          )) {
             if (typeof turns === "object" && turns !== null) {
               for (const [turnType, count] of Object.entries(turns)) {
                 const turnCount = (count as number) || 0;
@@ -781,7 +799,8 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
     }
 
     // Set entry_vehicles same as total_vehicles for TMC
-    aggregated.counts.entry_vehicles = aggregated.counts.total_vehicles || aggregated.total;
+    aggregated.counts.entry_vehicles =
+      aggregated.counts.total_vehicles || aggregated.total;
 
     return aggregated;
   }
@@ -805,7 +824,7 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
       if (results.vehicles) {
         for (const [vehicleClass, lanes] of Object.entries(results.vehicles)) {
           // Skip 'total' pseudo-class if present
-          if (vehicleClass === 'total') {
+          if (vehicleClass === "total") {
             continue;
           }
 
@@ -814,7 +833,8 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
           }
 
           for (const [laneId, count] of Object.entries(lanes as any)) {
-            const numericCount = typeof count === 'number' ? count : (parseInt(String(count)) || 0);
+            const numericCount =
+              typeof count === "number" ? count : parseInt(String(count)) || 0;
             aggregated.vehicles[vehicleClass][laneId] =
               (aggregated.vehicles[vehicleClass][laneId] || 0) + numericCount;
           }
@@ -921,7 +941,10 @@ export class VideoMinuteResultDAO implements IBaseDAO<IVideoMinuteResult> {
    * Used when results are already grouped by date in the UI
    * Uses UTC time for consistency with absoluteTime field
    */
-  private formatStudyTimeLabel(startTime: Date, durationMinutes: number): string {
+  private formatStudyTimeLabel(
+    startTime: Date,
+    durationMinutes: number,
+  ): string {
     const endTime = new Date(startTime.getTime() + durationMinutes * 60 * 1000);
 
     const formatTime = (date: Date): string => {

package/src/dao/auth/auth.dao.ts

@@ -4,58 +4,61 @@ import { IAuth } from "../../interfaces/auth/auth.interfaces";
 import KnexManager from "../../KnexConnection";
 
 export class AuthDAO implements IBaseDAO<IAuth> {
-    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
-
-    async create(item: IAuth): Promise<IAuth> {
-        const [createdAuth] = await this._knex("auth").insert(item).returning("*");
-        return createdAuth;
-    }
-
-    async getById(id: number): Promise<IAuth | null> {
-        const auth = await this._knex("auth").where({ id }).first();
-        return auth || null;
-    }
-
-    async getByUuid(uuid: string): Promise<IAuth | null> {
-        // Auth table doesn't have uuid, so we'll return null or throw error
-        return null;
-    }
-
-    async getByUserId(userId: number): Promise<IAuth | null> {
-        const auth = await this._knex("auth").where({ userId }).first();
-        return auth || null;
-    }
-
-    async getByEmailToken(emailToken: string): Promise<IAuth | null> {
-        const auth = await this._knex("auth").where({ emailToken }).first();
-        return auth || null;
-    }
-
-    async update(id: number, item: Partial<IAuth>): Promise<IAuth | null> {
-        const [updatedAuth] = await this._knex("auth").where({ id }).update(item).returning("*");
-        return updatedAuth || null;
-    }
-
-    async delete(id: number): Promise<boolean> {
-        const result = await this._knex("auth").where({ id }).del();
-        return result > 0;
-    }
-
-    async getAll(page: number, limit: number): Promise<IDataPaginator<IAuth>> {
-        const offset = (page - 1) * limit;
-
-        const [countResult] = await this._knex("auth").count("* as count");
-        const totalCount = +countResult.count;
-        const auths = await this._knex("auth").limit(limit).offset(offset);
-
-        return {
-            success: true,
-            data: auths,
-            page,
-            limit,
-            count: auths.length,
-            totalCount,
-            totalPages: Math.ceil(totalCount / limit),
-        };
-    }
-}
+  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+  async create(item: IAuth): Promise<IAuth> {
+    const [createdAuth] = await this._knex("auth").insert(item).returning("*");
+    return createdAuth;
+  }
+
+  async getById(id: number): Promise<IAuth | null> {
+    const auth = await this._knex("auth").where({ id }).first();
+    return auth || null;
+  }
+
+  async getByUuid(uuid: string): Promise<IAuth | null> {
+    // Auth table doesn't have uuid, so we'll return null or throw error
+    return null;
+  }
+
+  async getByUserId(userId: number): Promise<IAuth | null> {
+    const auth = await this._knex("auth").where({ userId }).first();
+    return auth || null;
+  }
+
+  async getByEmailToken(emailToken: string): Promise<IAuth | null> {
+    const auth = await this._knex("auth").where({ emailToken }).first();
+    return auth || null;
+  }
+
+  async update(id: number, item: Partial<IAuth>): Promise<IAuth | null> {
+    const [updatedAuth] = await this._knex("auth")
+      .where({ id })
+      .update(item)
+      .returning("*");
+    return updatedAuth || null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex("auth").where({ id }).del();
+    return result > 0;
+  }
+
+  async getAll(page: number, limit: number): Promise<IDataPaginator<IAuth>> {
+    const offset = (page - 1) * limit;
+
+    const [countResult] = await this._knex("auth").count("* as count");
+    const totalCount = +countResult.count;
+    const auths = await this._knex("auth").limit(limit).offset(offset);
+
+    return {
+      success: true,
+      data: auths,
+      page,
+      limit,
+      count: auths.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
+}

package/src/dao/batch/batch.dao.ts

@@ -4,115 +4,118 @@ import { IBatch } from "../../interfaces/batch/batch.interfaces";
 import KnexManager from "../../KnexConnection";
 
 export class BatchDAO implements IBaseDAO<IBatch> {
-    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
 
-    async create(item: IBatch): Promise<IBatch> {
-        const [createdBatch] = await this._knex("video_batch").insert(item).returning("*");
-        return createdBatch;
-    }
+  async create(item: IBatch): Promise<IBatch> {
+    const [createdBatch] = await this._knex("video_batch")
+      .insert(item)
+      .returning("*");
+    return createdBatch;
+  }
 
-    async getById(id: number): Promise<IBatch | null> {
-        const batch = await this._knex("video_batch as b")
-            .innerJoin("folders as f", "b.folderId", "f.id")
-            .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"))
-            .where("b.id", id)
-            .first();
-        return batch || null;
-    }
+  async getById(id: number): Promise<IBatch | null> {
+    const batch = await this._knex("video_batch as b")
+      .innerJoin("folders as f", "b.folderId", "f.id")
+      .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"))
+      .where("b.id", id)
+      .first();
+    return batch || null;
+  }
 
-    async getByUuid(uuid: string): Promise<IBatch | null> {
-        const batch = await this._knex("video_batch as b")
-            .innerJoin("folders as f", "b.folderId", "f.id")
-            .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"))
-            .where("b.uuid", uuid)
-            .first();
-        return batch || null;
-    }
+  async getByUuid(uuid: string): Promise<IBatch | null> {
+    const batch = await this._knex("video_batch as b")
+      .innerJoin("folders as f", "b.folderId", "f.id")
+      .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"))
+      .where("b.uuid", uuid)
+      .first();
+    return batch || null;
+  }
 
-    async update(id: number, item: Partial<IBatch>): Promise<IBatch | null> {
-        const [updatedBatch] = await this._knex("video_batch").where({ id }).update(item).returning("*");
-        return updatedBatch || null;
-    }
+  async update(id: number, item: Partial<IBatch>): Promise<IBatch | null> {
+    const [updatedBatch] = await this._knex("video_batch")
+      .where({ id })
+      .update(item)
+      .returning("*");
+    return updatedBatch || null;
+  }
 
-    async delete(id: number): Promise<boolean> {
-        const result = await this._knex("video_batch").where({ id }).del();
-        return result > 0;
-    }
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex("video_batch").where({ id }).del();
+    return result > 0;
+  }
 
-    async getAll(page: number, limit: number, folderId?: number | null): Promise<IDataPaginator<IBatch>> {
-        const offset = (page - 1) * limit;
+  async getAll(
+    page: number,
+    limit: number,
+    folderId?: number | null,
+  ): Promise<IDataPaginator<IBatch>> {
+    const offset = (page - 1) * limit;
 
-        const query = this._knex("video_batch as b")
-            .innerJoin("folders as f", "b.folderId", "f.id")
-            .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"));
-        if (folderId !== undefined && folderId !== null) {
-            query.where("b.folderId", folderId);
-        }
+    const query = this._knex("video_batch as b")
+      .innerJoin("folders as f", "b.folderId", "f.id")
+      .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"));
+    if (folderId !== undefined && folderId !== null) {
+      query.where("b.folderId", folderId);
+    }
 
-        const [countResult] = await query.clone().clearSelect().count("* as count");
-        const totalCount = +countResult.count;
-        const batches = await query.clone().limit(limit).offset(offset);
+    const [countResult] = await query.clone().clearSelect().count("* as count");
+    const totalCount = +countResult.count;
+    const batches = await query.clone().limit(limit).offset(offset);
 
-        return {
-            success: true,
-            data: batches,
-            page,
-            limit,
-            count: batches.length,
-            totalCount,
-            totalPages: Math.ceil(totalCount / limit),
-        };
-    }
+    return {
+      success: true,
+      data: batches,
+      page,
+      limit,
+      count: batches.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
 
-    /**
-     * Get batches by folder ID
-     */
-    async getByFolderId(folderId: number): Promise<IBatch[]> {
-        return this._knex("video_batch as b")
-            .innerJoin("folders as f", "b.folderId", "f.id")
-            .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"))
-            .where("b.folderId", folderId)
-            .orderBy("b.created_at", "desc");
-    }
+  /**
+   * Get batches by folder ID
+   */
+  async getByFolderId(folderId: number): Promise<IBatch[]> {
+    return this._knex("video_batch as b")
+      .innerJoin("folders as f", "b.folderId", "f.id")
+      .select("b.*", this._knex.raw("to_jsonb(f.*) as folder"))
+      .where("b.folderId", folderId)
+      .orderBy("b.created_at", "desc");
+  }
 
-    /**
-     * Update batch progress
-     */
-    async updateProgress(
-        id: number,
-        completedVideos: number,
-        failedVideos: number
-    ): Promise<void> {
-        await this._knex("video_batch")
-            .where({ id })
-            .update({
-                completedVideos,
-                failedVideos,
-                updated_at: this._knex.fn.now()
-            });
-    }
+  /**
+   * Update batch progress
+   */
+  async updateProgress(
+    id: number,
+    completedVideos: number,
+    failedVideos: number,
+  ): Promise<void> {
+    await this._knex("video_batch").where({ id }).update({
+      completedVideos,
+      failedVideos,
+      updated_at: this._knex.fn.now(),
+    });
+  }
 
-    /**
-     * Mark batch as completed
-     */
-    async markCompleted(id: number): Promise<void> {
-        await this._knex("video_batch")
-            .where({ id })
-            .update({
-                status: "COMPLETED",
-                updated_at: this._knex.fn.now()
-            });
-    }
+  /**
+   * Mark batch as completed
+   */
+  async markCompleted(id: number): Promise<void> {
+    await this._knex("video_batch").where({ id }).update({
+      status: "COMPLETED",
+      updated_at: this._knex.fn.now(),
+    });
+  }
 
-    /**
-     * Mark batch as failed
-     */
-    async markFailed(id: number): Promise<void> {
-        await this._knex("video_batch")
-            .where({ id })
-            .update({
-                status: "FAILED",
-                updated_at: this._knex.fn.now()
-            });
-    }
+  /**
+   * Mark batch as failed
+   */
+  async markFailed(id: number): Promise<void> {
+    await this._knex("video_batch").where({ id }).update({
+      status: "FAILED",
+      updated_at: this._knex.fn.now(),
+    });
+  }
 }