oira666_tg 1.0.0

package/apply_middlewares.js

@@ -0,0 +1,47 @@
+const session = require('./middleware/session');
+const message_info = require('./middleware/message_info');
+const auth = require('./middleware/auth');
+
+const keyboard = require('./middleware/keyboard');
+const {
+  apply_handler_to_action,
+  apply_handler_to_expected_input,
+  apply_handler_to_command,
+  apply_handler_to_text_button,
+  apply_handler_to_unhandled_messages,
+  run_handler
+} = require('./middleware/apply_handler');
+const { error_handler } = require('./middleware/error_handler');
+const { set_options } = require('./options');
+
+
+/**
+ *
+ * @param {*} bot
+ * @param {*} options
+ */
+const apply_middlewares = (bot, options) => {
+  set_options(bot, options);
+
+  bot.use(session);
+  bot.use(auth);
+  bot.use(keyboard);
+
+  // Порядок имеет значение
+  // Применяется только первый найденный обработчик,
+  // Остальные игнорируются
+  bot.action(/.*/, apply_handler_to_action);
+  bot.on('message', apply_handler_to_text_button);
+  bot.on('message', apply_handler_to_command);
+  bot.use(apply_handler_to_expected_input);
+  bot.use(apply_handler_to_unhandled_messages);
+
+  bot.use(message_info);
+
+  bot.use(run_handler);
+
+
+  bot.catch(error_handler);
+};
+
+module.exports.apply_middlewares = apply_middlewares;

package/index.js

@@ -0,0 +1,29 @@
+const { apply_middlewares } = require('./apply_middlewares');
+const { redirect_handler, apply_handler_to_cron_task } = require('./middleware/apply_handler');
+const { find_in_handlers } = require('./utils/find_in_handlers');
+const { send_empty_message } = require('./utils/send_empty_message');
+const { error_handler, notifyAdmins, error_403_handler, sendErrorToUser } = require('./middleware/error_handler');
+
+const { TelegramSession } = require('../source/classes/TelegramSession');
+const { User } = require('../source/classes/User');
+const { MessageInfoManager } = require('../source/classes/MessageInfoManager');
+
+// apply middlwares
+module.exports.apply_middlewares = apply_middlewares;
+
+// handle handlers
+module.exports.redirect_handler = redirect_handler;
+module.exports.apply_handler_to_cron_task = apply_handler_to_cron_task;
+module.exports.find_in_handlers = find_in_handlers;
+module.exports.send_empty_message = send_empty_message;
+
+// error handling
+module.exports.error_handler = error_handler;
+module.exports.notifyAdmins = notifyAdmins;
+module.exports.error_403_handler = error_403_handler;
+module.exports.sendErrorToUser = sendErrorToUser;
+
+// classes
+module.exports.TelegramSession = TelegramSession;
+module.exports.User = User;
+module.exports.MessageInfoManager = MessageInfoManager;

package/middleware/apply_handler.js

