@grom.js/effect-tg 0.8.0 → 0.9.0

package/src/internal/botApi.ts

@@ -3,9 +3,11 @@ import type * as BotApiTransport from '../BotApiTransport.ts'
 import * as Effect from 'effect/Effect'
 import * as BotApiError from '../BotApiError.ts'
 
-export const make = (
-  transport: BotApiTransport.BotApiTransport.Service,
-): BotApi.BotApi.Service => (
+export const make = ({
+  transport,
+}: {
+  transport: BotApiTransport.Service
+}): BotApi.Service => (
   new Proxy({}, {
     get: (_target, prop) => {
       if (typeof prop !== 'string') {
@@ -18,15 +20,9 @@ export const make = (
           if (response.ok) {
             return response.result
           }
-          return yield* Effect.fail(
-            new BotApiError.BotApiError({
-              code: response.error_code,
-              description: response.description,
-              parameters: response.parameters,
-            }),
-          )
+          return yield* Effect.fail(BotApiError.fromResponse(response))
         },
       )
     },
-  }) as BotApi.BotApi.Service
+  }) as BotApi.Service
 )

package/src/internal/botApiError.ts

@@ -1,36 +1,31 @@
-import * as Duration from 'effect/Duration'
-import * as BotApiError from '../BotApiError.ts'
+import type { MethodFailureReason } from '../BotApiError.ts'
 
