rubika 1.0.0

package/README.md

@@ -0,0 +1,54 @@
+<p align="center">
+  <h1 style="color:#fff;">› rubika-bot Framework</h1>
+  <p><b>فریم‌ورک قدرتمند و پرسرعت جاوااسکریپت برای ربات‌های روبیکا</b></p>
+</p>
+
+---
+
+## › معرفی rubika-bot
+
+**rubika-bot** یک فریم‌ورک سبک، مدرن و کاملاً **غیرهمزمان** برای توسعه ربات‌های روبیکا است.  
+با معماری **Filter-Base** و **Type-Safe**، شما می‌توانید:
+
+- ربات‌هایی سریع و کم‌حجم بسازید
+- سیستم فرمان‌دهی و مدیریت پیام حرفه‌ای داشته باشید
+- با قابلیت **اسکِیبل و قابل گسترش**، پروژه‌های بزرگ هم مدیریت کنید
+
+---
+
+## › نصب و شروع سریع
+
+```bash
+bun add rubika-bot
+```
+
+## › نمونه کد ساده
+
+```js
+const { Bot, Filters } = require("rubika-bot");
+
+const bot = new Bot("rubika-bot");
+
+bot.command("/start", async (ctx, bot) => {
+  await bot.sendMessage(ctx.chat_id, "🤖 ربات استارت شد");
+});
+
+bot.on("message", [Filters.isText], async (ctx, bot) => {
+  await bot.sendMessage(ctx.chat_id, "سلام 😎");
+});
+
+bot.run();
+```
+
+## › ویژگی‌های کلیدی
+
+| ویژگی          | توضیح                                          |
+| -------------- | ---------------------------------------------- |
+| ⚡ Super-Speed | استفاده از معماری غیرهمزمان برای پاسخ‌دهی سریع |
+| 🛡️ Type-Safe   | کمک به جلوگیری از خطاهای متداول جاوااسکریپت    |
+| 🔧 Filter-Base | سیستم فیلترینگ قدرتمند برای مدیریت پیام‌ها     |
+| 📂 Modular     | ساختار ماژولار و قابل گسترش                    |
+
+## 🌐 لینک‌های مهم
+
+- [لینک گیتهاب](https://github.com/hadi-rostami/rubika-bot)

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "rubika",
+  "version": "1.0.0",
+  "author": "Hadi Rostami",
+  "main": "src/index.ts",
+  "description": "A modern library for Rubika built with Bun.",
+  "files": [
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "javascript",
+    "Rubika",
+    "bun",
+    "rubika"
+  ],
+  "license": "MIT",
+  "type": "module"
+}

package/src/bot.ts

