feat: Implement GroupService, UserService, and TablesService for database management

- Added `GroupService` for managing groups, including methods for creating, updating, deleting, retrieving by group ID, and managing rules and members.
- Implemented `UserService` for managing users, including methods for creating, retrieving by Telegram ID, and saving user data.
- Introduced `TablesService` to handle the initialization and seeding of database tables.
- Added `save` method in both `GroupService` and `UserService` to automatically save group or user data if it doesn't already exist.
- Created functionality in `GroupService` for adding and deleting rules, clearing all rules, and updating members.
- Implemented error handling for the `initialTables` and `seedTables` methods in `TablesService` using custom decorators.
- Added logic to prevent seeding if the `User` table already contains data in the `seedTables` method.
- Ensured that `GroupService` and `UserService` both interact with the database using the `PoolClient` for connection pooling.

This update enhances the database structure and service layer for managing groups and users, ensuring the proper initialization and seeding of tables, as well as providing methods for group and user management.

Author: m-mdy-m

src/database/service/group/Group.ts

@@ -0,0 +1,127 @@
+import { PoolClient } from 'pg';
+import { Group, User } from '../../../types/database/TablesTypes';
+import { Context } from 'grammy';
+export class GroupService {
+  constructor(private _client: PoolClient) {}
+  async create(group: Omit<Group, 'id'>) {
+    const query = `
+      INSERT INTO "Group" (
+        group_id, group_name, rules, black_list,
+        chat_permissions, updated_at, joined_at, approved_users,
+        warnings, is_spam_time,members
+      )
+      VALUES (
+        $1, $2, $3, $4, $5, NOW(), NOW(), $6, $7, $8, $9
+      ) RETURNING id,group_id, group_name, rules, black_list,chat_permissions, updated_at, joined_at, approved_users,warnings, is_spam_time,members;
+    `;
+    const values = [
+      group.group_id,
+      group.group_name,
+      group.rules || [],
+      group.black_list || [],
+      JSON.stringify(group.chat_permissions),
+      group.approved_users || [],
+      group.warnings || [],
+      group.is_spam_time || false,
+      group.members || [],
+    ];
+    const result = await this._client.query(query, values);
+    return result.rows[0];
+  }
+  async update(group: Group) {
+    const query = `
+    UPDATE "Group"
+    SET 
+      group_name = $1,
+      rules = $2,
+      black_list = $3,
+      chat_permissions = $4,
+      updated_at = NOW(),
+      approved_users = $5,
+      warnings = $6,
+      is_spam_time = $7,
+      members = $8
+    WHERE group_id = $9
+    RETURNING id, group_id, group_name, rules, black_list, chat_permissions, updated_at, approved_users, warnings, is_spam_time, members;
+  `;
+
+    const values = [group.group_name, group.rules, group.black_list, JSON.stringify(group.chat_permissions), group.approved_users, group.warnings, group.is_spam_time, group.members, group.group_id];
+
+    const result = await this._client.query(query, values);
+    return result.rows[0];
+  }
+
+  async delete() {}
+  async getByGroupId(groupId: number): Promise<Group | null> {
+    const query = `SELECT * FROM "Group" WHERE group_id = $1;`;
+    const result = await this._client.query(query, [groupId]);
+    return result.rows[0] || null;
+  }
+  async save(ctx: Context): Promise<Group> {
+    const [id, title] = [ctx.chat!.id!, ctx.chat!.title];
+    let group = await this.getByGroupId(id);
+    if (!group) {
+      const newGroupData: Omit<Group, 'id'> = {
+        group_id: id,
+        group_name: title || 'Unnamed Group',
+        rules: [],
+        black_list: [],
+        chat_permissions: {},
+        approved_users: [],
+        warnings: 0,
+        is_spam_time: false,
+        members: [],
+      };
+      group = await this.create(newGroupData);
+    }
+    return group!;
+  }
+  async addRule(groupId: number, newRule: string): Promise<void> {
+    const group = await this.getByGroupId(groupId);
+    if (!group) {
+      throw new Error(`Group with ID ${groupId} not found.`);
+    }
+
+    const updatedRules = [...group.rules, newRule]; // Add the new rule
+    await this.update({ ...group, rules: updatedRules });
+  }
+  async getRules(groupId: number): Promise<string[]> {
+    const query = `SELECT rules FROM "Group" WHERE group_id = $1;`;
+    const result = await this._client.query(query, [groupId]);
+    return result.rows[0]?.rules || [];
+  }
+  async updateMembers(groupId: number, newMember: number | string) {
+    const group = await this.getByGroupId(groupId);
+    if (!group) {
+      throw new Error(`Group with ID ${groupId} not found`);
+    }
+    const members = group.members.map(Number);
+    if (!members.includes(+newMember)) {
+      members.push(+newMember);
+    }
+    const updatedGroup = await this.update({
+      ...group,
+      members,
+    });
+
+    return updatedGroup;
+  }
+  async deleteLastRule(groupId: number): Promise<string[] | null> {
+    const group = await this.getByGroupId(groupId);
+    if (!group || group.rules.length === 0) {
+      return null; // No rules to delete
+    }
+
+    const updatedRules = group.rules.slice(0, -1); // Remove the last rule
+    await this.update({ ...group, rules: updatedRules });
+    return updatedRules;
+  }
+  async clearRules(groupId: number): Promise<void> {
+    const group = await this.getByGroupId(groupId);
+    if (!group) {
+      throw new Error(`Group with ID ${groupId} not found.`);
+    }
+
+    await this.update({ ...group, rules: [] }); // Clear all rules
+  }
+}

