feat: Implement Markdown to HTML conversion for Telegram messages and adjust message chunking to a safe length.

Author: tuvshinjargal

app/Services/Telegram/TelegramMessageService.php

@@ -13,6 +13,8 @@ final class TelegramMessageService
 {
     public const int MAX_MESSAGE_LENGTH = 4096;
 
+    private const int SAFE_MESSAGE_LENGTH = 3800;
+
     private const int CHUNK_DELAY_MS = 1000;
 
     private const string QUEUE_NAME = 'telegram';
@@ -28,6 +30,11 @@ public static function getMaxMessageLength(): int
         return self::MAX_MESSAGE_LENGTH;
     }
 
+    public static function getSafeMessageLength(): int
+    {
+        return self::SAFE_MESSAGE_LENGTH;
+    }
+
     public function sendLongMessage(TelegraphChat $chat, string $message, bool $markdown = true): void
     {
         $chunks = $this->splitMessage($message);
@@ -48,7 +55,7 @@ public function splitMessage(string $message): array
     {
         $message = mb_trim($message);
 
-        if (mb_strlen($message) <= self::MAX_MESSAGE_LENGTH) {
+        if (mb_strlen($message) <= self::SAFE_MESSAGE_LENGTH) {
             return [$message];
         }
 
@@ -69,7 +76,7 @@ private function chunkMessage(string $message): array
         $remaining = $message;
 
         while (mb_strlen($remaining) > 0) {
-            if (mb_strlen($remaining) <= self::MAX_MESSAGE_LENGTH) {
+            if (mb_strlen($remaining) <= self::SAFE_MESSAGE_LENGTH) {
                 $chunks[] = mb_trim($remaining);
                 break;
             }
@@ -84,7 +91,7 @@ private function chunkMessage(string $message): array
 
     private function extractChunk(string $text): string
     {
-        $maxLength = self::MAX_MESSAGE_LENGTH;
+        $maxLength = self::SAFE_MESSAGE_LENGTH;
         $searchText = mb_substr($text, 0, $maxLength);
         $threshold = (int) ($maxLength * self::MIN_SPLIT_THRESHOLD);
 
@@ -137,6 +144,43 @@ private function findSentenceEndSplit(string $text, int $threshold): ?string
 
     private function dispatchMessage(TelegraphChat $chat, string $chunk, bool $markdown): void
     {
+        if ($markdown) {
+            $html = $this->convertMarkdownToHtml($chunk);
+            $chat->html($html)->send();
+
+            return;
+        }
+
         $chat->message($chunk)->send();
     }
+
+    private function convertMarkdownToHtml(string $markdown): string
+    {
+        $converter = new GithubFlavoredMarkdownConverter([
+            'html_input' => 'strip',
+            'allow_unsafe_links' => false,
+        ]);
+
+        $html = $converter->convert($markdown)->getContent();
+
+        // Handle lists - convert <li> to bullets
+        $html = str_replace('<li>', '• ', $html);
+        $html = str_replace('</li>', "\n", $html);
+        $html = str_replace(['<ul>', '<ol>', '</ul>', '</ol>'], ["\n", "\n", "\n", "\n"], $html);
+
+        // Convert <p> tags to double newlines
+        $html = str_replace(
+            ['<p>', '</p>'],
+            ['', "\n\n"],
+            $html
+        );
+
+        // Convert <br> to newline
+        $html = str_replace(['<br>', '<br />'], "\n", $html);
+
+        // Strip unsupported tags
+        // Telegram supports: <b>, <strong>, <i>, <em>, <u>, <ins>, <s>, <strike>, <del>,
+        // <span class="tg-spoiler">, <a>, <code>, <pre>, <blockquote>
+        return trim(strip_tags($html, '<b><strong><i><em><u><ins><s><strike><del><a><code><pre><blockquote>'));
+    }
 }

tests/Unit/Services/Telegram/TelegramHtmlConversionTest.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Services\Telegram\TelegramMessageService;
+use DefStudio\Telegraph\Facades\Telegraph;
+use DefStudio\Telegraph\Models\TelegraphBot;
+use DefStudio\Telegraph\Models\TelegraphChat;
+
+beforeEach(function (): void {
+    Telegraph::fake();
+});
+
+test('converts basic markdown to telegram compatible html', function (): void {
+    $service = new TelegramMessageService();
+    // Use reflection to access private method
+    $reflection = new ReflectionClass(TelegramMessageService::class);
+    $method = $reflection->getMethod('convertMarkdownToHtml');
+
+    $markdown = "**Bold** and *Italic* and `code`";
+    $html = $method->invoke($service, $markdown);
+
+    // CommonMark uses <strong> for bold and <em> for italic
+    // Our converter strips <p>
+    expect($html)->toContain('<strong>Bold</strong>')
+        ->toContain('<em>Italic</em>')
+        ->toContain('<code>code</code>');
+});
+
+test('converts lists to telegram compatible format', function (): void {
+    $service = new TelegramMessageService();
+    $reflection = new ReflectionClass(TelegramMessageService::class);
+    $method = $reflection->getMethod('convertMarkdownToHtml');
+
+    $markdown = "- Item 1\n- Item 2";
+    $html = $method->invoke($service, $markdown);
+
+    expect($html)->toContain('• Item 1')
+        ->toContain('• Item 2');
+});
+
+test('safe message length is respected', function (): void {
+    $reflection = new ReflectionClass(TelegramMessageService::class);
+    $constant = $reflection->getReflectionConstant('SAFE_MESSAGE_LENGTH');
+    $safeLength = $constant->getValue();
+
+    expect($safeLength)->toBe(3800);
+    expect($safeLength)->toBeLessThan(TelegramMessageService::MAX_MESSAGE_LENGTH);
+});
+
+test('sends html message', function (): void {
+    Telegraph::fake([
+        DefStudio\Telegraph\Telegraph::ENDPOINT_MESSAGE => ['ok' => true, 'result' => []],
+    ]);
+
+    $bot = TelegraphBot::factory()->create();
+    $chat = TelegraphChat::factory()->for($bot, 'bot')->create();
+    $service = new TelegramMessageService();
+
+    $service->sendLongMessage($chat, '**Bold**', true);
+
+    Telegraph::assertSentData(DefStudio\Telegraph\Telegraph::ENDPOINT_MESSAGE, [
+        'text' => '<strong>Bold</strong>',
+        'parse_mode' => 'html',
+    ]);
+});

tests/Unit/Services/Telegram/TelegramMessageServiceTest.php

@@ -23,12 +23,12 @@
 
     it('returns single chunk for message at max length', function (): void {
         $service = new TelegramMessageService();
-        $message = str_repeat('a', TelegramMessageService::getMaxMessageLength());
+        $message = str_repeat('a', TelegramMessageService::getSafeMessageLength());
 
         $chunks = $service->splitMessage($message);
 
         expect($chunks)->toHaveCount(1)
-            ->and(mb_strlen($chunks[0]))->toBe(TelegramMessageService::getMaxMessageLength());
+            ->and(mb_strlen($chunks[0]))->toBe(TelegramMessageService::getSafeMessageLength());
     });
 
     it('splits at paragraph boundary when available', function (): void {
@@ -63,15 +63,16 @@
         $service = new TelegramMessageService();
 
         // Create a message that's just over max length without line breaks
-        $sentence1 = str_repeat('A ', 2000); // 4000 chars
+        // Safe length is 3800. We need sentence1 to be < 3800.
+        $sentence1 = str_repeat('A ', 1800); // 3600 chars
         $sentence2 = str_repeat('B ', 500); // 1000 chars
         $message = $sentence1.'. '.$sentence2;
 
         $chunks = $service->splitMessage($message);
 
         expect($chunks)->toHaveCount(2)
             ->and($chunks[0])->toEndWith('.')
-            ->and(mb_strlen($chunks[0]))->toBeLessThanOrEqual(TelegramMessageService::getMaxMessageLength());
+            ->and(mb_strlen($chunks[0]))->toBeLessThanOrEqual(TelegramMessageService::getSafeMessageLength());
     });
 
     it('splits at word boundary as fallback', function (): void {
@@ -84,7 +85,7 @@
 
         expect($chunks)->toHaveCount(2);
         foreach ($chunks as $chunk) {
-            expect(mb_strlen($chunk))->toBeLessThanOrEqual(TelegramMessageService::getMaxMessageLength());
+            expect(mb_strlen($chunk))->toBeLessThanOrEqual(TelegramMessageService::getSafeMessageLength());
         }
     });
 
@@ -97,8 +98,8 @@
         $chunks = $service->splitMessage($message);
 
         expect($chunks)->toHaveCount(2)
-            ->and(mb_strlen($chunks[0]))->toBe(TelegramMessageService::getMaxMessageLength())
-            ->and(mb_strlen($chunks[1]))->toBe(904); // 5000 - 4096
+            ->and(mb_strlen($chunks[0]))->toBe(TelegramMessageService::getSafeMessageLength())
+            ->and(mb_strlen($chunks[1]))->toBe(5000 - TelegramMessageService::getSafeMessageLength());
     });
 
     it('handles empty message', function (): void {
@@ -133,7 +134,7 @@
 
         // Each chunk should be under limit
         foreach ($chunks as $chunk) {
-            expect(mb_strlen($chunk))->toBeLessThanOrEqual(TelegramMessageService::getMaxMessageLength());
+            expect(mb_strlen($chunk))->toBeLessThanOrEqual(TelegramMessageService::getSafeMessageLength());
         }
 
         // All content should be preserved
@@ -169,7 +170,8 @@
         $service->sendLongMessage($chat, '**Bold text**');
 
         Telegraph::assertSentData(DefStudio\Telegraph\Telegraph::ENDPOINT_MESSAGE, [
-            'text' => "<p><strong>Bold text</strong></p>\n",
+            'text' => '<strong>Bold text</strong>',
+            'parse_mode' => 'html',
         ]);
     });