@@ -0,0 +1,236 @@
+const _ = require('lodash');
+const path = require('path');
+const { regexps } = require('../utils/regexps');
+const { _require } = require('../utils/_require');
+const { options } = require('../options');
+
+
+const MAX_handler_history_LENGTH = 5;
+
+
+/**
+ * Отправляет необработанные сообщения на обработчик unhandled_message.js
+ */
+const apply_handler_to_unhandled_messages = async (ctx, next) => {
+  // Если ввод уже был обработан другим обработчиком -
+  // ничего не делаем
+  if (!ctx.handler?.name) {
+    _add_handler_to_ctx(ctx, 'unhandled_message', 'unhandled_message');
+  }
+  await next();
+}
+
+
+/**
+ * Есди бот ожидает произовльного сообщения от пользователя
+ * в session.expected_input записывается имя обработчика,
+ * который готов обработать это сообщение.
+ * записывает его в ctx.handlername и применяет
+ */
+const apply_handler_to_expected_input = async (ctx, next) => {
+  // Если ввод уже был обработан другим обработчиком -
+  // ничего не делаем
+  if (!ctx.handler?.name) {
+
+    if (ctx.updateType === 'message') {
+      _add_handler_to_ctx(ctx, ctx.expected_input, 'expected_input');
+    }
+  }
+
+  ctx.expected_input = null;
+
+  await next();
+}
+
+const apply_handler_to_inline_query = async (ctx, next) => {
+  // Если ввод уже был обработан другим обработчиком -
+  // ничего не делаем
+  if (!ctx.handler?.name) {
+    _add_handler_to_ctx(ctx, 'inline_query', 'inline_query');
+  }
+  await next();
+}
+
+const apply_handler_to_chosen_inline_result = async (ctx, next) => {
+  // Если ввод уже был обработан другим обработчиком -
+  // ничего не делаем
+  if (!ctx.handler?.name) {
+    _add_handler_to_ctx(ctx, 'chosen_inline_result', 'chosen_inline_result');
+  }
+  await next();
+}
+
+
+const apply_handler_to_command = async (ctx, next) => {
+  // Если ввод уже был обработан другим обработчиком -
+  // ничего не делаем
+  if (!ctx.handler?.name) {
+    const is_command = (ctx?.message?.text || '').charAt(0) === '/';
+    if (is_command) {
+      const handlername = (ctx.message.text || '').slice(1);
+      const commandname = handlername.replace(/^(\w+).*$/i, '$1');
+      if (['admin', 'developer'].includes(ctx.user.role) || ~options.allowed_user_commands.indexOf(commandname)) {
+        _add_handler_to_ctx(ctx, handlername, 'command');
+      }
+    }
+  }
+
+  await next();
+}
+
+/**
+ * При создании текстовой кнопки в session.keyboard
+ * записывается соответствие текста и имени обработчика
+ * находит имя обработчика, соответствующее полученному тексту,
+ * записывает его в ctx.handlername и применяет
+ */
+const apply_handler_to_text_button = async (ctx, next) => {
+  // Если ввод уже был обработан другим обработчиком -
+  // ничего не делаем
+  if (!ctx.handler?.name) {
+    const button = _.find((ctx.keyboard || []), {caption: ctx.message.text}) || {};
+
+    _add_handler_to_ctx(ctx, button.action, 'text_button');
+  };
+
+  await next();
+}
+
+/**
+ * Имя действия обратного вызова является именем обработчика,
+ * записывает его в ctx.handlername и применяет
+ */
+const apply_handler_to_action = async (ctx, next) => {
+  // Если ввод уже был обработан другим обработчиком -
+  // ничего не делаем
+  if (!ctx.handler?.name) {
+    _add_handler_to_ctx(ctx, ctx.match.input, 'callback_action');
+  };
+  await ctx.telegram.answerCbQuery(ctx.update.callback_query.id);
+  await next();
+}
+
+/**
+ * Применяет новый обработчик, предыдущие записывает в историю
+ * @param {Context} ctx
+ * @param {String} handlername
+ */
+ const apply_handler_to_cron_task = async (ctx, handlername) => {
+  _add_handler_to_ctx(ctx, handlername, 'cron');
+  await run_handler(ctx);
+}
+
+
+/**
+ * Применяет новый обработчик, предыдущие записывает в историю
+ * @param {Context} ctx
+ * @param {String} handlername
+ */
+const redirect_handler = async (ctx, handlername) => {
+  const  current_handler = ctx.handler;
+  _add_handler_to_ctx(ctx, handlername, 'redirect');
+  await run_handler(ctx);
+  _add_handler_to_ctx(ctx, current_handler.name, current_handler.type);
+}
+
+
+const run_handler = async (ctx, next) => {
+  if (typeof ctx?.handler?.runner === 'function') {
+    await ctx.handler.runner(ctx);
+  }
+  if (typeof next === 'function') await next();
+
+  _add_handler_history(ctx);
+}
+
+/**
+ *
+ * @param {Object} ctx
+ * добавляет текущий обработчик в историю обработчиков
+ * которая сохраняется в сессии
+ */
+const _add_handler_history = (ctx) => {
+  if (!ctx.handler) return;
+  if (! ctx.handler_history) ctx.handler_history = [];
+
+  ctx.handler_history.unshift({
+    name: ctx.handler.name,
+    type: ctx.handler.type,
+    args: ctx.handler.args,
+    data: ctx.handler_history_data,
+  });
+
+  if (ctx.handler_history.length > MAX_handler_history_LENGTH) {
+    ctx.handler_history.splice(MAX_handler_history_LENGTH);
+  }
+}
+
+/**
+ * применяет обработчик из ctx.handler
+ * если такого обработчика нет - ничего не делает
+ */
+const _add_handler_to_ctx = (ctx, handlername, handlertype) => {
+  const current = _parse_handlername(handlername, handlertype);
+  if (!current.name) return;
+
+  // user paths
+  const user_handler_filepath = path.resolve(options.handlers_path, current.name + '.js');
+  const user_handler_filepath_main = path.resolve(options.handlers_path, current.name + '/main.js');
+  const user_handler_filepath_index = path.resolve(options.handlers_path, current.name + '/index.js');
+
+  // default paths
+  const handler_filepath = path.resolve(__dirname, '../source/handlers/', current.name + '.js');
+  const handler_filepath_main = path.resolve(__dirname, '../source/handlers/', current.name + '/main.js');
+  const handler_filepath_index = path.resolve(__dirname, '../source/handlers/', current.name + '/index.js');
+  const handler =  _require(
+    user_handler_filepath,
+    user_handler_filepath_main,
+    user_handler_filepath_index,
+    handler_filepath,
+    handler_filepath_main,
+    handler_filepath_index
+  );
+
+
+  if (typeof handler?.default === 'function') {
+    if (!ctx.handler) ctx.handler = {};
+
+    ctx.handler = { ...current };
+
+    ctx.handler.runner = handler.default;
+  }
+}
+
+
+
+/**
+ * Handlername имеет вид: "path/to/handler arg1 arg2 arg3"
+ * Current handler (вывод) имеет вид: { name, type, args: [] }
+ * @param {String} handlername
+ * @param {String} handlertype
+ * @returns Object - current handler
+ */
+const _parse_handlername = (handlername = '', handlertype = '') => {
+  if (!handlername) return {};
+
+  const parts = handlername.split(' ');
+  const parsedname = regexps.handlername.test(parts[0]) ? parts[0] : null;
+  parts.shift();
+
+  return ({
+    name: parsedname,
+    type: handlertype || null,
+    args: parts,
+  });
+}
+
+module.exports.redirect_handler = redirect_handler;
+module.exports.run_handler = run_handler;
+module.exports.apply_handler_to_unhandled_messages = apply_handler_to_unhandled_messages;
+module.exports.apply_handler_to_expected_input = apply_handler_to_expected_input;
+module.exports.apply_handler_to_inline_query = apply_handler_to_inline_query;
+module.exports.apply_handler_to_chosen_inline_result = apply_handler_to_chosen_inline_result;
+module.exports.apply_handler_to_command = apply_handler_to_command;
+module.exports.apply_handler_to_text_button = apply_handler_to_text_button;
+module.exports.apply_handler_to_action = apply_handler_to_action;
+module.exports.apply_handler_to_cron_task = apply_handler_to_cron_task;

