github-issue-tower-defence-management 1.184.1 → 1.185.0

package/src/adapter/entry-points/console/consoleOperationApi.test.ts

@@ -1,13 +1,19 @@
 import * as fs from 'fs';
+import { mock } from 'jest-mock-extended';
 import * as os from 'os';
 import * as path from 'path';
-import { mock } from 'jest-mock-extended';
-import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
-import { Project } from '../../../domain/entities/Project';
-import { Issue } from '../../../domain/entities/Issue';
+import type { Issue } from '../../../domain/entities/Issue';
+import type { Project } from '../../../domain/entities/Project';
+import type { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
 import {
-  ConsoleOperationContext,
-  ConsoleProjectBinding,
+  CONSOLE_DONE_STATUS_SELECTED_TAB_NAMES,
+  CONSOLE_DONE_STORY_SELECTED_TAB_NAMES,
+  CONSOLE_DONE_TAB_NAMES,
+  readDoneProjectItemIds,
+} from './consoleDoneStore';
+import {
+  type ConsoleOperationContext,
+  type ConsoleProjectBinding,
   handleAttachmentUpload,
   handleComment,
   handleCreateIssue,
@@ -15,14 +21,9 @@ import {
   handleReorderStory,
   handleReview,
   handleReviewComment,
+  handleStoryAdd,
   handleTriage,
 } from './consoleOperationApi';
-import {
-  CONSOLE_DONE_TAB_NAMES,
-  readDoneProjectItemIds,
-  CONSOLE_DONE_STATUS_SELECTED_TAB_NAMES,
-  CONSOLE_DONE_STORY_SELECTED_TAB_NAMES,
-} from './consoleDoneStore';
 
 describe('consoleOperationApi', () => {
   let baseDir: string;
@@ -112,6 +113,8 @@ describe('consoleOperationApi', () => {
       consoleDataOutputDir: baseDir,
       issueAttachmentRepository: null,
       updateStoryList: null,
+      resolveProjectRepository: null,
+      invalidateProject: null,
     };
   });
 
@@ -125,6 +128,8 @@ describe('consoleOperationApi', () => {
     consoleDataOutputDir: baseDir,
     issueAttachmentRepository: null,
     updateStoryList: null,
+    resolveProjectRepository: null,
+    invalidateProject: null,
   });
 
   afterEach(() => {
@@ -868,6 +873,8 @@ describe('consoleOperationApi', () => {
         consoleDataOutputDir: baseDir,
         issueAttachmentRepository: null,
         updateStoryList: null,
+        resolveProjectRepository: null,
+        invalidateProject: null,
       };
     });
 
@@ -1114,6 +1121,8 @@ describe('consoleOperationApi', () => {
         consoleDataOutputDir: baseDir,
         issueAttachmentRepository: null,
         updateStoryList: null,
+        resolveProjectRepository: null,
+        invalidateProject: null,
       };
       const response = await handleTriage(multiContext, {
         pjcode: 'globex',
@@ -1907,4 +1916,225 @@ describe('consoleOperationApi', () => {
       );
     });
   });
+
+  describe('handleStoryAdd', () => {
+    const buildProjectWithStories = (): Project => ({
+      ...project,
+      url: 'https://github.com/orgs/acme-labs/projects/1',
+      story: {
+        name: 'Story',
+        fieldId: 'storyField',
+        databaseId: 1,
+        stories: [
+          {
+            id: 'opt_first',
+            name: 'First story',
+            color: 'BLUE',
+            description: '',
+          },
+          {
+            id: 'opt_second',
+            name: 'Second story',
+            color: 'GREEN',
+            description: '',
+          },
+        ],
+        workflowManagementStory: { id: 'wms', name: 'workflow' },
+      },
+    });
+
+    const updateStoryList = jest.fn();
+    const projectRepositoryResolver = jest.fn(() => ({ updateStoryList }));
+
+    const addStoryContext = (p: Project): ConsoleOperationContext => ({
+      ...contextForProject(p),
+      resolveProjectRepository: projectRepositoryResolver,
+    });
+
+    beforeEach(() => {
+      updateStoryList.mockResolvedValue([]);
+      projectRepositoryResolver.mockReturnValue({ updateStoryList });
+    });
+
+    it('inserts the new story at index 1 and calls updateStoryList', async () => {
+      const p = buildProjectWithStories();
+      const response = await handleStoryAdd(addStoryContext(p), {
+        pjcode: 'acme',
+        storyName: 'Brand new story',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual({ ok: true });
+      expect(updateStoryList).toHaveBeenCalledWith(p, [
+        {
+          id: 'opt_first',
+          name: 'First story',
+          color: 'BLUE',
+          description: '',
+        },
+        { id: null, name: 'Brand new story', color: 'RED', description: '' },
+        {
+          id: 'opt_second',
+          name: 'Second story',
+          color: 'GREEN',
+          description: '',
+        },
+      ]);
+    });
+
+    it('inserts the new story as the only entry when the story list is empty', async () => {
+      const emptyStoryProject: Project = {
+        ...buildProjectWithStories(),
+        story: {
+          name: 'Story',
+          fieldId: 'storyField',
+          databaseId: 1,
+          stories: [],
+          workflowManagementStory: { id: 'wms', name: 'workflow' },
+        },
+      };
+      const response = await handleStoryAdd(
+        addStoryContext(emptyStoryProject),
+        {
+          pjcode: 'acme',
+          storyName: 'First ever story',
+        },
+      );
+      expect(response.statusCode).toBe(200);
+      expect(updateStoryList).toHaveBeenCalledWith(emptyStoryProject, [
+        { id: null, name: 'First ever story', color: 'RED', description: '' },
+      ]);
+    });
+
+    it('resolves the project repository using the project url', async () => {
+      const p = buildProjectWithStories();
+      await handleStoryAdd(addStoryContext(p), {
+        pjcode: 'acme',
+        storyName: 'Any story',
+      });
+      expect(projectRepositoryResolver).toHaveBeenCalledWith(p.url);
+    });
+
+    it('returns 502 when resolveProjectRepository is null', async () => {
+      const response = await handleStoryAdd(
+        {
+          ...contextForProject(buildProjectWithStories()),
+          resolveProjectRepository: null,
+        },
+        { pjcode: 'acme', storyName: 'Any story' },
+      );
+      expect(response).toEqual({
+        statusCode: 502,
+        body: { error: 'project repository is not configured' },
+      });
+    });
+
+    it('rejects when storyName is missing', async () => {
+      const response = await handleStoryAdd(
+        addStoryContext(buildProjectWithStories()),
+        {
+          pjcode: 'acme',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'storyName is required' },
+      });
+    });
+
+    it('rejects when pjcode is not configured', async () => {
+      const response = await handleStoryAdd(
+        addStoryContext(buildProjectWithStories()),
+        {
+          pjcode: 'unknown',
+          storyName: 'Any story',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'no project configured for pjcode "unknown"' },
+      });
+    });
+
+    it('rejects when the project has no story field', async () => {
+      const projectWithoutStory: Project = {
+        ...buildProjectWithStories(),
+        story: null,
+      };
+      const response = await handleStoryAdd(
+        addStoryContext(projectWithoutStory),
+        {
+          pjcode: 'acme',
+          storyName: 'Any story',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'project does not have a story field' },
+      });
+    });
+
+    it('invalidates the project cache after each successful add so consecutive adds both survive', async () => {
+      const p = buildProjectWithStories();
+      const pStory = p.story;
+      if (pStory === null) {
+        throw new Error('buildProjectWithStories must return a non-null story');
+      }
+
+      const projectAfterFirstAdd: Project = {
+        ...p,
+        story: {
+          ...pStory,
+          stories: [
+            pStory.stories[0],
+            { id: 'opt_x', name: 'Story X', color: 'RED', description: '' },
+            ...pStory.stories.slice(1),
+          ],
+        },
+      };
+
+      let invalidateCalled = false;
+      const invalidateProject = jest.fn((_pjcode: string) => {
+        invalidateCalled = true;
+      });
+
+      const resolveProject = jest.fn(async (pjcode: string) => {
+        if (pjcode !== 'acme') return null;
+        return { pjcode, project: invalidateCalled ? projectAfterFirstAdd : p };
+      });
+
+      const consecutiveUpdateStoryList = jest.fn().mockResolvedValue([]);
+      const consecutiveContext: ConsoleOperationContext = {
+        resolveIssueRepository: () => issueRepository,
+        resolveProject,
+        isPjcodeConfigured: (pjcode: string) => pjcode === 'acme',
+        consoleDataOutputDir: baseDir,
+        issueAttachmentRepository: null,
+        updateStoryList: null,
+        resolveProjectRepository: jest.fn(() => ({
+          updateStoryList: consecutiveUpdateStoryList,
+        })),
+        invalidateProject,
+      };
+
+      await handleStoryAdd(consecutiveContext, {
+        pjcode: 'acme',
+        storyName: 'Story X',
+      });
+      await handleStoryAdd(consecutiveContext, {
+        pjcode: 'acme',
+        storyName: 'Story Y',
+      });
+
+      expect(invalidateProject).toHaveBeenCalledTimes(2);
+      expect(invalidateProject).toHaveBeenCalledWith('acme');
+      expect(consecutiveUpdateStoryList).toHaveBeenNthCalledWith(
+        2,
+        expect.anything(),
+        expect.arrayContaining([
+          expect.objectContaining({ name: 'Story X' }),
+          expect.objectContaining({ name: 'Story Y' }),
+        ]),
+      );
+    });
+  });
 });

package/src/adapter/entry-points/console/consoleOperationApi.ts

@@ -1,15 +1,20 @@
+import type { Issue } from '../../../domain/entities/Issue';
 import {
+  buildStoryListWithNew,
+  type FieldOption,
+  type Project,
+} from '../../../domain/entities/Project';
+import type { IssueAttachmentRepository } from '../../../domain/usecases/adapter-interfaces/IssueAttachmentRepository';
+import type {
   IssueRepository,
   PullRequestReviewCommentSide,
 } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
-import { IssueAttachmentRepository } from '../../../domain/usecases/adapter-interfaces/IssueAttachmentRepository';
-import { FieldOption, Project } from '../../../domain/entities/Project';
-import { Issue } from '../../../domain/entities/Issue';
+import type { ProjectRepository } from '../../../domain/usecases/adapter-interfaces/ProjectRepository';
 import {
-  recordDoneProjectItemIdAcrossTabs,
-  recordDoneProjectItemIdForTabs,
   CONSOLE_DONE_STATUS_SELECTED_TAB_NAMES,
   CONSOLE_DONE_STORY_SELECTED_TAB_NAMES,
+  recordDoneProjectItemIdAcrossTabs,
+  recordDoneProjectItemIdForTabs,
 } from './consoleDoneStore';
 import { findConsoleItemUrl } from './consoleItemUrlLookup';
 
@@ -32,6 +37,10 @@ export type ConsoleIssueRepositoryResolver = (
   issueOrPullRequestUrl: string,
 ) => IssueRepository;
 
+export type ConsoleProjectRepositoryResolver = (
+  projectUrl: string,
+) => Pick<ProjectRepository, 'updateStoryList'>;
+
 export type ConsoleOperationContext = {
   resolveIssueRepository: ConsoleIssueRepositoryResolver;
   resolveProject: ConsoleProjectResolver;
@@ -41,6 +50,8 @@ export type ConsoleOperationContext = {
   updateStoryList:
     | ((project: Project, stories: FieldOption[]) => Promise<FieldOption[]>)
     | null;
+  resolveProjectRepository: ConsoleProjectRepositoryResolver | null;
+  invalidateProject: ((pjcode: string) => void) | null;
 };
 
 export type ConsoleOperationResponse = {
@@ -193,8 +204,7 @@ const resolveBinding = async (
 
 const isOperationResponse = (
   value: ConsoleProjectBinding | ConsoleOperationResponse,
-): value is ConsoleOperationResponse =>
-  Object.prototype.hasOwnProperty.call(value, 'statusCode');
+): value is ConsoleOperationResponse => Object.hasOwn(value, 'statusCode');
 
 // Validates that a pjcode is configured WITHOUT loading the ProjectV2 via
 // GraphQL. Close operations only need the pjcode (for recordDone namespacing)
@@ -769,3 +779,29 @@ export const handleReorderStory = async (
   await context.updateStoryList(project, reordered);
   return ok();
 };
+
+export const handleStoryAdd = async (
+  context: ConsoleOperationContext,
+  body: Record<string, unknown>,
+): Promise<ConsoleOperationResponse> => {
+  if (context.resolveProjectRepository === null) {
+    return badGateway('project repository is not configured');
+  }
+  const storyName = body.storyName;
+  if (!isNonEmptyString(storyName)) {
+    return badRequest('storyName is required');
+  }
+  const binding = await resolveBinding(context, body);
+  if (isOperationResponse(binding)) {
+    return binding;
+  }
+  const { pjcode, project } = binding;
+  if (project.story === null) {
+    return badRequest('project does not have a story field');
+  }
+  const newStoryList = buildStoryListWithNew(project.story.stories, storyName);
+  const projectRepository = context.resolveProjectRepository(project.url);
+  await projectRepository.updateStoryList(project, newStoryList);
+  context.invalidateProject?.(pjcode);
+  return ok();
+};

package/src/adapter/entry-points/console/consoleProjectResolver.test.ts

@@ -61,18 +61,18 @@ describe('createConsoleProjectResolver', () => {
     const loadProject = jest.fn(async (url: string) =>
       url.includes('acme') ? acmeProject : globexProject,
     );
-    const resolver = createConsoleProjectResolver(
+    const { resolve } = createConsoleProjectResolver(
       {
         acme: 'https://github.com/orgs/acme/projects/1',
         globex: 'https://github.com/orgs/globex/projects/2',
       },
       loadProject,
     );
-    await expect(resolver('acme')).resolves.toEqual({
+    await expect(resolve('acme')).resolves.toEqual({
       pjcode: 'acme',
       project: acmeProject,
     });
-    await expect(resolver('globex')).resolves.toEqual({
+    await expect(resolve('globex')).resolves.toEqual({
       pjcode: 'globex',
       project: globexProject,
     });
@@ -80,33 +80,53 @@ describe('createConsoleProjectResolver', () => {
 
   it('returns null for a pjcode that has no configured project url', async () => {
     const loadProject = jest.fn(async () => acmeProject);
-    const resolver = createConsoleProjectResolver(
+    const { resolve } = createConsoleProjectResolver(
       { acme: 'https://github.com/orgs/acme/projects/1' },
       loadProject,
     );
-    await expect(resolver('unknown')).resolves.toBeNull();
+    await expect(resolve('unknown')).resolves.toBeNull();
     expect(loadProject).not.toHaveBeenCalled();
   });
 
   it('returns null when the project fails to load', async () => {
     const loadProject = jest.fn(async () => null);
-    const resolver = createConsoleProjectResolver(
+    const { resolve } = createConsoleProjectResolver(
       { acme: 'https://github.com/orgs/acme/projects/1' },
       loadProject,
     );
-    await expect(resolver('acme')).resolves.toBeNull();
+    await expect(resolve('acme')).resolves.toBeNull();
   });
 
   it('loads each project at most once and serves later calls from cache', async () => {
     const loadProject = jest.fn(async () => acmeProject);
-    const resolver = createConsoleProjectResolver(
+    const { resolve } = createConsoleProjectResolver(
       { acme: 'https://github.com/orgs/acme/projects/1' },
       loadProject,
     );
-    await resolver('acme');
-    await resolver('acme');
+    await resolve('acme');
+    await resolve('acme');
     expect(loadProject).toHaveBeenCalledTimes(1);
   });
+
+  it('re-fetches the project after invalidation', async () => {
+    const freshProject: Project = { ...mock<Project>(), id: 'PVT_fresh' };
+    let callCount = 0;
+    const loadProject = jest.fn(async () =>
+      callCount++ === 0 ? acmeProject : freshProject,
+    );
+    const { resolve, invalidate } = createConsoleProjectResolver(
+      { acme: 'https://github.com/orgs/acme/projects/1' },
+      loadProject,
+    );
+    await expect(resolve('acme')).resolves.toMatchObject({
+      project: acmeProject,
+    });
+    invalidate('acme');
+    await expect(resolve('acme')).resolves.toMatchObject({
+      project: freshProject,
+    });
+    expect(loadProject).toHaveBeenCalledTimes(2);
+  });
 });
 
 describe('createConsoleProjectLoader', () => {

package/src/adapter/entry-points/console/consoleProjectResolver.ts

@@ -68,12 +68,19 @@ export const createPjcodeConfigChecker = (
     Object.prototype.hasOwnProperty.call(pjcodeToProjectUrl, pjcode);
 };
 
+export type ConsoleProjectResolverBundle = {
+  resolve: ConsoleProjectResolver;
+  invalidate: (pjcode: string) => void;
+};
+
 export const createConsoleProjectResolver = (
   pjcodeToProjectUrl: Record<string, string>,
   loadProject: ConsoleProjectLoader,
-): ConsoleProjectResolver => {
+): ConsoleProjectResolverBundle => {
   const cache = new Map<string, ConsoleProjectBinding>();
-  return async (pjcode: string): Promise<ConsoleProjectBinding | null> => {
+  const resolve: ConsoleProjectResolver = async (
+    pjcode: string,
+  ): Promise<ConsoleProjectBinding | null> => {
     const cached = cache.get(pjcode);
     if (cached !== undefined) {
       return cached;
@@ -90,4 +97,8 @@ export const createConsoleProjectResolver = (
     cache.set(pjcode, binding);
     return binding;
   };
+  const invalidate = (pjcode: string): void => {
+    cache.delete(pjcode);
+  };
+  return { resolve, invalidate };
 };

package/src/adapter/entry-points/console/ui/e2e/consoleScenario.spec.ts

@@ -459,10 +459,10 @@ test('creates an issue for a story when the add-task button and form are used',
   await tdpmRow.locator('.console-op-button', { hasText: 'Add task' }).click();
 
   await page
-    .locator('.console-story-create-input')
+    .locator('.console-inline-input-form-input')
     .fill('New task for TDPM Console port');
   await page
-    .locator('.console-story-create-form .console-op-button', {
+    .locator('.console-inline-input-form .console-op-button', {
       hasText: 'Create',
     })
     .click();
@@ -479,6 +479,41 @@ test('creates an issue for a story when the add-task button and form are used',
   );
 });
 
+test('creates a new story when the add-story button and form are used', async ({
+  page,
+}) => {
+  await page.goto(harness.appRootUrl);
+
+  await tabByLabel(page, 'Stories').click();
+
+  await page
+    .locator('.console-add-story-section .console-op-button', {
+      hasText: 'Add story',
+    })
+    .click();
+
+  await page
+    .locator('.console-add-story-section .console-inline-input-form-input')
+    .fill('My new story');
+  await page
+    .locator(
+      '.console-add-story-section .console-inline-input-form .console-op-button',
+      {
+        hasText: 'Create',
+      },
+    )
+    .click();
+
+  await expect
+    .poll(() => harness.addStoryCalls.length, { timeout: 10000 })
+    .toBe(1);
+  expect(harness.addStoryCalls[0].storyName).toBe('My new story');
+
+  await expect(
+    page.locator('.console-add-story-section .console-inline-input-form'),
+  ).toHaveCount(0);
+});
+
 test('reorders stories on the triage tab with up/down buttons', async ({
   page,
 }) => {

package/src/adapter/entry-points/console/ui/e2e/consoleTestHarness.ts

@@ -621,6 +621,10 @@ export type ConsoleE2eReorderStoryCall = {
   storyOptionIds: string[];
 };
 
+export type ConsoleE2eAddStoryCall = {
+  storyName: string;
+};
+
 export type ConsoleE2eHarness = {
   baseUrl: string;
   appUrl: string;
@@ -630,6 +634,7 @@ export type ConsoleE2eHarness = {
   requestChangesCalls: ConsoleE2eRequestChangesCall[];
   createIssueCalls: ConsoleE2eCreateIssueCall[];
   reorderStoryCalls: ConsoleE2eReorderStoryCall[];
+  addStoryCalls: ConsoleE2eAddStoryCall[];
   stop: () => Promise<void>;
 };
 
@@ -652,6 +657,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
   const requestChangesCalls: ConsoleE2eRequestChangesCall[] = [];
   const createIssueCalls: ConsoleE2eCreateIssueCall[] = [];
   const reorderStoryCalls: ConsoleE2eReorderStoryCall[] = [];
+  const addStoryCalls: ConsoleE2eAddStoryCall[] = [];
 
   const server = await startWebServer({
     accessToken: CONSOLE_E2E_TOKEN,
@@ -676,6 +682,19 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
         return result;
       },
     },
+    resolveProjectRepository: (_projectUrl) => ({
+      updateStoryList: async (_updatedProject, stories) => {
+        const newStory = stories.find((s) => s.id === null);
+        if (newStory !== undefined) {
+          addStoryCalls.push({ storyName: newStory.name });
+        }
+        const result = stories as FieldOption[];
+        if (project.story !== null) {
+          project.story.stories = result;
+        }
+        return result;
+      },
+    }),
     resolveProject,
     isPjcodeConfigured,
     issueTitleStateCache: new IssueTitleStateCache(),
@@ -706,6 +725,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
     requestChangesCalls,
     createIssueCalls,
     reorderStoryCalls,
+    addStoryCalls,
     stop: async (): Promise<void> => {
       await closeServer(server);
       fs.rmSync(tmpRoot, { recursive: true, force: true });

package/src/adapter/entry-points/console/ui/src/features/console/components/list/ConsoleStoryList.stories.tsx

@@ -50,7 +50,10 @@ const storiesWithUrl = storiesWithoutUrl.map((s) => ({
 const meta: Meta<typeof ConsoleStoryList> = {
   title: 'Console/ConsoleStoryList',
   component: ConsoleStoryList,
-  args: { onCreateIssue: () => Promise.resolve() },
+  args: {
+    onCreateIssue: () => Promise.resolve(),
+    onAddStory: () => Promise.resolve(),
+  },
 };
 
 export default meta;