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

package/src/client.ts

@@ -1,10 +1,7 @@
-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"
+import type { TgBotConfig } from "./config"
+import { getFile as getFileImpl, type GetFile } from "./client-file"
 
 export interface TgBotClient {
   readonly execute: <M extends keyof Api>(
@@ -14,33 +11,24 @@ export interface TgBotClient {
   readonly getFile: (input: GetFile) => Promise<File>
 }
 
-interface MakeTgClient {
+export interface MakeTgClient {
   bot_token: string
+  base_url?: 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 tgConfig: TgBotConfig = {
+    botToken: config.bot_token,
+    ...(config.base_url ? { baseUrl: config.base_url } : {})
+  }
 
-    const getFile = (input: GetFile) =>
-      file.getFile(input).pipe(Micro.provideContext(context), Micro.runPromise)
+  const execute = <M extends keyof Api>(
+    method: M,
+    input: Parameters<Api[M]>[0]
+  ) => executeTgBotMethod({ config: tgConfig, method, input })
 
-    return {
-      execute,
-      getFile
-    }
-  }).pipe(Micro.provideContext(ClientFileService.live()))
+  return {
+    execute,
+    getFile: (input: GetFile) => getFileImpl(input, { config: tgConfig, execute })
+  }
+}

package/src/config.ts

@@ -1,13 +1,10 @@
-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 interface TgBotConfig {
+  botToken: string
+  baseUrl?: string
+}
 
-export class TgBotApiToken extends Context.Tag("TgBotApiToken")<
-  TgBotApiToken,
-  string
->() {}
+export const getBaseUrl = (config?: Pick<TgBotConfig, "baseUrl">): string => {
+  return config?.baseUrl ?? TG_BOT_API_URL
+}

package/src/errors.ts

@@ -1,14 +1,18 @@
-import * as Data from "effect/Data"
+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 }
 
-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 Error {
+  readonly _tag = "TgBotClientError"
+  readonly cause: ErrorReason
 
-export class TgBotClientError extends Data.TaggedError("TgBotClientError")<{
-  cause: ErrorReason
-}> {}
+  constructor(options: { cause: ErrorReason }) {
+    super(`TgBotClientError: ${options.cause._tag}`)
+    this.cause = options.cause
+    this.name = "TgBotClientError"
+  }
+}

package/src/execute.ts

@@ -1,65 +1,62 @@
-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"
+import type { TgBotConfig } from "./config"
+import { getBaseUrl } from "./config"
+import { snakeToCamel } from "./utils"
 
-export const executeTgBotMethod = <M extends keyof Api>(
-  method: M,
+export async function executeTgBotMethod<M extends keyof Api>(params: {
+  config: TgBotConfig
+  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)
+}): Promise<ReturnType<Api[M]>> {
+  const { config, method, input } = params
+  const baseUrl = getBaseUrl(config)
+  const botToken = config.botToken
 
-    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 }
-        })
+  let httpResponse: Response
+  try {
+    httpResponse = await fetch(
+      `${baseUrl}/bot${botToken}/${snakeToCamel(method)}`,
+      {
+        body: makePayload(input) ?? null,
+        method: "POST"
+      }
+    )
+  } catch (cause) {
+    throw new TgBotClientError({
+      cause: { _tag: "ClientInternalError", cause }
     })
+  }
 
-    const response = yield* Micro.tryPromise({
-      try: () => httpResponse.json(),
-      catch: () =>
-        new TgBotClientError({
-          cause: { _tag: "NotJsonResponse", response: httpResponse }
-        })
+  let response: unknown
+  try {
+    response = await httpResponse.json()
+  } catch {
+    throw new TgBotClientError({
+      cause: { _tag: "NotJsonResponse", response: httpResponse }
     })
+  }
 
-    if (!isTgBotApiResponse(response)) {
-      return yield* Micro.fail(
-        new TgBotClientError({
-          cause: { _tag: "UnexpectedResponse", response }
-        })
-      )
-    }
+  if (!isTgBotApiResponse(response)) {
+    throw 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)
-          }
-        })
-      )
-    }
+  if (!httpResponse.ok) {
+    throw new TgBotClientError({
+      cause: {
+        _tag: "NotOkResponse",
+        ...(response.error_code ? { errorCode: response.error_code } : {}),
+        ...(response.description ? { details: response.description } : {})
+      }
+    })
+  }
 
-    return response.result as ReturnType<Api[M]>
-  })
+  return response.result as ReturnType<Api[M]>
+}
 
 export const makePayload = (body: object): FormData | undefined => {
   const entries = Object.entries(body)

package/src/index.ts

@@ -5,3 +5,4 @@ export * from "./config"
 export * from "./errors"
 export * from "./guards"
 export * from "./const"
+export * from "./utils"

package/src/utils.ts

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