heywaffle, slack event usecase 정리

Author: woohm402

src/infrastructures/implementMongoAtlasWaffleRepository.ts

@@ -2,13 +2,13 @@ import type { MongoClient } from 'mongodb';
 import { z } from 'zod';
 import type { SlackID } from '../entities/Slack';
 import type { implementDashboardService } from '../services/DashboardService';
-import type { implementSlackEventService } from '../services/SlackEventService';
+import type { getSlackWatcherUsecsae } from '../services/SlackEventService';
 import type { implementWaffleService } from '../services/WaffleService';
 
 export const implementMongoAtlasWaffleRepository = ({
   mongoClient,
 }: { mongoClient: Pick<MongoClient, 'db'> }): Parameters<
-  typeof implementSlackEventService
+  typeof getSlackWatcherUsecsae
 >[0]['waffleRepository'] &
   Parameters<typeof implementDashboardService>[0]['waffleRepository'] &
   Parameters<typeof implementWaffleService>[0]['waffleRepository'] => {

src/main.ts

@@ -6,7 +6,7 @@ import { implementMemberWaffleDotComRepository } from './infrastructures/impleme
 import { implementMongoAtlasWaffleRepository } from './infrastructures/implementMongoAtlasWaffleRepository';
 import { implementSlackPresenter } from './infrastructures/implementSlackPresenter';
 import { implementDeploymentService } from './services/GithubDeploymentService';
-import { implementSlackEventService } from './services/SlackEventService';
+
 import { implementWaffleService } from './services/WaffleService';
 
 import type { MongoClient } from 'mongodb';
@@ -15,6 +15,8 @@ import {
   type WaffleGraphDashboardService,
   implementWaffleGraphDashboardService,
 } from './services/WaffleGraphDashboardService';
+import { getHeywaffleUsecase } from './usecases/HeywaffleUsecase';
+import { getSlackWatcherUsecsae } from './usecases/SlackWatcherUsecase';
 
 export const handle = async (
   dependencies: {
@@ -33,11 +35,13 @@ export const handle = async (
   },
   request: Request,
 ): Promise<Response> => {
-  const slackService = implementSlackEventService({
+  const slackWatcherUsecase = getSlackWatcherUsecsae({
     messengerPresenter: implementSlackPresenter({
       slackClient: dependencies.slackClient,
       channelId: env.slackWatcherChannelId,
     }),
+  });
+  const heywaffleUsecase = getHeywaffleUsecase({
     waffleRepository: implementMongoAtlasWaffleRepository(dependencies),
     messageRepository: {
       getPermalink: async ({ channel, ts }) =>
@@ -98,9 +102,16 @@ export const handle = async (
 
       if (body.type === 'url_verification') return new Response(body.challenge, { status: 200 });
 
-      // 3초 안에 응답하지 않으면 웹훅이 다시 들어오므로 await 하지 않고 바로 응답한다
-      slackService.handleEvent(body.event);
+      if (body.event.type === 'message') heywaffleUsecase.handleSlackMessage(body.event);
+      if (
+        body.event.type === 'channel_created' ||
+        body.event.type === 'channel_archive' ||
+        body.event.type === 'channel_unarchive' ||
+        body.event.type === 'channel_rename'
+      )
+        slackWatcherUsecase.handleEvent(body.event);
 
+      // 3초 안에 응답하지 않으면 웹훅이 다시 들어오므로 await 하지 않는다
       return new Response(null, { status: 204 });
     }
 

src/services/SlackEventService.ts

@@ -0,0 +1,123 @@
+import type { AnyBlock, MessageEvent } from '@slack/web-api';
+import type { SlackID } from '../entities/Slack';
+import type { Log } from '../entities/Waffle';
+import { getTodayStartAsKST } from '../utils/getTodayStartAsKST';
+
+type HeywaffleUsecase = {
+  handleSlackMessage: (event: MessageEvent) => Promise<void>;
+};
+
+type Mention = `<@${SlackID}>`;
+const slackIDToMention = (id: SlackID): Mention => `<@${id}>`;
+const mentionToSlackID = (mention: Mention): SlackID => mention.slice(2, -1) as SlackID;
+
+export const getHeywaffleUsecase = ({
+  messageRepository,
+  waffleRepository,
+}: {
+  messageRepository: {
+    getPermalink: (_: { channel: string; ts: string }) => Promise<{ link: string }>;
+    sendMessage: (_: { channel: string; text: string; blocks?: AnyBlock[] }) => Promise<void>;
+  };
+  waffleRepository: {
+    insert: (_: Log[]) => Promise<void>;
+    listLogs: (_: { from: Date; to: Date }) => Promise<{ logs: Log[] }>;
+  };
+}): HeywaffleUsecase => {
+  return {
+    handleSlackMessage: async (event) => {
+      if (!('user' in event && typeof event.user === 'string' && event.subtype === undefined))
+        return;
+      const user = event.user as SlackID;
+      const targetUsers = ((event.text?.match(/<@[A-Z0-9]+>/g) ?? []) as Mention[]).filter(
+        (m) => m !== slackIDToMention(user),
+      );
+
+      if (targetUsers.length === 0) return;
+
+      const todayGivenCount = (
+        await waffleRepository.listLogs({
+          from: getTodayStartAsKST(new Date()),
+          to: new Date(),
+        })
+      ).logs
+        .filter((l) => l.from === user)
+        .reduce((a, c) => a + c.count, 0);
+      const dayMax = 5;
+      const left = dayMax - todayGivenCount;
+
+      const count = event.text?.match(/:waffle:/g)?.length ?? 0;
+
+      if (count === 0) return;
+      const total = count * targetUsers.length;
+
+      const href = (
+        await messageRepository.getPermalink({
+          channel: event.channel,
+          ts: event.ts,
+        })
+      ).link;
+
+      if (left < total) {
+        await messageRepository.sendMessage({
+          channel: event.user,
+          text: `*You have only ${left} ${left === 1 ? 'Waffle' : 'Waffles'} left for today!*`,
+          blocks: [
+            {
+              type: 'section',
+              text: {
+                type: 'mrkdwn',
+                text: `*You have only ${left} ${left === 1 ? 'Waffle' : 'Waffles'} left for today!*`,
+              },
+              accessory: {
+                type: 'button',
+                text: { type: 'plain_text', text: 'View Message' },
+                url: href,
+              },
+            },
+          ],
+        });
+        return;
+      }
+
+      await Promise.all([
+        ...[
+          {
+            channel: event.user,
+            text: `*You Gave ${count} ${count === 1 ? 'Waffle' : 'Waffles'} to ${targetUsers.join(',')} (${left - total} left)*`,
+          },
+          ...targetUsers.map((u) => ({
+            channel: mentionToSlackID(u),
+            text: `*You Received ${count} ${count === 1 ? 'Waffle' : 'Waffles'} from ${slackIDToMention(user)}!*`,
+          })),
+        ].map(({ channel, text }) =>
+          messageRepository.sendMessage({
+            channel,
+            text,
+            blocks: [
+              {
+                type: 'section',
+                text: { type: 'mrkdwn', text },
+                accessory: {
+                  type: 'button',
+                  text: { type: 'plain_text', text: 'View Message' },
+                  url: href,
+                },
+              },
+            ],
+          }),
+        ),
+
+        waffleRepository.insert(
+          targetUsers.map((targetUser) => ({
+            from: user,
+            to: mentionToSlackID(targetUser),
+            count,
+            href,
+            date: new Date(),
+          })),
+        ),
+      ]);
+    },
+  };
+};

src/usecases/HeywaffleUsecase.ts

@@ -0,0 +1,48 @@
+import type {
+  ChannelArchiveEvent,
+  ChannelCreatedEvent,
+  ChannelRenameEvent,
+  ChannelUnarchiveEvent,
+} from '@slack/web-api';
+import type { MessengerPresenter } from '../presenters/MessengerPresenter';
+
+type SlackWatcherUsecase = {
+  handleEvent: (
+    event: ChannelArchiveEvent | ChannelCreatedEvent | ChannelRenameEvent | ChannelUnarchiveEvent,
+  ) => Promise<void>;
+};
+
+export const getSlackWatcherUsecsae = ({
+  messengerPresenter,
+}: {
+  messengerPresenter: MessengerPresenter;
+}): SlackWatcherUsecase => {
+  return {
+    handleEvent: async (event) => {
+      switch (event.type) {
+        case 'channel_archive':
+          await messengerPresenter.sendMessage(({ formatChannel }) => ({
+            text: `${formatChannel(event.channel)} 채널이 보관되었어요`,
+          }));
+          break;
+        case 'channel_created':
+          await messengerPresenter.sendMessage(({ formatChannel }) => ({
+            text: `${formatChannel(event.channel.id)} 채널이 생성되었어요`,
+          }));
+          break;
+        case 'channel_rename':
+          await messengerPresenter.sendMessage(({ formatChannel }) => ({
+            text: `${formatChannel(event.channel.id)} 채널 이름이 변경되었어요`,
+          }));
+          break;
+        case 'channel_unarchive':
+          await messengerPresenter.sendMessage(({ formatChannel }) => ({
+            text: `${formatChannel(event.channel)} 채널이 보관 취소되었어요`,
+          }));
+          break;
+        default:
+          throw new Error('unexpected event');
+      }
+    },
+  };
+};