evogram-gramjs 1.0.3 → 1.1.1

package/src/services/ImageUploadService.ts

@@ -1,49 +0,0 @@
-import axios from 'axios'
-import FormData from 'form-data'
-
-/**
- * Сервис для загрузки изображений на внешние хостинги
- */
-export class ImageUploadService {
-	static readonly UPLOAD_URL = 'https://imgbox.vu/uploads'
-
-	/**
-	 * Загружает изображение на imgbox.vu/uploads
-	 *
-	 * @param imageBuffer Буфер изображения
-	 * @param filename Имя файла (опционально)
-	 * @returns Promise с URL загруженного изображения
-	 * @throws Error если загрузка не удалась
-	 */
-	static async uploadToImgbox(imageBuffer: Buffer, filename?: string): Promise<string> {
-		try {
-			const formData = new FormData()
-			formData.append('file', imageBuffer, {
-				filename: filename || 'avatar.jpg',
-				contentType: 'image/jpeg',
-			})
-
-			const response = await axios.post(this.UPLOAD_URL, formData, {
-				headers: formData.getHeaders(),
-			})
-
-			const result = response.data
-
-			// Проверяем формат ответа imgbox.vu
-			// API может возвращать URL в разных форматах, нужно проверить структуру ответа
-			if (result.url) {
-				return result.url
-			} else if (result.data?.url) {
-				return result.data.url
-			} else if (typeof result === 'string' && result.startsWith('http')) {
-				return result
-			} else {
-				// Если формат ответа неизвестен, возвращаем весь ответ как строку для отладки
-				throw new Error(`Неожиданный формат ответа от imgbox.vu: ${JSON.stringify(result)}`)
-			}
-		} catch (error: any) {
-			const errorMessage = error instanceof Error ? error.message : String(error)
-			throw new Error(`Ошибка загрузки изображения на imgbox.vu: ${errorMessage}`)
-		}
-	}
-}

package/src/sessions/Session.ts

@@ -1,21 +0,0 @@
-import { TelegramClient } from 'telegram'
-import { EvogramGramJS } from '../EvogramGramJS'
-import { SessionAuth } from './SessionAuth'
-import { SessionLogger } from './SessionLogger'
-
-export class Session {
-	/** Объект авторизации для сессии */
-	public auth: SessionAuth
-
-	constructor(public readonly sessionId: string, public readonly client: TelegramClient, public readonly logger: SessionLogger | undefined, auth: SessionAuth) {
-		this.auth = auth
-	}
-
-	public async db() {
-		return (await EvogramGramJS.databaseService.getSession(this.sessionId)) ?? null
-	}
-
-	public async user() {
-		return await this.client.getMe()
-	}
-}

package/src/sessions/SessionAuth.ts

