evogram-gramjs 1.1.0 → 1.1.1

package/src/sessions/SessionLogger.ts

@@ -1,208 +0,0 @@
-import { createWriteStream, WriteStream } from 'fs'
-import { mkdir } from 'fs/promises'
-import { join } from 'path'
-
-/**
- * Логгер для отдельной сессии
- * Записывает все действия и активность сессии в отдельный файл
- */
-export class SessionLogger {
-	private logStream: WriteStream | null = null
-	private logFilePath: string
-	private isInitialized: boolean = false
-
-	/**
-	 * @param sessionId Идентификатор сессии
-	 * @param logsDirectory Директория для хранения логов (по умолчанию './logs')
-	 */
-	constructor(private readonly sessionId: string, private readonly logsDirectory: string = './logs') {
-		// Формируем путь к файлу лога
-		const sanitizedSessionId = this.sanitizeFileName(sessionId)
-		const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
-		this.logFilePath = join(this.logsDirectory, `session-${sanitizedSessionId}-${timestamp}.log`)
-	}
-
-	/**
-	 * Инициализирует логгер (создает директорию и файл)
-	 */
-	async initialize(): Promise<void> {
-		if (this.isInitialized) return
-
-		try {
-			// Создаем директорию для логов, если её нет
-			await mkdir(this.logsDirectory, { recursive: true })
-
-			// Создаем поток записи в файл (режим append)
-			this.logStream = createWriteStream(this.logFilePath, { flags: 'a' })
-
-			// Записываем заголовок
-			this.writeLog('INFO', `Логгер инициализирован для сессии: ${this.sessionId}`)
-			this.writeLog('INFO', `Файл лога: ${this.logFilePath}`)
-			this.writeLog('INFO', `Время создания: ${new Date().toISOString()}`)
-			this.writeLog('INFO', '─'.repeat(80))
-
-			this.isInitialized = true
-		} catch (error) {
-			console.error(`Ошибка инициализации логгера для сессии ${this.sessionId}:`, error)
-			throw error
-		}
-	}
-
-	/**
-	 * Записывает лог-запись в файл
-	 *
-	 * @param level Уровень логирования (INFO, WARN, ERROR, DEBUG)
-	 * @param message Сообщение для логирования
-	 * @param data Дополнительные данные (опционально)
-	 */
-	log(level: 'INFO' | 'WARN' | 'ERROR' | 'DEBUG', message: string, data?: any): void {
-		if (!this.isInitialized) {
-			// Если логгер еще не инициализирован, инициализируем синхронно
-			this.initialize().catch((error) => {
-				console.error(`Ошибка инициализации логгера:`, error)
-			})
-			return
-		}
-
-		this.writeLog(level, message, data)
-	}
-
-	/**
-	 * Логирует информацию
-	 */
-	info(message: string, data?: any): void {
-		this.log('INFO', message, data)
-	}
-
-	/**
-	 * Логирует предупреждение
-	 */
-	warn(message: string, data?: any): void {
-		this.log('WARN', message, data)
-	}
-
-	/**
-	 * Логирует ошибку
-	 */
-	error(message: string, error?: Error | any): void {
-		const errorMessage = error instanceof Error ? error.message : String(error)
-		const errorStack = error instanceof Error ? error.stack : undefined
-		this.log('ERROR', message, { error: errorMessage, stack: errorStack })
-	}
-
-	/**
-	 * Логирует отладочную информацию
-	 */
-	debug(message: string, data?: any): void {
-		this.log('DEBUG', message, data)
-	}
-
-	/**
-	 * Логирует действие сессии
-	 *
-	 * @param action Название действия
-	 * @param details Детали действия
-	 */
-	logAction(action: string, details?: any): void {
-		this.info(`Действие: ${action}`, details)
-	}
-
-	/**
-	 * Логирует событие от Telegram клиента
-	 *
-	 * @param eventName Название события
-	 * @param eventData Данные события
-	 */
-	logTelegramEvent(eventName: string, eventData?: any): void {
-		this.debug(`Telegram событие: ${eventName}`, eventData)
-	}
-
-	/**
-	 * Закрывает поток записи
-	 */
-	async close(): Promise<void> {
-		if (this.logStream) {
-			this.writeLog('INFO', '─'.repeat(80))
-			this.writeLog('INFO', `Логгер закрыт для сессии: ${this.sessionId}`)
-			this.writeLog('INFO', `Время закрытия: ${new Date().toISOString()}`)
-
-			return new Promise((resolve, reject) => {
-				this.logStream!.end((error: Error | null | undefined) => {
-					if (error) {
-						reject(error)
-					} else {
-						this.logStream = null
-						this.isInitialized = false
-						resolve()
-					}
-				})
-			})
-		}
-	}
-
-	/**
-	 * Получает путь к файлу лога
-	 */
-	getLogFilePath(): string {
-		return this.logFilePath
-	}
-
-	/**
-	 * Внутренний метод для записи в файл
-	 *
-	 * @private
-	 */
-	private writeLog(level: string, message: string, data?: any): void {
-		if (!this.logStream) {
-			// Если поток еще не создан, выводим в консоль
-			console.log(`[${this.sessionId}] [${level}] ${message}`, data || '')
-			return
-		}
-
-		const timestamp = new Date().toISOString()
-		const logEntry: any = {
-			timestamp,
-			level,
-			sessionId: this.sessionId,
-			message,
-		}
-
-		if (data !== undefined) {
-			logEntry.data = data
-		}
-
-		// Форматируем запись для удобного чтения
-		const logLine = this.formatLogEntry(logEntry)
-		this.logStream.write(logLine + '\n')
-	}
-
-	/**
-	 * Форматирует запись лога для записи в файл
-	 *
-	 * @private
-	 */
-	private formatLogEntry(entry: any): string {
-		const { timestamp, level, message, data } = entry
-		let logLine = `[${timestamp}] [${level}] ${message}`
-
-		if (data !== undefined) {
-			try {
-				const dataStr = typeof data === 'string' ? data : JSON.stringify(data, null, 2)
-				logLine += `\n${dataStr}`
-			} catch (error) {
-				logLine += `\n[Не удалось сериализовать данные]`
-			}
-		}
-
-		return logLine
-	}
-
-	/**
-	 * Очищает имя файла от недопустимых символов
-	 *
-	 * @private
-	 */
-	private sanitizeFileName(fileName: string): string {
-		return fileName.replace(/[^a-zA-Z0-9_-]/g, '_')
-	}
-}

