@tgify/tgify 0.1.0

package/src/core/network/client.ts

@@ -0,0 +1,396 @@
+/* eslint @typescript-eslint/restrict-template-expressions: [ "error", { "allowNumber": true, "allowBoolean": true } ] */
+import * as crypto from 'crypto'
+import * as fs from 'fs'
+import { stat, realpath } from 'fs/promises'
+import * as http from 'http'
+import * as https from 'https'
+import * as path from 'path'
+import fetch, { RequestInit } from 'node-fetch'
+import { hasProp, hasPropType } from '../helpers/check'
+import { InputFile, Opts, Telegram } from '../types/typegram'
+import { AbortSignal } from 'abort-controller'
+import { compactOptions } from '../helpers/compact'
+import MultipartStream from './multipart-stream'
+import TelegramError from './error'
+import { URL } from 'url'
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const debug = require('debug')('telegraf:client')
+const { isStream } = MultipartStream
+
+const WEBHOOK_REPLY_METHOD_ALLOWLIST = new Set<keyof Telegram>([
+  'answerCallbackQuery',
+  'answerInlineQuery',
+  'deleteMessage',
+  'leaveChat',
+  'sendChatAction',
+])
+
+namespace ApiClient {
+  export type Agent = http.Agent | ((parsedUrl: URL) => http.Agent) | undefined
+  export interface Options {
+    /**
+     * Agent for communicating with the bot API.
+     */
+    agent?: http.Agent
+    /**
+     * Agent for attaching files via URL.
+     * 1. Not all agents support both `http:` and `https:`.
+     * 2. When passing a function, create the agents once, outside of the function.
+     *    Creating new agent every request probably breaks `keepAlive`.
+     */
+    attachmentAgent?: Agent
+    apiRoot: string
+    /**
+     * @default 'bot'
+     * @see https://github.com/tdlight-team/tdlight-telegram-bot-api#user-mode
+     */
+    apiMode: 'bot' | 'user'
+    webhookReply: boolean
+    testEnv: boolean
+  }
+
+  export interface CallApiOptions {
+    signal?: AbortSignal
+  }
+}
+
+const DEFAULT_EXTENSIONS: Record<string, string | undefined> = {
+  audio: 'mp3',
+  photo: 'jpg',
+  sticker: 'webp',
+  video: 'mp4',
+  animation: 'mp4',
+  video_note: 'mp4',
+  voice: 'ogg',
+}
+
+const DEFAULT_OPTIONS: ApiClient.Options = {
+  apiRoot: 'https://api.telegram.org',
+  apiMode: 'bot',
+  webhookReply: true,
+  agent: new https.Agent({
+    keepAlive: true,
+    keepAliveMsecs: 10000,
+  }),
+  attachmentAgent: undefined,
+  testEnv: false,
+}
+
+function includesMedia(payload: Record<string, unknown>) {
+  return Object.entries(payload).some(([key, value]) => {
+    if (key === 'link_preview_options') return false
+
+    if (Array.isArray(value)) {
+      return value.some(
+        ({ media }) =>
+          media && typeof media === 'object' && (media.source || media.url)
+      )
+    }
+    return (
+      value &&
+      typeof value === 'object' &&
+      ((hasProp(value, 'source') && value.source) ||
+        (hasProp(value, 'url') && value.url) ||
+        (hasPropType(value, 'media', 'object') &&
+          ((hasProp(value.media, 'source') && value.media.source) ||
+            (hasProp(value.media, 'url') && value.media.url))))
+    )
+  })
+}
+
+function replacer(_: unknown, value: unknown) {
+  if (value == null) return undefined
+  return value
+}
+
+function buildJSONConfig(payload: unknown): Promise<RequestInit> {
+  return Promise.resolve({
+    method: 'POST',
+    compress: true,
+    headers: { 'content-type': 'application/json', connection: 'keep-alive' },
+    body: JSON.stringify(payload, replacer),
+  })
+}
+
+const FORM_DATA_JSON_FIELDS = [
+  'results',
+  'reply_markup',
+  'mask_position',
+  'shipping_options',
+  'errors',
+] as const
+
+async function buildFormDataConfig(
+  payload: Opts<keyof Telegram>,
+  agent: ApiClient.Agent
+) {
+  for (const field of FORM_DATA_JSON_FIELDS) {
+    if (hasProp(payload, field) && typeof payload[field] !== 'string') {
+      payload[field] = JSON.stringify(payload[field])
+    }
+  }
+  const boundary = crypto.randomBytes(32).toString('hex')
+  const formData = new MultipartStream(boundary)
+  await Promise.all(
+    Object.keys(payload).map((key) =>
+      // @ts-expect-error payload[key] can obviously index payload, but TS doesn't trust us
+      attachFormValue(formData, key, payload[key], agent)
+    )
+  )
+  return {
+    method: 'POST',
+    compress: true,
+    headers: {
+      'content-type': `multipart/form-data; boundary=${boundary}`,
+      connection: 'keep-alive',
+    },
+    body: formData,
+  }
+}
+
+async function attachFormValue(
+  form: MultipartStream,
+  id: string,
+  value: unknown,
+  agent: ApiClient.Agent
+) {
+  if (value == null) {
+    return
+  }
+  if (
+    typeof value === 'string' ||
+    typeof value === 'boolean' ||
+    typeof value === 'number'
+  ) {
+    form.addPart({
+      headers: { 'content-disposition': `form-data; name="${id}"` },
+      body: `${value}`,
+    })
+    return
+  }
+  if (id === 'thumb' || id === 'thumbnail') {
+    const attachmentId = crypto.randomBytes(16).toString('hex')
+    await attachFormMedia(form, value as InputFile, attachmentId, agent)
+    return form.addPart({
+      headers: { 'content-disposition': `form-data; name="${id}"` },
+      body: `attach://${attachmentId}`,
+    })
+  }
+  if (Array.isArray(value)) {
+    const items = await Promise.all(
+      value.map(async (item) => {
+        if (typeof item.media !== 'object') {
+          return await Promise.resolve(item)
+        }
+        const attachmentId = crypto.randomBytes(16).toString('hex')
+        await attachFormMedia(form, item.media, attachmentId, agent)
+        const thumb = item.thumb ?? item.thumbnail
+        if (typeof thumb === 'object') {
+          const thumbAttachmentId = crypto.randomBytes(16).toString('hex')
+          await attachFormMedia(form, thumb, thumbAttachmentId, agent)
+          return {
+            ...item,
+            media: `attach://${attachmentId}`,
+            thumbnail: `attach://${thumbAttachmentId}`,
+          }
+        }
+        return { ...item, media: `attach://${attachmentId}` }
+      })
+    )
+    return form.addPart({
+      headers: { 'content-disposition': `form-data; name="${id}"` },
+      body: JSON.stringify(items),
+    })
+  }
+  if (
+    value &&
+    typeof value === 'object' &&
+    hasProp(value, 'media') &&
+    hasProp(value, 'type') &&
+    typeof value.media !== 'undefined' &&
+    typeof value.type !== 'undefined'
+  ) {
+    const attachmentId = crypto.randomBytes(16).toString('hex')
+    await attachFormMedia(form, value.media as InputFile, attachmentId, agent)
+    return form.addPart({
+      headers: { 'content-disposition': `form-data; name="${id}"` },
+      body: JSON.stringify({
+        ...value,
+        media: `attach://${attachmentId}`,
+      }),
+    })
+  }
+  return await attachFormMedia(form, value as InputFile, id, agent)
+}
+
+async function attachFormMedia(
+  form: MultipartStream,
+  media: InputFile,
+  id: string,
+  agent: ApiClient.Agent
+) {
+  let fileName = media.filename ?? `${id}.${DEFAULT_EXTENSIONS[id] ?? 'dat'}`
+  if ('url' in media && media.url !== undefined) {
+    const timeout = 500_000 // ms
+    const res = await fetch(media.url, { agent, timeout })
+    return form.addPart({
+      headers: {
+        'content-disposition': `form-data; name="${id}"; filename="${fileName}"`,
+      },
+      body: res.body,
+    })
+  }
+  if ('source' in media && media.source) {
+    let mediaSource = media.source
+    if (typeof media.source === 'string') {
+      const source = await realpath(media.source)
+      if ((await stat(source)).isFile()) {
+        fileName = media.filename ?? path.basename(media.source)
+        mediaSource = await fs.createReadStream(media.source)
+      } else {
+        throw new TypeError(`Unable to upload '${media.source}', not a file`)
+      }
+    }
+    if (isStream(mediaSource) || Buffer.isBuffer(mediaSource)) {
+      form.addPart({
+        headers: {
+          'content-disposition': `form-data; name="${id}"; filename="${fileName}"`,
+        },
+        body: mediaSource,
+      })
+    }
+  }
+}
+
+async function answerToWebhook(
+  response: Response,
+  payload: Opts<keyof Telegram>,
+  options: ApiClient.Options
+): Promise<true> {
+  if (!includesMedia(payload)) {
+    if (!response.headersSent) {
+      response.setHeader('content-type', 'application/json')
+    }
+    response.end(JSON.stringify(payload), 'utf-8')
+    return true
+  }
+
+  const { headers, body } = await buildFormDataConfig(
+    payload,
+    options.attachmentAgent
+  )
+  if (!response.headersSent) {
+    for (const [key, value] of Object.entries(headers)) {
+      response.setHeader(key, value)
+    }
+  }
+  await new Promise((resolve) => {
+    response.on('finish', resolve)
+    body.pipe(response)
+  })
+  return true
+}
+
+function redactToken(error: Error): never {
+  error.message = error.message.replace(
+    /\/(bot|user)(\d+):[^/]+\//,
+    '/$1$2:[REDACTED]/'
+  )
+  throw error
+}
+
+type Response = http.ServerResponse
+class ApiClient {
+  readonly options: ApiClient.Options
+
+  constructor(
+    readonly token: string,
+    options?: Partial<ApiClient.Options>,
+    private readonly response?: Response
+  ) {
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...compactOptions(options),
+    }
+    if (this.options.apiRoot.startsWith('http://')) {
+      this.options.agent = undefined
+    }
+  }
+
+  /**
+   * If set to `true`, first _eligible_ call will avoid performing a POST request.
+   * Note that such a call:
+   * 1. cannot report errors or return meaningful values,
+   * 2. resolves before bot API has a chance to process it,
+   * 3. prematurely confirms the update as processed.
+   *
+   * https://core.telegram.org/bots/faq#how-can-i-make-requests-in-response-to-updates
+   * https://github.com/telegraf/telegraf/pull/1250
+   */
+  set webhookReply(enable: boolean) {
+    this.options.webhookReply = enable
+  }
+
+  get webhookReply() {
+    return this.options.webhookReply
+  }
+
+  async callApi<M extends keyof Telegram>(
+    method: M,
+    payload: Opts<M>,
+    { signal }: ApiClient.CallApiOptions = {}
+  ): Promise<ReturnType<Telegram[M]>> {
+    const { token, options, response } = this
+
+    if (
+      options.webhookReply &&
+      response?.writableEnded === false &&
+      WEBHOOK_REPLY_METHOD_ALLOWLIST.has(method)
+    ) {
+      debug('Call via webhook', method, payload)
+      // @ts-expect-error using webhookReply is an optimisation that doesn't respond with normal result
+      // up to the user to deal with this
+      return await answerToWebhook(response, { method, ...payload }, options)
+    }
+
+    if (!token) {
+      throw new TelegramError({
+        error_code: 401,
+        description: 'Bot Token is required',
+      })
+    }
+
+    debug('HTTP call', method, payload)
+
+    const config: RequestInit = includesMedia(payload)
+      ? await buildFormDataConfig(
+          { method, ...payload },
+          options.attachmentAgent
+        )
+      : await buildJSONConfig(payload)
+    const apiUrl = new URL(
+      `./${options.apiMode}${token}${options.testEnv ? '/test' : ''}/${method}`,
+      options.apiRoot
+    )
+    config.agent = options.agent
+    // @ts-expect-error AbortSignal shim is missing some props from Request.AbortSignal
+    config.signal = signal
+    config.timeout = 500_000 // ms
+    const res = await fetch(apiUrl, config).catch(redactToken)
+    if (res.status >= 500) {
+      const errorPayload = {
+        error_code: res.status,
+        description: res.statusText,
+      }
+      throw new TelegramError(errorPayload, { method, payload })
+    }
+    const data = await res.json()
+    if (!data.ok) {
+      debug('API call failed', data)
+      throw new TelegramError(data, { method, payload })
+    }
+    return data.result
+  }
+}
+
+export default ApiClient