@@ -0,0 +1,197 @@
+import Network from "./network";
+import Methods from "./methods";
+import type { BotInfo, Update } from "./types/interfaces";
+import type { ContextMap, Handler, NestedFilter } from "./types/handlers";
+
+class Bot extends Methods {
+  protected initialize: boolean = false;
+  protected network: Network;
+  public BASE_URL: string;
+  public bot?: BotInfo;
+
+  public handlers: {
+    [K in keyof ContextMap]: Handler<ContextMap[K]>[];
+  } = { inline: [], update: [] };
+
+  /**
+   * نمونه‌ای از کلاس ربات را ایجاد می‌کند.
+   *
+   * این سازنده اصلی‌ترین بخش برای شروع کار با ربات است.
+   * با دریافت توکن و تنظیم زمان انتظار، پایه‌ی ارتباط با ای‌پی‌ای روبیکا را فراهم می‌کند.
+   *
+   * @param token - توکن اختصاصی ربات که برای احراز هویت در ای‌پی‌ای روبیکا استفاده می‌شود.
+   * @param timeout - زمان انتظار برای درخواست‌ها به سرور (بر حسب میلی‌ثانیه). پیش‌فرض 10000 میلی‌ثانیه.
+   *
+   * @example
+   * ```ts
+   * const bot = new Bot("your-token-here", 15000);
+   * ```
+   */
+  constructor(public token: string, timeout: number = 10000) {
+    super();
+    this.BASE_URL = `https://botapi.rubika.ir/v3/${token}`;
+    this.network = new Network(this.BASE_URL, timeout);
+
+    this.start();
+  }
+
+  /**
+   * یک رویداد (event) را ثبت می‌کند و با ورودی‌های مشخص، دستورات را اجرا می‌کند.
+   *
+   * این متد به شما امکان می‌دهد تا به ازای یک نوع خاص از رویداد (مثل پیام جدید، ورود کاربر و غیره)
+   * یک تابع پردازش (handler) تعیین کنید که زمان رخ دادن آن نوع از رویداد فراخوانی می‌شود.
+   *
+   * @param type - نوع رویدادی که می‌خواهید به آن پاسخ دهید (مثلاً "inline"، "update" و غیره).
+   * @param handler - (اختیاری) در صورتی که فیلتر وجود داشته باشد، این تابع پردازش خواهد بود.
+   *
+   * @example
+   * ```ts
+   * bot.on("inline", (ctx) => {
+   *   console.log("پیام جدید دریافت شد:", ctx.text);
+   * });
+   *
+   * bot.on("update", [filter.isText], (ctx) => {
+   *   console.log("پیام شامل متن است:", ctx.text);
+   * });
+   * ```
+   */
+  on<T extends keyof typeof this.handlers>(
+    type: T,
+    handler: (ctx: ContextMap[T], bot: Bot) => Promise<void>
+  ): void;
+
+  /**
+   * یک رویداد (event) را ثبت می‌کند و با ورودی‌های مشخص، دستورات را اجرا می‌کند.
+   *
+   * این متد به شما امکان می‌دهد تا به ازای یک نوع خاص از رویداد (مثل پیام جدید، ورود کاربر و غیره)
+   * یک تابع پردازش (handler) تعیین کنید که زمان رخ دادن آن نوع از رویداد فراخوانی می‌شود.
+   *
+   * @param type - نوع رویدادی که می‌خواهید به آن پاسخ دهید (مثلاً "inline"، "update" و غیره).
+   * @param filters - می‌تواند چند فیلتر یا تابع پردازش باشد.
+   * @param handler - (اختیاری) در صورتی که فیلتر وجود داشته باشد، این تابع پردازش خواهد بود.
+   *
+   * @example
+   * ```ts
+   * bot.on("inline", (ctx) => {
+   *   console.log("پیام جدید دریافت شد:", ctx.text);
+   * });
+   *
+   * bot.on("update", [filter.isText], (ctx) => {
+   *   console.log("پیام شامل متن است:", ctx.text);
+   * });
+   * ```
+   */
+  on<T extends keyof typeof this.handlers>(
+    type: T,
+    filters: NestedFilter<ContextMap[T]>,
+    handler: (ctx: ContextMap[T], bot: Bot) => Promise<void>
+  ): void;
+
+  on<T extends keyof typeof this.handlers>(
+    type: T,
+    filtersOrHandler:
+      | NestedFilter<ContextMap[T]>
+      | ((ctx: ContextMap[T], bot: Bot) => Promise<void>),
+    maybeHandler?: (ctx: ContextMap[T], bot: Bot) => Promise<void>
+  ): void {
+    if (typeof filtersOrHandler === "function") {
+      this.handlers[type].push({
+        filters: [],
+        handler: filtersOrHandler,
+      });
+    } else if (Array.isArray(filtersOrHandler) && maybeHandler) {
+      this.handlers[type].push({
+        filters: filtersOrHandler,
+        handler: maybeHandler,
+      });
+    }
+  }
+
+  /**
+   * یک دستور (command) را ثبت می‌کند.
+   *
+   * این متد به شما امکان می‌دهد تا به دستوراتی با پیشوند مشخص (مثل `/start` یا `!help`) پاسخ دهید.
+   * اگر پیام کاربر با پیشوند مطابقت داشته باشد، تابع پردازش مربوطه فراخوانی می‌شود.
+   *
+   * @param prefix - پیشوند دستور، که می‌تواند یک رشته یا یک عبارت منظم (RegExp) باشد.
+   * @param handler - (اختیاری) در صورتی که فیلتر وجود داشته باشد، این تابع پردازش خواهد بود.
+   *
+   * @example
+   * ```ts
+   * bot.command("/start", (ctx) => {
+   *   ctx.reply("سلام! خوش اومدی.");
+   * });
+   *
+   * bot.command(/!help/, (ctx) => {
+   *   ctx.reply("راهنمایی دریافت شد.");
+   * });
+   *
+   * bot.command("/ban", [filter.isAdmin], (ctx) => {
+   *   // فقط ادمین می‌تونه این دستور رو اجرا کنه
+   *   ctx.reply("کاربر مسدود شد.");
+   * });
+   * ```
+   */
+  command(
+    prefix: string | RegExp,
+    handler: (ctx: Update, bot: Bot) => Promise<void>
+  ): void;
+
+  /**
+   * یک دستور (command) را ثبت می‌کند.
+   *
+   * این متد به شما امکان می‌دهد تا به دستوراتی با پیشوند مشخص (مثل `/start` یا `!help`) پاسخ دهید.
+   * اگر پیام کاربر با پیشوند مطابقت داشته باشد، تابع پردازش مربوطه فراخوانی می‌شود.
+   *
+   * @param prefix - پیشوند دستور، که می‌تواند یک رشته یا یک عبارت منظم (RegExp) باشد.
+   * @param filters - می‌تواند چند فیلتر یا تابع پردازش باشد.
+   * @param handler - (اختیاری) در صورتی که فیلتر وجود داشته باشد، این تابع پردازش خواهد بود.
+   *
+   * @example
+   * ```ts
+   * bot.command("/start", (ctx) => {
+   *   ctx.reply("سلام! خوش اومدی.");
+   * });
+   *
+   * bot.command(/!help/, (ctx) => {
+   *   ctx.reply("راهنمایی دریافت شد.");
+   * });
+   *
+   * bot.command("/ban", [filter.isAdmin], (ctx) => {
+   *   // فقط ادمین می‌تونه این دستور رو اجرا کنه
+   *   ctx.reply("کاربر مسدود شد.");
+   * });
+   * ```
+   */
+  command(
+    prefix: string | RegExp,
+    filters: NestedFilter<ContextMap["update"]>,
+    handler: (ctx: Update, bot: Bot) => Promise<void>
+  ): void;
+
+  command(
+    prefix: string | RegExp,
+    filtersOrHandler:
+      | NestedFilter<ContextMap["update"]>
+      | ((ctx: Update, bot: Bot) => Promise<void>),
+    maybeHandler?: (ctx: Update, bot: Bot) => Promise<void>
+  ) {
+    if (typeof filtersOrHandler === "function") {
+      this.handlers.update.push({
+        filters: [],
+        handler: filtersOrHandler,
+        prefix,
+      });
+    } else if (Array.isArray(filtersOrHandler) && maybeHandler) {
+      this.handlers.update.push({
+        filters: filtersOrHandler,
+        handler: maybeHandler,
+        prefix,
+      });
+    } else {
+      throw new Error("Invalid arguments for command()");
+    }
+  }
+}
+
+export default Bot;

