github-issue-tower-defence-management 1.146.0 → 1.146.2

package/src/domain/entities/RequiredProjectField.ts

@@ -0,0 +1,64 @@
+import { FieldOption } from './Project';
+
+export type RequiredProjectFieldDataType = 'DATE' | 'TEXT' | 'SINGLE_SELECT';
+
+export type RequiredProjectFieldDefinition = {
+  name: string;
+  dataType: RequiredProjectFieldDataType;
+  options: Omit<FieldOption, 'id'>[];
+};
+
+const storyOption = (
+  name: string,
+  color: FieldOption['color'],
+): Omit<FieldOption, 'id'> => ({ name, color, description: '' });
+
+const REQUIRED_STORY_OPTIONS: Omit<FieldOption, 'id'>[] = [
+  storyOption('regular / NO STORY', 'RED'),
+  storyOption('regular / WORKFLOW BLOCKER', 'RED'),
+  storyOption('regular / high priority', 'RED'),
+  storyOption('regular / workflow management', 'YELLOW'),
+  storyOption('regular / routine management', 'YELLOW'),
+  storyOption('regular / middle bug', 'GRAY'),
+  storyOption('regular / minor bug', 'GRAY'),
+  storyOption('regular / refactor', 'GRAY'),
+  storyOption('regular / backlog', 'GRAY'),
+];
+
+const REQUIRED_NEXT_ACTION_HOUR_OPTIONS: Omit<FieldOption, 'id'>[] = Array.from(
+  { length: 23 },
+  (_, index) => ({
+    name: `${index + 1}`,
+    color: 'GRAY' as const,
+    description: '',
+  }),
+);
+
+export const STORY_FIELD_NAME = 'Story';
+export const NEXT_ACTION_DATE_FIELD_NAME = 'Next Action Date';
+export const NEXT_ACTION_HOUR_FIELD_NAME = 'Next Action Hour';
+export const DEPENDED_ISSUE_URL_FIELD_NAME =
+  'Depended Issue URL separated by comma';
+
+export const REQUIRED_PROJECT_FIELDS: RequiredProjectFieldDefinition[] = [
+  {
+    name: STORY_FIELD_NAME,
+    dataType: 'SINGLE_SELECT',
+    options: REQUIRED_STORY_OPTIONS,
+  },
+  {
+    name: NEXT_ACTION_DATE_FIELD_NAME,
+    dataType: 'DATE',
+    options: [],
+  },
+  {
+    name: NEXT_ACTION_HOUR_FIELD_NAME,
+    dataType: 'SINGLE_SELECT',
+    options: REQUIRED_NEXT_ACTION_HOUR_OPTIONS,
+  },
+  {
+    name: DEPENDED_ISSUE_URL_FIELD_NAME,
+    dataType: 'TEXT',
+    options: [],
+  },
+];

package/src/domain/usecases/HandleScheduledEventUseCase.test.ts

@@ -24,6 +24,7 @@ import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCa
 import { StartPreparationUseCase } from './StartPreparationUseCase';
 import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUseCase';
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
+import { ProjectRequiredFieldCreateUseCase } from './ProjectRequiredFieldCreateUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
 import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
 import { DailySecurityScanUseCase } from './DailySecurityScanUseCase';