package/middleware/auth.js

@@ -0,0 +1,22 @@
+const { User } = require('../source/classes/User');
+
+
+module.exports = async (ctx, next) => {
+  if (!ctx.from) {
+    await next();
+    return;
+  }
+  const user = new User(ctx.from.id);
+
+  await user.update(ctx.from, { isTelegtramUserObject: true });
+  await user.load();
+
+  if (!user.id) {
+    await user.insert(ctx.from);
+  }
+
+  await user.updateChats(ctx.from?.id, ctx.chat?.id);
+
+  ctx.user = user;
+  await next();
+}

package/middleware/error_handler.js

@@ -0,0 +1,230 @@
+const { options } = require('../options');
+const db = options.db;
+
+
+// можно бросать в воздухе не дожидаясь обработки
+const error_handler = async (err = {}, ctx = {}, handled = false) => {
+  try {
+    if (err.code === 'ETIMEDOUT') throw err;
+
+    if (ctx.from?.id && err?.on?.payload?.chat_id === ctx.from?.id) {
+      const handled403 = await error_403_handler(err, ctx.from?.id);
+      if (handled403) return;
+    }
+
+    switch(ctx.project_section){
+      case 'cron':
+        console.error('===== cron error begin =====');
+        logError(err);
+        console.error('handler: ', ctx.handler);
+        if (handled) console.error('Ошибка была обработана и проглочена приложением');
+        console.error('===== cron error end =====');
+        break;
+      case 'unhandledRejection':
+        console.error('=== UNHANDLED REJECTION ===');
+        logError(err);
+        console.error('=== END UNHANDLED REJECTION ===');
+        process.exit(1);
+        break;
+      default:
+        console.error('===== error begin =====');
+        logError(err);
+        console.error('message: ', ctx.message);
+        console.error('session: ', ctx.session);
+        console.error('user: ', ctx.user);
+        console.error('handler: ', ctx.handler);
+        if (handled) console.error('Ошибка была обработана и проглочена приложением');
+        console.error('===== error end =====');
+    }
+    await sendErrorToDevelopers(err, ctx, handled);
+  }
+  catch (err) {
+    console.error('===== error of error begin =====');
+    logError(err);
+    console.error('===== error of error end =====');
+  }
+}
+
+// можно бросать в воздухе не дожидаясь обработки
+const error_403_handler = async (err = {}, user_id) => {
+  try {
+    if (err?.response?.error_code === 403) {
+      await db.update('user', { unsubscribed: 1, dt_unsubscribe: new Date() }, { user_id: user_id, unsubscribed: 0 });
+      return true;
+    }
+    return false;
+  }
+  catch (err) {
+    console.error('===== error of error_403_handler begin =====');
+    logError(err);
+    console.error('===== error of error_403_handler end =====');
+    return false;
+  }
+}
+
+// можно бросать в воздухе не дожидаясь обработки
+const notifyAdmins = async (message_text, ctx) => {
+  try {
+    if (!message_text) return;
+    const _sql = `SELECT * FROM user WHERE role IN ('admin', 'developer') AND unsubscribed = 0`;
+    const admins = await db.query(_sql);
+    if (!admins || !admins.length) return;
+
+    for (const admin of admins) {
+      try {
+        await ctx.telegram.sendMessage(
+          admin.user_id,
+          message_text,
+          {
+            parse_mode: 'HTML',
+            disable_notification: true,
+          }
+        );
+      }
+      catch (err) {
+        const handled403 = await error_403_handler(err, admin.user_id);
+        if (!handled403) throw err;
+      }
+    }
+  }
+  catch (err) {
+    console.error('===== error of notifyAdmins begin =====');
+    logError(err);
+    console.error('===== error of notifyAdmins end =====');
+  }
+};
+
+// send the error to developers
+const sendErrorToDevelopers = async (err = {}, ctx = {}, handled) => {
+  const _sql = `SELECT * FROM user WHERE role = 'developer' AND unsubscribed = 0`;
+  const developers = await db.query(_sql);
+  if (!developers || !developers.length) return;
+  const message = getErrorMessageToSend(err, ctx, handled);
+  for (const developer of developers) {
+    try {
+      await ctx.telegram.sendMessage(
+        developer.user_id,
+        message,
+        {
+          parse_mode: 'HTML',
+          disable_notification: true,
+        }
+      );
+    }
+    catch (err) {
+      const handled403 = await error_403_handler(err, developer.user_id);
+      if (!handled403) throw err;
+    }
+  }
+};
+
+
+const getErrorMessageToSend = (err = {}, ctx = {}, handled) => {
+  let message = '<b>Ошибка</b>';
+  if (ctx.project_section) message += ` в ${ctx.project_section}`;
+  if (ctx.handler?.name) message += `\n${ctx.handler?.name}`;
+  if (ctx.user) message += `\n<b>Пользователь</b> ${ctx.user.id} ${ctx.user.username || ''} ${ctx.user.first_name || ''} ${ctx.user.last_name || ''}`;
+
+  if (err.message) message += `\n\n${err.message}`;
+
+  if (err && err.stack) {
+    const _cleanStack = cleanStack(err, { show_system_lines: false, max_lines: 6 });
+    message += `\n\n<code>${_cleanStack}</code>`;
+  }
+
+  if (handled) message += '\n\n<i>Ошибка была обработана и проглочена приложением</i>';
+
+  return message;
+};
+
+
+const logError = (err) => {
+  if (err && err.stack) {
+    const _cleanStack = cleanStack(err, { show_system_lines: true });
+    console.error('error: ', err.message);
+    console.error('stack: ', _cleanStack);
+  } else {
+    console.error('error: ', err);
+  }
+};
+
+
+const cleanStack = (err, { show_system_lines = true, max_lines }) => {
+  if(!err?.stack) return '';
+
+  const originalStack = err.stack.split('\n');
+  let _cleanStack = [];
+
+  let inNodeModulesBlock = false;
+  let inNodeInternalBlock = false;
+  let inUtilsDbBlock = false;
+  let nodeModulesLineCount = 0;
+  let nodeInternalLineCount = 0;
+  let utilsDbLineCount = 0;
+
+  for (const line of originalStack) {
+    if (max_lines && _cleanStack.length >= max_lines) break;
+
+    if (line.includes('processTicksAndRejections')) {
+      _cleanStack.push(line);
+    } else if (line.includes('node_modules')) {
+      if (show_system_lines) {
+        nodeModulesLineCount++;
+        if (!inNodeModulesBlock) {
+          inNodeModulesBlock = true;
+          _cleanStack.push(`    at node_modules (${nodeModulesLineCount} lines)....`);
+        } else {
+          _cleanStack[_cleanStack.length - 1] = `    at node_modules (${nodeModulesLineCount} lines)....`;
+        }
+      }
+    } else if (line.includes('(node:')) {
+      if (show_system_lines) {
+        nodeInternalLineCount++;
+        if (!inNodeInternalBlock) {
+          inNodeInternalBlock = true;
+          _cleanStack.push(`    at node (${nodeInternalLineCount} lines)....`);
+        } else {
+          _cleanStack[_cleanStack.length - 1] = `    at node (${nodeInternalLineCount} lines)....`;
+        }
+      }
+    } else if (line.includes('utils/db.js')) {
+      if (show_system_lines) {
+        utilsDbLineCount++;
+        if (!inUtilsDbBlock) {
+          inUtilsDbBlock = true;
+          _cleanStack.push(`    at utils/db.js (${utilsDbLineCount} lines)....`);
+        } else {
+          _cleanStack[_cleanStack.length - 1] = `    at utils/db.js (${utilsDbLineCount} lines)....`;
+        }
+      }
+    } else {
+      inNodeModulesBlock = false;
+      inNodeInternalBlock = false;
+      inUtilsDbBlock = false;
+      nodeModulesLineCount = 0;
+      nodeInternalLineCount = 0;
+      utilsDbLineCount = 0;
+      _cleanStack.push(line);
+    }
+  }
+
+  _cleanStack = _cleanStack.join('\n');
+  return _cleanStack;
+}
+
+const sendErrorToUser = async (ctx, message_text) => {
+  const _message_text = message_text ? message_text : ctx.t`Что-то пошло не так, попробуй еще раз`;
+  await ctx.telegram.sendMessage(
+    ctx.chat.id,
+    _message_text,
+    {
+      parse_mode: 'HTML',
+    }
+  );
+};
+
+module.exports.sendErrorToUser = sendErrorToUser;
+module.exports.notifyAdmins = notifyAdmins;
+module.exports.error_403_handler = error_403_handler;
+module.exports.error_handler = error_handler;
+

