github-issue-tower-defence-management 2.19.1 → 2.19.2

package/src/domain/usecases/ClearDependedIssueURLUseCase.ts

@@ -1,161 +0,0 @@
-import { Issue } from '../entities/Issue';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { Project } from '../entities/Project';
-import { ICEBOX_STATUS_NAME } from '../entities/WorkflowStatus';
-
-export class ClearDependedIssueURLUseCase {
-  constructor(
-    readonly issueRepository: Pick<
-      IssueRepository,
-      'clearProjectField' | 'createComment' | 'updateProjectTextField'
-    >,
-  ) {}
-
-  run = async (input: {
-    project: Project;
-    issues: Issue[];
-    cacheUsed: boolean;
-  }): Promise<void> => {
-    const dependedIssueUrlSeparatedByComma =
-      input.project.dependedIssueUrlSeparatedByComma;
-    if (!dependedIssueUrlSeparatedByComma) {
-      return;
-    }
-    const absentDependedIssueIsResolvable = !input.cacheUsed;
-    for (const issue of input.issues) {
-      if (issue.dependedIssueUrls.length <= 0 || issue.isClosed) {
-        continue;
-      }
-      const circularDependedIssueUrls = absentDependedIssueIsResolvable
-        ? this.findCircularDependedIssueUrls(issue, input.issues)
-        : [];
-      if (circularDependedIssueUrls.length > 0) {
-        await this.issueRepository.clearProjectField(
-          input.project,
-          dependedIssueUrlSeparatedByComma.fieldId,
-          issue,
-        );
-        await this.issueRepository.createComment(
-          issue,
-          `Circular dependency removed:
-${circularDependedIssueUrls.map((url) => `- ${url}`).join('\n')}`,
-        );
-        continue;
-      }
-      const notFoundDependedIssueUrls = absentDependedIssueIsResolvable
-        ? issue.dependedIssueUrls.filter(
-            (dependedIssueUrl) =>
-              !input.issues.some(
-                (depIssue) => depIssue.url === dependedIssueUrl,
-              ),
-          )
-        : [];
-      const iceboxDependedIssueUrls = issue.dependedIssueUrls.filter(
-        (dependedIssueUrl) =>
-          input.issues.some(
-            (depIssue) =>
-              depIssue.url === dependedIssueUrl &&
-              !depIssue.isClosed &&
-              depIssue.status === ICEBOX_STATUS_NAME,
-          ),
-      );
-      const openDependedIssueUrls = issue.dependedIssueUrls.filter(
-        (dependedIssueUrl) =>
-          input.issues.some(
-            (depIssue) =>
-              depIssue.url === dependedIssueUrl &&
-              !depIssue.isClosed &&
-              depIssue.status !== ICEBOX_STATUS_NAME,
-          ),
-      );
-      const closedDependedIssueUrls = issue.dependedIssueUrls.filter(
-        (dependedIssueUrl) =>
-          input.issues.some(
-            (depIssue) =>
-              depIssue.url === dependedIssueUrl && depIssue.isClosed,
-          ),
-      );
-      if (
-        notFoundDependedIssueUrls.length === 0 &&
-        closedDependedIssueUrls.length === 0 &&
-        iceboxDependedIssueUrls.length === 0
-      ) {
-        continue;
-      }
-      const remainingDependedIssueUrls = absentDependedIssueIsResolvable
-        ? openDependedIssueUrls
-        : issue.dependedIssueUrls.filter(
-            (dependedIssueUrl) =>
-              !closedDependedIssueUrls.includes(dependedIssueUrl) &&
-              !iceboxDependedIssueUrls.includes(dependedIssueUrl),
-          );
-      if (remainingDependedIssueUrls.length === 0) {
-        await this.issueRepository.clearProjectField(
-          input.project,
-          dependedIssueUrlSeparatedByComma.fieldId,
-          issue,
-        );
-      } else {
-        await this.issueRepository.updateProjectTextField(
-          input.project,
-          dependedIssueUrlSeparatedByComma.fieldId,
-          issue,
-          remainingDependedIssueUrls.join(','),
-        );
-      }
-      if (closedDependedIssueUrls.length > 0) {
-        const allCleared =
-          remainingDependedIssueUrls.length === 0 &&
-          notFoundDependedIssueUrls.length === 0 &&
-          iceboxDependedIssueUrls.length === 0;
-        await this.issueRepository.createComment(
-          issue,
-          `${allCleared ? 'All depended issues are already closed, dependency field cleared' : 'Some depended issues are already closed, removed from dependency field'}:
-${closedDependedIssueUrls.map((url) => `- ${url}`).join('\n')}`,
-        );
-      }
-      if (notFoundDependedIssueUrls.length > 0) {
-        await this.issueRepository.createComment(
-          issue,
-          `Dependency removed:
-${notFoundDependedIssueUrls.map((url) => `- ${url}`).join('\n')}`,
-        );
-      }
-      if (iceboxDependedIssueUrls.length > 0) {
-        const iceboxAllCleared =
-          remainingDependedIssueUrls.length === 0 &&
-          closedDependedIssueUrls.length === 0 &&
-          notFoundDependedIssueUrls.length === 0;
-        await this.issueRepository.createComment(
-          issue,
-          `${iceboxAllCleared ? 'All depended issues are in Icebox, dependency field cleared' : 'Some depended issues are in Icebox, removed from dependency field'}:\n${iceboxDependedIssueUrls.map((url) => `- ${url}`).join('\n')}`,
-        );
-      }
-    }
-  };
-
-  private findCircularDependedIssueUrls = (
-    issue: Issue,
-    issues: Issue[],
-  ): string[] =>
-    issue.dependedIssueUrls.filter((dependedIssueUrl) => {
-      const reachableIssueUrls = new Set<string>();
-      const stack = [dependedIssueUrl];
-      while (stack.length > 0) {
-        const url = stack.pop();
-        if (!url) {
-          throw new Error('url is undefined');
-        }
-        if (reachableIssueUrls.has(url)) {
-          continue;
-        }
-        reachableIssueUrls.add(url);
-        const dependedIssue = issues.find((candidate) => candidate.url === url);
-        if (!dependedIssue) {
-          continue;
-        }
-        stack.push(...dependedIssue.dependedIssueUrls);
-      }
-      return reachableIssueUrls.has(issue.url);
-    });
-}

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

