Telegram Bot on Cloudflare Worker

sponti_bot.js

export default {
 
  async fetch(request, env) {
    
    const getRecords = async (offset) => {
      const url = `https://api.airtable.com/v0/${env.AIRTABLE_BASE}/${env.AIRTABLE_ID}?api_key=${env.AIRTABLE_KEY}` + (offset ? `&offset=${offset}` : '')
      const response = await fetch(url)
      const records = await response.json()
      return records
    }

    const fetchAllRecords = async () => {
      let allRecords = []
      let data
      do {
          data = await getRecords(data?.offset);
          allRecords = allRecords.concat(data?.records);
      } while (data.offset)
      return allRecords
    }
    const records = await fetchAllRecords()
    // console.log('records', records)
    const categories = [...records.reduce((categorySet, record) => {
      if (record && record.fields && record.fields.Category && record.fields.Category.length) {
        record.fields.Category.forEach(category => categorySet.add(category))
      }
      return categorySet
    }, new Set())]
    // console.log('categories', categories)
    
    let spontiData
    
    const getRandomRecord = (category) => {
      const filteredRecords = category ? records.filter(record => record && record.fields && record.fields.Category && record.fields.Category.length && record.fields.Category.includes(category)) : records
      console.log('filteredRecords', filteredRecords)

      const randomRecord = filteredRecords[Math.floor(Math.random() * filteredRecords.length)]
      spontiData = randomRecord
      return randomRecord
    }
    if (request.method === "POST") {
      const payload = await request.json() 
      
      let text = ''
      let category = ''
      let reply_markup = {}
      
      if ('message' in payload) {
        switch (payload.message.text) {
          case '/help':
            text = `Dieser Bot antwortet mit Sponti-Sprüchen. Probiere den /random Befehl oder frage nach einer Kategorie \n\nVerfügbare Kategorien: ${categories.join(', ')}`
            break
          case '/category':
          case '/category@sponti_bot':
            function getRandom(arr, n) {
              var result = new Array(n),
                  len = arr.length,
                  taken = new Array(len);
              if (n > len)
                  throw new RangeError("getRandom: more elements taken than available");
              while (n--) {
                  var x = Math.floor(Math.random() * len);
                  result[n] = arr[x in taken ? taken[x] : x];
                  taken[x] = --len in taken ? taken[len] : len;
              }
              return result;
            }
            text = 'Wähle eine Kategorie'
            const randomCategorySelection = getRandom(categories, 10)
            const pairedCategories = randomCategorySelection.reduce(function(result, value, index, array) {
              if (index % 2 === 0)
                result.push(array.slice(index, index + 2));
              return result;
            }, []);
            reply_markup = JSON.stringify({
              inline_keyboard: pairedCategories.map(([categoryA, categoryB]) => [{ text: categoryA, callback_data: categoryA }, { text: categoryB, callback_data: categoryB }])
            })
            break
          case '/random':
          default:
            if (payload.message.text && payload.message.text.startsWith('/category')) {
              category = payload.message.text.split(' ')[1]
            }
            const randomRecord = getRandomRecord(category)
            text = randomRecord.fields.Spruch || 'Kein Spruch konnte gefunden werden'
        }
        
        const randomRecord = getRandomRecord(category)
        const chatId = payload.message.chat.id
        const url = `https://api.telegram.org/bot${env.API_KEY}/sendMessage`
        const response = await fetch(url, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            "chat_id": chatId,
            text,
            reply_markup
          })
        })
        const data = await response.json()
        console.log(data)
      }

      if ('callback_query' in payload) {
        const randomRecord = getRandomRecord(payload.callback_query.data)
        text = randomRecord.fields.Spruch || 'Kein Spruch konnte gefunden werden'
        const callback_query_id = payload.callback_query.id
        const callbackUrl = `https://api.telegram.org/bot${env.API_KEY}/answerCallbackQuery?callback_query_id=${callback_query_id}`
        await fetch(callbackUrl)
        const deleteUrl = `https://api.telegram.org/bot${env.API_KEY}/deleteMessage?chat_id=${payload.callback_query.message.chat.id}&message_id=${payload.callback_query.message.message_id}`
        await fetch(deleteUrl)
        const url = `https://api.telegram.org/bot${env.API_KEY}/sendMessage?chat_id=${payload.callback_query.message.chat.id}&text=${text}`
        await fetch(url)
      }
    }

    if (!spontiData) getRandomRecord()
    return new Response(spontiData?.fields?.Spruch)
  }
}