@grom.js/effect-tg 0.4.0 → 0.5.0

package/src/Markup.ts

@@ -0,0 +1,33 @@
+import type * as Option from 'effect/Option'
+import * as Data from 'effect/Data'
+
+/**
+ * Reply markup for the message.
+ */
+export type Markup
+  = | InlineKeyboard
+    | ReplyKeyboard
+    | ReplyKeyboardRemove
+    | ForceReply
+
+export class InlineKeyboard extends Data.TaggedClass('InlineKeyboard')<{
+  rows: [] // TODO
+}> {}
+
+export class ReplyKeyboard extends Data.TaggedClass('ReplyKeyboard')<{
+  rows: [] // TODO
+  persistent: boolean
+  resizable: boolean
+  oneTime: boolean
+  selective: boolean
+  inputPlaceholder: Option.Option<string>
+}> {}
+
+export class ReplyKeyboardRemove extends Data.TaggedClass('ReplyKeyboardRemove')<{
+  selective: boolean
+}> {}
+
+export class ForceReply extends Data.TaggedClass('ForceReply')<{
+  selective: boolean
+  inputPlaceholder: Option.Option<string>
+}> {}

package/src/Runner.ts

@@ -0,0 +1,22 @@
+import type * as Effect from 'effect/Effect'
+import type * as Bot from './Bot.ts'
+import * as internal from './internal/runner.ts'
+
+/**
+ * Runner runs a bot using long polling.
+ */
+export interface Runner<E = never, R = never> {
+  readonly run: {
+    <E1, R1>(bot: Bot.Bot<E1, R1>): Effect.Effect<
+      never,
+      E | E1,
+      R | Exclude<R1, Bot.Update>
+    >
+  }
+}
+
+/**
+ * Creates a simple runner that fetches updates by calling `BotApi.getUpdates`
+ * method and handles them one by one.
+ */
+export const makeSimple = internal.makeSimple

package/src/Send.ts

