@effect-ak/tg-bot-client 0.6.4 → 1.0.0

package/package.json

@@ -1,75 +1,41 @@
 {
   "name": "@effect-ak/tg-bot-client",
-  "version": "0.6.4",
-  "homepage": "https://effect-ak.github.io/telegram-bot-playground/",
+  "type": "module",
+  "description": "Type-safe HTTP client for Telegram Bot API",
+  "version": "1.0.0",
+  "license": "MIT",
   "author": {
     "name": "Aleksandr Kondaurov",
     "email": "kondaurov.dev@gmail.com"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "description": "TypeScript types for Telegram Bot Api and Telegram.Webapp",
-  "files": [
-    "dist/*.js",
-    "dist/*.mjs",
-    "dist/*.d.ts",
-    "!dist/bot-bundle.d.ts",
-    "!dist/bot-bundle.d.mts"
-  ],
-  "keywords": [
-    "telegram typescript types",
-    "telegram bot api client",
-    "telegram webapp"
-  ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/effect-ak/tg-bot-client"
+    "url": "https://github.com/effect-ak/tg-bot-client",
+    "directory": "packages/client"
   },
   "bugs": {
     "url": "https://github.com/effect-ak/tg-bot-client/issues"
   },
-  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
   "types": "./dist/index.d.ts",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs"
-    },
-    "./bot": {
-      "types": "./dist/bot.d.ts",
-      "require": "./dist/bot.js",
-      "import": "./dist/bot.mjs"
-    },
-    "./bot-bundle": {
-      "types": "./dist/bot.d.ts",
-      "require": "./dist/bot-bundle.js",
-      "import": "./dist/bot-bundle.mjs"
-    },
-    "./webapp": {
-      "types": "./dist/webapp.d.ts",
-      "require": "./dist/webapp.js",
-      "import": "./dist/webapp.mjs"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     }
   },
-  "devDependencies": {
-    "@types/node": "^22.10.1",
-    "@types/js-yaml": "^4.0.9",
-    "js-yaml": "^4.1.0",
-    "node-html-parser": "^6.1.13",
-    "openapi-types": "^12.1.3",
-    "ts-morph": "^24.0.0",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.3",
-    "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.1.1",
-    "effect": "3.12.0",
-    "tsup": "^8.5.0"
+  "dependencies": {
+    "@effect-ak/tg-bot-api": "0.9.2"
   },
   "peerDependencies": {
     "effect": "^3.12.0"
+  },
+  "scripts": {
+    "build": "tsup"
   }
 }

package/src/client-file.ts

@@ -0,0 +1,70 @@
+import * as Micro from "effect/Micro"
+import * as Context from "effect/Context"
+
+import { TgBotClientError } from "./errors"
+import { TgBotApiBaseUrl, TgBotApiToken } from "./config"
+import { executeTgBotMethod } from "./execute"
+
+export class ClientFileService extends Context.Tag("ClientFileService")<
+  ClientFileService,
+  {
+    getFile: (input: GetFile) => ReturnType<typeof getFile>
+  }
+>() {
+  static live = () => {
+    return ClientFileService.context({
+      getFile
+    })
+  }
+}
+
+export interface GetFile {
+  fileId: string
+  type?: string
+}
+
+const getFile = ({ fileId, type }: GetFile) =>
+  getFileBytes(fileId).pipe(
+    Micro.andThen(
+      ({ content, file_name }) =>
+        new File([content], file_name, {
+          ...(type ? { type } : undefined)
+        })
+    )
+  )
+
+const getFileBytes = (fileId: string) =>
+  Micro.gen(function* () {
+    const response = yield* executeTgBotMethod("get_file", { file_id: fileId })
+    const file_path = response.file_path
+
+    if (!file_path || file_path.length == 0) {
+      return yield* Micro.fail(
+        new TgBotClientError({
+          cause: {
+            _tag: "UnableToGetFile",
+            cause: "File path not defined"
+          }
+        })
+      )
+    }
+
+    const file_name = file_path.replaceAll("/", "-")
+    const baseUrl = yield* Micro.service(TgBotApiBaseUrl)
+    const botToken = yield* Micro.service(TgBotApiToken)
+
+    const url = `${baseUrl}/file/bot${botToken}/${file_path}`
+
+    const content = yield* Micro.tryPromise({
+      try: () => fetch(url).then((_) => _.arrayBuffer()),
+      catch: (cause) =>
+        new TgBotClientError({
+          cause: { _tag: "UnableToGetFile", cause }
+        })
+    })
+
+    return {
+      content,
+      file_name
+    }
+  })

package/src/client.ts

