@trafficgroup/knex-rel 0.1.21 → 0.1.23-rc.0

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

@@ -1,113 +1,102 @@
 import { Knex } from "knex";
 import { IBaseDAO, IDataPaginator } from "../../d.types";
-import { IStudy, IStudyFilters } from "../../interfaces/study/study.interfaces";
-import { STUDY_SORT_COLUMN_MAP } from "../../constants/study.constants";
+import { IStudy } from "../../interfaces/study/study.interfaces";
 import KnexManager from "../../KnexConnection";
+import { StudySortField, STUDY_SORT_COLUMN_MAP } from "../../constants/study.constants";
+import { SortOrder } from "../../constants/video.constants";
+
+export interface IStudyFilters {
+    createdBy?: number | null;
+    sortBy?: StudySortField;
+    sortOrder?: SortOrder;
+}
 
 export class StudyDAO implements IBaseDAO<IStudy> {
-  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+    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 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")
-      .leftJoin("locations as l", "s.locationId", "l.id")
-      .select(
-        "s.*",
-        this._knex.raw("to_jsonb(u.*) as user"),
-        this._knex.raw("to_jsonb(l.*) as location"),
-      )
-      .where("s.id", id)
-      .first();
-    return study || null;
-  }
+    async getById(id: number): Promise<IStudy | null> {
+        const study = await this._knex("study as s")
+            .innerJoin("users as u", "s.createdBy", "u.id")
+            .leftJoin("locations as l", "s.locationId", "l.id")
+            .select("s.*", this._knex.raw("to_jsonb(u.*) as user"), this._knex.raw("to_jsonb(l.*) as location"))
+            .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")
-      .leftJoin("locations as l", "s.locationId", "l.id")
-      .select(
-        "s.*",
-        this._knex.raw("to_jsonb(u.*) as user"),
-        this._knex.raw("to_jsonb(l.*) as location"),
-      )
-      .where("s.uuid", uuid)
-      .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")
+            .leftJoin("locations as l", "s.locationId", "l.id")
+            .select("s.*", this._knex.raw("to_jsonb(u.*) as user"), this._knex.raw("to_jsonb(l.*) as location"))
+            .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 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 delete(id: number): Promise<boolean> {
+        const result = await this._knex("study").where({ id }).del();
+        return result > 0;
+    }
 
-  async getAll(
-    page: number,
-    limit: number,
-    filters?: IStudyFilters,
-  ): Promise<IDataPaginator<IStudy>> {
-    const offset = (page - 1) * limit;
+    async getAll(page: number, limit: number, filters?: IStudyFilters): Promise<IDataPaginator<IStudy>> {
+        const offset = (page - 1) * limit;
 
-    const query = this._knex("study as s")
-      .innerJoin("users as u", "s.createdBy", "u.id")
-      .leftJoin("locations as l", "s.locationId", "l.id")
-      .select(
-        "s.*",
-        this._knex.raw("to_jsonb(u.*) as user"),
-        this._knex.raw("to_jsonb(l.*) as location"),
-      );
+        const query = this._knex("study as s")
+            .innerJoin("users as u", "s.createdBy", "u.id")
+            .leftJoin("locations as l", "s.locationId", "l.id")
+            .select("s.*", this._knex.raw("to_jsonb(u.*) as user"), this._knex.raw("to_jsonb(l.*) as location"));
 
-    const [countResult] = await query.clone().clearSelect().count("* as count");
-    const totalCount = +countResult.count;
+        if (filters) {
+            if (filters.createdBy !== undefined && filters.createdBy !== null) {
+                query.where("s.createdBy", filters.createdBy);
+            }
 
-    // Apply sorting
-    const sortColumn =
-      filters?.sortBy && STUDY_SORT_COLUMN_MAP[filters.sortBy]
-        ? STUDY_SORT_COLUMN_MAP[filters.sortBy]
-        : "s.created_at";
-    const sortOrder = filters?.sortOrder || "DESC";
-    query.orderBy(sortColumn, sortOrder);
+            if (filters.sortBy) {
+                const columnName = STUDY_SORT_COLUMN_MAP[filters.sortBy];
+                const order = filters.sortOrder || "DESC";
+                query.orderBy(columnName, order);
+            } else {
+                query.orderBy("s.created_at", "DESC");
+            }
+        } else {
+            query.orderBy("s.created_at", "DESC");
+        }
 
-    const studies = await query.clone().limit(limit).offset(offset);
+        const [countResult] = await query.clone().clearSelect().clearOrder().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),
-    };
-  }
+        return {
+            success: true,
+            data: studies,
+            page,
+            limit,
+            count: studies.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
 
-  async getStudiesByLocation(locationId: number): Promise<IStudy[]> {
-    const studies = await this._knex("study as s")
-      .innerJoin("users as u", "s.createdBy", "u.id")
-      .leftJoin("locations as l", "s.locationId", "l.id")
-      .select(
-        "s.*",
-        this._knex.raw("to_jsonb(u.*) as user"),
-        this._knex.raw("to_jsonb(l.*) as location"),
-      )
-      .where("s.locationId", locationId)
-      .orderBy("s.created_at", "desc")
-      .limit(10);
+    async getStudiesByLocation(locationId: number): Promise<IStudy[]> {
+        const studies = await this._knex("study as s")
+            .innerJoin("users as u", "s.createdBy", "u.id")
+            .leftJoin("locations as l", "s.locationId", "l.id")
+            .select("s.*", this._knex.raw("to_jsonb(u.*) as user"), this._knex.raw("to_jsonb(l.*) as location"))
+            .where("s.locationId", locationId)
+            .orderBy("s.created_at", "desc")
+            .limit(10);
 
-    return studies;
-  }
+        return studies;
+    }
 }

