@trafficgroup/knex-rel 0.1.19 → 0.1.20

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

@@ -2,101 +2,105 @@ import { Knex } from "knex";
 import { IBaseDAO, IDataPaginator } from "../../d.types";
 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();
-
-    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;
-    }
+  private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
 
-    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 create(item: IStudy): Promise<IStudy> {
+    const [createdStudy] = await this._knex("study")
+      .insert(item)
+      .returning("*");
+    return createdStudy;
+  }
 
-    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 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 delete(id: number): Promise<boolean> {
-        const result = await this._knex("study").where({ id }).del();
-        return result > 0;
-    }
+  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 getAll(page: number, limit: number, filters?: IStudyFilters): Promise<IDataPaginator<IStudy>> {
-        const offset = (page - 1) * limit;
+  async update(id: number, item: Partial<IStudy>): Promise<IStudy | null> {
+    const [updatedStudy] = await this._knex("study")
+      .where({ id })
+      .update(item)
+      .returning("*");
+    return updatedStudy || null;
+  }
 
-        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"));
+  async delete(id: number): Promise<boolean> {
+    const result = await this._knex("study").where({ id }).del();
+    return result > 0;
+  }
 
-        if (filters) {
-            if (filters.createdBy !== undefined && filters.createdBy !== null) {
-                query.where("s.createdBy", filters.createdBy);
-            }
+  async getAll(
+    page: number,
+    limit: number,
+    createdBy?: number | null,
+  ): Promise<IDataPaginator<IStudy>> {
+    const offset = (page - 1) * limit;
 
-            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 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"),
+      );
+    if (createdBy !== undefined && createdBy !== null) {
+      query.where("s.createdBy", createdBy);
+    }
 
-        const [countResult] = await query.clone().clearSelect().clearOrder().count("* as count");
-        const totalCount = +countResult.count;
-        const studies = await query.clone().limit(limit).offset(offset);
+    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),
-        };
-    }
+    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,12 +1,14 @@
-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,
@@ -15,48 +17,52 @@ 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[]> {
@@ -65,49 +71,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,54 +4,56 @@ 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,62 +4,94 @@ 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),
+    };
+  }
+}