@trafficgroup/knex-rel 0.0.26 → 0.0.28

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

@@ -0,0 +1,61 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+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),
+        };
+    }
+}

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

@@ -0,0 +1,124 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+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('*');
+    return result;
+  }
+
+  async getById(id: number): Promise<IChat | null> {
+    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();
+    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')
+        .limit(limit)
+        .offset(offset),
+      this._knex('chat').count('* as count')
+    ]);
+
+    const totalCount = parseInt(count as string);
+    return {
+      success: true,
+      data: results,
+      page,
+      limit,
+      count: results.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit)
+    };
+  }
+
+  async update(id: number, item: IChatUpdate): Promise<IChat | null> {
+    const [result] = await this._knex('chat')
+      .where('id', id)
+      .update({
+        ...item,
+        updated_at: new Date()
+      })
+      .returning('*');
+    return result || null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex('chat')
+      .where('id', id)
+      .delete();
+    return result > 0;
+  }
+
+  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')
+        .limit(limit)
+        .offset(offset),
+      this._knex('chat')
+        .where('userId', userId)
+        .count('* as count')
+    ]);
+
+    const totalCount = parseInt(count as string);
+    return {
+      success: true,
+      data: results,
+      page,
+      limit,
+      count: results.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit)
+    };
+  }
+
+  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')
+        .limit(limit)
+        .offset(offset),
+      this._knex('chat')
+        .where('userId', userId)
+        .where('status', 'active')
+        .count('* as count')
+    ]);
+
+    const totalCount = parseInt(count as string);
+    return {
+      success: true,
+      data: results,
+      page,
+      limit,
+      count: results.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit)
+    };
+  }
+}

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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,102 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+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('*');
+    return result;
+  }
+
+  async getById(id: number): Promise<IMessage | null> {
+    const result = await this._knex('message')
+      .where('id', id)
+      .first();
+    return result || null;
+  }
+
+  async getByUuid(uuid: string): Promise<IMessage | null> {
+    // Message table doesn't have uuid column, returning null
+    return null;
+  }
+
+  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')
+        .limit(limit)
+        .offset(offset),
+      this._knex('message').count('* as count')
+    ]);
+
+    const totalCount = parseInt(count as string);
+    return {
+      success: true,
+      data: results,
+      page,
+      limit,
+      count: results.length,
+      totalCount,
+      totalPages: Math.ceil(totalCount / limit)
+    };
+  }
+
+  async update(id: number, item: IMessageUpdate): Promise<IMessage | null> {
+    const [result] = await this._knex('message')
+      .where('id', id)
+      .update({
+        ...item,
+        updated_at: new Date()
+      })
+      .returning('*');
+    return result || null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex('message')
+      .where('id', id)
+      .delete();
+    return result > 0;
+  }
+
+  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')
+        .limit(limit)
+        .offset(offset),
+      this._knex('message')
+        .where('chatId', chatId)
+        .count('* as count')
+    ]);
+
+    const totalCount = parseInt(count as string);
+    return {
+      success: true,
+      data: results,
+      page,
+      limit,
+      count: results.length,
+      totalCount,
+      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')
+      .limit(limit)
+      .then((messages: IMessage[]) => messages.reverse());
+  }
+}

package/src/dao/study/study.dao.ts

