added working message handler

src/index.ts

@@ -9,7 +9,7 @@ async function main() {
   try {
     const config = prepareConfig();
     const telegram = new TelegramService(config.telegram);
-    const vkService = new VkService(config.vk);
+    const vkService = new VkService(config.vk, telegram);
 
     const telegramApi = new TelegramApi(telegram).listen();
     await telegram.start();

src/service/vk/handlers/MessageNewHandler.ts

@@ -1,12 +1,28 @@
-import { VkEventHandler } from "./types";
-import { ContextDefaultState, MessageContext } from "vk-io";
+import { VkEventHandler } from "./VkEventHandler";
+import { MessageContext } from "vk-io";
 import { NextMiddleware } from "middleware-io";
+import logger from "../../logger";
+import { ContextDefaultState } from "vk-io/lib/structures/contexts/context";
+
+export class MessageNewHandler extends VkEventHandler {
+  public execute = async (
+    context: MessageContext<ContextDefaultState>,
+    next: NextMiddleware
+  ) => {
+    if (context.isOutbox) {
+      await next();
+      return;
+    }
+
+    const users = await this.instance.api.users.get({
+      user_ids: [String(context.senderId)],
+    });
+    const from = users[0];
+
+    logger.debug(
+      `received message from ${from.first_name} ${from.last_name}: ${context.text}`
+    );
 
-export class MessageNewHandler extends VkEventHandler<
-  MessageContext<ContextDefaultState>
-> {
-  public execute = async (context, next: NextMiddleware) => {
-    console.log("received message!");
     await next();
   };
 }

src/service/vk/handlers/VkEventHandler.ts

@@ -0,0 +1,21 @@
+import { NextMiddleware } from "middleware-io";
+import { ConfigGroup, GroupInstance } from "../types";
+import { VkService } from "../index";
+import { TelegramService } from "../../telegram";
+
+export abstract class VkEventHandler {
+  public constructor(
+    protected group: ConfigGroup,
+    protected instance: GroupInstance,
+    protected vk: VkService,
+    protected telegram: TelegramService
+  ) {}
+
+  public execute: (
+    context: any,
+    next: NextMiddleware
+  ) => Promise<void> = async (ctx, next) => {
+    console.log(`vk received unknown event`, ctx);
+    await next();
+  };
+}

src/service/vk/handlers/index.ts

@@ -1,11 +1,14 @@
 import { VkEvent } from "../types";
-import { VkEventHandler } from "./types";
+import { VkEventHandler } from "./VkEventHandler";
 import { MessageNewHandler } from "./MessageNewHandler";
 
-export const vkEventToHandler: Record<VkEvent, typeof VkEventHandler> = {
-  [VkEvent.GroupJoin]: VkEventHandler,
-  [VkEvent.GroupLeave]: VkEventHandler,
+type DerivedHandler = typeof VkEventHandler;
+interface Handler extends DerivedHandler {}
+
+export const vkEventToHandler: Record<VkEvent, Handler> = {
+  [VkEvent.GroupJoin]: MessageNewHandler,
+  [VkEvent.GroupLeave]: MessageNewHandler,
   [VkEvent.MessageNew]: MessageNewHandler,
-  [VkEvent.PostSuggestion]: VkEventHandler,
-  [VkEvent.WallPostNew]: VkEventHandler,
+  [VkEvent.PostSuggestion]: MessageNewHandler,
+  [VkEvent.WallPostNew]: MessageNewHandler,
 };

src/service/vk/handlers/types.ts

@@ -1,13 +0,0 @@
-import { NextMiddleware } from "middleware-io";
-import { ConfigGroup } from "../types";
-
-export class VkEventHandler<T = any> {
-  public constructor(protected config: ConfigGroup) {}
-  public execute: (context: T, next: NextMiddleware) => Promise<void> = async (
-    ctx,
-    next
-  ) => {
-    console.log(`vk received unknown event`, ctx);
-    await next();
-  };
-}

src/service/vk/index.ts

@@ -4,15 +4,16 @@ import logger from "../logger";
 import { Request, Response } from "express";
 import { flatten, has, keys } from "ramda";
 import { NextFunction } from "connect";
-import { VkEventHandler } from "./handlers/types";
+import { VkEventHandler } from "./handlers/VkEventHandler";
 import { vkEventToHandler } from "./handlers";
+import { TelegramService } from "../telegram";
 
 export class VkService {
   public endpoint: string = "/";
   private readonly instances: Record<string, GroupInstance>;
   private readonly groups: Record<number, ConfigGroup>;
 
-  constructor(private config: VkConfig) {
+  constructor(private config: VkConfig, private telegram: TelegramService) {
     if (!config.groups.length) {
       throw new Error("No vk groups to handle. Specify them in config");
     }
@@ -63,7 +64,6 @@ export class VkService {
   private createGroupInstance = (group: ConfigGroup): GroupInstance => {
     const api = new API({
       token: group.apiKey,
-      apiBaseUrl: this.config.endpoint,
     });
     const upload = new Upload({ api });
     const updates = new Updates({
@@ -73,7 +73,14 @@ export class VkService {
       webhookSecret: group.secretKey,
     });
 
-    const handlers = this.setupHandlers(group);
+    const instance = {
+      api,
+      upload,
+      updates,
+    };
+
+    const handlers = this.setupHandlers(group, instance);
+
     handlers.forEach((channel) => {
       keys(channel).forEach((event) => {
         console.log(`updates in ${String(event)}`);
@@ -81,22 +88,26 @@ export class VkService {
       });
     });
 
-    return {
-      api,
-      upload,
-      updates,
-    };
+    return instance;
   };
 
   /**
    * Setups handlers
    */
-  private setupHandlers(group: ConfigGroup): Record<VkEvent, VkEventHandler>[] {
+  private setupHandlers(
+    group: ConfigGroup,
+    instance: GroupInstance
+  ): Record<VkEvent, VkEventHandler>[] {
     return flatten(
       group.channels.map((chan) =>
         chan.events.reduce((acc, event) => {
-          const handler = vkEventToHandler[event];
-          return { ...acc, [event]: new handler(group) };
+          const handler = new (vkEventToHandler as any)[event](
+            group,
+            instance,
+            this,
+            this.telegram
+          );
+          return { ...acc, [event]: handler };
         }, {} as Record<VkEvent, VkEventHandler>[])
       )
     );