github-issue-tower-defence-management 1.90.0 → 1.91.1

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleItemDetailData.ts

@@ -0,0 +1,167 @@
+import { useEffect, useState } from 'react';
+import type { ConsoleRelatedPullRequestView } from '../components/detail/ConsoleItemDetail';
+import type {
+  ConsoleChangedFile,
+  ConsoleComment,
+  ConsoleCommit,
+  ConsoleIssueState,
+  ConsoleListItem,
+  ConsoleRelatedPullRequest,
+} from '../logic/types';
+import type { ConsoleCaches } from './useConsoleCaches';
+import { useConsoleResource } from './useConsoleResource';
+
+const EMPTY_COMMENTS: ConsoleComment[] = [];
+const EMPTY_FILES: ConsoleChangedFile[] = [];
+const EMPTY_COMMITS: ConsoleCommit[] = [];
+const EMPTY_RELATED: ConsoleRelatedPullRequest[] = [];
+const DEFAULT_STATE: ConsoleIssueState = {
+  state: 'open',
+  merged: false,
+  isPullRequest: false,
+};
+
+export type ConsoleItemDetailData = {
+  state: ConsoleIssueState | null;
+  body: string;
+  bodyIsLoading: boolean;
+  bodyError: string | null;
+  comments: ConsoleComment[];
+  commentsAreLoading: boolean;
+  commentsError: string | null;
+  files: ConsoleChangedFile[];
+  filesAreLoading: boolean;
+  filesError: string | null;
+  commits: ConsoleCommit[];
+  commitsAreLoading: boolean;
+  commitsError: string | null;
+  relatedPullRequests: ConsoleRelatedPullRequestView[];
+};
+
+export const useConsoleItemDetailData = (
+  caches: ConsoleCaches,
+  item: ConsoleListItem | null,
+): ConsoleItemDetailData => {
+  const key = item !== null ? `${item.repo}#${item.number}` : null;
+  const url = item !== null ? item.url : null;
+  const isPr = item?.isPr ?? false;
+
+  const body = useConsoleResource(caches.body, key, url, '');
+  const state = useConsoleResource(caches.state, key, url, DEFAULT_STATE);
+  const comments = useConsoleResource(
+    caches.comments,
+    key,
+    url,
+    EMPTY_COMMENTS,
+  );
+  const files = useConsoleResource(
+    caches.files,
+    isPr ? key : null,
+    isPr ? url : null,
+    EMPTY_FILES,
+  );
+  const commits = useConsoleResource(
+    caches.commits,
+    isPr ? key : null,
+    isPr ? url : null,
+    EMPTY_COMMITS,
+  );
+  const relatedPrs = useConsoleResource(
+    caches.relatedPrs,
+    !isPr ? key : null,
+    !isPr ? url : null,
+    EMPTY_RELATED,
+  );
+
+  const [relatedViews, setRelatedViews] = useState<
+    ConsoleRelatedPullRequestView[]
+  >([]);
+
+  useEffect(() => {
+    if (isPr || relatedPrs.data.length === 0) {
+      setRelatedViews([]);
+      return;
+    }
+    let cancelled = false;
+    const initial: ConsoleRelatedPullRequestView[] = relatedPrs.data.map(
+      (pullRequest) => ({
+        pullRequest,
+        files: EMPTY_FILES,
+        filesAreLoading: true,
+        filesError: null,
+        commits: EMPTY_COMMITS,
+        commitsAreLoading: true,
+        commitsError: null,
+      }),
+    );
+    setRelatedViews(initial);
+
+    const updateView = (
+      prUrl: string,
+      patch: Partial<ConsoleRelatedPullRequestView>,
+    ): void => {
+      if (cancelled) {
+        return;
+      }
+      setRelatedViews((current) =>
+        current.map((view) =>
+          view.pullRequest.url === prUrl ? { ...view, ...patch } : view,
+        ),
+      );
+    };
+
+    for (const pullRequest of relatedPrs.data) {
+      const relatedKey = pullRequest.url;
+      caches.files
+        .load(relatedKey, pullRequest.url)
+        .then((value) =>
+          updateView(pullRequest.url, {
+            files: value,
+            filesAreLoading: false,
+          }),
+        )
+        .catch((cause: unknown) =>
+          updateView(pullRequest.url, {
+            filesAreLoading: false,
+            filesError: cause instanceof Error ? cause.message : String(cause),
+          }),
+        );
+      caches.commits
+        .load(relatedKey, pullRequest.url)
+        .then((value) =>
+          updateView(pullRequest.url, {
+            commits: value,
+            commitsAreLoading: false,
+          }),
+        )
+        .catch((cause: unknown) =>
+          updateView(pullRequest.url, {
+            commitsAreLoading: false,
+            commitsError:
+              cause instanceof Error ? cause.message : String(cause),
+          }),
+        );
+    }
+
+    return () => {
+      cancelled = true;
+    };
+  }, [caches, isPr, relatedPrs.data]);
+
+  return {
+    state: state.data,
+    body: body.data,
+    bodyIsLoading: body.isLoading,
+    bodyError: body.error,
+    comments: comments.data,
+    commentsAreLoading: comments.isLoading,
+    commentsError: comments.error,
+    files: files.data,
+    filesAreLoading: files.isLoading,
+    filesError: files.error,
+    commits: commits.data,
+    commitsAreLoading: commits.isLoading,
+    commitsError: commits.error,
+    relatedPullRequests: relatedViews,
+  };
+};

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleOperations.test.ts