package/middleware/keyboard.js

@@ -0,0 +1,13 @@
+const { TextButtons } = require('../source/classes/TextButtons');
+
+module.exports = async (ctx, next) => {
+  if (!ctx.from || !ctx.chat) {
+    await next();
+    return;
+  }
+
+  ctx.textbutton = new TextButtons(ctx);
+
+  await next();
+}
+

package/middleware/message_info.js

@@ -0,0 +1,23 @@
+const _ = require('lodash');
+const { MessageInfoManager } = require('../source/classes/MessageInfoManager');
+
+// How to use:
+// const messageInfo = await ctx.messageInfo.message(message_id); // load data
+// messageInfo.fieldname = { ... }; // set data
+// messageInfo.clean(); // delete data
+
+
+export default async (ctx, next) => {
+  if (!ctx.from) {
+    await next();
+    return;
+  }
+
+  const messageInfoManager = new MessageInfoManager({ from_id: ctx.from.id, chat_id: ctx.chat?.id || 'inline' });
+  ctx.messageInfo = messageInfoManager;
+
+  await next();
+
+  await ctx.messageInfo.save();
+}
+

package/middleware/session.js

@@ -0,0 +1,27 @@
+const _ = require('lodash');
+const { TelegramSession } = require('../source/classes/TelegramSession');
+
+export default async (ctx, next) => {
+  if (!ctx.from) {
+    await next();
+    return;
+  }
+
+  const session = new TelegramSession(ctx.from.id, ctx.chat?.id || 'inline');
+  await session.load();
+
+  ctx.session = session.data;
+  ctx.keyboard = session.keyboard;
+  ctx.handler_history = session.handler_history;
+  ctx.expected_input = session.expected_input;
+
+  await next();
+
+  session.data = ctx.session;
+  session.keyboard = ctx.keyboard;
+  session.handler_history = ctx.handler_history;
+  session.expected_input = ctx.expected_input;
+
+  await session.save();
+}
+

