@trafficgroup/knex-rel 0.0.27 → 0.0.29

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

@@ -4,58 +4,61 @@ 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/chat/chat.dao.ts

@@ -1,41 +1,39 @@
 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);
@@ -46,40 +44,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);
@@ -90,24 +88,28 @@ 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);
@@ -118,7 +120,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

@@ -1,66 +1,75 @@
-import { Knex } from "knex";
-import { IBaseDAO, IDataPaginator } from "../../d.types";
-import { IFolder } from "../../interfaces/folder/folder.interfaces";
-import KnexManager from "../../KnexConnection";
-
-export class FolderDAO implements IBaseDAO<IFolder> {
-    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 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 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 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 [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),
-        };
-    }
-}
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { IFolder } from "../../interfaces/folder/folder.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class FolderDAO implements IBaseDAO<IFolder> {
+  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 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 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 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 [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),
+    };
+  }
+}

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