github-issue-tower-defence-management 1.1.0

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts

@@ -0,0 +1,95 @@
+import YAML from 'yaml';
+import TYPIA from 'typia';
+import fs from 'fs';
+import { SystemDateRepository } from '../../repositories/SystemDateRepository';
+import { LocalStorageRepository } from '../../repositories/LocalStorageRepository';
+import { GoogleSpreadsheetRepository } from '../../repositories/GoogleSpreadsheetRepository';
+import { GraphqlProjectRepository } from '../../repositories/GraphqlProjectRepository';
+import { ApiV3IssueRepository } from '../../repositories/issue/ApiV3IssueRepository';
+import { CheerioIssueRepository } from '../../repositories/issue/CheerioIssueRepository';
+import { RestIssueRepository } from '../../repositories/issue/RestIssueRepository';
+import { GraphqlProjectItemRepository } from '../../repositories/issue/GraphqlProjectItemRepository';
+import { ApiV3CheerioRestIssueRepository } from '../../repositories/issue/ApiV3CheerioRestIssueRepository';
+import { GenerateWorkingTimeReportUseCase } from '../../../domain/usecases/GenerateWorkingTimeReportUseCase';
+import { HandleScheduledEventUseCase } from '../../../domain/usecases/HandleScheduledEventUseCase';
+import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
+import { ActionAnnouncementUseCase } from '../../../domain/usecases/ActionAnnouncementUseCase';
+import { SetWorkflowManagementIssueToStoryUseCase } from '../../../domain/usecases/SetWorkflowManagementIssueToStoryUseCase';
+import { InternalGraphqlIssueRepository } from '../../repositories/issue/InternalGraphqlIssueRepository';
+import { ClearNextActionHourUseCase } from '../../../domain/usecases/ClearNextActionHourUseCase';
+import { AnalyzeProblemByIssueUseCase } from '../../../domain/usecases/AnalyzeProblemByIssueUseCase';
+import { Issue } from '../../../domain/entities/Issue';
+import { Project } from '../../../domain/entities/Project';
+
+export class HandleScheduledEventUseCaseHandler {
+  handle = async (
+    configFilePath: string,
+  ): Promise<{
+    project: Project;
+    issues: Issue[];
+    cacheUsed: boolean;
+    targetDateTimes: Date[];
+  }> => {
+    const configFileContent = fs.readFileSync(configFilePath, 'utf8');
+    const input: unknown = YAML.parse(configFileContent);
+    type inputType = Parameters<HandleScheduledEventUseCase['run']>[0];
+    if (!TYPIA.is<inputType>(input)) {
+      throw new Error(
+        `Invalid input: ${JSON.stringify(input)}\n\n${JSON.stringify(TYPIA.validate<inputType>(input))}`,
+      );
+    }
+
+    const systemDateRepository = new SystemDateRepository();
+    const localStorageRepository = new LocalStorageRepository();
+    const googleSpreadsheetRepository = new GoogleSpreadsheetRepository(
+      localStorageRepository,
+    );
+    const localStorageCacheRepository = new LocalStorageCacheRepository(
+      localStorageRepository,
+    );
+    const projectRepository = new GraphqlProjectRepository();
+    const apiV3IssueRepository = new ApiV3IssueRepository();
+    const internalGraphqlIssueRepository = new InternalGraphqlIssueRepository();
+    const cheerioIssueRepository = new CheerioIssueRepository(
+      internalGraphqlIssueRepository,
+    );
+    const restIssueRepository = new RestIssueRepository();
+    const graphqlProjectItemRepository = new GraphqlProjectItemRepository();
+    const issueRepository = new ApiV3CheerioRestIssueRepository(
+      apiV3IssueRepository,
+      cheerioIssueRepository,
+      restIssueRepository,
+      graphqlProjectItemRepository,
+      localStorageCacheRepository,
+    );
+    const generateWorkingTimeReportUseCase =
+      new GenerateWorkingTimeReportUseCase(
+        issueRepository,
+        googleSpreadsheetRepository,
+        systemDateRepository,
+      );
+    const actionAnnouncement = new ActionAnnouncementUseCase(issueRepository);
+    const setWorkflowManagementIssueToStoryUseCase =
+      new SetWorkflowManagementIssueToStoryUseCase(issueRepository);
+    const clearNextActionHourUseCase = new ClearNextActionHourUseCase(
+      issueRepository,
+    );
+    const analyzeProblemByIssueUseCase = new AnalyzeProblemByIssueUseCase(
+      issueRepository,
+      systemDateRepository,
+    );
+    const handleScheduledEventUseCase = new HandleScheduledEventUseCase(
+      generateWorkingTimeReportUseCase,
+      actionAnnouncement,
+      setWorkflowManagementIssueToStoryUseCase,
+      clearNextActionHourUseCase,
+      analyzeProblemByIssueUseCase,
+      systemDateRepository,
+      googleSpreadsheetRepository,
+      projectRepository,
+      issueRepository,
+    );
+
+    return await handleScheduledEventUseCase.run(input);
+  };
+}