@@ -1,173 +0,0 @@
-import { EventEmitter } from 'events'
-import { TelegramClient } from 'telegram'
-import { EvogramGramJS } from '../EvogramGramJS'
-import { ImageUploadService } from '../services/ImageUploadService'
-import { AuthState } from '../types/auth.types'
-import { Deferred } from '../utils/Deferrer'
-import { SessionLogger } from './SessionLogger'
-
-/**
- * События авторизации для сессии
- */
-export enum SessionAuthEvent {
-	/** Начало авторизации */
-	AUTH_STARTED = 'auth:started',
-	/** Код отправлен */
-	CODE_SENT = 'auth:code_sent',
-	/** Код получен */
-	CODE_RECEIVED = 'auth:code_received',
-	/** Требуется пароль */
-	PASSWORD_REQUIRED = 'auth:password_required',
-	/** Авторизация успешна */
-	AUTH_SUCCESS = 'auth:success',
-	/** Ошибка авторизации */
-	AUTH_ERROR = 'auth:error',
-	/** Авторизация отменена */
-	AUTH_CANCELLED = 'auth:cancelled',
-}
-
-/**
- * Класс авторизации для конкретной сессии
- * Предоставляет методы авторизации, привязанные к сессии
- */
-export class SessionAuth extends EventEmitter {
-	public state: {
-		code: Deferred<string>
-		password: Deferred<string>
-		isRequiredPassword: boolean
-		stage: AuthState
-		connect: Deferred<boolean>
-	} = null as any
-
-	constructor(private readonly sessionId: string, private readonly client: TelegramClient, private readonly logger?: SessionLogger) {
-		super()
-	}
-
-	async start(phoneNumber: string) {
-		if (this.state) throw new Error(`Авторизация для сессии "${this.sessionId}" уже начата`)
-
-		this.state = {
-			code: new Deferred<string>(),
-			password: new Deferred<string>(),
-			isRequiredPassword: false,
-			stage: AuthState.INITIAL,
-			connect: new Deferred<boolean>(),
-		}
-
-		try {
-			await new Promise(async (res, rej) => {
-				await this.client
-					.start({
-						phoneNumber,
-						phoneCode: async () => {
-							res(true)
-							this.state.stage = AuthState.WAITING_CODE
-
-							const code = await this.state.code.promise
-							this.state.code = new Deferred<string>()
-
-							return code
-						},
-						password: async () => {
-							this.state.isRequiredPassword = true
-							this.state.stage = AuthState.WAITING_PASSWORD
-
-							const password = await this.state.password.promise
-							this.state.password = new Deferred<string>()
-
-							return password
-						},
-						onError: (error) => {
-							this.state.stage = AuthState.ERROR
-
-							this.emit(SessionAuthEvent.AUTH_ERROR, {
-								sessionId: this.sessionId,
-								error: error instanceof Error ? error.message : String(error),
-							})
-						},
-					})
-					.catch(rej)
-
-				try {
-					const me = await this.client.getMe()
-					this.state.connect.resolve(true)
-
-					let avatarBuffer = await this.client.downloadProfilePhoto('me'),
-						avatarUrl
-					if (avatarBuffer) avatarUrl = await ImageUploadService.uploadToImgbox(Buffer.isBuffer(avatarBuffer) ? avatarBuffer : Buffer.from(avatarBuffer))
-
-					await EvogramGramJS.databaseService.saveSession({
-						sessionId: this.sessionId,
-						apiId: this.client.apiId,
-						apiHash: this.client.apiHash,
-						userId: Number(me.id),
-						username: me.username,
-						firstName: me.firstName,
-						lastName: me.lastName,
-						phoneNumber: me.phone,
-						sessionString: this.client.session.save()!,
-						avatarUrl,
-					})
-				} catch {}
-			})
-
-			return {
-				success: true,
-			}
-		} catch (error) {
-			this.emit(SessionAuthEvent.AUTH_ERROR, {
-				sessionId: this.sessionId,
-				error: error instanceof Error ? error.message : String(error),
-			})
-
-			return {
-				success: false,
-				error,
-			}
-		}
-	}
-
-	async setCode(code: string) {
-		if (!this.state) throw new Error(`Авторизация для сессии "${this.sessionId}" не начата`)
-		const errorPromise = new Promise<Error>((resolve, reject) => {
-			this.once(SessionAuthEvent.AUTH_ERROR, (data) => data.sessionId === this.sessionId && resolve(data.error))
-			setTimeout(resolve, 1_000)
-		})
-
-		this.state.code.resolve(code)
-		const error = await errorPromise
-
-		return {
-			success: error ? false : true,
-			error: error || undefined,
-		}
-	}
-
-	async setPassword(password: string) {
-		if (!this.state) throw new Error(`Авторизация для сессии "${this.sessionId}" не начата`)
-
-		const errorPromise = new Promise<Error>((resolve, reject) => {
-			this.once(SessionAuthEvent.AUTH_ERROR, (data) => data.sessionId === this.sessionId && resolve(data.error))
-			setTimeout(resolve, 1_000)
-		})
-
-		this.state.password.resolve(password)
-		const error = await errorPromise
-
-		return {
-			success: error ? false : true,
-			error: error || undefined,
-		}
-	}
-
-	/**
-	 * Проверяет, требуется ли пароль для авторизации
-	 *
-	 * @returns true, если требуется пароль
-	 */
-	async isRequiredPassword(): Promise<boolean> {
-		if (this.state?.isRequiredPassword) return true
-		await new Promise((resolve) => setTimeout(resolve, 1000))
-		return this.state?.isRequiredPassword ?? false
-	}
-}

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
-	}
-}