index.js

import build from 'pino-abstract-transport';

const API_URL = 'https://api.telegram.org';

export async function sendMsgToTg(
  chatId,
  botToken,
  message,
  extra = {},
  apiUrl = API_URL,
) {
  const method = 'sendMessage';
  const baseUrl = apiUrl.replace(/\/+$/, '');
  const url = `${baseUrl}/bot${botToken}/${method}`;
  const body = JSON.stringify({
    chat_id: chatId,
    text: message,
    ...extra,
  });

  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body,
  });

  if (response.ok) {
    const data = await response.json();
    const { ok, result, error_code, description } = data;

    if (ok) return result;

    throw new Error(`${error_code}: ${description}`);
  }

  const { status, statusText } = response;
  throw new Error(`${status}: ${statusText}`);
}

const verboseSerializer = {
  html: (string) => `<pre><code class="language-json">${string}</code></pre>`,
  markdown: (string) => `\`\`\`json\n${string}\n\`\`\``,
  markdownv2: (string) => `\`\`\`json\n${string}\n\`\`\``,
};

const prepareMessage = ({ pinoData, verbose, parseMode, messageKey }) => {
  if (!verbose) return pinoData[messageKey];

  const msg = JSON.stringify(pinoData, null, 2);

  if (!parseMode) return msg;

  const parseModeLC = parseMode.toLowerCase();
  const serializer = verboseSerializer[parseModeLC];
  return serializer(msg);
};

/**
 *
 * @param {object} params - parameters for creating a transport
 * @param {number} params.chatId - chat ID
 * @param {string} params.botToken - bot token
 * @param {boolean} [params.verbose] - send debugging information
 * @param {string} [params.messageKey] - key for message. Default is 'msg'
 * @param {string} [params.apiUrl] - Telegram Bot API URL. Default is 'https://api.telegram.org'
 * @param {object} [params.extra] - additional parameters for sending a message https://core.telegram.org/bots/api#sendmessage
 * @returns {Promise}
 */
export default function ({
  chatId,
  botToken,
  verbose = false,
  messageKey = 'msg',
  apiUrl = API_URL,
  extra = {},
}) {
  const pendingPromises = new Set();

  return build(
    async (source) => {
      for await (const pinoData of source) {
        const { parse_mode } = extra;
        const message = prepareMessage({
          pinoData,
          verbose,
          parseMode: parse_mode,
          messageKey,
        });

        const promise = sendMsgToTg(chatId, botToken, message, extra, apiUrl)
          .catch((reason) => console.error(reason))
          .finally(() => {
            pendingPromises.delete(promise);
          });
        pendingPromises.add(promise);
      }
    },
    {
      async close(err, cb) {
        await Promise.allSettled([...pendingPromises]);
        cb(err, 'close');
      },
    },
  );
}