@grom.js/effect-tg 0.8.0 → 0.9.0

package/src/BotApiError.ts

@@ -1,81 +1,127 @@
-import type * as Duration from 'effect/Duration'
-import type * as BotApi from './BotApi.ts'
+import type * as HttpBody from '@effect/platform/HttpBody'
+import type * as HttpClientError from '@effect/platform/HttpClientError'
+import type * as BotApiTransport from './BotApiTransport.ts'
 import * as Data from 'effect/Data'
+import * as Duration from 'effect/Duration'
+import * as Match from 'effect/Match'
+import * as Option from 'effect/Option'
+import * as Predicate from 'effect/Predicate'
+import * as Dialog from './Dialog.ts'
 import * as internal from './internal/botApiError.ts'
 
+export const TypeId = '@grom.js/effect-tg/BotApiError'
+
+export type TypeId = typeof TypeId
+
+export const isBotApiError = (u: unknown): u is BotApiError => Predicate.hasProperty(u, TypeId)
+
+export type BotApiError =
+  | TransportError
+  | MethodFailed
+  | GroupUpgraded
+  | RateLimited
+  | InternalServerError
+
 /**
- * Error returned from the Bot API server in case of unsuccessful method call.
+ * Error caused by the transport when accessing Bot API.
  */
-export class BotApiError extends Data.TaggedError('@grom.js/effect-tg/BotApiError')<{
-  code: number
-  description: string
-  parameters?: BotApi.Types.ResponseParameters
+export class TransportError extends Data.TaggedError('TransportError')<{
+  cause:
+    | HttpClientError.HttpClientError
+    | HttpBody.HttpBodyError
 }> {
+  readonly [TypeId]: TypeId = TypeId
+
   override get message() {
-    return `(${this.code}) ${this.description}`
+    return Match.value(this.cause).pipe(
+      Match.tagsExhaustive({
+        RequestError: e => e.message,
+        ResponseError: e => e.message,
+        HttpBodyError: e => Match.value(e.reason).pipe(
+          Match.tagsExhaustive({
+            SchemaError: e => e.error.message,
+            JsonError: e => `JsonError: ${e.error}`,
+          }),
+        ),
+      }),
+    )
   }
 }
 
-/**
- * Attempts to narrow a {@link BotApiError} to a more specific {@link KnownError}.
- *
- * **Warning!** Error types are detected based on the error code and message
- * returned from the Bot API, which are not guaranteed to be the same in
- * the future. If they change, this function may not determine error type
- * correctly.
- *
- * @see {@link https://github.com/tdlib/telegram-bot-api telegram-bot-api source code}
- */
-export const narrow: (error: BotApiError) => KnownError | BotApiError = internal.narrow
+export class MethodFailed extends Data.TaggedError('MethodFailed')<{
+  response: FailureResponse
+  possibleReason: MethodFailureReason
+}> {
+  readonly [TypeId]: TypeId = TypeId
+
+  override get message() {
+    return `(${this.response.error_code}) ${this.response.description}`
+  }
+}
 
-export type KnownError
-  = | TooManyRequests
-    | BotBlockedByUser
-    | MessageNotModified
-    | ReplyMarkupTooLong
-    | QueryIdInvalid
-    | MediaGroupedInvalid
+export class GroupUpgraded extends Data.TaggedError('GroupUpgraded')<{
+  response: FailureResponse
+  supergroup: Dialog.Supergroup
+}> {
+  readonly [TypeId]: TypeId = TypeId
 
-/**
- * Flood limit exceeded. Need to wait `retryAfter` before retrying.
- */
-export class TooManyRequests extends Data.TaggedError('@grom.js/effect-tg/BotApiError/TooManyRequests')<{
-  cause: BotApiError
+  override get message() {
+    return `Group has been upgraded to a supergroup with ID ${this.supergroup.id}.`
+  }
+}
+
+export class RateLimited extends Data.TaggedError('RateLimited')<{
+  response: FailureResponse
   retryAfter: Duration.Duration
-}> {}
+}> {
+  readonly [TypeId]: TypeId = TypeId
 
-/**
- * Bot was blocked by the user.
- */
-export class BotBlockedByUser extends Data.TaggedError('@grom.js/effect-tg/BotApiError/BotBlockedByUser')<{
-  cause: BotApiError
-}> {}
+  override get message() {
+    return `Flood limit exceeded. Should wait for ${Duration.format(this.retryAfter)} before retrying.`
+  }
+}
 
-/**
- * Message was not modified as its content and reply markup
- * are exactly the same as the current one.
- */
-export class MessageNotModified extends Data.TaggedError('@grom.js/effect-tg/BotApiError/MessageNotModified')<{
-  cause: BotApiError
-}> {}
+export class InternalServerError extends Data.TaggedError('InternalServerError')<{
+  response: FailureResponse
+}> {
+  readonly [TypeId]: TypeId = TypeId
+}
 
-/**
- * Message reply markup is too long.
- */
-export class ReplyMarkupTooLong extends Data.TaggedError('@grom.js/effect-tg/BotApiError/ReplyMarkupTooLong')<{
-  cause: BotApiError
-}> {}
+export const fromResponse = (response: FailureResponse): BotApiError => {
+  if (response.error_code === 429 && response.parameters?.retry_after != null) {
+    return new RateLimited({
+      response,
+      retryAfter: Duration.seconds(response.parameters.retry_after),
+    })
+  }
+  if (response.error_code === 400 && response.parameters?.migrate_to_chat_id != null) {
+    return new GroupUpgraded({
+      response,
+      supergroup: Dialog.supergroup(
+        Option.getOrThrow(
+          Dialog.decodePeerId('supergroup', response.parameters.migrate_to_chat_id),
+        ),
+      ),
+    })
+  }
+  if (response.error_code >= 500) {
+    return new InternalServerError({ response })
+  }
+  return new MethodFailed({
+    response,
+    possibleReason: internal.guessReason({
+      code: response.error_code,
+      description: response.description,
+    }),
+  })
+}
 
-/**
- * Query has expired, or ID is invalid.
- */
-export class QueryIdInvalid extends Data.TaggedError('@grom.js/effect-tg/BotApiError/QueryIdInvalid')<{
-  cause: BotApiError
-}> {}
+export type MethodFailureReason =
+  | 'Unknown'
+  | 'BotBlockedByUser'
+  | 'MessageNotModified'
+  | 'ReplyMarkupTooLong'
+  | 'QueryIdInvalid'
+  | 'MediaGroupedInvalid'
 
-/**
- * Invalid combination of media types in the media group.
- */
-export class MediaGroupedInvalid extends Data.TaggedError('@grom.js/effect-tg/BotApiError/MediaGroupedInvalid')<{
-  cause: BotApiError
-}> {}
+type FailureResponse = Extract<BotApiTransport.BotApiResponse, { ok: false }>

package/src/BotApiTransport.ts

@@ -1,7 +1,7 @@
-import type * as Types from './internal/botApiTypes.gen.ts'
+import type * as BotApi from './BotApi.ts'
+import type * as BotApiError from './BotApiError.ts'
 import * as HttpClient from '@effect/platform/HttpClient'
 import * as Context from 'effect/Context'
-import * as Data from 'effect/Data'
 import * as Effect from 'effect/Effect'
 import * as Layer from 'effect/Layer'
 import * as BotApiUrl from './BotApiUrl.ts'
@@ -9,23 +9,21 @@ import * as internal from './internal/botApiTransport.ts'
 
 export class BotApiTransport extends Context.Tag('@grom.js/effect-tg/BotApiTransport')<
   BotApiTransport,
-  BotApiTransport.Service
+  Service
 >() {}
 
-export declare namespace BotApiTransport {
-  export interface Service {
-    sendRequest: (
-      method: string,
-      params: unknown,
-    ) => Effect.Effect<BotApiResponse, BotApiTransportError>
-  }
+export interface Service {
+  sendRequest: (
+    method: string,
+    params: unknown,
+  ) => Effect.Effect<BotApiResponse, BotApiError.TransportError>
 }
 
 /**
  * @see https://core.telegram.org/bots/api#making-requests
  */
-export type BotApiResponse
-  = {
+export type BotApiResponse =
+  | {
     ok: true
     result: unknown
     description?: string
@@ -33,15 +31,13 @@ export type BotApiResponse
     ok: false
     error_code: number
     description: string
-    parameters?: Types.ResponseParameters
+    parameters?: BotApi.Types.ResponseParameters
   }
 
-/**
- * Error caused by the transport when accessing Bot API.
- */
-export class BotApiTransportError extends Data.TaggedError('@grom.js/effect-tg/BotApiTransport/BotApiTransportError')<{
-  cause: unknown
-}> {}
+export const make: (options: {
+  httpClient: HttpClient.HttpClient
+  botApiUrl: BotApiUrl.Service
+}) => Service = internal.make
 
 export const layer: Layer.Layer<
   BotApiTransport,
@@ -50,6 +46,8 @@ export const layer: Layer.Layer<
 > = Layer.effect(
   BotApiTransport,
   Effect.all([HttpClient.HttpClient, BotApiUrl.BotApiUrl]).pipe(
-    Effect.andThen(reqs => internal.make(...reqs)),
+    Effect.andThen(([httpClient, botApiUrl]) => (
+      internal.make({ httpClient, botApiUrl })),
+    ),
   ),
 )

package/src/BotApiUrl.ts

@@ -2,24 +2,22 @@ import * as Context from 'effect/Context'
 
 export class BotApiUrl extends Context.Tag('@grom.js/effect-tg/BotApiUrl')<
   BotApiUrl,
-  BotApiUrl.Service
+  Service
 >() {}
 
-export declare namespace BotApiUrl {
-  export interface Service {
-    toMethod: (method: string) => URL
-    toFile: (filePath: string) => URL
-  }
+export interface Service {
+  toMethod: (method: string) => URL
+  toFile: (filePath: string) => URL
 }
 
-export const makeProd = (token: string): BotApiUrl.Service => (
+export const makeProd = (token: string): Service => (
   {
     toMethod: (method: string) => new URL(`https://api.telegram.org/bot${token}/${method}`),
     toFile: (filePath: string) => new URL(`https://api.telegram.org/file/bot${token}/${filePath}`),
   }
 )
 
-export const makeTest = (token: string): BotApiUrl.Service => (
+export const makeTest = (token: string): Service => (
   {
     toMethod: (method: string) => new URL(`https://api.telegram.org/bot${token}/test/${method}`),
     // TODO: make sure this works in test environment

package/src/Content.ts

@@ -12,20 +12,20 @@ import * as Option from 'effect/Option'
  * @todo Invoices (fiat & stars)
  * @see {@link https://core.telegram.org/tdlib/docs/classtd_1_1td__api_1_1_input_message_content.html TDLib • td_api.InputMessageContent}
  */
-export type Content
-  = | Text
-    | Photo
-    | Audio
-    | Document
-    | Video
-    | Animation
-    | Voice
-    | VideoNote
-    | Location
-    | Venue
-    | Contact
-    | Dice
-    | Sticker
+export type Content =
+  | Text
+  | Photo
+  | Audio
+  | Document
+  | Video
+  | Animation
+  | Voice
+  | VideoNote
+  | Location
+  | Venue
+  | Contact
+  | Dice
+  | Sticker
 
 /**
  * Content of a text message.

package/src/Dialog.ts

@@ -1,54 +1,176 @@
+import type * as BotApi from './BotApi.ts'
+import * as Brand from 'effect/Brand'
 import * as Data from 'effect/Data'
+import * as Option from 'effect/Option'
 import * as internal from './internal/dialog.ts'
 
-export type Dialog
-  = | UserId
-    | GroupId
-    | ChannelId
-    | SupergroupId
-    | PublicChannel
-    | PublicSupergroup
-    | ForumTopic
-    | ChannelDm
-
-export class UserId extends internal.PeerId({
-  tag: 'UserId',
-  isValid: id => (id >= 1 && id <= 0xFFFFFFFFFF),
-  toDialogId: id => id,
-}) {}
-
-export class GroupId extends internal.PeerId({
-  tag: 'GroupId',
-  isValid: id => (id >= 1 && id <= 999999999999),
-  toDialogId: id => -id,
-}) {}
-
-export class ChannelId extends internal.PeerId({
-  tag: 'ChannelId',
-  isValid: id => (id >= 1 && id <= 997852516352),
-  toDialogId: id => -(1000000000000 + id),
-}) {}
-
-export class SupergroupId extends internal.PeerId({
-  tag: 'SupergroupId',
-  isValid: id => (id >= 1 && id <= 997852516352),
-  toDialogId: id => -(1000000000000 + id),
-}) {}
-
-export class PublicChannel extends Data.TaggedClass('PublicChannel')<{
-  username: string
-}> {}
+// =============================================================================
+// Dialog
+// =============================================================================
+
+export type Dialog =
+  | Peer
+  | PrivateTopic
+  | ForumTopic
+  | ChannelDm
 
-export class PublicSupergroup extends Data.TaggedClass('PublicSupergroup')<{
-  username: string
+export class PrivateTopic extends Data.TaggedClass('PrivateTopic')<{
+  user: User
+  topicId: number
 }> {}
 
 export class ForumTopic extends Data.TaggedClass('ForumTopic')<{
-  forum: SupergroupId | PublicSupergroup
+  supergroup: Supergroup
   topicId: number
 }> {}
 
 export class ChannelDm extends Data.TaggedClass('ChannelDm')<{
-  channel: ChannelId | PublicChannel
-  userId: number
+  channel: Channel
+  topicId: number
 }> {}
+
+// =============================================================================
+// Peer
+// =============================================================================
+
+export type Peer =
+  | User
+  | Group
+  | Supergroup
+  | Channel
+
+export class User extends Data.TaggedClass('User')<{
+  id: UserId
+}> {
+  public dialogId(): DialogId {
+    return Option.getOrThrow(internal.encodePeerId('user', this.id))
+  }
+
+  public topic(topicId: number): PrivateTopic {
+    return new PrivateTopic({ user: this, topicId })
+  }
+}
+
+export class Group extends Data.TaggedClass('Group')<{
+  id: GroupId
+}> {
+  public dialogId(): DialogId {
+    return Option.getOrThrow(internal.encodePeerId('group', this.id))
+  }
+}
+
+export class Supergroup extends Data.TaggedClass('Supergroup')<{
+  id: SupergroupId
+}> {
+  public dialogId(): DialogId {
+    return Option.getOrThrow(internal.encodePeerId('supergroup', this.id))
+  }
+
+  public topic(topicId: number): ForumTopic {
+    return new ForumTopic({ supergroup: this, topicId })
+  }
+}
+
+export class Channel extends Data.TaggedClass('Channel')<{
+  id: ChannelId
+}> {
+  public dialogId(): DialogId {
+    return Option.getOrThrow(internal.encodePeerId('supergroup', this.id))
+  }
+
+  public directMessages(topicId: number): ChannelDm {
+    return new ChannelDm({ channel: this, topicId })
+  }
+}
+
+// =============================================================================
+// Brands
+// =============================================================================
+
+/**
+ * Dialog ID is a single integer encoding peer type and its ID.
+ *
+ * @see {@link https://core.telegram.org/api/bots/ids Telegram API • Bot API dialog IDs}
+ */
+export type DialogId = number & Brand.Brand<'@grom.js/effect-tg/DialogId'>
+export const DialogId = Brand.refined<DialogId>(
+  n => Option.isSome(internal.decodeDialogId(n)),
+  n => Brand.error(`Invalid dialog ID: ${n}`),
+)
+
+export type UserId = number & Brand.Brand<'@grom.js/effect-tg/UserId'>
+export const UserId = Brand.refined<UserId>(
+  n => Option.isSome(internal.encodePeerId('user', n)),
+  n => Brand.error(`Invalid user ID: ${n}`),
+)
+
+export type GroupId = number & Brand.Brand<'@grom.js/effect-tg/GroupId'>
+export const GroupId = Brand.refined<GroupId>(
+  n => Option.isSome(internal.encodePeerId('group', n)),
+  n => Brand.error(`Invalid group ID: ${n}`),
+)
+
+export type SupergroupId = number & Brand.Brand<'@grom.js/effect-tg/SupergroupId'>
+export const SupergroupId = Brand.refined<SupergroupId>(
+  n => Option.isSome(internal.encodePeerId('supergroup', n)),
+  n => Brand.error(`Invalid supergroup or channel ID: ${n}`),
+)
+
+/**
+ * @alias SupergroupId
+ */
+export type ChannelId = SupergroupId
+
+/**
+ * @alias SupergroupId
+ */
+export const ChannelId = SupergroupId
+
+// =============================================================================
+// Dialog ID <-> Peer ID
+// =============================================================================
+
+export const decodeDialogId: (dialogId: number) => Option.Option<
+  | { peer: 'user', id: UserId }
+  | { peer: 'group', id: GroupId }
+  | { peer: 'supergroup', id: SupergroupId }
+  | { peer: 'monoforum', id: number }
+  | { peer: 'secret-chat', id: number }
+> = internal.decodeDialogId
+
+export const decodePeerId: {
+  (peer: 'user', dialogId: number): Option.Option<UserId>
+  (peer: 'group', dialogId: number): Option.Option<GroupId>
+  (peer: 'supergroup', dialogId: number): Option.Option<SupergroupId>
+  (peer: 'monoforum', dialogId: number): Option.Option<number>
+  (peer: 'secret-chat', dialogId: number): Option.Option<number>
+} = internal.decodePeerId
+
+export const encodePeerId: (
+  peer: 'user' | 'group' | 'supergroup' | 'monoforum' | 'secret-chat',
+  id: number,
+) => Option.Option<DialogId> = internal.encodePeerId
+
+// =============================================================================
+// Constructors
+// =============================================================================
+
+export const user: (id: number) => User = (id) => {
+  return new User({ id: UserId(id) })
+}
+
+export const group: (id: number) => Group = (id) => {
+  return new Group({ id: GroupId(id) })
+}
+
+export const supergroup: (id: number) => Supergroup = (id) => {
+  return new Supergroup({ id: SupergroupId(id) })
+}
+
+export const channel: (id: number) => Channel = (id) => {
+  return new Channel({ id: SupergroupId(id) })
+}
+
+export const ofMessage: (
+  message: BotApi.Types.Message,
+) => Dialog = internal.ofMessage

package/src/File.ts

@@ -5,7 +5,6 @@ import type * as Effect from 'effect/Effect'
 import type * as Stream from 'effect/Stream'
 import type * as BotApi from './BotApi.ts'
 import type * as BotApiError from './BotApiError.ts'
-import type * as BotApiTransport from './BotApiTransport.ts'
 import type * as BotApiUrl from './BotApiUrl.ts'
 import * as Brand from 'effect/Brand'
 import * as Data from 'effect/Data'
@@ -28,8 +27,8 @@ export class InputFile extends Data.TaggedClass('InputFile')<{
  *
  * @see {@link https://core.telegram.org/bots/api#getfile Bot API • getFile}
  */
-export const get: (fileId: FileId) => Effect.Effect<
+export const download: (fileId: FileId) => Effect.Effect<
   HttpClientResponse.HttpClientResponse,
-  BotApiError.BotApiError | BotApiTransport.BotApiTransportError | HttpClientError.HttpClientError,
+  BotApiError.BotApiError | HttpClientError.HttpClientError,
   BotApi.BotApi | BotApiUrl.BotApiUrl | HttpClient.HttpClient
-> = internal.get
+> = internal.download

package/src/Markup.ts

@@ -4,11 +4,11 @@ import * as Data from 'effect/Data'
 /**
  * Reply markup for the message.
  */
-export type Markup
-  = | InlineKeyboard
-    | ReplyKeyboard
-    | ReplyKeyboardRemove
-    | ForceReply
+export type Markup =
+  | InlineKeyboard
+  | ReplyKeyboard
+  | ReplyKeyboardRemove
+  | ForceReply
 
 export class InlineKeyboard extends Data.TaggedClass('InlineKeyboard')<{
   rows: [] // TODO