@trafficgroup/knex-rel 0.1.9 → 0.1.10

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

@@ -4,103 +4,78 @@ import { IStudy } from "../../interfaces/study/study.interfaces";
 import KnexManager from "../../KnexConnection";
 
 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,
-    createdBy?: number | null,
-  ): Promise<IDataPaginator<IStudy>> {
-    const offset = (page - 1) * limit;
+    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")
-      .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 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().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/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

@@ -3,97 +3,63 @@ 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();
+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 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),
+        };
+    }
+}