telegram-botbuilder 1.0.1 → 1.0.3

package/lib/bot-service.d.ts

@@ -1,14 +1,18 @@
 import TelegramBot from 'node-telegram-bot-api';
 import { Schema, Action } from './bot-struct';
 import EventEmitter from 'events';
+type BotBuilderMiddleware = (chat: number, msg: TelegramBot.Message | TelegramBot.CallbackQuery) => Promise<boolean> | boolean;
 export interface ActionCallback {
     chatid: number;
 }
-export declare class EasyBot {
+export declare class BotBuilder {
     private _bot;
     private _schema;
     ActionSystem: EventEmitter;
     private _userdialogs;
+    private _middleware;
+    use(func: BotBuilderMiddleware): void;
+    private _runmw;
     constructor(schema: Schema, token: string, options?: TelegramBot.ConstructorOptions);
     private _getDialog;
     private _getButton;
@@ -20,3 +24,4 @@ export declare class EasyBot {
 export declare function ChangeDialog(id: string): Action;
 export declare function CallbackAction(descriptor: string): Action;
 export declare function WaitForData(descriptor: string): Action;
+export {};

package/lib/bot-service.js

@@ -39,7 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EasyBot = void 0;
+exports.BotBuilder = void 0;
 exports.ChangeDialog = ChangeDialog;
 exports.CallbackAction = CallbackAction;
 exports.WaitForData = WaitForData;
@@ -47,9 +47,10 @@ var node_telegram_bot_api_1 = __importDefault(require("node-telegram-bot-api"));
 var events_1 = __importDefault(require("events"));
 var crypto_1 = require("crypto");
 var fs_1 = require("fs");
-var EasyBot = /** @class */ (function () {
-    function EasyBot(schema, token, options) {
+var BotBuilder = /** @class */ (function () {
+    function BotBuilder(schema, token, options) {
         var _this = this;
+        this._middleware = [];
         this._bot = new node_telegram_bot_api_1.default(token, options);
         this._schema = schema;
         this._schema.buttons = [];
@@ -63,47 +64,118 @@ var EasyBot = /** @class */ (function () {
         }
         this.ActionSystem = new events_1.default();
         this._userdialogs = {};
-        this._bot.onText(/\/start/, function (msg) {
-            if (!_this._userdialogs[msg.chat.id])
-                _this._userdialogs[msg.chat.id] = { dialog: _this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' } };
-            _this._bot.deleteMessage(msg.chat.id, msg.message_id).catch(function () { return undefined; });
-            _this.ChangeDialog(msg.chat.id, _this._schema.start);
-        });
-        this._bot.on('callback_query', function (query) {
-            if (!_this._userdialogs[query.message.chat.id])
-                _this._userdialogs[query.message.chat.id] = { dialog: _this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' } };
-            _this._activateButton(query.message.chat.id, query.data);
-        });
-        this._bot.onText(/.+/g, function (msg) {
-            var chat = msg.chat.id;
-            if (_this._userdialogs[chat].waiter.statewait) {
-                _this._userdialogs[chat].waiter.statewait = false;
-                _this._bot.deleteMessage(chat, msg.message_id).catch(function () { return undefined; });
-                _this.ActionSystem.emit(_this._userdialogs[chat].waiter.descriptor, chat, msg.text);
-            }
-        });
-        this._bot.on('document', function (msg) {
-            if (!msg.document)
-                return;
-            var chat = msg.chat.id;
-            if (!_this._userdialogs[chat].waiter.statewait)
-                return;
-            _this._bot.downloadFile(msg.document.file_id, './').then(function (x) {
-                _this._userdialogs[chat].waiter.statewait = false;
-                _this._bot.deleteMessage(chat, msg.message_id).catch(function () { return undefined; });
-                var content = (0, fs_1.readFileSync)(x, 'utf8');
-                (0, fs_1.rmSync)(x);
-                _this.ActionSystem.emit(_this._userdialogs[chat].waiter.descriptor, chat, content);
+        this._bot.onText(/\/start/, function (msg) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._runmw(msg.chat.id, msg)];
+                    case 1:
+                        if (_a.sent())
+                            return [2 /*return*/];
+                        if (!this._userdialogs[msg.chat.id])
+                            this._userdialogs[msg.chat.id] = { dialog: this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' } };
+                        this._bot.deleteMessage(msg.chat.id, msg.message_id).catch(function () { return undefined; });
+                        this.ChangeDialog(msg.chat.id, this._schema.start);
+                        return [2 /*return*/];
+                }
             });
-        });
+        }); });
+        this._bot.on('callback_query', function (query) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._runmw(query.message.chat.id, query)];
+                    case 1:
+                        if (_a.sent())
+                            return [2 /*return*/];
+                        if (!this._userdialogs[query.message.chat.id])
+                            this._userdialogs[query.message.chat.id] = { dialog: this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' } };
+                        this._activateButton(query.message.chat.id, query.data);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        this._bot.onText(/.+/g, function (msg) { return __awaiter(_this, void 0, void 0, function () {
+            var chat;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._runmw(msg.chat.id, msg)];
+                    case 1:
+                        if (_a.sent())
+                            return [2 /*return*/];
+                        chat = msg.chat.id;
+                        if (this._userdialogs[chat].waiter.statewait) {
+                            this._userdialogs[chat].waiter.statewait = false;
+                            this._bot.deleteMessage(chat, msg.message_id).catch(function () { return undefined; });
+                            this.ActionSystem.emit(this._userdialogs[chat].waiter.descriptor, chat, msg.text);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        this._bot.on('document', function (msg) { return __awaiter(_this, void 0, void 0, function () {
+            var chat;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._runmw(msg.chat.id, msg)];
+                    case 1:
+                        if (_a.sent())
+                            return [2 /*return*/];
+                        if (!msg.document)
+                            return [2 /*return*/];
+                        chat = msg.chat.id;
+                        if (!this._userdialogs[chat].waiter.statewait)
+                            return [2 /*return*/];
+                        this._bot.downloadFile(msg.document.file_id, './').then(function (x) {
+                            _this._userdialogs[chat].waiter.statewait = false;
+                            _this._bot.deleteMessage(chat, msg.message_id).catch(function () { return undefined; });
+                            var content = (0, fs_1.readFileSync)(x, 'utf8');
+                            (0, fs_1.rmSync)(x);
+                            _this.ActionSystem.emit(_this._userdialogs[chat].waiter.descriptor, chat, content);
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     }
-    EasyBot.prototype._getDialog = function (id) {
+    BotBuilder.prototype.use = function (func) {
+        this._middleware.push(func);
+    };
+    BotBuilder.prototype._runmw = function (chat, msg) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, _i, _a, mw, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        res = false;
+                        _i = 0, _a = this._middleware;
+                        _c.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 5];
+                        mw = _a[_i];
+                        _b = res;
+                        if (_b) return [3 /*break*/, 3];
+                        return [4 /*yield*/, mw(chat, msg)];
+                    case 2:
+                        _b = (_c.sent());
+                        _c.label = 3;
+                    case 3:
+                        res = _b;
+                        _c.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 5: return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    BotBuilder.prototype._getDialog = function (id) {
         return this._schema.content.find(function (x) { return x.id === id; });
     };
-    EasyBot.prototype._getButton = function (callback) {
+    BotBuilder.prototype._getButton = function (callback) {
         return this._schema.buttons.find(function (x) { return x._callback === callback; });
     };
-    EasyBot.prototype._activateButton = function (chat, btn) {
+    BotBuilder.prototype._activateButton = function (chat, btn) {
         return __awaiter(this, void 0, void 0, function () {
             var _btn, _i, _a, act;
             return __generator(this, function (_b) {
@@ -138,7 +210,7 @@ var EasyBot = /** @class */ (function () {
             });
         });
     };
-    EasyBot.prototype.ChangeDialog = function (chat, id) {
+    BotBuilder.prototype.ChangeDialog = function (chat, id) {
         return __awaiter(this, void 0, void 0, function () {
             var dialog, markup, b, _i, _a, btn, text_1, _b, text, _c, _d, msg;
             return __generator(this, function (_e) {
@@ -211,16 +283,16 @@ var EasyBot = /** @class */ (function () {
             });
         });
     };
-    EasyBot.prototype.AttachDataWait = function (chat, descriptor) {
+    BotBuilder.prototype.AttachDataWait = function (chat, descriptor) {
         this._userdialogs[chat].waiter.descriptor = descriptor;
         this._userdialogs[chat].waiter.statewait = true;
     };
-    EasyBot.prototype.Message = function (chat, content) {
+    BotBuilder.prototype.Message = function (chat, content) {
         return this._bot.sendMessage(chat, content);
     };
-    return EasyBot;
+    return BotBuilder;
 }());
-exports.EasyBot = EasyBot;
+exports.BotBuilder = BotBuilder;
 function ChangeDialog(id) {
     var _this = this;
     return function (chat, _bot) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {

package/lib/bot-struct.d.ts

@@ -1,5 +1,5 @@
-import { EasyBot } from "./bot-service";
-export type Action = (chat: number, _bot: EasyBot) => Promise<void>;
+import { BotBuilder } from "./bot-service";
+export type Action = (chat: number, _bot: BotBuilder) => Promise<void>;
 export interface Dialog {
     id: string;
     text: string | ((chat: number) => Promise<string>);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telegram-botbuilder",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/bot-service.ts

@@ -8,16 +8,30 @@ import { readFileSync, rmSync } from 'fs';
 interface UserDialog {
   [key: number]: {dialog: string, lastid: number, waiter: { statewait: boolean, descriptor: string }};
 }
+type BotBuilderMiddleware = (chat: number, msg: TelegramBot.Message | TelegramBot.CallbackQuery) => Promise<boolean> | boolean;
 
 export interface ActionCallback {
   chatid: number;
 }
 
-export class EasyBot {
+export class BotBuilder {
   private _bot: TelegramBot;
   private _schema: BotSchema;
   public ActionSystem: EventEmitter;
   private _userdialogs: UserDialog;
+  private _middleware: BotBuilderMiddleware[] = [];
+
+  public use(func: BotBuilderMiddleware) {
+    this._middleware.push(func);
+  }
+
+  private async _runmw(chat: number, msg: TelegramBot.Message | TelegramBot.CallbackQuery) {
+    let res = false;
+    for (let mw of this._middleware) {
+      res = res || await mw(chat, msg);
+    }
+    return res;
+  }
 
   constructor (schema: Schema, token: string, options?: TelegramBot.ConstructorOptions) {
     this._bot = new TelegramBot(token, options);
@@ -36,18 +50,24 @@ export class EasyBot {
     this.ActionSystem = new EventEmitter();
     this._userdialogs = {};
 
-    this._bot.onText(/\/start/, (msg) => {
+    this._bot.onText(/\/start/, async (msg) => {
+      if (await this._runmw(msg.chat.id, msg)) return;
+
       if (!this._userdialogs[msg.chat.id]) this._userdialogs[msg.chat.id] = {dialog: this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' }}
       this._bot.deleteMessage(msg.chat.id, msg.message_id).catch(() => undefined);
       this.ChangeDialog(msg.chat.id, this._schema.start);
     });
 
-    this._bot.on('callback_query', (query) => {
+    this._bot.on('callback_query', async (query) => {
+      if (await this._runmw(query.message!.chat.id, query)) return;
+
       if (!this._userdialogs[query.message!.chat.id]) this._userdialogs[query.message!.chat.id] = {dialog: this._schema.start, lastid: -1, waiter: { statewait: false, descriptor: '' }}
       this._activateButton(query.message!.chat.id, query.data!)
     });
 
-    this._bot.onText(/.+/g, (msg) => {
+    this._bot.onText(/.+/g, async (msg) => {
+      if (await this._runmw(msg.chat.id, msg)) return;
+
       let chat = msg.chat.id;
       if (this._userdialogs[chat].waiter.statewait) {
         this._userdialogs[chat].waiter.statewait = false;
@@ -56,7 +76,9 @@ export class EasyBot {
       }
     })
 
-    this._bot.on('document', (msg) => {
+    this._bot.on('document', async (msg) => {
+      if (await this._runmw(msg.chat.id, msg)) return;
+
       if (!msg.document) return;
       let chat = msg.chat.id;
       if (!this._userdialogs[chat].waiter.statewait) return;
@@ -128,13 +150,13 @@ export class EasyBot {
 }
 
 export function ChangeDialog(id: string): Action {
-  return async (chat: number, _bot: EasyBot) => { await _bot.ChangeDialog(chat, id); };
+  return async (chat: number, _bot: BotBuilder) => { await _bot.ChangeDialog(chat, id); };
 }
 export function CallbackAction(descriptor: string): Action {
-  return async (chat: number, _bot: EasyBot) => { _bot.ActionSystem.emit(descriptor, {chatid: chat}); };
+  return async (chat: number, _bot: BotBuilder) => { _bot.ActionSystem.emit(descriptor, {chatid: chat}); };
 }
 export function WaitForData(descriptor: string): Action {
-  return (chat: number, _bot: EasyBot) => { 
+  return (chat: number, _bot: BotBuilder) => { 
     _bot.AttachDataWait(chat, descriptor);
     return new Promise(r => {
       _bot.ActionSystem.once(descriptor, r);

package/src/bot-struct.ts

@@ -1,7 +1,7 @@
-import { EasyBot } from "./bot-service";
+import { BotBuilder } from "./bot-service";
 
 
-export type Action = (chat: number, _bot: EasyBot) => Promise<void>;
+export type Action = (chat: number, _bot: BotBuilder) => Promise<void>;
 
 export interface Dialog {
   id: string;