package/options.js

@@ -0,0 +1,39 @@
+const _default_options = {
+  db: 'required', // oira666_db instance
+  handlers_path: 'required', // path to the handlers folder
+  bot: 'required', // telegraf bot instance
+  Markup: 'required', // telegraf Markup instance
+
+  allowed_user_commands: [ // commands allowed for normal users
+    'start',
+    'help',
+    'id',
+  ],
+
+  expected_input_lifetime: 60 * 1000, // expected input lifetime
+};
+
+const _options = { ..._default_options };
+
+const set_options = (options = {}) => {
+  const errors = [];
+
+  for (let key in _default_options) {
+     if (options[key] !== undefined) {
+      _options[key] = options[key];
+     }
+     else {
+      _options[key] = _default_options[key];
+     }
+
+     if (_options[key] === 'required') {
+      errors.push(`Option ${key} is required`);
+     }
+  }
+
+  if (errors.length) throw new Error(errors.join('\n'));
+};
+
+module.exports.set_options = set_options;
+
+module.exports.options = _options;

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "oira666_tg",
+  "version": "1.0.0",
+  "description": "tg framework for oira666",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "oira666",
+  "license": "ISC",
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "moment": "^2.30.1"
+  }
+}

package/source/classes/MessageInfo.js

@@ -0,0 +1,81 @@
+const _ = require('lodash');
+const { options } = require('../options');
+const db = options.db;
+
+
+/**
+ * НЕ ИСПОЛЬЗОВАТЬ НАПРЯМУЮ,
+ * только через прокси: MessageInfoManager
+ *
+ * @class MessageInfo
+ * @property {number} from_id
+ * @property {number} chat_id
+ * @property {number} message_id
+ */
+class MessageInfo {
+  constructor ({ from_id, chat_id, message_id }) {
+    // при изменении этих полей, нужно менять прокси-класс в MessageInfoManager
+    this.from_id = +from_id || 0;
+    this.chat_id = +chat_id || 0;
+    this.message_id = +message_id || 0;
+    this._data = null;
+  }
+
+  clean() {
+    this._data = null;
+  }
+
+   async save() {
+    if (!this.chat_id || !this.message_id) return;
+
+    if (_.isEmpty(this._data)) {
+      await this._deleteMessageInfo();
+    } else {
+      await this._saveMessageInfo();
+    }
+  }
+
+  async _saveMessageInfo() {
+    if (!this.chat_id || !this.message_id) return;
+
+    const query = `
+      INSERT INTO message_info (message_id, chat_id, user_id, data, dt_create)
+      VALUES (:message_id, :chat_id, :user_id, :data, :dt_create)
+      ON DUPLICATE KEY UPDATE
+        data = VALUES(data)
+    `;
+    const params = {
+      message_id: this.message_id,
+      chat_id: this.chat_id,
+      user_id: this.from_id,
+      data: JSON.stringify(this._data),
+      dt_create: new Date()
+    }
+    await db.query(query, params);
+  }
+
+  async _deleteMessageInfo() {
+    if (!this.chat_id || !this.message_id) return;
+
+    const query = `DELETE FROM message_info WHERE message_id = :message_id AND chat_id = :chat_id`;
+    await db.query(query, { message_id: this.message_id, chat_id: this.chat_id});
+  }
+
+  async load() {
+    if (!this.chat_id || !this.message_id) return;
+
+    const query = `
+      SELECT *
+      FROM message_info
+      WHERE message_id = :message_id AND chat_id = :chat_id
+    `;
+    const data = await db.query(query, { message_id: this.message_id, chat_id: this.chat_id});
+
+    if (!_.isEmpty(data)) {
+      this._data = data[0].data ? JSON.parse(data[0].data) : null;
+    }
+  }
+
+}
+
+module.exports.MessageInfo = MessageInfo;

