✨ 배포 알리미 구현 (#47)

Author: woohm402

.github/workflows/deploy.yml

@@ -37,6 +37,7 @@ jobs:
             --build-arg SLACK_BOT_TOKEN=${{ secrets.SLACK_BOT_TOKEN }} \
             --build-arg SLACK_AUTH_TOKEN=${{ secrets.SLACK_AUTH_TOKEN }} \
             --build-arg SLACK_WATCHER_CHANNEL_ID=C050TMDUSTA \
+            --build-arg DEPLOY_WATCHER_CHANNEL_ID=C06H0PJPDNH \
             .
           docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
           echo "::set-output name=image::$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG"

Dockerfile

@@ -2,10 +2,12 @@ FROM node:18.17.1-alpine
 ARG SLACK_BOT_TOKEN
 ARG SLACK_AUTH_TOKEN
 ARG SLACK_WATCHER_CHANNEL_ID
+ARG DEPLOY_WATCHER_CHANNEL_ID
 COPY . .
 RUN echo "SLACK_BOT_TOKEN=${SLACK_BOT_TOKEN}" >> .env.local
 RUN echo "SLACK_AUTH_TOKEN=${SLACK_AUTH_TOKEN}" >> .env.local
 RUN echo "SLACK_WATCHER_CHANNEL_ID=${SLACK_WATCHER_CHANNEL_ID}" >> .env.local
+RUN echo "DEPLOY_WATCHER_CHANNEL_ID=${DEPLOY_WATCHER_CHANNEL_ID}" >> .env.local
 RUN yarn install
 RUN yarn build:server
 CMD ["yarn", "start:server"]

src/clients/SlackClient.ts

@@ -1,3 +1,3 @@
 export type SlackClient = {
-  sendMessage: (text: string) => Promise<void>;
+  sendMessage: (text: string, options?: { ts?: string }) => Promise<{ ts: string }>;
 };

src/infrastructures/implementDeploymentService.ts

@@ -0,0 +1,70 @@
+import { type SlackClient } from '../clients/SlackClient';
+import { type GithubDeploymentService } from '../services/GithubDeploymentService';
+
+const identifierToSlackTs: Record<string, string> = {};
+
+export const implementDeploymentService = ({ slackClient }: { slackClient: SlackClient }): GithubDeploymentService => {
+  return {
+    handleCreateRelease: async (body) => {
+      const author: string = body.release.author.login;
+      const releaseBody: string = body.release.body;
+      const tag: string = body.release.tag_name;
+      const releaseUrl: string = body.release.html_url;
+      const repository = body.repository.name;
+
+      const changes = releaseBody.split('\n').reduce<{ content: string; contributor: string }[]>((acc, cur) => {
+        const match = cur.match(/\* (.*) by @(.*) in (.*)/);
+        if (!match) return acc;
+        return [...acc, { content: match[1], contributor: match[2] }];
+      }, []);
+
+      const { ts } = await slackClient.sendMessage(
+        [
+          `:rocket: *${repository}* by @${author} (<${releaseUrl}|${tag}>)`,
+          ...changes.map((c) => `  - ${c.content} @${c.contributor}`),
+        ].join('\n'),
+      );
+
+      identifierToSlackTs[toIdentifier({ tag, repository })] = ts;
+    },
+    handleActionStart: async (body) => {
+      const workflowName: string = body.workflow_run.name;
+      const tag: string = body.workflow_run.head_branch;
+      const repository: string = body.repository.name;
+      const workflowId: number = body.workflow_run.id;
+      const workflowUrl: string = body.workflow_run.html_url;
+
+      const isDeploy = workflowName.toLowerCase().includes('deploy');
+      if (!isDeploy) return;
+
+      const ts = identifierToSlackTs[toIdentifier({ tag, repository })];
+      if (!ts) return;
+
+      await slackClient.sendMessage(
+        [`:wip: deployment started :point_right: <${workflowUrl}|${workflowId}>`].join('\n'),
+        { ts },
+      );
+    },
+    handleActionComplete: async (body) => {
+      const workflowName: string = body.workflow_run.name;
+      const tag: string = body.workflow_run.head_branch;
+      const repository: string = body.repository.name;
+      const workflowId: number = body.workflow_run.id;
+      const workflowUrl: string = body.workflow_run.html_url;
+
+      const isDeploy = workflowName.toLowerCase().includes('deploy');
+      if (!isDeploy) return;
+
+      const ts = identifierToSlackTs[toIdentifier({ tag, repository })];
+      if (!ts) return;
+
+      await slackClient.sendMessage([`:tada: deployment completed <${workflowUrl}|${workflowId}>`].join('\n'), {
+        ts,
+      });
+
+      delete identifierToSlackTs[toIdentifier({ tag, repository })];
+    },
+  };
+};
+
+const toIdentifier = ({ tag, repository }: { repository: string; tag: string }) => `${repository}:${tag}`;

src/infrastructures/implementSlackHttpClient.ts

@@ -6,11 +6,11 @@ type Deps = {
 };
 export const implementSlackHttpClient = ({ external: { slackAuthToken }, channelId }: Deps): SlackClient => {
   return {
-    sendMessage: async (text: string) => {
+    sendMessage: async (text: string, options) => {
       const response = await fetch('https://slack.com/api/chat.postMessage', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${slackAuthToken}` },
-        body: JSON.stringify({ channel: channelId, text }),
+        body: JSON.stringify({ channel: channelId, text, thread_ts: options?.ts }),
       });
       const data = await response.json();
       if (!data.ok) throw data;

src/server.ts

@@ -1,6 +1,7 @@
 import dotenv from 'dotenv';
 import express from 'express';
 
+import { implementDeploymentService } from './infrastructures/implementDeploymentService';
 import { implementSlackEventService } from './infrastructures/implementSlackEventService';
 import { implementSlackHttpClient } from './infrastructures/implementSlackHttpClient';
 
@@ -9,10 +10,12 @@ dotenv.config({ path: '.env.local' });
 const slackAuthToken = process.env.SLACK_AUTH_TOKEN;
 const slackBotToken = process.env.SLACK_BOT_TOKEN;
 const slackWatcherChannelId = process.env.SLACK_WATCHER_CHANNEL_ID;
+const deployWatcherChannelId = process.env.DEPLOY_WATCHER_CHANNEL_ID;
 
 if (!slackAuthToken) throw new Error('Missing Slack Auth Token');
 if (!slackBotToken) throw new Error('Missing Slack Bot Token');
 if (!slackWatcherChannelId) throw new Error('Missing Slack Watcher Channel ID');
+if (!deployWatcherChannelId) throw new Error('Missing Deploy Watcher Channel ID');
 
 const PORT = 3000;
 const app = express();
@@ -25,11 +28,18 @@ const app = express();
 ██████╔╝███████╗██║     ███████╗██║ ╚████║██████╔╝███████╗██║ ╚████║╚██████╗██║███████╗███████║
 ╚═════╝ ╚══════╝╚═╝     ╚══════╝╚═╝  ╚═══╝╚═════╝ ╚══════╝╚═╝  ╚═══╝ ╚═════╝╚═╝╚══════╝╚══════╝                                    
  */
-const slackClient = implementSlackHttpClient({
-  external: { slackAuthToken },
-  channelId: slackWatcherChannelId,
+const slackService = implementSlackEventService({
+  slackClient: implementSlackHttpClient({
+    external: { slackAuthToken },
+    channelId: slackWatcherChannelId,
+  }),
+});
+const deploymentService = implementDeploymentService({
+  slackClient: implementSlackHttpClient({
+    external: { slackAuthToken },
+    channelId: deployWatcherChannelId,
+  }),
 });
-const slackService = implementSlackEventService({ slackClient });
 
 /**
 ██████╗ ███████╗ ██████╗██╗      █████╗ ██████╗ ███████╗
@@ -56,6 +66,15 @@ app.post('/slack/action-endpoint', express.json(), (req, res) => {
   }
 });
 
+app.post('/github/webhook-endpoint', express.json(), async (req, res) => {
+  if ('release' in req.body && req.body.action === 'released') await deploymentService.handleCreateRelease(req.body);
+  if ('workflow_run' in req.body && req.body.action === 'requested')
+    await deploymentService.handleActionStart(req.body);
+  if ('workflow_run' in req.body && req.body.action === 'completed')
+    await deploymentService.handleActionComplete(req.body);
+  res.sendStatus(200);
+});
+
 /**
 ███████╗████████╗ █████╗ ██████╗ ████████╗
 ██╔════╝╚══██╔══╝██╔══██╗██╔══██╗╚══██╔══╝

src/services/GithubDeploymentService.ts

@@ -0,0 +1,13 @@
+export type GithubDeploymentService = {
+  handleCreateRelease: (body: {
+    release: { author: { login: string }; body: string; tag_name: string; html_url: string };
+    repository: { name: string };
+  }) => Promise<void>;
+  handleActionStart: (body: WorkflowRunBody) => Promise<void>;
+  handleActionComplete: (body: WorkflowRunBody) => Promise<void>;
+};
+
+type WorkflowRunBody = {
+  workflow_run: { name: string; head_branch: string; id: number; html_url: string };
+  repository: { name: string };
+};