@tgify/tgify 0.1.4 → 1.0.1

package/src/filters.ts

@@ -3,7 +3,7 @@ import type {
   CommonMessageBundle,
   Message,
   Update,
-} from '@telegraf/types'
+} from '@tgify/types'
 import { DistinctKeys, KeyedDistinct, Guarded } from './core/helpers/util'
 
 export type Filter<U extends Update> = (update: Update) => update is U
@@ -15,78 +15,78 @@ export type AllGuarded<Fs extends Filter<Update>[]> = Fs extends [
   ...infer B,
 ]
   ? B extends []
-    ? Guarded<A>
-    : // TS doesn't know otherwise that B is Filter[]
-    B extends Filter<Update>[]
-    ? Guarded<A> & AllGuarded<B>
-    : never
+  ? Guarded<A>
+  : // TS doesn't know otherwise that B is Filter[]
+  B extends Filter<Update>[]
+  ? Guarded<A> & AllGuarded<B>
+  : never
   : never
 
 export const message =
   <Ks extends DistinctKeys<Message>[]>(...keys: Ks) =>
-  (
-    update: Update
-  ): update is Update.MessageUpdate<KeyedDistinct<Message, Ks[number]>> => {
-    if (!('message' in update)) return false
-    for (const key of keys) {
-      if (!(key in update.message)) return false
+    (
+      update: Update
+    ): update is Update.MessageUpdate<KeyedDistinct<Message, Ks[number]>> => {
+      if (!('message' in update)) return false
+      for (const key of keys) {
+        if (!(key in update.message)) return false
+      }
+      return true
     }
-    return true
-  }
 
 export const editedMessage =
   <Ks extends DistinctKeys<CommonMessageBundle>[]>(...keys: Ks) =>
-  (
-    update: Update
-  ): update is Update.EditedMessageUpdate<
-    KeyedDistinct<CommonMessageBundle, Ks[number]>
-  > => {
-    if (!('edited_message' in update)) return false
-    for (const key of keys) {
-      if (!(key in update.edited_message)) return false
+    (
+      update: Update
+    ): update is Update.EditedMessageUpdate<
+      KeyedDistinct<CommonMessageBundle, Ks[number]>
+    > => {
+      if (!('edited_message' in update)) return false
+      for (const key of keys) {
+        if (!(key in update.edited_message)) return false
+      }
+      return true
     }
-    return true
-  }
 
 export const channelPost =
   <Ks extends DistinctKeys<Message>[]>(...keys: Ks) =>
-  (
-    update: Update
-  ): update is Update.ChannelPostUpdate<KeyedDistinct<Message, Ks[number]>> => {
-    if (!('channel_post' in update)) return false
-    for (const key of keys) {
-      if (!(key in update.channel_post)) return false
+    (
+      update: Update
+    ): update is Update.ChannelPostUpdate<KeyedDistinct<Message, Ks[number]>> => {
+      if (!('channel_post' in update)) return false
+      for (const key of keys) {
+        if (!(key in update.channel_post)) return false
+      }
+      return true
     }
-    return true
-  }
 
 export const editedChannelPost =
   <Ks extends DistinctKeys<CommonMessageBundle>[]>(...keys: Ks) =>
-  (
-    update: Update
-  ): update is Update.EditedChannelPostUpdate<
-    KeyedDistinct<CommonMessageBundle, Ks[number]>
-  > => {
-    if (!('edited_channel_post' in update)) return false
-    for (const key of keys) {
-      if (!(key in update.edited_channel_post)) return false
+    (
+      update: Update
+    ): update is Update.EditedChannelPostUpdate<
+      KeyedDistinct<CommonMessageBundle, Ks[number]>
+    > => {
+      if (!('edited_channel_post' in update)) return false
+      for (const key of keys) {
+        if (!(key in update.edited_channel_post)) return false
+      }
+      return true
     }
-    return true
-  }
 
 export const callbackQuery =
   <Ks extends DistinctKeys<CallbackQuery>[]>(...keys: Ks) =>
-  (
-    update: Update
-  ): update is Update.CallbackQueryUpdate<
-    KeyedDistinct<CallbackQuery, Ks[number]>
-  > => {
-    if (!('callback_query' in update)) return false
-    for (const key of keys) {
-      if (!(key in update.callback_query)) return false
+    (
+      update: Update
+    ): update is Update.CallbackQueryUpdate<
+      KeyedDistinct<CallbackQuery, Ks[number]>
+    > => {
+      if (!('callback_query' in update)) return false
+      for (const key of keys) {
+        if (!(key in update.callback_query)) return false
+      }
+      return true
     }
-    return true
-  }
 
 /** Any of the provided filters must match */
 export const anyOf =
@@ -95,15 +95,15 @@ export const anyOf =
       [UIdx in keyof Us]: Filter<Us[UIdx]>
     }
   ) =>
-  (update: Update): update is Us[number] => {
-    for (const filter of filters) if (filter(update)) return true
-    return false
-  }
+    (update: Update): update is Us[number] => {
+      for (const filter of filters) if (filter(update)) return true
+      return false
+    }
 
 /** All of the provided filters must match */
 export const allOf =
   <U extends Update, Fs extends Filter<U>[]>(...filters: Fs) =>
-  (update: Update): update is AllGuarded<Fs> => {
-    for (const filter of filters) if (!filter(update)) return false
-    return true
-  }
+    (update: Update): update is AllGuarded<Fs> => {
+      for (const filter of filters) if (!filter(update)) return false
+      return true
+    }

package/src/format.ts

@@ -1,4 +1,4 @@
-import { User } from '@telegraf/types'
+import { User } from '@tgify/types'
 import {
   FmtString,
   createFmt,
@@ -105,6 +105,6 @@ export const mention = (
   typeof user === 'number'
     ? link(name, 'tg://user?id=' + user)
     : (linkOrMention(name, {
-        type: 'text_mention',
-        user,
-      }) as FmtString<'text_mention'>)
+      type: 'text_mention',
+      user,
+    }) as FmtString<'text_mention'>)

package/src/future.ts

@@ -1,4 +1,4 @@
-import { ReplyParameters } from '@telegraf/types'
+import { ReplyParameters } from '@tgify/types'
 import Context from './context'
 import { Middleware } from './middleware'
 

package/src/index.ts

@@ -1,3 +1,4 @@
+export { Tgify } from './tgify';
 export { Telegraf } from './telegraf'
 export { Context, NarrowedContext } from './context'
 export { Composer } from './composer'

package/src/markup.ts

@@ -14,10 +14,10 @@ type HideableIKBtn = Hideable<InlineKeyboardButton>
 
 export class Markup<
   T extends
-    | InlineKeyboardMarkup
-    | ReplyKeyboardMarkup
-    | ReplyKeyboardRemove
-    | ForceReply,
+  | InlineKeyboardMarkup
+  | ReplyKeyboardMarkup
+  | ReplyKeyboardRemove
+  | ForceReply,
 > {
   constructor(readonly reply_markup: T) {}
 
@@ -124,7 +124,7 @@ function buildKeyboard<B extends HideableKBtn | HideableIKBtn>(
     options.wrap !== undefined
       ? options.wrap
       : (_btn: B, _index: number, currentRow: B[]) =>
-          currentRow.length >= options.columns
+        currentRow.length >= options.columns
   let currentRow: B[] = []
   let index = 0
   for (const btn of buttons.filter((button) => !button.hide)) {

package/src/reactions.ts

@@ -12,9 +12,11 @@ export type Reaction =
 type ReactionCtx = { update: Partial<tg.Update.MessageReactionUpdate> }
 
 const inspectReaction = (reaction: tg.ReactionType) => {
+  if (reaction.type === 'emoji')
+    return reaction.emoji
   if (reaction.type === 'custom_emoji')
     return `Custom(${reaction.custom_emoji_id})`
-  else return reaction.emoji
+  else return 'paid()'
 }
 
 export class ReactionList {

package/src/session.ts

@@ -49,8 +49,8 @@ export function session<
   S extends NonNullable<C[P]>,
   C extends Context & { [key in P]?: C[P] },
   P extends (ExclusiveKeys<C, Context> & string) | 'session' = 'session',
-  // ^ Only allow prop names that aren't keys in base Context.
-  // At type level, this is cosmetic. To not get cluttered with all Context keys.
+// ^ Only allow prop names that aren't keys in base Context.
+// At type level, this is cosmetic. To not get cluttered with all Context keys.
 >(options?: SessionOptions<S, C, P>): MiddlewareFn<C> {
   const prop = options?.property ?? ('session' as P)
   const getSessionKey = options?.getSessionKey ?? defaultGetSessionKey

package/src/telegraf.ts

@@ -1,354 +1 @@
-import * as crypto from 'crypto'
-import * as http from 'http'
-import * as https from 'https'
-import * as tg from './core/types/typegram'
-import * as tt from './telegram-types'
-import { Composer } from './composer'
-import { MaybePromise } from './core/helpers/util'
-import ApiClient from './core/network/client'
-import { compactOptions } from './core/helpers/compact'
-import Context from './context'
-import d from 'debug'
-import generateCallback from './core/network/webhook'
-import { Polling } from './core/network/polling'
-import pTimeout from 'p-timeout'
-import Telegram from './telegram'
-import { TlsOptions } from 'tls'
-import { URL } from 'url'
-import safeCompare = require('safe-compare')
-const debug = d('telegraf:main')
-
-const DEFAULT_OPTIONS: Telegraf.Options<Context> = {
-  telegram: {},
-  handlerTimeout: 90_000, // 90s in ms
-  contextType: Context,
-}
-
-function always<T>(x: T) {
-  return () => x
-}
-
-const anoop = always(Promise.resolve())
-
-export namespace Telegraf {
-  export interface Options<TContext extends Context> {
-    contextType: new (
-      ...args: ConstructorParameters<typeof Context>
-    ) => TContext
-    handlerTimeout: number
-    telegram?: Partial<ApiClient.Options>
-  }
-
-  export interface LaunchOptions {
-    dropPendingUpdates?: boolean
-    /** List the types of updates you want your bot to receive */
-    allowedUpdates?: tt.UpdateType[]
-    /** Configuration options for when the bot is run via webhooks */
-    webhook?: {
-      /** Public domain for webhook. */
-      domain: string
-
-      /**
-       * Webhook url path; will be automatically generated if not specified
-       * @deprecated Pass `path` instead
-       * */
-      hookPath?: string
-
-      /** Webhook url path; will be automatically generated if not specified */
-      path?: string
-
-      host?: string
-      port?: number
-
-      /** The fixed IP address which will be used to send webhook requests instead of the IP address resolved through DNS */
-      ipAddress?: string
-
-      /**
-       * Maximum allowed number of simultaneous HTTPS connections to the webhook for update delivery, 1-100. Defaults to 40.
-       * Use lower values to limit the load on your bot's server, and higher values to increase your bot's throughput.
-       */
-      maxConnections?: number
-
-      /** TLS server options. Omit to use http. */
-      tlsOptions?: TlsOptions
-
-      /**
-       * A secret token to be sent in a header `“X-Telegram-Bot-Api-Secret-Token”` in every webhook request.
-       * 1-256 characters. Only characters `A-Z`, `a-z`, `0-9`, `_` and `-` are allowed.
-       * The header is useful to ensure that the request comes from a webhook set by you.
-       */
-      secretToken?: string
-
-      /**
-       * Upload your public key certificate so that the root certificate in use can be checked.
-       * See [self-signed guide](https://core.telegram.org/bots/self-signed) for details.
-       */
-      certificate?: tg.InputFile
-
-      cb?: http.RequestListener
-    }
-  }
-}
-
-const TOKEN_HEADER = 'x-telegram-bot-api-secret-token'
-
-export class Telegraf<C extends Context = Context> extends Composer<C> {
-  private readonly options: Telegraf.Options<C>
-  private webhookServer?: http.Server | https.Server
-  private polling?: Polling
-  /** Set manually to avoid implicit `getMe` call in `launch` or `webhookCallback` */
-  public botInfo?: tg.UserFromGetMe
-  public telegram: Telegram
-  readonly context: Partial<C> = {}
-
-  /** Assign to this to customise the webhook filter middleware.
-   * `{ path, secretToken }` will be bound to this rather than the Telegraf instance.
-   * Remember to assign a regular function and not an arrow function so it's bindable.
-   */
-  public webhookFilter = function (
-    // NOTE: this function is assigned to a variable instead of being a method to signify that it's assignable
-    // NOTE: the `this` binding is so custom impls don't need to double wrap
-    this: {
-      /** @deprecated Use path instead */
-      hookPath: string
-      path: string
-      secretToken?: string
-    },
-    req: http.IncomingMessage
-  ) {
-    const debug = d('telegraf:webhook')
-
-    if (req.method === 'POST') {
-      if (safeCompare(this.path, req.url as string)) {
-        // no need to check if secret_token was not set
-        if (!this.secretToken) return true
-        else {
-          const token = req.headers[TOKEN_HEADER] as string
-          if (safeCompare(this.secretToken, token)) return true
-          else debug('Secret token does not match:', token, this.secretToken)
-        }
-      } else debug('Path does not match:', req.url, this.path)
-    } else debug('Unexpected request method, not POST. Received:', req.method)
-
-    return false
-  }
-
-  private handleError = (err: unknown, ctx: C): MaybePromise<void> => {
-    // set exit code to emulate `warn-with-error-code` behavior of
-    // https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode
-    // to prevent a clean exit despite an error being thrown
-    process.exitCode = 1
-    console.error('Unhandled error while processing', ctx.update)
-    throw err
-  }
-
-  constructor(token: string, options?: Partial<Telegraf.Options<C>>) {
-    super()
-    // @ts-expect-error Trust me, TS
-    this.options = {
-      ...DEFAULT_OPTIONS,
-      ...compactOptions(options),
-    }
-    this.telegram = new Telegram(token, this.options.telegram)
-    debug('Created a `Telegraf` instance')
-  }
-
-  private get token() {
-    return this.telegram.token
-  }
-
-  /** @deprecated use `ctx.telegram.webhookReply` */
-  set webhookReply(webhookReply: boolean) {
-    this.telegram.webhookReply = webhookReply
-  }
-
-  /** @deprecated use `ctx.telegram.webhookReply` */
-  get webhookReply() {
-    return this.telegram.webhookReply
-  }
-
-  /**
-   * _Override_ error handling
-   */
-  catch(handler: (err: unknown, ctx: C) => MaybePromise<void>) {
-    this.handleError = handler
-    return this
-  }
-
-  /**
-   * You must call `bot.telegram.setWebhook` for this to work.
-   * You should probably use {@link Telegraf.createWebhook} instead.
-   */
-  webhookCallback(path = '/', opts: { secretToken?: string } = {}) {
-    const { secretToken } = opts
-    return generateCallback(
-      this.webhookFilter.bind({ hookPath: path, path, secretToken }),
-      (update: tg.Update, res: http.ServerResponse) =>
-        this.handleUpdate(update, res)
-    )
-  }
-
-  private getDomainOpts(opts: { domain: string; path?: string }) {
-    const protocol =
-      opts.domain.startsWith('https://') || opts.domain.startsWith('http://')
-
-    if (protocol)
-      debug(
-        'Unexpected protocol in domain, telegraf will use https:',
-        opts.domain
-      )
-
-    const domain = protocol ? new URL(opts.domain).host : opts.domain
-    const path = opts.path ?? `/telegraf/${this.secretPathComponent()}`
-    const url = `https://${domain}${path}`
-
-    return { domain, path, url }
-  }
-
-  /**
-   * Specify a url to receive incoming updates via webhook.
-   * Returns an Express-style middleware you can pass to app.use()
-   */
-  async createWebhook(
-    opts: { domain: string; path?: string } & tt.ExtraSetWebhook
-  ) {
-    const { domain, path, ...extra } = opts
-
-    const domainOpts = this.getDomainOpts({ domain, path })
-
-    await this.telegram.setWebhook(domainOpts.url, extra)
-    debug(`Webhook set to ${domainOpts.url}`)
-
-    return this.webhookCallback(domainOpts.path, {
-      secretToken: extra.secret_token,
-    })
-  }
-
-  private startPolling(allowedUpdates: tt.UpdateType[] = []) {
-    this.polling = new Polling(this.telegram, allowedUpdates)
-    return this.polling.loop(async (update) => {
-      await this.handleUpdate(update)
-    })
-  }
-
-  private startWebhook(
-    path: string,
-    tlsOptions?: TlsOptions,
-    port?: number,
-    host?: string,
-    cb?: http.RequestListener,
-    secretToken?: string
-  ) {
-    const webhookCb = this.webhookCallback(path, { secretToken })
-    const callback: http.RequestListener =
-      typeof cb === 'function'
-        ? (req, res) => webhookCb(req, res, () => cb(req, res))
-        : webhookCb
-    this.webhookServer =
-      tlsOptions != null
-        ? https.createServer(tlsOptions, callback)
-        : http.createServer(callback)
-    this.webhookServer.listen(port, host, () => {
-      debug('Webhook listening on port: %s', port)
-    })
-    return this
-  }
-
-  secretPathComponent() {
-    return crypto
-      .createHash('sha3-256')
-      .update(this.token)
-      .update(process.version) // salt
-      .digest('hex')
-  }
-
-  async launch(onLaunch?: () => void): Promise<void>
-  async launch(
-    config: Telegraf.LaunchOptions,
-    onLaunch?: () => void
-  ): Promise<void>
-  /**
-   * @see https://github.com/telegraf/telegraf/discussions/1344#discussioncomment-335700
-   */
-  async launch(
-    config: Telegraf.LaunchOptions | (() => void) = {},
-    /** @experimental */
-    onLaunch?: () => void
-  ) {
-    const [cfg, onMe] =
-      typeof config === 'function' ? [{}, config] : [config, onLaunch]
-    const drop_pending_updates = cfg.dropPendingUpdates
-    const allowed_updates = cfg.allowedUpdates
-    const webhook = cfg.webhook
-
-    debug('Connecting to Telegram')
-    this.botInfo ??= await this.telegram.getMe()
-    onMe?.()
-    debug(`Launching @${this.botInfo.username}`)
-
-    if (webhook === undefined) {
-      await this.telegram.deleteWebhook({ drop_pending_updates })
-      debug('Bot started with long polling')
-      await this.startPolling(allowed_updates)
-      return
-    }
-
-    const domainOpts = this.getDomainOpts({
-      domain: webhook.domain,
-      path: webhook.path ?? webhook.hookPath,
-    })
-
-    const { tlsOptions, port, host, cb, secretToken } = webhook
-
-    this.startWebhook(domainOpts.path, tlsOptions, port, host, cb, secretToken)
-
-    await this.telegram.setWebhook(domainOpts.url, {
-      drop_pending_updates: drop_pending_updates,
-      allowed_updates: allowed_updates,
-      ip_address: webhook.ipAddress,
-      max_connections: webhook.maxConnections,
-      secret_token: webhook.secretToken,
-      certificate: webhook.certificate,
-    })
-
-    debug(`Bot started with webhook @ ${domainOpts.url}`)
-  }
-
-  stop(reason = 'unspecified') {
-    debug('Stopping bot... Reason:', reason)
-    // https://github.com/telegraf/telegraf/pull/1224#issuecomment-742693770
-    if (this.polling === undefined && this.webhookServer === undefined) {
-      throw new Error('Bot is not running!')
-    }
-    this.webhookServer?.close()
-    this.polling?.stop()
-  }
-
-  private botInfoCall?: Promise<tg.UserFromGetMe>
-  async handleUpdate(update: tg.Update, webhookResponse?: http.ServerResponse) {
-    this.botInfo ??=
-      (debug(
-        'Update %d is waiting for `botInfo` to be initialized',
-        update.update_id
-      ),
-      await (this.botInfoCall ??= this.telegram.getMe()))
-    debug('Processing update', update.update_id)
-    const tg = new Telegram(this.token, this.telegram.options, webhookResponse)
-    const TelegrafContext = this.options.contextType
-    const ctx = new TelegrafContext(update, tg, this.botInfo)
-    Object.assign(ctx, this.context)
-    try {
-      await pTimeout(
-        Promise.resolve(this.middleware()(ctx, anoop)),
-        this.options.handlerTimeout
-      )
-    } catch (err) {
-      return await this.handleError(err, ctx)
-    } finally {
-      if (webhookResponse?.writableEnded === false) {
-        webhookResponse.end()
-      }
-      debug('Finished processing update', update.update_id)
-    }
-  }
-}
+export { Tgify as Telegraf } from './tgify'

package/src/telegram-types.ts

@@ -159,14 +159,14 @@ export type UpdateType = Exclude<UnionKeys<Update>, keyof Update>
 export type MessageSubType =
   | 'forward_date'
   | Exclude<
-      UnionKeys<Message>,
-      keyof Message.CaptionableMessage | 'entities' | 'media_group_id'
-    >
+    UnionKeys<Message>,
+    keyof Message.CaptionableMessage | 'entities' | 'media_group_id'
+  >
 
 type ExtractPartial<T extends object, U extends object> = T extends unknown
   ? Required<T> extends U
-    ? T
-    : never
+  ? T
+  : never
   : never
 
 /**

package/src/telegram.ts

@@ -42,9 +42,8 @@ export class Telegram extends ApiClient {
     }
 
     return new URL(
-      `./file/${this.options.apiMode}${this.token}${
-        this.options.testEnv ? '/test' : ''
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      `./file/${this.options.apiMode}${this.token}${this.options.testEnv ? '/test' : ''
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       }/${fileId.file_path!}`,
       this.options.apiRoot
     )
@@ -460,7 +459,7 @@ export class Telegram extends ApiClient {
   sendPoll(
     chatId: number | string,
     question: string,
-    options: readonly string[],
+    options: readonly tg.InputPollOption[],
     extra?: tt.ExtraPoll
   ) {
     return this.callApi('sendPoll', {
@@ -481,7 +480,7 @@ export class Telegram extends ApiClient {
   sendQuiz(
     chatId: number | string,
     question: string,
-    options: readonly string[],
+    options: readonly tg.InputPollOption[],
     extra?: tt.ExtraPoll
   ) {
     return this.callApi('sendPoll', {
@@ -941,9 +940,9 @@ export class Telegram extends ApiClient {
     markup: tg.InlineKeyboardMarkup | undefined
   ) {
     return this.callApi('editMessageReplyMarkup', {
-      chat_id: chatId,
-      message_id: messageId,
-      inline_message_id: inlineMessageId,
+      ...(chatId !== undefined && { chat_id: chatId }),
+      ...(messageId !== undefined && { message_id: messageId }),
+      ...(inlineMessageId !== undefined && { inline_message_id: inlineMessageId }),
       reply_markup: markup,
     })
   }
@@ -1311,16 +1310,19 @@ export class Telegram extends ApiClient {
    * HTTP URL as a String for Telegram to get a file from the Internet, or upload a new one using
    * Input helpers. Animated and video sticker set thumbnails can't be uploaded via HTTP URL.
    * If omitted, then the thumbnail is dropped and the first sticker is used as the thumbnail.
+   * @param format Format of the sticker set thumbnail; must be one of "static", "animated", or "video"
    */
   setStickerSetThumbnail(
     name: string,
     userId: number,
-    thumbnail?: tg.Opts<'setStickerSetThumbnail'>['thumbnail']
+    thumbnail?: tg.Opts<'setStickerSetThumbnail'>['thumbnail'],
+    format: tg.Opts<'setStickerSetThumbnail'>['format'] = 'static'
   ) {
     return this.callApi('setStickerSetThumbnail', {
       name,
-      user_id: userId,
+      format,
       thumbnail,
+      user_id: userId,
     })
   }