package/source/classes/MessageInfoManager.js

@@ -0,0 +1,64 @@
+const _ = require('lodash');
+const { MessageInfo } = require('./MessageInfo');
+
+class MessageInfoManager {
+  constructor(params = {}) {
+    this.chat_id = +params.chat_id || 0;
+    this.from_id = +params.from_id || 0;
+    this._messages = {};
+  }
+
+  async message(message_id) {
+    const message_key = message_id + "_" + this.chat_id;
+
+    if (this._messages[message_key]) return this._messages[message_key];
+
+    this._messages[message_key] = this.classProxy(
+      new MessageInfo({
+        message_id,
+        chat_id: this.chat_id,
+        from_id: this.from_id,
+      })
+    );
+    await this._messages[message_key].load();
+    return this._messages[message_key];
+  }
+
+  async save() {
+    const tasks = [];
+    for (const message_key in this._messages) {
+      tasks.push(this._messages[message_key].save());
+    }
+    if (tasks.length) await Promise.all(tasks);
+  }
+
+  classProxy(instance) {
+    const selfProps = ['chat_id', 'from_id', 'message_id', '_data'];
+
+    return new Proxy(instance, {
+      get(target, prop, receiver) {
+        if (typeof target[prop] === "function") {
+          return Reflect.get(...arguments);
+        }
+        if (selfProps.includes(prop)) {
+          return target[prop];
+        }
+        if (target._data) {
+          return target._data[prop];
+        }
+        return undefined;
+      },
+      set(target, prop, value) {
+        if (selfProps.includes(prop)) {
+          target[prop] = value;
+          return true;
+        }
+        if (!target._data) target._data = {};
+        target._data[prop] = value;
+        return true;
+      },
+    });
+  }
+}
+
+module.exports.MessageInfoManager = MessageInfoManager;

package/source/classes/TelegramSession.js

