github-issue-tower-defence-management 1.154.0 → 1.154.1

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

@@ -0,0 +1,296 @@
+const mockGet = jest.fn();
+const mockPostGithubGraphqlJson = jest.fn();
+
+jest.mock('ky', () => ({
+  default: {
+    get: mockGet,
+    post: jest.fn(),
+    put: jest.fn(),
+    patch: jest.fn(),
+    delete: jest.fn(),
+    extend: jest.fn(),
+    create: jest.fn(),
+    stop: jest.fn(),
+  },
+  __esModule: true,
+}));
+
+jest.mock('./githubGraphqlClient', () => ({
+  postGithubGraphqlJson: mockPostGithubGraphqlJson,
+}));
+
+import { GraphqlProjectRepository } from './GraphqlProjectRepository';
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+const mockJsonResponse = <T>(data: T) => ({
+  json: jest.fn().mockResolvedValue(data),
+});
+
+const projectId = 'PVT_kwHOAGJHa84AFWnr';
+const projectUrl = 'https://github.com/users/HiromiShikata/projects/48';
+
+const restProjectResponse = {
+  id: 1403371,
+  node_id: projectId,
+  title: 'UMINO',
+};
+
+const restFieldsResponse = [
+  {
+    id: 12940049,
+    node_id: 'PVTSSF_status',
+    name: 'Status',
+    options: [
+      {
+        id: 'f75ad846',
+        name: { html: 'Unread', raw: 'Unread' },
+        description: { html: '', raw: '' },
+        color: 'ORANGE',
+      },
+    ],
+  },
+];
+
+const graphqlProjectResponse = {
+  data: {
+    node: {
+      id: projectId,
+      databaseId: 1403371,
+      title: 'UMINO',
+      shortDescription: '',
+      public: true,
+      closed: false,
+      createdAt: '2022-08-27T01:26:40Z',
+      updatedAt: '2026-07-24T08:49:59Z',
+      number: 48,
+      url: projectUrl,
+      fields: {
+        nodes: [
+          {
+            id: 'PVTSSF_status',
+            databaseId: 12940049,
+            name: 'Status',
+            dataType: 'SINGLE_SELECT',
+            options: [
+              {
+                id: 'f75ad846',
+                name: 'Unread',
+                description: '',
+                color: 'ORANGE',
+              },
+            ],
+          },
+        ],
+      },
+    },
+  },
+};
+
+const buildProjectCache = () => {
+  const stored = new Map<string, unknown>();
+  return {
+    stored,
+    getLatest: jest.fn(async (key: string) => {
+      const value = stored.get(key);
+      if (typeof value !== 'object' || value === null) {
+        return null;
+      }
+      return { value, timestamp: new Date('2026-08-15T00:00:00Z') };
+    }),
+    set: jest.fn(async (key: string, value: unknown) => {
+      stored.set(key, value);
+    }),
+    getSingle: jest.fn(async () => null),
+    setSingle: jest.fn(async () => undefined),
+  };
+};
+
+describe('GraphqlProjectRepository project location', () => {
+  const localStorageRepository = new LocalStorageRepository();
+
+  beforeEach(() => {
+    mockGet.mockReset();
+    mockPostGithubGraphqlJson.mockReset();
+    mockGet.mockImplementation((url: string) =>
+      url.endsWith('/fields')
+        ? mockJsonResponse(restFieldsResponse)
+        : mockJsonResponse(restProjectResponse),
+    );
+  });
+
+  it('should read the project over REST and issue no GraphQL query when the location is already recorded', async () => {
+    const projectCache = buildProjectCache();
+    projectCache.stored.set(`projectLocation-${projectId}`, {
+      owner: 'HiromiShikata',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    const project = await repository.getProject(projectId);
+
+    expect(mockPostGithubGraphqlJson).not.toHaveBeenCalled();
+    expect(mockGet).toHaveBeenCalledWith(
+      'https://api.github.com/users/HiromiShikata/projectsV2/48',
+      expect.anything(),
+    );
+    expect(project?.id).toEqual(projectId);
+    expect(project?.status.statuses).toEqual([
+      { id: 'f75ad846', name: 'Unread', color: 'ORANGE', description: '' },
+    ]);
+  });
+
+  it('should record the location from the project url on the cold start read so the next read goes over REST', async () => {
+    const projectCache = buildProjectCache();
+    mockPostGithubGraphqlJson.mockResolvedValue(graphqlProjectResponse);
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    await repository.getProject(projectId);
+
+    expect(mockPostGithubGraphqlJson).toHaveBeenCalledTimes(1);
+    expect(projectCache.stored.get(`projectLocation-${projectId}`)).toEqual({
+      owner: 'HiromiShikata',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+
+    const second = await repository.getProject(projectId);
+
+    expect(mockPostGithubGraphqlJson).toHaveBeenCalledTimes(1);
+    expect(second?.id).toEqual(projectId);
+  });
+
+  it('should list the field names over REST from the project url without any GraphQL query', async () => {
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+    );
+
+    const names = await repository.listFieldNames({
+      id: projectId,
+      url: projectUrl,
+      databaseId: 1403371,
+      name: 'UMINO',
+      status: { name: 'Status', fieldId: 'PVTSSF_status', statuses: [] },
+      nextActionDate: null,
+      nextActionHour: null,
+      story: null,
+      remainingEstimationMinutes: null,
+      dependedIssueUrlSeparatedByComma: null,
+      completionDate50PercentConfidence: null,
+    });
+
+    expect(mockPostGithubGraphqlJson).not.toHaveBeenCalled();
+    expect(mockGet).toHaveBeenCalledWith(
+      'https://api.github.com/users/HiromiShikata/projectsV2/48/fields',
+      {
+        searchParams: { per_page: 100 },
+        headers: {
+          Authorization: 'token dummy-token',
+          Accept: 'application/vnd.github+json',
+        },
+      },
+    );
+    expect(names).toEqual(['Status']);
+  });
+
+  it('should warn and fall back to the GraphQL project query when the location cache read throws', async () => {
+    const projectCache = buildProjectCache();
+    projectCache.getLatest.mockRejectedValue(new Error('corrupted file'));
+    mockPostGithubGraphqlJson.mockResolvedValue(graphqlProjectResponse);
+    const warn = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    const project = await repository.getProject(projectId);
+
+    expect(project?.id).toEqual(projectId);
+    expect(mockPostGithubGraphqlJson).toHaveBeenCalledTimes(1);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'reading the project location disk cache failed, falling back to the GraphQL project query',
+      ),
+    );
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('corrupted file'),
+    );
+    warn.mockRestore();
+  });
+
+  it('should warn and still return the project when the location cache write throws', async () => {
+    const projectCache = buildProjectCache();
+    projectCache.set.mockRejectedValue(new Error('disk full'));
+    mockPostGithubGraphqlJson.mockResolvedValue(graphqlProjectResponse);
+    const warn = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    const project = await repository.getProject(projectId);
+
+    expect(project?.id).toEqual(projectId);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'writing the project location disk cache failed, every later process will fall back to the GraphQL project query',
+      ),
+    );
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('disk full'));
+    warn.mockRestore();
+  });
+
+  it('should discard a recorded location that no longer resolves and re-read the project over GraphQL', async () => {
+    const projectCache = buildProjectCache();
+    projectCache.stored.set(`projectLocation-${projectId}`, {
+      owner: 'RenamedAway',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+    mockGet.mockImplementation(() => {
+      throw Object.assign(new Error('Not Found'), {
+        response: { status: 404 },
+      });
+    });
+    mockPostGithubGraphqlJson.mockResolvedValue(graphqlProjectResponse);
+    const warn = jest
+      .spyOn(console, 'warn')
+      .mockImplementation(() => undefined);
+    const repository = new GraphqlProjectRepository(
+      localStorageRepository,
+      'dummy-token',
+      projectCache,
+    );
+
+    const project = await repository.getProject(projectId);
+
+    expect(project?.id).toEqual(projectId);
+    expect(mockPostGithubGraphqlJson).toHaveBeenCalledTimes(1);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'the recorded project location no longer resolves over REST, re-reading the project over GraphQL',
+      ),
+    );
+    expect(projectCache.stored.get(`projectLocation-${projectId}`)).toEqual({
+      owner: 'HiromiShikata',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+    warn.mockRestore();
+  });
+});

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