src/database/service/tables/Tables.ts

@@ -0,0 +1,37 @@
+import { Catch } from '../../../decorators/ErrorHandlingDecorator';
+import { ConnectionPool } from '../../ConnectionPool';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+export class TablesService {
+  constructor(private _connectionPool: ConnectionPool) {}
+  @Catch({
+    category: 'Database',
+    message: 'Failed to set up initial tables.',
+    statusCode: 500,
+  })
+  async initialTables() {
+    const client = await this._connectionPool.getClient();
+    const sqlFilePath = path.join(__dirname, '..', '..', './sql/Tables.sql');
+    const sql = await fs.readFile(sqlFilePath, 'utf-8');
+    await client.query(sql);
+    console.log('Initial tables have been set up successfully.');
+  }
+  @Catch({
+    category: 'Database',
+    message: 'Failed to seed tables.',
+    statusCode: 500,
+  })
+  async seedTables() {
+    const client = await this._connectionPool.getClient();
+    const result = await client.query(`SELECT COUNT(*) FROM "User";`);
+    const userCount = parseInt(result.rows[0].count, 10);
+    if (userCount > 0) {
+      console.log('The tables have already been seeded. Skipping seeding process.');
+      return; // Skip seeding if there's already data in the User table
+    }
+    const sqlFilePath = path.join(__dirname, '..', '..', './sql/seed/SeedDataTables.sql');
+    const sql = await fs.readFile(sqlFilePath, 'utf-8');
+    await client.query(sql);
+    console.log('All tables have been seeded successfully.');
+  }
+}

src/database/service/user/User.ts

@@ -0,0 +1,42 @@
+import { PoolClient } from 'pg';
+import { User } from '../../../types/database/TablesTypes';
+import { Context } from 'grammy';
+export class UserService {
+  constructor(private _client: PoolClient) {}
+  async create(user: Omit<User, 'id'>) {
+    const query = `
+          INSERT INTO "User"(
+            telegram_id, username, first_name, role,
+            warnings, approved_groups
+          )
+          VALUES (
+            $1, $2, $3, $4, $5, $6
+          ) RETURNING  id,telegram_id, username, first_name, role,warnings, approved_groups;`;
+    const values = [user.telegram_id, user.username, user.first_name, user.role, user.warnings, user.approved_groups];
+    const result = await this._client.query(query, values);
+    return result.rows[0];
+  }
+  async update() {}
+  async delete() {}
+  async getByTelegramId(telegram_id: number): Promise<User | null> {
+    const query = `SELECT * FROM "User" WHERE telegram_id = $1;`;
+    const result = await this._client.query(query, [telegram_id]);
+    return result.rows[0] || null;
+  }
+  async save(ctx: Context): Promise<User> {
+    const [id, username, first_name] = [ctx.from?.id!, ctx.from?.username, ctx.from?.first_name!];
+    let user = await this.getByTelegramId(id);
+    if (!user) {
+      const newUserData: Omit<User, 'id'> = {
+        telegram_id: id,
+        role: 'user',
+        username: username || null,
+        first_name: first_name,
+        warnings: 0,
+        approved_groups: [],
+      };
+      user = await this.create(newUserData);
+    }
+    return user!;
+  }
+}