@green-api/greenapi-integration 0.7.0 → 0.7.1

package/README.ru.md

@@ -1,4 +1,4 @@
-[# Универсальная интеграционная платформа для GREEN-API
+# Универсальная интеграционная платформа для GREEN-API
 
 ## Поддержка
 
@@ -24,10 +24,9 @@
 
 - [Установка](#установка)
 - [Основные компоненты](#основные-компоненты)
-- [Руководство разработчика](#руководство-разработчика)
+- [Руководство для разработчика](#руководство-для-разработчика)
 - [Рабочий пример](#рабочий-пример)
 - [Реальные примеры](#реальные-примеры)
-- [Лучшие практики](#лучшие-практики)
 
 ## Установка
 
@@ -43,14 +42,14 @@ npm install @green-api/greenapi-integration
 
 ```typescript
 abstract class BaseAdapter<TPlatformWebhook, TPlatformMessage> {
-	public constructor(
-		transformer: MessageTransformer<TPlatformWebhook, TPlatformMessage>,
-		storage: StorageProvider
-	);
+    public constructor(
+            transformer: MessageTransformer<TPlatformWebhook, TPlatformMessage>,
+            storage: StorageProvider
+    );
 
-	public abstract createPlatformClient(params: any): Promise<any>;
+    public abstract createPlatformClient(params: any): Promise<any>;
 
-	public abstract sendToPlatform(message: TPlatformMessage, instance: TInstance): Promise<void>;
+    public abstract sendToPlatform(message: TPlatformMessage, instance: TInstance): Promise<void>;
 }
 ```
 
@@ -100,28 +99,28 @@ await adapter.updateUser(userEmail, updateData);
 ```typescript
 // Конечная точка для вебхуков платформы
 app.post('/webhook/platform', async (req, res) => {
-	try {
-		await adapter.handlePlatformWebhook(req.body, instanceId);
-		res.status(200).send();
-	} catch (error) {
-		console.error('Не удалось обработать вебхук платформы:', error);
-		res.status(500).send();
-	}
+    try {
+        await adapter.handlePlatformWebhook(req.body, instanceId);
+        res.status(200).send();
+    } catch (error) {
+        console.error('Не удалось обработать вебхук платформы:', error);
+        res.status(500).send();
+    }
 });
 
 // Конечная точка для вебхуков GREEN-API
 app.post('/webhook/green-api', async (req, res) => {
-	try {
-		// Обработка определенных типов вебхуков
-		await adapter.handleGreenApiWebhook(req.body, [
-			'incomingMessageReceived',
-			'outgoingMessageStatus'
-		]);
-		res.status(200).send();
-	} catch (error) {
-		console.error('Не удалось обработать вебхук GREEN-API:', error);
-		res.status(500).send();
-	}
+    try {
+        // Обработка определенных типов вебхуков
+        await adapter.handleGreenApiWebhook(req.body, [
+            'incomingMessageReceived',
+            'outgoingMessageStatus'
+        ]);
+        res.status(200).send();
+    } catch (error) {
+        console.error('Не удалось обработать вебхук GREEN-API:', error);
+        res.status(500).send();
+    }
 });
 ```
 
@@ -131,9 +130,9 @@ app.post('/webhook/green-api', async (req, res) => {
 
 ```typescript
 abstract class MessageTransformer<TPlatformWebhook, TPlatformMessage> {
-	abstract toPlatformMessage(webhook: GreenApiWebhook): TPlatformMessage;
+    abstract toPlatformMessage(webhook: GreenApiWebhook): TPlatformMessage;
 
-	abstract toGreenApiMessage(message: TPlatformWebhook): Message;
+    abstract toGreenApiMessage(message: TPlatformWebhook): Message;
 }
 ```
 
@@ -143,17 +142,17 @@ abstract class MessageTransformer<TPlatformWebhook, TPlatformMessage> {
 
 ```typescript
 abstract class StorageProvider<TUser extends BaseUser = BaseUser, TInstance extends BaseInstance = Instance> {
-	abstract createInstance(instance: BaseInstance, userId: bigint | number): Promise<TInstance>;
+    abstract createInstance(instance: BaseInstance, userId: bigint | number): Promise<TInstance>;
 
-	abstract getInstance(idInstance: number | bigint): Promise<TInstance | null>;
+    abstract getInstance(idInstance: number | bigint): Promise<TInstance | null>;
 
-	abstract removeInstance(instanceId: number | bigint): Promise<TInstance>;
+    abstract removeInstance(instanceId: number | bigint): Promise<TInstance>;
 
-	abstract createUser(data: any): Promise<TUser>;
+    abstract createUser(data: any): Promise<TUser>;
 
-	abstract findUser(identifier: string): Promise<TUser | null>;
+    abstract findUser(identifier: string): Promise<TUser | null>;
 
-	abstract updateUser(identifier: string, data: any): Promise<TUser>;
+    abstract updateUser(identifier: string, data: any): Promise<TUser>;
 }
 ```
 
@@ -163,10 +162,10 @@ abstract class StorageProvider<TUser extends BaseUser = BaseUser, TInstance exte
 
 ```typescript
 abstract class BaseGreenApiAuthGuard<T extends BaseRequest = BaseRequest> {
-	constructor(protected storage: StorageProvider);
+    constructor(protected storage: StorageProvider);
 
-	// Валидация входящих вебхуков
-	async validateRequest(request: T): Promise<boolean>;
+    // Валидация входящих вебхуков
+    async validateRequest(request: T): Promise<boolean>;
 }
 ```
 
@@ -174,24 +173,24 @@ abstract class BaseGreenApiAuthGuard<T extends BaseRequest = BaseRequest> {
 
 ```typescript
 class YourAuthGuard extends BaseGreenApiAuthGuard<YourRequest> {
-	constructor(storage: StorageProvider) {
-		super(storage);
-	}
+    constructor(storage: StorageProvider) {
+        super(storage);
+    }
 }
 
 // Использование с Express
 app.post('/webhook', async (req, res) => {
-	const guard = new YourAuthGuard(storage);
-	try {
-		await guard.validateRequest(req);
-		// Обработка вебхука ...
-	} catch (error) {
-		if (error instanceof AuthenticationError) {
-			res.status(401).json({error: error.message});
-			return;
-		}
-		res.status(500).json({error: 'Internal server error'});
-	}
+    const guard = new YourAuthGuard(storage);
+    try {
+        await guard.validateRequest(req);
+        // Обработка вебхука ...
+    } catch (error) {
+        if (error instanceof AuthenticationError) {
+            res.status(401).json({error: error.message});
+            return;
+        }
+        res.status(500).json({error: 'Internal server error'});
+    }
 });
 ```
 
@@ -212,12 +211,12 @@ logger.fatal("Fatal error", {critical: true});
 
 // Логирование ошибок с контекстом
 try {
-	await someOperation();
+    await someOperation();
 } catch (error) {
-	logger.logErrorResponse(error, "Operation failed", {
-		operationId: "123",
-		additionalInfo: "some context"
-	});
+    logger.logErrorResponse(error, "Operation failed", {
+        operationId: "123",
+        additionalInfo: "some context"
+    });
 }
 ```
 
@@ -243,20 +242,20 @@ try {
 
 ```json
 {
-  "timestamp": "30/01/2025, 04:34:49",
-  "level": "error",
-  "context": "CoreService",
-  "message": "Operation failed",
-  "error": "Failed to process request",
-  "stack": [
-    "Error: Failed to process request",
-    "    at CoreService.process (/app/service.js:123:45)",
-    "    at async Router.handle (/app/router.js:67:89)"
-  ],
-  "additionalContext": {
-    "requestId": "abc-123",
-    "userId": "user_456"
-  }
+    "timestamp": "30/01/2025, 04:34:49",
+    "level": "error",
+    "context": "CoreService",
+    "message": "Operation failed",
+    "error": "Failed to process request",
+    "stack": [
+        "Error: Failed to process request",
+        "    at CoreService.process (/app/service.js:123:45)",
+        "    at async Router.handle (/app/router.js:67:89)"
+    ],
+    "additionalContext": {
+        "requestId": "abc-123",
+        "userId": "user_456"
+    }
 }
 ```
 
@@ -265,12 +264,12 @@ try {
 ```typescript
 // Обработка ошибок Axios
 try {
-	await apiRequest();
+    await apiRequest();
 } catch (error) {
-	logger.logErrorResponse(error, "API Request failed", {
-		endpoint: "/users",
-		method: "POST"
-	});
+    logger.logErrorResponse(error, "API Request failed", {
+        endpoint: "/users",
+        method: "POST"
+    });
 }
 ```
 
@@ -278,18 +277,18 @@ try {
 
 ```json
 {
-  "timestamp": "30/01/2025, 04:34:49",
-  "level": "error",
-  "context": "ApiService",
-  "message": "API Request failed - API Error:",
-  "status": 400,
-  "statusText": "Bad Request",
-  "data": {
-    "error": "Invalid input"
-  },
-  "url": "https://api.example.com/users",
-  "method": "POST",
-  "endpoint": "/users"
+    "timestamp": "30/01/2025, 04:34:49",
+    "level": "error",
+    "context": "ApiService",
+    "message": "API Request failed - API Error:",
+    "status": 400,
+    "statusText": "Bad Request",
+    "data": {
+        "error": "Invalid input"
+    },
+    "url": "https://api.example.com/users",
+    "method": "POST",
+    "endpoint": "/users"
 }
 ```
 
@@ -300,18 +299,18 @@ try {
 ```typescript
 // Пример с NestJS
 const app = await NestFactory.create(AppModule, {
-	logger: GreenApiLogger.getInstance("NestJS")
+    logger: GreenApiLogger.getInstance("NestJS")
 });
 
 // Пример с Express
 app.use((err, req, res, next) => {
-	const logger = GreenApiLogger.getInstance("Express");
-	logger.error("Request failed", {
-		path: req.path,
-		method: req.method,
-		error: err.message
-	});
-	next(err);
+    const logger = GreenApiLogger.getInstance("Express");
+    logger.error("Request failed", {
+        path: req.path,
+        method: req.method,
+        error: err.message
+    });
+    next(err);
 });
 ```
 
@@ -325,7 +324,7 @@ app.use((err, req, res, next) => {
 ```typescript
 // main.ts
 const app = await NestFactory.create(AppModule, {
-	logger: false  // Отключение логера NestJS
+    logger: false  // Отключение логера NestJS
 });
 ```
 
@@ -356,69 +355,17 @@ gaLogger = GreenApiLogger.getInstance(YourClass.name);
 - `getInstance(context: string = "Global"): GreenApiLogger`: Получение или создание экземпляра логгера для указанного
   контекста
 
-#### Лучшие практики
-
-1. **Используйте последовательные имена контекста**
-
-```typescript
-// В вашем компоненте/сервисе
-private readonly
-logger = GreenApiLogger.getInstance(YourService.name);
-```
-
-2. **Включайте релевантный контекст**
-
-```typescript
-logger.info("User action completed", {
-	userId: user.id,
-	action: "profile_update",
-	duration: timeTaken
-});
-```
-
-3. **Правильная обработка ошибок**
-
-```typescript
-try {
-	await complexOperation();
-} catch (error) {
-	logger.logErrorResponse(error, "Complex operation failed", {
-		operationId: id,
-		parameters: params
-	});
-}
-```
-
-4. **Используйте соответствующие уровни логирования**
-
-```typescript
-// Debug для детальной информации
-logger.debug("Processing chunk", {chunkId: 123, size: 1024});
-
-// Info для общей информации о работе
-logger.info("User logged in", {userId: 456});
-
-// Warn для потенциальных проблем
-logger.warn("High memory usage", {memoryUsage: "85%"});
-
-// Error для реальных проблем
-logger.error("Database connection failed", {dbHost: "primary"});
-
-// Fatal для критических проблем
-logger.fatal("System shutdown required", {reason: "data corruption"});
-```
-
 ### 6. GreenApiClient
 
 Прямой интерфейс к методам GREEN-API.
 
 ```typescript
 const client = new GreenApiClient({
-	idInstance: 'your_instance_id',
-	apiTokenInstance: 'your_token'
+    idInstance: 'your_instance_id',
+    apiTokenInstance: 'your_token'
 });
 
-// Примеры специальных операций:
+// Примеры вызовы методов:
 await client.setProfilePicture(fileBlob);
 await client.getAuthorizationCode(phoneNumber);
 await client.getQR();
@@ -480,17 +427,17 @@ graph TB
 ```typescript
 // types/types.ts
 export interface YourPlatformWebhook {
-	id: string;
-	from: string;
-	message: string;
-	timestamp: number;
-	// Добавьте другие поля, специфичные для вашей платформы
+    id: string;
+    from: string;
+    message: string;
+    timestamp: number;
+    // Добавьте другие поля, специфичные для вашей платформы
 }
 
 export interface YourPlatformMessage {
-	recipient: string;
-	content: string;
-	// Добавьте другие поля, специфичные для вашей платформы
+    recipient: string;
+    content: string;
+    // Добавьте другие поля, специфичные для вашей платформы
 }
 ```
 
@@ -504,22 +451,22 @@ import { MessageTransformer, Message, GreenApiWebhook } from '@green-api/greenap
 import { YourPlatformWebhook, YourPlatformMessage } from '../types/types';
 
 export class YourTransformer extends MessageTransformer<YourPlatformWebhook, YourPlatformMessage> {
-	toPlatformMessage(webhook: GreenApiWebhook): YourPlatformMessage {
-		// Преобразование вебхука GREEN-API в формат вашей платформы
-		return {
-			recipient: webhook.senderData.sender,
-			content: webhook.messageData.textMessageData?.textMessage || '',
-		};
-	}
-
-	toGreenApiMessage(message: YourPlatformWebhook): Message {
-		// Преобразование вебхука вашей платформы в формат GREEN-API
-		return {
-			type: 'text',
-			chatId: message.from,
-			message: message.message,
-		};
-	}
+    toPlatformMessage(webhook: GreenApiWebhook): YourPlatformMessage {
+        // Преобразование вебхука GREEN-API в формат вашей платформы
+        return {
+            recipient: webhook.senderData.sender,
+            content: webhook.messageData.textMessageData?.textMessage || '',
+        };
+    }
+
+    toGreenApiMessage(message: YourPlatformWebhook): Message {
+        // Преобразование вебхука вашей платформы в формат GREEN-API
+        return {
+            type: 'text',
+            chatId: message.from,
+            message: message.message,
+        };
+    }
 }
 ```
 
@@ -534,24 +481,24 @@ import { StorageProvider, BaseUser, Instance, Settings } from '@green-api/greena
 import { PrismaClient } from '@prisma/client'; // Or your database client
 
 export class YourStorage extends StorageProvider {
-	private db: PrismaClient;
-
-	constructor() {
-		this.db = new PrismaClient();
-	}
-
-	async createInstance(instance: Instance, userId: bigint) {
-		return this.db.instance.create({
-			data: {
-				idInstance: instance.idInstance,
-				apiTokenInstance: instance.apiTokenInstance,
-				userId,
-				settings: instance.settings || {},
-			},
-		});
-	}
-
-	// Остальные методы
+    private db: PrismaClient;
+
+    constructor() {
+        this.db = new PrismaClient();
+    }
+
+    async createInstance(instance: Instance, userId: bigint) {
+        return this.db.instance.create({
+            data: {
+                idInstance: instance.idInstance,
+                apiTokenInstance: instance.apiTokenInstance,
+                userId,
+                settings: instance.settings || {},
+            },
+        });
+    }
+
+    // Остальные методы
 }
 ```
 
@@ -566,17 +513,17 @@ import { YourPlatformClient } from 'your-platform-sdk';
 import { YourPlatformWebhook, YourPlatformMessage } from '../types/types';
 
 export class YourAdapter extends BaseAdapter<YourPlatformWebhook, YourPlatformMessage> {
-	async createPlatformClient(config: { apiKey: string, apiUrl: string }) {
-		return new YourPlatformClient({
-			baseUrl: config.apiUrl,
-			apiKey: config.apiKey,
-		});
-	}
-
-	async sendToPlatform(message: YourPlatformMessage, instance: Instance) {
-		const client = await this.createPlatformClient(instance.config);
-		await client.sendMessage(message);
-	}
+    async createPlatformClient(config: { apiKey: string, apiUrl: string }) {
+        return new YourPlatformClient({
+            baseUrl: config.apiUrl,
+            apiKey: config.apiKey,
+        });
+    }
+
+    async sendToPlatform(message: YourPlatformMessage, instance: Instance) {
+        const client = await this.createPlatformClient(instance.config);
+        await client.sendMessage(message);
+    }
 }
 ```
 
@@ -597,72 +544,72 @@ const transformer = new YourTransformer();
 const adapter = new YourAdapter(transformer, storage);
 
 class WebhookGuard extends BaseGreenApiAuthGuard {
-	constructor(storage: StorageProvider) {
-		super(storage);
-	}
+    constructor(storage: StorageProvider) {
+        super(storage);
+    }
 }
 
 const guard = new WebhookGuard(storage);
 
 // Эндпоинты для вебхуков
 router.post('/green-api', async (req, res) => {
-	try {
-		// Проверка вебхука
-		await guard.validateRequest(req);
-
-		// Обработка вебхука после проверки. 
-		// В списке вторым параметром укажите типы вебхуков, которые необходимо обработать
-		await adapter.handleGreenApiWebhook(req.body, ['incomingMessageReceived']);
-		res.status(200).json({status: 'ok'});
-	} catch (error) {
-		if (error instanceof AuthenticationError) {
-			res.status(401).json({error: 'Ошибка аутентификации'});
-			return;
-		}
-		console.error('Ошибка обработки вебхука:', error);
-		res.status(500).json({error: 'Внутренняя ошибка сервера'});
-	}
+    try {
+        // Проверка вебхука
+        await guard.validateRequest(req);
+
+        // Обработка вебхука после проверки. 
+        // В списке вторым параметром укажите типы вебхуков, которые необходимо обработать
+        await adapter.handleGreenApiWebhook(req.body, ['incomingMessageReceived']);
+        res.status(200).json({status: 'ok'});
+    } catch (error) {
+        if (error instanceof AuthenticationError) {
+            res.status(401).json({error: 'Ошибка аутентификации'});
+            return;
+        }
+        console.error('Ошибка обработки вебхука:', error);
+        res.status(500).json({error: 'Внутренняя ошибка сервера'});
+    }
 });
 
 router.post('/platform', async (req, res) => {
-	try {
-		const instanceId = req.query.instanceId;
-		await adapter.handlePlatformWebhook(req.body, instanceId);
-		res.status(200).json({status: 'ok'});
-	} catch (error) {
-		console.error('Ошибка обработки вебхука платформы:', error);
-		res.status(500).json({error: 'Внутренняя ошибка сервера'});
-	}
+    try {
+        const instanceId = req.query.instanceId;
+        await adapter.handlePlatformWebhook(req.body, instanceId);
+        res.status(200).json({status: 'ok'});
+    } catch (error) {
+        console.error('Ошибка обработки вебхука платформы:', error);
+        res.status(500).json({error: 'Внутренняя ошибка сервера'});
+    }
 });
 
 router.post('/instance', async (req, res) => {
-	try {
-		const {idInstance, apiTokenInstance, userEmail} = req.body;
-
-		if (!idInstance || !apiTokenInstance || !userEmail) {
-			throw new BadRequestError('Отсутствуют обязательные поля');
-		}
-
-		const instance = await adapter.createInstance({
-			idInstance: Number(idInstance),
-			apiTokenInstance,
-			settings: {
-				webhookUrl: `${process.env.APP_URL}/webhook/green-api`,
-				webhookUrlToken: `token_${Date.now()}`,
-				incomingWebhook: 'yes'
-			}
-		}, userEmail);
-
-		res.status(200).json({
-			status: 'ok',
-			data: instance,
-			message: 'Инстанс успешно создан. Подождите 2 минуты для применения настроек.'
-		});
-
-	} catch (error) {
-		console.error('Ошибка создания инстанса:', error);
-		res.status(500).json({error: 'Не удалось создать инстанс'});
-	}
+    try {
+        const {idInstance, apiTokenInstance, userEmail} = req.body;
+
+        if (!idInstance || !apiTokenInstance || !userEmail) {
+            throw new BadRequestError('Отсутствуют обязательные поля');
+        }
+
+        const instance = await adapter.createInstance({
+            idInstance: Number(idInstance),
+            apiTokenInstance,
+            settings: {
+                webhookUrl: `${process.env.APP_URL}/webhook/green-api`,
+                webhookUrlToken: `token_${Date.now()}`,
+                incomingWebhook: 'yes'
+            }
+        }, userEmail);
+
+        res.status(200).json({
+            status: 'ok',
+            data: instance,
+            message: 'Инстанс успешно создан. Подождите 2 минуты для применения настроек.'
+        });
+
+    } catch (error) {
+        console.error('Ошибка создания инстанса:', error);
+        res.status(500).json({error: 'Не удалось создать инстанс'});
+    }
 });
 
 export default router;
@@ -686,25 +633,25 @@ import { YourStorage } from './core/storage';
 dotenv.config();
 
 async function bootstrap() {
-	// Инициализация компонентов
-	const storage = new YourStorage();
-	const transformer = new YourTransformer();
-	const adapter = new YourAdapter(transformer, storage);
+    // Инициализация компонентов
+    const storage = new YourStorage();
+    const transformer = new YourTransformer();
+    const adapter = new YourAdapter(transformer, storage);
 
-	// Создание Express приложения
-	const app = express();
-	app.use(bodyParser.json());
+    // Создание Express приложения
+    const app = express();
+    app.use(bodyParser.json());
 
-	// Настройка маршрутов для вебхуков
-	app.use('/webhook', webhookRouter);
+    // Настройка маршрутов для вебхуков
+    app.use('/webhook', webhookRouter);
 
-	// Запуск сервера
-	const port = process.env.PORT || 3000;
-	app.listen(port, () => {
-		console.log(`Сервер запущен на порту ${port}`);
-	});
+    // Запуск сервера
+    const port = process.env.PORT || 3000;
+    app.listen(port, () => {
+        console.log(`Сервер запущен на порту ${port}`);
+    });
 
-	console.log('Интеграционная платформа готова!');
+    console.log('Интеграционная платформа готова!');
 }
 
 // Обработка ошибок
@@ -720,10 +667,10 @@ import { AppModule } from './app.module';
 import helmet from 'helmet';
 
 async function bootstrap() {
-	const app = await NestFactory.create(AppModule);
-	app.setGlobalPrefix('api');
-	app.use(helmet());
-	await app.listen(process.env.PORT ?? 3000);
+    const app = await NestFactory.create(AppModule);
+    app.setGlobalPrefix('api');
+    app.use(helmet());
+    await app.listen(process.env.PORT ?? 3000);
 }
 
 bootstrap();
@@ -735,20 +682,20 @@ bootstrap();
 
 ```json
 {
-  "name": "greenapi-integration-yourplatform",
-  "version": "1.0.0",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "@green-api/greenapi-integration": "^0.4.0",
-    "@prisma/client": "^5.0.0",
-    "express": "^4.18.2"
-    // другие зависимости
-  }
+    "name": "greenapi-integration-yourplatform",
+    "version": "1.0.0",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "prepublishOnly": "npm run build"
+    },
+    "dependencies": {
+        "@green-api/greenapi-integration": "^0.4.0",
+        "@prisma/client": "^5.0.0",
+        "express": "^4.18.2"
+        // другие зависимости
+    }
 }
 ```
 
@@ -814,16 +761,16 @@ examples/
 
 ```typescript
 interface SimplePlatformWebhook {
-	messageId: string;
-	from: string;
-	text: string;
-	timestamp: number;
+    messageId: string;
+    from: string;
+    text: string;
+    timestamp: number;
 }
 
 interface SimplePlatformMessage {
-	to: string;
-	content: string;
-	replyTo?: string;
+    to: string;
+    content: string;
+    replyTo?: string;
 }
 ```
 
@@ -831,35 +778,35 @@ interface SimplePlatformMessage {
 
 ```typescript
 import {
-	MessageTransformer,
-	Message,
-	GreenApiWebhook,
-	formatPhoneNumber,
-	IntegrationError
+    MessageTransformer,
+    Message,
+    GreenApiWebhook,
+    formatPhoneNumber,
+    IntegrationError
 } from '@green-api/greenapi-integration';
 
 export class SimpleTransformer extends MessageTransformer<SimplePlatformWebhook, SimplePlatformMessage> {
-	toPlatformMessage(webhook: GreenApiWebhook): SimplePlatformMessage {
-		if (webhook.typeWebhook === "incomingMessageReceived") {
-			if (webhook.messageData.typeMessage !== "extendedTextMessage") {
-				throw new IntegrationError("Поддерживаются только текстовые сообщения", "BAD_REQUEST_ERROR", 400);
-			}
-
-			return {
-				to: webhook.senderData.sender,
-				content: webhook.messageData.extendedTextMessageData?.text || "",
-			};
-		}
-		throw new IntegrationError("Поддерживаются только вебхуки вида incomingMessageReceived", "INTEGRATION_ERROR", 500);
-	}
-
-	toGreenApiMessage(message: SimplePlatformWebhook): Message {
-		return {
-			type: 'text',
-			chatId: formatPhoneNumber(message.from),
-			message: message.text,
-		};
-	}
+    toPlatformMessage(webhook: GreenApiWebhook): SimplePlatformMessage {
+        if (webhook.typeWebhook === "incomingMessageReceived") {
+            if (webhook.messageData.typeMessage !== "extendedTextMessage") {
+                throw new IntegrationError("Поддерживаются только текстовые сообщения", "BAD_REQUEST_ERROR", 400);
+            }
+
+            return {
+                to: webhook.senderData.sender,
+                content: webhook.messageData.extendedTextMessageData?.text || "",
+            };
+        }
+        throw new IntegrationError("Поддерживаются только вебхуки вида incomingMessageReceived", "INTEGRATION_ERROR", 500);
+    }
+
+    toGreenApiMessage(message: SimplePlatformWebhook): Message {
+        return {
+            type: 'text',
+            chatId: formatPhoneNumber(message.from),
+            message: message.text,
+        };
+    }
 }
 ```
 
@@ -869,44 +816,44 @@ export class SimpleTransformer extends MessageTransformer<SimplePlatformWebhook,
 import { StorageProvider, BaseUser, Instance, Settings } from '@green-api/greenapi-integration';
 
 export class SimpleStorage extends StorageProvider {
-	private users: Map<string, BaseUser> = new Map();
-	private instances: Map<number, Instance> = new Map();
-
-	async createInstance(instance: Instance, userId: bigint): Promise<Instance> {
-		this.instances.set(Number(instance.idInstance), {
-			...instance,
-		});
-		return instance;
-	}
-
-	async getInstance(idInstance: number): Promise<Instance | null> {
-		return this.instances.get(idInstance) || null;
-	}
-
-	async removeInstance(instanceId: number): Promise<Instance> {
-		const instance = this.instances.get(instanceId);
-		if (!instance) throw new Error('Инстанс не найден');
-		this.instances.delete(instanceId);
-		return instance;
-	}
-
-	async createUser(data: any): Promise<BaseUser> {
-		const user = {id: Date.now(), ...data};
-		this.users.set(data.email, user);
-		return user;
-	}
-
-	async findUser(identifier: string): Promise<BaseUser | null> {
-		return this.users.get(identifier) || null;
-	}
-
-	async updateUser(identifier: string, data: any): Promise<BaseUser> {
-		const user = await this.findUser(identifier);
-		if (!user) throw new Error('Пользователь не найден');
-		const updated = {...user, ...data};
-		this.users.set(identifier, updated);
-		return updated;
-	}
+    private users: Map<string, BaseUser> = new Map();
+    private instances: Map<number, Instance> = new Map();
+
+    async createInstance(instance: Instance, userId: bigint): Promise<Instance> {
+        this.instances.set(Number(instance.idInstance), {
+            ...instance,
+        });
+        return instance;
+    }
+
+    async getInstance(idInstance: number): Promise<Instance | null> {
+        return this.instances.get(idInstance) || null;
+    }
+
+    async removeInstance(instanceId: number): Promise<Instance> {
+        const instance = this.instances.get(instanceId);
+        if (!instance) throw new Error('Инстанс не найден');
+        this.instances.delete(instanceId);
+        return instance;
+    }
+
+    async createUser(data: any): Promise<BaseUser> {
+        const user = {id: Date.now(), ...data};
+        this.users.set(data.email, user);
+        return user;
+    }
+
+    async findUser(identifier: string): Promise<BaseUser | null> {
+        return this.users.get(identifier) || null;
+    }
+
+    async updateUser(identifier: string, data: any): Promise<BaseUser> {
+        const user = await this.findUser(identifier);
+        if (!user) throw new Error('Пользователь не найден');
+        const updated = {...user, ...data};
+        this.users.set(identifier, updated);
+        return updated;
+    }
 }
 ```
 
@@ -917,38 +864,38 @@ import { BaseAdapter, Instance } from "@green-api/greenapi-integration";
 import axios from 'axios';
 
 export class SimpleAdapter extends BaseAdapter<SimplePlatformWebhook, SimplePlatformMessage> {
-	async createPlatformClient(config: { apiKey: string, apiUrl: string }) {
-		return axios.create({
-			baseURL: config.apiUrl,
-			headers: {
-				'Authorization': `Bearer ${config.apiKey}`,
-				'Content-Type': 'application/json'
-			}
-		});
-	}
-
-	async sendToPlatform(message: SimplePlatformMessage, instance: Instance): Promise<void> {
-		// В реальной реализации мы бы отправляли сообщение на платформу
-		// Для демонстрации просто логируем и симулируем ответ
-		console.log('Платформа получила сообщение:', message);
-
-		// Симулируем обработку и ответ платформы
-		setTimeout(() => {
-			console.log('Обработка платформой завершена, отправляем ответ...');
-			this.simulatePlatformResponse(message, instance.idInstance);
-		}, 1000);
-	}
-
-	private async simulatePlatformResponse(originalMessage: SimplePlatformMessage, idInstance: number | bigint) {
-		const platformWebhook: SimplePlatformWebhook = {
-			messageId: `resp_${Date.now()}`,
-			from: originalMessage.to.replace('@c.us', ''),
-			text: `Спасибо за ваше сообщение: "${originalMessage.content}". Это автоматический ответ.`,
-			timestamp: Date.now()
-		};
-
-		await this.handlePlatformWebhook(platformWebhook, idInstance);
-	}
+    async createPlatformClient(config: { apiKey: string, apiUrl: string }) {
+        return axios.create({
+            baseURL: config.apiUrl,
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+    }
+
+    async sendToPlatform(message: SimplePlatformMessage, instance: Instance): Promise<void> {
+        // В реальной реализации мы бы отправляли сообщение на платформу
+        // Для демонстрации просто логируем и симулируем ответ
+        console.log('Платформа получила сообщение:', message);
+
+        // Симулируем обработку и ответ платформы
+        setTimeout(() => {
+            console.log('Обработка платформой завершена, отправляем ответ...');
+            this.simulatePlatformResponse(message, instance.idInstance);
+        }, 1000);
+    }
+
+    private async simulatePlatformResponse(originalMessage: SimplePlatformMessage, idInstance: number | bigint) {
+        const platformWebhook: SimplePlatformWebhook = {
+            messageId: `resp_${Date.now()}`,
+            from: originalMessage.to.replace('@c.us', ''),
+            text: `Спасибо за ваше сообщение: "${originalMessage.content}". Это автоматический ответ.`,
+            timestamp: Date.now()
+        };
+
+        await this.handlePlatformWebhook(platformWebhook, idInstance);
+    }
 }
 ```
 
@@ -966,92 +913,80 @@ import * as dotenv from "dotenv";
 dotenv.config();
 
 async function main() {
-	// Инициализация компонентов
-	const transformer = new SimpleTransformer();
-	const storage = new SimpleStorage();
-	const adapter = new SimpleAdapter(transformer, storage);
-
-	// Конфигурация обоих инстансов
-	const visitorInstance = {
-		idInstance: Number(process.env.VISITOR_ID_INSTANCE),
-		apiTokenInstance: process.env.VISITOR_API_TOKEN!,
-	};
-
-	const agentInstance = {
-		idInstance: Number(process.env.AGENT_ID_INSTANCE),
-		apiTokenInstance: process.env.AGENT_API_TOKEN!,
-	};
-
-	// Создание клиента GREEN-API для посетителя (для отправки начального сообщения)
-	const visitorClient = new GreenApiClient(visitorInstance);
-
-	// Настройка инстанса агента
-	console.log("Настройка инстанса агента...");
-	const user = await adapter.createUser("agent@example.com", {
-		email: "agent@example.com",
-		name: "Agent",
-	});
-
-	const instance = await adapter.createInstance({
-		idInstance: agentInstance.idInstance, apiTokenInstance: agentInstance.apiTokenInstance, settings: {
-			webhookUrl: process.env.WEBHOOK_URL + "/webhook/green-api",
-			webhookUrlToken: "your-secure-token",
-			incomingWebhook: "yes",
-		},
-	}, user.email);
-
-	console.log("Ожидание 2 минуты для применения настроек...");
-	await new Promise(resolve => setTimeout(resolve, 120000));
-	console.log("Инстанс готов!");
-
-	// Настройка веб-сервера
-	const app = express();
-	app.use(bodyParser.json());
-
-	// Обработка вебхуков от GREEN-API
-	app.post("/webhook/green-api", async (req, res) => {
-		try {
-			console.log("Получен вебхук от GREEN-API:", req.body);
-			await adapter.handleGreenApiWebhook(req.body, ["incomingMessageReceived"]);
-			res.status(200).json({status: "ok"});
-		} catch (error) {
-			console.error("Ошибка обработки вебхука:", error);
-			res.status(500).json({error: "Внутренняя ошибка сервера"});
-		}
-	});
-
-	// Запуск сервера
-	const port = Number(process.env.PORT) || 3000;
-	app.listen(port, () => {
-		console.log(`Сервер вебхуков запущен на порту ${port}`);
-	});
-
-	// Отправка начального сообщения от посетителя
-	console.log("Отправка начального сообщения от посетителя...");
-	await visitorClient.sendMessage({
-		chatId: formatPhoneNumber(process.env.AGENT_PHONE_NUMBER!),
-		message: "Здравствуйте! Это тестовое сообщение от посетителя.",
-		type: "text",
-	});
-
-	console.log("Начальное сообщение отправлено! Проверьте WhatsApp агента для просмотра ответа.");
+    // Инициализация компонентов
+    const transformer = new SimpleTransformer();
+    const storage = new SimpleStorage();
+    const adapter = new SimpleAdapter(transformer, storage);
+
+    // Конфигурация обоих инстансов
+    const visitorInstance = {
+        idInstance: Number(process.env.VISITOR_ID_INSTANCE),
+        apiTokenInstance: process.env.VISITOR_API_TOKEN!,
+    };
+
+    const agentInstance = {
+        idInstance: Number(process.env.AGENT_ID_INSTANCE),
+        apiTokenInstance: process.env.AGENT_API_TOKEN!,
+    };
+
+    // Создание клиента GREEN-API для посетителя (для отправки начального сообщения)
+    const visitorClient = new GreenApiClient(visitorInstance);
+
+    // Настройка инстанса агента
+    console.log("Настройка инстанса агента...");
+    const user = await adapter.createUser("agent@example.com", {
+        email: "agent@example.com",
+        name: "Agent",
+    });
+
+    const instance = await adapter.createInstance({
+        idInstance: agentInstance.idInstance, apiTokenInstance: agentInstance.apiTokenInstance, settings: {
+            webhookUrl: process.env.WEBHOOK_URL + "/webhook/green-api",
+            webhookUrlToken: "your-secure-token",
+            incomingWebhook: "yes",
+        },
+    }, user.email);
+
+    console.log("Ожидание 2 минуты для применения настроек...");
+    await new Promise(resolve => setTimeout(resolve, 120000));
+    console.log("Инстанс готов!");
+
+    // Настройка веб-сервера
+    const app = express();
+    app.use(bodyParser.json());
+
+    // Обработка вебхуков от GREEN-API
+    app.post("/webhook/green-api", async (req, res) => {
+        try {
+            console.log("Получен вебхук от GREEN-API:", req.body);
+            await adapter.handleGreenApiWebhook(req.body, ["incomingMessageReceived"]);
+            res.status(200).json({status: "ok"});
+        } catch (error) {
+            console.error("Ошибка обработки вебхука:", error);
+            res.status(500).json({error: "Внутренняя ошибка сервера"});
+        }
+    });
+
+    // Запуск сервера
+    const port = Number(process.env.PORT) || 3000;
+    app.listen(port, () => {
+        console.log(`Сервер вебхуков запущен на порту ${port}`);
+    });
+
+    // Отправка начального сообщения от посетителя
+    console.log("Отправка начального сообщения от посетителя...");
+    await visitorClient.sendMessage({
+        chatId: formatPhoneNumber(process.env.AGENT_PHONE_NUMBER!),
+        message: "Здравствуйте! Это тестовое сообщение от посетителя.",
+        type: "text",
+    });
+
+    console.log("Начальное сообщение отправлено! Проверьте WhatsApp агента для просмотра ответа.");
 }
-
+ 
 main().catch(console.error);
 ```
 
-### .env
-
-```env
-VISITOR_ID_INSTANCE=your_visitor_instance_id
-VISITOR_API_TOKEN=your_visitor_instance_token
-AGENT_ID_INSTANCE=your_agent_instance_id
-AGENT_API_TOKEN=your_agent_instance_token
-AGENT_PHONE_NUMBER=your_agent_phone_number
-WEBHOOK_URL=your_webhook_url
-PORT=3000
-```
-
 ## Реальные примеры
 
 Для полных примеров реальных интеграций, смотрите:
@@ -1078,10 +1013,10 @@ isValidSettingValue('webhookUrl', 'https://example.com') // Возвращает
 
 // Очистка настроек
 const input = {
-	webhookUrl: 'https://example.com',
-	outgoingWebhook: 'yes',
-	invalidKey: 'value',
-	delaySendMessagesMilliseconds: 'invalid'
+    webhookUrl: 'https://example.com',
+    outgoingWebhook: 'yes',
+    invalidKey: 'value',
+    delaySendMessagesMilliseconds: 'invalid'
 }
 validateAndCleanSettings(input) // Возвращает { webhookUrl: 'https://example.com', outgoingWebhook: 'yes' }
 ```
@@ -1089,4 +1024,3 @@ validateAndCleanSettings(input) // Возвращает { webhookUrl: 'https://e
 ## Лицензия
 
 MIT
-]()