@@ -0,0 +1,330 @@
+/**
+ * Utilities for sending messages.
+ */
+
+import type * as BotApi from './BotApi.ts'
+import type * as BotApiTransport from './BotApiTransport.ts'
+import type * as Content from './Content.ts'
+import type * as Dialog_ from './Dialog.ts'
+import type * as Markup from './Markup.ts'
+import * as Context from 'effect/Context'
+import * as Data from 'effect/Data'
+import * as Effect from 'effect/Effect'
+import * as Effectable from 'effect/Effectable'
+import * as Function from 'effect/Function'
+import * as Inspectable from 'effect/Inspectable'
+import * as Pipeable from 'effect/Pipeable'
+import * as internal from './internal/send.ts'
+
+// ─── Type ID ──────────────────────────────────────────────────────
+
+const MessageToSendTypeId: unique symbol = Symbol.for('@grom.js/effect-tg/Send/MessageToSend')
+
+// ─── Services ─────────────────────────────────────────────────────
+
+/**
+ * Service providing the target dialog for sending messages.
+ */
+export class Dialog extends Context.Tag('@grom.js/effect-tg/Send/Dialog')<
+  Dialog,
+  Dialog_.Dialog
+>() {}
+
+// ─── Options ──────────────────────────────────────────────────────
+
+/**
+ * Options for sending a message.
+ *
+ * @see {@link https://core.telegram.org/tdlib/docs/classtd_1_1td__api_1_1message_send_options.html td.td_api.messageSendOptions}
+ */
+export class Options extends Data.Class<{
+  disableNotification?: boolean
+  protectContent?: boolean
+  allowPaidBroadcast?: boolean
+}> {}
+
+// ─── Direct Send ──────────────────────────────────────────────────
+
+/**
+ * Sends a message directly with explicit parameters.
+ *
+ * Prefer {@linkcode message} for more composability.
+ *
+ * Example:
+ * ```ts
+ * yield* Send.sendMessage({
+ *   content: new Content.Text({
+ *     text,
+ *     linkPreview: Option.none(),
+ *   }),
+ *   dialog: new Dialog.UserId(userId),
+ *   options: new Send.Options({
+ *     protectContent: true,
+ *   }),
+ * })
+ * ```
+ *
+ * @see {@link https://core.telegram.org/tdlib/docs/classtd_1_1td__api_1_1send_message.html td.td_api.sendMessage}
+ */
+export const sendMessage: (params: {
+  content: Content.Content
+  dialog: Dialog_.Dialog
+  options?: Options
+  markup?: Markup.Markup
+}) => Effect.Effect<
+  BotApi.Types.Message,
+  BotApi.BotApiError | BotApiTransport.BotApiTransportError,
+  BotApi.BotApi
+> = internal.sendMessage
+
+// ─── MessageToSend ────────────────────────────────────────────────
+
+type MessageToSendEffect = Effect.Effect<
+  BotApi.Types.Message,
+  BotApi.BotApiError | BotApiTransport.BotApiTransportError,
+  BotApi.BotApi | Dialog
+>
+
+/**
+ * A message prepared to be sent.
+ */
+export interface MessageToSend extends
+  Inspectable.Inspectable,
+  MessageToSendEffect
+{
+  readonly [MessageToSendTypeId]: typeof MessageToSendTypeId
+  readonly content: Content.Content
+  readonly options: Options
+  readonly markup: Markup.Markup | undefined
+}
+
+const Proto = {
+  [MessageToSendTypeId]: MessageToSendTypeId,
+  ...Effectable.CommitPrototype,
+  ...Inspectable.BaseProto,
+
+  commit(this: MessageToSend): MessageToSendEffect {
+    return Effect.flatMap(
+      Dialog,
+      dialog => sendMessage({
+        dialog,
+        content: this.content,
+        options: this.options,
+        markup: this.markup,
+      }),
+    )
+  },
+
+  toJSON(this: MessageToSend) {
+    return {
+      _id: this[MessageToSendTypeId].description,
+      content: this.content,
+      options: this.options,
+      markup: this.markup,
+    }
+  },
+
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return Pipeable.pipeArguments(this, arguments)
+  },
+}
+
+const make = (args: {
+  content: Content.Content
+  options?: Options
+  markup?: Markup.Markup
+}): MessageToSend => {
+  const self = Object.create(Proto)
+  self.content = args.content
+  self.options = args.options
+  self.markup = args.markup
+  return self
+}
+
+// ─── Constructors ─────────────────────────────────────────────────
+
+/**
+ * Creates a message to send with the given content.
+ *
+ * Example:
+ * ```ts
+ * yield* Send.message(content).pipe(
+ *   Send.withProtection,
+ *   Send.to(dialog),
+ * )
+ * ```
+ */
+export const message = (
+  content: Content.Content,
+): MessageToSend => make({ content })
+
+// ─── Dialog Provider ──────────────────────────────────────────────
+
+export const to: {
+  /**
+   * Provides the target dialog for sending messages.
+   *
+   * Example:
+   * ```ts
+   * // Per-message
+   * yield* Send.message(content).pipe(
+   *   Send.withProtection,
+   *   Send.to(dialog),
+   * )
+   *
+   * // For entire handler (multiple sends)
+   * const handler = Effect.gen(function* () {
+   *   yield* Send.message(content1)
+   *   yield* Send.message(content2)
+   * }).pipe(Send.to(dialog))
+   * ```
+   */
+  (dialog: Dialog_.Dialog): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Dialog>>
+  <A, E, R>(effect: Effect.Effect<A, E, R>, dialog: Dialog_.Dialog): Effect.Effect<A, E, Exclude<R, Dialog>>
+} = Function.dual(2, <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+  dialog: Dialog_.Dialog,
+): Effect.Effect<A, E, Exclude<R, Dialog>> => (
+  Effect.provideService(effect, Dialog, dialog)
+))
+
+// ─── Options Combinators ──────────────────────────────────────────
+
+/**
+ * Modifies the options for sending a message by merging with existing options.
+ *
+ * Example:
+ * ```ts
+ * yield* Send.message(content).pipe(
+ *   Send.withOptions({
+ *     disableNotification: true,
+ *     protectContent: true,
+ *   }),
+ *   Send.to(dialog),
+ * )
+ * ```
+ *
+ * Available shortcuts:
+ * - {@linkcode withoutNotification}
+ * - {@linkcode withNotification}
+ * - {@linkcode withoutContentProtection}
+ * - {@linkcode withContentProtection}
+ * - {@linkcode withoutPaidBroadcast}
+ * - {@linkcode withPaidBroadcast}
+ */
+export const withOptions: {
+  (options: Options): (self: MessageToSend) => MessageToSend
+  (self: MessageToSend, options: Options): MessageToSend
+} = Function.dual(2, (
+  self: MessageToSend,
+  options: Options,
+): MessageToSend => (
+  make(
+    {
+      content: self.content,
+      options: new Options({
+        ...self.options,
+        ...options,
+      }),
+      markup: self.markup,
+    },
+  )
+))
+
+/**
+ * Disables notification for the message.
+ *
+ * Shortcut for `withOptions({ disableNotification: true })`.
+ */
+export const withoutNotification: (
+  self: MessageToSend,
+) => MessageToSend = withOptions({ disableNotification: true })
+
+/**
+ * Enables notification for the message.
+ *
+ * Shortcut for `withOptions({ disableNotification: false })`.
+ */
+export const withNotification: (
+  self: MessageToSend,
+) => MessageToSend = withOptions({ disableNotification: false })
+
+/**
+ * Allows message content to be saved and forwarded.
+ *
+ * Shortcut for `withOptions({ protectContent: false })`.
+ */
+export const withoutContentProtection: (
+  self: MessageToSend,
+) => MessageToSend = withOptions({ protectContent: false })
+
+/**
+ * Protects message content from saving and forwarding.
+ *
+ * Shortcut for `withOptions({ protectContent: true })`.
+ */
+export const withContentProtection: (
+  self: MessageToSend,
+) => MessageToSend = withOptions({ protectContent: true })
+
+/**
+ * Disallows paid broadcast for the message.
+ *
+ * Shortcut for `withOptions({ allowPaidBroadcast: false })`.
+ */
+export const withoutPaidBroadcast: (
+  self: MessageToSend,
+) => MessageToSend = withOptions({ allowPaidBroadcast: false })
+
+/**
+ * Allows paid broadcast for the message.
+ *
+ * Shortcut for `withOptions({ allowPaidBroadcast: true })`.
+ */
+export const withPaidBroadcast: (
+  self: MessageToSend,
+) => MessageToSend = withOptions({ allowPaidBroadcast: true })
+
+// ─── Markup Combinators ──────────────────────────────────────────
+
+/**
+ * Sets the reply markup for the message.
+ *
+ * Example:
+ * ```ts
+ * yield* Send.message(content).pipe(
+ *   Send.withMarkup(
+ *     new Markup.ForceReply({
+ *       selective: false,
+ *       inputPlaceholder: Option.some("effect-tg or grammY?"),
+ *     }),
+ *   ),
+ *   Send.to(dialog),
+ * )
+ * ```
+ */
+export const withMarkup: {
+  (markup: Markup.Markup): (self: MessageToSend) => MessageToSend
+  (self: MessageToSend, markup: Markup.Markup): MessageToSend
+} = Function.dual(2, (
+  self: MessageToSend,
+  markup: Markup.Markup,
+): MessageToSend => (
+  make({
+    content: self.content,
+    options: self.options,
+    markup,
+  })
+))
+
+/**
+ * Removes the reply markup from the message.
+ */
+export const withoutMarkup: (
+  self: MessageToSend,
+) => MessageToSend = self => make({
+  content: self.content,
+  options: self.options,
+  markup: undefined,
+})