@@ -0,0 +1,46 @@
+import * as Micro from "effect/Micro"
+import * as Context from "effect/Context"
+
+import type { Api } from "@effect-ak/tg-bot-api"
+import { executeTgBotMethod } from "./execute"
+import { TgBotApiToken } from "./config"
+import { GetFile, ClientFileService } from "./client-file"
+
+export interface TgBotClient {
+  readonly execute: <M extends keyof Api>(
+    method: M,
+    input: Parameters<Api[M]>[0]
+  ) => Promise<ReturnType<Api[M]>>
+  readonly getFile: (input: GetFile) => Promise<File>
+}
+
+interface MakeTgClient {
+  bot_token: string
+}
+
+export function makeTgBotClient(config: MakeTgClient): TgBotClient {
+  return createEffect(config).pipe(Micro.runSync)
+}
+
+const createEffect = ({ bot_token }: MakeTgClient) =>
+  Micro.gen(function* () {
+    const file = yield* Micro.service(ClientFileService)
+    const context = Context.make(TgBotApiToken, bot_token)
+
+    const execute = <M extends keyof Api>(
+      method: M,
+      input: Parameters<Api[M]>[0]
+    ) =>
+      executeTgBotMethod(method, input).pipe(
+        Micro.provideContext(context),
+        Micro.runPromise
+      )
+
+    const getFile = (input: GetFile) =>
+      file.getFile(input).pipe(Micro.provideContext(context), Micro.runPromise)
+
+    return {
+      execute,
+      getFile
+    }
+  }).pipe(Micro.provideContext(ClientFileService.live()))

package/src/config.ts

@@ -0,0 +1,13 @@
+import * as Context from "effect/Context"
+
+import { TG_BOT_API_URL } from "./const"
+
+export class TgBotApiBaseUrl extends Context.Reference<TgBotApiBaseUrl>()(
+  "TgBotApiBaseUrl",
+  { defaultValue: () => TG_BOT_API_URL }
+) {}
+
+export class TgBotApiToken extends Context.Tag("TgBotApiToken")<
+  TgBotApiToken,
+  string
+>() {}

package/src/const.ts

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

@@ -0,0 +1,14 @@
+import * as Data from "effect/Data"
+
+type ErrorReason = Data.TaggedEnum<{
+  NotOkResponse: { errorCode?: number; details?: string }
+  UnexpectedResponse: { response: unknown }
+  ClientInternalError: { cause: unknown }
+  UnableToGetFile: { cause: unknown }
+  BotHandlerError: { cause: unknown }
+  NotJsonResponse: { response: unknown }
+}>
+
+export class TgBotClientError extends Data.TaggedError("TgBotClientError")<{
+  cause: ErrorReason
+}> {}

package/src/execute.ts

@@ -0,0 +1,84 @@
+import * as String from "effect/String"
+import * as Micro from "effect/Micro"
+import type { Api } from "@effect-ak/tg-bot-api"
+
+import { TgBotClientError } from "./errors"
+import { isFileContent, isTgBotApiResponse } from "./guards"
+import { TgBotApiBaseUrl, TgBotApiToken } from "./config"
+
+export const executeTgBotMethod = <M extends keyof Api>(
+  method: M,
+  input: Parameters<Api[M]>[0]
+): Micro.Micro<ReturnType<Api[M]>, TgBotClientError, TgBotApiToken> =>
+  Micro.gen(function* () {
+    const botToken = yield* Micro.service(TgBotApiToken)
+    const baseUrl = yield* Micro.service(TgBotApiBaseUrl)
+
+    const httpResponse = yield* Micro.tryPromise({
+      try: () =>
+        fetch(`${baseUrl}/bot${botToken}/${String.snakeToCamel(method)}`, {
+          body: makePayload(input) ?? null,
+          method: "POST"
+        }),
+      catch: (cause) =>
+        new TgBotClientError({
+          cause: { _tag: "ClientInternalError", cause }
+        })
+    })
+
+    const response = yield* Micro.tryPromise({
+      try: () => httpResponse.json(),
+      catch: () =>
+        new TgBotClientError({
+          cause: { _tag: "NotJsonResponse", response: httpResponse }
+        })
+    })
+
+    if (!isTgBotApiResponse(response)) {
+      return yield* Micro.fail(
+        new TgBotClientError({
+          cause: { _tag: "UnexpectedResponse", response }
+        })
+      )
+    }
+
+    if (!httpResponse.ok) {
+      return yield* Micro.fail(
+        new TgBotClientError({
+          cause: {
+            _tag: "NotOkResponse",
+            ...(response.error_code
+              ? { errorCode: response.error_code }
+              : undefined),
+            ...(response.description
+              ? { details: response.description }
+              : undefined)
+          }
+        })
+      )
+    }
+
+    return response.result as ReturnType<Api[M]>
+  })
+
+export const makePayload = (body: object): FormData | undefined => {
+  const entries = Object.entries(body)
+
+  if (entries.length == 0) return undefined
+
+  const result = new FormData()
+
+  for (const [key, value] of entries) {
+    if (!value) continue
+
+    if (typeof value != "object") {
+      result.append(key, `${value}`)
+    } else if (isFileContent(value)) {
+      result.append(key, new Blob([value.file_content]), value.file_name)
+    } else {
+      result.append(key, JSON.stringify(value))
+    }
+  }
+
+  return result
+}

package/src/guards.ts

@@ -0,0 +1,27 @@
+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/index.ts

@@ -0,0 +1,7 @@
+export * from "./execute"
+export * from "./client-file"
+export * from "./client"
+export * from "./config"
+export * from "./errors"
+export * from "./guards"
+export * from "./const"

