@hasna/connectors 1.1.4 → 1.1.6

package/connectors/connect-telegram/src/api/chats.ts

@@ -0,0 +1,290 @@
+import type { TelegramClient } from './client';
+import type { TelegramChat, TelegramChatMember, TelegramChatPermissions, TelegramUser } from '../types';
+
+export interface GetChatOptions {
+  chatId: number | string;
+}
+
+export interface GetChatMemberOptions {
+  chatId: number | string;
+  userId: number;
+}
+
+export interface GetChatMemberCountOptions {
+  chatId: number | string;
+}
+
+export interface GetChatAdministratorsOptions {
+  chatId: number | string;
+}
+
+export interface LeaveChatOptions {
+  chatId: number | string;
+}
+
+export interface SetChatTitleOptions {
+  chatId: number | string;
+  title: string;
+}
+
+export interface SetChatDescriptionOptions {
+  chatId: number | string;
+  description?: string;
+}
+
+export interface BanChatMemberOptions {
+  chatId: number | string;
+  userId: number;
+  untilDate?: number;
+  revokeMessages?: boolean;
+}
+
+export interface UnbanChatMemberOptions {
+  chatId: number | string;
+  userId: number;
+  onlyIfBanned?: boolean;
+}
+
+export interface ExportChatInviteLinkOptions {
+  chatId: number | string;
+}
+
+export interface PinChatMessageOptions {
+  chatId: number | string;
+  messageId: number;
+  disableNotification?: boolean;
+}
+
+export interface UnpinChatMessageOptions {
+  chatId: number | string;
+  messageId?: number;
+}
+
+export interface UnpinAllChatMessagesOptions {
+  chatId: number | string;
+}
+
+export interface RestrictChatMemberOptions {
+  chatId: number | string;
+  userId: number;
+  permissions: TelegramChatPermissions;
+  useIndependentChatPermissions?: boolean;
+  untilDate?: number;
+}
+
+export interface PromoteChatMemberOptions {
+  chatId: number | string;
+  userId: number;
+  isAnonymous?: boolean;
+  canManageChat?: boolean;
+  canDeleteMessages?: boolean;
+  canManageVideoChats?: boolean;
+  canRestrictMembers?: boolean;
+  canPromoteMembers?: boolean;
+  canChangeInfo?: boolean;
+  canInviteUsers?: boolean;
+  canPostMessages?: boolean;
+  canEditMessages?: boolean;
+  canPinMessages?: boolean;
+  canManageTopics?: boolean;
+}
+
+/**
+ * Telegram Chats API
+ */
+export class ChatsApi {
+  constructor(private readonly client: TelegramClient) {}
+
+  /**
+   * Get chat information
+   */
+  async getChat(options: GetChatOptions): Promise<TelegramChat> {
+    return this.client.request<TelegramChat>('getChat', {
+      params: {
+        chat_id: options.chatId,
+      },
+    });
+  }
+
+  /**
+   * Get a chat member
+   */
+  async getChatMember(options: GetChatMemberOptions): Promise<TelegramChatMember> {
+    return this.client.request<TelegramChatMember>('getChatMember', {
+      params: {
+        chat_id: options.chatId,
+        user_id: options.userId,
+      },
+    });
+  }
+
+  /**
+   * Get the number of members in a chat
+   */
+  async getChatMemberCount(options: GetChatMemberCountOptions): Promise<number> {
+    return this.client.request<number>('getChatMemberCount', {
+      params: {
+        chat_id: options.chatId,
+      },
+    });
+  }
+
+  /**
+   * Get chat administrators
+   */
+  async getChatAdministrators(options: GetChatAdministratorsOptions): Promise<TelegramChatMember[]> {
+    return this.client.request<TelegramChatMember[]>('getChatAdministrators', {
+      params: {
+        chat_id: options.chatId,
+      },
+    });
+  }
+
+  /**
+   * Leave a chat
+   */
+  async leaveChat(options: LeaveChatOptions): Promise<boolean> {
+    return this.client.request<boolean>('leaveChat', {
+      params: {
+        chat_id: options.chatId,
+      },
+    });
+  }
+
+  /**
+   * Set chat title (for groups and channels)
+   */
+  async setChatTitle(options: SetChatTitleOptions): Promise<boolean> {
+    return this.client.request<boolean>('setChatTitle', {
+      params: {
+        chat_id: options.chatId,
+        title: options.title,
+      },
+    });
+  }
+
+  /**
+   * Set chat description
+   */
+  async setChatDescription(options: SetChatDescriptionOptions): Promise<boolean> {
+    return this.client.request<boolean>('setChatDescription', {
+      params: {
+        chat_id: options.chatId,
+        description: options.description,
+      },
+    });
+  }
+
+  /**
+   * Ban a user from a chat
+   */
+  async banChatMember(options: BanChatMemberOptions): Promise<boolean> {
+    return this.client.request<boolean>('banChatMember', {
+      params: {
+        chat_id: options.chatId,
+        user_id: options.userId,
+        until_date: options.untilDate,
+        revoke_messages: options.revokeMessages,
+      },
+    });
+  }
+
+  /**
+   * Unban a user from a chat
+   */
+  async unbanChatMember(options: UnbanChatMemberOptions): Promise<boolean> {
+    return this.client.request<boolean>('unbanChatMember', {
+      params: {
+        chat_id: options.chatId,
+        user_id: options.userId,
+        only_if_banned: options.onlyIfBanned,
+      },
+    });
+  }
+
+  /**
+   * Export chat invite link
+   */
+  async exportChatInviteLink(options: ExportChatInviteLinkOptions): Promise<string> {
+    return this.client.request<string>('exportChatInviteLink', {
+      params: {
+        chat_id: options.chatId,
+      },
+    });
+  }
+
+  /**
+   * Pin a message in a chat
+   */
+  async pinChatMessage(options: PinChatMessageOptions): Promise<boolean> {
+    return this.client.request<boolean>('pinChatMessage', {
+      params: {
+        chat_id: options.chatId,
+        message_id: options.messageId,
+        disable_notification: options.disableNotification,
+      },
+    });
+  }
+
+  /**
+   * Unpin a message in a chat
+   */
+  async unpinChatMessage(options: UnpinChatMessageOptions): Promise<boolean> {
+    return this.client.request<boolean>('unpinChatMessage', {
+      params: {
+        chat_id: options.chatId,
+        message_id: options.messageId,
+      },
+    });
+  }
+
+  /**
+   * Unpin all messages in a chat
+   */
+  async unpinAllChatMessages(options: UnpinAllChatMessagesOptions): Promise<boolean> {
+    return this.client.request<boolean>('unpinAllChatMessages', {
+      params: {
+        chat_id: options.chatId,
+      },
+    });
+  }
+
+  /**
+   * Restrict a chat member
+   */
+  async restrictChatMember(options: RestrictChatMemberOptions): Promise<boolean> {
+    return this.client.request<boolean>('restrictChatMember', {
+      body: {
+        chat_id: options.chatId,
+        user_id: options.userId,
+        permissions: options.permissions,
+        use_independent_chat_permissions: options.useIndependentChatPermissions,
+        until_date: options.untilDate,
+      },
+    });
+  }
+
+  /**
+   * Promote a chat member
+   */
+  async promoteChatMember(options: PromoteChatMemberOptions): Promise<boolean> {
+    return this.client.request<boolean>('promoteChatMember', {
+      params: {
+        chat_id: options.chatId,
+        user_id: options.userId,
+        is_anonymous: options.isAnonymous,
+        can_manage_chat: options.canManageChat,
+        can_delete_messages: options.canDeleteMessages,
+        can_manage_video_chats: options.canManageVideoChats,
+        can_restrict_members: options.canRestrictMembers,
+        can_promote_members: options.canPromoteMembers,
+        can_change_info: options.canChangeInfo,
+        can_invite_users: options.canInviteUsers,
+        can_post_messages: options.canPostMessages,
+        can_edit_messages: options.canEditMessages,
+        can_pin_messages: options.canPinMessages,
+        can_manage_topics: options.canManageTopics,
+      },
+    });
+  }
+}

