@trafficgroup/knex-rel 0.1.8 → 0.1.10

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

@@ -2,225 +2,210 @@ import { Knex } from "knex";
 import { IBaseDAO, IDataPaginator } from "../../d.types";
 import { IVideo } from "../../interfaces/video/video.interfaces";
 import KnexManager from "../../KnexConnection";
+import { VALID_VIDEO_SORT_FIELDS, VALID_SORT_ORDERS, VIDEO_SORT_COLUMN_MAP, VideoSortField, SortOrder } from "../../constants/video.constants";
 
 export class VideoDAO implements IBaseDAO<IVideo> {
-  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
-
-  static getInstance(): Knex<any, unknown[]> {
-    return KnexManager.getConnection();
-  }
-
-  async create(item: IVideo): Promise<IVideo> {
-    const [createdVideo] = await this._knex("video")
-      .insert(item)
-      .returning("*");
-    return createdVideo;
-  }
-
-  async getById(id: number): Promise<IVideo | null> {
-    const video = await this._knex("video as v")
-      .innerJoin("folders as f", "v.folderId", "f.id")
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
-      .where("v.id", id)
-      .first();
-    return video || null;
-  }
-
-  async getByUuid(uuid: string): Promise<IVideo | null> {
-    const video = await this._knex("video as v")
-      .innerJoin("folders as f", "v.folderId", "f.id")
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
-      .where("v.uuid", uuid)
-      .first();
-    return video || null;
-  }
-
-  async update(id: number, item: Partial<IVideo>): Promise<IVideo | null> {
-    const [updatedVideo] = await this._knex("video")
-      .where({ id })
-      .update(item)
-      .returning("*");
-    return updatedVideo || null;
-  }
-
-  async delete(id: number): Promise<boolean> {
-    const result = await this._knex("video").where({ id }).del();
-    return result > 0;
-  }
-
-  // entityId corresponde al id del folder al que pertenece el video
-  async getAll(
-    page: number,
-    limit: number,
-    folderId?: number | null,
-  ): Promise<IDataPaginator<IVideo>> {
-    const offset = (page - 1) * limit;
-
-    const query = this._knex("video as v")
-      .innerJoin("folders as f", "v.folderId", "f.id")
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"));
-    if (folderId !== undefined && folderId !== null) {
-      query.where("v.folderId", folderId);
+    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+    static getInstance(): Knex<any, unknown[]> {
+        return KnexManager.getConnection();
+    }
+
+    async create(item: IVideo): Promise<IVideo> {
+        const [createdVideo] = await this._knex("video").insert(item).returning("*");
+        return createdVideo;
+    }
+
+    async getById(id: number): Promise<IVideo | null> {
+        const video = await this._knex("video as v")
+            .innerJoin("folders as f", "v.folderId", "f.id")
+            .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+            .where("v.id", id)
+            .first();
+        return video || null;
+    }
+
+    async getByUuid(uuid: string): Promise<IVideo | null> {
+        const video = await this._knex("video as v")
+            .innerJoin("folders as f", "v.folderId", "f.id")
+            .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+            .where("v.uuid", uuid)
+            .first();
+        return video || null;
     }
 
-    const [countResult] = await query.clone().clearSelect().count("* as count");
-    const totalCount = +countResult.count;
-    const videos = await query.clone().limit(limit).offset(offset);
-
-    return {
-      success: true,
-      data: videos,
-      page,
-      limit,
-      count: videos.length,
-      totalCount,
-      totalPages: Math.ceil(totalCount / limit),
-    };
-  }
-
-  async getVideoStatsByFolderIds(folderIds: number[]): Promise<{
-    total_videos: number;
-    completed_videos: number;
-    failed_videos: number;
-    processing_videos: number;
-  }> {
-    if (!folderIds || folderIds.length === 0) {
-      return {
-        total_videos: 0,
-        completed_videos: 0,
-        failed_videos: 0,
-        processing_videos: 0,
-      };
+    async update(id: number, item: Partial<IVideo>): Promise<IVideo | null> {
+        const [updatedVideo] = await this._knex("video").where({ id }).update(item).returning("*");
+        return updatedVideo || null;
     }
 
-    const result = (await this._knex("video")
-      .whereIn("folderId", folderIds)
-      .select(
-        this._knex.raw("COUNT(*) as total_videos"),
-        this._knex.raw(
-          "COUNT(CASE WHEN status = ? THEN 1 END) as completed_videos",
-          ["COMPLETED"],
-        ),
-        this._knex.raw(
-          "COUNT(CASE WHEN status = ? THEN 1 END) as failed_videos",
-          ["FAILED"],
-        ),
-        this._knex.raw(
-          "COUNT(CASE WHEN status = ? THEN 1 END) as processing_videos",
-          ["PROCESSING"],
-        ),
-      )
-      .first()) as any;
-
-    return {
-      total_videos: parseInt(result?.total_videos) || 0,
-      completed_videos: parseInt(result?.completed_videos) || 0,
-      failed_videos: parseInt(result?.failed_videos) || 0,
-      processing_videos: parseInt(result?.processing_videos) || 0,
-    };
-  }
-
-  async getCompletedVideosByFolderIds(
-    folderIds: number[],
-    videoType?: string,
-  ): Promise<IVideo[]> {
-    if (!folderIds || folderIds.length === 0) {
-      return [];
+    async delete(id: number): Promise<boolean> {
+        const result = await this._knex("video").where({ id }).del();
+        return result > 0;
+    }
+
+    // entityId corresponde al id del folder al que pertenece el video
+    async getAll(page: number, limit: number, folderId?: number | null, sortBy?: VideoSortField, sortOrder?: SortOrder): Promise<IDataPaginator<IVideo>> {
+        const offset = (page - 1) * limit;
+
+        // Validate and set defaults for sorting (defensive programming)
+        const sortField = (sortBy || 'name') as VideoSortField;
+
+        if (!VALID_VIDEO_SORT_FIELDS.includes(sortField as any)) {
+            throw new Error(`Invalid sortBy value: ${sortField}. Must be one of: ${VALID_VIDEO_SORT_FIELDS.join(', ')}`);
+        }
+
+        const sortDirection = ((sortOrder || 'DESC').toUpperCase()) as SortOrder;
+
+        if (!VALID_SORT_ORDERS.includes(sortDirection as any)) {
+            throw new Error(`Invalid sortOrder value: ${sortOrder}. Must be one of: ${VALID_SORT_ORDERS.join(', ')}`);
+        }
+
+        // Map sortBy to database column with table alias
+        const sortColumn = VIDEO_SORT_COLUMN_MAP[sortField];
+
+        const query = this._knex("video as v")
+            .innerJoin("folders as f", "v.folderId", "f.id")
+            .leftJoin("cameras as c", "v.cameraId", "c.id")
+            .select(
+                "v.*",
+                this._knex.raw("to_jsonb(f.*) as folder"),
+                "c.name as cameraName",
+                "c.uuid as cameraUuid"
+            );
+        if (folderId !== undefined && folderId !== null) {
+            query.where("v.folderId", folderId);
+        }
+
+        const [countResult] = await query.clone().clearSelect().count("* as count");
+        const totalCount = +countResult.count;
+        const videos = await query
+            .clone()
+            .orderBy(sortColumn, sortDirection.toLowerCase() as 'asc' | 'desc')
+            .limit(limit)
+            .offset(offset);
+
+        return {
+            success: true,
+            data: videos,
+            page,
+            limit,
+            count: videos.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
+
+    async getVideoStatsByFolderIds(folderIds: number[]): Promise<{
+        total_videos: number;
+        completed_videos: number;
+        failed_videos: number;
+        processing_videos: number;
+    }> {
+        if (!folderIds || folderIds.length === 0) {
+            return {
+                total_videos: 0,
+                completed_videos: 0,
+                failed_videos: 0,
+                processing_videos: 0
+            };
+        }
+
+        const result = await this._knex("video")
+            .whereIn("folderId", folderIds)
+            .select(
+                this._knex.raw('COUNT(*) as total_videos'),
+                this._knex.raw("COUNT(CASE WHEN status = ? THEN 1 END) as completed_videos", ['COMPLETED']),
+                this._knex.raw("COUNT(CASE WHEN status = ? THEN 1 END) as failed_videos", ['FAILED']),
+                this._knex.raw("COUNT(CASE WHEN status = ? THEN 1 END) as processing_videos", ['PROCESSING'])
+            )
+            .first() as any;
+
+        return {
+            total_videos: parseInt(result?.total_videos) || 0,
+            completed_videos: parseInt(result?.completed_videos) || 0,
+            failed_videos: parseInt(result?.failed_videos) || 0,
+            processing_videos: parseInt(result?.processing_videos) || 0
+        };
+    }
+
+    async getCompletedVideosByFolderIds(folderIds: number[], videoType?: string): Promise<IVideo[]> {
+        if (!folderIds || folderIds.length === 0) {
+            return [];
+        }
+
+        const query = this._knex("video")
+            .whereIn("folderId", folderIds)
+            .where("status", "COMPLETED");
+
+        if (videoType) {
+            query.where("videoType", videoType);
+        }
+
+        return await query.select("id", "name", "metadata", "results", "created_at", this._knex.raw("EXTRACT(EPOCH FROM (updated_at - created_at)) as duration"));
     }
 
-    const query = this._knex("video")
-      .whereIn("folderId", folderIds)
-      .where("status", "COMPLETED");
+    /**
+     * Update the duration in seconds for a video
+     */
+    async updateDuration(id: number, durationSeconds: number): Promise<IVideo | null> {
+        const [updatedVideo] = await this._knex("video")
+            .where({ id })
+            .update({ duration_seconds: durationSeconds, updated_at: this._knex.fn.now() })
+            .returning("*");
+        return updatedVideo || null;
+    }
 
-    if (videoType) {
-      query.where("videoType", videoType);
+    /**
+     * Get videos that don't have minute-by-minute data yet
+     */
+    async getVideosWithoutMinuteData(page: number, limit: number): Promise<IDataPaginator<IVideo>> {
+        const offset = (page - 1) * limit;
+
+        const query = this._knex("video as v")
+            .leftJoin("video_minute_results as vmr", "v.id", "vmr.video_id")
+            .whereNull("vmr.video_id")
+            .where("v.status", "COMPLETED")
+            .innerJoin("folders as f", "v.folderId", "f.id")
+            .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+            .groupBy("v.id", "f.id");
+
+        const [countResult] = await query.clone().clearSelect().count("* as count");
+        const totalCount = +countResult.count;
+        const videos = await query.clone().limit(limit).offset(offset);
+
+        return {
+            success: true,
+            data: videos,
+            page,
+            limit,
+            count: videos.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
     }
 
-    return await query.select(
-      "id",
-      "name",
-      "metadata",
-      "results",
-      "created_at",
-      this._knex.raw(
-        "EXTRACT(EPOCH FROM (updated_at - created_at)) as duration",
-      ),
-    );
-  }
-
-  /**
-   * Update the duration in seconds for a video
-   */
-  async updateDuration(
-    id: number,
-    durationSeconds: number,
-  ): Promise<IVideo | null> {
-    const [updatedVideo] = await this._knex("video")
-      .where({ id })
-      .update({
-        duration_seconds: durationSeconds,
-        updated_at: this._knex.fn.now(),
-      })
-      .returning("*");
-    return updatedVideo || null;
-  }
-
-  /**
-   * Get videos that don't have minute-by-minute data yet
-   */
-  async getVideosWithoutMinuteData(
-    page: number,
-    limit: number,
-  ): Promise<IDataPaginator<IVideo>> {
-    const offset = (page - 1) * limit;
-
-    const query = this._knex("video as v")
-      .leftJoin("video_minute_results as vmr", "v.id", "vmr.video_id")
-      .whereNull("vmr.video_id")
-      .where("v.status", "COMPLETED")
-      .innerJoin("folders as f", "v.folderId", "f.id")
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
-      .groupBy("v.id", "f.id");
-
-    const [countResult] = await query.clone().clearSelect().count("* as count");
-    const totalCount = +countResult.count;
-    const videos = await query.clone().limit(limit).offset(offset);
-
-    return {
-      success: true,
-      data: videos,
-      page,
-      limit,
-      count: videos.length,
-      totalCount,
-      totalPages: Math.ceil(totalCount / limit),
-    };
-  }
-
-  /**
-   * Get videos from same folder with same type that have metadata and are COMPLETED
-   * Suitable for use as lane annotation templates
-   */
-  async getTemplateVideos(
-    folderId: number,
-    videoType: string,
-  ): Promise<IVideo[]> {
-    try {
-      let query = this._knex("video")
-        .where("folderId", folderId)
-        .where("videoType", videoType)
-        .where("status", "COMPLETED")
-        .whereNotNull("metadata")
-        .whereRaw("metadata != '{}'");
-
-      // Apply video type specific metadata validation
-      if (videoType === "ATR") {
-        // ATR videos use lanes array structure
-        query = query.whereRaw("jsonb_array_length(metadata->'lanes') > 0");
-      } else {
-        // TMC/JUNCTION/ROUNDABOUT/PATHWAY videos use objects with pt1/pt2 structure
-        // Check if metadata has at least one key with pt1 and pt2 properties
-        query = query.whereRaw(`
+    /**
+     * Get videos from same folder with same type that have metadata and are COMPLETED
+     * Suitable for use as lane annotation templates
+     */
+    async getTemplateVideos(folderId: number, videoType: string): Promise<IVideo[]> {
+        try {
+            let query = this._knex("video")
+                .where("folderId", folderId)
+                .where("videoType", videoType)
+                .where("status", "COMPLETED")
+                .whereNotNull("metadata")
+                .whereRaw("metadata != '{}'");
+
+            // Apply video type specific metadata validation
+            if (videoType === "ATR") {
+                // ATR videos use lanes array structure
+                query = query.whereRaw("jsonb_array_length(metadata->'lanes') > 0");
+            } else {
+                // TMC/JUNCTION/ROUNDABOUT/PATHWAY videos use objects with pt1/pt2 structure
+                // Check if metadata has at least one key with pt1 and pt2 properties
+                query = query.whereRaw(`
                     EXISTS (
                         SELECT 1
                         FROM jsonb_each(metadata) as entry(key, value)
@@ -235,116 +220,157 @@ export class VideoDAO implements IBaseDAO<IVideo> {
                         AND jsonb_array_length(value->'pt2') = 2
                     )
                 `);
-      }
+            }
+
+            const videos = await query
+                .orderBy("updated_at", "desc")
+                .select("*");
+
+            return videos;
+        } catch (error) {
+            console.error("Error fetching template videos:", error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get all video IDs for a specific folder (used for cascade operations)
+     */
+    async getVideoIdsByFolderId(folderId: number): Promise<number[]> {
+        const rows = await this._knex('video')
+            .where({ folderId })
+            .select('id')
+            .orderBy('id', 'asc');
 
-      const videos = await query.orderBy("updated_at", "desc").select("*");
+        return rows.map(row => row.id);
+    }
+
+    /**
+     * Get videos by batch ID
+     */
+    async getByBatchId(batchId: number): Promise<IVideo[]> {
+        return this._knex("video as v")
+            .innerJoin("folders as f", "v.folderId", "f.id")
+            .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+            .where("v.batchId", batchId)
+            .orderBy("v.created_at", "asc");
+    }
 
-      return videos;
-    } catch (error) {
-      console.error("Error fetching template videos:", error);
-      throw error;
+    /**
+     * Get videos sorted chronologically by recording start time for a study
+     */
+    async getChronologicalVideos(
+        studyId: number,
+        startDate?: Date,
+        endDate?: Date
+    ): Promise<IDataPaginator<IVideo>> {
+        let query = this._knex("video as v")
+            .innerJoin("folders as f", "v.folderId", "f.id")
+            .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+            .where("f.studyId", studyId)
+            .whereNotNull("v.recordingStartedAt");
+
+        if (startDate) {
+            query = query.where("v.recordingStartedAt", ">=", startDate);
+        }
+
+        if (endDate) {
+            query = query.where("v.recordingStartedAt", "<=", endDate);
+        }
+
+        const [countResult] = await query.clone().clearSelect().count("* as count");
+        const totalCount = +countResult.count;
+        const videos = await query.clone().orderBy("v.recordingStartedAt", "asc");
+
+        return {
+            success: true,
+            data: videos,
+            page: 1,
+            limit: totalCount,
+            count: videos.length,
+            totalCount,
+            totalPages: 1,
+        };
     }
-  }
-
-  /**
-   * Get all video IDs for a specific folder (used for cascade operations)
-   */
-  async getVideoIdsByFolderId(folderId: number): Promise<number[]> {
-    const rows = await this._knex("video")
-      .where({ folderId })
-      .select("id")
-      .orderBy("id", "asc");
-
-    return rows.map((row) => row.id);
-  }
-
-  /**
-   * Get videos by batch ID
-   */
-  async getByBatchId(batchId: number): Promise<IVideo[]> {
-    return this._knex("video as v")
-      .innerJoin("folders as f", "v.folderId", "f.id")
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
-      .where("v.batchId", batchId)
-      .orderBy("v.created_at", "asc");
-  }
-
-  /**
-   * Get videos sorted chronologically by recording start time for a study
-   */
-  async getChronologicalVideos(
-    studyId: number,
-    startDate?: Date,
-    endDate?: Date,
-  ): Promise<IDataPaginator<IVideo>> {
-    let query = this._knex("video as v")
-      .innerJoin("folders as f", "v.folderId", "f.id")
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
-      .where("f.studyId", studyId)
-      .whereNotNull("v.recordingStartedAt");
-
-    if (startDate) {
-      query = query.where("v.recordingStartedAt", ">=", startDate);
+
+    /**
+     * Update recording start time for a video
+     */
+    async updateRecordingStartTime(id: number, recordingStartedAt: Date): Promise<void> {
+        await this._knex("video")
+            .where({ id })
+            .update({
+                recordingStartedAt,
+                updated_at: this._knex.fn.now()
+            });
     }
 
-    if (endDate) {
-      query = query.where("v.recordingStartedAt", "<=", endDate);
+    /**
+     * Update trim settings for a video
+     */
+    async updateTrimSettings(
+        id: number,
+        trimEnabled: boolean,
+        trimPeriods: { startTime: string; endTime: string }[] | null
+    ): Promise<void> {
+        await this._knex("video")
+            .where({ id })
+            .update({
+                trimEnabled,
+                trimPeriods: trimPeriods ? JSON.stringify(trimPeriods) : null,
+                updated_at: this._knex.fn.now()
+            });
     }
 
-    const [countResult] = await query.clone().clearSelect().count("* as count");
-    const totalCount = +countResult.count;
-    const videos = await query.clone().orderBy("v.recordingStartedAt", "asc");
-
-    return {
-      success: true,
-      data: videos,
-      page: 1,
-      limit: totalCount,
-      count: videos.length,
-      totalCount,
-      totalPages: 1,
-    };
-  }
-
-  /**
-   * Update recording start time for a video
-   */
-  async updateRecordingStartTime(
-    id: number,
-    recordingStartedAt: Date,
-  ): Promise<void> {
-    await this._knex("video").where({ id }).update({
-      recordingStartedAt,
-      updated_at: this._knex.fn.now(),
-    });
-  }
-
-  /**
-   * Update trim settings for a video
-   */
-  async updateTrimSettings(
-    id: number,
-    trimEnabled: boolean,
-    trimPeriods: { startTime: string; endTime: string }[] | null,
-  ): Promise<void> {
-    await this._knex("video")
-      .where({ id })
-      .update({
-        trimEnabled,
-        trimPeriods: trimPeriods ? JSON.stringify(trimPeriods) : null,
-        updated_at: this._knex.fn.now(),
-      });
-  }
-
-  /**
-   * Get videos with trimming enabled for a folder
-   */
-  async getVideosWithTrimming(folderId: number): Promise<IVideo[]> {
-    return this._knex("video as v")
-      .innerJoin("folders as f", "v.folderId", "f.id")
-      .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
-      .where("v.folderId", folderId)
-      .where("v.trimEnabled", true)
-      .orderBy("v.recordingStartedAt", "asc");
-  }
+    /**
+     * Get videos with trimming enabled for a folder
+     */
+    async getVideosWithTrimming(folderId: number): Promise<IVideo[]> {
+        return this._knex("video as v")
+            .innerJoin("folders as f", "v.folderId", "f.id")
+            .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+            .where("v.folderId", folderId)
+            .where("v.trimEnabled", true)
+            .orderBy("v.recordingStartedAt", "asc");
+    }
+
+    /**
+     * Get paginated videos for a specific camera
+     * @param cameraId - The camera ID
+     * @param page - Page number
+     * @param limit - Items per page
+     */
+    async getVideosByCameraId(
+        cameraId: number,
+        page: number,
+        limit: number
+    ): Promise<IDataPaginator<IVideo>> {
+        const offset = (page - 1) * limit;
+
+        const query = this._knex("video as v")
+            .innerJoin("folders as f", "v.folderId", "f.id")
+            .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+            .where("v.cameraId", cameraId);
+
+        const [countResult] = await query.clone()
+            .clearSelect()
+            .count("* as count");
+        const totalCount = +countResult.count;
+
+        const videos = await query
+            .clone()
+            .limit(limit)
+            .offset(offset)
+            .orderBy("v.created_at", "desc");
+
+        return {
+            success: true,
+            data: videos,
+            page,
+            limit,
+            count: videos.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit)
+        };
+    }
 }