github-issue-tower-defence-management 1.1.0

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

@@ -0,0 +1,124 @@
+import { GoogleSpreadsheetRepository } from './GoogleSpreadsheetRepository';
+import { describe, test, expect } from '@jest/globals';
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+describe('GoogleSpreadsheetRepository', () => {
+  const localStorageRepository = new LocalStorageRepository();
+  const repository = new GoogleSpreadsheetRepository(localStorageRepository);
+  const spreadsheetUrl =
+    'https://docs.google.com/spreadsheets/d/1N_3y0y46v5tHbra5YSm6PldflcsF1bkfeWDdQ3MRuXM/edit?gid=0#gid=0';
+
+  describe('getSpreadsheetId', () => {
+    const testCases: [string, string][] = [
+      [
+        'https://docs.google.com/spreadsheets/d/1234567890abcdef/edit#gid=0',
+        '1234567890abcdef',
+      ],
+      [
+        'https://docs.google.com/spreadsheets/d/abcdef1234567890/edit',
+        'abcdef1234567890',
+      ],
+    ];
+
+    test.each(testCases)(
+      'given %s returns %s',
+      (input: string, expected: string) => {
+        expect(repository.getSpreadsheetId(input)).toBe(expected);
+      },
+    );
+  });
+
+  describe('getSheet', () => {
+    const testCases: [string, string, string[][] | null][] = [
+      ['SheetUndefined', 'Undefined Sheet', null],
+      // ['SheetEmpty', 'Empty Sheet', []],
+      ['SheetSingleCell', 'Single Cell', [['test']]],
+      [
+        'SheetMultipleRows',
+        'Multiple Rows',
+        [
+          ['1', '2'],
+          ['3', '4'],
+        ],
+      ],
+    ];
+
+    test.each(testCases)(
+      'gets sheet %s with %s',
+      async (sheetName: string, _: string, expected: string[][] | null) => {
+        const result = await repository.getSheet(spreadsheetUrl, sheetName);
+        expect(result).toEqual(expected);
+      },
+    );
+
+    test('returns null for non-existent sheet', async () => {
+      const result = await repository.getSheet(
+        spreadsheetUrl,
+        'NonExistentSheet',
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('updateCell', () => {
+    const testCases: [string, number, number, string][] = [
+      ['Sheet1', 0, 0, 'First Value'],
+      ['Sheet1', 0, 0, 'Updated Value'],
+      ['Sheet1', 1, 1, '123'],
+      ['Sheet1', 2, 2, 'Test'],
+    ];
+
+    test.each(testCases)(
+      'updates cell in sheet %s at row %d col %d with value %s',
+      async (sheetName: string, row: number, col: number, value: string) => {
+        await repository.updateCell(spreadsheetUrl, sheetName, row, col, value);
+        const result = await repository.getSheet(spreadsheetUrl, sheetName);
+        if (!result) {
+          throw new Error('Sheet not found');
+        }
+        expect(result[row][col]).toBe(value);
+      },
+    );
+  });
+
+  describe('appendSheetValues', () => {
+    const testCases: [string[][]][] = [
+      [[['Single Row']]],
+      [[['Multiple', 'Columns']]],
+      [
+        [
+          ['Row1Col1', 'Row1Col2'],
+          ['Row2Col1', 'Row2Col2'],
+        ],
+      ],
+    ];
+
+    test.each(testCases)(
+      'appends values %j to sheet',
+      async (values: string[][]) => {
+        const sheetName = 'AppendTest';
+        const initialSheet = await repository.getSheet(
+          spreadsheetUrl,
+          sheetName,
+        );
+        const initialLength = initialSheet ? initialSheet.length : 0;
+
+        await repository.appendSheetValues(spreadsheetUrl, sheetName, values);
+
+        const updatedSheet = await repository.getSheet(
+          spreadsheetUrl,
+          sheetName,
+        );
+        expect(updatedSheet).not.toBeNull();
+        if (!updatedSheet) {
+          throw new Error('Sheet not found');
+        }
+        expect(updatedSheet.length).toBe(initialLength + values.length);
+
+        for (let i = 0; i < values.length; i++) {
+          expect(updatedSheet[initialLength + i]).toEqual(values[i]);
+        }
+      },
+    );
+  });
+});

package/src/adapter/repositories/GoogleSpreadsheetRepository.ts

@@ -0,0 +1,151 @@
+import { SpreadsheetRepository } from '../../domain/usecases/adapter-interfaces/SpreadsheetRepository';
+import { google } from 'googleapis';
+import { LocalStorageRepository } from './LocalStorageRepository';
+import dotenv from 'dotenv';
+dotenv.config();
+
+export class GoogleSpreadsheetRepository implements SpreadsheetRepository {
+  keyFile = './tmp/service-account-key.json';
+
+  constructor(
+    readonly localStorageRepository: LocalStorageRepository,
+    serviceAccountKey: string = process.env.GOOGLE_SERVICE_ACCOUNT_KEY ||
+      'dummy',
+  ) {
+    this.localStorageRepository.write(this.keyFile, serviceAccountKey);
+  }
+
+  getSpreadsheetId = (spreadsheetUrl: string): string => {
+    const url = new URL(spreadsheetUrl);
+    return url.pathname.split('/')[3];
+  };
+  getSheet = async (
+    spreadsheetUrl: string,
+    sheetName: string,
+  ): Promise<string[][] | null> => {
+    const auth = new google.auth.GoogleAuth({
+      keyFile: this.keyFile,
+      scopes: ['https://www.googleapis.com/auth/spreadsheets'],
+    });
+    const sheets = google.sheets({ version: 'v4', auth });
+    const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
+    const responseSheet = await sheets.spreadsheets.get({
+      spreadsheetId,
+    });
+    if (responseSheet.status !== 200) {
+      throw new Error(
+        `Failed to get sheet: ${responseSheet.status}. ${JSON.stringify(responseSheet.data)}`,
+      );
+    }
+    const sheet = responseSheet.data.sheets?.find(
+      (s) => s.properties?.title === sheetName,
+    );
+    if (!sheet) {
+      return null;
+    }
+    const response = await sheets.spreadsheets.values.get({
+      spreadsheetId,
+      range: sheetName,
+    });
+    if (response.status !== 200) {
+      throw new Error(
+        `Failed to get sheet: ${response.status}. ${JSON.stringify(response.data)}`,
+      );
+    }
+    if (!response.data.values) {
+      return null;
+    }
+    return response.data.values.map((row) => row.map((cell) => String(cell)));
+  };
+  updateCell = async (
+    spreadsheetUrl: string,
+    sheetName: string,
+    row: number,
+    column: number,
+    value: string,
+  ): Promise<void> => {
+    const auth = new google.auth.GoogleAuth({
+      keyFile: this.keyFile,
+      scopes: ['https://www.googleapis.com/auth/spreadsheets'],
+    });
+    const sheets = google.sheets({ version: 'v4', auth });
+    const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
+    await this.createNewSheetIfNotExists(spreadsheetUrl, sheetName);
+    const response = await sheets.spreadsheets.values.update({
+      spreadsheetId,
+      range: `${sheetName}!${String.fromCharCode(65 + column)}${row + 1}`,
+      valueInputOption: 'RAW',
+      requestBody: {
+        values: [[value]],
+      },
+    });
+    if (response.status !== 200) {
+      throw new Error(
+        `Failed to update cell: ${response.status}. ${JSON.stringify(response.data)}`,
+      );
+    }
+  };
+  createNewSheetIfNotExists = async (
+    spreadsheetUrl: string,
+    sheetName: string,
+  ): Promise<void> => {
+    const auth = new google.auth.GoogleAuth({
+      keyFile: this.keyFile,
+      scopes: ['https://www.googleapis.com/auth/spreadsheets'],
+    });
+    const sheets = google.sheets({ version: 'v4', auth });
+    const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
+    const sheet = await this.getSheet(spreadsheetUrl, sheetName);
+    if (sheet !== null) {
+      return;
+    }
+    const response = await sheets.spreadsheets.batchUpdate({
+      spreadsheetId,
+      requestBody: {
+        requests: [
+          {
+            addSheet: {
+              properties: {
+                title: sheetName,
+              },
+            },
+          },
+        ],
+      },
+    });
+    if (response.status !== 200) {
+      throw new Error(
+        `Failed to create sheet: ${response.status}. ${JSON.stringify(response.data)}`,
+      );
+    }
+  };
+
+  appendSheetValues = async (
+    spreadsheetUrl: string,
+    sheetName: string,
+    values: string[][],
+  ): Promise<void> => {
+    const auth = new google.auth.GoogleAuth({
+      keyFile: this.keyFile,
+      scopes: ['https://www.googleapis.com/auth/spreadsheets'],
+    });
+    const sheets = google.sheets({ version: 'v4', auth });
+    const spreadsheetId = this.getSpreadsheetId(spreadsheetUrl);
+    await this.createNewSheetIfNotExists(spreadsheetUrl, sheetName);
+    const sheet = await this.getSheet(spreadsheetUrl, sheetName);
+    const range = `${sheetName}!A${sheet ? sheet.length + 1 : 1}:A`;
+    const response = await sheets.spreadsheets.values.append({
+      spreadsheetId,
+      range: range,
+      valueInputOption: 'RAW',
+      requestBody: {
+        values,
+      },
+    });
+    if (response.status !== 200) {
+      throw new Error(
+        `Failed to append values: ${response.status}. ${JSON.stringify(response.data)}`,
+      );
+    }
+  };
+}

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

@@ -0,0 +1,46 @@
+import { GraphqlProjectRepository } from './GraphqlProjectRepository';
+
+describe('GraphqlProjectRepository', () => {
+  let repository: GraphqlProjectRepository;
+  const token = process.env.GH_TOKEN;
+  const login = 'HiromiShikata';
+  const projectUrl = `https://github.com/users/HiromiShikata/projects/49`;
+  const projectNumber = 49;
+  const projectId = 'PVT_kwHOAGJHa84AFhgF';
+
+  beforeEach(() => {
+    repository = new GraphqlProjectRepository(token);
+  });
+
+  describe('fetchProjectId', () => {
+    it('should fetch project ID using GraphQL API', async () => {
+      const response = await repository.fetchProjectId(login, projectNumber);
+
+      expect(response).toEqual(projectId);
+    });
+  });
+
+  describe('findProjectIdByUrl', () => {
+    it('should extract project ID from URL and fetch it', async () => {
+      const response = await repository.findProjectIdByUrl(projectUrl);
+      expect(response).toEqual(projectId);
+    });
+  });
+
+  describe('getProject', () => {
+    it('should retrieve project details', async () => {
+      const project = await repository.getProject(projectId);
+      expect(project).toEqual({
+        id: 'PVT_kwHOAGJHa84AFhgF',
+        name: 'V2 project on owner for testing',
+        nextActionDate: {
+          fieldId: 'PVTF_lAHOAGJHa84AFhgFzgVlnK4',
+          name: 'NextActionDate',
+        },
+        nextActionHour: null,
+        remainingEstimationMinutes: null,
+        story: null,
+      });
+    });
+  });
+});

package/src/adapter/repositories/GraphqlProjectRepository.ts

@@ -0,0 +1,236 @@
+import axios from 'axios';
+import { BaseGitHubRepository } from './BaseGitHubRepository';
+import { ProjectRepository } from '../../domain/usecases/adapter-interfaces/ProjectRepository';
+import { Project } from '../../domain/entities/Project';
+import { normalizeFieldName } from './utils';
+
+export class GraphqlProjectRepository
+  extends BaseGitHubRepository
+  implements ProjectRepository
+{
+  extractProjectFromUrl = (
+    projectUrl: string,
+  ): {
+    owner: string;
+    projectNumber: number;
+  } => {
+    const url = new URL(projectUrl);
+    const path = url.pathname.split('/');
+    const owner = path[2];
+    const projectNumber = parseInt(path[4], 10);
+    return { owner, projectNumber };
+  };
+  fetchProjectId = async (
+    login: string,
+    projectNumber: number,
+  ): Promise<string> => {
+    const graphqlQuery = {
+      query: `query GetProjectID($login: String!, $number: Int!) {
+  organization(login: $login) {
+    projectV2(number: $number) {
+      id
+    }
+  }
+  user(login: $login){
+    projectV2(number: $number){
+      id
+    }
+  }
+}`,
+      variables: {
+        login: login,
+        number: projectNumber,
+      },
+    };
+
+    const response = await axios<{
+      data: {
+        organization: {
+          projectV2: {
+            id: string;
+          };
+        };
+        user: {
+          projectV2: {
+            id: string;
+          };
+        };
+      };
+    }>({
+      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;
+    if (!projectId) {
+      throw new Error('projectId is not found');
+    }
+    return projectId;
+  };
+  findProjectIdByUrl = async (
+    projectUrl: string,
+  ): Promise<Project['id'] | null> => {
+    const { owner, projectNumber } = this.extractProjectFromUrl(projectUrl);
+    return await this.fetchProjectId(owner, projectNumber);
+  };
+  getProject = async (projectId: Project['id']): Promise<Project | null> => {
+    const query = `query GetProjectV2($projectId: ID!) {
+  node(id: $projectId) {
+    ... on ProjectV2 {
+      id
+      title
+      shortDescription
+      public
+      closed
+      createdAt
+      updatedAt
+      number
+      url
+      fields(first: 100) {
+        nodes {
+          ... on ProjectV2Field {
+            id
+            name
+            dataType
+          }
+          ... on ProjectV2IterationField {
+            id
+            name
+            dataType
+            configuration {
+              iterations {
+                startDate
+                duration
+                title
+              }
+            }
+          }
+          ... on ProjectV2SingleSelectField {
+            id
+            name
+            dataType
+            options {
+              id
+              name
+              description
+              color
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+`;
+    const variables = {
+      projectId: projectId,
+    };
+    const response = await axios.post<{
+      data: {
+        node: {
+          id: string;
+          title: string;
+          shortDescription: string;
+          public: boolean;
+          closed: boolean;
+          createdAt: string;
+          updatedAt: string;
+          number: number;
+          url: string;
+          fields: {
+            nodes: {
+              id: string;
+              name: string;
+              dataType: string;
+              configuration: {
+                iterations: {
+                  startDate: string;
+                  duration: string;
+                  title: string;
+                }[];
+              };
+              options: {
+                id: string;
+                name: string;
+              }[];
+            }[];
+          };
+        };
+      };
+    }>(
+      'https://api.github.com/graphql',
+      {
+        query,
+        variables,
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${this.ghToken}`,
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+    const project = response.data.data.node;
+    if (!project) {
+      return null;
+    }
+    const nextActionDate = project.fields.nodes.find(
+      (field) => normalizeFieldName(field.name) === 'nextactiondate',
+    );
+    const nextActionHour = project.fields.nodes.find(
+      (field) => normalizeFieldName(field.name) === 'nextactionhour',
+    );
+    const story = project.fields.nodes.find(
+      (field) => normalizeFieldName(field.name) === 'story',
+    );
+    const workflowManagementStory = story?.options.find((option) =>
+      normalizeFieldName(option.name).includes('workflowmanagement'),
+    );
+    const remainignEstimationMinutes = project.fields.nodes.find(
+      (field) =>
+        normalizeFieldName(field.name) === 'remainingestimationminutes',
+    );
+    return {
+      id: project.id,
+      name: project.title,
+      nextActionDate: nextActionDate
+        ? {
+            name: nextActionDate.name,
+            fieldId: nextActionDate.id,
+          }
+        : null,
+      nextActionHour: nextActionHour
+        ? {
+            name: nextActionHour.name,
+            fieldId: nextActionHour.id,
+          }
+        : null,
+      story:
+        story && workflowManagementStory
+          ? {
+              name: story.name,
+              fieldId: story.id,
+              stories: story.options.map((option) => ({
+                id: option.id,
+                name: option.name,
+              })),
+              workflowManagementStory,
+            }
+          : null,
+      remainingEstimationMinutes: remainignEstimationMinutes
+        ? {
+            name: remainignEstimationMinutes.name,
+            fieldId: remainignEstimationMinutes.id,
+          }
+        : null,
+    };
+  };
+}

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

@@ -0,0 +1,146 @@
+import { LocalStorageCacheRepository } from './LocalStorageCacheRepository';
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+describe('LocalStorageCacheRepository', () => {
+  let localStorageRepository: jest.Mocked<LocalStorageRepository>;
+  let repository: LocalStorageCacheRepository;
+  let now: Date;
+
+  beforeEach(() => {
+    now = new Date('2024-01-01T00:00:00.000Z');
+    jest.useFakeTimers();
+    jest.setSystemTime(now);
+
+    localStorageRepository = {
+      listFiles: jest.fn(),
+      read: jest.fn(),
+      write: jest.fn(),
+      mkdir: jest.fn(),
+    };
+    repository = new LocalStorageCacheRepository(localStorageRepository);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('getLatest', () => {
+    type GetLatestParams = Parameters<LocalStorageCacheRepository['getLatest']>;
+    type GetLatestReturn = ReturnType<LocalStorageCacheRepository['getLatest']>;
+
+    interface TestCase {
+      name: string;
+      key: GetLatestParams[0];
+      files: string[];
+      fileContent: string | null;
+      expected: Awaited<GetLatestReturn>;
+    }
+
+    const testCases: TestCase[] = [
+      {
+        name: 'returns null when no files exist',
+        key: 'test-key',
+        files: [],
+        fileContent: null,
+        expected: null,
+      },
+      {
+        name: 'returns null when file content is empty',
+        key: 'test-key',
+        files: ['2024-01-01T00:00:00.000Z'],
+        fileContent: null,
+        expected: null,
+      },
+      {
+        name: 'returns null when content is invalid JSON',
+        key: 'test-key',
+        files: ['2024-01-01T00:00:00.000Z'],
+        fileContent: 'invalid-json',
+        expected: null,
+      },
+      {
+        name: 'returns value when valid JSON exists',
+        key: 'test-key',
+        files: ['2024-01-01T00:00:00.000Z'],
+        fileContent: '{"test": "value"}',
+        expected: {
+          value: { test: 'value' },
+          timestamp: new Date('2024-01-01T00:00:00.000Z'),
+        },
+      },
+    ];
+
+    test.each(testCases)(
+      '$name',
+      async ({ key, files, fileContent, expected }) => {
+        localStorageRepository.listFiles.mockReturnValue(files);
+        localStorageRepository.read.mockReturnValue(fileContent);
+
+        const result = await repository.getLatest(key);
+
+        expect(result).toEqual(expected);
+      },
+    );
+  });
+
+  describe('set', () => {
+    type SetParams = Parameters<LocalStorageCacheRepository['set']>;
+
+    interface TestCase {
+      name: string;
+      key: SetParams[0];
+      value: SetParams[1];
+      expectedDirPath: string;
+      expectedFilePath: string;
+      expectedContent: string;
+    }
+
+    const testCases: TestCase[] = [
+      {
+        name: 'stores string value',
+        key: 'test-key',
+        value: 'test-value',
+        expectedDirPath: './tmp/cache/test-key',
+        expectedFilePath: './tmp/cache/test-key/2024-01-01T00:00:00.000Z.json',
+        expectedContent: '"test-value"',
+      },
+      {
+        name: 'stores object value',
+        key: 'test-key',
+        value: { test: 'value' },
+        expectedDirPath: './tmp/cache/test-key',
+        expectedFilePath: './tmp/cache/test-key/2024-01-01T00:00:00.000Z.json',
+        expectedContent: '{"test":"value"}',
+      },
+      {
+        name: 'stores array value',
+        key: 'test-key',
+        value: [1, 2, 3],
+        expectedDirPath: './tmp/cache/test-key',
+        expectedFilePath: './tmp/cache/test-key/2024-01-01T00:00:00.000Z.json',
+        expectedContent: '[1,2,3]',
+      },
+    ];
+
+    test.each(testCases)(
+      '$name',
+      async ({
+        key,
+        value,
+        expectedDirPath,
+        expectedFilePath,
+        expectedContent,
+      }) => {
+        await repository.set(key, value);
+
+        expect(localStorageRepository.mkdir).toHaveBeenCalledWith(
+          expectedDirPath,
+        );
+        expect(localStorageRepository.write).toHaveBeenCalledWith(
+          expectedFilePath,
+          expectedContent,
+        );
+      },
+    );
+  });
+});