package/src/dao/systemConfiguration/SystemConfigurationDAO.ts

@@ -1,14 +1,12 @@
-import type { Knex } from "knex";
-import { v4 as uuidv4 } from "uuid";
-import { ISystemConfiguration } from "../../interfaces/systemConfiguration/ISystemConfiguration";
-import KnexManager from "../../KnexConnection";
+import type { Knex } from 'knex';
+import { v4 as uuidv4 } from 'uuid';
+import { ISystemConfiguration } from '../../interfaces/systemConfiguration/ISystemConfiguration';
+import KnexManager from '../../KnexConnection';
 
 export class SystemConfigurationDAO {
   private knex: Knex = KnexManager.getConnection();
 
-  public async create(
-    config: Omit<ISystemConfiguration, "id">,
-  ): Promise<ISystemConfiguration> {
+  public async create(config: Omit<ISystemConfiguration, 'id'>): Promise<ISystemConfiguration> {
     const toInsert = {
       configUuid: config.configUuid ?? uuidv4(),
       key: config.key,
@@ -17,52 +15,48 @@ export class SystemConfigurationDAO {
       description: config.description,
     };
 
-    const [inserted] = await this.knex<ISystemConfiguration>(
-      "system_configuration",
-    )
+    const [inserted] = await this.knex<ISystemConfiguration>('system_configuration')
       .insert(toInsert)
-      .returning("*");
+      .returning('*');
 
     return this.getById(inserted.id!);
   }
 
   public async getById(id: number): Promise<ISystemConfiguration | null> {
-    const rec = await this.knex<ISystemConfiguration>("system_configuration")
-      .where("id", id)
+    const rec = await this.knex<ISystemConfiguration>('system_configuration')
+      .where('id', id)
       .first();
     return rec ?? null;
   }
 
   public async getByUuid(uuid: string): Promise<ISystemConfiguration | null> {
-    const rec = await this.knex<ISystemConfiguration>("system_configuration")
-      .where("configUuid", uuid)
+    const rec = await this.knex<ISystemConfiguration>('system_configuration')
+      .where('configUuid', uuid)
       .first();
     return rec ?? null;
   }
 
   public async getByKey(key: string): Promise<ISystemConfiguration | null> {
-    const rec = await this.knex<ISystemConfiguration>("system_configuration")
-      .where("key", key)
+    const rec = await this.knex<ISystemConfiguration>('system_configuration')
+      .where('key', key)
       .first();
     return rec ?? null;
   }
 
-  public async getMultipleByKeys(
-    keys: string[],
-  ): Promise<ISystemConfiguration[]> {
+  public async getMultipleByKeys(keys: string[]): Promise<ISystemConfiguration[]> {
     if (keys.length === 0) {
       return [];
     }
 
-    return this.knex<ISystemConfiguration>("system_configuration")
-      .whereIn("key", keys)
-      .select("*");
+    return this.knex<ISystemConfiguration>('system_configuration')
+      .whereIn('key', keys)
+      .select('*');
   }
 
   public async getAllConfigs(): Promise<ISystemConfiguration[]> {
-    return this.knex<ISystemConfiguration>("system_configuration")
-      .select("*")
-      .orderBy("key", "asc");
+    return this.knex<ISystemConfiguration>('system_configuration')
+      .select('*')
+      .orderBy('key', 'asc');
   }
 
   public async getAll(): Promise<ISystemConfiguration[]> {
@@ -71,49 +65,49 @@ export class SystemConfigurationDAO {
 
   public async update(
     id: number,
-    updates: Partial<ISystemConfiguration>,
+    updates: Partial<ISystemConfiguration>
   ): Promise<ISystemConfiguration | null> {
-    await this.knex<ISystemConfiguration>("system_configuration")
-      .where("id", id)
+    await this.knex<ISystemConfiguration>('system_configuration')
+      .where('id', id)
       .update(updates);
     return this.getById(id);
   }
 
   public async updateByKey(
     key: string,
-    updates: Partial<ISystemConfiguration>,
+    updates: Partial<ISystemConfiguration>
   ): Promise<ISystemConfiguration | null> {
-    await this.knex<ISystemConfiguration>("system_configuration")
-      .where("key", key)
+    await this.knex<ISystemConfiguration>('system_configuration')
+      .where('key', key)
       .update(updates);
     return this.getByKey(key);
   }
 
   public async updateByUuid(
     uuid: string,
-    updates: Partial<ISystemConfiguration>,
+    updates: Partial<ISystemConfiguration>
   ): Promise<ISystemConfiguration | null> {
-    await this.knex<ISystemConfiguration>("system_configuration")
-      .where("configUuid", uuid)
+    await this.knex<ISystemConfiguration>('system_configuration')
+      .where('configUuid', uuid)
       .update(updates);
     return this.getByUuid(uuid);
   }
 
   public async delete(id: number): Promise<void> {
-    await this.knex<ISystemConfiguration>("system_configuration")
-      .where("id", id)
+    await this.knex<ISystemConfiguration>('system_configuration')
+      .where('id', id)
       .del();
   }
 
   public async deleteByKey(key: string): Promise<void> {
-    await this.knex<ISystemConfiguration>("system_configuration")
-      .where("key", key)
+    await this.knex<ISystemConfiguration>('system_configuration')
+      .where('key', key)
       .del();
   }
 
   public async deleteByUuid(uuid: string): Promise<void> {
-    await this.knex<ISystemConfiguration>("system_configuration")
-      .where("configUuid", uuid)
+    await this.knex<ISystemConfiguration>('system_configuration')
+      .where('configUuid', uuid)
       .del();
   }
 }

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

@@ -4,56 +4,54 @@ import { IUser } from "../../interfaces/user/user.interfaces";
 import KnexManager from "../../KnexConnection";
 
 export class UserDAO implements IBaseDAO<IUser> {
-  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
-
-  async create(item: IUser): Promise<IUser> {
-    const [createdUser] = await this._knex("users").insert(item).returning("*");
-    return createdUser;
-  }
-
-  async getById(id: number): Promise<IUser | null> {
-    const user = await this._knex("users").where({ id }).first();
-    return user || null;
-  }
-
-  async getByUuid(uuid: string): Promise<IUser | null> {
-    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("users")
-      .where({ id })
-      .update(item)
-      .returning("*");
-    return updatedUser || null;
-  }
-
-  async delete(id: number): Promise<boolean> {
-    const result = await this._knex("users").where({ id }).del();
-    return result > 0;
-  }
-
-  async getAll(page: number, limit: number): Promise<IDataPaginator<IUser>> {
-    const offset = (page - 1) * limit;
-
-    const [countResult] = await this._knex("users").count("* as count");
-    const totalCount = +countResult.count;
-    const users = await this._knex("users").limit(limit).offset(offset);
-
-    return {
-      success: true,
-      data: users,
-      page,
-      limit,
-      count: users.length,
-      totalCount,
-      totalPages: Math.ceil(totalCount / limit),
-    };
-  }
+    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+    async create(item: IUser): Promise<IUser> {
+        const [createdUser] = await this._knex("users").insert(item).returning("*");
+        return createdUser;
+    }
+
+    async getById(id: number): Promise<IUser | null> {
+        const user = await this._knex("users").where({ id }).first();
+        return user || null;
+    }
+
+    async getByUuid(uuid: string): Promise<IUser | null> {
+        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("users").where({ id }).update(item).returning("*");
+        return updatedUser || null;
+    }
+
+    async delete(id: number): Promise<boolean> {
+        const result = await this._knex("users").where({ id }).del();
+        return result > 0;
+    }
+
+    async getAll(page: number, limit: number): Promise<IDataPaginator<IUser>> {
+        const offset = (page - 1) * limit;
+
+        const [countResult] = await this._knex("users").count("* as count");
+        const totalCount = +countResult.count;
+        const users = await this._knex("users").limit(limit).offset(offset);
+
+        return {
+            success: true,
+            data: users,
+            page,
+            limit,
+            count: users.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
 }

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

@@ -4,94 +4,62 @@ import { IUserPushNotificationToken } from "../../interfaces/user-push-notificat
 import KnexManager from "../../KnexConnection";
 
 export class UserPushNotificationTokenDAO implements IBaseDAO<IUserPushNotificationToken> {
-  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+    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 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 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 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 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 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 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 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 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;
+    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);
+        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),
-    };
-  }
-}
+        return {
+            success: true,
+            data: tokens,
+            page,
+            limit,
+            count: tokens.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
+}