package/src/core/network/error.ts

@@ -0,0 +1,29 @@
+import { ResponseParameters } from '../types/typegram'
+
+interface ErrorPayload {
+  error_code: number
+  description: string
+  parameters?: ResponseParameters
+}
+export class TelegramError extends Error {
+  constructor(
+    readonly response: ErrorPayload,
+    readonly on = {}
+  ) {
+    super(`${response.error_code}: ${response.description}`)
+  }
+
+  get code() {
+    return this.response.error_code
+  }
+
+  get description() {
+    return this.response.description
+  }
+
+  get parameters() {
+    return this.response.parameters
+  }
+}
+
+export default TelegramError

package/src/core/network/multipart-stream.ts

@@ -0,0 +1,45 @@
+import * as stream from 'stream'
+import { hasPropType } from '../helpers/check'
+import SandwichStream from 'sandwich-stream'
+const CRNL = '\r\n'
+
+interface Part {
+  headers: { [key: string]: string }
+  body: NodeJS.ReadStream | NodeJS.ReadableStream | Buffer | string
+}
+
+class MultipartStream extends SandwichStream {
+  constructor(boundary: string) {
+    super({
+      head: `--${boundary}${CRNL}`,
+      tail: `${CRNL}--${boundary}--`,
+      separator: `${CRNL}--${boundary}${CRNL}`,
+    })
+  }
+
+  addPart(part: Part) {
+    const partStream = new stream.PassThrough()
+    for (const [key, header] of Object.entries(part.headers)) {
+      partStream.write(`${key}:${header}${CRNL}`)
+    }
+    partStream.write(CRNL)
+    if (MultipartStream.isStream(part.body)) {
+      part.body.pipe(partStream)
+    } else {
+      partStream.end(part.body)
+    }
+    this.add(partStream)
+  }
+
+  static isStream(
+    stream: unknown
+  ): stream is { pipe: MultipartStream['pipe'] } {
+    return (
+      typeof stream === 'object' &&
+      stream !== null &&
+      hasPropType(stream, 'pipe', 'function')
+    )
+  }
+}
+
+export default MultipartStream

