@trafficgroup/knex-rel 0.1.11 → 0.1.12

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

@@ -2,210 +2,264 @@ 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";
+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;
+  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,
+    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(", ")}`,
+      );
     }
 
-    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 sortDirection = (sortOrder || "DESC").toUpperCase() as SortOrder;
 
-    async delete(id: number): Promise<boolean> {
-        const result = await this._knex("video").where({ id }).del();
-        return result > 0;
+    if (!VALID_SORT_ORDERS.includes(sortDirection as any)) {
+      throw new Error(
+        `Invalid sortOrder value: ${sortOrder}. Must be one of: ${VALID_SORT_ORDERS.join(", ")}`,
+      );
     }
 
-    // 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),
-        };
+    // 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);
     }
 
-    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
-        };
+    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,
+      };
     }
 
-    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 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 [];
     }
 
-    /**
-     * 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;
-    }
+    const query = this._knex("video")
+      .whereIn("folderId", folderIds)
+      .where("status", "COMPLETED");
 
-    /**
-     * 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),
-        };
+    if (videoType) {
+      query.where("videoType", videoType);
     }
 
-    /**
-     * 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(`
+    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(`
                     EXISTS (
                         SELECT 1
                         FROM jsonb_each(metadata) as entry(key, value)
@@ -220,157 +274,154 @@ export class VideoDAO implements IBaseDAO<IVideo> {
                         AND jsonb_array_length(value->'pt2') = 2
                     )
                 `);
-            }
+      }
 
-            const videos = await query
-                .orderBy("updated_at", "desc")
-                .select("*");
+      const videos = await query.orderBy("updated_at", "desc").select("*");
 
-            return videos;
-        } catch (error) {
-            console.error("Error fetching template videos:", error);
-            throw error;
-        }
+      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');
-
-        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);
-        }
-
-        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()
-            });
-    }
-
-    /**
-     * 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)
-        };
-    }
+    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 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),
+    };
+  }
 }