@trafficgroup/knex-rel 0.1.11 → 0.1.12

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;
+  }
 }

package/src/dao/chat/chat.dao.ts

@@ -1,6 +1,10 @@
 import { Knex } from "knex";
 import { IBaseDAO, IDataPaginator } from "../../d.types";
-import { IChat, IChatCreate, IChatUpdate } from '../../interfaces/chat/chat.interfaces';
+import {
+  IChat,
+  IChatCreate,
+  IChatUpdate,
+} from "../../interfaces/chat/chat.interfaces";
 import KnexManager from "../../KnexConnection";
 
 export interface IChatPaginatorResponse extends IDataPaginator<IChat> {
@@ -11,23 +15,17 @@ export class ChatDAO implements IBaseDAO<IChat> {
   private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
 
   async create(item: IChatCreate): Promise<IChat> {
-    const [result] = await this._knex('chat')
-      .insert(item)
-      .returning('*');
+    const [result] = await this._knex("chat").insert(item).returning("*");
     return result;
   }
 
   async getById(id: number): Promise<IChat | null> {
-    const result = await this._knex('chat')
-      .where('id', id)
-      .first();
+    const result = await this._knex("chat").where("id", id).first();
     return result || null;
   }
 
   async getByUuid(uuid: string): Promise<IChat | null> {
-    const result = await this._knex('chat')
-      .where('uuid', uuid)
-      .first();
+    const result = await this._knex("chat").where("uuid", uuid).first();
     return result || null;
   }
 
@@ -35,11 +33,11 @@ export class ChatDAO implements IBaseDAO<IChat> {
     const offset = (page - 1) * limit;
 
     const [results, [{ count }]] = await Promise.all([
-      this._knex('chat')
-        .orderBy('created_at', 'desc')
+      this._knex("chat")
+        .orderBy("created_at", "desc")
         .limit(limit)
         .offset(offset),
-      this._knex('chat').count('* as count')
+      this._knex("chat").count("* as count"),
     ]);
 
     const totalCount = parseInt(count as string);
@@ -50,40 +48,40 @@ export class ChatDAO implements IBaseDAO<IChat> {
       limit,
       count: results.length,
       totalCount,
-      totalPages: Math.ceil(totalCount / limit)
+      totalPages: Math.ceil(totalCount / limit),
     };
   }
 
   async update(id: number, item: IChatUpdate): Promise<IChat | null> {
-    const [result] = await this._knex('chat')
-      .where('id', id)
+    const [result] = await this._knex("chat")
+      .where("id", id)
       .update({
         ...item,
-        updated_at: new Date()
+        updated_at: new Date(),
       })
-      .returning('*');
+      .returning("*");
     return result || null;
   }
 
   async delete(id: number): Promise<boolean> {
-    const result = await this._knex('chat')
-      .where('id', id)
-      .delete();
+    const result = await this._knex("chat").where("id", id).delete();
     return result > 0;
   }
 
-  async getByUserId(userId: number, page = 1, limit = 10): Promise<IDataPaginator<IChat>> {
+  async getByUserId(
+    userId: number,
+    page = 1,
+    limit = 10,
+  ): Promise<IDataPaginator<IChat>> {
     const offset = (page - 1) * limit;
 
     const [results, [{ count }]] = await Promise.all([
-      this._knex('chat')
-        .where('userId', userId)
-        .orderBy('created_at', 'desc')
+      this._knex("chat")
+        .where("userId", userId)
+        .orderBy("created_at", "desc")
         .limit(limit)
         .offset(offset),
-      this._knex('chat')
-        .where('userId', userId)
-        .count('* as count')
+      this._knex("chat").where("userId", userId).count("* as count"),
     ]);
 
     const totalCount = parseInt(count as string);
@@ -94,36 +92,38 @@ export class ChatDAO implements IBaseDAO<IChat> {
       limit,
       count: results.length,
       totalCount,
-      totalPages: Math.ceil(totalCount / limit)
+      totalPages: Math.ceil(totalCount / limit),
     };
   }
 
-  async getActiveByUserId(userId: number, page = 1, limit = 10, query?: string): Promise<IChatPaginatorResponse> {
+  async getActiveByUserId(
+    userId: number,
+    page = 1,
+    limit = 10,
+    query?: string,
+  ): Promise<IChatPaginatorResponse> {
     const offset = (page - 1) * limit;
 
     // Build data query
-    let dataQuery = this._knex('chat')
-      .where('userId', userId)
-      .where('status', 'active');
+    let dataQuery = this._knex("chat")
+      .where("userId", userId)
+      .where("status", "active");
 
     // Build count query
-    let countQuery = this._knex('chat')
-      .where('userId', userId)
-      .where('status', 'active');
+    let countQuery = this._knex("chat")
+      .where("userId", userId)
+      .where("status", "active");
 
     // Apply search filter if query is provided
     if (query && query.trim()) {
       const searchTerm = `%${query.trim()}%`;
-      dataQuery = dataQuery.where('title', 'ILIKE', searchTerm);
-      countQuery = countQuery.where('title', 'ILIKE', searchTerm);
+      dataQuery = dataQuery.where("title", "ILIKE", searchTerm);
+      countQuery = countQuery.where("title", "ILIKE", searchTerm);
     }
 
     const [results, [{ count }]] = await Promise.all([
-      dataQuery
-        .orderBy('created_at', 'desc')
-        .limit(limit)
-        .offset(offset),
-      countQuery.count('* as count')
+      dataQuery.orderBy("created_at", "desc").limit(limit).offset(offset),
+      countQuery.count("* as count"),
     ]);
 
     const totalCount = parseInt(count as string);
@@ -138,7 +138,7 @@ export class ChatDAO implements IBaseDAO<IChat> {
       count: results.length,
       totalCount,
       totalPages,
-      hasMore
+      hasMore,
     };
   }
-}
+}

package/src/dao/folder/folder.dao.ts

@@ -2,71 +2,128 @@ import { Knex } from "knex";
 import { IBaseDAO, IDataPaginator } from "../../d.types";
 import { IFolder } from "../../interfaces/folder/folder.interfaces";
 import KnexManager from "../../KnexConnection";
+import {
+  FolderSortField,
+  FolderStatus,
+  FOLDER_SORT_COLUMN_MAP,
+} from "../../constants/folder.constants";
+import { SortOrder } from "../../constants/video.constants";
+
+export interface IFolderFilters {
+  studyId?: number | null;
+  status?: FolderStatus;
+  search?: string;
+  sortBy?: FolderSortField;
+  sortOrder?: SortOrder;
+}
 
 export class FolderDAO implements IBaseDAO<IFolder> {
-    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
 
-    async create(item: IFolder): Promise<IFolder> {
-        const [createdFolder] = await this._knex("folders").insert(item).returning("*");
-        return createdFolder;
-    }
+  async create(item: IFolder): Promise<IFolder> {
+    const [createdFolder] = await this._knex("folders")
+      .insert(item)
+      .returning("*");
+    return createdFolder;
+  }
 
-    async getById(id: number): Promise<IFolder | null> {
-        const folder = await this._knex("folders as f")
-            .innerJoin("study as s", "f.studyId", "s.id")
-            .select("f.*", this._knex.raw("to_jsonb(s.*) as study"))
-            .where("f.id", id)
-            .first();
-        return folder || null;
-    }
+  async getById(id: number): Promise<IFolder | null> {
+    const folder = await this._knex("folders as f")
+      .innerJoin("study as s", "f.studyId", "s.id")
+      .select("f.*", this._knex.raw("to_jsonb(s.*) as study"))
+      .where("f.id", id)
+      .first();
+    return folder || null;
+  }
 
-    async getByUuid(uuid: string): Promise<IFolder | null> {
-        const folder = await this._knex("folders as f")
-            .innerJoin("study as s", "f.studyId", "s.id")
-            .select("f.*", this._knex.raw("to_jsonb(s.*) as study"))
-            .where("f.uuid", uuid)
-            .first();
-        return folder || null;
-    }
+  async getByUuid(uuid: string): Promise<IFolder | null> {
+    const folder = await this._knex("folders as f")
+      .innerJoin("study as s", "f.studyId", "s.id")
+      .select("f.*", this._knex.raw("to_jsonb(s.*) as study"))
+      .where("f.uuid", uuid)
+      .first();
+    return folder || null;
+  }
 
-    async update(id: number, item: Partial<IFolder>): Promise<IFolder | null> {
-        const [updatedFolder] = await this._knex("folders").where({ id }).update(item).returning("*");
-        return updatedFolder || null;
-    }
+  async update(id: number, item: Partial<IFolder>): Promise<IFolder | null> {
+    const [updatedFolder] = await this._knex("folders")
+      .where({ id })
+      .update(item)
+      .returning("*");
+    return updatedFolder || null;
+  }
 
-    async delete(id: number): Promise<boolean> {
-        const result = await this._knex("folders").where({ id }).del();
-        return result > 0;
-    }
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex("folders").where({ id }).del();
+    return result > 0;
+  }
+
+  async getAll(
+    page: number,
+    limit: number,
+    filters?: IFolderFilters,
+  ): Promise<IDataPaginator<IFolder>> {
+    const offset = (page - 1) * limit;
+
+    const query = this._knex("folders as f")
+      .innerJoin("study as s", "f.studyId", "s.id")
+      .leftJoin("locations as l", "s.locationId", "l.id")
+      .select(
+        "f.*",
+        this._knex.raw("to_jsonb(s.*) as study"),
+        "l.name as locationName",
+        "l.uuid as locationUuid",
+      );
 
-    async getAll(page: number, limit: number, studyId?: number | null): Promise<IDataPaginator<IFolder>> {
-        const offset = (page - 1) * limit;
+    // Apply filters
+    if (filters) {
+      // Filter by studyId
+      if (filters.studyId !== undefined && filters.studyId !== null) {
+        query.where("f.studyId", filters.studyId);
+      }
 
-        const query = this._knex("folders as f")
-            .innerJoin("study as s", "f.studyId", "s.id")
-            .leftJoin("locations as l", "s.locationId", "l.id")
-            .select(
-                "f.*",
-                this._knex.raw("to_jsonb(s.*) as study"),
-                "l.name as locationName",
-                "l.uuid as locationUuid"
-            );
-        if (studyId !== undefined && studyId !== null) {
-            query.where("f.studyId", studyId);
-        }
+      // Filter by status
+      if (filters.status) {
+        query.where("f.status", filters.status);
+      }
 
-        const [countResult] = await query.clone().clearSelect().count("* as count");
-        const totalCount = +countResult.count;
-        const folders = await query.clone().limit(limit).offset(offset);
+      // Search by name (case-insensitive)
+      if (filters.search) {
+        query.whereRaw("LOWER(f.name) LIKE ?", [
+          `%${filters.search.toLowerCase()}%`,
+        ]);
+      }
 
-        return {
-            success: true,
-            data: folders,
-            page,
-            limit,
-            count: folders.length,
-            totalCount,
-            totalPages: Math.ceil(totalCount / limit),
-        };
+      // Apply sorting
+      if (filters.sortBy) {
+        const columnName = FOLDER_SORT_COLUMN_MAP[filters.sortBy];
+        const order = filters.sortOrder || "DESC";
+        query.orderBy(columnName, order);
+      } else {
+        // Default sort by created_at DESC
+        query.orderBy("f.created_at", "DESC");
+      }
+    } else {
+      // Default sort by created_at DESC
+      query.orderBy("f.created_at", "DESC");
     }
+
+    const [countResult] = await query
+      .clone()
+      .clearSelect()
+      .clearOrder()
+      .count("* as count");
+    const totalCount = +countResult.count;
+    const folders = await query.clone().limit(limit).offset(offset);
+
+    return {
+      success: true,
+      data: folders,
+      page,
+      limit,
+      count: folders.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit),
+    };
+  }
 }