@qotaq/lalphgram 0.1.0

package/src/services/MessengerAdapter/MessengerAdapter.ts

@@ -0,0 +1,53 @@
+/**
+ * Generic messenger adapter interface for sending and receiving messages
+ * @since 1.0.0
+ */
+import type { Effect, Stream } from "effect"
+import { Context, Data, Schema } from "effect"
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class MessengerAdapterError extends Data.TaggedError("MessengerAdapterError")<{
+  message: string
+  cause: unknown
+}> {}
+
+/**
+ * @since 1.0.0
+ * @category schemas
+ */
+export class IncomingMessage extends Schema.Class<IncomingMessage>("IncomingMessage")({
+  chatId: Schema.String,
+  text: Schema.String,
+  from: Schema.String
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface OutgoingMessage {
+  readonly text: string
+  readonly options?: ReadonlyArray<{ readonly label: string }> | undefined
+  readonly replyKeyboard?: ReadonlyArray<{ readonly label: string }> | undefined
+}
+
+/**
+ * @since 1.0.0
+ * @category services
+ */
+export interface MessengerAdapterService {
+  readonly sendMessage: (message: string | OutgoingMessage) => Effect.Effect<void, MessengerAdapterError>
+  readonly incomingMessages: Stream.Stream<IncomingMessage, MessengerAdapterError>
+}
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export class MessengerAdapter extends Context.Tag("MessengerAdapter")<
+  MessengerAdapter,
+  MessengerAdapterService
+>() {}

package/src/services/MessengerAdapter/TelegramAdapter.ts

@@ -0,0 +1,145 @@
+/**
+ * Telegram messenger adapter using the Telegraf library
+ * @since 1.0.0
+ */
+import { Effect, Layer, Option, Queue, Ref, Stream } from "effect"
+import { Markup, Telegraf } from "telegraf"
+import { TelegramConfig } from "../TelegramConfig.js"
+import { IncomingMessage, MessengerAdapter, MessengerAdapterError, type OutgoingMessage } from "./MessengerAdapter.js"
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const TelegramAdapterLive = Layer.scoped(
+  MessengerAdapter,
+  Effect.gen(function*() {
+    const store = yield* TelegramConfig
+    const config = yield* store.get
+
+    if (Option.isNone(config) || config.value.botToken === "") {
+      return yield* new MessengerAdapterError({
+        message: "Telegram bot token not configured. Run setup first.",
+        cause: null
+      })
+    }
+
+    const bot = new Telegraf(config.value.botToken)
+    const messageQueue = yield* Queue.unbounded<IncomingMessage>()
+    const questionCounter = yield* Ref.make(0)
+
+    const buttonLabels = new Map<string, string>()
+
+    bot.action(/^q:(\d+):(\d+)$/, (ctx) => {
+      const key = `${ctx.match[1]}:${ctx.match[2]}`
+      const label = buttonLabels.get(key) ?? ctx.match[2] ?? ""
+      buttonLabels.delete(key)
+      if (ctx.from != null) {
+        const msg = new IncomingMessage({
+          chatId: String(ctx.chat?.id ?? ""),
+          text: label,
+          from: ctx.from.username ?? ctx.from.first_name
+        })
+        Queue.unsafeOffer(messageQueue, msg)
+      }
+      Effect.runPromise(
+        Effect.tryPromise({
+          try: () => ctx.editMessageText(`${label} ✓`),
+          catch: () => new MessengerAdapterError({ message: "Failed to edit message", cause: null })
+        }).pipe(Effect.orElseSucceed(() => undefined))
+      )
+      return ctx.answerCbQuery()
+    })
+
+    bot.on("message", (ctx) => {
+      const text = "text" in ctx.message ? ctx.message.text : undefined
+      if (text != null && ctx.from != null) {
+        const msg = new IncomingMessage({
+          chatId: String(ctx.chat.id),
+          text,
+          from: ctx.from.username ?? ctx.from.first_name
+        })
+        Queue.unsafeOffer(messageQueue, msg)
+      }
+    })
+
+    yield* Effect.tryPromise({
+      try: () => bot.launch(),
+      catch: (err) =>
+        new MessengerAdapterError({
+          message: `Failed to launch Telegram bot: ${String(err)}`,
+          cause: err
+        })
+    }).pipe(Effect.fork)
+
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        bot.stop("shutdown")
+      })
+    )
+
+    const sendMessage = (message: string | OutgoingMessage) =>
+      Effect.gen(function*() {
+        const currentConfig = yield* store.get
+        const resolvedChatId = Option.isSome(currentConfig) ? currentConfig.value.chatId : null
+        if (resolvedChatId === null) {
+          return yield* new MessengerAdapterError({
+            message: "Telegram chat ID not configured. Run setup first.",
+            cause: null
+          })
+        }
+
+        if (typeof message === "string") {
+          yield* Effect.tryPromise({
+            try: () => bot.telegram.sendMessage(resolvedChatId, message, { parse_mode: "HTML" }),
+            catch: (err) =>
+              new MessengerAdapterError({
+                message: `Failed to send Telegram message: ${String(err)}`,
+                cause: err
+              })
+          })
+        } else if (message.replyKeyboard != null && message.replyKeyboard.length > 0) {
+          const replyMarkup = Markup.keyboard(
+            message.replyKeyboard.map((o) => [Markup.button.text(o.label)])
+          ).resize()
+
+          yield* Effect.tryPromise({
+            try: () =>
+              bot.telegram.sendMessage(resolvedChatId, message.text, {
+                ...replyMarkup,
+                parse_mode: "HTML"
+              }),
+            catch: (err) =>
+              new MessengerAdapterError({
+                message: `Failed to send Telegram message: ${String(err)}`,
+                cause: err
+              })
+          })
+        } else {
+          const qId = yield* Ref.updateAndGet(questionCounter, (n) => n + 1)
+          const buttons = message.options?.map((o, i) => {
+            buttonLabels.set(`${qId}:${i}`, o.label)
+            return [Markup.button.callback(o.label, `q:${qId}:${i}`)]
+          }) ?? []
+          const keyboard = buttons.length > 0 ? Markup.inlineKeyboard(buttons) : undefined
+
+          yield* Effect.tryPromise({
+            try: () =>
+              bot.telegram.sendMessage(resolvedChatId, message.text, {
+                ...keyboard,
+                parse_mode: "HTML"
+              }),
+            catch: (err) =>
+              new MessengerAdapterError({
+                message: `Failed to send Telegram message: ${String(err)}`,
+                cause: err
+              })
+          })
+        }
+      })
+
+    const incomingMessages = Stream.fromQueue(messageQueue)
+
+    return MessengerAdapter.of({ sendMessage, incomingMessages })
+  })
+)