@@ -0,0 +1,277 @@
+const mockGet = jest.fn();
+
+jest.mock('ky', () => ({
+  default: {
+    get: mockGet,
+    post: jest.fn(),
+    put: jest.fn(),
+    patch: jest.fn(),
+    delete: jest.fn(),
+    extend: jest.fn(),
+    create: jest.fn(),
+    stop: jest.fn(),
+  },
+  __esModule: true,
+}));
+
+import {
+  RestProjectRepository,
+  projectLocationFromUrl,
+  projectUrlFromLocation,
+} from './RestProjectRepository';
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+const mockJsonResponse = <T>(data: T) => ({
+  json: jest.fn().mockResolvedValue(data),
+});
+
+const projectResponse = {
+  id: 1403371,
+  node_id: 'PVT_kwHOAGJHa84AFWnr',
+  title: 'UMINO',
+};
+
+const fieldsResponse = [
+  {
+    id: 12940049,
+    node_id: 'PVTSSF_status',
+    name: 'Status',
+    options: [
+      {
+        id: 'f75ad846',
+        name: { html: 'Unread', raw: 'Unread' },
+        description: { html: '', raw: '' },
+        color: 'ORANGE',
+      },
+      {
+        id: 'e9931e57',
+        name: { html: 'Todo by human', raw: 'Todo by human' },
+        description: { html: 'own queue', raw: 'own queue' },
+        color: 'PINK',
+      },
+    ],
+  },
+  {
+    id: 133939017,
+    node_id: 'PVTSSF_story',
+    name: 'story',
+    options: [
+      {
+        id: '6dc26727',
+        name: {
+          html: 'regular / workflow management',
+          raw: 'regular / workflow management',
+        },
+        description: { html: '', raw: '' },
+        color: 'BLUE',
+      },
+    ],
+  },
+  {
+    id: 35978365,
+    node_id: 'PVTF_nextactiondate',
+    name: 'nextactiondate',
+  },
+];
+
+describe('RestProjectRepository', () => {
+  const localStorageRepository = new LocalStorageRepository();
+  const repository = new RestProjectRepository(
+    localStorageRepository,
+    'dummy-token',
+  );
+  const location = {
+    owner: 'HiromiShikata',
+    ownerType: 'users' as const,
+    projectNumber: 48,
+  };
+
+  afterEach(() => {
+    mockGet.mockReset();
+  });
+
+  describe('listFieldDefinitions', () => {
+    it('should read the fields from the projects REST endpoint and convert the option colors', async () => {
+      mockGet.mockReturnValueOnce(mockJsonResponse(fieldsResponse));
+
+      const fields = await repository.listFieldDefinitions(location);
+
+      expect(mockGet).toHaveBeenCalledTimes(1);
+      expect(mockGet).toHaveBeenCalledWith(
+        'https://api.github.com/users/HiromiShikata/projectsV2/48/fields',
+        {
+          searchParams: { per_page: 100 },
+          headers: {
+            Authorization: 'token dummy-token',
+            Accept: 'application/vnd.github+json',
+          },
+        },
+      );
+      expect(fields).toEqual([
+        {
+          fieldId: 'PVTSSF_status',
+          databaseId: 12940049,
+          name: 'Status',
+          options: [
+            {
+              id: 'f75ad846',
+              name: 'Unread',
+              color: 'ORANGE',
+              description: '',
+            },
+            {
+              id: 'e9931e57',
+              name: 'Todo by human',
+              color: 'PINK',
+              description: 'own queue',
+            },
+          ],
+        },
+        {
+          fieldId: 'PVTSSF_story',
+          databaseId: 133939017,
+          name: 'story',
+          options: [
+            {
+              id: '6dc26727',
+              name: 'regular / workflow management',
+              color: 'BLUE',
+              description: '',
+            },
+          ],
+        },
+        {
+          fieldId: 'PVTF_nextactiondate',
+          databaseId: 35978365,
+          name: 'nextactiondate',
+          options: [],
+        },
+      ]);
+    });
+
+    it('should address the organization route for an organization owned project', async () => {
+      mockGet.mockReturnValueOnce(mockJsonResponse([]));
+
+      await repository.listFieldDefinitions({
+        owner: 'X-Mile',
+        ownerType: 'orgs',
+        projectNumber: 7,
+      });
+
+      expect(mockGet).toHaveBeenCalledWith(
+        'https://api.github.com/orgs/X-Mile/projectsV2/7/fields',
+        expect.anything(),
+      );
+    });
+  });
+
+  describe('listFieldNames', () => {
+    it('should return every field name including the ones the project entity does not keep', async () => {
+      mockGet.mockReturnValueOnce(mockJsonResponse(fieldsResponse));
+
+      const names = await repository.listFieldNames(location);
+
+      expect(names).toEqual(['Status', 'story', 'nextactiondate']);
+    });
+  });
+
+  describe('getProject', () => {
+    it('should build the project from the REST project and field responses', async () => {
+      mockGet.mockImplementation((url: string) =>
+        url.endsWith('/fields')
+          ? mockJsonResponse(fieldsResponse)
+          : mockJsonResponse(projectResponse),
+      );
+
+      const project = await repository.getProject(location);
+
+      expect(project?.id).toEqual('PVT_kwHOAGJHa84AFWnr');
+      expect(project?.databaseId).toEqual(1403371);
+      expect(project?.name).toEqual('UMINO');
+      expect(project?.url).toEqual(
+        'https://github.com/users/HiromiShikata/projects/48',
+      );
+      expect(project?.status.fieldId).toEqual('PVTSSF_status');
+      expect(project?.status.statuses.map((status) => status.name)).toEqual([
+        'Unread',
+        'Todo by human',
+      ]);
+      expect(project?.story?.workflowManagementStory).toEqual({
+        id: '6dc26727',
+        name: 'regular / workflow management',
+        color: 'BLUE',
+        description: '',
+      });
+      expect(project?.nextActionDate).toEqual({
+        name: 'nextactiondate',
+        fieldId: 'PVTF_nextactiondate',
+      });
+    });
+
+    it('should return null when the project no longer exists at that owner and number', async () => {
+      mockGet.mockImplementation(() => {
+        throw Object.assign(new Error('Not Found'), {
+          response: { status: 404 },
+        });
+      });
+
+      expect(await repository.getProject(location)).toBeNull();
+    });
+
+    it('should rethrow a failure that is not a not found response', async () => {
+      mockGet.mockImplementation(() => {
+        throw Object.assign(new Error('Bad Gateway'), {
+          response: { status: 502 },
+        });
+      });
+
+      await expect(repository.getProject(location)).rejects.toThrow(
+        'Bad Gateway',
+      );
+    });
+  });
+});
+
+describe('projectLocationFromUrl', () => {
+  it('should read the owner and the number from a user owned project url', () => {
+    expect(
+      projectLocationFromUrl(
+        'https://github.com/users/HiromiShikata/projects/48',
+      ),
+    ).toEqual({
+      owner: 'HiromiShikata',
+      ownerType: 'users',
+      projectNumber: 48,
+    });
+  });
+
+  it('should read the owner and the number from an organization owned project url', () => {
+    expect(
+      projectLocationFromUrl('https://github.com/orgs/X-Mile/projects/7'),
+    ).toEqual({
+      owner: 'X-Mile',
+      ownerType: 'orgs',
+      projectNumber: 7,
+    });
+  });
+
+  it('should return null for a url that is not a project url', () => {
+    expect(
+      projectLocationFromUrl(
+        'https://github.com/HiromiShikata/secretary/issues/1',
+      ),
+    ).toBeNull();
+  });
+});
+
+describe('projectUrlFromLocation', () => {
+  it('should rebuild the project url the GraphQL API returns', () => {
+    expect(
+      projectUrlFromLocation({
+        owner: 'HiromiShikata',
+        ownerType: 'users',
+        projectNumber: 48,
+      }),
+    ).toEqual('https://github.com/users/HiromiShikata/projects/48');
+  });
+});