package/connectors/connect-telegram/src/api/client.ts

@@ -0,0 +1,134 @@
+import type { TelegramConfig, TelegramApiResponse } from '../types';
+import { TelegramApiError } from '../types';
+
+const TELEGRAM_API_BASE = 'https://api.telegram.org';
+
+export interface TelegramRequestOptions {
+  method?: 'GET' | 'POST';
+  params?: Record<string, string | number | boolean | undefined>;
+  body?: Record<string, unknown> | FormData;
+}
+
+/**
+ * Telegram Bot API Client
+ */
+export class TelegramClient {
+  private readonly botToken: string;
+  private readonly baseUrl: string;
+
+  constructor(config: TelegramConfig) {
+    if (!config.botToken) {
+      throw new Error('Telegram Bot Token is required');
+    }
+    this.botToken = config.botToken;
+    this.baseUrl = `${TELEGRAM_API_BASE}/bot${this.botToken}`;
+  }
+
+  /**
+   * Make a request to the Telegram Bot API
+   */
+  async request<T>(
+    method: string,
+    options: TelegramRequestOptions = {}
+  ): Promise<T> {
+    const { method: httpMethod = 'POST', params, body } = options;
+
+    let url = `${this.baseUrl}/${method}`;
+
+    // Add query params for GET requests
+    if (params && httpMethod === 'GET') {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+
+    const headers: Record<string, string> = {};
+    let fetchBody: BodyInit | undefined;
+
+    if (body) {
+      if (body instanceof FormData) {
+        // Let the browser set the content-type with boundary for FormData
+        fetchBody = body;
+      } else {
+        headers['Content-Type'] = 'application/json';
+        fetchBody = JSON.stringify(body);
+      }
+    } else if (params && httpMethod === 'POST') {
+      // For POST without body, send params as JSON body
+      headers['Content-Type'] = 'application/json';
+      const cleanParams: Record<string, unknown> = {};
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          cleanParams[key] = value;
+        }
+      });
+      fetchBody = JSON.stringify(cleanParams);
+    }
+
+    const response = await fetch(url, {
+      method: httpMethod,
+      headers,
+      body: fetchBody,
+    });
+
+    const data = await response.json() as TelegramApiResponse<T>;
+
+    if (!data.ok) {
+      throw new TelegramApiError(
+        data.description || 'Unknown Telegram API error',
+        response.status,
+        data.error_code
+      );
+    }
+
+    return data.result as T;
+  }
+
+  /**
+   * Upload a file to Telegram
+   */
+  async uploadFile<T>(
+    method: string,
+    fileField: string,
+    fileData: Uint8Array,
+    fileName: string,
+    additionalParams: Record<string, string | number | boolean | undefined> = {}
+  ): Promise<T> {
+    const formData = new FormData();
+
+    // Add the file - create a proper ArrayBuffer from Uint8Array
+    const arrayBuffer = fileData.buffer.slice(fileData.byteOffset, fileData.byteOffset + fileData.byteLength) as ArrayBuffer;
+    const blob = new Blob([arrayBuffer]);
+    formData.append(fileField, blob, fileName);
+
+    // Add additional params
+    Object.entries(additionalParams).forEach(([key, value]) => {
+      if (value !== undefined && value !== null && value !== '') {
+        formData.append(key, String(value));
+      }
+    });
+
+    return this.request<T>(method, { body: formData });
+  }
+
+  /**
+   * Get a preview of the bot token (for display/debugging)
+   */
+  getTokenPreview(): string {
+    if (this.botToken.length > 10) {
+      const parts = this.botToken.split(':');
+      if (parts.length === 2) {
+        return `${parts[0]}:****`;
+      }
+      return `${this.botToken.substring(0, 6)}...`;
+    }
+    return '***';
+  }
+}

