rubjs 2.9.3 → 3.0.1

package/lib/core/client.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const network_1 = __importDefault(require("./network"));
+const methods_1 = __importDefault(require("./methods"));
+const session_1 = __importDefault(require("./session"));
+class Client extends methods_1.default {
+    constructor(session, platform = 'Web', timeout = 5000) {
+        super();
+        this.session = session;
+        this.platform = platform;
+        this.timeout = timeout;
+        this.initialize = false;
+        this.plugins = [];
+        this.errorMiddlewares = [];
+        this.handlers = {
+            chat: [],
+            message: [],
+            activities: [],
+            notifications: [],
+        };
+        this.sessionDb = new session_1.default(this.session);
+        this.network = new network_1.default(this);
+        this.start();
+    }
+    on(type, filtersOrHandler, maybeHandler) {
+        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,
+            });
+        }
+        else {
+            throw new Error('Invalid arguments for on()');
+        }
+    }
+    command(prefix, filtersOrHandler, maybeHandler) {
+        if (typeof filtersOrHandler === 'function') {
+            this.handlers['message'].push({
+                filters: [],
+                handler: filtersOrHandler,
+                prefix,
+            });
+        }
+        else if (Array.isArray(filtersOrHandler) && maybeHandler) {
+            this.handlers['message'].push({
+                filters: filtersOrHandler,
+                handler: maybeHandler,
+                prefix,
+            });
+        }
+        else {
+            throw new Error('Invalid arguments for command()');
+        }
+    }
+}
+exports.default = Client;

package/lib/core/context/activities.type.d.ts

@@ -0,0 +1,12 @@
+import { Client } from '../..';
+import { DecoratorsTypes } from '../../types/index.type';
+declare class Activities implements DecoratorsTypes.ShowActivities {
+    type: string;
+    object_guid: string;
+    object_type: string;
+    user_activity_guid: string;
+    store: Record<string, any>;
+    client: Client;
+    constructor(client: Client, update: DecoratorsTypes.ShowActivities);
+}
+export default Activities;