-export const narrow = (
-  error: BotApiError.BotApiError,
-): BotApiError.KnownError | BotApiError.BotApiError => {
-  const code = error.code
-  const msg = error.message.toLowerCase()
-  const params = error.parameters
-  if (code === 429 && params?.retry_after != null) {
-    return new BotApiError.TooManyRequests({
-      cause: error,
-      retryAfter: Duration.seconds(params.retry_after),
-    })
-  }
+export const guessReason = ({
+  code,
+  description,
+}: {
+  code: number
+  description: string
+}): MethodFailureReason => {
+  const msg = description.toLowerCase()
   if (code === 403) {
     if (msg.includes('bot was blocked by the user')) {
-      return new BotApiError.BotBlockedByUser({ cause: error })
+      return 'BotBlockedByUser'
     }
   }
   if (code === 400) {
     if (msg.includes('message is not modified')) {
-      return new BotApiError.MessageNotModified({ cause: error })
+      return 'MessageNotModified'
     }
     if (msg.includes('reply markup too long')) {
-      return new BotApiError.ReplyMarkupTooLong({ cause: error })
+      return 'ReplyMarkupTooLong'
     }
     if (msg.includes('query is too old') && msg.includes('query id is invalid')) {
-      return new BotApiError.QueryIdInvalid({ cause: error })
+      return 'QueryIdInvalid'
     }
     if (msg.includes('can\'t use the media of the specified type in the album')) {
-      return new BotApiError.MediaGroupedInvalid({ cause: error })
+      return 'MediaGroupedInvalid'
     }
   }
-  return error
+  return 'Unknown'
 }

package/src/internal/botApiTransport.ts

@@ -1,10 +1,11 @@
 import type * as HttpClient from '@effect/platform/HttpClient'
+import type * as BotApiTransport from '../BotApiTransport.ts'
 import type * as BotApiUrl from '../BotApiUrl.ts'
 import * as HttpBody from '@effect/platform/HttpBody'
 import * as Chunk from 'effect/Chunk'
 import * as Effect from 'effect/Effect'
 import * as Stream from 'effect/Stream'
-import * as BotApiTransport from '../BotApiTransport.ts'
+import * as BotApiError from '../BotApiError.ts'
 import * as File from '../File.ts'
 
 interface ExtractedFile {
@@ -13,13 +14,16 @@ interface ExtractedFile {
 }
 
 /**
- * Recursively checks whether a value contains {@linkcode File.InputFile} instances.
+ * Recursively checks whether a value contains
+ * {@linkcode File.InputFile InputFile} instances.
  */
 const hasInputFile = (value: unknown): boolean => {
-  if (value instanceof File.InputFile)
+  if (value instanceof File.InputFile) {
     return true
-  if (Array.isArray(value))
+  }
+  if (Array.isArray(value)) {
     return value.some(hasInputFile)
+  }
   if (typeof value === 'object' && value !== null) {
     return Object.values(value).some(hasInputFile)
   }
@@ -49,8 +53,9 @@ const cloneAndExtract = (
 }
 
 /**
- * Deep clones params, replacing {@linkcode InputFile} instances with
- * `attach://{id}` strings and collecting them into the files array.
+ * Clones parameters deeply, replacing {@linkcode File.InputFile InputFile}
+ * instances with `attach://{id}` strings and collecting them into
+ * the files array.
  */
 const extractFiles = (params: unknown): {
   params: Record<string, unknown>
@@ -81,8 +86,9 @@ const makeHttpBody = Effect.fnUntraced(function* (params: unknown) {
   const { params: processedParams, files } = extractFiles(params)
   const formData = new FormData()
   for (const [key, value] of Object.entries(processedParams)) {
-    if (value == null)
+    if (value == null) {
       continue
+    }
     const serialized = typeof value === 'string' ? value : JSON.stringify(value)
     formData.append(key, serialized)
   }
@@ -97,10 +103,13 @@ const makeHttpBody = Effect.fnUntraced(function* (params: unknown) {
   return HttpBody.formData(formData)
 })
 
-export const make = (
-  httpClient: HttpClient.HttpClient,
-  botApiUrl: BotApiUrl.BotApiUrl.Service,
-): BotApiTransport.BotApiTransport.Service => ({
+export const make = ({
+  httpClient,
+  botApiUrl,
+}: {
+  httpClient: HttpClient.HttpClient
+  botApiUrl: BotApiUrl.Service
+}): BotApiTransport.Service => ({
   sendRequest: (method, params) => (
     Effect.gen(function* () {
       const body = yield* makeHttpBody(params)
@@ -108,11 +117,10 @@ export const make = (
       const responseJson = yield* response.json
       // We trust Bot API and don't want to introduce overhead with validation.
       return responseJson as BotApiTransport.BotApiResponse
-    })
-      .pipe(
-        Effect.catchAll(cause => (
-          Effect.fail(new BotApiTransport.BotApiTransportError({ cause }))
-        )),
-      )
+    }).pipe(
+      Effect.catchAll(cause => (
+        Effect.fail(new BotApiError.TransportError({ cause }))
+      )),
+    )
   ),
 })

package/src/internal/dialog.ts

@@ -1,33 +1,116 @@
-export function PeerId<Tag extends string>({
-  tag,
-  isValid,
-  toDialogId,
-}: {
-  tag: Tag
-  isValid: (peerId: number) => boolean
-  toDialogId: (peerId: number) => number
-}): {
-  new (id: number): {
-    readonly _tag: Tag
-    readonly id: number
-    readonly dialogId: number
+import type * as BotApi from '../BotApi.ts'
+import * as Option from 'effect/Option'
+import * as Dialog from '../Dialog.ts'
+
+// =============================================================================
+// Dialog ID <-> Peer ID
+// =============================================================================
+
+export const decodeDialogId = (dialogId: number): Option.Option<
+  | { peer: 'user', id: Dialog.UserId }
+  | { peer: 'group', id: Dialog.GroupId }
+  | { peer: 'supergroup', id: Dialog.SupergroupId }
+  | { peer: 'monoforum', id: number }
+  | { peer: 'secret-chat', id: number }
+> => {
+  if (Number.isSafeInteger(dialogId)) {
+    if (1 <= dialogId && dialogId <= 0xFFFFFFFFFF) {
+      return Option.some({ peer: 'user', id: +dialogId as Dialog.UserId })
+    }
+    if (-999999999999 <= dialogId && dialogId <= -1) {
+      return Option.some({ peer: 'group', id: -dialogId as Dialog.GroupId })
+    }
+    if (-1997852516352 <= dialogId && dialogId <= -1000000000001) {
+      return Option.some({ peer: 'supergroup', id: -(dialogId + 1000000000000) as Dialog.SupergroupId })
+    }
+    if (-4000000000000 <= dialogId && dialogId <= -2002147483649) {
+      return Option.some({ peer: 'monoforum', id: -(dialogId + 1000000000000) })
+    }
+    if (-2002147483648 <= dialogId && dialogId <= -1997852516353) {
+      return Option.some({ peer: 'secret-chat', id: dialogId + 2000000000000 })
+    }
+  }
+  return Option.none()
+}
+
+export const decodePeerId: {
+  (peer: 'user', dialogId: number): Option.Option<Dialog.UserId>
+  (peer: 'group', dialogId: number): Option.Option<Dialog.GroupId>
+  (peer: 'supergroup', dialogId: number): Option.Option<Dialog.SupergroupId>
+  (peer: 'monoforum', dialogId: number): Option.Option<number>
+  (peer: 'secret-chat', dialogId: number): Option.Option<number>
+} = (peer, dialogId) => {
+  const decoded = decodeDialogId(dialogId)
+  if (Option.isSome(decoded) && decoded.value.peer === peer) {
+    return Option.some(decoded.value.id as any)
+  }
+  return Option.none()
+}
+
+export const encodePeerId = (
+  peer: 'user' | 'group' | 'supergroup' | 'monoforum' | 'secret-chat',
+  id: number,
+): Option.Option<Dialog.DialogId> => {
+  if (Number.isSafeInteger(id)) {
+    if (peer === 'user' && 1 <= id && id <= 0xFFFFFFFFFF) {
+      return Option.some(id as Dialog.DialogId)
+    }
+    if (peer === 'group' && 1 <= id && id <= 999999999999) {
+      return Option.some(-id as Dialog.DialogId)
+    }
+    if (peer === 'supergroup' && 1 <= id && id <= 997852516352) {
+      return Option.some(-(id + 1000000000000) as Dialog.DialogId)
+    }
+    if (peer === 'monoforum' && 1002147483649 <= id && id <= 3000000000000) {
+      return Option.some(-(id + 1000000000000) as Dialog.DialogId)
+    }
+    if (peer === 'secret-chat' && -2147483648 <= id && id <= 2147483647) {
+      return Option.some((id - 2000000000000) as Dialog.DialogId)
+    }
   }
-} {
-  class Base {
-    public readonly _tag = tag
-    public readonly id: number
-    public readonly dialogId: number
+  return Option.none()
+}
+
+// =============================================================================
+// Constructors
+// =============================================================================
 
-    constructor(id: number) {
-      if (!Number.isSafeInteger(id)) {
-        throw new TypeError(`invalid integer: ${id}`)
+export const ofMessage: (
+  message: BotApi.Types.Message,
+) => Dialog.Dialog = (m) => {
+  // TODO: Remove type assertion when bot-api-spec updates types.
+  switch (m.chat.type as 'private' | 'group' | 'supergroup' | 'channel') {
+    case 'private': {
+      const user = new Dialog.User({
+        id: Option.getOrThrow(decodePeerId('user', m.chat.id)),
+      })
+      if (m.message_thread_id != null) {
+        return user.topic(m.message_thread_id)
+      }
+      return user
+    }
+    case 'group': {
+      return new Dialog.Group({
+        id: Option.getOrThrow(decodePeerId('group', m.chat.id)),
+      })
+    }
+    case 'supergroup': {
+      const supergroup = new Dialog.Supergroup({
+        id: Option.getOrThrow(decodePeerId('supergroup', m.chat.id)),
+      })
+      if (m.message_thread_id != null) {
+        return supergroup.topic(m.message_thread_id)
       }
-      if (!isValid(id)) {
-        throw new Error(`invalid peer id: ${id}`)
+      return supergroup
+    }
+    case 'channel': {
+      const channel = new Dialog.Channel({
+        id: Option.getOrThrow(decodePeerId('supergroup', m.chat.id)),
+      })
+      if (m.direct_messages_topic != null) {
+        return channel.directMessages(m.direct_messages_topic.topic_id)
       }
-      this.id = id
-      this.dialogId = toDialogId(id)
+      return channel
     }
   }
-  return Base
 }

package/src/internal/file.ts

@@ -4,7 +4,7 @@ import * as Effect from 'effect/Effect'
 import * as BotApi from '../BotApi.ts'
 import * as BotApiUrl from '../BotApiUrl.ts'
 
-export const get = Effect.fnUntraced(
+export const download = Effect.fnUntraced(
   function* (fileId: FileId) {
     const file = yield* BotApi.callMethod('getFile', { file_id: fileId })
     if (file.file_path == null) {

package/src/internal/runner.ts

@@ -1,54 +1,50 @@
-import type { BotApiError } from '../BotApiError.ts'
-import type { BotApiTransportError } from '../BotApiTransport.ts'
-import type { Runner } from '../Runner.ts'
+import type * as BotApiError from '../BotApiError.ts'
+import type * as Runner from '../Runner.ts'
 import * as Duration from 'effect/Duration'
 import * as Effect from 'effect/Effect'
 import * as Match from 'effect/Match'
 import * as Schedule from 'effect/Schedule'
-import { Update } from '../Bot.ts'
-import { BotApi } from '../BotApi.ts'
+import * as Bot from '../Bot.ts'
+import * as BotApi from '../BotApi.ts'
 
 export const makeSimple = (options?: {
   allowedUpdates?: string[]
-}): Runner<BotApiError | BotApiTransportError, BotApi> => ({
+}): Runner.Runner<BotApiError.BotApiError, BotApi.BotApi> => ({
   run: Effect.fnUntraced(
     function* (bot) {
       const { allowedUpdates } = options ?? {}
-      const api = yield* BotApi
+      const api = yield* BotApi.BotApi
       let lastUpdateId: undefined | number
       while (true) {
-        const [update] = yield* api
-          .getUpdates({
-            offset: lastUpdateId == null ? undefined : lastUpdateId + 1,
-            allowed_updates: allowedUpdates,
-            timeout: 30,
-            limit: 1,
-          })
-          .pipe(
-            Effect.retry({
-              schedule: Schedule.spaced(Duration.seconds(3)),
-              while: error => Match.value(error).pipe(
-                Match.tagsExhaustive({
-                  '@grom.js/effect-tg/BotApiError': error => Effect.succeed(
-                    error.code >= 500 || (
-                      error.code !== 401
-                      && error.code !== 403
-                      && error.code !== 404
-                    ),
-                  ),
-                  '@grom.js/effect-tg/BotApiTransport/BotApiTransportError': () => Effect.succeed(true),
-                }),
-              ),
-            }),
-          )
-        if (update) {
-          yield* Effect
-            .provideService(bot, Update, update)
-            .pipe(
-              Effect.catchAll(error => (
-                Effect.logError('Error in bot:', error)
+        const updates = yield* api.getUpdates({
+          offset: lastUpdateId == null ? undefined : lastUpdateId + 1,
+          allowed_updates: allowedUpdates,
+          timeout: 30,
+          limit: 1,
+        }).pipe(
+          Effect.retry({
+            schedule: Schedule.exponential(Duration.millis(100)),
+            while: e => Match.value(e).pipe(
+              Match.tag('InternalServerError', () => true),
+              Match.tag('TransportError', e => Match.value(e.cause).pipe(
+                Match.tag('RequestError', e => e.reason === 'Transport'),
+                Match.orElse(() => false),
               )),
-            )
+              Match.orElse(() => false),
+            ),
+          }),
+          Effect.catchTag('RateLimited', e => Effect.gen(function* () {
+            yield* Effect.sleep(e.retryAfter)
+            return []
+          })),
+        )
+        if (updates.length > 0) {
+          const update = updates[0]!
+          yield* Effect.provideService(bot, Bot.Update, update).pipe(
+            Effect.catchAll(error => (
+              Effect.logError('Error in bot:', error)
+            )),
+          )
           lastUpdateId = update.update_id
         }
       }