package/connectors/connect-telegram/src/api/index.ts

@@ -0,0 +1,66 @@
+import type { TelegramConfig } from '../types';
+import { TelegramClient } from './client';
+import { MessagesApi } from './messages';
+import { ChatsApi } from './chats';
+import { UpdatesApi } from './updates';
+import { InlineApi } from './inline';
+import { BotApi } from './bot';
+
+/**
+ * Main Telegram Connector class
+ * Provides access to Telegram Bot API services
+ */
+export class Telegram {
+  private readonly client: TelegramClient;
+
+  // Service APIs
+  public readonly messages: MessagesApi;
+  public readonly chats: ChatsApi;
+  public readonly updates: UpdatesApi;
+  public readonly inline: InlineApi;
+  public readonly bot: BotApi;
+
+  constructor(config: TelegramConfig) {
+    this.client = new TelegramClient(config);
+    this.messages = new MessagesApi(this.client);
+    this.chats = new ChatsApi(this.client);
+    this.updates = new UpdatesApi(this.client);
+    this.inline = new InlineApi(this.client);
+    this.bot = new BotApi(this.client);
+  }
+
+  /**
+   * Create a client from environment variables
+   * Looks for TELEGRAM_BOT_TOKEN
+   */
+  static fromEnv(): Telegram {
+    const botToken = process.env.TELEGRAM_BOT_TOKEN;
+
+    if (!botToken) {
+      throw new Error('TELEGRAM_BOT_TOKEN environment variable is required');
+    }
+
+    return new Telegram({ botToken });
+  }
+
+  /**
+   * Get a preview of the bot token (for debugging)
+   */
+  getTokenPreview(): string {
+    return this.client.getTokenPreview();
+  }
+
+  /**
+   * Get the underlying client for direct API access
+   */
+  getClient(): TelegramClient {
+    return this.client;
+  }
+}
+
+export { TelegramClient } from './client';
+export { MessagesApi } from './messages';
+export { ChatsApi } from './chats';
+export { UpdatesApi } from './updates';
+export { InlineApi } from './inline';
+export { BotApi } from './bot';

