github-issue-tower-defence-management 1.146.3 → 1.146.5

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

@@ -1,9 +1,55 @@
 import {
   createConsoleGithubTokenResolver,
   createConsoleIssueRepositoryResolver,
+  createConsoleProjectRepositoryResolver,
+  extractProjectOwner,
   extractRepositoryOwner,
 } from './consoleGithubTokenResolver';
 
+describe('extractProjectOwner', () => {
+  it('should return the organization login of an organization project url', () => {
+    expect(
+      extractProjectOwner('https://github.com/orgs/acme/projects/18'),
+    ).toBe('acme');
+  });
+
+  it('should return the user login of a user project url', () => {
+    expect(
+      extractProjectOwner('https://github.com/users/acme-owner/projects/48'),
+    ).toBe('acme-owner');
+  });
+
+  it('should return null for a url that is not a project url', () => {
+    expect(
+      extractProjectOwner('https://github.com/acme/acme-repository/issues/178'),
+    ).toBeNull();
+  });
+});
+
+describe('createConsoleProjectRepositoryResolver', () => {
+  it('builds the project repository from the token of the owner in the project url', () => {
+    const resolve = createConsoleProjectRepositoryResolver<string>(
+      (repositoryOwner) => `token-of-${repositoryOwner}`,
+      (githubToken) => `repository-with-${githubToken}`,
+    );
+
+    expect(resolve('https://github.com/orgs/acme/projects/18')).toBe(
+      'repository-with-token-of-acme',
+    );
+  });
+
+  it('throws when the project owner cannot be read from the project url', () => {
+    const resolve = createConsoleProjectRepositoryResolver<string>(
+      (repositoryOwner) => `token-of-${repositoryOwner}`,
+      (githubToken) => `repository-with-${githubToken}`,
+    );
+
+    expect(() => resolve('https://github.com/orgs/acme')).toThrow(
+      'The project owner cannot be read from the project url: https://github.com/orgs/acme',
+    );
+  });
+});
+
 describe('createConsoleIssueRepositoryResolver', () => {
   it('builds the issue repository from the token of the owner in the url', () => {
     const resolve = createConsoleIssueRepositoryResolver<string>(
@@ -12,8 +58,8 @@ describe('createConsoleIssueRepositoryResolver', () => {
     );
 
     expect(
-      resolve('https://github.com/meta-site/hr-audit-mock/issues/178'),
-    ).toBe('repository-with-token-of-meta-site');
+      resolve('https://github.com/acme-labs/acme-portal-mock/issues/178'),
+    ).toBe('repository-with-token-of-acme-labs');
   });
 
   it('throws when the repository owner cannot be read from the url', () => {
@@ -22,8 +68,10 @@ describe('createConsoleIssueRepositoryResolver', () => {
       (githubToken) => `repository-with-${githubToken}`,
     );
 
-    expect(() => resolve('https://github.com/meta-site/hr-audit-mock')).toThrow(
-      'The repository owner cannot be read from the operated url: https://github.com/meta-site/hr-audit-mock',
+    expect(() =>
+      resolve('https://github.com/acme-labs/acme-portal-mock'),
+    ).toThrow(
+      'The repository owner cannot be read from the operated url: https://github.com/acme-labs/acme-portal-mock',
     );
   });
 });
@@ -32,9 +80,9 @@ describe('extractRepositoryOwner', () => {
   it('should return the owner of an issue url', () => {
     expect(
       extractRepositoryOwner(
-        'https://github.com/meta-site/hr-audit-mock/issues/178',
+        'https://github.com/acme-labs/acme-portal-mock/issues/178',
       ),
-    ).toBe('meta-site');
+    ).toBe('acme-labs');
   });
 
   it('should return the owner of a pull request url', () => {
@@ -47,7 +95,7 @@ describe('extractRepositoryOwner', () => {
 
   it('should return null for a url that is not an issue or a pull request', () => {
     expect(
-      extractRepositoryOwner('https://github.com/meta-site/hr-audit-mock'),
+      extractRepositoryOwner('https://github.com/acme-labs/acme-portal-mock'),
     ).toBeNull();
   });
 });
@@ -68,41 +116,41 @@ describe('createConsoleGithubTokenResolver', () => {
   it('should return the token read from the file configured for that owner', () => {
     const resolve = createConsoleGithubTokenResolver(
       'default-token',
-      { 'meta-site': '/creds/meta-site-token.txt' },
+      { 'acme-labs': '/creds/acme-labs-token.txt' },
       (filePath) =>
-        filePath === '/creds/meta-site-token.txt'
+        filePath === '/creds/acme-labs-token.txt'
           ? 'fine-grained-token\n'
           : (() => {
               throw new Error(`unexpected file path: ${filePath}`);
             })(),
     );
 
-    expect(resolve('meta-site')).toBe('fine-grained-token');
+    expect(resolve('acme-labs')).toBe('fine-grained-token');
   });
 
   it('should keep using the default token for the other owners when one owner has a token file', () => {
     const resolve = createConsoleGithubTokenResolver(
       'default-token',
-      { 'meta-site': '/creds/meta-site-token.txt' },
+      { 'acme-labs': '/creds/acme-labs-token.txt' },
       () => 'fine-grained-token',
     );
 
-    expect(resolve('X-Mile')).toBe('default-token');
+    expect(resolve('globex-inc')).toBe('default-token');
   });
 
   it('should read the token file only once per owner', () => {
     let readCount = 0;
     const resolve = createConsoleGithubTokenResolver(
       'default-token',
-      { 'meta-site': '/creds/meta-site-token.txt' },
+      { 'acme-labs': '/creds/acme-labs-token.txt' },
       () => {
         readCount += 1;
         return 'fine-grained-token';
       },
     );
 
-    resolve('meta-site');
-    resolve('meta-site');
+    resolve('acme-labs');
+    resolve('acme-labs');
 
     expect(readCount).toBe(1);
   });
@@ -110,25 +158,25 @@ describe('createConsoleGithubTokenResolver', () => {
   it('should throw when the configured token file contains no token', () => {
     const resolve = createConsoleGithubTokenResolver(
       'default-token',
-      { 'meta-site': '/creds/meta-site-token.txt' },
+      { 'acme-labs': '/creds/acme-labs-token.txt' },
       () => '  \n',
     );
 
-    expect(() => resolve('meta-site')).toThrow(
-      'The GitHub token file configured for repository owner "meta-site" contains no token: /creds/meta-site-token.txt',
+    expect(() => resolve('acme-labs')).toThrow(
+      'The GitHub token file configured for repository owner "acme-labs" contains no token: /creds/acme-labs-token.txt',
     );
   });
 
   it('should surface the read failure when the configured token file cannot be read', () => {
     const resolve = createConsoleGithubTokenResolver(
       'default-token',
-      { 'meta-site': '/creds/meta-site-token.txt' },
+      { 'acme-labs': '/creds/acme-labs-token.txt' },
       () => {
         throw new Error('ENOENT: no such file or directory');
       },
     );
 
-    expect(() => resolve('meta-site')).toThrow(
+    expect(() => resolve('acme-labs')).toThrow(
       'ENOENT: no such file or directory',
     );
   });

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

@@ -26,6 +26,30 @@ export const createConsoleIssueRepositoryResolver = <IssueRepositoryType>(
   };
 };
 
+export const extractProjectOwner = (projectUrl: string): string | null => {
+  const match = projectUrl.match(
+    /^https:\/\/github\.com\/(?:orgs|users)\/([A-Za-z0-9._-]+)\/projects\/\d+/,
+  );
+  return match ? match[1] : null;
+};
+
+export const createConsoleProjectRepositoryResolver = <ProjectRepositoryType>(
+  resolveGithubToken: ConsoleGithubTokenResolver,
+  buildProjectRepositoryForToken: (
+    githubToken: string,
+  ) => ProjectRepositoryType,
+): ((projectUrl: string) => ProjectRepositoryType) => {
+  return (projectUrl: string): ProjectRepositoryType => {
+    const projectOwner = extractProjectOwner(projectUrl);
+    if (projectOwner === null) {
+      throw new Error(
+        `The project owner cannot be read from the project url: ${projectUrl}`,
+      );
+    }
+    return buildProjectRepositoryForToken(resolveGithubToken(projectOwner));
+  };
+};
+
 export const createConsoleGithubTokenResolver = (
   defaultToken: string,
   githubTokenFilePathByRepositoryOwner: Record<string, string> | null,

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

@@ -141,12 +141,12 @@ describe('consoleOperationApi', () => {
       await handleReview(contextRecordingResolvedUrls, {
         pjcode: 'acme',
         action: 'approve',
-        prUrl: 'https://github.com/meta-site/hr-audit-mock/pull/178',
+        prUrl: 'https://github.com/acme-labs/acme-portal-mock/pull/178',
         projectItemId: 'PVTI_resolver',
       });
 
       expect(resolvedUrls).toContain(
-        'https://github.com/meta-site/hr-audit-mock/pull/178',
+        'https://github.com/acme-labs/acme-portal-mock/pull/178',
       );
     });
 

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

@@ -2,6 +2,7 @@ import { mock } from 'jest-mock-extended';
 import { Project } from '../../../domain/entities/Project';
 import {
   buildPjcodeToProjectUrl,
+  createConsoleProjectLoader,
   createConsoleProjectResolver,
   createPjcodeConfigChecker,
 } from './consoleProjectResolver';
@@ -107,3 +108,93 @@ describe('createConsoleProjectResolver', () => {
     expect(loadProject).toHaveBeenCalledTimes(1);
   });
 });
+
+describe('createConsoleProjectLoader', () => {
+  const globexProjectOfLoader: Project = {
+    ...mock<Project>(),
+    id: 'PVT_globex',
+  };
+
+  const buildProjectRepositoryResolver = (
+    findProjectIdByUrl: (projectUrl: string) => Promise<string | null>,
+    getProject: (projectId: string) => Promise<Project | null>,
+  ) =>
+    jest.fn((projectUrl: string) => {
+      if (projectUrl !== 'https://github.com/orgs/globex/projects/18') {
+        throw new Error(`unexpected project url: ${projectUrl}`);
+      }
+      return { findProjectIdByUrl, getProject };
+    });
+
+  it('resolves the project id through the repository chosen for the project url', async () => {
+    const resolveProjectRepository = buildProjectRepositoryResolver(
+      async () => 'PVT_globex',
+      async () => globexProjectOfLoader,
+    );
+    const loadProject = createConsoleProjectLoader(
+      resolveProjectRepository,
+      async () => null,
+      () => undefined,
+    );
+
+    await expect(
+      loadProject('https://github.com/orgs/globex/projects/18'),
+    ).resolves.toBe(globexProjectOfLoader);
+    expect(resolveProjectRepository).toHaveBeenCalledWith(
+      'https://github.com/orgs/globex/projects/18',
+    );
+  });
+
+  it('prefers the locally cached project over a GraphQL project load', async () => {
+    const getProject = jest.fn(async () => globexProjectOfLoader);
+    const loadProject = createConsoleProjectLoader(
+      buildProjectRepositoryResolver(async () => 'PVT_globex', getProject),
+      async (projectId: string) =>
+        projectId === 'PVT_globex' ? globexProjectOfLoader : null,
+      () => undefined,
+    );
+
+    await expect(
+      loadProject('https://github.com/orgs/globex/projects/18'),
+    ).resolves.toBe(globexProjectOfLoader);
+    expect(getProject).not.toHaveBeenCalled();
+  });
+
+  it('reports and returns null when the project id cannot be resolved', async () => {
+    const reportedMessages: string[] = [];
+    const loadProject = createConsoleProjectLoader(
+      buildProjectRepositoryResolver(
+        async () => null,
+        async () => globexProjectOfLoader,
+      ),
+      async () => null,
+      (message: string) => reportedMessages.push(message),
+    );
+
+    await expect(
+      loadProject('https://github.com/orgs/globex/projects/18'),
+    ).resolves.toBeNull();
+    expect(reportedMessages).toEqual([
+      'No project found for projectUrl https://github.com/orgs/globex/projects/18',
+    ]);
+  });
+
+  it('reports and returns null when the project cannot be loaded', async () => {
+    const reportedMessages: string[] = [];
+    const loadProject = createConsoleProjectLoader(
+      buildProjectRepositoryResolver(
+        async () => 'PVT_globex',
+        async () => null,
+      ),
+      async () => null,
+      (message: string) => reportedMessages.push(message),
+    );
+
+    await expect(
+      loadProject('https://github.com/orgs/globex/projects/18'),
+    ).resolves.toBeNull();
+    expect(reportedMessages).toEqual([
+      'Failed to load project for projectUrl https://github.com/orgs/globex/projects/18',
+    ]);
+  });
+});

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

@@ -9,6 +9,38 @@ export type ConsoleProjectLoader = (
   projectUrl: string,
 ) => Promise<Project | null>;
 
+export type ConsoleProjectIdAndProjectReader = {
+  findProjectIdByUrl: (projectUrl: string) => Promise<string | null>;
+  getProject: (projectId: string) => Promise<Project | null>;
+};
+
+export const createConsoleProjectLoader = (
+  resolveProjectRepository: (
+    projectUrl: string,
+  ) => ConsoleProjectIdAndProjectReader,
+  getCachedProject: (projectId: string) => Promise<Project | null>,
+  reportLoadFailure: (message: string) => void,
+): ConsoleProjectLoader => {
+  return async (projectUrl: string): Promise<Project | null> => {
+    const projectRepository = resolveProjectRepository(projectUrl);
+    const projectId = await projectRepository.findProjectIdByUrl(projectUrl);
+    if (!projectId) {
+      reportLoadFailure(`No project found for projectUrl ${projectUrl}`);
+      return null;
+    }
+    const cachedProject = await getCachedProject(projectId);
+    if (cachedProject) {
+      return cachedProject;
+    }
+    const loadedProject = await projectRepository.getProject(projectId);
+    if (!loadedProject) {
+      reportLoadFailure(`Failed to load project for projectUrl ${projectUrl}`);
+      return null;
+    }
+    return loadedProject;
+  };
+};
+
 export const buildPjcodeToProjectUrl = (
   defaultPjcode: string,
   defaultProjectUrl: string,