package/src/sessions/SessionManager.ts

@@ -1,211 +0,0 @@
-import { EventEmitter } from 'events'
-import { Api, TelegramClient } from 'telegram'
-import { UpdateConnectionState } from 'telegram/network'
-import { StringSession } from 'telegram/sessions'
-import { EvogramGramJS } from '../EvogramGramJS'
-import { Session as SessionEntity } from '../entities/Session.entity'
-import { DatabaseService } from '../services/DatabaseService'
-import { SessionConfig, SessionEvent, SessionEventData, SessionInfo, SessionInvalidEventData } from '../types/session.types'
-import { Session } from './Session'
-import { SessionAuth } from './SessionAuth'
-import { SessionLogger } from './SessionLogger'
-
-/**
- * Сервис для управления множеством сессий Telegram клиентов
- *
- * Предоставляет удобный API для:
- * - Добавления и удаления сессий
- * - Получения информации о сессиях
- * - Отслеживания событий (подключение, отключение, ошибки)
- * - Сохранения данных в базе данных
- */
-export class SessionManager extends EventEmitter {
-	constructor(private readonly TELEGRAM_APP_ID: number, private readonly TELEGRAM_APP_HASH: string, private readonly databaseService?: DatabaseService) {
-		super()
-	}
-
-	/** Хранилище всех активных сессий */
-	private sessions: Map<string, SessionInfo> = new Map()
-
-	public async initialize(): Promise<void> {
-		const sessions = await this.databaseService?.getSessions()
-		if (!sessions || sessions.length === 0) return
-
-		for (const session of sessions) {
-			await this.addSession({
-				sessionId: session.sessionId,
-				sessionString: session.sessionString,
-				apiId: session.apiId,
-				apiHash: session.apiHash,
-				clientOptions: session.clientOptions ? JSON.parse(session.clientOptions) : undefined,
-			})
-		}
-	}
-
-	/**
-	 * Добавляет новую сессию
-	 *
-	 * @param config Конфигурация сессии
-	 * @returns Promise с информацией о созданной сессии
-	 * @throws Error если сессия с таким ID уже существует
-	 */
-	async addSession(config: SessionConfig): Promise<SessionInfo> {
-		// Проверяем, не существует ли уже сессия с таким ID в памяти
-		if (this.sessions.has(config.sessionId)) return this.sessions.get(config.sessionId)!
-
-		// Создаем строковую сессию (если не предоставлена, создается пустая)
-		const session = new StringSession(config.sessionString || '')
-
-		// Создаем Telegram клиент
-		const client = new TelegramClient(session, config.apiId ?? this.TELEGRAM_APP_ID, config.apiHash ?? this.TELEGRAM_APP_HASH, {
-			useIPV6: config.clientOptions?.useIPV6 ?? false,
-			connectionRetries: config.clientOptions?.connectionRetries ?? 5,
-		})
-		await client.connect()
-
-		client.addEventHandler(async (event) => {
-			if ((await this.getSession(config.sessionId)?.db())?.error) return
-			else if (!(await this.getSession(config.sessionId)?.db())?.sessionString) return
-
-			if (event instanceof UpdateConnectionState) {
-				const error = await client
-					.getMe()
-					.then(() => undefined)
-					.catch((error) => error)
-
-				if (error) {
-					this.emit(SessionEvent.SESSION_INVALID, {
-						sessionId: config.sessionId,
-						error: error,
-					} as SessionInvalidEventData)
-
-					await EvogramGramJS.databaseService.updateSession(config.sessionId, { error: error.errorMessage })
-					await this.disconnectSession(config.sessionId)
-				}
-			}
-		})
-
-		const sessionAuth = new SessionAuth(config.sessionId, client)
-
-		const sessionInfo = new Session(config.sessionId, client, undefined, sessionAuth)
-		this.sessions.set(config.sessionId, sessionInfo)
-
-		// Генерируем событие добавления сессии
-		this.emit(SessionEvent.SESSION_ADDED, {
-			sessionId: config.sessionId,
-			sessionInfo,
-		} as SessionEventData)
-
-		return sessionInfo
-	}
-
-	async disconnectSession(sessionId: string): Promise<void> {
-		const session = this.sessions.get(sessionId)
-		if (!session) throw new Error(`Сессия с ID ${sessionId} не найдена`)
-
-		await session.client.disconnect()
-		this.emit(SessionEvent.SESSION_DISCONNECTED, {
-			sessionId: sessionId,
-		} as SessionEventData)
-	}
-
-	async getActiveSessions(): Promise<SessionInfo[]> {
-		const sessions = Array.from(this.sessions.values())
-
-		const results = await Promise.all(
-			sessions.map(async (session) => {
-				const dbData = await session.db()
-				return { session, hasError: !!dbData?.error }
-			})
-		)
-
-		return results.filter((result) => !result.hasError).map((result) => result.session)
-	}
-
-	/**
-	 * Получает информацию о сессии по ID
-	 *
-	 * @param sessionId Идентификатор сессии
-	 * @returns Информация о сессии или undefined, если не найдена
-	 */
-	getSession(sessionId: string): SessionInfo | undefined {
-		const sessionInfo = this.sessions.get(sessionId)
-		return sessionInfo
-	}
-
-	/**
-	 * Получает Telegram клиент по ID сессии
-	 *
-	 * @param sessionId Идентификатор сессии
-	 * @returns Telegram клиент или undefined, если сессия не найдена
-	 */
-	getClient(sessionId: string): TelegramClient | undefined {
-		return this.getSession(sessionId)?.client
-	}
-
-	/**
-	 * Получает логгер сессии по ID
-	 *
-	 * @param sessionId Идентификатор сессии
-	 * @returns Логгер сессии или undefined, если сессия не найдена или логирование отключено
-	 */
-	getLogger(sessionId: string): SessionLogger | undefined {
-		return this.getSession(sessionId)?.logger
-	}
-
-	/**
-	 * Получает все активные сессии
-	 *
-	 * @returns Массив информации о всех сессиях
-	 */
-	getAllSessions(): SessionInfo[] {
-		return Array.from(this.sessions.values())
-	}
-
-	async getAllLoadedSessions(): Promise<({ db: SessionEntity | null; user: Api.User | null } & Omit<SessionInfo, 'db' | 'user'>)[]> {
-		const sessions = Array.from(this.sessions.values())
-
-		const results = await Promise.all(
-			sessions
-				.filter((x) => x.sessionId)
-				.map(async (session) => {
-					return {
-						...session,
-						db: await session.db().catch(() => null),
-						user: await session.user().catch(() => null),
-					}
-				})
-		)
-
-		//@ts-ignore
-		return results
-	}
-
-	/**
-	 * Получает список всех ID сессий
-	 *
-	 * @returns Массив идентификаторов сессий
-	 */
-	getAllSessionIds(): string[] {
-		return Array.from(this.sessions.keys())
-	}
-
-	/**
-	 * Проверяет, существует ли сессия с указанным ID
-	 *
-	 * @param sessionId Идентификатор сессии
-	 * @returns true, если сессия существует, иначе false
-	 */
-	hasSession(sessionId: string): boolean {
-		return this.sessions.has(sessionId)
-	}
-
-	/**
-	 * Получает количество активных сессий
-	 *
-	 * @returns Количество сессий
-	 */
-	getSessionCount(): number {
-		return this.sessions.size
-	}
-}