package/test/execute.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, assert, vi } from "vitest"
+
+import { fixture } from "./fixture"
+import { MESSAGE_EFFECTS } from "../src/const"
+import { Micro } from "effect"
+import { executeTgBotMethod } from "../src/execute"
+
+const fetchSpy = vi.spyOn(global, "fetch")
+
+describe("telegram bot client, execute method", () => {
+  fixture("send dice", async ({ chat_id, context }) => {
+    // skip();
+
+    const response = await executeTgBotMethod("send_dice", {
+      chat_id,
+      emoji: "🎲",
+      message_effect_id: MESSAGE_EFFECTS["🔥"]
+    }).pipe(Micro.provideContext(context), Micro.runPromiseExit)
+
+    assert(response._tag == "Success")
+
+    const url = fetchSpy.mock.calls[0][0] as string
+    const lastPath = url.split("/").pop()
+
+    expect(lastPath).toEqual("sendDice")
+
+    assert(response != null)
+
+    expect(response.value.chat.id).toBeDefined()
+  })
+
+  fixture("send message", async ({ chat_id, client, skip }) => {
+    skip()
+
+    const response = await client.execute("send_message", {
+      chat_id,
+      text: "hey again",
+      message_effect_id: MESSAGE_EFFECTS["🔥"]
+    })
+
+    expect(response.chat.id).toBeDefined()
+  })
+
+  fixture("send message with keyboard", async ({ chat_id, client, skip }) => {
+    skip()
+
+    const response = await client.execute("send_message", {
+      chat_id,
+      text: "hey again!",
+      message_effect_id: MESSAGE_EFFECTS["🎉"],
+      reply_markup: {
+        inline_keyboard: [
+          [
+            {
+              text: "api documentation",
+              web_app: {
+                url: "https://core.telegram.org/api"
+              }
+            }
+          ]
+        ]
+      }
+    })
+
+    expect(response.chat.id).toBeDefined()
+  })
+
+  fixture("send document", async ({ chat_id, client, skip }) => {
+    skip()
+
+    const response = await client.execute("send_document", {
+      chat_id,
+      message_effect_id: MESSAGE_EFFECTS["🎉"],
+      document: {
+        file_content: Buffer.from("Hello!"),
+        file_name: "hello.txt"
+      },
+      caption: "simple text file"
+    })
+
+    expect(response.document?.file_id).toBeDefined()
+
+    expect(response.chat.id).toBeDefined()
+  })
+
+  fixture("send message with action", async ({ chat_id, client }) => {
+    await client.execute("send_chat_action", {
+      chat_id,
+      action: "upload_voice"
+    })
+
+    await new Promise((res) => setTimeout(res, 5000))
+
+    const response = await client.execute("send_message", {
+      chat_id,
+      text: "hey again with typings",
+      message_effect_id: MESSAGE_EFFECTS["🔥"]
+    })
+
+    expect(response.chat.id).toBeDefined()
+  })
+})

package/test/file.test.ts

@@ -0,0 +1,23 @@
+import { assert, describe, expect } from "vitest"
+
+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", {
+      chat_id,
+      document: {
+        file_content: Buffer.from("Hello!"),
+        file_name: "hello.txt"
+      }
+    })
+
+    const fileId = document.document?.file_id
+
+    assert(fileId, "file id is null")
+
+    const response = await client.getFile({ fileId })
+
+    expect(response).toBeDefined()
+  })
+})

package/test/fixture.ts

@@ -0,0 +1,35 @@
+import { test } from "vitest"
+import { Context } from "effect"
+
+import { makeTgBotClient, TgBotClient } from "../src/client"
+import { TgBotApiToken } from "../src/config"
+
+interface Fixture {
+  readonly token: string
+  readonly client: TgBotClient
+  readonly chat_id: string
+  readonly context: Context.Context<TgBotApiToken>
+}
+
+export const fixture = test.extend<Fixture>({
+  token: async (_, use) => {
+    const token = process.env["bot_token"]
+    if (!token) throw Error("bot_token not defined in config.json")
+    use(token)
+  },
+
+  client: async ({ token }, use) => {
+    const client = makeTgBotClient({
+      bot_token: token
+    })
+    use(client)
+  },
+  chat_id: async (_, use) => {
+    const chatId = process.env["chat_id"]
+    if (!chatId) throw Error("chat_id not defined in config.json")
+    use(chatId)
+  },
+  context: async ({ token }, use) => {
+    use(Context.make(TgBotApiToken, token))
+  }
+})

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["src", "test"],
+  "compilerOptions": {
+    "lib": ["DOM", "ESNext"],
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./src/*"],
+      "~test/*": ["./test/*"]
+    }
+  }
+}

package/tsup.config.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://cdn.jsdelivr.net/npm/tsup/schema.json",
+  "entry": ["src/index.ts"],
+  "outDir": "dist",
+  "format": ["esm", "cjs"],
+  "splitting": false,
+  "sourcemap": false,
+  "clean": true,
+  "dts": true
+}