refactor(codecatalyst): use public SDK model #3031

* Listen for errors
* Smart eviction
* Add some basic caching to reduce the # of verifySession and getUserDetails calls.

Author: JadenSimon

.eslintignore

@@ -3,7 +3,6 @@ node_modules/**
 src/shared/telemetry/clienttelemetry.d.ts
 src/codewhisperer/client/codewhispererclient.d.ts
 src/codewhisperer/client/codewhispereruserclient.d.ts
-types/clientcodecatalyst.d.ts
 **/*.gen.ts
 src/testFixtures/workspaceFolder/ts-plain-sam-app/
 dist/**

.gitignore

@@ -27,7 +27,6 @@ src/shared/telemetry/vscodeTelemetry.json
 src/shared/telemetry/clienttelemetry.d.ts
 src/codewhisperer/client/codewhispererclient.d.ts
 src/codewhisperer/client/codewhispereruserclient.d.ts
-types/clientcodecatalyst.d.ts
 
 # Generated by tests
 src/testFixtures/**/bin

package-lock.json

@@ -3571,7 +3571,7 @@
         "adm-zip": "^0.5.9",
         "amazon-states-language-service": "^1.7.2",
         "async-lock": "^1.3.0",
-        "aws-sdk": "^2.1211.0",
+        "aws-sdk": "^2.1267.0",
         "aws-ssm-document-language-service": "^1.0.0",
         "bytes": "^3.1.2",
         "cross-spawn": "^7.0.3",

package.json