package/src/adapter/repositories/AxiosSlackRepository.test.ts

@@ -0,0 +1,119 @@
+import dotenv from 'dotenv';
+import { AxiosSlackRepository } from './AxiosSlackRepository';
+import fs from 'fs';
+import https from 'https';
+import path from 'path';
+
+dotenv.config();
+
+const SLACK_USER_TOKEN = process.env.SLACK_USER_TOKEN;
+const TEST_CHANNEL_NAME = 'test-integration';
+const TEST_USER_NAME = 'shikata.hiromi_test2';
+const TEST_IMAGE_URL = 'https://i.imgur.com/Zi3qToQ.jpeg';
+const TEST_IMAGE_PATH = './tmp/test/fixtures/test-image.png';
+
+if (!SLACK_USER_TOKEN) {
+  throw new Error('SLACK_USER_TOKEN is required');
+}
+
+describe('AxiosSlackRepository Integration Tests', () => {
+  jest.setTimeout(30 * 1000);
+  let slackRepository: AxiosSlackRepository;
+
+  beforeAll(() => {
+    slackRepository = new AxiosSlackRepository(SLACK_USER_TOKEN);
+  });
+
+  describe('postMessageToChannel', () => {
+    it('should post a message to a channel', async () => {
+      const message = `Test message ${new Date().toISOString()}`;
+
+      await expect(
+        slackRepository.postMessageToChannel(message, TEST_CHANNEL_NAME),
+      ).resolves.not.toThrow();
+    });
+
+    it('should throw error for non-existent channel', async () => {
+      const message = 'Test message';
+
+      await expect(
+        slackRepository.postMessageToChannel(message, 'non-existent-channel'),
+      ).rejects.toThrow('Channel non-existent-channel not found');
+    });
+  });
+
+  describe('postMessageToChannelThread', () => {
+    it('should post a message to a thread', async () => {
+      const message = `Test thread message ${new Date().toISOString()}`;
+      const { threadTs } = await slackRepository.postMessageToChannel(
+        `message for thread`,
+        TEST_CHANNEL_NAME,
+      );
+
+      await expect(
+        slackRepository.postMessageToChannelThread(
+          message,
+          TEST_CHANNEL_NAME,
+          threadTs,
+        ),
+      ).resolves.not.toThrow();
+    });
+  });
+
+  describe('postMessageToChannelWithImage', () => {
+    it.skip('should post a message with image', async () => {
+      const message = `Test image message ${new Date().toISOString()}`;
+      if (!fs.existsSync(path.dirname(TEST_IMAGE_PATH))) {
+        fs.mkdirSync(path.dirname(TEST_IMAGE_PATH), { recursive: true });
+        const res = https.get(TEST_IMAGE_URL, (res) =>
+          res.pipe(fs.createWriteStream(TEST_IMAGE_PATH)),
+        );
+        await new Promise((resolve, reject) => {
+          res.on('end', resolve);
+          res.on('error', reject);
+        });
+      }
+
+      await expect(
+        slackRepository.postMessageToChannelWithImage(
+          message,
+          TEST_CHANNEL_NAME,
+          TEST_IMAGE_PATH,
+        ),
+      ).resolves.not.toThrow();
+    });
+
+    it('should throw error for non-existent image', async () => {
+      const message = 'Test message';
+
+      await expect(
+        slackRepository.postMessageToChannelWithImage(
+          message,
+          TEST_CHANNEL_NAME,
+          'non-existent-image.png',
+        ),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('postMessageToDirectMessage', () => {
+    it('should post a direct message', async () => {
+      const message = `Test DM ${new Date().toISOString()}`;
+
+      await expect(
+        slackRepository.postMessageToDirectMessage(message, TEST_USER_NAME),
+      ).resolves.not.toThrow();
+    });
+
+    it('should throw error for non-existent user', async () => {
+      const message = 'Test message';
+
+      await expect(
+        slackRepository.postMessageToDirectMessage(
+          message,
+          'non-existent-user',
+        ),
+      ).rejects.toThrow('User non-existent-user not found');
+    });
+  });
+});

package/src/adapter/repositories/AxiosSlackRepository.ts

@@ -0,0 +1,184 @@
+import axios, { AxiosInstance } from 'axios';
+import fs from 'fs';
+import { SlackRepository } from '../../domain/usecases/adapter-interfaces/SlackRepository';
+
+export class AxiosSlackRepository implements SlackRepository {
+  private readonly client: AxiosInstance;
+  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.client = axios.create({
+      baseURL: this.baseUrl,
+      headers: {
+        Authorization: `Bearer ${userToken}`,
+      },
+    });
+  }
+
+  async postMessageToChannel(
+    message: string,
+    channelName: string,
+  ): Promise<{
+    threadTs: string;
+  }> {
+    const { data } = await this.client.get<{
+      ok: boolean;
+      channels: { id: string; name: string }[];
+    }>('/conversations.list');
+
+    const channel = data.channels.find((c) => c.name === channelName);
+    if (!channel) throw new Error(`Channel ${channelName} not found`);
+
+    const res = await this.client.post<{ ok: boolean; ts: string }>(
+      '/chat.postMessage',
+      {
+        channel: channel.id,
+        text: message,
+      },
+    );
+    if (!res.data.ok) {
+      throw new Error(`Failed to post message: ${JSON.stringify(res.data)}`);
+    }
+    return {
+      threadTs: res.data.ts,
+    };
+  }
+
+  async postMessageToChannelThread(
+    message: string,
+    channelName: string,
+    threadTs: string,
+  ): Promise<void> {
+    const { data } = await this.client.get<{
+      ok: boolean;
+      channels: { id: string; name: string }[];
+    }>('/conversations.list');
+
+    const channel = data.channels.find((c) => c.name === channelName);
+    if (!channel) throw new Error(`Channel ${channelName} not found`);
+
+    const res = await this.client.post<{ ok: boolean }>('/chat.postMessage', {
+      channel: channel.id,
+      text: message,
+      thread_ts: threadTs,
+    });
+    if (!res.data.ok) {
+      throw new Error(`Failed to post message: ${JSON.stringify(res.data)}`);
+    }
+  }
+
+  async postMessageToDirectMessage(
+    message: string,
+    userName: string,
+  ): Promise<void> {
+    const { data } = await this.client.get<{
+      ok: boolean;
+      members: { id: string; name: string }[];
+    }>('/users.list');
+
+    const user = data.members.find((u) => u.name === userName);
+    if (!user) throw new Error(`User ${userName} not found`);
+
+    const res = await this.client.post<{ ok: boolean }>('/chat.postMessage', {
+      channel: user.id,
+      text: message,
+    });
+    if (!res.data.ok) {
+      throw new Error(`Failed to post message: ${JSON.stringify(res.data)}`);
+    }
+  }
+  async postMessageToChannelWithImage(
+    message: string,
+    channelName: string,
+    imageFilePath: string,
+  ): Promise<void> {
+    const { data } = await this.client.get<{
+      ok: boolean;
+      channels: { id: string; name: string }[];
+    }>('/conversations.list');
+
+    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 uploadUrlRes = await this.client.post<{
+      ok: boolean;
+      upload_url: string;
+      file_id: string;
+    }>(
+      '/files.getUploadURLExternal',
+      {
+        filename: fileName,
+        length: fileStats.size,
+      },
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
+        },
+      },
+    );
+    if (!uploadUrlRes.data.ok) {
+      throw new Error(
+        `Failed to get upload URL: ${JSON.stringify(uploadUrlRes.data)}`,
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    const fileContent = fs.readFileSync(imageFilePath);
+    await axios.post(uploadUrlRes.data.upload_url, fileContent, {
+      headers: {
+        'Content-Type': 'application/octet-stream',
+      },
+    });
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    const completeRes = await this.client.post<{ ok: boolean }>(
+      '/files.completeUploadExternal',
+      {
+        files: [
+          {
+            id: uploadUrlRes.data.file_id,
+          },
+        ],
+      },
+    );
+    if (!completeRes.data.ok) {
+      throw new Error(
+        `Failed to complete upload: ${JSON.stringify(completeRes.data)}`,
+      );
+    }
+
+    const fileInfo = await this.client.get<{
+      ok: boolean;
+      file: { url_private: string };
+    }>(`/files.info?file=${uploadUrlRes.data.file_id}`);
+
+    if (!fileInfo.data.ok) {
+      throw new Error(
+        `Failed to get file info: ${JSON.stringify(fileInfo.data)}`,
+      );
+    }
+
+    const imageUrl = fileInfo.data.file.url_private;
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    const res = await this.client.post<{ ok: boolean }>('/chat.postMessage', {
+      channel: channel.id,
+      text: message,
+      blocks: [
+        {
+          type: 'image',
+          image_url: imageUrl,
+          alt_text: fileName,
+        },
+      ],
+    });
+    if (!res.data.ok) {
+      throw new Error(`Failed to post message: ${JSON.stringify(res.data)}`);
+    }
+  }
+}

package/src/adapter/repositories/BaseGitHubRepository.test.ts

@@ -0,0 +1,95 @@
+import fs from 'fs';
+import { BaseGitHubRepository } from './BaseGitHubRepository';
+import resetAllMocks = jest.resetAllMocks;
+describe('BaseGitHubRepository', () => {
+  const jsonFilePath = './tmp/github.com.cookies.json';
+  class TestGitHubRepository extends BaseGitHubRepository {
+    constructor() {
+      super(jsonFilePath, process.env.GH_TOKEN);
+    }
+    extractIssueFromUrlPublic = this.extractIssueFromUrl;
+    createHeaderPublic = this.createHeader;
+    createCookieStringFromFilePublic = this.createCookieStringFromFile;
+    isCookiePublic = this.isCookie;
+  }
+  const baseGitHubRepository: TestGitHubRepository = new TestGitHubRepository();
+  beforeAll(() => {
+    resetAllMocks();
+    const cookies = [
+      {
+        name: 'name',
+        value: 'value',
+        domain: 'domain',
+        path: 'path',
+        expires: 1,
+        httpOnly: true,
+        secure: true,
+        sameSite: 'Lax',
+      },
+    ];
+    fs.writeFileSync(jsonFilePath, JSON.stringify(cookies));
+  });
+  afterAll(() => {
+    fs.rmSync(jsonFilePath);
+  });
+
+  describe('extractIssueFromUrl', () => {
+    it('should return issue number', () => {
+      const extracted = baseGitHubRepository.extractIssueFromUrlPublic(
+        'https://github.com/HiromiShikata/test-repository/issues/38',
+      );
+      expect(extracted).toEqual({
+        owner: 'HiromiShikata',
+        repo: 'test-repository',
+        issueNumber: 38,
+        isIssue: true,
+      });
+    });
+  });
+
+  describe('createHeader', () => {
+    it('should return headers with cookie', async () => {
+      const headers = await baseGitHubRepository.createHeaderPublic();
+      expect(headers).toHaveProperty('cookie');
+    });
+  });
+
+  describe('createCookieStringFromFile', () => {
+    it('should return cookie string', async () => {
+      const cookie =
+        await baseGitHubRepository.createCookieStringFromFilePublic();
+      expect(cookie).toEqual(
+        'name=value; Domain=domain; Path=path; Expires=Thu, 01 Jan 1970 00:00:01 GMT; HttpOnly; Secure; SameSite=Lax',
+      );
+    });
+  });
+
+  describe('isCookie', () => {
+    it('should return true if cookie is valid', () => {
+      const cookie = {
+        name: 'name',
+        value: 'value',
+        domain: 'domain',
+        path: 'path',
+        expires: 1,
+        httpOnly: true,
+        secure: true,
+        sameSite: 'lax',
+      };
+      expect(baseGitHubRepository.isCookiePublic(cookie)).toBe(true);
+    });
+
+    it('should return false if cookie is invalid', () => {
+      const cookie = {
+        name: 'name',
+        value: 'value',
+        domain: 'domain',
+        path: 'path',
+        expires: 1,
+        httpOnly: true,
+        secure: true,
+      };
+      expect(baseGitHubRepository.isCookiePublic(cookie)).toBe(false);
+    });
+  });
+});

package/src/adapter/repositories/BaseGitHubRepository.ts

@@ -0,0 +1,172 @@
+import { promises as fsPromises } from 'fs';
+import { serialize } from 'cookie';
+import axios, { AxiosError } from 'axios';
+import { getCookieContent } from 'gh-cookie';
+import fs from 'fs';
+
+axios.interceptors.response.use(
+  (response) => response,
+  (error: AxiosError) => {
+    if (error.response) {
+      throw new Error(`API Error: ${error.response.status}`);
+    }
+    throw new Error('Network Error');
+  },
+);
+
+interface Cookie {
+  name: string;
+  value: string;
+  domain?: string;
+  path?: string;
+  expires?: number;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: 'lax' | 'strict' | 'none';
+}
+
+export class BaseGitHubRepository {
+  cookie: string | null;
+  constructor(
+    readonly jsonFilePath: string = './tmp/github.com.cookies.json',
+    readonly ghToken: string = process.env.GH_TOKEN || 'dummy',
+    readonly ghUserName: string | undefined = process.env.GH_USER_NAME,
+    readonly ghUserPassword: string | undefined = process.env.GH_USER_PASSWORD,
+    readonly ghAuthenticatorKey: string | undefined = process.env
+      .GH_AUTHENTICATOR_KEY,
+  ) {
+    this.cookie = null;
+  }
+  protected extractIssueFromUrl = (
+    issueUrl: string,
+  ): { owner: string; repo: string; issueNumber: number; isIssue: boolean } => {
+    const match = issueUrl.match(
+      /https:\/\/github.com\/([^/]+)\/([^/]+)\/(issues|pull)\/(\d+)/,
+    );
+    if (!match) {
+      throw new Error(`Invalid issue URL: ${issueUrl}`);
+    }
+    const [, owner, repo, pullOrIssue, issueNumberStr] = match;
+    const issueNumber = parseInt(issueNumberStr, 10);
+    if (isNaN(issueNumber)) {
+      throw new Error(
+        `Invalid issue number: ${issueNumberStr}. URL: ${issueUrl}`,
+      );
+    }
+    return { owner, repo, issueNumber, isIssue: pullOrIssue === 'issues' };
+  };
+
+  getCookie = async (): Promise<string> => {
+    if (!this.cookie) {
+      this.cookie = await this.createCookieStringFromFile();
+    }
+    return this.cookie;
+  };
+  createHeader = async (): Promise<object> => {
+    const cookie = await this.getCookie();
+    const headers = {
+      accept:
+        'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+      'accept-language':
+        'en-US,en;q=0.9,es-MX;q=0.8,es;q=0.7,ja-JP;q=0.6,ja;q=0.5',
+      'cache-control': 'max-age=0',
+      'sec-ch-ua':
+        '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
+      'sec-ch-ua-mobile': '?0',
+      'sec-ch-ua-platform': '"Linux"',
+      'sec-fetch-dest': 'document',
+      'sec-fetch-mode': 'navigate',
+      'sec-fetch-site': 'same-origin',
+      'sec-fetch-user': '?1',
+      'upgrade-insecure-requests': '1',
+      Referer: 'https://github.com/orgs/community/discussions/30979',
+      'Referrer-Policy': 'no-referrer-when-downgrade',
+    };
+    return {
+      ...headers,
+      cookie: cookie,
+    };
+  };
+  protected createCookieStringFromFile = async (): Promise<string> => {
+    if (!fs.existsSync(this.jsonFilePath)) {
+      if (
+        !this.ghUserName ||
+        !this.ghUserPassword ||
+        !this.ghAuthenticatorKey
+      ) {
+        throw new Error('No cookie file and no credentials provided');
+      }
+      const cookie = await getCookieContent(
+        this.ghUserName,
+        this.ghUserPassword,
+        this.ghAuthenticatorKey,
+      );
+      await fsPromises.writeFile(this.jsonFilePath, cookie);
+    }
+    const data = await fsPromises.readFile(this.jsonFilePath, {
+      encoding: 'utf-8',
+    });
+    const cookiesData: unknown = JSON.parse(data);
+    return this.generateCookieHeaderFromJson(cookiesData);
+  };
+  protected isCookie = (cookie: object): cookie is Cookie => {
+    return (
+      'name' in cookie &&
+      typeof cookie.name === 'string' &&
+      'value' in cookie &&
+      typeof cookie.value === 'string' &&
+      'domain' in cookie &&
+      typeof cookie.domain === 'string' &&
+      'path' in cookie &&
+      typeof cookie.path === 'string' &&
+      'expires' in cookie &&
+      typeof cookie.expires === 'number' &&
+      'httpOnly' in cookie &&
+      typeof cookie.httpOnly === 'boolean' &&
+      'secure' in cookie &&
+      typeof cookie.secure === 'boolean' &&
+      'sameSite' in cookie &&
+      typeof cookie.sameSite === 'string' &&
+      ['lax', 'strict', 'none'].indexOf(cookie.sameSite) !== -1
+    );
+  };
+
+  protected generateCookieHeaderFromJson = async (
+    cookieData: unknown,
+  ): Promise<string> => {
+    if (!Array.isArray(cookieData)) {
+      throw new Error('Invalid cookie array');
+    }
+
+    const cookies: Cookie[] = cookieData.map((cookieOrig: object) => {
+      const sameSite =
+        typeof cookieOrig !== 'object' ||
+        !('sameSite' in cookieOrig) ||
+        typeof cookieOrig.sameSite !== 'string'
+          ? 'none'
+          : cookieOrig.sameSite.toLowerCase();
+      const cookie = {
+        ...cookieOrig,
+        sameSite,
+      };
+
+      if (!this.isCookie(cookie)) {
+        throw new Error(`Invalid cookie properties: ${JSON.stringify(cookie)}`);
+      }
+      return cookie;
+    });
+    const cookieHeader = cookies
+      .map((cookie) =>
+        serialize(cookie.name, cookie.value, {
+          domain: cookie.domain,
+          path: cookie.path,
+          expires: cookie.expires ? new Date(cookie.expires * 1000) : undefined,
+          httpOnly: cookie.httpOnly,
+          secure: cookie.secure,
+          sameSite: cookie.sameSite,
+        }),
+      )
+      .join('; ');
+    return cookieHeader;
+  };
+}