@@ -85,6 +86,8 @@ describe('HandleScheduledEventUseCase', () => {
   });
 
   describe('run', () => {
+    const mockProjectRequiredFieldCreateUseCase =
+      mock<ProjectRequiredFieldCreateUseCase>();
     const mockSetupTowerDefenceProjectUseCase =
       mock<SetupTowerDefenceProjectUseCase>();
     const mockActionAnnouncementUseCase = mock<ActionAnnouncementUseCase>();
@@ -128,6 +131,7 @@ describe('HandleScheduledEventUseCase', () => {
     const mockIssueRepository = mock<IssueRepository>();
 
     const useCase = new HandleScheduledEventUseCase(
+      mockProjectRequiredFieldCreateUseCase,
       mockSetupTowerDefenceProjectUseCase,
       mockActionAnnouncementUseCase,
       mockSetWorkflowManagementIssueToStoryUseCase,

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -29,6 +29,7 @@ import { RevertOrphanedPreparationUseCase } from './RevertOrphanedPreparationUse
 import { RevertNotReadyReviewQueueIssueUseCase } from './RevertNotReadyReviewQueueIssueUseCase';
 import { resolveLabelsAsLlmAgentName } from './resolveLabelsAsLlmAgentName';
 import { resolveAllowedIssueAuthors } from './resolveAllowedIssueAuthors';
+import { ProjectRequiredFieldCreateUseCase } from './ProjectRequiredFieldCreateUseCase';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
 import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
 import {
@@ -114,6 +115,7 @@ const isTransientSpreadsheetApiError = (error: Error): boolean => {
 
 export class HandleScheduledEventUseCase {
   constructor(
+    readonly projectRequiredFieldCreateUseCase: ProjectRequiredFieldCreateUseCase,
     readonly setupTowerDefenceProjectUseCase: SetupTowerDefenceProjectUseCase,
     readonly actionAnnouncementUseCase: ActionAnnouncementUseCase,
     readonly setWorkflowManagementIssueToStoryUseCase: SetWorkflowManagementIssueToStoryUseCase,
@@ -187,6 +189,9 @@ export class HandleScheduledEventUseCase {
     if (input.disabled) {
       return null;
     }
+    await this.projectRequiredFieldCreateUseCase.run({
+      projectUrl: input.projectUrl,
+    });
     await this.setupTowerDefenceProjectUseCase.run({
       projectUrl: input.projectUrl,
     });

package/src/domain/usecases/NotifySilentLiveSessionsUseCase.test.ts

@@ -755,18 +755,18 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     });
 
     it('parks a role-named leader session while its latest owner call is unanswered', async () => {
-      setupLiveInteractiveSession('uminopm');
+      setupLiveInteractiveSession('acmepm');
       mockSessionOutputActivityRepository.listSessionOutputActivities.mockResolvedValue(
         [
           {
-            sessionName: 'uminopm',
+            sessionName: 'acmepm',
             lastOutputEpochSeconds:
               nowEpochSeconds - DEFAULT_MAIN_SILENT_THRESHOLD_SECONDS,
           },
         ],
       );
       mockOwnerCallStatusProvider.listUnansweredOwnerCallEpochSecondsBySessionName.mockResolvedValue(
-        new Map([['uminopm', nowEpochSeconds - 60]]),
+        new Map([['acmepm', nowEpochSeconds - 60]]),
       );
 
       await useCase.run(runParams());

package/src/domain/usecases/ProjectRequiredFieldCreateUseCase.test.ts

@@ -0,0 +1,159 @@
+import { mock } from 'jest-mock-extended';
+import { Project } from '../entities/Project';
+import {
+  DEPENDED_ISSUE_URL_FIELD_NAME,
+  NEXT_ACTION_DATE_FIELD_NAME,
+  NEXT_ACTION_HOUR_FIELD_NAME,
+  STORY_FIELD_NAME,
+} from '../entities/RequiredProjectField';
+import { ProjectRequiredFieldCreateUseCase } from './ProjectRequiredFieldCreateUseCase';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+
+describe('ProjectRequiredFieldCreateUseCase', () => {
+  const projectUrl = 'https://github.com/orgs/meta-site/projects/18';
+  const project: Project = {
+    id: 'PVT_kwDOBjp5zs4BfQGn',
+    url: projectUrl,
+    databaseId: 18,
+    name: 'cmg',
+    status: {
+      name: 'Status',
+      fieldId: 'PVTSSF_status',
+      statuses: [],
+    },
+    nextActionDate: null,
+    nextActionHour: null,
+    story: null,
+    remainingEstimationMinutes: null,
+    dependedIssueUrlSeparatedByComma: null,
+    completionDate50PercentConfidence: null,
+  };
+
+  const createUseCase = (existingFieldNames: string[]) => {
+    const projectRepository =
+      mock<
+        Pick<ProjectRepository, 'getByUrl' | 'listFieldNames' | 'createField'>
+      >();
+    projectRepository.getByUrl.mockResolvedValue(project);
+    projectRepository.listFieldNames.mockResolvedValue(existingFieldNames);
+    projectRepository.createField.mockResolvedValue(undefined);
+    return {
+      projectRepository,
+      useCase: new ProjectRequiredFieldCreateUseCase(projectRepository),
+    };
+  };
+
+  it('should create every required field when the project has none of them', async () => {
+    const { projectRepository, useCase } = createUseCase([
+      'Title',
+      'Assignees',
+      'Status',
+    ]);
+
+    await useCase.run({ projectUrl });
+
+    const createdFieldNames = projectRepository.createField.mock.calls.map(
+      (call) => call[1].name,
+    );
+    expect(createdFieldNames).toEqual([
+      STORY_FIELD_NAME,
+      NEXT_ACTION_DATE_FIELD_NAME,
+      NEXT_ACTION_HOUR_FIELD_NAME,
+      DEPENDED_ISSUE_URL_FIELD_NAME,
+    ]);
+  });
+
+  it('should create nothing when the project already has every required field', async () => {
+    const { projectRepository, useCase } = createUseCase([
+      'Title',
+      'Status',
+      'story',
+      'nextactiondate',
+      'nextactionhour',
+      'Depended Issue URL separated by comma',
+    ]);
+
+    await useCase.run({ projectUrl });
+
+    expect(projectRepository.createField).not.toHaveBeenCalled();
+  });
+
+  it('should create only the missing fields', async () => {
+    const { projectRepository, useCase } = createUseCase([
+      'Title',
+      'Status',
+      'Story',
+      'Next Action Date',
+    ]);
+
+    await useCase.run({ projectUrl });
+
+    const createdFieldNames = projectRepository.createField.mock.calls.map(
+      (call) => call[1].name,
+    );
+    expect(createdFieldNames).toEqual([
+      NEXT_ACTION_HOUR_FIELD_NAME,
+      DEPENDED_ISSUE_URL_FIELD_NAME,
+    ]);
+  });
+
+  it('should create the story field with the standard story options', async () => {
+    const { projectRepository, useCase } = createUseCase(['Title', 'Status']);
+
+    await useCase.run({ projectUrl });
+
+    const storyCall = projectRepository.createField.mock.calls.find(
+      (call) => call[1].name === STORY_FIELD_NAME,
+    );
+    expect(storyCall?.[1].dataType).toBe('SINGLE_SELECT');
+    expect(storyCall?.[1].options.map((option) => option.name)).toEqual([
+      'regular / NO STORY',
+      'regular / WORKFLOW BLOCKER',
+      'regular / high priority',
+      'regular / workflow management',
+      'regular / routine management',
+      'regular / middle bug',
+      'regular / minor bug',
+      'regular / refactor',
+      'regular / backlog',
+    ]);
+  });
+
+  it('should create the next action hour field with the hour options from 1 to 23', async () => {
+    const { projectRepository, useCase } = createUseCase(['Title', 'Status']);
+
+    await useCase.run({ projectUrl });
+
+    const hourCall = projectRepository.createField.mock.calls.find(
+      (call) => call[1].name === NEXT_ACTION_HOUR_FIELD_NAME,
+    );
+    expect(hourCall?.[1].dataType).toBe('SINGLE_SELECT');
+    expect(hourCall?.[1].options.map((option) => option.name)).toEqual(
+      Array.from({ length: 23 }, (_, index) => `${index + 1}`),
+    );
+  });
+
+  it('should create the depended issue url field as a text field', async () => {
+    const { projectRepository, useCase } = createUseCase(['Title', 'Status']);
+
+    await useCase.run({ projectUrl });
+
+    const dependedCall = projectRepository.createField.mock.calls.find(
+      (call) => call[1].name === DEPENDED_ISSUE_URL_FIELD_NAME,
+    );
+    expect(dependedCall?.[1].dataType).toBe('TEXT');
+    expect(dependedCall?.[1].options).toEqual([]);
+  });
+
+  it('should create the next action date field as a date field', async () => {
+    const { projectRepository, useCase } = createUseCase(['Title', 'Status']);
+
+    await useCase.run({ projectUrl });
+
+    const dateCall = projectRepository.createField.mock.calls.find(
+      (call) => call[1].name === NEXT_ACTION_DATE_FIELD_NAME,
+    );
+    expect(dateCall?.[1].dataType).toBe('DATE');
+    expect(dateCall?.[1].options).toEqual([]);
+  });
+});

package/src/domain/usecases/ProjectRequiredFieldCreateUseCase.ts

@@ -0,0 +1,32 @@
+import { Project } from '../entities/Project';
+import { normalizeProjectFieldName } from '../entities/ProjectFieldName';
+import { REQUIRED_PROJECT_FIELDS } from '../entities/RequiredProjectField';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+
+export class ProjectRequiredFieldCreateUseCase {
+  constructor(
+    private readonly projectRepository: Pick<
+      ProjectRepository,
+      'getByUrl' | 'listFieldNames' | 'createField'
+    >,
+  ) {}
+
+  run = async (params: { projectUrl: string }): Promise<void> => {
+    const project = await this.projectRepository.getByUrl(params.projectUrl);
+    await this.createMissingFields(project);
+  };
+
+  private createMissingFields = async (project: Project): Promise<void> => {
+    const existingFieldNames = (
+      await this.projectRepository.listFieldNames(project)
+    ).map(normalizeProjectFieldName);
+    for (const required of REQUIRED_PROJECT_FIELDS) {
+      if (
+        existingFieldNames.includes(normalizeProjectFieldName(required.name))
+      ) {
+        continue;
+      }
+      await this.projectRepository.createField(project, required);
+    }
+  };
+}

package/src/domain/usecases/SetWorkflowManagementIssueToStoryUseCase.test.ts

@@ -381,9 +381,9 @@ describe('SetWorkflowManagementIssueToStoryUseCase', () => {
         nextActionDate: null,
         nextActionHour: null,
         isPr: false,
-        org: 'xcare-medical',
-        repo: 'xcare-platform',
-        url: 'https://github.com/xcare-medical/xcare-platform/issues/1445',
+        org: 'initech-medical',
+        repo: 'initech-platform',
+        url: 'https://github.com/initech-medical/initech-platform/issues/1445',
       };
       mockIssueRepository.searchIssue.mockResolvedValue([]);
 
@@ -401,8 +401,8 @@ describe('SetWorkflowManagementIssueToStoryUseCase', () => {
       expect(mockIssueRepository.searchIssue.mock.calls).toEqual([
         [
           {
-            owner: 'xcare-medical',
-            repositoryName: 'xcare-platform',
+            owner: 'initech-medical',
+            repositoryName: 'initech-platform',
             type: 'issue',
             state: 'open',
             title:
@@ -412,16 +412,16 @@ describe('SetWorkflowManagementIssueToStoryUseCase', () => {
       ]);
       expect(mockIssueRepository.createNewIssue).toHaveBeenCalledTimes(1);
       const createCall = mockIssueRepository.createNewIssue.mock.calls[0];
-      expect(createCall[0]).toEqual('xcare-medical');
-      expect(createCall[1]).toEqual('xcare-platform');
+      expect(createCall[0]).toEqual('initech-medical');
+      expect(createCall[1]).toEqual('initech-platform');
       expect(createCall[2]).toEqual(
         'TDPM: story label "story:routine-management" has no matching "regular / routine-management" Story option',
       );
       expect(createCall[3]).toContain(
-        'https://github.com/xcare-medical/xcare-platform/issues/1445',
+        'https://github.com/initech-medical/initech-platform/issues/1445',
       );
       expect(createCall[3]).toContain('story:routine-management');
-      expect(createCall[4]).toEqual(['xcare-medical']);
+      expect(createCall[4]).toEqual(['initech-medical']);
       expect(createCall[5]).toEqual([]);
     });
 
@@ -434,13 +434,13 @@ describe('SetWorkflowManagementIssueToStoryUseCase', () => {
         nextActionDate: null,
         nextActionHour: null,
         isPr: false,
-        org: 'xcare-medical',
-        repo: 'xcare-platform',
-        url: 'https://github.com/xcare-medical/xcare-platform/issues/1445',
+        org: 'initech-medical',
+        repo: 'initech-platform',
+        url: 'https://github.com/initech-medical/initech-platform/issues/1445',
       };
       mockIssueRepository.searchIssue.mockResolvedValue([
         {
-          url: 'https://github.com/xcare-medical/xcare-platform/issues/9999',
+          url: 'https://github.com/initech-medical/initech-platform/issues/9999',
           title:
             'TDPM: story label "story:routine-management" has no matching "regular / routine-management" Story option',
           number: '9999',
@@ -471,9 +471,9 @@ describe('SetWorkflowManagementIssueToStoryUseCase', () => {
         nextActionDate: null,
         nextActionHour: null,
         isPr: false,
-        org: 'xcare-medical',
-        repo: 'xcare-platform',
-        url: 'https://github.com/xcare-medical/xcare-platform/issues/1500',
+        org: 'initech-medical',
+        repo: 'initech-platform',
+        url: 'https://github.com/initech-medical/initech-platform/issues/1500',
       };
       mockIssueRepository.searchIssue.mockResolvedValue([]);
 
@@ -503,9 +503,9 @@ describe('SetWorkflowManagementIssueToStoryUseCase', () => {
         nextActionDate: null,
         nextActionHour: null,
         isPr: false,
-        org: 'xcare-medical',
-        repo: 'xcare-platform',
-        url: 'https://github.com/xcare-medical/xcare-platform/issues/1445',
+        org: 'initech-medical',
+        repo: 'initech-platform',
+        url: 'https://github.com/initech-medical/initech-platform/issues/1445',
       };
       const matchedIssue: Issue = {
         ...mock<Issue>(),

package/src/domain/usecases/SetupTowerDefenceProjectUseCase.test.ts

@@ -367,22 +367,31 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     expect(payload[1].color).toBe(REQUIRED_WORKFLOW_STATUSES[1].color);
   });
 
-  it('should rename legacy "Todo" to "Todo by human" by reusing the existing option ID', async () => {
+  it('should reuse the default template "Todo" option ID for Unread so a newly added item lands in Unread', async () => {
     const mockProjectRepository =
       mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
     const mockIssueRepository =
       mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
-    const statuses: FieldOption[] = REQUIRED_WORKFLOW_STATUSES.map(
-      (required, index) => ({
-        id: `id-${index}`,
-        name:
-          required.name === TODO_STATUS_NAME
-            ? LEGACY_TODO_STATUS_NAME
-            : required.name,
-        color: required.color,
+    const statuses: FieldOption[] = [
+      {
+        id: 'template-todo',
+        name: LEGACY_TODO_STATUS_NAME,
+        color: 'PINK',
         description: '',
-      }),
-    );
+      },
+      {
+        id: 'template-in-progress',
+        name: 'In progress',
+        color: 'YELLOW',
+        description: 'This is actively being worked on',
+      },
+      {
+        id: 'template-done',
+        name: DONE_STATUS_NAME,
+        color: 'PURPLE',
+        description: '',
+      },
+    ];
     const project = buildProject(statuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
     mockProjectRepository.updateStatusList.mockResolvedValue([]);
@@ -400,9 +409,10 @@ describe('SetupTowerDefenceProjectUseCase', () => {
 
     expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
     const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
-    const todoEntry = payload.find((s) => s.name === TODO_STATUS_NAME);
-    expect(todoEntry).toBeDefined();
-    expect(todoEntry?.id).toBe('id-5');
+    const unreadEntry = payload.find((s) => s.name === DEFAULT_STATUS_NAME);
+    expect(unreadEntry?.id).toBe('template-todo');
+    const todoByHumanEntry = payload.find((s) => s.name === TODO_STATUS_NAME);
+    expect(todoByHumanEntry?.id).toBeNull();
     expect(payload.some((s) => s.name === LEGACY_TODO_STATUS_NAME)).toBe(false);
   });
 

package/src/domain/usecases/SetupTowerDefenceProjectUseCase.ts

@@ -2,6 +2,7 @@ import { FieldOption } from '../entities/Project';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
 import { IssueRepository } from './adapter-interfaces/IssueRepository';
 import {
+  DEFAULT_STATUS_NAME,
   IN_TMUX_STATUS_NAME,
   LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
   LEGACY_IN_TMUX_STATUS_NAME,
@@ -27,6 +28,7 @@ export class SetupTowerDefenceProjectUseCase {
   private static readonly LEGACY_STATUS_NAMES: Readonly<
     Record<string, string>
   > = {
+    [DEFAULT_STATUS_NAME]: LEGACY_TODO_STATUS_NAME,
     [TODO_STATUS_NAME]: LEGACY_TODO_STATUS_NAME,
     [IN_TMUX_STATUS_NAME]: LEGACY_IN_TMUX_STATUS_NAME,
   };
@@ -84,6 +86,7 @@ export class SetupTowerDefenceProjectUseCase {
         !SetupTowerDefenceProjectUseCase.MIGRATED_FROM_NAMES.has(status.name),
     );
 
+    const reusedOptionIds = new Set<FieldOption['id']>();
     const newStatusList: (Omit<FieldOption, 'id'> & {
       id: FieldOption['id'] | null;
     })[] = [
@@ -93,8 +96,14 @@ export class SetupTowerDefenceProjectUseCase {
         const found =
           existing.find((status) => status.name === required.name) ??
           (legacyName !== undefined
-            ? existing.find((status) => status.name === legacyName)
+            ? existing.find(
+                (status) =>
+                  status.name === legacyName && !reusedOptionIds.has(status.id),
+              )
             : undefined);
+        if (found) {
+          reusedOptionIds.add(found.id);
+        }
         return {
           id: found ? found.id : null,
           name: required.name,

package/src/domain/usecases/adapter-interfaces/ProjectRepository.ts

@@ -1,6 +1,12 @@
 import { FieldOption, Project } from '../../entities/Project';
+import { RequiredProjectFieldDefinition } from '../../entities/RequiredProjectField';
 
 export interface ProjectRepository {
+  listFieldNames: (project: Project) => Promise<string[]>;
+  createField: (
+    project: Project,
+    field: RequiredProjectFieldDefinition,
+  ) => Promise<void>;
   findProjectIdByUrl: (projectUrl: string) => Promise<Project['id'] | null>;
   getProject: (projectId: Project['id']) => Promise<Project | null>;
   updateStoryList: (