feat(service/db): Adding several new services to connect with the database and integrating the application to connect with the database

- `service/db/index.ts`:It provides several methods for connecting to the database and disconnecting from the database, and another method that is a helper method for returning the table.

- `service/db/group`: They provide services for Group Setting and Group Membership repo management
- `service/db/user`:  They provide warning, approved and user repo management services

Author: bitsgenix

src/service/db/group/Membership.ts

@@ -0,0 +1,21 @@
+import { DatabaseService } from "..";
+import { GroupMembership } from "../../../entities/GroupMembership";
+
+export class GroupMembershipService extends DatabaseService {
+  private groupMembershipRepo = this.getRepo(GroupMembership);
+
+  async add(membership: GroupMembership) {
+    return this.groupMembershipRepo.save(membership);
+  }
+
+  async getById(id: number) {
+    return this.groupMembershipRepo.findOne({ where: { id } });
+  }
+
+  async remove(id: number) {
+    return this.groupMembershipRepo.delete({ id });
+  }
+  async deleteUser(userId:number){
+    return this.groupMembershipRepo.delete({ user: { id: userId } });
+  }
+}

src/service/db/group/index.ts

@@ -0,0 +1,22 @@
+import { DatabaseService } from "..";
+import { GroupSettings } from "../../../entities/GroupSettings";
+
+export class GroupSettingsService extends DatabaseService {
+  private groupSettingsRepo = this.getRepo(GroupSettings);
+
+  async create(settings: Partial<GroupSettings>): Promise<GroupSettings> {
+    return this.groupSettingsRepo.create(settings);
+  }
+
+  async getByGroupId(groupId: number): Promise<GroupSettings | null> {
+    return this.groupSettingsRepo.findOne({ where: { group_id: groupId } });
+  }
+
+  async save(settings: GroupSettings) {
+    return this.groupSettingsRepo.save(settings);
+  }
+
+  async remove(id: number) {
+    return this.groupSettingsRepo.delete({ id });
+  }
+}

src/service/db/index.ts

@@ -0,0 +1,31 @@
+import { DataSource, ObjectLiteral, Repository } from "typeorm";
+import { AppDataSource } from "../../config/db";
+import { logger } from "../../config/logger";
+export class DatabaseService {
+  protected db: DataSource;
+
+  constructor() {
+    this.db = AppDataSource;
+  }
+
+  protected getRepo<T extends ObjectLiteral>(entity: {
+    new (): T;
+  }): Repository<T> {
+    return this.db.getRepository(entity);
+  }
+
+  async initialize() {
+    try {
+      await this.db.initialize();
+      logger.info("Database connection initialized", "DATABASE");
+    } catch (error: any) {
+      logger.error("Error initializing database connection", error, "DATABASE");
+    }
+  }
+
+  async close() {
+    await this.db.destroy();
+    logger.info("Database connection closed");
+  }
+}
+export const db = new DatabaseService();

src/service/db/user/Approved.ts

@@ -0,0 +1,25 @@
+import { DatabaseService } from "..";
+import { ApprovedUser } from "../../../entities/ApprovedUser";
+import { GroupSettings } from "../../../entities/GroupSettings";
+
+export class ApprovedUserService extends DatabaseService {
+  private approvedUserRepo = this.getRepo(ApprovedUser);
+  async create(userData: Partial<ApprovedUser>): Promise<ApprovedUser> {
+    return this.approvedUserRepo.create(userData);
+  }
+  async save(user: ApprovedUser): Promise<ApprovedUser> {
+    return this.approvedUserRepo.save(user);
+  }
+
+  async getById(id: number): Promise<ApprovedUser | null> {
+    return this.approvedUserRepo.findOne({ where: { id } });
+  }
+  async getByIdAndGroup(userId: number,groupSettings:GroupSettings) {
+    return this.approvedUserRepo.findOne({
+      where: { user_id: userId, group: groupSettings },
+    });
+  }
+  async remove(id: number): Promise<void> {
+    await this.approvedUserRepo.delete({ id });
+  }
+}

src/service/db/user/index.ts

@@ -0,0 +1,43 @@
+import { Context } from "grammy";
+import { DatabaseService } from "..";
+import { User } from "../../../entities/User";
+
+export class UserService extends DatabaseService {
+  private userRepo = this.getRepo(User);
+
+  async create(userdata: Partial<User>): Promise<User> {
+    return this.userRepo.create(userdata);
+  }
+
+  async getByTelegramId(telegramId: number) {
+    return this.userRepo.findOne({ where: { telegram_id: telegramId } });
+  }
+  async save(user: User) {
+    return this.userRepo.save(user);
+  }
+  async findByRelations(userId: number, relationship: string) {
+    return this.userRepo.findOne({
+      where: { telegram_id: userId },
+      relations: [relationship],
+    });
+  }
+  async removeUser(id: number) {
+    return this.userRepo.delete({ id });
+  }
+  async createUser(ctx: Context, telegram_id: number) {
+    const chatMember = await ctx.getChatMember(telegram_id);
+    const role = chatMember.status;
+    let user = await this.getByTelegramId(telegram_id);
+
+    if (!user) {
+      user = await this.userRepo.create({
+        telegram_id,
+        role,
+        warnings: [],
+      });
+      await this.userRepo.save(user);
+    }
+
+    return user;
+  }
+}

src/service/db/user/warning.ts

@@ -0,0 +1,27 @@
+import { DatabaseService } from "..";
+import { User } from "../../../entities/User";
+import { Warning } from "../../../entities/Warning";
+
+export class WarningServiceDb extends DatabaseService {
+  private warningRepo = this.getRepo(Warning);
+  async create(warning: Partial<Warning>): Promise<Warning> {
+    return this.warningRepo.create(warning);
+  }
+  async save(warning: Warning) {
+    return this.warningRepo.save(warning);
+  }
+
+  async getByUserId(userId: number) {
+    return this.warningRepo.find({ where: { user: { id: userId } } });
+  }
+  async remove(id: number) {
+    return this.warningRepo.delete({ id });
+  }
+  async clear(user: any) {
+    return this.warningRepo.delete({ user });
+  }
+
+  async count(user: User) {
+    return await this.warningRepo.count({ where: { user } });
+  }
+}