package/lib/core/context/activities.type.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Activities {
+    constructor(client, update) {
+        this.store = {};
+        Object.defineProperty(this, 'client', {
+            value: client,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+        this.type = update.type;
+        this.object_guid = update.object_guid;
+        this.object_type = update.object_type;
+        this.user_activity_guid = update.user_activity_guid;
+    }
+}
+exports.default = Activities;

package/lib/core/context/chat.type.d.ts

@@ -0,0 +1,14 @@
+import { Client } from '../..';
+import { DecoratorsTypes } from '../../types/index.type';
+declare class Chat implements DecoratorsTypes.ChatUpdates {
+    object_guid: string;
+    action: string;
+    chat: DecoratorsTypes.Chat;
+    updated_parameters: string[];
+    timestamp: string;
+    type: string;
+    store: Record<string, any>;
+    client: Client;
+    constructor(client: Client, update: DecoratorsTypes.ChatUpdates);
+}
+export default Chat;

package/lib/core/context/chat.type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Chat {
+    constructor(client, update) {
+        this.store = {};
+        Object.defineProperty(this, 'client', {
+            value: client,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+        this.object_guid = update.object_guid;
+        this.action = update.action;
+        this.chat = update.chat;
+        this.updated_parameters = update.updated_parameters;
+        this.timestamp = update.timestamp;
+        this.type = update.type;
+    }
+}
+exports.default = Chat;

package/lib/core/context/contextConstructors.d.ts

@@ -0,0 +1,10 @@
+import Activities from './activities.type';
+import Chat from './chat.type';
+import Message from './message.type';
+import Notifications from './notifications.type';
+export declare const ContextConstructors: {
+    message: typeof Message;
+    chat: typeof Chat;
+    activities: typeof Activities;
+    notifications: typeof Notifications;
+};

package/lib/core/context/contextConstructors.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextConstructors = void 0;
+const activities_type_1 = __importDefault(require("./activities.type"));
+const chat_type_1 = __importDefault(require("./chat.type"));
+const message_type_1 = __importDefault(require("./message.type"));
+const notifications_type_1 = __importDefault(require("./notifications.type"));
+exports.ContextConstructors = {
+    message: message_type_1.default,
+    chat: chat_type_1.default,
+    activities: activities_type_1.default,
+    notifications: notifications_type_1.default,
+};

package/lib/core/context/index.d.ts

@@ -0,0 +1,5 @@
+import Activities from './activities.type';
+import Chat from './chat.type';
+import Message from './message.type';
+import Notifications from './notifications.type';
+export { Activities, Chat, Message, Notifications };

package/lib/core/context/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notifications = exports.Message = exports.Chat = exports.Activities = void 0;
+const activities_type_1 = __importDefault(require("./activities.type"));
+exports.Activities = activities_type_1.default;
+const chat_type_1 = __importDefault(require("./chat.type"));
+exports.Chat = chat_type_1.default;
+const message_type_1 = __importDefault(require("./message.type"));
+exports.Message = message_type_1.default;
+const notifications_type_1 = __importDefault(require("./notifications.type"));
+exports.Notifications = notifications_type_1.default;

package/lib/core/context/message.type.d.ts

@@ -0,0 +1,26 @@
+import { Client } from '../..';
+import { DecoratorsTypes } from '../../types/index.type';
+declare class Message implements DecoratorsTypes.MessageUpdate {
+    message_id: string;
+    action: string;
+    message: DecoratorsTypes.Message;
+    updated_parameters: any[];
+    timestamp: string;
+    prev_message_id: string;
+    object_guid: string;
+    type: string;
+    state: string;
+    client_guid: string;
+    store: Record<string, any>;
+    client: Client;
+    originalType: string;
+    constructor(client: Client, update: DecoratorsTypes.MessageUpdate);
+    reply(text?: string, object_guid?: string, message_id?: string, auto_delete?: number, file_inline?: string | Buffer<ArrayBufferLike>, type?: string, is_spoil?: boolean, thumb?: string, audio_info?: boolean): Promise<any>;
+    pin(object_guid?: string, message_id?: string, action?: 'Pin' | 'Unpin'): Promise<any>;
+    reply_photo(photo: string | Buffer<ArrayBufferLike>, caption?: string, object_guid?: string, auto_delete?: number, reply_to_message_id?: string, is_spoil?: boolean, thumb?: string): Promise<any>;
+    forward(to_object_guid: string): Promise<any>;
+    delete(): Promise<any>;
+    reaction(reaction_id: number, object_guid?: string, message_id?: string, action?: 'Add' | 'Remove'): Promise<any>;
+    getReplyMessage(object_guid?: string, message_id?: string): Promise<any>;
+}
+export default Message;

package/lib/core/context/message.type.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getOriginalType = (message) => {
+    try {
+        if (!message?.message?.type)
+            return 'Delete';
+        if (message.message.type.includes('FileInline')) {
+            return message.message.file_inline?.type;
+        }
+        if (message.message.type === 'Event') {
+            return message.message.event_data.type;
+        }
+        return message.message.type;
+    }
+    catch (e) {
+        console.log(e, message);
+    }
+};
+class Message {
+    constructor(client, update) {
+        this.store = {};
+        Object.defineProperty(this, 'client', {
+            value: client,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+        Object.defineProperty(this, 'originalType', {
+            value: getOriginalType(update),
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+        this.client_guid = update.client_guid;
+        this.message_id = update.message_id;
+        this.action = update.action;
+        this.message = update.message;
+        this.updated_parameters = update.updated_parameters;
+        this.timestamp = update.timestamp;
+        this.prev_message_id = update.prev_message_id;
+        this.object_guid = update.object_guid;
+        this.type = update.type;
+        this.state = update.state;
+    }
+    async reply(text, object_guid, message_id, auto_delete, file_inline, type, is_spoil, thumb, audio_info) {
+        return await this.client.sendMessage(object_guid || this.object_guid, text, message_id || this.message_id, file_inline, type, is_spoil, thumb, audio_info, auto_delete);
+    }
+    async pin(object_guid, message_id, action = 'Pin') {
+        return await this.client.setPinMessage(object_guid || this.object_guid, message_id || this.message_id, action);
+    }
+    async reply_photo(photo, caption, object_guid, auto_delete, reply_to_message_id, is_spoil, thumb) {
+        return await this.reply(caption, object_guid, reply_to_message_id, auto_delete, photo, 'Image', is_spoil, thumb);
+    }
+    async forward(to_object_guid) {
+        return await this.client.forwardMessages(this.object_guid, to_object_guid, [
+            this.message_id,
+        ]);
+    }
+    async delete() {
+        return await this.client.deleteMessages(this.object_guid, [
+            this.message_id,
+        ]);
+    }
+    async reaction(reaction_id, object_guid, message_id, action = 'Add') {
+        return await this.client.actionOnMessageReaction(object_guid || this.object_guid, message_id || this.message_id, reaction_id, action);
+    }
+    async getReplyMessage(object_guid, message_id) {
+        const result = await this.client.getMessagesByID(object_guid || this.object_guid, message_id || [this.message.reply_to_message_id]);
+        return result.messages[0];
+    }
+}
+exports.default = Message;

package/lib/core/context/notifications.type.d.ts

@@ -0,0 +1,14 @@
+import { Client } from '../..';
+import { DecoratorsTypes } from '../../types/index.type';
+declare class Notifications implements DecoratorsTypes.ShowNotifications {
+    notification_id: string;
+    type: string;
+    title: string;
+    text: string;
+    image_file_id?: number;
+    message_data: DecoratorsTypes.MessageData;
+    store: Record<string, any>;
+    client: Client;
+    constructor(client: Client, update: DecoratorsTypes.ShowNotifications);
+}
+export default Notifications;

package/lib/core/context/notifications.type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Notifications {
+    constructor(client, update) {
+        this.store = {};
+        Object.defineProperty(this, 'client', {
+            value: client,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+        this.notification_id = update.notification_id;
+        this.type = update.type;
+        this.title = update.title;
+        this.text = update.text;
+        this.image_file_id = update.image_file_id;
+        this.message_data = update.message_data;
+    }
+}
+exports.default = Notifications;

package/lib/core/crypto.d.ts

@@ -0,0 +1,12 @@
+declare class Crypto {
+    static AES_IV: Buffer<ArrayBuffer>;
+    static decode_auth: (auth: string) => string;
+    static passphrase(auth: string): string;
+    static secret(length: number): string;
+    static decrypt(data_enc: string, key: Buffer<ArrayBufferLike>): string;
+    static encrypt(data: string, key: Buffer<ArrayBufferLike>): string;
+    static sign(data_enc: string, privateKey: string): string;
+    static createKeys(): string[];
+    static decrypt_RSA_OAEP(private_key: string, data: string): string;
+}
+export default Crypto;

package/lib/core/crypto.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_rsa_1 = __importDefault(require("node-rsa"));
+const crypto_1 = __importDefault(require("crypto"));
+class Crypto {
+    static passphrase(auth) {
+        if (auth.length !== 32) {
+            throw new Error('auth length should be 32 digits');
+        }
+        const resultList = [];
+        const chunks = auth.match(/.{8}/g);
+        if (!chunks || chunks.length !== 4) {
+            throw new Error('Invalid auth format');
+        }
+        const combined = chunks[2] + chunks[0] + chunks[3] + chunks[1];
+        for (const character of combined) {
+            const newChar = String.fromCharCode(((character.charCodeAt(0) - 97 + 9) % 26) + 97);
+            resultList.push(newChar);
+        }
+        return resultList.join('');
+    }
+    static secret(length) {
+        if (length <= 0 || !Number.isInteger(length)) {
+            throw new Error('Length must be a positive integer');
+        }
+        const characters = 'abcdefghijklmnopqrstuvwxyz';
+        let secret = '';
+        for (let i = 0; i < length; i++) {
+            const randomIndex = Math.floor(Math.random() * characters.length);
+            secret += characters[randomIndex];
+        }
+        return secret;
+    }
+    static decrypt(data_enc, key) {
+        const decipher = crypto_1.default.createDecipheriv('aes-256-cbc', key, this.AES_IV);
+        let decrypted = decipher.update(data_enc, 'base64', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+    static encrypt(data, key) {
+        const cipher = crypto_1.default.createCipheriv('aes-256-cbc', key, this.AES_IV);
+        let encrypted = cipher.update(data, 'utf8', 'base64');
+        encrypted += cipher.final('base64');
+        return encrypted;
+    }
+    static sign(data_enc, privateKey) {
+        if (!privateKey) {
+            throw new Error('Private key is not defined');
+        }
+        const sign = crypto_1.default.createSign('SHA256');
+        sign.update(data_enc);
+        sign.end();
+        const signature = sign.sign(privateKey, 'base64');
+        return signature;
+    }
+    static createKeys() {
+        const keyPair = new node_rsa_1.default({
+            b: 1024,
+        });
+        let publicKey = Crypto.decode_auth(Buffer.from(keyPair.exportKey('pkcs1-public-pem'), 'binary').toString('base64'));
+        let privateKey = keyPair.exportKey('pkcs1-private-pem');
+        return [publicKey, privateKey];
+    }
+    static decrypt_RSA_OAEP(private_key, data) {
+        const keyPair = new node_rsa_1.default(private_key);
+        const decrypted = keyPair.decrypt(data, 'utf8');
+        return decrypted;
+    }
+}
+Crypto.AES_IV = Buffer.alloc(16, 0);
+Crypto.decode_auth = (auth) => {
+    let n = '';
+    const lowercase = 'abcdefghijklmnopqrstuvwxyz';
+    const uppercase = lowercase.toUpperCase();
+    const digits = '0123456789';
+    for (const s of auth) {
+        if (lowercase.includes(s)) {
+            n += String.fromCharCode(((32 - (s.charCodeAt(0) - 97)) % 26) + 97);
+        }
+        else if (uppercase.includes(s)) {
+            n += String.fromCharCode(((29 - (s.charCodeAt(0) - 65)) % 26) + 65);
+        }
+        else if (digits.includes(s)) {
+            n += String.fromCharCode(((13 - (s.charCodeAt(0) - 48)) % 10) + 48);
+        }
+        else {
+            n += s;
+        }
+    }
+    return n;
+};
+exports.default = Crypto;

package/lib/core/filters.d.ts

@@ -0,0 +1,33 @@
+import { MessageUpdate, FileInline } from "../types/decorators.type";
+declare class Filters {
+    static findKey(message: any, key: string): any;
+    static guidType(message: MessageUpdate, startWith: string): boolean;
+    static isMention(message: MessageUpdate): boolean;
+    static isMarkdown(message: MessageUpdate): boolean;
+    static isReply(message: MessageUpdate): boolean;
+    static isEdited(message: MessageUpdate): boolean;
+    static isLink(message: MessageUpdate): boolean;
+    static isText(message: MessageUpdate): boolean;
+    static isGroup(message: MessageUpdate): boolean;
+    static isChannel(message: MessageUpdate): boolean;
+    static isPrivate(message: MessageUpdate): boolean;
+    static isForward(message: MessageUpdate): boolean;
+    static fileInline(message: MessageUpdate): FileInline | undefined;
+    static isFileInline(message: MessageUpdate): boolean;
+    static isFile(message: MessageUpdate): boolean;
+    static isPhoto(message: MessageUpdate): boolean;
+    static isSticker(message: MessageUpdate): boolean;
+    static isVideo(message: MessageUpdate): boolean;
+    static isVoice(message: MessageUpdate): boolean;
+    static isGif(message: MessageUpdate): boolean;
+    static isMusic(message: MessageUpdate): boolean;
+    static isLocation(message: MessageUpdate): boolean;
+    static isContact(message: MessageUpdate): boolean;
+    static isPoll(message: MessageUpdate): boolean;
+    static isLive(message: MessageUpdate): boolean;
+    static isEvent(message: MessageUpdate): boolean;
+    static isLength(length: number, object_guid?: string): (message: MessageUpdate) => boolean;
+    static startsWithCommand(text: string, object_guid?: string, length?: number): (message: MessageUpdate) => boolean | undefined;
+    static equalCommand(text: string, object_guid?: string): (message: MessageUpdate) => boolean | undefined;
+}
+export default Filters;

package/lib/core/filters.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Filters {
+    static findKey(message, key) {
+        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 guidType(message, startWith) {
+        const result = Filters.findKey(message, "object_guid");
+        return result?.startsWith(startWith) ?? false;
+    }
+    static isMention(message) {
+        return !!Filters.findKey(message.message?.metadata?.meta_data_parts, "link");
+    }
+    static isMarkdown(message) {
+        return !!Filters.findKey(message.message, "metadata");
+    }
+    static isReply(message) {
+        return !!Filters.findKey(message, "reply_to_message_id");
+    }
+    static isEdited(message) {
+        return !!Filters.findKey(message, "is_edited");
+    }
+    static isLink(message) {
+        const link = Filters.findKey(message, "text");
+        if (!link)
+            return false;
+        const RUBIKA_LINK_PATTERN = /\brubika\.ir\b/;
+        const USERNAME_PATTERN = /@([a-zA-Z0-9_]{3,32})/;
+        return (link.includes("http") ||
+            RUBIKA_LINK_PATTERN.test(link) ||
+            USERNAME_PATTERN.test(link));
+    }
+    static isText(message) {
+        return !!Filters.findKey(message, "text");
+    }
+    static isGroup(message) {
+        return Filters.guidType(message, "g0");
+    }
+    static isChannel(message) {
+        return Filters.guidType(message, "c0");
+    }
+    static isPrivate(message) {
+        return Filters.guidType(message, "u0");
+    }
+    static isForward(message) {
+        return !!Filters.findKey(message, "forwarded_from");
+    }
+    static fileInline(message) {
+        return message.message?.file_inline;
+    }
+    static isFileInline(message) {
+        return ["FileInline", "FileInlineCaption"].includes(message.message?.type);
+    }
+    static isFile(message) {
+        return Filters.fileInline(message)?.type === "File";
+    }
+    static isPhoto(message) {
+        return Filters.fileInline(message)?.type === "Image";
+    }
+    static isSticker(message) {
+        return Filters.fileInline(message)?.type === "Sticker";
+    }
+    static isVideo(message) {
+        return Filters.fileInline(message)?.type === "Video";
+    }
+    static isVoice(message) {
+        return Filters.fileInline(message)?.type === "Voice";
+    }
+    static isGif(message) {
+        return Filters.fileInline(message)?.type === "Gif";
+    }
+    static isMusic(message) {
+        return Filters.fileInline(message)?.type === "Music";
+    }
+    static isLocation(message) {
+        return !!Filters.findKey(message.message, "location");
+    }
+    static isContact(message) {
+        return !!Filters.findKey(message.message, "contact_message");
+    }
+    static isPoll(message) {
+        return !!Filters.findKey(message, "poll");
+    }
+    static isLive(message) {
+        return !!Filters.findKey(message, "live_data");
+    }
+    static isEvent(message) {
+        return !!Filters.findKey(message, "event_data");
+    }
+    static isLength(length, object_guid) {
+        return (message) => {
+            if (object_guid) {
+                if (object_guid !== message.object_guid)
+                    return false;
+            }
+            if (message?.message?.text) {
+                return message?.message?.text.length === length;
+            }
+            return false;
+        };
+    }
+    static startsWithCommand(text, object_guid, length) {
+        return (message) => {
+            if (object_guid) {
+                if (object_guid !== message.object_guid)
+                    return false;
+            }
+            if (message?.message?.text) {
+                if (length) {
+                    if (message?.message?.text.length !== length)
+                        return false;
+                }
+                return message.message.text.startsWith(text);
+            }
+        };
+    }
+    static equalCommand(text, object_guid) {
+        return (message) => {
+            if (object_guid) {
+                if (object_guid !== message.object_guid)
+                    return false;
+            }
+            if (message?.message?.text) {
+                return message.message.text === text;
+            }
+        };
+    }
+}
+exports.default = Filters;

package/lib/core/methods/advanced/builder.d.ts

@@ -0,0 +1,3 @@
+import Client from '../../client';
+declare function builder(this: Client, name: string, input: object, tmp_session?: boolean): Promise<any>;
+export default builder;

package/lib/core/methods/advanced/builder.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("../../crypto"));
+async function builder(name, input, tmp_session = false) {
+    if (!this.auth)
+        this.auth = crypto_1.default.secret(32);
+    if (!this.key)
+        this.key = Buffer.from(crypto_1.default.passphrase(this.auth), 'utf8');
+    let result = await this.network.send({
+        input,
+        tmp_session,
+        method: name,
+    });
+    if (result) {
+        const data_enc = result.data_enc;
+        if (data_enc) {
+            const decrypted = crypto_1.default.decrypt(data_enc, this.key);
+            result = JSON.parse(decrypted);
+        }
+        const status = result.status;
+        const status_det = result.status_det;
+        if (status == 'OK' && status_det == 'OK') {
+            return result.data;
+        }
+    }
+}
+exports.default = builder;

package/lib/core/methods/auth/logout.d.ts

@@ -0,0 +1,3 @@
+import Client from "../../client";
+declare function logout(this: Client): Promise<any>;
+export default logout;

package/lib/core/methods/auth/logout.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function logout() {
+    return await this.builder("logout", {});
+}
+exports.default = logout;

package/lib/core/methods/auth/registerDevice.d.ts

@@ -0,0 +1,3 @@
+import Client from "../../client";
+declare function registerDevice(this: Client): Promise<void>;
+export default registerDevice;