@@ -206,10 +206,6 @@ ${fileContents}
 
 ;(async () => {
     const serviceClientDefinitions: ServiceClientDefinition[] = [
-        {
-            serviceJsonPath: 'types/codecatalyst-2020-12-01.json',
-            serviceName: 'ClientCodeCatalyst',
-        },
         {
             serviceJsonPath: 'src/shared/telemetry/service-2.json',
             serviceName: 'ClientTelemetry',

scripts/build/generateServiceClient.ts

@@ -4,7 +4,7 @@
  */
 
 import * as vscode from 'vscode'
-import { ConnectedCodeCatalystClient } from '../shared/clients/codecatalystClient'
+import { CodeCatalystClient } from '../shared/clients/codecatalystClient'
 import { isCloud9 } from '../shared/extensionUtilities'
 import {
     Auth,
@@ -58,7 +58,7 @@ export class CodeCatalystAuthenticationProvider {
     }
 
     // Get rid of this? Not sure where to put PAT code.
-    public async getPat(client: ConnectedCodeCatalystClient, username = client.identity.name): Promise<string> {
+    public async getPat(client: CodeCatalystClient, username = client.identity.name): Promise<string> {
         const stored = await this.storage.getPat(username)
 
         if (stored) {
@@ -71,7 +71,7 @@ export class CodeCatalystAuthenticationProvider {
         return resp.secret
     }
 
-    public async getCredentialsForGit(client: ConnectedCodeCatalystClient) {
+    public async getCredentialsForGit(client: CodeCatalystClient) {
         getLogger().verbose(`codecatalyst (git): attempting to provide credentials`)
 
         const username = client.identity.name

src/codecatalyst/auth.ts

@@ -13,28 +13,24 @@ import { selectCodeCatalystResource } from './wizards/selectResource'
 import { openCodeCatalystUrl } from './utils'
 import { CodeCatalystAuthenticationProvider } from './auth'
 import { Commands } from '../shared/vscode/commands2'
-import {
-    CodeCatalystClient,
-    ConnectedCodeCatalystClient,
-    CodeCatalystResource,
-} from '../shared/clients/codecatalystClient'
-import { createClientFactory, DevEnvironmentId, getConnectedDevEnv, openDevEnv } from './model'
+import { CodeCatalystClient, CodeCatalystResource, createClient } from '../shared/clients/codecatalystClient'
+import { DevEnvironmentId, getConnectedDevEnv, openDevEnv } from './model'
 import { showConfigureDevEnv } from './vue/configure/backend'
 import { showCreateDevEnv } from './vue/create/backend'
 import { CancellationError } from '../shared/utilities/timeoutUtils'
 import { ToolkitError } from '../shared/errors'
 import { telemetry } from '../shared/telemetry/telemetry'
 import { showConfirmationMessage } from '../shared/utilities/messages'
 import { AccountStatus } from '../shared/telemetry/telemetryClient'
-import { CreateDevEnvironmentRequest } from '../../types/clientcodecatalyst'
+import { CreateDevEnvironmentRequest } from 'aws-sdk/clients/codecatalyst'
 
 /** "List CodeCatalyst Commands" command. */
 export async function listCommands(): Promise<void> {
     vscode.commands.executeCommand('workbench.action.quickOpen', '> CodeCatalyst')
 }
 
 /** "Clone CodeCatalyst Repository" command. */
-export async function cloneCodeCatalystRepo(client: ConnectedCodeCatalystClient, url?: vscode.Uri): 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')
@@ -65,7 +61,7 @@ export async function cloneCodeCatalystRepo(client: ConnectedCodeCatalystClient,
  * - "Open CodeCatalyst Repository"
  */
 export async function openCodeCatalystResource(
-    client: ConnectedCodeCatalystClient,
+    client: CodeCatalystClient,
     kind: CodeCatalystResource['type']
 ): Promise<void> {
     const resource = await selectCodeCatalystResource(client, kind)
@@ -78,7 +74,7 @@ export async function openCodeCatalystResource(
 }
 
 export async function stopDevEnv(
-    client: ConnectedCodeCatalystClient,
+    client: CodeCatalystClient,
     devenv: DevEnvironmentId,
     opts?: { readonly showPrompt?: boolean }
 ): Promise<void> {
@@ -102,7 +98,7 @@ export async function stopDevEnv(
     })
 }
 
-export async function deleteDevEnv(client: ConnectedCodeCatalystClient, devenv: DevEnvironmentId): Promise<void> {
+export async function deleteDevEnv(client: CodeCatalystClient, devenv: DevEnvironmentId): Promise<void> {
     await client.deleteDevEnvironment({
         id: devenv.id,
         projectName: devenv.project.name,
@@ -116,7 +112,7 @@ export type DevEnvironmentSettings = Pick<
 >
 
 export async function updateDevEnv(
-    client: ConnectedCodeCatalystClient,
+    client: CodeCatalystClient,
     devenv: DevEnvironmentId,
     settings: DevEnvironmentSettings
 ) {
@@ -128,27 +124,16 @@ export async function updateDevEnv(
     })
 }
 
-function createClientInjector(
-    authProvider: CodeCatalystAuthenticationProvider,
-    clientFactory: () => Promise<CodeCatalystClient>
-): ClientInjector {
+function createClientInjector(authProvider: CodeCatalystAuthenticationProvider): ClientInjector {
     return async (command, ...args) => {
-        let client = await clientFactory()
+        telemetry.record({ userId: AccountStatus.NotSet })
 
-        try {
-            if (!client.connected) {
-                const conn = await authProvider.promptNotConnected()
-                client = await client.setCredentials(async () => (await conn.getToken()).accessToken)
-            }
+        await authProvider.restore()
+        const conn = authProvider.activeConnection ?? (await authProvider.promptNotConnected())
+        const client = await createClient(conn)
+        telemetry.record({ userId: client.identity.id })
 
-            return await command(client, ...args)
-        } finally {
-            const userId = client.connected ? client.identity.id : AccountStatus.NotApplicable
-
-            // TODO(sijaden): should this mark only instantiated spans or future spans as well?
-            // right now it won't mark spans if they're created and emitted prior to the command finishing
-            telemetry.record({ userId })
-        }
+        return command(client, ...args)
     }
 }
 
@@ -159,7 +144,7 @@ function createCommandDecorator(commands: CodeCatalystCommands): CommandDecorato
 }
 
 interface CodeCatalystCommand<T extends any[], U> {
-    (client: ConnectedCodeCatalystClient, ...args: T): U | Promise<U>
+    (client: CodeCatalystClient, ...args: T): U | Promise<U>
 }
 
 interface ClientInjector {
@@ -176,17 +161,14 @@ type Inject<T, U> = T extends (...args: infer P) => infer R
         : never
     : never
 
-type WithClient<T> = Parameters<Inject<T, ConnectedCodeCatalystClient>>
+type WithClient<T> = Parameters<Inject<T, CodeCatalystClient>>
 
 export class CodeCatalystCommands {
     public readonly withClient: ClientInjector
     public readonly bindClient = createCommandDecorator(this)
 
-    public constructor(
-        authProvider: CodeCatalystAuthenticationProvider,
-        clientFactory = createClientFactory(authProvider)
-    ) {
-        this.withClient = createClientInjector(authProvider, clientFactory)
+    public constructor(authProvider: CodeCatalystAuthenticationProvider) {
+        this.withClient = createClientInjector(authProvider)
     }
 
     public listCommands() {
@@ -282,9 +264,8 @@ export class CodeCatalystCommands {
 
     public static fromContext(ctx: Pick<vscode.ExtensionContext, 'secrets' | 'globalState'>) {
         const auth = CodeCatalystAuthenticationProvider.fromContext(ctx)
-        const factory = createClientFactory(auth)
 
-        return new this(auth, factory)
+        return new this(auth)
     }
 
     public static readonly declared = {

src/codecatalyst/commands.ts

@@ -6,7 +6,7 @@
 import * as vscode from 'vscode'
 import { RootNode } from '../awsexplorer/localExplorer'
 import { Connection, createBuilderIdConnection, isBuilderIdConnection } from '../credentials/auth'
-import { DevEnvironment } from '../shared/clients/codecatalystClient'
+import { createClient, DevEnvironment } from '../shared/clients/codecatalystClient'
 import { UnknownError } from '../shared/errors'
 import { isCloud9 } from '../shared/extensionUtilities'
 import { addColor, getIcon } from '../shared/icons'
@@ -15,7 +15,7 @@ import { TreeNode } from '../shared/treeview/resourceTreeDataProvider'
 import { Commands } from '../shared/vscode/commands2'
 import { CodeCatalystAuthenticationProvider } from './auth'
 import { CodeCatalystCommands } from './commands'
-import { ConnectedDevEnv, createClientFactory, getConnectedDevEnv, getDevfileLocation } from './model'
+import { ConnectedDevEnv, getConnectedDevEnv, getDevfileLocation } from './model'
 import * as codecatalyst from './model'
 
 const getStartedCommand = Commands.register(
@@ -146,8 +146,11 @@ export class CodeCatalystRootNode implements RootNode {
 
     private async getDevEnv() {
         try {
-            const client = await createClientFactory(this.authProvider)()
-            return client.connected ? await getConnectedDevEnv(client) : undefined
+            await this.authProvider.restore()
+            const conn = this.authProvider.activeConnection
+            const client = conn !== undefined ? await createClient(conn) : undefined
+
+            return client !== undefined ? await getConnectedDevEnv(client) : undefined
         } catch (err) {
             getLogger().warn(`codecatalyst: failed to get Dev Environment: ${UnknownError.cast(err).message}`)
         }

src/codecatalyst/explorer.ts

@@ -11,13 +11,10 @@ import {
     CodeCatalystClient,
     DevEnvironment,
     CodeCatalystRepo,
-    ConnectedCodeCatalystClient,
-    createClient,
     getCodeCatalystConfig,
 } from '../shared/clients/codecatalystClient'
 import { DevEnvClient } from '../shared/clients/devenvClient'
 import { getLogger } from '../shared/logger'
-import { CodeCatalystAuthenticationProvider } from './auth'
 import { AsyncCollection, toCollection } from '../shared/utilities/asyncCollection'
 import { getCodeCatalystSpaceName, getCodeCatalystProjectName } from '../shared/vscode/env'
 import { writeFile } from 'fs-extra'
@@ -95,17 +92,13 @@ export function getCodeCatalystSsmEnv(region: string, ssmPath: string, devenv: D
 }
 
 export function createCodeCatalystEnvProvider(
-    client: ConnectedCodeCatalystClient,
+    client: CodeCatalystClient,
     ssmPath: string,
     devenv: DevEnvironment,
     useSshAgent: boolean = true
 ): EnvProvider {
     return async () => {
-        if (!client.connected) {
-            throw new Error('Cannot provide environment variables when not logged-in')
-        }
-
-        await cacheBearerToken(client.token, devenv.id)
+        await cacheBearerToken(await client.getBearerToken(), devenv.id)
         const vars = getCodeCatalystSsmEnv(client.regionCode, ssmPath, devenv)
 
         return useSshAgent ? { [SSH_AGENT_SOCKET_VARIABLE]: await startSshAgent(), ...vars } : vars
@@ -150,32 +143,13 @@ export function getHostNameFromEnv(env: DevEnvironmentId): string {
     return `${HOST_NAME_PREFIX}${env.id}`
 }
 
-export function createClientFactory(
-    authProvider: CodeCatalystAuthenticationProvider
-): () => Promise<CodeCatalystClient> {
-    return async () => {
-        await authProvider.restore()
-        const client = await createClient()
-        const conn = authProvider.activeConnection
-
-        if (conn) {
-            // TODO(sijaden): add global caching module
-            return client.setCredentials(async () => (await conn.getToken()).accessToken)
-        } else {
-            // TODO: show prompt/notification to use Builder ID
-        }
-
-        return client
-    }
-}
-
 export interface ConnectedDevEnv {
     readonly summary: DevEnvironment
     readonly devenvClient: DevEnvClient
 }
 
 export async function getConnectedDevEnv(
-    codeCatalystClient: ConnectedCodeCatalystClient,
+    codeCatalystClient: CodeCatalystClient,
     devenvClient = new DevEnvClient()
 ): Promise<ConnectedDevEnv | undefined> {
     const devEnvId = devenvClient.id
@@ -211,7 +185,7 @@ interface DevEnvConnection {
 }
 
 export async function prepareDevEnvConnection(
-    client: ConnectedCodeCatalystClient,
+    client: CodeCatalystClient,
     { id, org, project }: DevEnvironmentId,
     { topic, timeout }: { topic?: string; timeout?: Timeout } = {}
 ): Promise<DevEnvConnection> {
@@ -253,7 +227,7 @@ export async function prepareDevEnvConnection(
  * @param targetPath vscode workspace (default: "/projects/[repo]")
  */
 export async function openDevEnv(
-    client: ConnectedCodeCatalystClient,
+    client: CodeCatalystClient,
     devenv: DevEnvironmentId,
     targetPath?: string
 ): Promise<void> {
@@ -338,7 +312,7 @@ export async function getDevfileLocation(client: DevEnvClient, root?: vscode.Uri
  * Given a collection of CodeCatalyst repos, try to find a corresponding devenv, if any
  */
 export function associateDevEnv(
-    client: ConnectedCodeCatalystClient,
+    client: CodeCatalystClient,
     repos: AsyncCollection<CodeCatalystRepo>
 ): AsyncCollection<CodeCatalystRepo & { devEnv?: DevEnvironment }> {
     return toCollection(async function* () {