@effect-ak/tg-bot-client 1.3.4 → 1.4.1

package/test/execute.test.ts

@@ -1,8 +1,6 @@
 import { describe, expect, vi } from "vitest"
 
 import { fixture } from "./fixture"
-import { MESSAGE_EFFECTS } from "~/const"
-import { executeTgBotMethod } from "~/execute"
 
 const fetchSpy = vi.spyOn(global, "fetch")
 
@@ -10,10 +8,10 @@ describe("telegram bot client, execute method", () => {
   fixture("send dice", async ({ chat_id, client }) => {
     // skip();
 
-    const response = await client.execute("send_dice", {
+    const result = await client.execute("send_dice", {
       chat_id,
       emoji: "🎲",
-      message_effect_id: MESSAGE_EFFECTS["🔥"]
+      message_effect_id: "🔥"
     })
 
     const url = fetchSpy.mock.calls[0][0] as string
@@ -21,28 +19,34 @@ describe("telegram bot client, execute method", () => {
 
     expect(lastPath).toEqual("sendDice")
 
-    expect(response.chat.id).toBeDefined()
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.chat.id).toBeDefined()
+    }
   })
 
   fixture("send message", async ({ chat_id, client, skip }) => {
     skip()
 
-    const response = await client.execute("send_message", {
+    const result = await client.execute("send_message", {
       chat_id,
       text: "hey again",
-      message_effect_id: MESSAGE_EFFECTS["🔥"]
+      message_effect_id: "🔥"
     })
 
-    expect(response.chat.id).toBeDefined()
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.chat.id).toBeDefined()
+    }
   })
 
   fixture("send message with keyboard", async ({ chat_id, client, skip }) => {
     skip()
 
-    const response = await client.execute("send_message", {
+    const result = await client.execute("send_message", {
       chat_id,
       text: "hey again!",
-      message_effect_id: MESSAGE_EFFECTS["🎉"],
+      message_effect_id: "🎉",
       reply_markup: {
         inline_keyboard: [
           [
@@ -57,15 +61,18 @@ describe("telegram bot client, execute method", () => {
       }
     })
 
-    expect(response.chat.id).toBeDefined()
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.chat.id).toBeDefined()
+    }
   })
 
   fixture("send document", async ({ chat_id, client, skip }) => {
     skip()
 
-    const response = await client.execute("send_document", {
+    const result = await client.execute("send_document", {
       chat_id,
-      message_effect_id: MESSAGE_EFFECTS["🎉"],
+      message_effect_id: "🎉",
       document: {
         file_content: Buffer.from("Hello!"),
         file_name: "hello.txt"
@@ -73,9 +80,11 @@ describe("telegram bot client, execute method", () => {
       caption: "simple text file"
     })
 
-    expect(response.document?.file_id).toBeDefined()
-
-    expect(response.chat.id).toBeDefined()
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.document?.file_id).toBeDefined()
+      expect(result.data.chat.id).toBeDefined()
+    }
   })
 
   fixture("send message with action", async ({ chat_id, client }) => {
@@ -86,12 +95,15 @@ describe("telegram bot client, execute method", () => {
 
     await new Promise((res) => setTimeout(res, 5000))
 
-    const response = await client.execute("send_message", {
+    const result = await client.execute("send_message", {
       chat_id,
       text: "hey again with typings",
-      message_effect_id: MESSAGE_EFFECTS["🔥"]
+      message_effect_id: "🔥"
     })
 
-    expect(response.chat.id).toBeDefined()
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.data.chat.id).toBeDefined()
+    }
   })
 })

package/test/file.test.ts

@@ -4,7 +4,7 @@ import { fixture } from "./fixture"
 
 describe("telegram bot client, download file", () => {
   fixture("get file content", async ({ client, chat_id }) => {
-    const document = await client.execute("send_document", {
+    const result = await client.execute("send_document", {
       chat_id,
       document: {
         file_content: Buffer.from("Hello!"),
@@ -12,12 +12,14 @@ describe("telegram bot client, download file", () => {
       }
     })
 
-    const fileId = document.document?.file_id
+    assert(result.ok, "send_document failed")
+
+    const fileId = result.data.document?.file_id
 
     assert(fileId, "file id is null")
 
-    const response = await client.getFile({ fileId })
+    const fileResult = await client.getFile({ fileId })
 
-    expect(response).toBeDefined()
+    expect(fileResult.ok).toBe(true)
   })
 })

package/src/client-file.ts

@@ -1,57 +0,0 @@
-import { TgBotClientError } from "./errors"
-import type { ExecuteMethod } from "./execute"
-
-export interface TgFile {
-  readonly content: ArrayBuffer
-  readonly file_name: string
-  readonly base64String: () => string
-  readonly file: () => File
-}
-
-export const getFile = async (params: {
-  fileId: string
-  config: {
-    bot_token: string
-    base_url: string
-  }
-  type?: string
-  execute: ExecuteMethod
-}): Promise<TgFile> => {
-  const { fileId, config, execute } = params
-  const response = await execute("get_file", { file_id: fileId })
-  const file_path = response.file_path
-
-  if (!file_path || file_path.length === 0) {
-    throw new TgBotClientError({
-      cause: {
-        _tag: "UnableToGetFile",
-        cause: "File path not defined"
-      }
-    })
-  }
-
-  const file_name = file_path.replaceAll("/", "-")
-  const url = `${config.base_url}/file/bot${config.bot_token}/${file_path}`
-
-  let content: ArrayBuffer
-  try {
-    content = await fetch(url).then((_) => _.arrayBuffer())
-  } catch (cause) {
-    throw new TgBotClientError({
-      cause: { _tag: "UnableToGetFile", cause }
-    })
-  }
-
-  const base64String = () => Buffer.from(content).toString("base64")
-  const file = () =>
-    new File([content], file_name, {
-      ...(params.type ? { type: params.type } : {})
-    })
-
-  return {
-    content,
-    file_name,
-    base64String,
-    file
-  }
-}

package/src/const.ts

@@ -1,20 +0,0 @@
-export const TG_BOT_API_URL = "https://api.telegram.org"
-
-export const MESSAGE_EFFECTS = {
-  "🔥": "5104841245755180586",
-  "👍": "5107584321108051014",
-  "👎": "5104858069142078462",
-  "❤️": "5159385139981059251",
-  "🎉": "5046509860389126442",
-  "💩": "5046589136895476101"
-} as const
-
-export type MessageEffect = keyof typeof MESSAGE_EFFECTS
-
-export const messageEffectIdCodes = Object.keys(
-  MESSAGE_EFFECTS
-) as MessageEffect[]
-
-export const isMessageEffect = (input: unknown): input is MessageEffect => {
-  return typeof input === "string" && input in MESSAGE_EFFECTS
-}

package/src/errors.ts

@@ -1,18 +0,0 @@
-type ErrorReason =
-  | { _tag: "NotOkResponse"; errorCode?: number; details?: string }
-  | { _tag: "UnexpectedResponse"; response: unknown }
-  | { _tag: "ClientInternalError"; cause: unknown }
-  | { _tag: "UnableToGetFile"; cause: unknown }
-  | { _tag: "BotHandlerError"; cause: unknown }
-  | { _tag: "NotJsonResponse"; response: unknown }
-
-export class TgBotClientError extends Error {
-  readonly _tag = "TgBotClientError"
-  readonly cause: ErrorReason
-
-  constructor(options: { cause: ErrorReason }) {
-    super(`TgBotClientError: ${options.cause._tag}`)
-    this.cause = options.cause
-    this.name = "TgBotClientError"
-  }
-}

package/src/guards.ts

@@ -1,27 +0,0 @@
-export interface FileContent {
-  file_content: Uint8Array<ArrayBuffer>
-  file_name: string
-}
-
-export const isFileContent = (input: unknown): input is FileContent =>
-  typeof input == "object" &&
-  input != null &&
-  "file_content" in input &&
-  input.file_content instanceof Uint8Array &&
-  "file_name" in input &&
-  typeof input.file_name == "string"
-
-export interface TgBotApiResponseSchema {
-  ok: boolean
-  error_code?: number
-  description?: string
-  result?: unknown
-}
-
-export const isTgBotApiResponse = (
-  input: unknown
-): input is TgBotApiResponseSchema =>
-  typeof input == "object" &&
-  input != null &&
-  "ok" in input &&
-  typeof input.ok == "boolean"

package/src/utils.ts

@@ -1,3 +0,0 @@
-export const snakeToCamel = (str: string): string => {
-  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())
-}