fix(codecatalyst): exclude third-party repos for "Clone" #3252

Problem:
CodeCatalyst API does not support cloning 3P repos.

Solution:
Do not show 3P repos when listing repos for "Clone CodeCatalyst Repository" command.

Fixes IDE-10273

Signed-off-by: Nikolas Komonen <[email protected]>

Author: nkomonen-amazon

src/codecatalyst/commands.ts

@@ -9,7 +9,7 @@ import * as nls from 'vscode-nls'
 const localize = nls.loadMessageBundle()
 
 import * as vscode from 'vscode'
-import { selectCodeCatalystResource } from './wizards/selectResource'
+import { selectCodeCatalystRepository, selectCodeCatalystResource } from './wizards/selectResource'
 import { openCodeCatalystUrl, recordSource } from './utils'
 import { CodeCatalystAuthenticationProvider } from './auth'
 import { Commands } from '../shared/vscode/commands2'
@@ -33,7 +33,7 @@ export async function listCommands(): Promise<void> {
 export async function cloneCodeCatalystRepo(client: CodeCatalystClient, url?: vscode.Uri): Promise<void> {
     let resource: { name: string; project: string; org: string }
     if (!url) {
-        const r = await selectCodeCatalystResource(client, 'repo')
+        const r = await selectCodeCatalystRepository(client, false)
         if (!r) {
             throw new CancellationError('user')
         }

src/codecatalyst/wizards/selectResource.ts

@@ -124,16 +124,17 @@ export function createProjectPrompter(
 
 export function createRepoPrompter(
     client: codecatalyst.CodeCatalystClient,
-    proj?: codecatalyst.CodeCatalystProject
+    proj?: codecatalyst.CodeCatalystProject,
+    thirdParty?: boolean
 ): QuickPickPrompter<codecatalyst.CodeCatalystRepo> {
     const helpUri = isCloud9() ? docs.cloud9.cloneRepo : docs.vscode.main
     const repos = proj
-        ? client.listSourceRepositories({ spaceName: proj.org.name, projectName: proj.name })
-        : client.listResources('repo')
+        ? client.listSourceRepositories({ spaceName: proj.org.name, projectName: proj.name }, thirdParty)
+        : client.listResources('repo', thirdParty)
 
     return createResourcePrompter(repos, helpUri, {
         title: 'Select a CodeCatalyst Repository',
-        placeholder: 'Search for a Repository',
+        placeholder: 'Search for a CodeCatalyst Repository',
     })
 }
 
@@ -190,6 +191,15 @@ export async function selectCodeCatalystResource<T extends ResourceType>(
     return isValidResponse(response) ? (response as codecatalyst.CodeCatalystResource & { type: T }) : undefined
 }
 
+export async function selectCodeCatalystRepository(
+    client: codecatalyst.CodeCatalystClient,
+    includeThirdPartyRepos?: boolean
+): Promise<codecatalyst.CodeCatalystRepo | undefined> {
+    const prompter = createRepoPrompter(client, undefined, includeThirdPartyRepos)
+    const response = await prompter.prompt()
+    return isValidResponse(response) ? response : undefined
+}
+
 /**
  * Special-case of {@link createRepoPrompter} for creating a new devenv
  */

src/shared/clients/codecatalystClient.ts

@@ -21,6 +21,12 @@ import { CodeCatalyst } from 'aws-sdk'
 import { ToolkitError } from '../errors'
 import { SsoConnection } from '../../credentials/auth'
 import { TokenProvider } from '../../credentials/sdkV2Compat'
+import { Uri } from 'vscode'
+import {
+    GetSourceRepositoryCloneUrlsRequest,
+    ListSourceRepositoriesItem,
+    ListSourceRepositoriesItems,
+} from 'aws-sdk/clients/codecatalyst'
 
 // REMOVE ME SOON: only used for development
 interface CodeCatalystConfig {
@@ -411,12 +417,33 @@ class CodeCatalystClientInternal {
 
     /**
      * Gets a flat list of all repos for the given CodeCatalyst user.
+     * @param thirdParty If you want to include 3P (eg github) results in
+     *                   your output.
      */
     public listSourceRepositories(
-        request: CodeCatalyst.ListSourceRepositoriesRequest
+        request: CodeCatalyst.ListSourceRepositoriesRequest,
+        thirdParty: boolean = true
     ): AsyncCollection<CodeCatalystRepo[]> {
-        const requester = async (request: CodeCatalyst.ListSourceRepositoriesRequest) =>
-            this.call(this.sdkClient.listSourceRepositories(request), true, { items: [] })
+        const requester = async (request: CodeCatalyst.ListSourceRepositoriesRequest) => {
+            const allRepositories = this.call(this.sdkClient.listSourceRepositories(request), true, { items: [] })
+            let finalRepositories = allRepositories
+
+            // Filter out 3P repos
+            if (!thirdParty) {
+                finalRepositories = allRepositories.then(async repos => {
+                    repos.items = await excludeThirdPartyRepos(
+                        this,
+                        request.spaceName,
+                        request.projectName,
+                        repos.items
+                    )
+                    return repos
+                })
+            }
+
+            return finalRepositories
+        }
+
         const collection = pageableToCollection(requester, request, 'nextToken', 'items')
         return collection.map(
             summaries =>
@@ -445,12 +472,17 @@ class CodeCatalystClientInternal {
 
     /**
      * Lists ALL of the given resource in the current account
+     *
+     * @param thirdParty If you want 3P repos in the result.
      */
     public listResources(resourceType: 'org'): AsyncCollection<CodeCatalystOrg[]>
     public listResources(resourceType: 'project'): AsyncCollection<CodeCatalystProject[]>
-    public listResources(resourceType: 'repo'): AsyncCollection<CodeCatalystRepo[]>
+    public listResources(resourceType: 'repo', thirdParty?: boolean): AsyncCollection<CodeCatalystRepo[]>
     public listResources(resourceType: 'devEnvironment'): AsyncCollection<DevEnvironment[]>
-    public listResources(resourceType: CodeCatalystResource['type']): AsyncCollection<CodeCatalystResource[]> {
+    public listResources(
+        resourceType: CodeCatalystResource['type'],
+        ...args: any[]
+    ): AsyncCollection<CodeCatalystResource[]> {
         function mapInner<T, U>(
             collection: AsyncCollection<T[]>,
             fn: (element: T) => AsyncCollection<U[]>
@@ -465,7 +497,7 @@ class CodeCatalystClientInternal {
                 return mapInner(this.listResources('org'), o => this.listProjects({ spaceName: o.name }))
             case 'repo':
                 return mapInner(this.listResources('project'), p =>
-                    this.listSourceRepositories({ projectName: p.name, spaceName: p.org.name })
+                    this.listSourceRepositories({ projectName: p.name, spaceName: p.org.name }, ...args)
                 )
             case 'branch':
                 throw new Error('Listing branches is not currently supported')
@@ -481,13 +513,14 @@ class CodeCatalystClientInternal {
     }
 
     /**
-     * Gets the git source host URL for the given CodeCatalyst repo.
+     * Gets the git source host URL for the given CodeCatalyst or third-party repo.
      */
     public async getRepoCloneUrl(args: CodeCatalyst.GetSourceRepositoryCloneUrlsRequest): Promise<string> {
         const r = await this.call(this.sdkClient.getSourceRepositoryCloneUrls(args), false)
 
         // The git extension skips over credential providers if the username is included in the authority
-        return `https://${r.https.replace(/.*@/, '')}`
+        const uri = Uri.parse(r.https)
+        return uri.with({ authority: uri.authority.replace(/.*@/, '') }).toString()
     }
 
     public async createDevEnvironment(args: CodeCatalyst.CreateDevEnvironmentRequest): Promise<DevEnvironment> {
@@ -676,3 +709,48 @@ class CodeCatalystClientInternal {
         return devenv
     }
 }
+
+/**
+ * Returns only the first-party repos from the given
+ * list of repository items.
+ */
+export async function excludeThirdPartyRepos(
+    client: CodeCatalystClient,
+    spaceName: CodeCatalystOrg['name'],
+    projectName: CodeCatalystProject['name'],
+    items?: Pick<ListSourceRepositoriesItem, 'name'>[]
+): Promise<ListSourceRepositoriesItems | undefined> {
+    if (items === undefined) {
+        return items
+    }
+
+    // Filter out 3P repos.
+    return (
+        await Promise.all(
+            items.map(async item => {
+                return (await isThirdPartyRepo(client, {
+                    spaceName,
+                    projectName,
+                    sourceRepositoryName: item.name,
+                }))
+                    ? undefined
+                    : item
+            })
+        )
+    ).filter(item => item !== undefined) as CodeCatalyst.ListSourceRepositoriesItem[]
+}
+
+/**
+ * Determines if a repo is third party (3P) compared to first party (1P).
+ *
+ * 1P is CodeCatalyst, 3P is something like Github.
+ */
+async function isThirdPartyRepo(
+    client: CodeCatalystClient,
+    codeCatalystRepo: GetSourceRepositoryCloneUrlsRequest
+): Promise<boolean> {
+    const url = await client.getRepoCloneUrl(codeCatalystRepo)
+    // TODO: Make more robust to work with gamma once getCodeCatalystConfig()
+    // can provide a valid hostname
+    return !Uri.parse(url).authority.endsWith('codecatalyst.aws')
+}

src/test/caws/codecatalystClient.test.ts

@@ -0,0 +1,85 @@
+/*!
+ * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as assert from 'assert'
+import sinon = require('sinon')
+import { toCodeCatalystUrl } from '../../codecatalyst/utils'
+import * as codecatalyst from '../../shared/clients/codecatalystClient'
+
+describe('codeCatalystClient', function () {
+    it('toCodeCatalystUrl()', async function () {
+        const org: codecatalyst.CodeCatalystOrg = {
+            type: 'org',
+            name: 'org1',
+            regionName: 'region',
+        }
+        const project: codecatalyst.CodeCatalystProject = {
+            type: 'project',
+            org: org,
+            name: 'project1',
+        }
+        const repo: codecatalyst.CodeCatalystRepo = {
+            type: 'repo',
+            org: org,
+            project: project,
+            id: 'repoid1',
+            name: 'repo1',
+            lastUpdatedTime: new Date(),
+            createdTime: new Date(),
+        }
+        const prefix = `https://${codecatalyst.getCodeCatalystConfig().hostname}/spaces`
+        assert.deepStrictEqual(toCodeCatalystUrl(org), `${prefix}/org1/view`)
+        assert.deepStrictEqual(toCodeCatalystUrl(project), `${prefix}/org1/projects/project1/view`)
+        assert.deepStrictEqual(
+            toCodeCatalystUrl(repo),
+            `${prefix}/org1/projects/project1/source-repositories/repo1/view`
+        )
+    })
+})
+
+describe('getFirstPartyRepos()', function () {
+    let sandbox: sinon.SinonSandbox
+    let codeCatalystClient: codecatalyst.CodeCatalystClient
+    let getRepoCloneUrlStub: sinon.SinonStub
+
+    before(function () {
+        sandbox = sinon.createSandbox()
+    })
+
+    beforeEach(function () {
+        codeCatalystClient = <codecatalyst.CodeCatalystClient>{}
+
+        getRepoCloneUrlStub = sandbox.stub()
+        codeCatalystClient.getRepoCloneUrl = getRepoCloneUrlStub
+    })
+
+    it('removes third party repos', async function () {
+        getRepoCloneUrlStub.onCall(0).resolves('https://github.com/aws/not-code-catalyst-1.git')
+        getRepoCloneUrlStub.onCall(1).resolves('https://codecatalyst.aws/code-catalyst-1')
+        getRepoCloneUrlStub.onCall(2).resolves('https://github.com/aws/not-code-catalyst-2.git')
+        getRepoCloneUrlStub.onCall(3).resolves('https://codecatalyst.aws/code-catalyst-1')
+
+        const allRepos = await codecatalyst.excludeThirdPartyRepos(codeCatalystClient, '', '', [
+            { name: 'not-code-catalyst-1' },
+            { name: 'code-catalyst-1' },
+            { name: 'not-code-catalyst-2' },
+            { name: 'code-catalyst-2' },
+        ])
+
+        assert.deepStrictEqual(allRepos, [{ name: 'code-catalyst-1' }, { name: 'code-catalyst-2' }])
+    })
+
+    it('returns empty array if no first party repos', async function () {
+        getRepoCloneUrlStub.onCall(0).resolves('https://github.com/aws/aws-cdk.git')
+        getRepoCloneUrlStub.onCall(1).resolves('https://github.com/aws/vscode-toolkit.git')
+
+        const allRepos = await codecatalyst.excludeThirdPartyRepos(codeCatalystClient, '', '', [
+            { name: 'aws-cdk' },
+            { name: 'vscode-toolkit' },
+        ])
+
+        assert.deepStrictEqual(allRepos, [])
+    })
+})