@trafficgroup/knex-rel 0.1.8 → 0.1.10

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

@@ -1,39 +1,41 @@
 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 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;
   }
 
   async getAll(page = 1, limit = 10): Promise<IDataPaginator<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);
@@ -44,40 +46,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);
@@ -88,28 +90,24 @@ 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,
-  ): Promise<IDataPaginator<IChat>> {
+  async getActiveByUserId(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)
-        .where("status", "active")
-        .orderBy("created_at", "desc")
+      this._knex('chat')
+        .where('userId', userId)
+        .where('status', 'active')
+        .orderBy('created_at', 'desc')
         .limit(limit)
         .offset(offset),
-      this._knex("chat")
-        .where("userId", userId)
-        .where("status", "active")
-        .count("* as count"),
+      this._knex('chat')
+        .where('userId', userId)
+        .where('status', 'active')
+        .count('* as count')
     ]);
 
     const totalCount = parseInt(count as string);
@@ -120,7 +118,7 @@ export class ChatDAO implements IBaseDAO<IChat> {
       limit,
       count: results.length,
       totalCount,
-      totalPages: Math.ceil(totalCount / limit),
+      totalPages: Math.ceil(totalCount / limit)
     };
   }
-}
+}

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

@@ -4,72 +4,69 @@ import { IFolder } from "../../interfaces/folder/folder.interfaces";
 import KnexManager from "../../KnexConnection";
 
 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,
-    studyId?: number | null,
-  ): Promise<IDataPaginator<IFolder>> {
-    const offset = (page - 1) * limit;
+    async getAll(page: number, limit: number, studyId?: number | null): Promise<IDataPaginator<IFolder>> {
+        const offset = (page - 1) * limit;
 
-    const query = this._knex("folders as f")
-      .innerJoin("study as s", "f.studyId", "s.id")
-      .select("f.*", this._knex.raw("to_jsonb(s.*) as study"));
-    if (studyId !== undefined && studyId !== null) {
-      query.where("f.studyId", 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);
+        }
 
-    const [countResult] = await query.clone().clearSelect().count("* as count");
-    const totalCount = +countResult.count;
-    const folders = await query.clone().limit(limit).offset(offset);
+        const [countResult] = await query.clone().clearSelect().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),
-    };
-  }
+        return {
+            success: true,
+            data: folders,
+            page,
+            limit,
+            count: folders.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
 }

package/src/dao/location/location.dao.ts

