rubjs 3.2.2 → 3.2.3

package/lib/core/bot/methods/index.d.ts

@@ -35,7 +35,8 @@ export default class Methods {
     start(this: Bot, ...args: Parameters<typeof Utilities.start>): Promise<any>;
     run(this: Bot, ...args: Parameters<typeof Utilities.run>): Promise<any>;
     getUpdates(this: Bot, ...args: Parameters<typeof Utilities.getUpdates>): Promise<any>;
-    setupWebhook(this: Bot, ...args: Parameters<typeof Utilities.setupWebhook>): Promise<any>;
+    __setupWebhook(this: Bot, ...args: Parameters<typeof Utilities.setupWebhook>): Promise<any>;
+    __polling(this: Bot, ...args: Parameters<typeof Utilities.polling>): Promise<any>;
     setCommands(this: Bot, ...args: Parameters<typeof Settings.setCommands>): Promise<any>;
     updateBotEndpoints(this: Bot, ...args: Parameters<typeof Settings.updateBotEndpoints>): Promise<any>;
 }

package/lib/core/bot/methods/index.js

@@ -123,9 +123,12 @@ class Methods {
     async getUpdates(...args) {
         return Utilities.getUpdates.apply(this, args);
     }
-    async setupWebhook(...args) {
+    async __setupWebhook(...args) {
         return Utilities.setupWebhook.apply(this, args);
     }
+    async __polling(...args) {
+        return Utilities.polling.apply(this, args);
+    }
     // settings
     async setCommands(...args) {
         return Settings.setCommands.apply(this, args);

package/lib/core/bot/methods/utilities/index.d.ts

@@ -1,5 +1,6 @@
 import run from './run';
 import start from './start';
+import polling from './polling';
 import getUpdates from './getUpdates';
 import setupWebhook from './webhook';
-export { run, start, getUpdates, setupWebhook };
+export { run, start, getUpdates, setupWebhook, polling };

package/lib/core/bot/methods/utilities/index.js

@@ -3,11 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupWebhook = exports.getUpdates = exports.start = exports.run = void 0;
+exports.polling = exports.setupWebhook = exports.getUpdates = exports.start = exports.run = void 0;
 const run_1 = __importDefault(require("./run"));
 exports.run = run_1.default;
 const start_1 = __importDefault(require("./start"));
 exports.start = start_1.default;
+const polling_1 = __importDefault(require("./polling"));
+exports.polling = polling_1.default;
 const getUpdates_1 = __importDefault(require("./getUpdates"));
 exports.getUpdates = getUpdates_1.default;
 const webhook_1 = __importDefault(require("./webhook"));

package/lib/core/bot/methods/utilities/polling.d.ts

@@ -0,0 +1,2 @@
+import Bot from '../../bot';
+export default function polling(this: Bot): Promise<void>;

package/lib/core/bot/methods/utilities/polling.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = polling;
+const fs_1 = __importDefault(require("fs"));
+const update_context_1 = __importDefault(require("../../contexts/update.context"));
+const models_1 = require("../../types/models");
+const checkFilters_1 = require("../../../../utils/checkFilters");
+const checkTypes = [models_1.UpdateTypeEnum.UpdatedMessage, models_1.UpdateTypeEnum.NewMessage];
+async function polling() {
+    console.log('start robot with polling mode...');
+    let next_offset_id = loadOffset();
+    setInterval(async () => {
+        try {
+            const res = await this.getUpdates(next_offset_id);
+            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 nowTime = Math.floor(Date.now() / 1000);
+                if (nowTime - messageTime < 5) {
+                    for (let { prefix, filters, handler } of this.handlers.update) {
+                        const ctx = new update_context_1.default(this, m);
+                        const passed = await (0, checkFilters_1.checkFilters)(ctx, filters);
+                        if (passed) {
+                            if (prefix) {
+                                if (!checkTypes.includes(ctx.type))
+                                    continue;
+                                const text = ctx.updated_message?.text || ctx.new_message?.text || '';
+                                if (typeof prefix === 'string' && text !== prefix)
+                                    continue;
+                                if (prefix instanceof RegExp && !prefix.test(text))
+                                    continue;
+                            }
+                            await handler(ctx);
+                        }
+                    }
+                }
+            }
+            if (res.next_offset_id) {
+                next_offset_id = res.next_offset_id;
+                saveOffset(next_offset_id);
+            }
+        }
+        catch (e) {
+            console.error('Error occurred while polling:', e);
+        }
+    }, 1000);
+}
+function saveOffset(offset) {
+    fs_1.default.writeFileSync('offset.json', JSON.stringify({ offset }));
+}
+function loadOffset() {
+    if (!fs_1.default.existsSync('offset.json'))
+        return undefined;
+    const data = fs_1.default.readFileSync('offset.json', 'utf8');
+    return JSON.parse(data).offset;
+}

package/lib/core/bot/methods/utilities/run.js

@@ -8,6 +8,9 @@ async function run(url, host, port = 3000, updates = [
     while (!this.initialize) {
         await this.network.delay(2000);
     }
-    await this.setupWebhook(url, host, port, updates);
+    if (url)
+        await this.__setupWebhook(url, host, port, updates);
+    else
+        await this.__polling();
 }
 exports.default = run;

package/lib/core/bot/methods/utilities/webhook.d.ts

@@ -1,4 +1,4 @@
 import Bot from '../../bot';
 import { UpdateEndpointTypeEnum } from '../../types/models';
-declare function setupWebhook(this: Bot, url?: string, host?: string, port?: number, updates?: UpdateEndpointTypeEnum[]): Promise<void>;
+declare function setupWebhook(this: Bot, url: string, host?: string, port?: number, updates?: UpdateEndpointTypeEnum[]): Promise<void>;
 export default setupWebhook;

package/lib/core/bot/methods/utilities/webhook.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const json_bigint_1 = __importDefault(require("json-bigint"));
 const handleUpdates_1 = __importDefault(require("./handleUpdates"));
-const localtunnel_1 = __importDefault(require("localtunnel"));
 const JSONbig = (0, json_bigint_1.default)({ storeAsString: true });
 function handleParser(_, body, done) {
     try {
@@ -16,31 +15,6 @@ function handleParser(_, body, done) {
         done(err, undefined);
     }
 }
-async function manageTunnelWithWebhook(port, updates, url) {
-    const setEndpoints = async (url) => {
-        for (let update of updates) {
-            const res = await this.updateBotEndpoints(url, update);
-            if (res.status != 'Done')
-                console.error(`[ manageTunnelWithWebhook ] status updateBotEndpoints is ${res.status} for update: ${update}`);
-        }
-        console.log('start robot...');
-    };
-    if (url) {
-        return await setEndpoints(url);
-    }
-    while (true) {
-        try {
-            const tunnel = await (0, localtunnel_1.default)({ port });
-            await setEndpoints(tunnel.url);
-            await new Promise((resolve) => tunnel.on('close', resolve));
-            console.warn('🚪 Tunnel closed. Reconnecting...');
-        }
-        catch (err) {
-            console.error('❌ Tunnel failed:', err);
-            await new Promise((r) => setTimeout(r, 3000));
-        }
-    }
-}
 function lowerFirstChar(str) {
     return str.charAt(0).toLowerCase() + str.slice(1);
 }
@@ -52,6 +26,11 @@ async function setupWebhook(url, host = '0.0.0.0', port = 3000, updates = []) {
         this.server.post(`/${lowerFirstChar(update)}`, handleUpdates_1.default.bind(this));
     }
     await this.server.listen({ port, host });
-    await manageTunnelWithWebhook.bind(this)(port, updates, url);
+    for (let update of updates) {
+        const res = await this.updateBotEndpoints(url, update);
+        if (res.status != 'Done')
+            console.error(`[ setupWebhook ] status updateBotEndpoints is ${res.status} for update: ${update}`);
+    }
+    console.log('start robot...');
 }
 exports.default = setupWebhook;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rubjs",
-	"version": "3.2.2",
+	"version": "3.2.3",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"keywords": [
@@ -34,6 +34,7 @@
 		"fastify": "^5.4.0",
 		"json-bigint": "^1.0.0",
 		"localtunnel": "npm:@security-patched/localtunnel@^2.0.2-secpatched.5",
+		"ngrok": "^5.0.0-beta.2",
 		"node-rsa": "^1.1.1",
 		"optional-require": "^2.0.1",
 		"undici": "^7.10.0",

package/lib/core/bot/contexts/message.context.d.ts

@@ -1,17 +0,0 @@
-import { Bot } from '../../..';
-import { PaymentStatus, Update as UpdateMessage, UpdateTypeEnum, Message as MessageUpdate, Keypad, ChatKeypadTypeEnum, InlineKeypad } from '../types/models';
-declare class Update implements UpdateMessage {
-    type: UpdateTypeEnum;
-    chat_id: string;
-    removed_message_id?: string;
-    new_message?: MessageUpdate;
-    updated_message?: MessageUpdate;
-    updated_payment?: PaymentStatus;
-    store: Record<string, any>;
-    bot: Bot;
-    constructor(bot: Bot, update: Update);
-    reply(text: string, chat_keypad?: Keypad, inline_keypad?: InlineKeypad, disable_notification?: boolean, reply_to_message_id?: string, chat_keypad_type?: ChatKeypadTypeEnum): Promise<import("../types/models").SendMessage>;
-    forward(to_chat_id: string, disable_notification?: boolean): Promise<import("../types/models").SendMessage | undefined>;
-    delete(): Promise<import("../types/models").SendMessage | undefined>;
-}
-export default Update;

package/lib/core/bot/contexts/message.context.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class Update {
-    constructor(bot, update) {
-        this.store = {};
-        Object.defineProperty(this, 'bot', {
-            value: bot,
-            enumerable: false,
-            writable: true,
-            configurable: true,
-        });
-        this.type = update.type;
-        this.chat_id = update.chat_id;
-        if (update?.new_message)
-            this.new_message = update?.new_message;
-        if (update?.updated_message)
-            this.updated_message = update?.updated_message;
-        if (update?.updated_payment)
-            this.updated_payment = update?.updated_payment;
-        if (update.removed_message_id)
-            this.removed_message_id = update.removed_message_id;
-    }
-    async reply(text, chat_keypad, inline_keypad, disable_notification = false, reply_to_message_id, chat_keypad_type) {
-        return await this.bot.sendMessage(this.chat_id, text, chat_keypad, inline_keypad, disable_notification, reply_to_message_id, chat_keypad_type);
-    }
-    async forward(to_chat_id, disable_notification = false) {
-        const message_id = this.new_message?.message_id || this.updated_message?.message_id;
-        if (!message_id)
-            return;
-        return await this.bot.forwardMessage(this.chat_id, message_id, to_chat_id, disable_notification);
-    }
-    async delete() {
-        const message_id = this.new_message?.message_id || this.updated_message?.message_id;
-        if (!message_id)
-            return;
-        return await this.bot.deleteMessage(this.chat_id, message_id);
-    }
-}
-exports.default = Update;

package/lib/core/bot/network/polling.js

@@ -1,44 +0,0 @@
-"use strict";
-// import fs from 'fs';
-// import Network from '.';
-// import Message from '../contexts/message.context';
-// export default async function polling(network: Network) {
-// 	console.log('start robot with polling mode...');
-// 	let next_offset_id: string | undefined = loadOffset();
-// 	setInterval(async () => {
-// 		try {
-// 			const res = await network.bot.getUpdates(next_offset_id);
-// 			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 nowTime = Math.floor(Date.now() / 1000);
-// 				if (nowTime - messageTime < 5) {
-// 					m = new Message(network.bot, m);
-// 					for (let handler of network.bot.handlers) {
-// 						if (
-// 							handler.filters.length === 0 ||
-// 							handler.filters.every((filter) => filter(m))
-// 						) {
-// 							await handler.handler(m);
-// 						}
-// 					}
-// 				}
-// 			}
-// 			if (res.next_offset_id) {
-// 				next_offset_id = res.next_offset_id;
-// 				saveOffset(next_offset_id as string);
-// 			}
-// 		} catch (e) {
-// 			console.error('Error occurred while polling:', e);
-// 		}
-// 	}, 1000);
-// }
-// function saveOffset(offset: string) {
-// 	fs.writeFileSync('offset.json', JSON.stringify({ offset }));
-// }
-// function loadOffset(): string | undefined {
-// 	if (!fs.existsSync('offset.json')) return undefined;
-// 	const data = fs.readFileSync('offset.json', 'utf8');
-// 	return JSON.parse(data).offset;
-// }