github-issue-tower-defence-management 1.35.2 → 1.36.1

package/src/adapter/repositories/GraphqlProjectRepository.ts

@@ -1,4 +1,4 @@
-import axios from 'axios';
+import ky from 'ky';
 import { BaseGitHubRepository } from './BaseGitHubRepository';
 import { ProjectRepository } from '../../domain/usecases/adapter-interfaces/ProjectRepository';
 import { FieldOption, Project } from '../../domain/entities/Project';
@@ -46,34 +46,33 @@ export class GraphqlProjectRepository
       },
     };
 
-    const response = await axios<{
-      data: {
-        organization: {
-          projectV2: {
-            id: string;
-            databaseId: number;
+    const response = await ky
+      .post('https://api.github.com/graphql', {
+        json: graphqlQuery,
+        headers: {
+          Authorization: `Bearer ${this.ghToken}`,
+        },
+      })
+      .json<{
+        data: {
+          organization: {
+            projectV2: {
+              id: string;
+              databaseId: number;
+            };
           };
-        };
-        user: {
-          projectV2: {
-            id: string;
-            databaseId: number;
+          user: {
+            projectV2: {
+              id: string;
+              databaseId: number;
+            };
           };
         };
-      };
-    }>({
-      url: 'https://api.github.com/graphql',
-      method: 'post',
-      headers: {
-        Authorization: `Bearer ${this.ghToken}`,
-        'Content-Type': 'application/json',
-      },
-      data: JSON.stringify(graphqlQuery),
-    });
+      }>();
 
     const projectId =
-      response.data.data.organization?.projectV2?.id ||
-      response.data.data.user?.projectV2?.id;
+      response.data.organization?.projectV2?.id ||
+      response.data.user?.projectV2?.id;
     if (!projectId) {
       throw new Error('projectId is not found');
     }
@@ -142,56 +141,51 @@ export class GraphqlProjectRepository
     const variables = {
       projectId: projectId,
     };
-    const response = await axios.post<{
-      data: {
-        node: {
-          id: string;
-          databaseId: number;
-          title: string;
-          shortDescription: string;
-          public: boolean;
-          closed: boolean;
-          createdAt: string;
-          updatedAt: string;
-          number: number;
-          url: string;
-          fields: {
-            nodes: {
-              id: string;
-              databaseId: number;
-              name: string;
-              dataType: string;
-              configuration: {
-                iterations: {
-                  startDate: string;
-                  duration: string;
-                  title: string;
-                }[];
-              };
-              options: {
+    const response = await ky
+      .post('https://api.github.com/graphql', {
+        json: { query, variables },
+        headers: {
+          Authorization: `Bearer ${this.ghToken}`,
+        },
+      })
+      .json<{
+        data: {
+          node: {
+            id: string;
+            databaseId: number;
+            title: string;
+            shortDescription: string;
+            public: boolean;
+            closed: boolean;
+            createdAt: string;
+            updatedAt: string;
+            number: number;
+            url: string;
+            fields: {
+              nodes: {
                 id: string;
+                databaseId: number;
                 name: string;
-                description: string;
-                color: string;
+                dataType: string;
+                configuration: {
+                  iterations: {
+                    startDate: string;
+                    duration: string;
+                    title: string;
+                  }[];
+                };
+                options: {
+                  id: string;
+                  name: string;
+                  description: string;
+                  color: string;
+                }[];
               }[];
-            }[];
+            };
           };
         };
-      };
-    }>(
-      'https://api.github.com/graphql',
-      {
-        query,
-        variables,
-      },
-      {
-        headers: {
-          Authorization: `Bearer ${this.ghToken}`,
-          'Content-Type': 'application/json',
-        },
-      },
-    );
-    const project = response.data.data.node;
+      }>();
+    const project = response.data.node;
     if (!project) {
       return null;
     }

package/src/adapter/repositories/{AxiosSlackRepository.test.ts → KySlackRepository.test.ts}

@@ -1,5 +1,5 @@
 import dotenv from 'dotenv';
-import { AxiosSlackRepository } from './AxiosSlackRepository';
+import { KySlackRepository } from './KySlackRepository';
 import fs from 'fs';
 import https from 'https';
 import path from 'path';
@@ -16,13 +16,13 @@ if (!SLACK_USER_TOKEN) {
   throw new Error('SLACK_USER_TOKEN is required');
 }
 
-describe('AxiosSlackRepository Integration Tests', () => {
+describe('KySlackRepository Integration Tests', () => {
   jest.setTimeout(60 * 1000);
   jest.retryTimes(3, { logErrorsBeforeRetry: true });
-  let slackRepository: AxiosSlackRepository;
+  let slackRepository: KySlackRepository;
 
   beforeAll(() => {
-    slackRepository = new AxiosSlackRepository(SLACK_USER_TOKEN);
+    slackRepository = new KySlackRepository(SLACK_USER_TOKEN);
   });
   beforeEach(async () => {
     await new Promise((resolve) => setTimeout(resolve, 2000));

package/src/adapter/repositories/KySlackRepository.ts

@@ -0,0 +1,297 @@
+import ky from 'ky';
+import fs from 'fs';
+import { SlackRepository } from '../../domain/usecases/adapter-interfaces/SlackRepository';
+
+type ConversationsListResponse = {
+  ok: boolean;
+  channels: { id: string; name: string }[];
+};
+type UsersListResponse = {
+  ok: boolean;
+  members: { id: string; name: string }[];
+};
+type PostMessageResponse = {
+  ok: boolean;
+  ts: string;
+};
+type UploadUrlResponse = {
+  ok: boolean;
+  upload_url: string;
+  file_id: string;
+};
+type CompleteUploadResponse = {
+  ok: boolean;
+};
+type FileInfoResponse = {
+  ok: boolean;
+  file: { url_private: string };
+};
+
+const isRecord = (data: unknown): data is Record<string, unknown> => {
+  return typeof data === 'object' && data !== null;
+};
+
+const isConversationsListResponse = (
+  data: unknown,
+): data is ConversationsListResponse => {
+  return (
+    isRecord(data) &&
+    typeof data['ok'] === 'boolean' &&
+    Array.isArray(data['channels'])
+  );
+};
+
+const isUsersListResponse = (data: unknown): data is UsersListResponse => {
+  return (
+    isRecord(data) &&
+    typeof data['ok'] === 'boolean' &&
+    Array.isArray(data['members'])
+  );
+};
+
+const isPostMessageResponse = (data: unknown): data is PostMessageResponse => {
+  return isRecord(data) && typeof data['ok'] === 'boolean';
+};
+
+const isUploadUrlResponse = (data: unknown): data is UploadUrlResponse => {
+  return (
+    isRecord(data) &&
+    typeof data['ok'] === 'boolean' &&
+    'upload_url' in data &&
+    'file_id' in data
+  );
+};
+
+const isCompleteUploadResponse = (
+  data: unknown,
+): data is CompleteUploadResponse => {
+  return isRecord(data) && typeof data['ok'] === 'boolean';
+};
+
+const isFileInfoResponse = (data: unknown): data is FileInfoResponse => {
+  return isRecord(data) && typeof data['ok'] === 'boolean' && 'file' in data;
+};
+
+export class KySlackRepository implements SlackRepository {
+  private readonly client: typeof ky;
+  private readonly authHeader: string;
+  private readonly baseUrl = 'https://slack.com/api';
+
+  constructor(userToken: string) {
+    if (!userToken.startsWith('xoxp-')) {
+      throw new Error('Invalid user token. It should start with xoxp-');
+    }
+    this.authHeader = `Bearer ${userToken}`;
+    this.client = ky.extend({
+      retry: {
+        limit: 3,
+        methods: ['get', 'post'],
+        statusCodes: [429, 500, 502, 503, 504],
+      },
+    });
+  }
+
+  async postMessageToChannel(
+    message: string,
+    channelName: string,
+  ): Promise<{
+    threadTs: string;
+  }> {
+    const data = await this.client
+      .get(`${this.baseUrl}/conversations.list`, {
+        headers: { Authorization: this.authHeader },
+      })
+      .json<ConversationsListResponse>();
+
+    if (!isConversationsListResponse(data)) {
+      throw new Error(`Invalid response: ${JSON.stringify(data)}`);
+    }
+
+    const channel = data.channels.find((c) => c.name === channelName);
+    if (!channel) throw new Error(`Channel ${channelName} not found`);
+
+    const res = await this.client
+      .post(`${this.baseUrl}/chat.postMessage`, {
+        json: { channel: channel.id, text: message },
+        headers: { Authorization: this.authHeader },
+      })
+      .json<PostMessageResponse>();
+
+    if (!isPostMessageResponse(res)) {
+      throw new Error(`Invalid response: ${JSON.stringify(res)}`);
+    }
+    if (!res.ok) {
+      throw new Error(`Failed to post message: ${JSON.stringify(res)}`);
+    }
+    return { threadTs: res.ts };
+  }
+
+  async postMessageToChannelThread(
+    message: string,
+    channelName: string,
+    threadTs: string,
+  ): Promise<void> {
+    const data = await this.client
+      .get(`${this.baseUrl}/conversations.list`, {
+        headers: { Authorization: this.authHeader },
+      })
+      .json<ConversationsListResponse>();
+
+    if (!isConversationsListResponse(data)) {
+      throw new Error(`Invalid response: ${JSON.stringify(data)}`);
+    }
+
+    const channel = data.channels.find((c) => c.name === channelName);
+    if (!channel) throw new Error(`Channel ${channelName} not found`);
+
+    const res = await this.client
+      .post(`${this.baseUrl}/chat.postMessage`, {
+        json: { channel: channel.id, text: message, thread_ts: threadTs },
+        headers: { Authorization: this.authHeader },
+      })
+      .json<PostMessageResponse>();
+
+    if (!isPostMessageResponse(res)) {
+      throw new Error(`Invalid response: ${JSON.stringify(res)}`);
+    }
+    if (!res.ok) {
+      throw new Error(`Failed to post message: ${JSON.stringify(res)}`);
+    }
+  }
+
+  async postMessageToDirectMessage(
+    message: string,
+    userName: string,
+  ): Promise<void> {
+    const data = await this.client
+      .get(`${this.baseUrl}/users.list`, {
+        headers: { Authorization: this.authHeader },
+      })
+      .json<UsersListResponse>();
+
+    if (!isUsersListResponse(data)) {
+      throw new Error(`Invalid response: ${JSON.stringify(data)}`);
+    }
+
+    const user = data.members.find((u) => u.name === userName);
+    if (!user) throw new Error(`User ${userName} not found`);
+
+    const res = await this.client
+      .post(`${this.baseUrl}/chat.postMessage`, {
+        json: { channel: user.id, text: message },
+        headers: { Authorization: this.authHeader },
+      })
+      .json<PostMessageResponse>();
+
+    if (!isPostMessageResponse(res)) {
+      throw new Error(`Invalid response: ${JSON.stringify(res)}`);
+    }
+    if (!res.ok) {
+      throw new Error(`Failed to post message: ${JSON.stringify(res)}`);
+    }
+  }
+
+  async postMessageToChannelWithImage(
+    message: string,
+    channelName: string,
+    imageFilePath: string,
+  ): Promise<void> {
+    const data = await this.client
+      .get(`${this.baseUrl}/conversations.list`, {
+        headers: { Authorization: this.authHeader },
+      })
+      .json<ConversationsListResponse>();
+
+    if (!isConversationsListResponse(data)) {
+      throw new Error(`Invalid response: ${JSON.stringify(data)}`);
+    }
+
+    const channel = data.channels.find((c) => c.name === channelName);
+    if (!channel) throw new Error(`Channel ${channelName} not found`);
+
+    const fileStats = fs.statSync(imageFilePath);
+    const fileName = imageFilePath.split('/').pop();
+
+    const formBody = new URLSearchParams({
+      filename: fileName ?? '',
+      length: String(fileStats.size),
+    });
+
+    const uploadUrlRes = await this.client
+      .post(`${this.baseUrl}/files.getUploadURLExternal`, {
+        body: formBody,
+        headers: {
+          Authorization: this.authHeader,
+          'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
+        },
+      })
+      .json<UploadUrlResponse>();
+
+    if (!isUploadUrlResponse(uploadUrlRes)) {
+      throw new Error(`Invalid response: ${JSON.stringify(uploadUrlRes)}`);
+    }
+    if (!uploadUrlRes.ok) {
+      throw new Error(
+        `Failed to get upload URL: ${JSON.stringify(uploadUrlRes)}`,
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    const fileContent = fs.readFileSync(imageFilePath);
+    await ky.post(uploadUrlRes.upload_url, {
+      body: new Uint8Array(fileContent),
+      headers: { 'Content-Type': 'application/octet-stream' },
+    });
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    const completeRes = await this.client
+      .post(`${this.baseUrl}/files.completeUploadExternal`, {
+        json: { files: [{ id: uploadUrlRes.file_id }] },
+        headers: { Authorization: this.authHeader },
+      })
+      .json<CompleteUploadResponse>();
+
+    if (!isCompleteUploadResponse(completeRes)) {
+      throw new Error(`Invalid response: ${JSON.stringify(completeRes)}`);
+    }
+    if (!completeRes.ok) {
+      throw new Error(
+        `Failed to complete upload: ${JSON.stringify(completeRes)}`,
+      );
+    }
+
+    const fileInfo = await this.client
+      .get(`${this.baseUrl}/files.info?file=${uploadUrlRes.file_id}`, {
+        headers: { Authorization: this.authHeader },
+      })
+      .json<FileInfoResponse>();
+
+    if (!isFileInfoResponse(fileInfo)) {
+      throw new Error(`Invalid response: ${JSON.stringify(fileInfo)}`);
+    }
+    if (!fileInfo.ok) {
+      throw new Error(`Failed to get file info: ${JSON.stringify(fileInfo)}`);
+    }
+
+    const imageUrl = fileInfo.file.url_private;
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    const res = await this.client
+      .post(`${this.baseUrl}/chat.postMessage`, {
+        json: {
+          channel: channel.id,
+          text: message,
+          blocks: [{ type: 'image', image_url: imageUrl, alt_text: fileName }],
+        },
+        headers: { Authorization: this.authHeader },
+      })
+      .json<PostMessageResponse>();
+
+    if (!isPostMessageResponse(res)) {
+      throw new Error(`Invalid response: ${JSON.stringify(res)}`);
+    }
+    if (!res.ok) {
+      throw new Error(`Failed to post message: ${JSON.stringify(res)}`);
+    }
+  }
+}

package/src/adapter/repositories/issue/ApiV3IssueRepository.ts

@@ -1,4 +1,4 @@
-import axios from 'axios';
+import ky from 'ky';
 import { BaseGitHubRepository } from '../BaseGitHubRepository';
 
 export class ApiV3IssueRepository extends BaseGitHubRepository {
@@ -35,22 +35,21 @@ export class ApiV3IssueRepository extends BaseGitHubRepository {
       url += `&assignee=${query.assignee}`;
     }
 
-    const response = await axios.get<{
-      items: {
-        html_url: string;
-        title: string;
-        number: string;
-      }[];
-    }>(url, {
-      headers: {
-        Authorization: `token ${this.ghToken}`,
-        Accept: 'application/vnd.github.v3+json',
-      },
-    });
-    if (response.status !== 200) {
-      throw new Error(`Failed to search issue: ${response.status}`);
-    }
-    return response.data.items.map((item) => ({
+    const response = await ky
+      .get(url, {
+        headers: {
+          Authorization: `token ${this.ghToken}`,
+          Accept: 'application/vnd.github.v3+json',
+        },
+      })
+      .json<{
+        items: {
+          html_url: string;
+          title: string;
+          number: string;
+        }[];
+      }>();
+    return response.items.map((item) => ({
       url: item.html_url,
       title: item.title,
       number: item.number,
@@ -66,22 +65,21 @@ export class ApiV3IssueRepository extends BaseGitHubRepository {
     }[]
   > => {
     const url = `https://api.github.com/search/issues?q=${query}`;
-    const response = await axios.get<{
-      items: {
-        html_url: string;
-        title: string;
-        number: string;
-      }[];
-    }>(url, {
-      headers: {
-        Authorization: `token ${this.ghToken}`,
-        Accept: 'application/vnd.github.v3+json',
-      },
-    });
-    if (response.status !== 200) {
-      throw new Error(`Failed to search issue: ${response.status}`);
-    }
-    return response.data.items.map((item) => ({
+    const response = await ky
+      .get(url, {
+        headers: {
+          Authorization: `token ${this.ghToken}`,
+          Accept: 'application/vnd.github.v3+json',
+        },
+      })
+      .json<{
+        items: {
+          html_url: string;
+          title: string;
+          number: string;
+        }[];
+      }>();
+    return response.items.map((item) => ({
       url: item.html_url,
       title: item.title,
       number: item.number,

package/src/adapter/repositories/issue/CheerioIssueRepository.test.ts

@@ -1,6 +1,6 @@
 import { CheerioIssueRepository } from './CheerioIssueRepository';
 import * as cheerio from 'cheerio';
-import axios from 'axios';
+import ky from 'ky';
 import { InternalGraphqlIssueRepository } from './InternalGraphqlIssueRepository';
 import dotenv from 'dotenv';
 import { LocalStorageRepository } from '../LocalStorageRepository';
@@ -186,8 +186,8 @@ describe('CheerioIssueRepository', () => {
   describe('getStatusTimelineEvents', () => {
     it('should return status timeline events', async () => {
       const headers = await repository.createHeader();
-      const content = await axios.get<string>(issueUrl, { headers });
-      const $ = cheerio.load(content.data);
+      const html = await ky.get(issueUrl, { headers }).text();
+      const $ = cheerio.load(html);
       const statusTimeline = await repository.getStatusTimelineEvents($);
       expect(statusTimeline).toEqual([]);
     });

package/src/adapter/repositories/issue/CheerioIssueRepository.ts

@@ -1,4 +1,4 @@
-import axios from 'axios';
+import ky from 'ky';
 import * as cheerio from 'cheerio';
 import { BaseGitHubRepository } from '../BaseGitHubRepository';
 import { InternalGraphqlIssueRepository } from './InternalGraphqlIssueRepository';
@@ -44,8 +44,7 @@ export class CheerioIssueRepository extends BaseGitHubRepository {
   }
   getIssue = async (issueUrl: string): Promise<Issue> => {
     const headers = await this.createHeader();
-    const content = await axios.get<string>(issueUrl, { headers });
-    const html = content.data;
+    const html = await ky.get(issueUrl, { headers }).text();
     const $ = cheerio.load(html);
     if (html.includes('react-app.embeddedData')) {
       const issue =