package/src/core/network/polling.ts

@@ -0,0 +1,94 @@
+import * as tg from '../types/typegram'
+import * as tt from '../../telegram-types'
+import AbortController from 'abort-controller'
+import ApiClient from './client'
+import d from 'debug'
+import { promisify } from 'util'
+import { TelegramError } from './error'
+const debug = d('telegraf:polling')
+const wait = promisify(setTimeout)
+function always<T>(x: T) {
+  return () => x
+}
+const noop = always(Promise.resolve())
+
+export class Polling {
+  private readonly abortController = new AbortController()
+  private skipOffsetSync = false
+  private offset = 0
+  constructor(
+    private readonly telegram: ApiClient,
+    private readonly allowedUpdates: readonly tt.UpdateType[]
+  ) {}
+
+  private async *[Symbol.asyncIterator]() {
+    debug('Starting long polling')
+    do {
+      try {
+        const updates = await this.telegram.callApi(
+          'getUpdates',
+          {
+            timeout: 50,
+            offset: this.offset,
+            allowed_updates: this.allowedUpdates,
+          },
+          this.abortController
+        )
+        const last = updates[updates.length - 1]
+        if (last !== undefined) {
+          this.offset = last.update_id + 1
+        }
+        yield updates
+      } catch (error) {
+        const err = error as Error & {
+          parameters?: { retry_after: number }
+        }
+
+        if (err.name === 'AbortError') return
+        if (
+          err.name === 'FetchError' ||
+          (err instanceof TelegramError && err.code === 429) ||
+          (err instanceof TelegramError && err.code >= 500)
+        ) {
+          const retryAfter: number = err.parameters?.retry_after ?? 5
+          debug('Failed to fetch updates, retrying after %ds.', retryAfter, err)
+          await wait(retryAfter * 1000)
+          continue
+        }
+        if (
+          err instanceof TelegramError &&
+          // Unauthorized      Conflict
+          (err.code === 401 || err.code === 409)
+        ) {
+          this.skipOffsetSync = true
+          throw err
+        }
+        throw err
+      }
+    } while (!this.abortController.signal.aborted)
+  }
+
+  private async syncUpdateOffset() {
+    if (this.skipOffsetSync) return
+    debug('Syncing update offset...')
+    await this.telegram.callApi('getUpdates', { offset: this.offset, limit: 1 })
+  }
+
+  async loop(handleUpdate: (updates: tg.Update) => Promise<void>) {
+    if (this.abortController.signal.aborted)
+      throw new Error('Polling instances must not be reused!')
+    try {
+      for await (const updates of this)
+        await Promise.all(updates.map(handleUpdate))
+    } finally {
+      debug('Long polling stopped')
+      // prevent instance reuse
+      this.stop()
+      await this.syncUpdateOffset().catch(noop)
+    }
+  }
+
+  stop() {
+    this.abortController.abort()
+  }
+}