@@ -0,0 +1,66 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { IStudy } from "../../interfaces/study/study.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class StudyDAO implements IBaseDAO<IStudy> {
+    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+    async create(item: IStudy): Promise<IStudy> {
+        const [createdStudy] = await this._knex("study").insert(item).returning("*");
+        return createdStudy;
+    }
+
+    async getById(id: number): Promise<IStudy | null> {
+        const study = await this._knex("study as s")
+            .innerJoin("users as u", "s.createdBy", "u.id")
+            .select("s.*", this._knex.raw("to_jsonb(u.*) as user"))
+            .where("s.id", id)
+            .first();
+        return study || null;
+    }
+
+    async getByUuid(uuid: string): Promise<IStudy | null> {
+        const study = await this._knex("study as s")
+            .innerJoin("users as u", "s.createdBy", "u.id")
+            .select("s.*", this._knex.raw("to_jsonb(u.*) as user"))
+            .where("s.uuid", uuid)
+            .first();
+        return study || null;
+    }
+
+    async update(id: number, item: Partial<IStudy>): Promise<IStudy | null> {
+        const [updatedStudy] = await this._knex("study").where({ id }).update(item).returning("*");
+        return updatedStudy || null;
+    }
+
+    async delete(id: number): Promise<boolean> {
+        const result = await this._knex("study").where({ id }).del();
+        return result > 0;
+    }
+
+    async getAll(page: number, limit: number, createdBy?: number | null): Promise<IDataPaginator<IStudy>> {
+        const offset = (page - 1) * limit;
+
+        const query = this._knex("study as s")
+            .innerJoin("users as u", "s.createdBy", "u.id")
+            .select("s.*", this._knex.raw("to_jsonb(u.*) as user"));
+        if (createdBy !== undefined && createdBy !== null) {
+            query.where("s.createdBy", createdBy);
+        }
+
+        const [countResult] = await query.clone().clearSelect().count("* as count");
+        const totalCount = +countResult.count;
+        const studies = await query.clone().limit(limit).offset(offset);
+
+        return {
+            success: true,
+            data: studies,
+            page,
+            limit,
+            count: studies.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
+}

package/src/dao/user/user.dao.ts

@@ -7,38 +7,42 @@ export class UserDAO implements IBaseDAO<IUser> {
     private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
 
     async create(item: IUser): Promise<IUser> {
-        const [createdUser] = await this._knex("user").insert(item).returning("*");
+        const [createdUser] = await this._knex("users").insert(item).returning("*");
         return createdUser;
     }
 
     async getById(id: number): Promise<IUser | null> {
-        const user = await this._knex("user").where({ id }).first();
+        const user = await this._knex("users").where({ id }).first();
         return user || null;
     }
 
     async getByUuid(uuid: string): Promise<IUser | null> {
-        const user = await this._knex("user").where({ uuid }).first();
+        const user = await this._knex("users").where({ uuid }).first();
+        return user || null;
+    }
+
+
+    async getByEmail(email: string): Promise<IUser | null> {
+        const user = await this._knex("users").where({ email }).first();
         return user || null;
     }
 
     async update(id: number, item: Partial<IUser>): Promise<IUser | null> {
-        const [updatedUser] = await this._knex("user").where({ id }).update(item).returning("*");
+        const [updatedUser] = await this._knex("users").where({ id }).update(item).returning("*");
         return updatedUser || null;
     }
 
     async delete(id: number): Promise<boolean> {
-        const result = await this._knex("user").where({ id }).del();
+        const result = await this._knex("users").where({ id }).del();
         return result > 0;
     }
 
-    async getAll(): Promise<IDataPaginator<IUser>> {
-        const page = 1; // Default to first page
-        const limit = 10; // Default limit
+    async getAll(page: number, limit: number): Promise<IDataPaginator<IUser>> {
         const offset = (page - 1) * limit;
 
-        const [countResult] = await this._knex("user").count("* as count");
+        const [countResult] = await this._knex("users").count("* as count");
         const totalCount = +countResult.count;
-        const users = await this._knex("user").limit(limit).offset(offset);
+        const users = await this._knex("users").limit(limit).offset(offset);
 
         return {
             success: true,

package/src/dao/user-push-notification-token/user-push-notification-token.dao.ts

@@ -0,0 +1,65 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { IUserPushNotificationToken } from "../../interfaces/user-push-notification-token/user-push-notification-token.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class UserPushNotificationTokenDAO implements IBaseDAO<IUserPushNotificationToken> {
+    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+    async create(item: IUserPushNotificationToken): Promise<IUserPushNotificationToken> {
+        const [createdToken] = await this._knex("user_push_notification_token").insert(item).returning("*");
+        return createdToken;
+    }
+
+    async getById(id: number): Promise<IUserPushNotificationToken | null> {
+        const token = await this._knex("user_push_notification_token").where({ id }).first();
+        return token || null;
+    }
+
+    async getByUuid(uuid: string): Promise<IUserPushNotificationToken | null> {
+        throw new Error("Method not implemented. UserPushNotificationToken does not have UUID field.");
+    }
+
+    async getByUserId(userId: number): Promise<IUserPushNotificationToken[]> {
+        const tokens = await this._knex("user_push_notification_token").where({ userId });
+        return tokens;
+    }
+
+    async getByToken(token: string): Promise<IUserPushNotificationToken | null> {
+        const tokenRecord = await this._knex("user_push_notification_token").where({ token }).first();
+        return tokenRecord || null;
+    }
+
+    async getAvailableByUserId(userId: number): Promise<IUserPushNotificationToken[]> {
+        const tokens = await this._knex("user_push_notification_token").where({ userId, available: true });
+        return tokens;
+    }
+
+    async update(id: number, item: Partial<IUserPushNotificationToken>): Promise<IUserPushNotificationToken | null> {
+        const [updatedToken] = await this._knex("user_push_notification_token").where({ id }).update(item).returning("*");
+        return updatedToken || null;
+    }
+
+    async delete(id: number): Promise<boolean> {
+        const result = await this._knex("user_push_notification_token").where({ id }).del();
+        return result > 0;
+    }
+
+    async getAll(page: number, limit: number): Promise<IDataPaginator<IUserPushNotificationToken>> {
+        const offset = (page - 1) * limit;
+
+        const [countResult] = await this._knex("user_push_notification_token").count("* as count");
+        const totalCount = +countResult.count;
+        const tokens = await this._knex("user_push_notification_token").limit(limit).offset(offset);
+
+        return {
+            success: true,
+            data: tokens,
+            page,
+            limit,
+            count: tokens.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
+}

package/src/dao/video/video.dao.ts

@@ -0,0 +1,120 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { IVideo } from "../../interfaces/video/video.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class VideoDAO implements IBaseDAO<IVideo> {
+    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+    static getInstance(): Knex<any, unknown[]> {
+        return KnexManager.getConnection();
+    }
+
+    async create(item: IVideo): Promise<IVideo> {
+        const [createdVideo] = await this._knex("video").insert(item).returning("*");
+        return createdVideo;
+    }
+
+    async getById(id: number): Promise<IVideo | null> {
+        const video = await 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.id", id)
+            .first();
+        return video || null;
+    }
+
+    async getByUuid(uuid: string): Promise<IVideo | null> {
+        const video = await 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.uuid", uuid)
+            .first();
+        return video || null;
+    }
+
+    async update(id: number, item: Partial<IVideo>): Promise<IVideo | null> {
+        const [updatedVideo] = await this._knex("video").where({ id }).update(item).returning("*");
+        return updatedVideo || null;
+    }
+
+    async delete(id: number): Promise<boolean> {
+        const result = await this._knex("video").where({ id }).del();
+        return result > 0;
+    }
+
+    // entityId corresponde al id del folder al que pertenece el video
+    async getAll(page: number, limit: number, folderId?: number | null): 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"));
+        if (folderId !== undefined && folderId !== null) {
+            query.where("v.folderId", folderId);
+        }
+
+        const [countResult] = await query.clone().clearSelect().count("* as count");
+        const totalCount = +countResult.count;
+        const videos = await query.clone().limit(limit).offset(offset);
+
+        return {
+            success: true,
+            data: videos,
+            page,
+            limit,
+            count: videos.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
+
+    async getVideoStatsByFolderIds(folderIds: number[]): Promise<{
+        total_videos: number;
+        completed_videos: number;
+        failed_videos: number;
+        processing_videos: number;
+    }> {
+        if (!folderIds || folderIds.length === 0) {
+            return {
+                total_videos: 0,
+                completed_videos: 0,
+                failed_videos: 0,
+                processing_videos: 0
+            };
+        }
+
+        const result = await this._knex("video")
+            .whereIn("folderId", folderIds)
+            .select(
+                this._knex.raw('COUNT(*) as total_videos'),
+                this._knex.raw("COUNT(CASE WHEN status = ? THEN 1 END) as completed_videos", ['COMPLETED']),
+                this._knex.raw("COUNT(CASE WHEN status = ? THEN 1 END) as failed_videos", ['FAILED']),
+                this._knex.raw("COUNT(CASE WHEN status = ? THEN 1 END) as processing_videos", ['PROCESSING'])
+            )
+            .first() as any;
+
+        return {
+            total_videos: parseInt(result?.total_videos) || 0,
+            completed_videos: parseInt(result?.completed_videos) || 0,
+            failed_videos: parseInt(result?.failed_videos) || 0,
+            processing_videos: parseInt(result?.processing_videos) || 0
+        };
+    }
+
+    async getCompletedVideosByFolderIds(folderIds: number[], videoType?: string): Promise<IVideo[]> {
+        if (!folderIds || folderIds.length === 0) {
+            return [];
+        }
+
+        const query = this._knex("video")
+            .whereIn("folderId", folderIds)
+            .where("status", "COMPLETED");
+
+        if (videoType) {
+            query.where("videoType", videoType);
+        }
+
+        return await query.select("id", "name", "metadata", "results", "created_at", this._knex.raw("EXTRACT(EPOCH FROM (updated_at - created_at)) as duration"));
+    }
+}