feat(database): Add connection pool closing and reinitialization logic

Author: m-mdy-m

src/database/ConnectionPool.ts

@@ -4,6 +4,7 @@ import logger from '../utils/logger';
 export class ConnectionPool {
   private _pool: Pool;
   private _isProduction: 'development' | 'production';
+  private _isClosed: boolean = false;
   constructor() {
     const connectionString = this.getConnectionString();
     this._isProduction = Config.environment;
@@ -59,6 +60,8 @@ export class ConnectionPool {
   }
 
   async close(): Promise<void> {
+    if (this._isClosed) return; // Prevent closing the pool more than once
+    this._isClosed = true;
     await this._pool.end();
   }
   private initializePool(connectionString: string): Pool {
@@ -72,6 +75,10 @@ export class ConnectionPool {
     });
   }
   async reinitializePool() {
+    if (this._isClosed) {
+      throw new Error('Cannot reinitialize a closed pool.');
+    }
+
     if (this._pool && !this._pool.ended) {
       await this._pool.end();
     }

src/service/database/ServiceProvider.ts

@@ -6,15 +6,11 @@ import { UserService } from '../../database/models/User';
 import { GroupRuleService } from '../../database/models/GroupRule';
 import { WarningDatabaseService } from '../../database/models/Warning';
 import logger from '../../utils/logger';
-import { CopBot } from '../../bot';
 
 export class ServiceProvider {
   private static instance: ServiceProvider;
   private _clientInstance: Client;
   private _connectionPool!: ConnectionPool;
-
-  private lastRequestTime: number | null = null; // Track the last request time
-  private readonly requestInterval: number = 5000;
   private constructor() {
     this._clientInstance = new Client();
   }
@@ -31,18 +27,6 @@ export class ServiceProvider {
     }
     return ServiceProvider.instance;
   }
-  private async enforceRateLimit(): Promise<void> {
-    const now = Date.now();
-    if (this.lastRequestTime) {
-      const elapsed = now - this.lastRequestTime;
-      if (elapsed < this.requestInterval) {
-        const waitTime = this.requestInterval - elapsed;
-        logger.error(`⚠️ Rate limit exceeded. Please wait for ${waitTime} ms before making another request.`);
-        await new Promise((resolve) => setTimeout(resolve, waitTime));
-      }
-    }
-    this.lastRequestTime = Date.now();
-  }
   static getInstance() {
     return ServiceProvider.instance;
   }
@@ -57,7 +41,6 @@ export class ServiceProvider {
     await this._connectionPool.close();
   }
   async getPoolClint(): Promise<PoolClient> {
-    await this.enforceRateLimit();
     try {
       const client = await this._connectionPool.getClient();
       client.on('error', (err: any) => {