@tgify/tgify 0.1.0 → 0.1.5

package/src/core/network/error.ts

@@ -1,29 +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
+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

@@ -1,45 +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
+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

@@ -1,94 +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()
-  }
-}
+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

@@ -1,58 +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)
-  }
-}
+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

@@ -1,54 +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>
+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>