sneakoscope 7.3.0 → 7.6.0

package/dist/core/telegram/bot-api.js

@@ -3,12 +3,14 @@ export class TelegramBotApiError extends Error {
     method;
     errorCode;
     retryAfterSeconds;
-    constructor(method, errorCode, message, retryAfterSeconds = null) {
+    delivery;
+    constructor(method, errorCode, message, retryAfterSeconds = null, delivery) {
         super(redactString(message));
         this.method = method;
         this.errorCode = errorCode;
         this.retryAfterSeconds = retryAfterSeconds;
         this.name = 'TelegramBotApiError';
+        this.delivery = delivery ?? deliveryForFailure(method, errorCode);
     }
 }
 export class TelegramBotApiClient {
@@ -54,46 +56,119 @@ export class TelegramBotApiClient {
             return { body: form };
         });
     }
-    async perform(method, init) {
+    async perform(method, init, requestTimeoutMs = this.timeoutMs, externalSignal) {
         for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
             const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+            const timer = setTimeout(() => controller.abort(), Math.max(1_000, requestTimeoutMs));
+            const abortFromExternalSignal = () => controller.abort();
+            if (externalSignal?.aborted)
+                controller.abort();
+            else
+                externalSignal?.addEventListener('abort', abortFromExternalSignal, { once: true });
             try {
                 const response = await this.request(`${this.apiOrigin}/bot${this.token}/${method}`, {
                     method: 'POST',
                     ...init(),
                     signal: controller.signal
                 });
-                const body = await response.json();
+                const body = await readTelegramResponse(response, method);
                 if (response.ok && body.ok)
                     return body.result;
                 const retryAfter = body.parameters?.retry_after ?? null;
-                if ((response.status === 429 || body.error_code === 429) && retryAfter && attempt < this.maxRetries) {
-                    await this.sleep(Math.min(60_000, Math.max(1_000, retryAfter * 1_000)));
+                if ((response.status === 429 || body.error_code === 429) && attempt < this.maxRetries) {
+                    await this.sleep(retryAfter === null ? retryDelayMs(attempt) : Math.min(60_000, Math.max(1_000, retryAfter * 1_000)));
+                    continue;
+                }
+                if (isRetrySafeMethod(method) && response.status >= 500 && attempt < this.maxRetries) {
+                    await this.sleep(retryDelayMs(attempt));
                     continue;
                 }
                 throw new TelegramBotApiError(method, body.error_code ?? response.status, safeTelegramError(body.description ?? 'Telegram API request failed', this.token), retryAfter);
             }
             catch (error) {
-                if (error instanceof TelegramBotApiError)
+                if (externalSignal?.aborted) {
+                    throw new TelegramBotApiError(method, 0, 'telegram_api_aborted');
+                }
+                if (error instanceof TelegramBotApiError) {
+                    if (isRetrySafeMethod(method) && error.errorCode >= 500 && attempt < this.maxRetries) {
+                        await this.sleep(retryDelayMs(attempt));
+                        continue;
+                    }
                     throw error;
+                }
                 const message = error instanceof Error && error.name === 'AbortError' ? 'telegram_api_timeout' : 'telegram_api_transport_failed';
+                if (isRetrySafeMethod(method) && attempt < this.maxRetries) {
+                    await this.sleep(retryDelayMs(attempt));
+                    continue;
+                }
                 throw new TelegramBotApiError(method, 0, message);
             }
             finally {
                 clearTimeout(timer);
+                externalSignal?.removeEventListener('abort', abortFromExternalSignal);
             }
         }
         throw new TelegramBotApiError(method, 0, 'telegram_api_retry_exhausted');
     }
-    async getUpdates(input = {}) {
-        return this.call('getUpdates', {
+    async getUpdates(input = {}, options = {}) {
+        const payload = {
             ...(input.offset === undefined ? {} : { offset: input.offset }),
             timeout: Math.max(0, Math.min(50, input.timeout ?? 25)),
             allowed_updates: input.allowed_updates ?? ['message', 'callback_query']
-        });
+        };
+        return this.perform('getUpdates', () => ({
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(payload)
+        }), options.requestTimeoutMs ?? this.timeoutMs, options.signal);
     }
 }
+export async function probeTelegramBotReadiness(api) {
+    const bot = await api.call('getMe', {});
+    const id = bot?.id === undefined ? '' : String(bot.id);
+    if (!/^[1-9]\d*$/.test(id) || bot?.is_bot !== true) {
+        throw new Error('telegram_bot_identity_invalid');
+    }
+    const webhook = await api.call('getWebhookInfo', {});
+    if (typeof webhook?.url !== 'string') {
+        throw new Error('telegram_webhook_info_invalid');
+    }
+    return {
+        bot: {
+            id,
+            username: typeof bot.username === 'string' && bot.username.trim() ? bot.username.trim() : null
+        },
+        webhook_configured: typeof webhook?.url === 'string' && webhook.url.trim().length > 0,
+        pending_update_count: Number.isInteger(webhook?.pending_update_count) && Number(webhook.pending_update_count) >= 0
+            ? Number(webhook.pending_update_count)
+            : 0
+    };
+}
+async function readTelegramResponse(response, method) {
+    try {
+        const body = await response.json();
+        if (!body
+            || typeof body !== 'object'
+            || typeof body.ok !== 'boolean'
+            || (body.ok && !('result' in body))) {
+            throw new Error('invalid_shape');
+        }
+        return body;
+    }
+    catch {
+        throw new TelegramBotApiError(method, response.status, 'telegram_api_invalid_response');
+    }
+}
+function isRetrySafeMethod(method) {
+    return /^get[A-Z]/.test(method);
+}
+function deliveryForFailure(method, errorCode) {
+    if (isRetrySafeMethod(method))
+        return 'not_dispatched';
+    return errorCode >= 400 && errorCode < 500 ? 'not_dispatched' : 'unknown';
+}
+function retryDelayMs(attempt) {
+    return Math.min(5_000, 500 * (2 ** attempt));
+}
 function safeTelegramError(message, token) {
     return redactString(message).split(token).join('[redacted]');
 }