rubika 1.2.3 → 1.2.4

package/bot/methods/utilities/polling.ts

@@ -1,64 +1,89 @@
-import fs from "fs";
-import Bot from "../../bot";
-import { checkFilters } from "../../../utils";
 import { UpdateTypeEnum } from "../../types/enums";
+import { checkFilters } from "../../../utils";
 import Update from "../../contexts/update";
+import Bot from "../../bot";
+import path from "path";
+import fs from "fs";
+import { Filters } from "../../../client";
+
+const checkTypes = [
+  UpdateTypeEnum.UpdatedMessage,
+  UpdateTypeEnum.NewMessage,
+  UpdateTypeEnum.RemovedMessage,
+  UpdateTypeEnum.UpdatedPayment,
+  UpdateTypeEnum.StoppedBot,
+  UpdateTypeEnum.StartedBot,
+];
 
-const checkTypes = [UpdateTypeEnum.UpdatedMessage, UpdateTypeEnum.NewMessage];
+const OFFSET_FILE_PATH = path.join(
+  process.cwd(),
+  process.env.OFFSET_PATH || "offset.json",
+);
+
+const sleep = async (time: number) =>
+  await new Promise((res) => setTimeout(res, time));
 
 export default async function polling(this: Bot) {
   console.log("✔ Start Robot... [ polling mode ]");
 
   let next_offset_id: string | undefined = loadOffset();
 
-  setInterval(async () => {
+  while (true) {
     try {
-      const res = await this.getUpdates(next_offset_id);
-      const nowTime = Math.floor(Date.now() / 1000);
-      for (let m of res.updates) {
-        if (isNaN(m.new_message?.time || m.updated_message?.time)) continue;
-        const messageTime =
-          Number(m.new_message?.time || m.updated_message?.time) | 0;
+      const res = await this.getUpdates(next_offset_id, 100);
+
+      if (res.status_message !== "OK") {
+        await sleep(500);
+        continue;
+      }
 
-        if (nowTime - messageTime < 10) {
-          for (let { prefix, filters, handler } of this.handlers.update) {
-            const ctx = new Update(m, this);
-            const passed = await checkFilters(ctx, filters);
+      for (const m of res.updates) {
+        if (!checkTypes.includes(m.type)) continue;
+        const time = m.update_time - Math.floor(Date.now() / 1000);
 
-            if (passed) {
-              if (prefix) {
-                if (!checkTypes.includes(ctx.type)) continue;
+        if (time > 10 || time < -10) continue;
+        for (const { prefix, filters, handler } of this.handlers.update) {
+          const ctx = new Update(m, this);
+          const passed = await checkFilters(ctx, filters);
 
-                const text =
-                  ctx.updated_message?.text || ctx.new_message?.text || "";
+          if (passed) {
+            if (prefix) {
+              const text = Filters.findKey(m, "text") || null;
 
-                if (typeof prefix === "string" && text !== prefix) continue;
-                if (prefix instanceof RegExp && !prefix.test(text)) continue;
-              }
-              try {
-                await handler(ctx);
-              } catch {}
+              if (!text) continue;
+              if (typeof prefix === "string" && text !== prefix) continue;
+              if (prefix instanceof RegExp && !prefix.test(text)) continue;
+            }
+            try {
+              await handler(ctx);
+            } catch {
+              continue;
             }
           }
         }
       }
-
       if (res.next_offset_id) {
         next_offset_id = res.next_offset_id;
         saveOffset(next_offset_id as string);
       }
     } catch (e) {
-      this.logger.error("Error occurred while polling:" + e, "warn");
+      console.log(e);
     }
-  }, 1000);
+
+    await sleep(500);
+  }
 }
 
 function saveOffset(offset: string) {
-  fs.writeFileSync("offset.json", JSON.stringify({ offset }));
+  const dir = path.dirname(OFFSET_FILE_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(OFFSET_FILE_PATH, JSON.stringify({ offset }));
 }
 
 function loadOffset(): string | undefined {
-  if (!fs.existsSync("offset.json")) return undefined;
-  const data = fs.readFileSync("offset.json", "utf8");
+  if (!fs.existsSync(OFFSET_FILE_PATH)) return undefined;
+  const data = fs.readFileSync(OFFSET_FILE_PATH, "utf8");
   return JSON.parse(data).offset;
 }

package/bot/methods/utilities/run.ts

@@ -17,8 +17,8 @@ async function run(
   while (!this.initialize) {
     await this.network.delay(2000);
   }
-  if (url) await this.__setupWebhook(url, host, port, updates);
-  else await this.__polling();
+  if (url) await this.setupWebhook(url, host, port, updates);
+  else await this.polling();
 }
 
 export default run;

package/bot/methods/utilities/start.ts

@@ -6,15 +6,18 @@ async function start(this: Bot, token?: string) {
     if (token) this.token = token;
     else {
       const token = await prompt("[start] Please enter your bot token: ");
-      return await this.start(token);
+      await this.start(token);
+      return;
     }
   }
 
   try {
     const res = await this.getMe();
     this.bot = res.bot;
+    
   } catch (err) {
-    throw this.logger.error(`[start] error in token maby:${err}`, "warn");
+    await this.logger.error(`[start] error in token maby:${await err}`, "warn");
+    return 
   }
 
   this.initialize = true;

package/bot/methods/utilities/webhook.ts

@@ -13,7 +13,6 @@ async function setupWebhook(
   port: number = 3000,
   updates: UpdateEndpointTypeEnum[] = [],
 ) {
-  // create server
   Bun.serve({
     port,
     hostname: host,
@@ -44,7 +43,7 @@ async function setupWebhook(
   for (const update of updates) {
     const res = await this.updateBotEndpoints(url, update);
 
-    if (res.status !== "Done") {
+    if (res.status_message !== "OK" && res.status !== "Done") {
       this.logger.error(
         `[setupWebhook] status updateBotEndpoints is ${res.status} for update: ${update}`,
         "warn",

package/bot/network.ts

@@ -1,12 +1,36 @@
+import { Logger } from "../utils";
+import Bot from "./bot";
+
 export default class Network {
-  private MAX_ATTEMPTS = 3;
+  constructor(
+    public base_url: string,
+    public logger: Logger<Bot>,
+    public retryCount: number = 3,
+    public timeout: number = 10000,
+  ) {}
+
+  stringifyBigInts = (obj: object): object => {
+    if (Array.isArray(obj)) {
+      return obj.map(this.stringifyBigInts);
+    }
+
+    if (obj !== null && typeof obj === "object") {
+      const result: Record<string, unknown> = {};
+      for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+          result[key] = this.stringifyBigInts(obj[key as keyof typeof obj]);
+        }
+      }
+      return result;
+    }
 
-  constructor(public base_url: string, public timeout: number = 10000) {}
+    return obj;
+  };
 
   async request(method: string, data: object) {
-    const url = `${this.base_url}/${method}`;
+    const url = this.base_url + "/" + method;
 
-    for (let attempt = 1; attempt <= this.MAX_ATTEMPTS; attempt++) {
+    for (let attempt = 1; attempt <= this.retryCount; attempt++) {
       try {
         const res = await fetch(url, {
           method: "POST",
@@ -15,29 +39,33 @@ export default class Network {
           },
           body: JSON.stringify(data),
         });
+
         if (res.status === 200) {
           const responseData = await res.json();
 
-          return JSON.parse(
-            JSON.stringify(responseData, (_, v) =>
-              typeof v === "bigint" ? v.toString() : v
-            )
-          );
+          return responseData;
         } else {
-          console.warn(
-            `[request] Attempt ${attempt}: Unexpected status ${res.status}`
+          this.logger.error(
+            `[request] attempt ${attempt}: ${res.statusText} ${res.status}`,
+            "error",
           );
         }
-      } catch (error: unknown) {
-        console.error(`[request] Attempt ${attempt} failed:`, error);
+      } catch {
+        this.logger.error(
+          `[request] attempt ${attempt} message: you dont have access to the internet.`,
+          "error",
+        );
       }
 
       await this.delay(1000);
     }
 
-    return new Error(
-      `[request] Failed after ${this.MAX_ATTEMPTS} attempts: ${method}`
+    this.logger.error(
+      `[request] failed after ${this.retryCount} attempts { method: ${method} }`,
+      "error",
     );
+
+    return false;
   }
 
   delay(ms: number) {

package/bot/types/handlers.ts

@@ -1,9 +1,9 @@
 import Bot from "..";
 import { Update, Inline } from "../contexts";
 
-export interface ContextMap {
-  update: Update;
-  inline: Inline;
+export interface ContextMap<T> {
+  update: Update<T>;
+  inline: Inline<T>;
   error: {
     message: string;
     bot: Bot;

package/bot/types/interfaces.ts

@@ -14,7 +14,16 @@ import {
   UpdateTypeEnum,
 } from "./enums";
 
-export interface Chat {
+interface STATUS_MESSAGE {
+  status_message:
+    | "OK"
+    | "INVALID_ACCESS"
+    | "TOO_REQUESTS"
+    | "NETWORK_ERROR"
+    | "INVALID_TOKEN";
+}
+
+export interface Chat extends STATUS_MESSAGE {
   chat: {
     chat_id: string;
     chat_type: ChatTypeEnum;
@@ -25,6 +34,9 @@ export interface Chat {
     username: string;
   };
 }
+export interface UpdateBotEndpoints extends STATUS_MESSAGE {
+  status: string;
+}
 
 export interface File {
   file_id: string;
@@ -49,7 +61,7 @@ export interface MessageTextUpdate {
   text: string;
 }
 
-export interface Bot {
+export interface Bot extends STATUS_MESSAGE {
   bot: {
     bot_id: string;
     bot_title: string;
@@ -61,6 +73,10 @@ export interface Bot {
   };
 }
 
+export interface REQUEST_SEND_FILE extends STATUS_MESSAGE {
+  upload_url: string;
+}
+
 export interface BotCommand {
   command: string;
   description: string;
@@ -224,6 +240,30 @@ export interface Message {
   live_location?: LiveLocation;
 }
 
+export interface UpdateMessage {
+  chat_id: string;
+  update_time: number;
+  type: UpdateTypeEnum;
+  new_message?: Message;
+  updated_message?: Message;
+  removed_message_id?: string;
+  updated_payment?: PaymentStatus;
+}
+export interface InlineMessage {
+  sender_id: string;
+  text: string;
+  file?: File;
+  location?: Location;
+  aux_data?: AuxData;
+  message_id: string;
+  chat_id: string;
+}
+
+export interface GetUpdates extends STATUS_MESSAGE {
+  updates: UpdateMessage[];
+  next_offset_id: string;
+}
+
 export interface BotInfo {
   bot_id: string;
   bot_title: string;
@@ -233,11 +273,11 @@ export interface BotInfo {
   start_message: string;
 }
 
-export interface SendMessage {
+export interface SendMessage extends STATUS_MESSAGE {
   message_id: string;
 }
 
-export interface UploadFile {
+export interface UploadFile extends STATUS_MESSAGE {
   status: string;
   status_det: string;
   data: { file_id: string };

package/bot/types/utils.ts

@@ -35,8 +35,13 @@ export interface MetadataResult {
 }
 
 // antiSpam
-export type SpamCallbackType = (ctx: Update) => Promise<void>;
+export type SpamCallbackType = (ctx: Update<unknown>) => Promise<void>;
 export type OptionSpamType = {
   spam_time: number;
   spam_limit: number;
 };
+
+export type BotConfig = {
+  timeout: number;
+  retryCount: number;
+};

package/bot/utils/antiSpam.ts

@@ -14,7 +14,7 @@ export default class AntiSpam {
     this.spam_limit = options.spam_time || 4;
   }
 
-  checkSpam = async (ctx: Update) => {
+  checkSpam = async (ctx: Update<unknown>) => {
     if (!ctx.new_message) return;
 
     const now = Date.now();

package/client/client.ts

@@ -1,9 +1,15 @@
 import Network from "./network";
 import Methods from "./methods";
+import { Logger } from "../utils";
 import { SessionManager } from "./utils";
 import Message from "./contexts/message.type";
-import * as ClientTypes from "./types/client.type";
-import { Logger } from "../utils";
+import {
+  ContextMap,
+  RubPlugin,
+  Handler,
+  SessionType,
+  PlatformType,
+} from "./types/client.type";
 
 export default class Client extends Methods {
   public initialize = false;
@@ -13,12 +19,10 @@ export default class Client extends Methods {
   public auth?: string;
   public sessionDb: SessionManager;
   public network: Network;
-  public plugins: ClientTypes.RubPlugin[] = [];
+  public plugins: RubPlugin[] = [];
   public userGuid?: string;
   public handlers: {
-    [K in keyof ClientTypes.ContextMap]: ClientTypes.Handler<
-      ClientTypes.ContextMap[K]
-    >[];
+    [K in keyof ContextMap<unknown>]: Handler<ContextMap<unknown>[K]>[];
   } = {
     error: [],
     chat: [],
@@ -30,9 +34,9 @@ export default class Client extends Methods {
   public logger = new Logger<Client>(this.handlers.error, this);
 
   constructor(
-    private session: ClientTypes.SessionType,
+    private session: SessionType,
     public application: "Shad" | "Rubika" = "Rubika",
-    public platform: ClientTypes.PlatformType = "Web",
+    public platform: PlatformType = "Web",
     public timeout: number = 5000,
   ) {
     super();
@@ -42,25 +46,23 @@ export default class Client extends Methods {
     this.start();
   }
 
-  on<T extends keyof typeof this.handlers>(
-    type: T,
-    handler: (ctx: ClientTypes.ContextMap[T]) => Promise<void>,
+  on<T, K extends keyof typeof this.handlers>(
+    type: K,
+    handler: (ctx: ContextMap<T>[K]) => Promise<void>,
   ): void;
 
-  on<T extends keyof typeof this.handlers>(
-    type: T,
-    filters: Array<
-      (ctx: ClientTypes.ContextMap[T]) => boolean | Promise<boolean>
-    >,
-    handler: (ctx: ClientTypes.ContextMap[T]) => Promise<void>,
+  on<T, K extends keyof typeof this.handlers>(
+    type: K,
+    filters: Array<(ctx: ContextMap<T>[K]) => boolean | Promise<boolean>>,
+    handler: (ctx: ContextMap<T>[K]) => Promise<void>,
   ): void;
 
-  on<T extends keyof typeof this.handlers>(
-    type: T,
+  on<T, K extends keyof typeof this.handlers>(
+    type: K,
     filtersOrHandler:
-      | Array<(ctx: ClientTypes.ContextMap[T]) => boolean | Promise<boolean>>
-      | ((ctx: ClientTypes.ContextMap[T]) => Promise<void>),
-    maybeHandler?: (ctx: ClientTypes.ContextMap[T]) => Promise<void>,
+      | Array<(ctx: ContextMap<T>[K]) => boolean | Promise<boolean>>
+      | ((ctx: ContextMap<T>[K]) => Promise<void>),
+    maybeHandler?: (ctx: ContextMap<T>[K]) => Promise<void>,
   ) {
     if (typeof filtersOrHandler === "function") {
       this.handlers[type].push({
@@ -73,27 +75,27 @@ export default class Client extends Methods {
         handler: maybeHandler,
       });
     } else {
-      return new Error("Invalid arguments for on()");
+      new Error("Invalid arguments for on()");
     }
   }
 
-  command(
+  command<T>(
     prefix: string | RegExp,
-    handler: (ctx: Message) => Promise<void>,
+    handler: (ctx: Message<T>) => Promise<void>,
   ): void;
 
-  command(
+  command<T>(
     prefix: string | RegExp,
-    filters: Array<(ctx: Message) => boolean | Promise<boolean>>,
-    handler: (ctx: Message) => Promise<void>,
+    filters: Array<(ctx: Message<T>) => boolean | Promise<boolean>>,
+    handler: (ctx: Message<T>) => Promise<void>,
   ): void;
 
-  command(
+  command<T>(
     prefix: string | RegExp,
     filtersOrHandler:
-      | Array<(ctx: Message) => boolean | Promise<boolean>>
-      | ((ctx: Message) => Promise<void>),
-    maybeHandler?: (ctx: Message) => Promise<void>,
+      | Array<(ctx: Message<T>) => boolean | Promise<boolean>>
+      | ((ctx: Message<T>) => Promise<void>),
+    maybeHandler?: (ctx: Message<T>) => Promise<void>,
   ) {
     if (typeof filtersOrHandler === "function") {
       this.handlers["message"].push({
@@ -108,7 +110,7 @@ export default class Client extends Methods {
         prefix,
       });
     } else {
-      return new Error("Invalid arguments for command()");
+      new Error("Invalid arguments for command()");
     }
   }
 }

package/client/contexts/activities.type.ts

@@ -2,12 +2,12 @@ import { inspect } from "util";
 import { Client } from "../../..";
 import { DecoratorsTypes } from "../types/index.type";
 
-class Activities implements DecoratorsTypes.ShowActivities {
+class Activities<T> implements DecoratorsTypes.ShowActivities {
   type: string;
   object_guid: string;
   object_type: string;
   user_activity_guid: string;
-  store: Record<string, any> = {};
+  store: Partial<T> = {};
 
   declare client: Client;
 

package/client/contexts/chat.type.ts

@@ -2,14 +2,14 @@ import { inspect } from "util";
 import { Client } from "../../..";
 import { DecoratorsTypes } from "../types/index.type";
 
-class Chat implements DecoratorsTypes.ChatUpdates {
+class Chat<T> implements DecoratorsTypes.ChatUpdates {
   object_guid: string;
   action: string;
   chat: DecoratorsTypes.Chat;
   updated_parameters: string[];
   timestamp: string;
   type: string;
-  store: Record<string, any> = {};
+  store: Partial<T> = {};
 
   declare client: Client;
 

package/client/contexts/message.type.ts

@@ -18,11 +18,11 @@ const getOriginalType = (message: any) => {
   }
 };
 
-class Message implements DecoratorsTypes.MessageUpdate {
+class Message<T> implements DecoratorsTypes.MessageUpdate {
   message_id: string;
   action: string;
   message: DecoratorsTypes.Message;
-  updated_parameters: any[];
+  updated_parameters: string[];
   timestamp: string;
   prev_message_id: string;
   object_guid: string;
@@ -30,7 +30,7 @@ class Message implements DecoratorsTypes.MessageUpdate {
   state: string;
   client_guid: string;
   is_scheduled: boolean;
-  store: Record<string, any> = {};
+  store: Partial<T> = {};
 
   declare client: Client;
   declare originalType: string;
@@ -59,6 +59,7 @@ class Message implements DecoratorsTypes.MessageUpdate {
     object_guid?: string,
     message_id?: string,
     auto_delete?: number,
+    aux_data?: { button_id: string },
     file_inline?: string | Buffer<ArrayBufferLike>,
     type?: string,
     is_spoil?: boolean,
@@ -70,6 +71,7 @@ class Message implements DecoratorsTypes.MessageUpdate {
       text,
       message_id || this.message_id,
       file_inline,
+      aux_data,
       type,
       is_spoil,
       thumb,
@@ -107,6 +109,7 @@ class Message implements DecoratorsTypes.MessageUpdate {
       object_guid,
       reply_to_message_id,
       auto_delete,
+      undefined,
       image,
       "Image",
       is_spoil,
@@ -128,6 +131,7 @@ class Message implements DecoratorsTypes.MessageUpdate {
       object_guid,
       reply_to_message_id,
       auto_delete,
+      undefined,
       video,
       "Video",
       is_spoil,
@@ -149,6 +153,7 @@ class Message implements DecoratorsTypes.MessageUpdate {
       object_guid,
       reply_to_message_id,
       auto_delete,
+      undefined,
       gif,
       "Gif",
       is_spoil,
@@ -170,6 +175,7 @@ class Message implements DecoratorsTypes.MessageUpdate {
       object_guid,
       reply_to_message_id,
       auto_delete,
+      undefined,
       music,
       "Music",
       is_spoil,
@@ -191,6 +197,7 @@ class Message implements DecoratorsTypes.MessageUpdate {
       object_guid,
       reply_to_message_id,
       auto_delete,
+      undefined,
       voice,
       "Voice",
       is_spoil,

package/client/contexts/notifications.type.ts

@@ -2,14 +2,14 @@ import { inspect } from "util";
 import { Client } from "../../..";
 import { DecoratorsTypes } from "../types/index.type";
 
-class Notifications implements DecoratorsTypes.ShowNotifications {
+class Notifications<T> implements DecoratorsTypes.ShowNotifications {
   notification_id: string;
   type: string;
   title: string;
   text: string;
   image_file_id?: number;
   message_data: DecoratorsTypes.MessageData;
-  store: Record<string, any> = {};
+  store: Partial<T> = {};
 
   declare client: Client;
 

package/client/crypto.ts

@@ -93,12 +93,12 @@ class Crypto {
     const keyPair = new NodeRSA({
       b: 1024,
     });
-    let publicKey = Crypto.decode_auth(
+    const publicKey = Crypto.decode_auth(
       Buffer.from(keyPair.exportKey('pkcs1-public-pem'), 'binary').toString(
         'base64',
       ),
     );
-    let privateKey = keyPair.exportKey('pkcs1-private-pem');
+    const privateKey = keyPair.exportKey('pkcs1-private-pem');
     return [publicKey, privateKey];
   }