package/src/core/network/webhook.ts

@@ -0,0 +1,58 @@
+import * as http from 'http'
+import d from 'debug'
+import { type Update } from '../types/typegram'
+const debug = d('telegraf:webhook')
+
+export default function generateWebhook(
+  filter: (req: http.IncomingMessage) => boolean,
+  updateHandler: (update: Update, res: http.ServerResponse) => Promise<void>
+) {
+  return async (
+    req: http.IncomingMessage & { body?: Update },
+    res: http.ServerResponse,
+    next = (): void => {
+      res.statusCode = 403
+      debug('Replying with status code', res.statusCode)
+      res.end()
+    }
+  ): Promise<void> => {
+    debug('Incoming request', req.method, req.url)
+
+    if (!filter(req)) {
+      debug('Webhook filter failed', req.method, req.url)
+      return next()
+    }
+
+    let update: Update
+
+    try {
+      if (req.body != null) {
+        /* If req.body is already set, we expect it to be the parsed
+         request body (update object) received from Telegram
+         However, some libraries such as `serverless-http` set req.body to the
+         raw buffer, so we'll handle that additionally */
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let body: any = req.body
+        // if body is Buffer, parse it into string
+        if (body instanceof Buffer) body = String(req.body)
+        // if body is string, parse it into object
+        if (typeof body === 'string') body = JSON.parse(body)
+        update = body
+      } else {
+        let body = ''
+        // parse each buffer to string and append to body
+        for await (const chunk of req) body += String(chunk)
+        // parse body to object
+        update = JSON.parse(body)
+      }
+    } catch (error: unknown) {
+      // if any of the parsing steps fails, give up and respond with error
+      res.writeHead(415).end()
+      debug('Failed to parse request body:', error)
+      return
+    }
+
+    return await updateHandler(update, res)
+  }
+}