@@ -0,0 +1,101 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { ILocation } from "../../interfaces/location/location.interfaces";
+import { IVideo } from "../../interfaces/video/video.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class LocationDAO implements IBaseDAO<ILocation> {
+    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+    async create(item: ILocation): Promise<ILocation> {
+        const [createdLocation] = await this._knex("locations").insert(item).returning("*");
+        return createdLocation;
+    }
+
+    async getById(id: number): Promise<ILocation | null> {
+        const location = await this._knex("locations").where({ id }).first();
+        return location || null;
+    }
+
+    async getByUuid(uuid: string): Promise<ILocation | null> {
+        const location = await this._knex("locations").where({ uuid }).first();
+        return location || null;
+    }
+
+    async update(id: number, item: Partial<ILocation>): Promise<ILocation | null> {
+        const [updatedLocation] = await this._knex("locations").where({ id }).update(item).returning("*");
+        return updatedLocation || null;
+    }
+
+    async delete(id: number): Promise<boolean> {
+        const result = await this._knex("locations").where({ id }).del();
+        return result > 0;
+    }
+
+    async getAll(page: number, limit: number): Promise<IDataPaginator<ILocation>> {
+        const offset = (page - 1) * limit;
+
+        const [countResult] = await this._knex("locations").count("* as count");
+        const totalCount = +countResult.count;
+        const locations = await this._knex("locations").limit(limit).offset(offset);
+
+        return {
+            success: true,
+            data: locations,
+            page,
+            limit,
+            count: locations.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
+
+    async getByName(name: string): Promise<ILocation | null> {
+        const location = await this._knex("locations").where({ name }).first();
+        return location || null;
+    }
+
+    async getLocationsNearCoordinates(longitude: number, latitude: number, radiusKm: number = 1): Promise<ILocation[]> {
+        // Using ST_DWithin for geographic distance calculation
+        // This is a PostgreSQL-specific query for geospatial operations
+        const locations = await this._knex("locations")
+            .whereRaw(
+                `ST_DWithin(
+                    ST_MakePoint(longitude, latitude)::geography,
+                    ST_MakePoint(?, ?)::geography,
+                    ?
+                )`,
+                [longitude, latitude, radiusKm * 1000] // Convert km to meters
+            );
+        return locations;
+    }
+
+    /**
+     * Get all locations with optional search filter by name (case-insensitive partial match)
+     */
+    async getAllWithSearch(page: number, limit: number, name?: string): Promise<IDataPaginator<ILocation>> {
+        const offset = (page - 1) * limit;
+
+        let query = this._knex("locations");
+
+        // 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}%`);
+        }
+
+        const [countResult] = await query.clone().count("* as count");
+        const totalCount = +countResult.count;
+        const locations = await query.clone().limit(limit).offset(offset).orderBy('name', 'asc');
+
+        return {
+            success: true,
+            data: locations,
+            page,
+            limit,
+            count: locations.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
+}

package/src/dao/message/message.dao.ts

@@ -1,22 +1,22 @@
 import { Knex } from "knex";
 import { IBaseDAO, IDataPaginator } from "../../d.types";
-import {
-  IMessage,
-  IMessageCreate,
-  IMessageUpdate,
-} from "../../interfaces/message/message.interfaces";
+import { IMessage, IMessageCreate, IMessageUpdate } from '../../interfaces/message/message.interfaces';
 import KnexManager from "../../KnexConnection";
 
 export class MessageDAO implements IBaseDAO<IMessage> {
   private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
 
   async create(item: IMessageCreate): Promise<IMessage> {
-    const [result] = await this._knex("message").insert(item).returning("*");
+    const [result] = await this._knex('message')
+      .insert(item)
+      .returning('*');
     return result;
   }
 
   async getById(id: number): Promise<IMessage | null> {
-    const result = await this._knex("message").where("id", id).first();
+    const result = await this._knex('message')
+      .where('id', id)
+      .first();
     return result || null;
   }
 
@@ -27,13 +27,13 @@ export class MessageDAO implements IBaseDAO<IMessage> {
 
   async getAll(page = 1, limit = 10): Promise<IDataPaginator<IMessage>> {
     const offset = (page - 1) * limit;
-
+    
     const [results, [{ count }]] = await Promise.all([
-      this._knex("message")
-        .orderBy("created_at", "asc")
+      this._knex('message')
+        .orderBy('created_at', 'asc')
         .limit(limit)
         .offset(offset),
-      this._knex("message").count("* as count"),
+      this._knex('message').count('* as count')
     ]);
 
     const totalCount = parseInt(count as string);
@@ -44,40 +44,40 @@ export class MessageDAO implements IBaseDAO<IMessage> {
       limit,
       count: results.length,
       totalCount,
-      totalPages: Math.ceil(totalCount / limit),
+      totalPages: Math.ceil(totalCount / limit)
     };
   }
 
   async update(id: number, item: IMessageUpdate): Promise<IMessage | null> {
-    const [result] = await this._knex("message")
-      .where("id", id)
+    const [result] = await this._knex('message')
+      .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("message").where("id", id).delete();
+    const result = await this._knex('message')
+      .where('id', id)
+      .delete();
     return result > 0;
   }
 
-  async getByChatId(
-    chatId: number,
-    page = 1,
-    limit = 50,
-  ): Promise<IDataPaginator<IMessage>> {
+  async getByChatId(chatId: number, page = 1, limit = 50): Promise<IDataPaginator<IMessage>> {
     const offset = (page - 1) * limit;
-
+    
     const [results, [{ count }]] = await Promise.all([
-      this._knex("message")
-        .where("chatId", chatId)
-        .orderBy("created_at", "asc")
+      this._knex('message')
+        .where('chatId', chatId)
+        .orderBy('created_at', 'asc')
         .limit(limit)
         .offset(offset),
-      this._knex("message").where("chatId", chatId).count("* as count"),
+      this._knex('message')
+        .where('chatId', chatId)
+        .count('* as count')
     ]);
 
     const totalCount = parseInt(count as string);
@@ -88,15 +88,15 @@ export class MessageDAO implements IBaseDAO<IMessage> {
       limit,
       count: results.length,
       totalCount,
-      totalPages: Math.ceil(totalCount / limit),
+      totalPages: Math.ceil(totalCount / limit)
     };
   }
 
   async getLatestMessages(chatId: number, limit = 50): Promise<IMessage[]> {
-    return await this._knex("message")
-      .where("chatId", chatId)
-      .orderBy("created_at", "desc")
+    return await this._knex('message')
+      .where('chatId', chatId)
+      .orderBy('created_at', 'desc')
       .limit(limit)
       .then((messages: IMessage[]) => messages.reverse());
   }
-}
+}