package/src/Text.ts

@@ -0,0 +1,42 @@
+import type { TgxElement } from '@grom.js/tgx/types'
+import type { Types } from './BotApi.ts'
+import * as Data from 'effect/Data'
+
+/**
+ * Formatted text.
+ */
+export type Text
+  = | Plain
+    | Html
+    | Markdown
+    | Tgx
+
+export class Plain extends Data.TaggedClass('Plain')<{
+  text: string
+  entities?: Array<Types.MessageEntity>
+}> {}
+
+export class Html extends Data.TaggedClass('Html')<{
+  html: string
+}> {}
+
+export class Markdown extends Data.TaggedClass('Markdown')<{
+  markdown: string
+}> {}
+
+export class Tgx extends Data.TaggedClass('Tgx')<{
+  tgx: TgxElement
+}> {}
+
+// ———— Constructors ———————————————————————————————————————————————————————————
+
+export const plain = (
+  text: string,
+  entities?: Array<Types.MessageEntity>,
+): Plain => new Plain({ text, entities })
+
+export const html = (html: string): Html => new Html({ html })
+
+export const markdown = (markdown: string): Markdown => new Markdown({ markdown })
+
+export const tgx = (tgx: TgxElement): Tgx => new Tgx({ tgx })

package/src/index.ts

@@ -0,0 +1,12 @@
+export * as Bot from './Bot.ts'
+export * as BotApi from './BotApi.ts'
+export * as BotApiTransport from './BotApiTransport.ts'
+export * as BotApiUrl from './BotApiUrl.ts'
+export * as Content from './Content.ts'
+export * as Dialog from './Dialog.ts'
+export * as File from './File.ts'
+export * as LinkPreview from './LinkPreview.ts'
+export * as Markup from './Markup.ts'
+export * as Runner from './Runner.ts'
+export * as Send from './Send.ts'
+export * as Text from './Text.ts'

package/src/internal/botApi.ts

@@ -0,0 +1,31 @@
+import type * as BotApiTransport from '../BotApiTransport.ts'
+import * as Effect from 'effect/Effect'
+import * as BotApi from '../BotApi.ts'
+
+export const make = (
+  transport: BotApiTransport.BotApiTransport.Service,
+): BotApi.BotApi.Service => (
+  new Proxy({}, {
+    get: (_target, prop) => {
+      if (typeof prop !== 'string') {
+        return
+      }
+      const method = prop
+      return Effect.fnUntraced(
+        function* (params: void | Record<string, unknown> = {}) {
+          const response = yield* transport.sendRequest(method, params)
+          if (response.ok) {
+            return response.result
+          }
+          return yield* Effect.fail(
+            new BotApi.BotApiError({
+              code: response.error_code,
+              description: response.description,
+              parameters: response.parameters,
+            }),
+          )
+        },
+      )
+    },
+  }) as BotApi.BotApi.Service
+)