@trafficgroup/knex-rel 0.1.8 → 0.1.10

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

@@ -4,61 +4,58 @@ 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,118 +4,115 @@ 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()
+            });
+    }
 }

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

@@ -1,154 +1,134 @@
 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> {
-  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),
-    };
-  }
-
-  async getByName(name: string): Promise<ICamera | null> {
-    const camera = await this._knex("cameras").where({ name }).first();
-    return camera || null;
-  }
-
-  async getCamerasNearCoordinates(
-    longitude: number,
-    latitude: number,
-    radiusKm: number = 1,
-  ): Promise<ICamera[]> {
-    // Using ST_DWithin for geographic distance calculation
-    // This is a PostgreSQL-specific query for geospatial operations
-    const cameras = await this._knex("cameras").whereRaw(
-      `ST_DWithin(
-                    ST_MakePoint(longitude, latitude)::geography,
-                    ST_MakePoint(?, ?)::geography,
-                    ?
-                )`,
-      [longitude, latitude, radiusKm * 1000], // Convert km to meters
-    );
-    return cameras;
-  }
-
-  /**
-   * Get all cameras with optional search filter by name (case-insensitive partial match)
-   */
-  async getAllWithSearch(
-    page: number,
-    limit: number,
-    name?: string,
-  ): Promise<IDataPaginator<ICamera>> {
-    const offset = (page - 1) * limit;
-
-    let query = this._knex("cameras");
-
-    // 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}%`);
+    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);
+        }
+
+        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);
+        }
+
+        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)
+        };
     }
 
-    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),
-    };
-  }
-
-  /**
-   * Get paginated videos for a specific camera with folder data included
-   */
-  async getVideosByCamera(
-    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);
-
-    // 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)
-      .orderBy("v.created_at", "desc");
-
-    return {
-      success: true,
-      data: videos,
-      page,
-      limit,
-      count: videos.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;
+    }
 }