@@ -1,345 +0,0 @@
-import { mock } from 'jest-mock-extended';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { ClearPastNextActionDateHourUseCase } from './ClearPastNextActionDateHourUseCase';
-import { Project } from '../entities/Project';
-import { Issue } from '../entities/Issue';
-
-describe('ClearPastNextActionDateHourUseCase', () => {
-  jest.setTimeout(60 * 1000);
-  const mockIssueRepository = mock<IssueRepository>();
-
-  const nextActionHourField = {
-    name: 'Next Action Hour',
-    fieldId: 'hourFieldId',
-    options: [],
-  };
-  const nextActionDateField = {
-    name: 'Next Action Date',
-    fieldId: 'dateFieldId',
-  };
-
-  const basicProject = {
-    ...mock<Project>(),
-    nextActionHour: nextActionHourField,
-    nextActionDate: nextActionDateField,
-  };
-
-  const openIssueWithHour = {
-    ...mock<Issue>(),
-    state: 'OPEN' as const,
-    nextActionHour: 10,
-    nextActionDate: null,
-  };
-
-  const openIssueWithDateOnly = {
-    ...mock<Issue>(),
-    state: 'OPEN' as const,
-    nextActionHour: null,
-    nextActionDate: new Date('2026-04-01T00:00:00'),
-  };
-
-  describe('run', () => {
-    beforeEach(() => {
-      jest.clearAllMocks();
-    });
-
-    const testCases: {
-      name: string;
-      input: {
-        targetDates: Date[];
-        project: Project;
-        issues: Issue[];
-        cacheUsed: boolean;
-      };
-      expectedClearProjectFieldCalls: [Project, string, Issue][];
-    }[] = [
-      {
-        name: 'should not clear anything when targetDates is empty',
-        input: {
-          targetDates: [],
-          project: basicProject,
-          issues: [openIssueWithDateOnly],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [],
-      },
-      {
-        name: 'should not clear anything when project has no nextActionDate and no nextActionHour',
-        input: {
-          targetDates: [new Date('2026-04-02T10:00:00')],
-          project: {
-            ...basicProject,
-            nextActionHour: null,
-            nextActionDate: null,
-          },
-          issues: [openIssueWithDateOnly],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [],
-      },
-      {
-        name: 'should clear nextActionDate for issue with only nextActionDate set and date is before today',
-        input: {
-          targetDates: [new Date('2026-04-02T10:00:00')],
-          project: {
-            ...basicProject,
-            nextActionHour: null,
-            nextActionDate: nextActionDateField,
-          },
-          issues: [
-            {
-              ...openIssueWithDateOnly,
-              nextActionDate: new Date('2026-04-01T00:00:00'),
-            },
-          ],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [
-          [
-            {
-              ...basicProject,
-              nextActionHour: null,
-              nextActionDate: nextActionDateField,
-            },
-            'dateFieldId',
-            {
-              ...openIssueWithDateOnly,
-              nextActionDate: new Date('2026-04-01T00:00:00'),
-            },
-          ],
-        ],
-      },
-      {
-        name: 'should clear nextActionDate when date is today',
-        input: {
-          targetDates: [new Date('2026-04-02T10:00:00')],
-          project: {
-            ...basicProject,
-            nextActionHour: null,
-            nextActionDate: nextActionDateField,
-          },
-          issues: [
-            {
-              ...openIssueWithDateOnly,
-              nextActionDate: new Date('2026-04-02T00:00:00'),
-            },
-          ],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [
-          [
-            {
-              ...basicProject,
-              nextActionHour: null,
-              nextActionDate: nextActionDateField,
-            },
-            'dateFieldId',
-            {
-              ...openIssueWithDateOnly,
-              nextActionDate: new Date('2026-04-02T00:00:00'),
-            },
-          ],
-        ],
-      },
-      {
-        name: 'should not clear nextActionDate when date is in the future',
-        input: {
-          targetDates: [new Date('2026-04-02T10:00:00')],
-          project: {
-            ...basicProject,
-            nextActionHour: null,
-            nextActionDate: nextActionDateField,
-          },
-          issues: [
-            {
-              ...openIssueWithDateOnly,
-              nextActionDate: new Date('2026-04-03T00:00:00'),
-            },
-          ],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [],
-      },
-      {
-        name: 'should not clear nextActionDate when issue has nextActionHour set (handled by hour path)',
-        input: {
-          targetDates: [new Date('2026-04-02T10:00:00')],
-          project: {
-            ...basicProject,
-            nextActionHour: null,
-            nextActionDate: nextActionDateField,
-          },
-          issues: [
-            {
-              ...mock<Issue>(),
-              state: 'OPEN' as const,
-              nextActionHour: 9,
-              nextActionDate: new Date('2026-04-01T00:00:00'),
-            },
-          ],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [],
-      },
-      {
-        name: 'should not clear nextActionDate when issue state is not OPEN',
-        input: {
-          targetDates: [new Date('2026-04-02T10:00:00')],
-          project: {
-            ...basicProject,
-            nextActionHour: null,
-            nextActionDate: nextActionDateField,
-          },
-          issues: [
-            {
-              ...openIssueWithDateOnly,
-              state: 'CLOSED' as const,
-              nextActionDate: new Date('2026-04-01T00:00:00'),
-            },
-          ],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [],
-      },
-      {
-        name: 'should not clear nextActionHour at 09:45 when scheduled hour 10 has not yet arrived',
-        input: {
-          targetDates: [
-            new Date('2026-04-02T09:45:00'),
-            new Date('2026-04-02T09:46:00'),
-          ],
-          project: basicProject,
-          issues: [
-            {
-              ...openIssueWithHour,
-              nextActionHour: 10,
-              nextActionDate: null,
-            },
-          ],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [],
-      },
-      {
-        name: 'should clear nextActionHour when sweep has no minute-45 tick but scheduled hour has already passed',
-        input: {
-          targetDates: [
-            new Date('2026-04-02T10:05:00'),
-            new Date('2026-04-02T10:15:00'),
-          ],
-          project: basicProject,
-          issues: [
-            {
-              ...openIssueWithHour,
-              nextActionHour: 10,
-              nextActionDate: null,
-            },
-          ],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [
-          [
-            basicProject,
-            'hourFieldId',
-            {
-              ...openIssueWithHour,
-              nextActionHour: 10,
-              nextActionDate: null,
-            },
-          ],
-          [
-            basicProject,
-            'dateFieldId',
-            {
-              ...openIssueWithHour,
-              nextActionHour: 10,
-              nextActionDate: null,
-            },
-          ],
-        ],
-      },
-      {
-        name: 'should not clear nextActionHour when scheduled hour has not yet arrived',
-        input: {
-          targetDates: [
-            new Date('2026-04-02T09:00:00'),
-            new Date('2026-04-02T09:01:00'),
-          ],
-          project: basicProject,
-          issues: [
-            {
-              ...openIssueWithHour,
-              nextActionHour: 10,
-              nextActionDate: null,
-            },
-          ],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [],
-      },
-      {
-        name: 'should clear both nextActionDate-only issues and nextActionHour issues in same run',
-        input: {
-          targetDates: [
-            new Date('2026-04-02T09:45:00'),
-            new Date('2026-04-02T09:46:00'),
-          ],
-          project: basicProject,
-          issues: [
-            {
-              ...openIssueWithHour,
-              nextActionHour: 9,
-              nextActionDate: null,
-            },
-            {
-              ...openIssueWithDateOnly,
-              nextActionDate: new Date('2026-04-01T00:00:00'),
-            },
-          ],
-          cacheUsed: false,
-        },
-        expectedClearProjectFieldCalls: [
-          [
-            basicProject,
-            'hourFieldId',
-            {
-              ...openIssueWithHour,
-              nextActionHour: 9,
-              nextActionDate: null,
-            },
-          ],
-          [
-            basicProject,
-            'dateFieldId',
-            {
-              ...openIssueWithHour,
-              nextActionHour: 9,
-              nextActionDate: null,
-            },
-          ],
-          [
-            basicProject,
-            'dateFieldId',
-            {
-              ...openIssueWithDateOnly,
-              nextActionDate: new Date('2026-04-01T00:00:00'),
-            },
-          ],
-        ],
-      },
-    ];
-
-    testCases.forEach(({ name, input, expectedClearProjectFieldCalls }) => {
-      it(name, async () => {
-        jest.clearAllMocks();
-        const useCase = new ClearPastNextActionDateHourUseCase(
-          mockIssueRepository,
-        );
-        await useCase.run(input);
-        expect(mockIssueRepository.clearProjectField.mock.calls).toEqual(
-          expectedClearProjectFieldCalls,
-        );
-      });
-    });
-  });
-});

package/src/domain/usecases/ClearPastNextActionDateHourUseCase.ts

@@ -1,81 +0,0 @@
-import { Issue } from '../entities/Issue';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { Project } from '../entities/Project';
-import { issueReactivationTriggerStartOfTomorrow } from './issueReactivationTriggerIsPending';
-
-export class ClearPastNextActionDateHourUseCase {
-  constructor(
-    readonly issueRepository: Pick<IssueRepository, 'clearProjectField'>,
-  ) {}
-
-  run = async (input: {
-    targetDates: Date[];
-    project: Project;
-    issues: Issue[];
-    cacheUsed: boolean;
-  }): Promise<void> => {
-    if (input.targetDates.length === 0) {
-      return;
-    }
-    const now = input.targetDates[input.targetDates.length - 1];
-
-    const nextActionHourField = input.project.nextActionHour;
-    if (nextActionHourField) {
-      const nextActionDateField = input.project.nextActionDate;
-      for (const issue of input.issues) {
-        if (issue.nextActionHour === null || issue.state !== 'OPEN') {
-          continue;
-        }
-        const scheduledDate = issue.nextActionDate ?? now;
-        const scheduledTime = new Date(
-          Date.UTC(
-            scheduledDate.getUTCFullYear(),
-            scheduledDate.getUTCMonth(),
-            scheduledDate.getUTCDate(),
-            issue.nextActionHour,
-          ),
-        );
-        if (scheduledTime.getTime() > now.getTime()) {
-          continue;
-        }
-        await this.issueRepository.clearProjectField(
-          input.project,
-          nextActionHourField.fieldId,
-          issue,
-        );
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-        if (!nextActionDateField) {
-          continue;
-        }
-        await this.issueRepository.clearProjectField(
-          input.project,
-          nextActionDateField.fieldId,
-          issue,
-        );
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-      }
-    }
-
-    const nextActionDate = input.project.nextActionDate;
-    if (!nextActionDate) {
-      return;
-    }
-    const startOfTomorrow = issueReactivationTriggerStartOfTomorrow(now);
-    for (const issue of input.issues) {
-      if (
-        issue.nextActionHour !== null ||
-        (issue.nextActionDate?.getTime() ?? Infinity) >=
-          startOfTomorrow.getTime() ||
-        issue.state !== 'OPEN'
-      ) {
-        continue;
-      }
-      await this.issueRepository.clearProjectField(
-        input.project,
-        nextActionDate.fieldId,
-        issue,
-      );
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-    }
-  };
-}