@trafficgroup/knex-rel 0.1.19 → 0.1.20

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

@@ -4,115 +4,160 @@ 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;
-
-        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);
-
-        return {
-            success: true,
-            data: batches,
-            page,
-            limit,
-            count: batches.length,
-            totalCount,
-            totalPages: Math.ceil(totalCount / limit),
-        };
-    }
+  async getAll(
+    page: number,
+    limit: number,
+    folderId?: number | null,
+  ): Promise<IDataPaginator<IBatch>> {
+    const offset = (page - 1) * 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");
+    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);
     }
 
-    /**
-     * 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()
-            });
-    }
+    const [countResult] = await query.clone().clearSelect().count("* as count");
+    const totalCount = +countResult.count;
+    const batches = await query.clone().limit(limit).offset(offset);
 
-    /**
-     * 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()
-            });
-    }
+    return {
+      success: true,
+      data: batches,
+      page,
+      limit,
+      count: batches.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
 
-    /**
-     * 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()
-            });
-    }
+  /**
+   * 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(),
+    });
+  }
+
+  /**
+   * Atomically increment completedVideos counter with row-level locking.
+   * Returns the updated batch with fresh counters.
+   */
+  async incrementCompleted(id: number): Promise<IBatch> {
+    return this._knex.transaction(async (trx) => {
+      const batch = await trx("video_batch").where({ id }).forUpdate().first();
+
+      if (!batch) throw new Error(`Batch ${id} not found`);
+
+      const newCompleted = batch.completedVideos + 1;
+
+      await trx("video_batch").where({ id }).update({
+        completedVideos: newCompleted,
+        updated_at: trx.fn.now(),
+      });
+
+      return { ...batch, completedVideos: newCompleted };
+    });
+  }
+
+  /**
+   * Atomically increment failedVideos counter with row-level locking.
+   * Returns the updated batch with fresh counters.
+   */
+  async incrementFailed(id: number): Promise<IBatch> {
+    return this._knex.transaction(async (trx) => {
+      const batch = await trx("video_batch").where({ id }).forUpdate().first();
+
+      if (!batch) throw new Error(`Batch ${id} not found`);
+
+      const newFailed = batch.failedVideos + 1;
+
+      await trx("video_batch").where({ id }).update({
+        failedVideos: newFailed,
+        updated_at: trx.fn.now(),
+      });
+
+      return { ...batch, failedVideos: newFailed };
+    });
+  }
+
+  /**
+   * 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(),
+    });
+  }
 }

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

@@ -4,131 +4,134 @@ import { ICamera } from "../../interfaces/camera/camera.interfaces";
 import KnexManager from "../../KnexConnection";
 
 export class CameraDAO implements IBaseDAO<ICamera> {
-    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
-
-    async create(item: ICamera): Promise<ICamera> {
-        const [createdCamera] = await this._knex("cameras").insert(item).returning("*");
-        return createdCamera;
-    }
-
-    async getById(id: number): Promise<ICamera | null> {
-        const camera = await this._knex("cameras").where({ id }).first();
-        return camera || null;
-    }
-
-    async getByUuid(uuid: string): Promise<ICamera | null> {
-        const camera = await this._knex("cameras").where({ uuid }).first();
-        return camera || null;
-    }
-
-    async update(id: number, item: Partial<ICamera>): Promise<ICamera | null> {
-        const [updatedCamera] = await this._knex("cameras").where({ id }).update(item).returning("*");
-        return updatedCamera || null;
-    }
-
-    async delete(id: number): Promise<boolean> {
-        const result = await this._knex("cameras").where({ id }).del();
-        return result > 0;
+  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+  async create(item: ICamera): Promise<ICamera> {
+    const [createdCamera] = await this._knex("cameras")
+      .insert(item)
+      .returning("*");
+    return createdCamera;
+  }
+
+  async getById(id: number): Promise<ICamera | null> {
+    const camera = await this._knex("cameras").where({ id }).first();
+    return camera || null;
+  }
+
+  async getByUuid(uuid: string): Promise<ICamera | null> {
+    const camera = await this._knex("cameras").where({ uuid }).first();
+    return camera || null;
+  }
+
+  async update(id: number, item: Partial<ICamera>): Promise<ICamera | null> {
+    const [updatedCamera] = await this._knex("cameras")
+      .where({ id })
+      .update(item)
+      .returning("*");
+    return updatedCamera || null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex("cameras").where({ id }).del();
+    return result > 0;
+  }
+
+  async getAll(page: number, limit: number): Promise<IDataPaginator<ICamera>> {
+    const offset = (page - 1) * limit;
+
+    const [countResult] = await this._knex("cameras").count("* as count");
+    const totalCount = +countResult.count;
+    const cameras = await this._knex("cameras").limit(limit).offset(offset);
+
+    return {
+      success: true,
+      data: cameras,
+      page,
+      limit,
+      count: cameras.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
+
+  /**
+   * Get cameras for a specific location
+   * @param locationId - The location ID
+   * @param status - Optional filter by camera status
+   */
+  async getCamerasByLocationId(
+    locationId: number,
+    status?: string,
+  ): Promise<ICamera[]> {
+    let query = this._knex("cameras").where("locationId", locationId);
+
+    if (status) {
+      query = query.where("status", status);
     }
 
-    async getAll(page: number, limit: number): Promise<IDataPaginator<ICamera>> {
-        const offset = (page - 1) * limit;
-
-        const [countResult] = await this._knex("cameras").count("* as count");
-        const totalCount = +countResult.count;
-        const cameras = await this._knex("cameras").limit(limit).offset(offset);
-
-        return {
-            success: true,
-            data: cameras,
-            page,
-            limit,
-            count: cameras.length,
-            totalCount,
-            totalPages: Math.ceil(totalCount / limit),
-        };
+    return query.orderBy("name", "asc");
+  }
+
+  /**
+   * Get cameras for a specific location with pagination
+   * @param locationId - The location ID
+   * @param page - Page number
+   * @param limit - Items per page
+   * @param status - Optional filter by camera status
+   */
+  async getCamerasByLocationIdPaginated(
+    locationId: number,
+    page: number,
+    limit: number,
+    status?: string,
+  ): Promise<IDataPaginator<ICamera>> {
+    const offset = (page - 1) * limit;
+
+    let query = this._knex("cameras").where("locationId", locationId);
+
+    if (status) {
+      query = query.where("status", status);
     }
 
-    /**
-     * Get cameras for a specific location
-     * @param locationId - The location ID
-     * @param status - Optional filter by camera status
-     */
-    async getCamerasByLocationId(
-        locationId: number,
-        status?: string
-    ): Promise<ICamera[]> {
-        let query = this._knex("cameras")
-            .where("locationId", locationId);
-
-        if (status) {
-            query = query.where("status", status);
-        }
-
-        return query.orderBy("name", "asc");
+    const [countResult] = await query.clone().count("* as count");
+    const totalCount = +countResult.count;
+    const cameras = await query
+      .clone()
+      .limit(limit)
+      .offset(offset)
+      .orderBy("name", "asc");
+
+    return {
+      success: true,
+      data: cameras,
+      page,
+      limit,
+      count: cameras.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
+
+  /**
+   * Check if a camera name already exists for a location
+   * @param name - Camera name
+   * @param locationId - Location ID
+   * @param excludeId - Optional camera ID to exclude (for update operations)
+   */
+  async existsByNameAndLocation(
+    name: string,
+    locationId: number,
+    excludeId?: number,
+  ): Promise<boolean> {
+    let query = this._knex("cameras")
+      .where("locationId", locationId)
+      .where("name", name);
+
+    if (excludeId !== undefined) {
+      query = query.whereNot("id", excludeId);
     }
 
-    /**
-     * Get cameras for a specific location with pagination
-     * @param locationId - The location ID
-     * @param page - Page number
-     * @param limit - Items per page
-     * @param status - Optional filter by camera status
-     */
-    async getCamerasByLocationIdPaginated(
-        locationId: number,
-        page: number,
-        limit: number,
-        status?: string
-    ): Promise<IDataPaginator<ICamera>> {
-        const offset = (page - 1) * limit;
-
-        let query = this._knex("cameras")
-            .where("locationId", locationId);
-
-        if (status) {
-            query = query.where("status", status);
-        }
-
-        const [countResult] = await query.clone().count("* as count");
-        const totalCount = +countResult.count;
-        const cameras = await query
-            .clone()
-            .limit(limit)
-            .offset(offset)
-            .orderBy("name", "asc");
-
-        return {
-            success: true,
-            data: cameras,
-            page,
-            limit,
-            count: cameras.length,
-            totalCount,
-            totalPages: Math.ceil(totalCount / limit)
-        };
-    }
-
-    /**
-     * Check if a camera name already exists for a location
-     * @param name - Camera name
-     * @param locationId - Location ID
-     * @param excludeId - Optional camera ID to exclude (for update operations)
-     */
-    async existsByNameAndLocation(
-        name: string,
-        locationId: number,
-        excludeId?: number
-    ): Promise<boolean> {
-        let query = this._knex("cameras")
-            .where("locationId", locationId)
-            .where("name", name);
-
-        if (excludeId !== undefined) {
-            query = query.whereNot("id", excludeId);
-        }
-
-        const result = await query.first();
-        return result !== null && result !== undefined;
-    }
+    const result = await query.first();
+    return result !== null && result !== undefined;
+  }
 }