@@ -0,0 +1,111 @@
+const _ = require('lodash');
+const moment = require('moment');
+const { options } = require('../options');
+const db = options.db;
+
+class TelegramSession {
+  constructor (from_id, chat_id) {
+    this.session_key = `${from_id}:${chat_id}`;
+    this.user_id = +from_id || 0;
+    this._data = null;
+    this._handler_history = null;
+    this._expected_input = null;
+    this._keyboard = null;
+  }
+
+  get data() {
+    return !_.isEmpty(this._data) ? this._data : {};
+  }
+
+  get keyboard() {
+    return !_.isEmpty(this._keyboard) ? this._keyboard : [];
+  }
+
+  get handler_history() {
+    return !_.isEmpty(this._handler_history) ? this._handler_history : [];
+  }
+
+  get expected_input() {
+    return +moment() - +moment(this._expected_input?.dt_create) <= options.expected_input_lifetime ?
+            this._expected_input?.action || null : null;
+  }
+
+  set data(value) {
+    this._data = !_.isEmpty(value) ? value : null;
+  }
+
+  set keyboard(value) {
+    this._keyboard = Array.isArray(value) && !_.isEmpty(value) ? value : null;
+  }
+
+  set handler_history(value) {
+    this._handler_history = !_.isEmpty(value) ? value : null;
+  }
+
+  set expected_input(value) {
+    this._expected_input = value ? { action: value, dt_create: moment().format('YYYY-MM-DD HH:mm:ss') } : null;
+  }
+
+  async save() {
+    if (! this.session_key) return;
+
+    if (_.isEmpty(this._data) && _.isEmpty(this._handler_history) && _.isEmpty(this._expected_input)) {
+      await this._deleteSession();
+    } else {
+      await this._saveSession();
+    }
+  }
+
+  async _saveSession() {
+    if (! this.session_key) return;
+
+    const query = `
+      INSERT INTO session (session_key, user_id, data, keyboard, handler_history, expected_input, dt_access)
+      VALUES (:session_key, :user_id, :data, :keyboard, :handler_history, :expected_input, :dt_access)
+      ON DUPLICATE KEY UPDATE
+        data = VALUES(data),
+        keyboard = VALUES(keyboard),
+        handler_history = VALUES(handler_history),
+        expected_input = VALUES(expected_input),
+        dt_access = VALUES(dt_access)
+    `;
+    const params = {
+      session_key: this.session_key,
+      user_id: this.user_id,
+      data: _.isEmpty(this._data) ? null : JSON.stringify(this._data),
+      keyboard: _.isEmpty(this._keyboard) ? null : JSON.stringify(this._keyboard),
+      handler_history: _.isEmpty(this._handler_history) ? null : JSON.stringify(this._handler_history),
+      expected_input: _.isEmpty(this._expected_input) ? null : JSON.stringify(this._expected_input),
+      dt_access: new Date()
+    }
+    await db.query(query, params);
+  }
+
+  async _deleteSession() {
+    if (! this.session_key) return;
+
+    const query = `DELETE FROM telegram_session WHERE session_key = :session_key`;
+    await db.query(query, {session_key: this.session_key});
+  }
+
+  async load() {
+    if (! this.session_key) return;
+
+    const query = `
+      SELECT *
+      FROM session
+      WHERE session_key = :session_key
+    `;
+    const data = await db.query(query, {session_key: this.session_key});
+
+    if (!_.isEmpty(data)) {
+      this._data = data[0].data ? JSON.parse(data[0].data) : null;
+      this._keyboard = data[0].keyboard ? JSON.parse(data[0].keyboard) : null;
+      this._handler_history = data[0].handler_history ? JSON.parse(data[0].handler_history) : null;
+      this._expected_input = data[0].expected_input ? JSON.parse(data[0].expected_input) : null;
+    }
+  }
+
+}
+
+module.exports.TelegramSession = TelegramSession;

package/source/classes/TextButtons.js

@@ -0,0 +1,21 @@
+const { options } = require('../options');
+const Markup = options.Markup;
+
+
+class TextButtons {
+  constructor (ctx) {
+    this.ctx = ctx;
+  }
+
+  add(caption, action) {
+    this.ctx.keyboard.push({ caption, action });
+    return Markup.button.text(caption);
+  }
+
+  clean() {
+    this.ctx.keyboard = [];
+  }
+
+}
+
+module.exports.TextButtons = TextButtons;

package/source/classes/User.js