package/connectors/connect-telegram/src/api/inline.ts

@@ -0,0 +1,63 @@
+import type { TelegramClient } from './client';
+import type { TelegramInlineQueryResult } from '../types';
+
+export interface AnswerInlineQueryOptions {
+  inlineQueryId: string;
+  results: TelegramInlineQueryResult[];
+  cacheTime?: number;
+  isPersonal?: boolean;
+  nextOffset?: string;
+  button?: InlineQueryResultsButton;
+}
+
+export interface InlineQueryResultsButton {
+  text: string;
+  webApp?: { url: string };
+  startParameter?: string;
+}
+
+export interface AnswerCallbackQueryOptions {
+  callbackQueryId: string;
+  text?: string;
+  showAlert?: boolean;
+  url?: string;
+  cacheTime?: number;
+}
+
+/**
+ * Telegram Inline API
+ */
+export class InlineApi {
+  constructor(private readonly client: TelegramClient) {}
+
+  /**
+   * Answer an inline query
+   */
+  async answerInlineQuery(options: AnswerInlineQueryOptions): Promise<boolean> {
+    return this.client.request<boolean>('answerInlineQuery', {
+      params: {
+        inline_query_id: options.inlineQueryId,
+        results: JSON.stringify(options.results),
+        cache_time: options.cacheTime,
+        is_personal: options.isPersonal,
+        next_offset: options.nextOffset,
+        button: options.button ? JSON.stringify(options.button) : undefined,
+      },
+    });
+  }
+
+  /**
+   * Answer a callback query
+   */
+  async answerCallbackQuery(options: AnswerCallbackQueryOptions): Promise<boolean> {
+    return this.client.request<boolean>('answerCallbackQuery', {
+      params: {
+        callback_query_id: options.callbackQueryId,
+        text: options.text,
+        show_alert: options.showAlert,
+        url: options.url,
+        cache_time: options.cacheTime,
+      },
+    });
+  }
+}