package/src/adapter/repositories/RestProjectRepository.ts

@@ -0,0 +1,129 @@
+import ky from 'ky';
+import { BaseGitHubRepository } from './BaseGitHubRepository';
+import {
+  ProjectDefinition,
+  ProjectFieldDefinition,
+  convertToFieldOptionColor,
+  projectFromDefinition,
+} from './projectFieldDefinition';
+import { Project } from '../../domain/entities/Project';
+
+export type ProjectLocation = {
+  owner: string;
+  ownerType: 'users' | 'orgs';
+  projectNumber: number;
+};
+
+type RestProjectResponse = {
+  id: number;
+  node_id: string;
+  title: string;
+};
+
+type RestProjectFieldResponse = {
+  id: number;
+  node_id: string;
+  name: string;
+  options?: {
+    id: string;
+    name: { raw: string };
+    description: { raw: string };
+    color: string;
+  }[];
+};
+
+const isNotFoundResponse = (error: unknown): boolean => {
+  if (typeof error !== 'object' || error === null || !('response' in error)) {
+    return false;
+  }
+  const response = error.response;
+  return (
+    typeof response === 'object' &&
+    response !== null &&
+    'status' in response &&
+    response.status === 404
+  );
+};
+
+export const projectUrlFromLocation = (location: ProjectLocation): string =>
+  `https://github.com/${location.ownerType}/${location.owner}/projects/${location.projectNumber}`;
+
+export const projectLocationFromUrl = (
+  projectUrl: string,
+): ProjectLocation | null => {
+  const match = projectUrl.match(
+    /https:\/\/github\.com\/(users|orgs)\/([^/]+)\/projects\/(\d+)/,
+  );
+  if (!match) {
+    return null;
+  }
+  const [, ownerType, owner, projectNumberText] = match;
+  return {
+    owner,
+    ownerType: ownerType === 'orgs' ? 'orgs' : 'users',
+    projectNumber: parseInt(projectNumberText, 10),
+  };
+};
+
+export class RestProjectRepository extends BaseGitHubRepository {
+  private projectApiUrl = (location: ProjectLocation): string =>
+    `https://api.github.com/${location.ownerType}/${location.owner}/projectsV2/${location.projectNumber}`;
+
+  private requestHeaders = (): Record<string, string> => ({
+    Authorization: `token ${this.ghToken}`,
+    Accept: 'application/vnd.github+json',
+  });
+
+  listFieldDefinitions = async (
+    location: ProjectLocation,
+  ): Promise<ProjectFieldDefinition[]> => {
+    const fields = await ky
+      .get(`${this.projectApiUrl(location)}/fields`, {
+        searchParams: { per_page: 100 },
+        headers: this.requestHeaders(),
+      })
+      .json<RestProjectFieldResponse[]>();
+    return fields.map((field) => ({
+      fieldId: field.node_id,
+      databaseId: field.id,
+      name: field.name,
+      options: (field.options ?? []).map((option) => ({
+        id: option.id,
+        name: option.name.raw,
+        color: convertToFieldOptionColor(option.color),
+        description: option.description.raw,
+      })),
+    }));
+  };
+
+  listFieldNames = async (location: ProjectLocation): Promise<string[]> => {
+    const fields = await this.listFieldDefinitions(location);
+    return fields.map((field) => field.name);
+  };
+
+  getProject = async (location: ProjectLocation): Promise<Project | null> => {
+    let project: RestProjectResponse;
+    let fields: ProjectFieldDefinition[];
+    try {
+      [project, fields] = await Promise.all([
+        ky
+          .get(this.projectApiUrl(location), { headers: this.requestHeaders() })
+          .json<RestProjectResponse>(),
+        this.listFieldDefinitions(location),
+      ]);
+    } catch (error) {
+      if (isNotFoundResponse(error)) {
+        return null;
+      }
+      throw error;
+    }
+    const definition: ProjectDefinition = {
+      id: project.node_id,
+      url: projectUrlFromLocation(location),
+      databaseId: project.id,
+      name: project.title,
+      fields,
+    };
+    return projectFromDefinition(definition);
+  };
+}