Merge pull request #1 from Yuvasee/api-abstraction

v2.0.0

Author: Yuvasee

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 dist
 package-lock.json
+*.tgz

jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+};

package.json

@@ -1,18 +1,23 @@
 {
   "name": "@v9v/nodejs-bot-engine",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Node.js bot engine",
-  "main": "dist/index.js",
+  "main": "src/index.ts",
   "scripts": {
-    "prepublish": "npx typescript --declaration",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "rimraf dist && npx typescript --declaration",
+    "prepublish": "npm run build",
+    "test": "jest --watch",
+    "coverage": "jest --coverage"
   },
   "author": "Yuri Vasilchikov",
   "license": "ISC",
   "devDependencies": {
     "@types/dotenv": "^8.2.0",
+    "@types/jest": "^24.0.25",
     "@types/node": "^13.1.4",
     "@types/node-telegram-bot-api": "^0.40.1",
+    "jest": "^24.9.0",
+    "ts-jest": "^24.3.0",
     "tslint": "^5.20.1",
     "typescript": "^3.7.4"
   },

src/BotEngine.ts

@@ -1,75 +1,92 @@
-import TelegramBot = require('node-telegram-bot-api');
-import Command from './interfaces/Command';
-import CommandSet from './interfaces/CommandSet';
+import { IBotEngine, IBotApiAdapter, BotSpeechApi, Command, Feature, Messenger } from './interfaces';
+import * as re from './re';
+import TelegramApiAdapter from './adapters/TelegramApiAdapter';
 
-export default class BotEngine {
-    private registeredCommands = new Set<string>([]);
+const ADAPTER_MAP: Record<Messenger, any> = {
+    [Messenger.Telegram]: TelegramApiAdapter,
+}
 
-    constructor(private api: TelegramBot) {}
+export default class BotEngine implements IBotEngine {
+    private commandsRegistry = new Set<string>([]);
+    private apiAdapter: IBotApiAdapter;
 
-    public registerCommand(this: BotEngine, command: Command) {
-        if (this.registeredCommands.has(command.name)) {
-            throw new Error(`Command names collision occured: ${command.name}. Commands should have unique names.`);
-        }
+    constructor(messenger: Messenger, secret: string) {
+        this.apiAdapter = new ADAPTER_MAP[messenger](secret);
+    }
 
-        if (!command.trigger) {
-            throw new Error(`Command ${command.name} has no trigger`);
+    public registerCommand(command: Command) {
+        const validationError = this.validateCommand(command);
+        if (validationError) {
+            throw new Error(validationError);
         }
 
-        this.api.onText(command.trigger, command.reaction(this.api));
-        this.registeredCommands.add(command.name);
+        const { triggers, reaction, name } = command;
+        triggers.forEach((trigger) => this.apiAdapter.onText(trigger, reaction));
+        this.commandsRegistry.add(name);
+        console.log('Registered command: ' + name);
 
-        console.log('Registered command: ' + command.name);
         return this;
     }
 
-    public registerCommandSet(this: BotEngine, commandSet: CommandSet) {
-        const { name: setName, commands, fallback } = commandSet;
-        const commandNames = Object.keys(commands);
-
-        if (this.registeredCommands.has(setName)) {
-            throw new Error(`Command names collision occured: ${setName}. Commands should have unique names.`);
+    public registerFeature(feature: Feature) {
+        const validationResult = this.validateFeature(feature);
+        if (validationResult) {
+            throw new Error(validationResult);
         }
-        this.registeredCommands.add(setName);
 
-        console.log(`Command set: ${setName} ---`);
+        const { name, commands, fallback } = feature;
+        const commandNames = Object.keys(commands);
+
+        this.commandsRegistry.add(name);
+        console.log(`Command set: ${name} ---`);
 
-        commandNames.forEach(commandName => {
-            // matches "setName commandName..."
-            const reKnownCmd = `^${setName}[ \\t]+${commandName}([ \\t]+.*)?$`;
-            commands[commandName].trigger = new RegExp(reKnownCmd);
+        commandNames.forEach((commandName) => {
+            commands[commandName].triggers = commands[commandName].triggers || [];
+            commands[commandName].triggers.push(re.featureCommand(name, commandName));
             this.registerCommand(commands[commandName]);
         });
 
-        // matches "setName" and "setName not(one|of|commandNames)..."
-        const reFallbackCmd = `^${setName}(?!\\S|([ \\t]+)?(${commandNames.join('|')}))`;
-        fallback.trigger = new RegExp(reFallbackCmd);
+        fallback.triggers = fallback.triggers || [];
+        fallback.triggers.push(re.featureFallback(name, commandNames));
         this.registerCommand(fallback);
 
         console.log(`---`);
 
         return this;
     }
 
-    public registerFallback(this: BotEngine) {
-        // matches minus command
-        const reMinusSum = '-\\d+(?:[.,]\\d+)?(?:[+\\-*\\/]\\d+(?:[.,]\\d+)?)*';
-        const commands = [...this.registeredCommands];
-        const commandsJoined = commands.join('|');
+    public registerFallback() {
+        const commandNames = [...this.commandsRegistry];
+
+        const triggers = [re.globalFallback(commandNames)];
+        const reaction = (bot: BotSpeechApi) => {
+            bot.sendMessage(`commands:\n${commandNames.join('\n')}`);
+        };
+
+        this.registerCommand({ name: 'global fallback', triggers, reaction });
+    }
 
-        // matches all but valid commands
-        const reFallbackGlobal = `^(?!(${reMinusSum}|${commandsJoined})).+|^(${commandsJoined})\\w+.*`;
+    private validateCommand(command: Command): string | undefined {
+        if (this.commandsRegistry.has(command.name)) {
+            return `Command names collision occured: ${command.name}. Commands should have unique names.`;
+        }
 
-        this.registerCommand({
-            name: 'global fallback',
+        if (!command.triggers?.length) {
+            return `Command ${command.name} has no triggers`;
+        }
 
-            trigger: new RegExp(reFallbackGlobal),
+        if (command.triggers.map((t) => t instanceof RegExp).includes(false)) {
+            return `Command ${command.name} triggers array contains invalid element`;
+        }
+    }
 
-            reaction: botApi => (msg, match) => {
-                botApi.sendMessage(msg.chat.id, `commands: \n${commands.join('\n')}`);
-            },
-        });
+    private validateFeature(feature: Feature): string | undefined {
+        if (this.commandsRegistry.has(feature.name)) {
+            return `Command names collision occured: ${name}. Commands should have unique names.`;
+        }
 
-        return this;
+        if (!Object.keys(feature.commands).length) {
+            return `Feature ${feature.name} has no commands`;
+        }
     }
 }

src/adapters/TelegramApiAdapter.ts

@@ -0,0 +1,39 @@
+import TelegramBot = require('node-telegram-bot-api');
+import { IBotApiAdapter, BotSpeechApi, CommonMessage, Messenger, SheetData, Reaction } from '../interfaces';
+import { ParseMode } from 'node-telegram-bot-api';
+
+export default class TelegramApiAdapter implements IBotApiAdapter {
+    private api: TelegramBot;
+
+    constructor(secret: string) {
+        this.api = new TelegramBot(secret, { polling: true });
+    }
+
+    public onText(this: TelegramApiAdapter, trigger: RegExp, reaction: Reaction) {
+        this.api.onText(trigger, (rawMessage: TelegramBot.Message) => {
+            const speechApi = this.makeSpeechApi(rawMessage);
+            const message = this.makeCommonMessage(rawMessage);
+            reaction(speechApi, message);
+        });
+    }
+
+    private makeSpeechApi(this: TelegramApiAdapter, msg: TelegramBot.Message): BotSpeechApi {
+        const telegramApi = this.api;
+        return {
+            sendMessage(text: string) {
+                telegramApi.sendMessage(msg.chat.id, text, { parse_mode: 'HTML' as ParseMode });
+            },
+            sendFile(file: Buffer, fileName: string, contentType: string) {
+                telegramApi.sendDocument(msg.chat.id, file, {}, { filename: fileName, contentType });
+            },
+        };
+    }
+
+    private makeCommonMessage(rawMessage: TelegramBot.Message) {
+        return {
+            messenger: Messenger.Telegram,
+            text: rawMessage.text,
+            userId: rawMessage.from.id.toString(),
+        } as CommonMessage;
+    }
+}

src/index.ts

@@ -1,6 +1,4 @@
 import BotEngine from './BotEngine';
-import Command from './interfaces/Command';
-import CommandSet from './interfaces/CommandSet';
+export * from './interfaces';
 
 export default BotEngine;
-export { BotEngine, Command, CommandSet };

src/interfaces/Command.ts

@@ -0,0 +1,51 @@
+export interface IBotEngine {
+    registerCommand: (command: Command) => void;
+    registerFeature: (feature: Feature) => void;
+    registerFallback: () => void;
+}
+
+export interface IBotApiAdapter {
+    onText: (trigger: RegExp, reaction: Reaction) => void;
+}
+
+export interface BotConfig {
+    telegramToken: string;
+}
+
+/**
+ * On every message received new BotApi instance created
+ * with bindings to proper channel API, chat id etc.
+ */
+export interface BotSpeechApi {
+    sendMessage: (text: string) => void;
+    sendFile: (file: Buffer, fileName: string, contentType: string) => void;
+}
+
+export enum Messenger {
+    Telegram = 'Telegram',
+}
+
+export interface CommonMessage {
+    messenger: Messenger;
+    text: string;
+    userId: string;
+}
+
+export interface SheetData {
+    columns: string[];
+    rows: string[][];
+}
+
+export type Reaction = (bot: BotSpeechApi, msg: CommonMessage) => void;
+
+export interface Command {
+    name: string;
+    triggers?: RegExp[];
+    reaction: Reaction;
+}
+
+export interface Feature {
+    name: string;
+    commands: Record<string, Command>;
+    fallback: Command;
+}

src/interfaces/CommandSet.ts

@@ -0,0 +1,29 @@
+/**
+ * Matches "feature command [anything...]"
+ * Used to match particular feature command
+ * @param {string} feature
+ * @param {string} command
+ */
+export function featureCommand(feature: string, command: string): RegExp {
+    return new RegExp(`^${feature}[ \\t]+${command}([ \\t]+.*)?$`);
+}
+
+/**
+ * Matches "feature" and "feature [anything but (one|of|commands)]"
+ * Used to match improper feature use and show fallback
+ * @param {string} feature
+ * @param {string[]} commands
+ */
+export function featureFallback(feature: string, commands: string[]): RegExp {
+    return new RegExp(`^${feature}(?!\\S|([ \\t]+)?(${commands.join('|')}))`);
+}
+
+/**
+ * Matches everything but valid commands
+ * @param {string[]} commands
+ */
+export function globalFallback(commands: string[]): RegExp {
+    const reMinusSum = '-\\d+(?:[.,]\\d+)?(?:[+\\-*\\/]\\d+(?:[.,]\\d+)?)*';
+    const joinedCommands = commands.join('|');
+    return new RegExp(`^(?!(${reMinusSum}|${joinedCommands})).+|^(${joinedCommands})\\w+.*`);
+}