common-tg-service 1.0.92 → 1.0.94

package/dist/components/Telegram/utils/connection-manager.d.ts

@@ -1,8 +1,28 @@
 import TelegramManager from '../TelegramManager';
 import { UsersService } from '../../../components/users/users.service';
+interface ClientInfo {
+    client: TelegramManager;
+    lastUsed: number;
+    autoDisconnect: boolean;
+    connectionAttempts: number;
+    isConnecting: boolean;
+}
 interface GetClientOptions {
     autoDisconnect?: boolean;
     handler?: boolean;
+    maxRetries?: number;
+}
+interface ConnectionStats {
+    activeConnections: number;
+    totalConnections: number;
+    failedConnections: number;
+    cleanupCount: number;
+}
+declare class ConnectionManagerError extends Error {
+    readonly mobile: string;
+    readonly operation: string;
+    readonly originalError?: Error;
+    constructor(message: string, mobile: string, operation: string, originalError?: Error);
 }
 declare class ConnectionManager {
     private static instance;
@@ -10,19 +30,38 @@ declare class ConnectionManager {
     private readonly logger;
     private cleanupInterval;
     private usersService;
+    private readonly maxRetries;
+    private readonly connectionTimeout;
+    private stats;
     private constructor();
     setUsersService(usersService: UsersService): void;
     static getInstance(): ConnectionManager;
     private cleanupInactiveConnections;
     private updateLastUsed;
-    getClient(mobile: string, options?: GetClientOptions): Promise<TelegramManager | undefined>;
-    hasClient(number: string): boolean;
-    disconnectAll(): Promise<void>;
+    private validateMobile;
+    private getUserByMobile;
+    getClient(mobile: string, options?: GetClientOptions): Promise<TelegramManager>;
+    private tryGetExistingClient;
+    private waitForConnection;
+    private createNewClientWithRetries;
+    private createNewClient;
+    private handleFinalError;
+    private markUserAsExpired;
+    hasClient(mobile: string): boolean;
+    disconnectAll(): Promise<number>;
     private registerClient;
-    unregisterClient(mobile: string): Promise<void>;
+    unregisterClient(mobile: string): Promise<boolean>;
     getActiveConnectionCount(): number;
+    getConnectionStats(): ConnectionStats;
+    getClientInfo(mobile: string): Omit<ClientInfo, 'client'> | null;
     startCleanupInterval(intervalMs?: number): NodeJS.Timeout;
     stopCleanupInterval(): void;
+    healthCheck(): Promise<{
+        status: 'healthy' | 'degraded' | 'unhealthy';
+        activeConnections: number;
+        stats: ConnectionStats;
+        issues: string[];
+    }>;
 }
 export declare const connectionManager: ConnectionManager;
-export {};
+export { ConnectionManager, ConnectionManagerError };

package/dist/components/Telegram/utils/connection-manager.js

@@ -3,21 +3,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.connectionManager = void 0;
+exports.ConnectionManagerError = exports.ConnectionManager = exports.connectionManager = void 0;
 const TelegramManager_1 = __importDefault(require("../TelegramManager"));
 const parseError_1 = require("../../../utils/parseError");
 const telegram_logger_1 = require("./telegram-logger");
 const common_1 = require("@nestjs/common");
 const utils_1 = require("../../../utils");
 const TelegramBots_config_1 = require("../../../utils/TelegramBots.config");
+class ConnectionManagerError extends Error {
+    constructor(message, mobile, operation, originalError) {
+        super(message);
+        this.mobile = mobile;
+        this.operation = operation;
+        this.originalError = originalError;
+        this.name = 'ConnectionManagerError';
+    }
+}
+exports.ConnectionManagerError = ConnectionManagerError;
 class ConnectionManager {
     constructor() {
-        this.cleanupInterval = null;
         this.clients = new Map();
+        this.cleanupInterval = null;
+        this.usersService = null;
+        this.maxRetries = 3;
+        this.connectionTimeout = 30000;
+        this.stats = {
+            activeConnections: 0,
+            totalConnections: 0,
+            failedConnections: 0,
+            cleanupCount: 0
+        };
         this.logger = telegram_logger_1.TelegramLogger.getInstance();
+        this.logger.logOperation('system', 'ConnectionManager initialized');
     }
     setUsersService(usersService) {
+        if (!usersService) {
+            throw new Error('UsersService cannot be null or undefined');
+        }
         this.usersService = usersService;
+        this.logger.logOperation('system', 'UsersService registered successfully');
     }
     static getInstance() {
         if (!ConnectionManager.instance) {
@@ -26,131 +50,393 @@ class ConnectionManager {
         return ConnectionManager.instance;
     }
     async cleanupInactiveConnections(maxIdleTime = 180000) {
-        const now = Date.now();
-        for (const [mobile, connection] of this.clients.entries()) {
-            if (!connection.autoDisconnect) {
-                continue;
+        const startTime = Date.now();
+        let cleanedCount = 0;
+        try {
+            this.logger.logOperation('system', 'Starting cleanup of inactive connections', { maxIdleTime });
+            const now = Date.now();
+            const clientsToCleanup = [];
+            for (const [mobile, connection] of this.clients.entries()) {
+                if (!connection.autoDisconnect) {
+                    continue;
+                }
+                if (now - connection.lastUsed > maxIdleTime) {
+                    clientsToCleanup.push(mobile);
+                }
             }
-            if (now - connection.lastUsed > maxIdleTime) {
-                this.logger.logOperation(mobile, 'Releasing inactive connection');
-                await this.unregisterClient(mobile);
+            for (const mobile of clientsToCleanup) {
+                try {
+                    this.logger.logOperation(mobile, 'Cleaning up inactive connection');
+                    await this.unregisterClient(mobile);
+                    cleanedCount++;
+                }
+                catch (error) {
+                    this.logger.logError(mobile, 'Failed to cleanup inactive connection', error);
+                }
             }
+            this.stats.cleanupCount += cleanedCount;
+            const duration = Date.now() - startTime;
+            this.logger.logOperation('system', 'Cleanup completed', {
+                cleanedCount,
+                totalChecked: this.clients.size + cleanedCount,
+                duration: `${duration}ms`
+            });
+            return cleanedCount;
+        }
+        catch (error) {
+            this.logger.logError('system', 'Error during cleanup operation', error);
+            throw new ConnectionManagerError('Cleanup operation failed', 'system', 'cleanupInactiveConnections', error);
         }
     }
     updateLastUsed(mobile) {
-        const connection = this.clients.get(mobile);
-        if (connection) {
-            connection.lastUsed = Date.now();
-            this.clients.set(mobile, connection);
+        try {
+            const connection = this.clients.get(mobile);
+            if (connection) {
+                connection.lastUsed = Date.now();
+                this.clients.set(mobile, connection);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            this.logger.logError(mobile, 'Failed to update last used timestamp', error);
+            return false;
+        }
+    }
+    async validateMobile(mobile) {
+        if (!mobile || typeof mobile !== 'string' || mobile.trim().length === 0) {
+            throw new common_1.BadRequestException('Mobile number is required and must be a non-empty string');
+        }
+    }
+    async getUserByMobile(mobile) {
+        if (!this.usersService) {
+            throw new common_1.InternalServerErrorException('UsersService not initialized');
+        }
+        try {
+            const users = await this.usersService.search({ mobile });
+            if (!users || users.length === 0) {
+                throw new common_1.BadRequestException(`User not found for mobile: ${mobile}`);
+            }
+            const user = users[0];
+            if (!user.session) {
+                throw new common_1.BadRequestException(`User session not found for mobile: ${mobile}`);
+            }
+            return user;
+        }
+        catch (error) {
+            if (error instanceof common_1.BadRequestException) {
+                throw error;
+            }
+            this.logger.logError(mobile, 'Failed to fetch user from database', error);
+            throw new common_1.InternalServerErrorException('Failed to retrieve user information');
         }
     }
     async getClient(mobile, options = {}) {
-        if (!mobile) {
-            this.logger.logDebug('system', 'getClient called with empty mobile number');
-            return undefined;
+        const startTime = Date.now();
+        const { autoDisconnect = true, handler = true, maxRetries = this.maxRetries } = options;
+        try {
+            await this.validateMobile(mobile);
+            this.logger.logOperation(mobile, 'Getting/Creating client', {
+                autoDisconnect,
+                handler,
+                maxRetries
+            });
+            const existingClient = await this.tryGetExistingClient(mobile);
+            if (existingClient) {
+                const duration = Date.now() - startTime;
+                this.logger.logOperation(mobile, 'Client retrieved successfully', {
+                    source: 'existing',
+                    duration: `${duration}ms`
+                });
+                return existingClient;
+            }
+            const newClient = await this.createNewClientWithRetries(mobile, { autoDisconnect, handler }, maxRetries);
+            const duration = Date.now() - startTime;
+            this.logger.logOperation(mobile, 'Client created successfully', {
+                source: 'new',
+                duration: `${duration}ms`
+            });
+            return newClient;
         }
-        const { autoDisconnect = true, handler = true, } = options;
-        this.logger.logOperation(mobile, 'Getting/Creating client', { autoDisconnect, handler });
+        catch (error) {
+            const duration = Date.now() - startTime;
+            this.stats.failedConnections++;
+            this.logger.logError(mobile, 'Failed to get client', error);
+            if (error instanceof common_1.BadRequestException || error instanceof common_1.InternalServerErrorException) {
+                throw error;
+            }
+            throw new common_1.InternalServerErrorException('Failed to establish Telegram connection');
+        }
+    }
+    async tryGetExistingClient(mobile) {
         const clientInfo = this.clients.get(mobile);
-        if (clientInfo?.client) {
-            this.updateLastUsed(mobile);
-            if (clientInfo.client.connected()) {
-                this.logger.logOperation(mobile, 'Reusing existing connected client');
-                return clientInfo.client;
+        if (!clientInfo?.client) {
+            return null;
+        }
+        if (clientInfo.isConnecting) {
+            this.logger.logOperation(mobile, 'Another connection attempt in progress, waiting...');
+            await this.waitForConnection(mobile);
+            return this.clients.get(mobile)?.client || null;
+        }
+        this.updateLastUsed(mobile);
+        if (clientInfo.client.connected()) {
+            this.logger.logOperation(mobile, 'Reusing existing connected client');
+            return clientInfo.client;
+        }
+        try {
+            clientInfo.isConnecting = true;
+            this.logger.logOperation(mobile, 'Reconnecting existing client');
+            await Promise.race([
+                clientInfo.client.connect(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), this.connectionTimeout))
+            ]);
+            clientInfo.isConnecting = false;
+            return clientInfo.client;
+        }
+        catch (error) {
+            clientInfo.isConnecting = false;
+            this.logger.logError(mobile, 'Failed to reconnect existing client', error);
+            await this.unregisterClient(mobile);
+            return null;
+        }
+    }
+    async waitForConnection(mobile, maxWaitTime = 60000) {
+        const startTime = Date.now();
+        const checkInterval = 1000;
+        while (Date.now() - startTime < maxWaitTime) {
+            const clientInfo = this.clients.get(mobile);
+            if (!clientInfo?.isConnecting) {
+                return;
             }
-            else {
-                try {
-                    this.logger.logOperation(mobile, 'Reconnecting existing client');
-                    await clientInfo.client.connect();
-                    return clientInfo.client;
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+        }
+        throw new Error('Timeout waiting for connection to complete');
+    }
+    async createNewClientWithRetries(mobile, options, maxRetries) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                this.logger.logOperation(mobile, `Creating client (attempt ${attempt}/${maxRetries})`);
+                const client = await this.createNewClient(mobile, options);
+                this.stats.totalConnections++;
+                return client;
+            }
+            catch (error) {
+                lastError = error;
+                this.logger.logError(mobile, `Client creation attempt ${attempt} failed`, error);
+                if (attempt < maxRetries) {
+                    const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+                    this.logger.logOperation(mobile, `Retrying in ${delay}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
                 }
-                catch (error) {
-                    this.logger.logError(mobile, 'Failed to reconnect client', error);
-                    await this.unregisterClient(mobile);
+                else {
+                    await this.handleFinalError(mobile, error);
                 }
             }
         }
-        if (!this.usersService) {
-            throw new Error('UsersService not initialized');
+        throw lastError || new Error('All retry attempts failed');
+    }
+    async createNewClient(mobile, options) {
+        const tempClientInfo = {
+            client: null,
+            lastUsed: Date.now(),
+            autoDisconnect: options.autoDisconnect,
+            connectionAttempts: 0,
+            isConnecting: true
+        };
+        this.clients.set(mobile, tempClientInfo);
+        try {
+            const user = await this.getUserByMobile(mobile);
+            const telegramManager = new TelegramManager_1.default(user.session, user.mobile);
+            const client = await Promise.race([
+                telegramManager.createClient(options.handler),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Client creation timeout')), this.connectionTimeout))
+            ]);
+            await Promise.race([
+                client.getMe(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Client verification timeout')), this.connectionTimeout))
+            ]);
+            await this.registerClient(mobile, telegramManager, { autoDisconnect: options.autoDisconnect });
+            return telegramManager;
         }
-        const user = (await this.usersService.search({ mobile }))[0];
-        if (!user) {
-            throw new common_1.BadRequestException('user not found');
+        catch (error) {
+            this.clients.delete(mobile);
+            throw error;
         }
-        const telegramManager = new TelegramManager_1.default(user.session, user.mobile);
-        let client;
+    }
+    async handleFinalError(mobile, error) {
         try {
-            client = await telegramManager.createClient(handler);
-            await client.getMe();
-            if (client) {
-                await this.registerClient(mobile, telegramManager, { autoDisconnect });
-                this.logger.logOperation(mobile, 'Client created successfully');
-                return telegramManager;
+            this.logger.logDebug(mobile, 'Parsing final error details...');
+            const errorDetails = (0, parseError_1.parseError)(error, mobile, false);
+            try {
+                await TelegramBots_config_1.BotConfig.getInstance().sendMessage(TelegramBots_config_1.ChannelCategory.ACCOUNT_LOGIN_FAILURES, `${process.env.clientId}::${mobile}\n\n${errorDetails.message}`);
             }
-            else {
-                throw new common_1.BadRequestException('Client Expired');
+            catch (notificationError) {
+                this.logger.logError(mobile, 'Failed to send error notification', notificationError);
             }
+            const lowerCaseMessage = errorDetails.message.toLowerCase();
+            const expiredKeywords = ['expired', 'unregistered', 'deactivated', 'revoked', 'user_deactivated_ban'];
+            if ((0, utils_1.contains)(lowerCaseMessage, expiredKeywords)) {
+                await this.markUserAsExpired(mobile);
+            }
+            throw new common_1.BadRequestException(errorDetails.message);
         }
         catch (error) {
-            this.logger.logError(mobile, 'Client creation failed', error);
-            this.logger.logDebug(mobile, 'Parsing error details...');
-            await this.unregisterClient(mobile);
-            const errorDetails = (0, parseError_1.parseError)(error, mobile, false);
-            await TelegramBots_config_1.BotConfig.getInstance().sendMessage(TelegramBots_config_1.ChannelCategory.ACCOUNT_LOGIN_FAILURES, `${process.env.clientId}::${mobile}\n\n${errorDetails.message}`);
-            if ((0, utils_1.contains)(errorDetails.message.toLowerCase(), ['expired', 'unregistered', 'deactivated', "revoked", "user_deactivated_ban"])) {
-                this.logger.logOperation(mobile, 'Marking user as expired');
-                await this.usersService.updateByFilter({ $or: [{ tgId: user.tgId }, { mobile: mobile }] }, { expired: true });
+            if (error instanceof common_1.BadRequestException) {
+                throw error;
             }
-            throw new common_1.BadRequestException(errorDetails.message);
+            this.logger.logError(mobile, 'Error handling final error', error);
+            throw new common_1.InternalServerErrorException('Client creation failed with unhandled error');
+        }
+    }
+    async markUserAsExpired(mobile) {
+        try {
+            if (!this.usersService) {
+                throw new Error('UsersService not available');
+            }
+            this.logger.logOperation(mobile, 'Marking user as expired');
+            const users = await this.usersService.search({ mobile });
+            const user = users?.[0];
+            const filter = user?.tgId
+                ? { $or: [{ tgId: user.tgId }, { mobile: mobile }] }
+                : { mobile: mobile };
+            await this.usersService.updateByFilter(filter, { expired: true });
+            this.logger.logOperation(mobile, 'User marked as expired successfully');
+        }
+        catch (error) {
+            this.logger.logError(mobile, 'Failed to mark user as expired', error);
         }
     }
-    hasClient(number) {
-        return this.clients.has(number);
+    hasClient(mobile) {
+        try {
+            if (!mobile)
+                return false;
+            return this.clients.has(mobile);
+        }
+        catch (error) {
+            this.logger.logError(mobile || 'unknown', 'Error checking client existence', error);
+            return false;
+        }
     }
     async disconnectAll() {
-        this.logger.logOperation('system', 'Disconnecting all clients');
-        const clientMobiles = Array.from(this.clients.keys());
-        await Promise.all(clientMobiles.map(mobile => {
-            this.logger.logOperation(mobile, 'Disconnecting client');
-            return this.unregisterClient(mobile);
-        }));
-        this.clients.clear();
-        this.logger.logOperation('system', 'All clients disconnected');
+        const startTime = Date.now();
+        let disconnectedCount = 0;
+        try {
+            this.logger.logOperation('system', 'Starting disconnection of all clients');
+            const clientMobiles = Array.from(this.clients.keys());
+            const results = await Promise.allSettled(clientMobiles.map(async (mobile) => {
+                this.logger.logOperation(mobile, 'Disconnecting client');
+                await this.unregisterClient(mobile);
+                return mobile;
+            }));
+            results.forEach((result, index) => {
+                if (result.status === 'fulfilled') {
+                    disconnectedCount++;
+                }
+                else {
+                    this.logger.logError(clientMobiles[index], 'Failed to disconnect client', result.reason);
+                }
+            });
+            this.clients.clear();
+            const duration = Date.now() - startTime;
+            this.logger.logOperation('system', 'All clients disconnection completed', {
+                totalClients: clientMobiles.length,
+                successfulDisconnections: disconnectedCount,
+                failedDisconnections: clientMobiles.length - disconnectedCount,
+                duration: `${duration}ms`
+            });
+            return disconnectedCount;
+        }
+        catch (error) {
+            this.logger.logError('system', 'Error during disconnectAll operation', error);
+            throw new ConnectionManagerError('Failed to disconnect all clients', 'system', 'disconnectAll', error);
+        }
     }
     async registerClient(mobile, telegramManager, options = { autoDisconnect: true }) {
-        this.clients.set(mobile, {
-            client: telegramManager,
-            lastUsed: Date.now(),
-            autoDisconnect: options.autoDisconnect
-        });
-        this.logger.logOperation(mobile, `Client registered successfully${!options.autoDisconnect ? ' (excluded from auto-cleanup)' : ''}`);
+        try {
+            this.clients.set(mobile, {
+                client: telegramManager,
+                lastUsed: Date.now(),
+                autoDisconnect: options.autoDisconnect,
+                connectionAttempts: 0,
+                isConnecting: false
+            });
+            this.stats.activeConnections = this.clients.size;
+            this.logger.logOperation(mobile, `Client registered successfully${!options.autoDisconnect ? ' (excluded from auto-cleanup)' : ''}`, {
+                activeConnections: this.stats.activeConnections
+            });
+        }
+        catch (error) {
+            this.logger.logError(mobile, 'Failed to register client', error);
+            throw new ConnectionManagerError('Client registration failed', mobile, 'registerClient', error);
+        }
     }
     async unregisterClient(mobile) {
         try {
             const clientInfo = this.clients.get(mobile);
             if (clientInfo) {
-                await clientInfo.client?.disconnect();
-                this.logger.logOperation(mobile, 'Client unregistered successfully');
+                clientInfo.isConnecting = false;
+                if (clientInfo.client) {
+                    await Promise.race([
+                        clientInfo.client.disconnect(),
+                        new Promise((resolve) => setTimeout(() => {
+                            this.logger.logError(mobile, 'Client disconnect timeout, forcing cleanup', {});
+                            resolve();
+                        }, 10000))
+                    ]);
+                }
+                this.clients.delete(mobile);
+                this.stats.activeConnections = this.clients.size;
+                this.logger.logOperation(mobile, 'Client unregistered successfully', {
+                    activeConnections: this.stats.activeConnections
+                });
+                return true;
             }
             else {
-                this.logger.logError(mobile, 'Client not found for unregistration', new Error('Client not found'));
+                this.logger.logDebug(mobile, 'Client not found for unregistration');
+                return false;
             }
         }
         catch (error) {
             this.logger.logError(mobile, 'Error in unregisterClient', error);
-        }
-        finally {
             this.clients.delete(mobile);
+            this.stats.activeConnections = this.clients.size;
+            return false;
         }
     }
     getActiveConnectionCount() {
         return this.clients.size;
     }
+    getConnectionStats() {
+        return {
+            ...this.stats,
+            activeConnections: this.clients.size
+        };
+    }
+    getClientInfo(mobile) {
+        const clientInfo = this.clients.get(mobile);
+        if (!clientInfo)
+            return null;
+        return {
+            lastUsed: clientInfo.lastUsed,
+            autoDisconnect: clientInfo.autoDisconnect,
+            connectionAttempts: clientInfo.connectionAttempts,
+            isConnecting: clientInfo.isConnecting
+        };
+    }
     startCleanupInterval(intervalMs = 300000) {
-        this.cleanupInterval = setInterval(() => {
-            this.cleanupInactiveConnections().catch(err => {
-                this.logger.logError('system', 'Error in cleanup interval', err);
-            });
+        if (this.cleanupInterval) {
+            this.stopCleanupInterval();
+        }
+        this.logger.logOperation('system', 'Starting cleanup interval', { intervalMs });
+        this.cleanupInterval = setInterval(async () => {
+            try {
+                const cleanedCount = await this.cleanupInactiveConnections();
+                this.logger.logDebug('system', `Cleanup interval completed: ${cleanedCount} clients cleaned`);
+            }
+            catch (error) {
+                this.logger.logError('system', 'Error in cleanup interval', error);
+            }
         }, intervalMs);
         return this.cleanupInterval;
     }
@@ -158,8 +444,50 @@ class ConnectionManager {
         if (this.cleanupInterval) {
             clearInterval(this.cleanupInterval);
             this.cleanupInterval = null;
+            this.logger.logOperation('system', 'Cleanup interval stopped');
+        }
+    }
+    async healthCheck() {
+        const issues = [];
+        let status = 'healthy';
+        try {
+            if (!this.usersService) {
+                issues.push('UsersService not initialized');
+                status = 'unhealthy';
+            }
+            const activeCount = this.getActiveConnectionCount();
+            if (activeCount > 100) {
+                issues.push(`High connection count: ${activeCount}`);
+                status = status === 'healthy' ? 'degraded' : status;
+            }
+            let stuckConnections = 0;
+            for (const [mobile, info] of this.clients.entries()) {
+                if (info.isConnecting && (Date.now() - info.lastUsed) > 60000) {
+                    stuckConnections++;
+                }
+            }
+            if (stuckConnections > 0) {
+                issues.push(`${stuckConnections} stuck connections detected`);
+                status = status === 'healthy' ? 'degraded' : status;
+            }
+            return {
+                status,
+                activeConnections: activeCount,
+                stats: this.getConnectionStats(),
+                issues
+            };
+        }
+        catch (error) {
+            this.logger.logError('system', 'Health check failed', error);
+            return {
+                status: 'unhealthy',
+                activeConnections: 0,
+                stats: this.stats,
+                issues: ['Health check failed']
+            };
         }
     }
 }
+exports.ConnectionManager = ConnectionManager;
 exports.connectionManager = ConnectionManager.getInstance();
 //# sourceMappingURL=connection-manager.js.map