package/src/filters.ts

@@ -0,0 +1,92 @@
+import { Update } from "./types/interfaces";
+
+export default class Filters {
+  static findKey(message: any, key: string): any {
+    if (!message || typeof message !== "object") {
+      return undefined;
+    }
+
+    const messageKeys = Object.keys(message);
+    if (messageKeys.includes(key)) {
+      return message[key];
+    }
+
+    for (const messageKey of messageKeys) {
+      const value = message[messageKey];
+
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === "object") {
+            const found = Filters.findKey(item, key);
+            if (found !== undefined) return found;
+          }
+        }
+      }
+
+      if (typeof value === "object") {
+        const found = Filters.findKey(value, key);
+        if (found !== undefined) return found;
+      }
+    }
+
+    return undefined;
+  }
+
+  static isText(message: Update): boolean {
+    return !!Filters.findKey(message, "text");
+  }
+
+  static isLocation(message: Update): boolean {
+    return !!Filters.findKey(message, "location");
+  }
+
+  static isSticker(message: Update): boolean {
+    return !!Filters.findKey(message, "sticker");
+  }
+
+  static isForward(message: Update): boolean {
+    return !!Filters.findKey(message, "forwarded_from");
+  }
+
+  static isReply(message: Update): boolean {
+    return !!Filters.findKey(message, "reply_to_message_id");
+  }
+
+  static isContact(message: Update): boolean {
+    return !!Filters.findKey(message, "contact_message");
+  }
+
+  static isPoll(message: Update): boolean {
+    return !!Filters.findKey(message, "poll");
+  }
+
+  static isLiveLocation(message: Update): boolean {
+    return !!Filters.findKey(message, "live_location");
+  }
+
+  static isFile(message: Update): boolean {
+    return !!Filters.findKey(message, "file");
+  }
+
+  static isMention(message: Update): boolean {
+    return !!Filters.findKey(
+      message.new_message?.metadata?.meta_data_parts,
+      "link"
+    );
+  }
+
+  static isMarkdown(message: Update): boolean {
+    return !!Filters.findKey(message, "metadata");
+  }
+
+  static isDelete(message: Update): boolean {
+    return !!Filters.findKey(message, "removed_message_id");
+  }
+
+  static kypadID(button_id: string): (message: Update) => boolean {
+    return (message: Update) => {
+      const res = Filters.findKey(message, "button_id");
+      return res === button_id;
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import Bot from "./bot";
+import Utils from "./utils";
+import Filters from "./filters";
+import type * as Enums from "./types/enums";
+
+export default Bot;
+export { Bot, Filters, Utils };
+export type { Enums };

package/src/methods/advanced/builder.ts

@@ -0,0 +1,23 @@
+import Bot from "../..";
+
+async function builder(
+  this: Bot,
+  method: string,
+  input: object = {}
+): Promise<any> {
+  if (!this.token) {
+    throw new Error(
+      "[builder] Bot token is not set. Please provide a valid token."
+    );
+  }
+
+  const response: any = await this.network.request(method, input);
+
+  if (response?.status === "OK") {
+    return response.data;
+  }
+
+  throw new Error(`[builder] error in request ${method}:\n ${response} `);
+}
+
+export default builder;

package/src/methods/advanced/index.ts

@@ -0,0 +1,3 @@
+import builder from "./builder";
+
+export { builder };

package/src/methods/bot/getMe.ts

@@ -0,0 +1,8 @@
+import Bot from "../..";
+
+
+async function getMe(this: Bot) {
+  return await this.builder("getMe", {});
+}
+
+export default getMe;

package/src/methods/bot/index.ts

@@ -0,0 +1,3 @@
+import getMe from './getMe';
+
+export { getMe };

package/src/methods/chat/getChat.ts

@@ -0,0 +1,7 @@
+import Bot from '../..';
+
+async function getChat(this: Bot, chat_id: string) {
+	return await this.builder('getChat', { chat_id });
+}
+
+export default getChat;

package/src/methods/chat/index.ts

@@ -0,0 +1,3 @@
+import getChat from './getChat';
+
+export { getChat };

package/src/methods/files/_sendFile.ts

@@ -0,0 +1,47 @@
+import Bot from "../..";
+import Markdown from "../../utils/parser";
+import { FileSource, SendType } from "../../types/methods";
+import { InlineKeypad, Keypad } from "../../types/interfaces";
+import { ChatKeypadTypeEnum, FileTypeEnum } from "../../types/enums";
+
+async function _sendFile(
+  this: Bot,
+  chat_id: string,
+  file: FileSource,
+  text?: string,
+  type: FileTypeEnum = FileTypeEnum.File,
+  chat_keypad?: Keypad,
+  inline_keypad?: InlineKeypad,
+  disable_notification = false,
+  reply_to_message_id?: string,
+  chat_keypad_type?: ChatKeypadTypeEnum
+) {
+  const { upload_url } = await this.requestSendFile(type);
+  const {
+    data: { file_id },
+  } = await this.uploadFile(upload_url, file);
+
+  let data: SendType = {
+    chat_id,
+    file_id,
+    disable_notification,
+  };
+
+  if (text) data = { ...data, ...Markdown.toMetadata(text.trim()) };
+  if (chat_keypad) data.chat_keypad = chat_keypad;
+  if (inline_keypad) data.inline_keypad = inline_keypad;
+  if (chat_keypad_type) data.chat_keypad_type = chat_keypad_type;
+  if (reply_to_message_id) data.reply_to_message_id = reply_to_message_id;
+
+  if (chat_keypad && !chat_keypad_type) {
+    data.chat_keypad_type = ChatKeypadTypeEnum.New;
+  }
+
+  if (inline_keypad && chat_keypad_type) {
+    data.chat_keypad_type = ChatKeypadTypeEnum.None;
+  }
+
+  return await this.builder("sendFile", data);
+}
+
+export default _sendFile;

package/src/methods/files/getFile.ts

@@ -0,0 +1,7 @@
+import Bot from '../..';
+
+async function getFile(this: Bot, file_id: string) {
+	return await this.builder('getFile', { file_id });
+}
+
+export default getFile;

package/src/methods/files/index.ts

@@ -0,0 +1,6 @@
+import getFile from './getFile';
+import requestSendFile from './requestSendFile';
+import _sendFile from './_sendFile';
+import uploadFile from './uploadFile';
+
+export { getFile, requestSendFile, uploadFile , _sendFile };

package/src/methods/files/requestSendFile.ts

@@ -0,0 +1,8 @@
+import Bot from '../..';
+import { FileTypeEnum } from '../../types/enums';
+
+async function requestSendFile(this: Bot, type: FileTypeEnum) {
+	return await this.builder('requestSendFile', { type });
+}
+
+export default requestSendFile;

package/src/methods/files/uploadFile.ts

@@ -0,0 +1,88 @@
+import { fetch } from "bun";
+import { basename } from "path";
+import Bot from "../..";
+import { FileSource } from "../../types/methods";
+
+async function uploadFile(
+  this: Bot,
+  url: string,
+  source: FileSource,
+  filename?: string
+) {
+  let fileData: ArrayBuffer;
+  let detectedFilename: string;
+
+  if (typeof source === "string") {
+    if (source.startsWith("http://") || source.startsWith("https://")) {
+      // download file
+      console.log(`[ uploadFile ] Downloading from URL: ${source}`);
+      const res = await fetch(source);
+      if (!res.ok) {
+        throw new Error(
+          `Failed to download file: ${res.status} ${res.statusText}`
+        );
+      }
+
+      fileData = await res.arrayBuffer();
+      detectedFilename =
+        filename || getFilenameFromUrl(source) || "downloaded_file";
+    } else {
+      // file path
+      if (!Bun.file(source).size) {
+        throw new Error(`File not found: ${source}`);
+      }
+      fileData = await Bun.file(source).arrayBuffer();
+      detectedFilename = filename || basename(source);
+    }
+  } else {
+    // binery data
+    if (source instanceof Buffer) {
+      fileData = source.buffer.slice(
+        source.byteOffset,
+        source.byteOffset + source.byteLength
+      ) as ArrayBuffer;
+    } else if (source instanceof Uint8Array) {
+      fileData = source.buffer.slice(
+        source.byteOffset,
+        source.byteOffset + source.byteLength
+      ) as ArrayBuffer;
+    } else {
+      fileData = source;
+    }
+    detectedFilename = filename || "binary_file";
+  }
+
+  // FormData
+  const formData = new FormData();
+  formData.append("file", new Blob([fileData]), detectedFilename);
+
+  const res = await fetch(url, {
+    method: "POST",
+    body: formData,
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`HTTP ${res.status}: ${text}`);
+  }
+
+  const response = await res.json();
+
+  if (response.status !== "OK") {
+    throw new Error(`Upload failed: ${JSON.stringify(response)}`);
+  }
+
+  return response;
+}
+
+function getFilenameFromUrl(url: string): string | null {
+  try {
+    const path = new URL(url).pathname;
+    const filename = basename(path);
+    return filename !== "." ? filename : null;
+  } catch {
+    return null;
+  }
+}
+
+export default uploadFile;