feat(auth): add minimal signout button (#2970)

## Problem
No UI to signout

## Solution
Add a button on the node. This is a placeholder to make development easier and is not the final UI.

Author: JadenSimon

package.json

@@ -1717,6 +1717,11 @@
                     "command": "aws.cdk.viewDocs",
                     "when": "viewItem == awsCdkRootNode",
                     "group": "0@2"
+                },
+                {
+                    "command": "aws.auth.logout",
+                    "when": "viewItem == awsAuthNode",
+                    "group": "inline@1"
                 }
             ]
         },
@@ -1814,6 +1819,11 @@
                     }
                 }
             },
+            {
+                "command": "aws.auth.logout",
+                "title": "%AWS.command.logout%",
+                "category": "%AWS.title%"
+            },
             {
                 "command": "aws.createIssueOnGitHub",
                 "title": "%AWS.command.createIssueOnGitHub%",

src/credentials/auth.ts

@@ -356,6 +356,12 @@ export class Auth implements AuthService, ConnectionManager {
         return connections.find(c => c.id === connection.id)
     }
 
+    /**
+     * Attempts to remove all auth state related to the connection.
+     *
+     * For SSO, this involves an API call to clear server-side state. The call happens
+     * before the local token(s) are cleared as they are needed in the request.
+     */
     private async invalidateConnection(id: Connection['id']) {
         const profile = this.store.getProfileOrThrow(id)
 
@@ -482,6 +488,7 @@ export async function promptLogin(auth: Auth) {
 }
 
 const loginCommand = Commands.register('aws.auth.login', promptLogin)
+Commands.register('aws.auth.logout', () => Auth.instance.logout())
 
 function mapEventType<T, U = void>(event: vscode.Event<T>, fn?: (val: T) => U): vscode.Event<U> {
     const emitter = new vscode.EventEmitter<U>()
@@ -508,6 +515,7 @@ export class AuthNode {
         const item = new vscode.TreeItem(itemLabel)
         item.iconPath = getIcon('vscode-account')
         item.command = loginCommand.build(this.resource).asCommand({ title: 'Login' })
+        item.contextValue = 'awsAuthNode'
 
         return item
     }

src/credentials/sso/clients.ts

@@ -110,24 +110,30 @@ export class OidcClient {
 }
 
 type OmittedProps = 'accessToken' | 'nextToken'
-type ExtractOverload<T> = T extends {
-    (this: void, ...args: infer P1): infer R1
-    (this: void, ...args: infer P2): infer R2
-    (this: void, ...args: infer P3): infer R3
+type ExtractOverload<T, U> = T extends {
+    (...args: infer P1): infer R1
+    (...args: infer P2): infer R2
+    (...args: infer P3): infer R3
 }
-    ? (...args: P1) => R1
+    ? (this: U, ...args: P1) => R1
     : never
 
+// Removes all methods that use callbacks instead of promises
+type PromisifyClient<T> = {
+    [P in keyof T]: T[P] extends (...args: any[]) => any ? ExtractOverload<T[P], PromisifyClient<T>> : T[P]
+}
+
 export class SsoClient {
-    public constructor(private readonly client: SSO, private readonly provider: SsoAccessTokenProvider) {}
+    public constructor(
+        private readonly client: PromisifyClient<SSO>,
+        private readonly provider: SsoAccessTokenProvider
+    ) {}
 
     public listAccounts(
         request: Omit<ListAccountsRequest, OmittedProps> = {}
     ): AsyncCollection<RequiredProps<AccountInfo, 'accountId'>[]> {
-        const method = this.client.listAccounts.bind(this.client)
         const requester = (request: Omit<ListAccountsRequest, 'accessToken'>) =>
-            this.call(method as ExtractOverload<typeof method>, request)
-
+            this.call(this.client.listAccounts, request)
         const collection = pageableToCollection(requester, request, 'nextToken', 'accountList')
 
         return collection.filter(isNonNullable).map(accounts => accounts.map(a => (assertHasProps(a, 'accountId'), a)))
@@ -136,10 +142,8 @@ export class SsoClient {
     public listAccountRoles(
         request: Omit<ListAccountRolesRequest, OmittedProps>
     ): AsyncCollection<Required<RoleInfo>[]> {
-        const method = this.client.listAccountRoles.bind(this.client)
         const requester = (request: Omit<ListAccountRolesRequest, 'accessToken'>) =>
-            this.call(method as ExtractOverload<typeof method>, request)
-
+            this.call(this.client.listAccountRoles, request)
         const collection = pageableToCollection(requester, request, 'nextToken', 'roleList')
 
         return collection
@@ -148,8 +152,7 @@ export class SsoClient {
     }
 
     public async getRoleCredentials(request: Omit<GetRoleCredentialsRequest, OmittedProps>) {
-        const method = this.client.getRoleCredentials.bind(this.client)
-        const response = await this.call(method as ExtractOverload<typeof method>, request)
+        const response = await this.call(this.client.getRoleCredentials, request)
 
         assertHasProps(response, 'roleCredentials')
         assertHasProps(response.roleCredentials, 'accessKeyId', 'secretAccessKey')
@@ -163,20 +166,19 @@ export class SsoClient {
     }
 
     public async logout(request: Omit<LogoutRequest, OmittedProps> = {}) {
-        const method = this.client.logout.bind(this.client)
-        await this.call(method as ExtractOverload<typeof method>, request)
+        await this.call(this.client.logout, request)
     }
 
     private call<T extends { accessToken: string | undefined }, U>(
-        method: (request: T) => Promise<U>,
+        method: (this: typeof this.client, request: T) => Promise<U>,
         request: Omit<T, 'accessToken'>
     ): Promise<U> {
         const requester = async (req: T) => {
             const token = await this.provider.getToken()
             assertHasProps(token, 'accessToken')
 
             try {
-                return await method({ ...req, accessToken: token.accessToken })
+                return await method.call(this.client, { ...req, accessToken: token.accessToken })
             } catch (error) {
                 await this.handleError(error)
                 throw error