package/src/core/types/typegram.ts

@@ -0,0 +1,54 @@
+import * as Typegram from '@telegraf/types'
+
+// internal type provisions
+export * from '@telegraf/types/api'
+export * from '@telegraf/types/inline'
+export * from '@telegraf/types/manage'
+export * from '@telegraf/types/markup'
+export * from '@telegraf/types/message'
+export * from '@telegraf/types/methods'
+export * from '@telegraf/types/passport'
+export * from '@telegraf/types/payment'
+export * from '@telegraf/types/settings'
+export * from '@telegraf/types/update'
+
+// telegraf input file definition
+interface InputFileByPath {
+  source: string
+  filename?: string
+}
+interface InputFileByReadableStream {
+  source: NodeJS.ReadableStream
+  filename?: string
+}
+interface InputFileByBuffer {
+  source: Buffer
+  filename?: string
+}
+interface InputFileByURL {
+  url: string
+  filename?: string
+}
+export type InputFile =
+  | InputFileByPath
+  | InputFileByReadableStream
+  | InputFileByBuffer
+  | InputFileByURL
+
+export type Telegram = Typegram.ApiMethods<InputFile>
+
+export type Opts<M extends keyof Telegram> = Typegram.Opts<InputFile>[M]
+export type InputMedia = Typegram.InputMedia<InputFile>
+export type InputMediaPhoto = Typegram.InputMediaPhoto<InputFile>
+export type InputMediaVideo = Typegram.InputMediaVideo<InputFile>
+export type InputMediaAnimation = Typegram.InputMediaAnimation<InputFile>
+export type InputMediaAudio = Typegram.InputMediaAudio<InputFile>
+export type InputMediaDocument = Typegram.InputMediaDocument<InputFile>
+
+// tiny helper types
+export type ChatAction = Opts<'sendChatAction'>['action']
+
+/**
+ * Sending video notes by a URL is currently unsupported
+ */
+export type InputFileVideoNote = Exclude<InputFile, InputFileByURL>