feat: Implement ServiceProvider for centralized database access and service management

- Created the `ServiceProvider` class to provide centralized access to the `Client`, `ConnectionPool`, `GroupService`, and `UserService`.
- Ensured that the `ServiceProvider` follows the singleton pattern, initializing only once and reusing the instance.
- Added methods to retrieve the `Client`, `ConnectionPool`, and services for managing groups and users (`GroupService` and `UserService`).
- Implemented `getPoolClint` method for acquiring a connection client from the connection pool.
- Included `close` method to close the connection pool when no longer needed.
- Added initialization logic in `initialize` method to ensure proper setup and avoid multiple initializations.

This update centralizes database management and service instantiation, simplifying access to core functionalities.

Author: m-mdy-m

src/service/database/ServiceProvider.ts

@@ -0,0 +1,48 @@
+import { PoolClient } from 'pg';
+import { Client } from '../../database/Client';
+import { ConnectionPool } from '../../database/ConnectionPool';
+import { GroupService } from '../../database/service/group/Group';
+import { UserService } from '../../database/service/user/User';
+
+export class ServiceProvider {
+  private static instance: ServiceProvider;
+  private _clientInstance: Client;
+  private _connectionPool!: ConnectionPool;
+  private constructor() {
+    this._clientInstance = new Client();
+  }
+
+  static async initialize(): Promise<ServiceProvider> {
+    if (!ServiceProvider.instance) {
+      const instance = new ServiceProvider();
+      await instance._clientInstance.initialize();
+      instance._connectionPool = instance._clientInstance.getConnectionPool();
+      ServiceProvider.instance = instance;
+    }
+    return ServiceProvider.instance;
+  }
+  static getInstance() {
+    return ServiceProvider.instance;
+  }
+  getClient(): Client {
+    return this._clientInstance;
+  }
+
+  getConnectionPool(): ConnectionPool {
+    return this._connectionPool;
+  }
+  async close(): Promise<void> {
+    await this._connectionPool.close();
+  }
+  async getPoolClint(): Promise<PoolClient> {
+    return await this._connectionPool.getClient();
+  }
+  async getGroupService() {
+    const clint = await this.getPoolClint();
+    return new GroupService(clint);
+  }
+  async getUserService() {
+    const clint = await this.getPoolClint();
+    return new UserService(clint);
+  }
+}