@@ -0,0 +1,198 @@
+import { act, renderHook } from '@testing-library/react';
+import { overlayStorageKey } from '../logic/overlay';
+import {
+  consoleListItemsFixture,
+  consoleStatusOptionsFixture,
+} from '../testing/fixtures';
+import { useConsoleOperations } from './useConsoleOperations';
+import { useConsoleOverlay } from './useConsoleOverlay';
+
+const prItem = consoleListItemsFixture[0];
+const issueItem = consoleListItemsFixture[2];
+
+const captureFetch = (): jest.Mock => {
+  const fetchMock = jest.fn(async () => ({
+    ok: true,
+    status: 200,
+    json: async () => ({ ok: true }),
+  }));
+  global.fetch = fetchMock as unknown as typeof fetch;
+  return fetchMock;
+};
+
+const lastBody = (fetchMock: jest.Mock): Record<string, unknown> =>
+  JSON.parse((fetchMock.mock.calls.at(-1)?.[1] as { body: string }).body);
+
+const setup = () => {
+  localStorage.clear();
+  window.history.replaceState({}, '', '/projects/umino/prs?k=token');
+  return renderHook(() => {
+    const overlay = useConsoleOverlay('umino');
+    const operations = useConsoleOperations('umino', 'prs', overlay);
+    return { overlay, operations };
+  });
+};
+
+describe('useConsoleOperations', () => {
+  it('posts a totally wrong review as a close with the totally wrong comment body', async () => {
+    const fetchMock = captureFetch();
+    const { result } = setup();
+    await act(async () => {
+      await result.current.operations.reviewPullRequest(
+        prItem,
+        prItem.url,
+        'totally_wrong',
+      );
+    });
+    expect(fetchMock.mock.calls[0][0]).toBe('/api/review?k=token');
+    expect(lastBody(fetchMock)).toMatchObject({
+      pjcode: 'umino',
+      action: 'close',
+      prUrl: prItem.url,
+      commentBody: 'totally wrong',
+    });
+  });
+
+  it('posts an unnecessary review as a close with the unnecessary comment body', async () => {
+    const fetchMock = captureFetch();
+    const { result } = setup();
+    await act(async () => {
+      await result.current.operations.reviewPullRequest(
+        prItem,
+        prItem.url,
+        'unnecessary',
+      );
+    });
+    expect(lastBody(fetchMock)).toMatchObject({
+      action: 'close',
+      commentBody: 'This pull request is unnecessary.',
+    });
+  });
+
+  it('posts an approve review and marks the item done in the overlay', async () => {
+    captureFetch();
+    const { result } = setup();
+    await act(async () => {
+      await result.current.operations.reviewPullRequest(
+        prItem,
+        prItem.url,
+        'approve',
+      );
+    });
+    const stored = JSON.parse(
+      localStorage.getItem(overlayStorageKey('umino')) ?? '{}',
+    );
+    expect(stored[prItem.projectItemId].done).toBe(true);
+  });
+
+  it('posts a not-planned close through the triage endpoint', async () => {
+    const fetchMock = captureFetch();
+    const { result } = setup();
+    await act(async () => {
+      await result.current.operations.closeIssue(
+        issueItem,
+        'close_not_planned',
+      );
+    });
+    expect(fetchMock.mock.calls[0][0]).toBe('/api/triage?k=token');
+    expect(lastBody(fetchMock)).toMatchObject({
+      pjcode: 'umino',
+      action: 'close_not_planned',
+      issueUrl: issueItem.url,
+    });
+  });
+
+  it('posts set_status and records the overlay status', async () => {
+    const fetchMock = captureFetch();
+    const { result } = setup();
+    const option = consoleStatusOptionsFixture[1];
+    await act(async () => {
+      await result.current.operations.setStatus(issueItem, option);
+    });
+    expect(lastBody(fetchMock)).toMatchObject({
+      action: 'set_status',
+      statusName: option.name,
+    });
+    const stored = JSON.parse(
+      localStorage.getItem(overlayStorageKey('umino')) ?? '{}',
+    );
+    expect(stored[issueItem.projectItemId].status.name).toBe(option.name);
+  });
+
+  it('posts set_intmux through the intmux endpoint', async () => {
+    const fetchMock = captureFetch();
+    const { result } = setup();
+    const option = consoleStatusOptionsFixture[5];
+    await act(async () => {
+      await result.current.operations.setInTmuxByHuman(issueItem, option);
+    });
+    expect(fetchMock.mock.calls[0][0]).toBe('/api/intmux?k=token');
+    expect(lastBody(fetchMock)).toMatchObject({
+      pjcode: 'umino',
+      action: 'set_intmux',
+    });
+  });
+
+  it('does not mark done on snooze outside the todo-by-human tab', async () => {
+    captureFetch();
+    const { result } = setup();
+    await act(async () => {
+      await result.current.operations.setNextActionDate(
+        issueItem,
+        'snooze_1day',
+      );
+    });
+    const stored = JSON.parse(
+      localStorage.getItem(overlayStorageKey('umino')) ?? '{}',
+    );
+    expect(stored[issueItem.projectItemId]?.done).toBeUndefined();
+  });
+
+  it('marks done on snooze in the todo-by-human tab so the item is skipped', async () => {
+    captureFetch();
+    localStorage.clear();
+    window.history.replaceState(
+      {},
+      '',
+      '/projects/umino/todo-by-human?k=token',
+    );
+    const { result } = renderHook(() => {
+      const overlay = useConsoleOverlay('umino');
+      const operations = useConsoleOperations(
+        'umino',
+        'todo-by-human',
+        overlay,
+      );
+      return { overlay, operations };
+    });
+    await act(async () => {
+      await result.current.operations.setNextActionDate(
+        issueItem,
+        'snooze_1week',
+      );
+    });
+    const stored = JSON.parse(
+      localStorage.getItem(overlayStorageKey('umino')) ?? '{}',
+    );
+    expect(stored[issueItem.projectItemId].done).toBe(true);
+  });
+
+  it('rejects an operation and posts nothing when no pjcode is available', async () => {
+    const fetchMock = captureFetch();
+    localStorage.clear();
+    window.history.replaceState({}, '', '/?k=token');
+    const { result } = renderHook(() => {
+      const overlay = useConsoleOverlay('console');
+      const operations = useConsoleOperations(null, 'prs', overlay);
+      return { overlay, operations };
+    });
+    await expect(
+      result.current.operations.reviewPullRequest(
+        prItem,
+        prItem.url,
+        'approve',
+      ),
+    ).rejects.toThrow('No project specified in the URL path.');
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleOperations.ts

@@ -0,0 +1,243 @@
+import { useCallback } from 'react';
+import {
+  type ConsoleIntmuxRequest,
+  type ConsoleReviewRequest,
+  type ConsoleTriageRequest,
+  postConsoleOperation,
+} from '../lib/consoleApi';
+import {
+  type ConsoleCloseAction,
+  type ConsoleNextActionDateAction,
+  type ConsoleReviewAction,
+  TOTALLY_WRONG_COMMENT_BODY,
+  UNNECESSARY_COMMENT_BODY,
+} from '../logic/operations';
+import { overlayKeyForItem } from '../logic/overlay';
+import type {
+  ConsoleFieldOption,
+  ConsoleListItem,
+  ConsoleTabName,
+} from '../logic/types';
+import type { ConsoleOverlayState } from './useConsoleOverlay';
+import { useConsoleToken } from './useConsoleToken';
+
+export const REVIEW_OPERATION_PATH = '/api/review';
+export const TRIAGE_OPERATION_PATH = '/api/triage';
+export const INTMUX_OPERATION_PATH = '/api/intmux';
+
+export type ConsoleOperationsApi = {
+  reviewPullRequest: (
+    item: ConsoleListItem,
+    prUrl: string,
+    action: ConsoleReviewAction,
+  ) => Promise<void>;
+  setNextActionDate: (
+    item: ConsoleListItem,
+    action: ConsoleNextActionDateAction,
+  ) => Promise<void>;
+  setStory: (
+    item: ConsoleListItem,
+    option: ConsoleFieldOption,
+  ) => Promise<void>;
+  setStatus: (
+    item: ConsoleListItem,
+    option: ConsoleFieldOption,
+  ) => Promise<void>;
+  setInTmuxByHuman: (
+    item: ConsoleListItem,
+    option: ConsoleFieldOption,
+  ) => Promise<void>;
+  closeIssue: (
+    item: ConsoleListItem,
+    action: ConsoleCloseAction,
+  ) => Promise<void>;
+};
+
+const reviewRequest = (
+  pjcode: string,
+  item: ConsoleListItem,
+  prUrl: string,
+  action: ConsoleReviewAction,
+): ConsoleReviewRequest => {
+  if (action === 'approve') {
+    return {
+      pjcode,
+      action: 'approve',
+      prUrl,
+      projectItemId: item.projectItemId,
+    };
+  }
+  if (action === 'request_changes') {
+    return {
+      pjcode,
+      action: 'request_changes',
+      prUrl,
+      projectItemId: item.projectItemId,
+      commentBody: '',
+    };
+  }
+  if (action === 'totally_wrong') {
+    return {
+      pjcode,
+      action: 'close',
+      prUrl,
+      projectItemId: item.projectItemId,
+      commentBody: TOTALLY_WRONG_COMMENT_BODY,
+    };
+  }
+  return {
+    pjcode,
+    action: 'close',
+    prUrl,
+    projectItemId: item.projectItemId,
+    commentBody: UNNECESSARY_COMMENT_BODY,
+  };
+};
+
+const missingPjcodeError = (): Error =>
+  new Error('No project specified in the URL path.');
+
+export const useConsoleOperations = (
+  pjcode: string | null,
+  mode: ConsoleTabName,
+  overlayState: ConsoleOverlayState,
+): ConsoleOperationsApi => {
+  const { appendToken } = useConsoleToken();
+  const { patchOverlay } = overlayState;
+
+  const markDone = useCallback(
+    (item: ConsoleListItem) => {
+      patchOverlay(overlayKeyForItem(item), { done: true }, mode);
+    },
+    [patchOverlay, mode],
+  );
+
+  const reviewPullRequest = useCallback(
+    async (
+      item: ConsoleListItem,
+      prUrl: string,
+      action: ConsoleReviewAction,
+    ) => {
+      if (pjcode === null) {
+        throw missingPjcodeError();
+      }
+      await postConsoleOperation(
+        appendToken,
+        REVIEW_OPERATION_PATH,
+        reviewRequest(pjcode, item, prUrl, action),
+      );
+      markDone(item);
+    },
+    [pjcode, appendToken, markDone],
+  );
+
+  const setNextActionDate = useCallback(
+    async (item: ConsoleListItem, action: ConsoleNextActionDateAction) => {
+      if (pjcode === null) {
+        throw missingPjcodeError();
+      }
+      const request: ConsoleTriageRequest = {
+        pjcode,
+        action,
+        issueUrl: item.url,
+        projectItemId: item.projectItemId,
+      };
+      await postConsoleOperation(appendToken, TRIAGE_OPERATION_PATH, request);
+      if (mode === 'todo-by-human') {
+        markDone(item);
+      }
+    },
+    [pjcode, appendToken, markDone, mode],
+  );
+
+  const setStory = useCallback(
+    async (item: ConsoleListItem, option: ConsoleFieldOption) => {
+      if (pjcode === null) {
+        throw missingPjcodeError();
+      }
+      const request: ConsoleTriageRequest = {
+        pjcode,
+        action: 'set_story',
+        issueUrl: item.url,
+        projectItemId: item.projectItemId,
+        storyOptionId: option.id,
+      };
+      await postConsoleOperation(appendToken, TRIAGE_OPERATION_PATH, request);
+      patchOverlay(
+        overlayKeyForItem(item),
+        { done: true, story: { name: option.name, color: option.color } },
+        mode,
+      );
+    },
+    [pjcode, appendToken, patchOverlay, mode],
+  );
+
+  const setStatus = useCallback(
+    async (item: ConsoleListItem, option: ConsoleFieldOption) => {
+      if (pjcode === null) {
+        throw missingPjcodeError();
+      }
+      const request: ConsoleTriageRequest = {
+        pjcode,
+        action: 'set_status',
+        issueUrl: item.url,
+        projectItemId: item.projectItemId,
+        statusName: option.name,
+      };
+      await postConsoleOperation(appendToken, TRIAGE_OPERATION_PATH, request);
+      patchOverlay(
+        overlayKeyForItem(item),
+        { done: true, status: { name: option.name, color: option.color } },
+        mode,
+      );
+    },
+    [pjcode, appendToken, patchOverlay, mode],
+  );
+
+  const setInTmuxByHuman = useCallback(
+    async (item: ConsoleListItem, option: ConsoleFieldOption) => {
+      if (pjcode === null) {
+        throw missingPjcodeError();
+      }
+      const request: ConsoleIntmuxRequest = {
+        pjcode,
+        action: 'set_intmux',
+        issueUrl: item.url,
+        projectItemId: item.projectItemId,
+      };
+      await postConsoleOperation(appendToken, INTMUX_OPERATION_PATH, request);
+      patchOverlay(
+        overlayKeyForItem(item),
+        { done: true, status: { name: option.name, color: option.color } },
+        mode,
+      );
+    },
+    [pjcode, appendToken, patchOverlay, mode],
+  );
+
+  const closeIssue = useCallback(
+    async (item: ConsoleListItem, action: ConsoleCloseAction) => {
+      if (pjcode === null) {
+        throw missingPjcodeError();
+      }
+      const request: ConsoleTriageRequest = {
+        pjcode,
+        action,
+        issueUrl: item.url,
+        projectItemId: item.projectItemId,
+      };
+      await postConsoleOperation(appendToken, TRIAGE_OPERATION_PATH, request);
+      markDone(item);
+    },
+    [pjcode, appendToken, markDone],
+  );
+
+  return {
+    reviewPullRequest,
+    setNextActionDate,
+    setStory,
+    setStatus,
+    setInTmuxByHuman,
+    closeIssue,
+  };
+};

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleOverlay.test.ts

@@ -0,0 +1,40 @@
+import { act, renderHook } from '@testing-library/react';
+import { overlayStorageKey } from '../logic/overlay';
+import { useConsoleOverlay } from './useConsoleOverlay';
+
+describe('useConsoleOverlay', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('starts from the persisted overlay', () => {
+    localStorage.setItem(
+      overlayStorageKey('umino'),
+      JSON.stringify({ PVTI_1: { ts: 5, mode: 'prs', done: true } }),
+    );
+    const { result } = renderHook(() => useConsoleOverlay('umino'));
+    expect(result.current.overlay.PVTI_1?.done).toBe(true);
+  });
+
+  it('patches and persists overlay entries with timestamp and mode', () => {
+    const { result } = renderHook(() => useConsoleOverlay('umino'));
+    act(() => {
+      result.current.patchOverlay('PVTI_2', { done: true }, 'triage');
+    });
+    expect(result.current.overlay.PVTI_2?.done).toBe(true);
+    expect(result.current.overlay.PVTI_2?.mode).toBe('triage');
+    const stored = JSON.parse(
+      localStorage.getItem(overlayStorageKey('umino')) ?? '{}',
+    );
+    expect(stored.PVTI_2.done).toBe(true);
+  });
+
+  it('ignores malformed persisted entries', () => {
+    localStorage.setItem(
+      overlayStorageKey('umino'),
+      JSON.stringify({ bad: { no: 'ts' } }),
+    );
+    const { result } = renderHook(() => useConsoleOverlay('umino'));
+    expect(result.current.overlay.bad).toBeUndefined();
+  });
+});