@@ -0,0 +1,104 @@
+import _ from 'lodash';
+const { options } = require('../options');
+const db = options.db;
+
+class User {
+  constructor (user_id) {
+    this.params = {};
+    this.params.user_id = parseInt(user_id) || 0;
+    this.user = {};
+    this.settings = {};
+    this.loaded = false;
+  }
+
+  get id() {return this.user.user_id || 0}
+  get user_id() {return this.user.user_id || 0}
+  get is_bot() {return Boolean(this.user.is_bot)}
+  get role() {return this.user.role}
+  get unsubscribed() {return Boolean(Number(this.user.unsubscribed))}
+  get is_new() {return Boolean(this.user.is_new)}
+  get is_private_member() {return Boolean(this.user.is_private_member)}
+  get username() {return this.user.username || null}
+  get display_name() {return this.user.display_name || null}
+
+
+  async load() {
+    const user = await db.query(`
+      SELECT
+        user.*,
+        IF(chats.user_id IS NULL, 0, 1) AS is_private_member,
+
+        @full_name := NULLIF(TRIM(CONCAT_WS(' ', user.last_name, user.first_name)), '') AS full_name,
+        COALESCE(@full_name, user.username) AS display_name
+
+      FROM user
+      LEFT JOIN user_chats AS chats ON (chats.user_id = user.user_id AND chats.chat_id = user.user_id)
+      WHERE user.user_id = :user_id
+    `, {user_id: this.params.user_id});
+    this.user = _.isEmpty(user) ? {} : user[0];
+    this.loaded = true;
+  }
+
+  async insert(newuser = {}) {
+    this.params.user_id = parseInt(newuser.id) || 0;
+    if (!this.params.user_id) return null;
+    const params = {
+      user_id: this.params.user_id,
+      is_bot: newuser.is_bot ? 1 : 0,
+      language_code: newuser.language_code || null,
+      username: newuser.username || null,
+      first_name: newuser.first_name || null,
+      last_name: newuser.last_name || null,
+      dt_create: new Date(),
+      dt_update: new Date(),
+      dt_unsubscribe: null,
+      unsubscribed: 0,
+    }
+    await db.insert('user', params, { ignore: true });
+    this.user = {
+      ...params,
+      is_new: true,
+    };
+  }
+
+  async update(params = {}, { isTelegtramUserObject = false }) {
+    let _params = params;
+    if (!this.params.user_id) return null;
+    if (isTelegtramUserObject) {
+      _params = {
+        user_id: this.params.user_id,
+        is_bot: params.is_bot ? 1 : 0,
+        language_code: params.language_code || null,
+        username: params.username || null,
+        first_name: params.first_name || null,
+        last_name: params.last_name || null,
+        dt_update: new Date(),
+        dt_unsubscribe: null,
+        unsubscribed: 0,
+      }
+    }
+
+    await db.update('user', _params, { user_id: this.params.user_id });
+    this.user = {
+      ...this.user,
+      ...params,
+    };
+  }
+
+  async unsubscribe() {
+    await this.update({ unsubscribed : 1, dt_unsubscribe: new Date() });
+    this.user.is_resubscribed = 0;
+    this.user.unsubscribed = 1;
+    this.user.dt_unsubscribe = new Date();
+  }
+
+  async updateChats(user_id, chat_id) {
+    if (!user_id || !chat_id) return;
+    await db.insert('user_chats',
+      { user_id, chat_id, dt_create: new Date() },
+      { ignore: true }
+    );
+  }
+}
+
+module.exports.User = User;

package/source/handlers/id.js

@@ -0,0 +1,6 @@
+export default async (ctx) => {
+  await ctx.telegram.sendMessage(
+    ctx.chat.id,
+    ctx.t`ID Твоего пользователя в телеграме: ${ctx.from.id}\nID этого чата в телеграме: ${ctx.chat.id}`,
+  );
+};

package/source/handlers/test.js

@@ -0,0 +1,15 @@
+export default async (ctx) => {
+  try {
+    await ctx.telegram.sendMessage(
+      ctx.chat.id,
+      ctx.t`Hello, world!`,
+      {
+        parse_mode: 'HTML',
+      }
+    );
+  }
+  catch (err) {
+    console.log(JSON.parse(JSON.stringify(err)));
+    console.log(err?.on?.payload?.chat_id);
+  }
+};

package/utils/_require.js

@@ -0,0 +1,17 @@
+import fs from 'fs';
+
+
+const _require = (...filepaths) => {
+  let result;
+
+  for (let i=0; i<filepaths.length; i++) {
+    if (filepaths[i] && fs.existsSync(filepaths[i])) {
+      result = require(filepaths[i]);
+      break;
+    }
+  }
+
+  return (result || {});
+}
+
+module.exports._require = _require;

package/utils/find_in_handlers.js

@@ -0,0 +1,12 @@
+import _ from "lodash";
+
+
+const find_in_handlers = (ctx, name) => {
+  const reg = new RegExp('(^|/)' + name + '(/|\s|$)');
+
+  if (reg.test(ctx.handler.name)) return true;
+  if (~_.findIndex((ctx.handler.hystory || []), o => reg.test(o.name || '') )) return true;
+  return false;
+}
+
+module.exports.find_in_handlers = find_in_handlers;

package/utils/regexps.js

@@ -0,0 +1,8 @@
+const regexps = {
+  email: /^[\.a-zA-Z_-\d]+@[a-zA-Z_-\d\.]+?\.[a-zA-Z]{2,5}$/,
+  handlername: /^[a-zA-Z\/\d_]+$/,
+  url: /^https?:\/\/.+\.[A-Za-zА-Яа-я]{2,5}((\/|\?).*)?$/,
+  handlername_args: /^[a-zA-Z_\/]+(\s.+)?$/,
+}
+
+module.exports.regexps = regexps;

package/utils/send_empty_message.js

@@ -0,0 +1,12 @@
+const send_empty_message = async (ctx, message_text) => {
+  const message = await ctx.telegram.sendMessage(
+    ctx.chat.id,
+    message_text,
+    {
+      parse_mode: 'HTML',
+    }
+  );
+  return message.message_id;
+};
+
+module.exports.send_empty_message = send_empty_message;