package/src/types/auth.types.ts

@@ -1,94 +0,0 @@
-/**
- * Состояния процесса авторизации
- */
-export enum AuthState {
-	/** Начальное состояние - не авторизован */
-	INITIAL = 'initial',
-	/** Ожидание кода подтверждения */
-	WAITING_CODE = 'waiting_code',
-	/** Ожидание пароля (2FA) */
-	WAITING_PASSWORD = 'waiting_password',
-	/** Авторизация завершена */
-	AUTHORIZED = 'authorized',
-	/** Ошибка авторизации */
-	ERROR = 'error',
-}
-
-/**
- * Информация о процессе авторизации
- */
-export interface AuthInfo {
-	/** Идентификатор сессии */
-	sessionId: string
-	/** Текущее состояние авторизации */
-	state: AuthState
-	/** Номер телефона (если указан) */
-	phoneNumber?: string
-	/** Требуется ли пароль (2FA) */
-	isRequiredPassword: boolean
-	/** Код подтверждения (если ожидается) */
-	code?: string
-	/** Пароль (2FA) (если ожидается) */
-	password?: string
-	/** Хеш кода подтверждения */
-	phoneCodeHash?: string
-	/** Сообщение об ошибке (если есть) */
-	error?: string
-	/** Время начала авторизации */
-	startedAt: Date
-	/** Время последнего обновления */
-	updatedAt: Date
-	/** Промисы для ожидания кода и пароля */
-	_codeResolver?: (code: string) => void
-	_codeRejecter?: (error: Error) => void
-	_passwordResolver?: (password: string) => void
-	_passwordRejecter?: (error: Error) => void
-	/** Промис для отслеживания начальной ошибки (до запроса кода) */
-	_initialErrorRejecter?: (error: Error) => void
-	/** Resolver для промиса, когда код был запрошен (успешное начало) */
-	_codeRequestedResolver?: () => void
-	/** Флаг, что код был запрошен (для различения начальной ошибки от ошибки после запроса кода) */
-	_codeRequested?: boolean
-	/** Флаг, что была ошибка неверного кода (для отслеживания повторной попытки) */
-	_hasCodeError?: boolean
-}
-
-/**
- * Результат отправки кода
- */
-export interface SendCodeResult {
-	/** Успешно ли отправлен код */
-	success: boolean
-	/** Требуется ли пароль (2FA) */
-	isRequiredPassword: boolean
-	/** Сообщение об ошибке (если есть) */
-	error?: string
-	/** Тип отправки кода (sms, call, etc.) */
-	phoneCodeHash?: string
-}
-
-/**
- * Результат ввода кода
- */
-export interface SignInResult {
-	/** Успешно ли авторизован */
-	success: boolean
-	/** Требуется ли пароль (2FA) */
-	isRequiredPassword: boolean
-	/** Сообщение об ошибке (если есть) */
-	error?: string
-	/** Строка сессии (если авторизация успешна) */
-	sessionString?: string
-}
-
-/**
- * Результат ввода пароля
- */
-export interface SignInWithPasswordResult {
-	/** Успешно ли авторизован */
-	success: boolean
-	/** Сообщение об ошибке (если есть) */
-	error?: string
-	/** Строка сессии (если авторизация успешна) */
-	sessionString?: string
-}

package/src/types/session.types.ts

@@ -1,96 +0,0 @@
-import { Session } from '../sessions/Session'
-
-/**
- * Конфигурация для создания новой сессии
- */
-export interface SessionConfig {
-	/** Уникальный идентификатор сессии */
-	sessionId: string
-	/** API ID из Telegram */
-	apiId?: number
-	/** API Hash из Telegram */
-	apiHash?: string
-	/** Строка сессии (если уже существует) */
-	sessionString?: string
-	/** Дополнительные опции для клиента */
-	clientOptions?: {
-		/** Использовать IPv6 */
-		useIPV6?: boolean
-		/** Таймаут подключения */
-		connectionRetries?: number
-		/** Максимальное количество попыток переподключения */
-		maxRetries?: number
-	}
-	/** Настройки логирования */
-	logging?: {
-		/** Включить логирование (по умолчанию true) */
-		enabled?: boolean
-		/** Директория для хранения логов (по умолчанию './logs') */
-		logsDirectory?: string
-	}
-}
-
-/**
- * Информация о сессии
- * Использует класс Session для представления сессии
- */
-export type SessionInfo = Session
-
-/**
- * События, которые может генерировать менеджер сессий
- */
-export enum SessionEvent {
-	/** Сессия была добавлена */
-	SESSION_ADDED = 'session:added',
-	/** Сессия была удалена */
-	SESSION_REMOVED = 'session:removed',
-	/** Сессия подключилась */
-	SESSION_CONNECTED = 'session:connected',
-	/** Сессия отключилась */
-	SESSION_DISCONNECTED = 'session:disconnected',
-	/** Произошла ошибка в сессии */
-	SESSION_ERROR = 'session:error',
-
-	/** Сессия стала недействительной */
-	SESSION_INVALID = 'session:invalid',
-}
-
-/**
- * Данные события добавления/удаления сессии
- */
-export interface SessionEventData {
-	sessionId: string
-	sessionInfo?: Session
-}
-
-/**
- * Данные события подключения/отключения
- */
-export interface SessionConnectionEventData {
-	sessionId: string
-	isConnected: boolean
-}
-
-/**
- * Данные события ошибки
- */
-export interface SessionErrorEventData {
-	sessionId: string
-	error: Error
-}
-
-/**
- * Данные события удаления сессии
- */
-export interface SessionRemovedEventData {
-	sessionId: string
-	error: Error
-}
-
-/**
- * Данные события недействительности сессии
- */
-export interface SessionInvalidEventData {
-	sessionId: string
-	error: Error
-}

package/src/utils/Deferrer.ts

@@ -1,12 +0,0 @@
-export class Deferred<T> {
-	public promise: Promise<T>
-	public resolve: (value: T | PromiseLike<T>) => void = () => {}
-	public reject: (reason?: any) => void = () => {}
-
-	constructor() {
-		this.promise = new Promise<T>((resolve, reject) => {
-			this.resolve = resolve
-			this.reject = reject
-		})
-	}
-}