Minor UI Changes (#5464)

* Refresh on delete table

* Adding telemetry events

* fixing errors

* reverting icon changes

* sort column names

* edit item changes

* Updated unit test cases

* adding unit test cases

Author: Lokesh1302

packages/core/src/dynamoDb/activation.ts

@@ -13,26 +13,24 @@ import { DynamoDbTableNode } from './explorer/dynamoDbTableNode'
 import { deleteDynamoDbTable } from './commands/deleteDynamoDbTable'
 import { searchDynamoDbTables } from './commands/searchDynamoDbTables'
 import { DynamoDbInstanceNode } from './explorer/dynamoDbInstanceNode'
+import { telemetry } from '../shared/telemetry'
 
 export async function activate(context: ExtContext): Promise<void> {
     context.extensionContext.subscriptions.push(
         Commands.register('aws.dynamoDb.searchTables', async (node: DynamoDbTableNode | DynamoDbInstanceNode) => {
-            const dynamoDbtableInfo =
-                node instanceof DynamoDbTableNode
-                    ? { regionName: node.regionCode, groupName: node.regionCode! }
-                    : undefined
-            const source = node ? (dynamoDbtableInfo ? 'ExplorerDynamoDbTableNode' : 'ExplorerServiceNode') : 'Command'
+            const source = node ? 'ExplorerDynamoDbInstanceNode' : 'Command'
             await searchDynamoDbTables(context, source)
         }),
 
         Commands.register('aws.dynamoDb.copyArn', async (node: DynamoDbTableNode) => await copyDynamoDbArn(node)),
 
         Commands.register('aws.dynamoDb.refreshExplorer', async (node: DynamoDbInstanceNode) => node.refresh()),
 
-        Commands.register(
-            'aws.dynamoDb.viewTable',
-            async (node: DynamoDbTableNode) => await viewDynamoDbTable(context, node)
-        ),
+        Commands.register('aws.dynamoDb.viewTable', async (node: DynamoDbTableNode) => {
+            return telemetry.dynamodb_openTable.run(async () => {
+                await viewDynamoDbTable(context, node)
+            })
+        }),
 
         Commands.register('aws.dynamoDb.deleteTable', async (node: DynamoDbTableNode) => {
             await deleteDynamoDbTable(node)

packages/core/src/dynamoDb/commands/deleteDynamoDbTable.ts

@@ -33,14 +33,20 @@ export async function deleteDynamoDbTable(
 
     await telemetry.dynamodb_deleteTable.run(async () => {
         telemetry.record({ action: 'user' })
-        const response = await client.deleteTable({ TableName: node.dynamoDbtable })
-        if (response.TableDescription && response.TableDescription.TableName) {
-            getLogger().debug(`Deleted DynamoDB table: ${response.TableDescription.TableName}`)
-            node.parentNode.refresh()
-            return
+        try {
+            const response = await client.deleteTable({ TableName: node.dynamoDbtable })
+            if (response.TableDescription && response.TableDescription.TableName) {
+                getLogger().debug(`Deleted DynamoDB table: ${response.TableDescription.TableName}`)
+                await new Promise((resolve) => setTimeout(resolve, 3000)).then(async () => {
+                    await node.parentNode.refreshNode()
+                })
+            } else {
+                throw new Error(`Delete failed with error : ${JSON.stringify(response)}`)
+            }
+        } catch (err) {
+            const errorString = `Failed to delete DynamoDB table: ${node.dynamoDbtable}`
+            getLogger().error(errorString)
+            throw new Error(errorString)
         }
-        const errorString = `Failed to delete DynamoDB table: ${node.dynamoDbtable}`
-        getLogger().error(errorString)
-        throw new Error(errorString)
     })
 }

packages/core/src/dynamoDb/commands/searchDynamoDbTables.ts

@@ -5,14 +5,14 @@
 
 import * as nls from 'vscode-nls'
 import { Wizard } from '../../shared/wizards/wizard'
-import { telemetry } from '../../shared/telemetry/telemetry'
 import { DataQuickPickItem } from '../../shared/ui/pickerPrompter'
 import { DynamoDbClient } from '../../shared/clients/dynamoDbClient'
 import { toArrayAsync } from '../../shared/utilities/collectionUtils'
 import { CancellationError } from '../../shared/utilities/timeoutUtils'
 import { RegionSubmenu, RegionSubmenuResponse } from '../../shared/ui/common/regionSubmenu'
 import { ExtContext } from '../../shared/extensions'
 import { viewDynamoDbTable } from '../vue/tableView'
+import { telemetry } from '../../shared/telemetry'
 
 const localize = nls.loadMessageBundle()
 

packages/core/src/dynamoDb/explorer/dynamoDbInstanceNode.ts

@@ -10,6 +10,7 @@ import { DynamoDbClient } from '../../shared/clients/dynamoDbClient'
 import { AWSTreeNodeBase } from '../../shared/treeview/nodes/awsTreeNodeBase'
 import { PlaceholderNode } from '../../shared/treeview/nodes/placeholderNode'
 import { toMap, toArrayAsync, updateInPlace } from '../../shared/utilities/collectionUtils'
+import { telemetry } from '../../shared/telemetry'
 
 export class DynamoDbInstanceNode extends AWSTreeNodeBase {
     protected readonly placeHolderMessage = '[No Tables Found]'
@@ -35,13 +36,25 @@ export class DynamoDbInstanceNode extends AWSTreeNodeBase {
     }
 
     public async updateChildren(): Promise<void> {
-        const tables = toMap(await toArrayAsync(this.dynamoDbClient.getTables()), (configuration) => configuration)
-        const sortedTablesByName = new Map([...tables.entries()].sort((a, b) => a[0].localeCompare(b[0])))
-        updateInPlace(
-            this.dynamoDbTableNodes,
-            sortedTablesByName.keys(),
-            (key) => this.dynamoDbTableNodes.get(key)!,
-            (key) => new DynamoDbTableNode(this.regionCode, key, this)
-        )
+        return telemetry.dynamodb_view.run(async (span) => {
+            span.record({ dynamoDbTarget: 'table' })
+            const tables = toMap(await toArrayAsync(this.dynamoDbClient.getTables()), (configuration) => configuration)
+            const sortedTablesByName = new Map([...tables.entries()].sort((a, b) => a[0].localeCompare(b[0])))
+            updateInPlace(
+                this.dynamoDbTableNodes,
+                sortedTablesByName.keys(),
+                (key) => this.dynamoDbTableNodes.get(key)!,
+                (key) => new DynamoDbTableNode(this.regionCode, key, this)
+            )
+        })
+    }
+
+    public async clearChildren() {
+        this.dynamoDbTableNodes = new Map<string, DynamoDbTableNode>()
+    }
+
+    public async refreshNode(): Promise<void> {
+        await this.clearChildren()
+        await vscode.commands.executeCommand('aws.refreshAwsExplorerNode', this)
     }
 }

packages/core/src/dynamoDb/utils/dynamodb.ts

@@ -10,6 +10,7 @@ import { copyToClipboard } from '../../shared/utilities/messages'
 import { DynamoDbTableNode } from '../explorer/dynamoDbTableNode'
 import { DynamoDbClient } from '../../shared/clients/dynamoDbClient'
 import { AttributeValue, Key, ScanInput } from 'aws-sdk/clients/dynamodb'
+import { telemetry } from '../../shared/telemetry'
 
 export interface RowData {
     [key: string]: string
@@ -33,11 +34,12 @@ export interface TableSchema {
 export async function getTableContent(
     tableRequest: ScanInput,
     regionCode: string,
+    tableSchema: TableSchema,
     client = new DynamoDbClient(regionCode)
 ) {
     tableRequest.Limit = await getMaxItemsPerPage()
     const response = await client.scanTable(tableRequest)
-    const { columnNames, tableHeader } = getTableColumnsNames(response)
+    const { columnNames, tableHeader } = getTableColumnsNames(response, tableSchema)
     const tableItems = getTableItems(columnNames, response)
 
     const tableData: TableData = {
@@ -48,25 +50,38 @@ export async function getTableContent(
     return tableData
 }
 
-export function getTableColumnsNames(items: DynamoDB.Types.ScanOutput): {
+export function getTableColumnsNames(
+    items: DynamoDB.Types.ScanOutput,
+    tableSchema: TableSchema
+): {
     columnNames: Set<string>
     tableHeader: RowData[]
 } {
     const tableColumnsNames = new Set<string>()
     const tableHeader = [] as RowData[]
+    const response = {
+        columnNames: tableColumnsNames,
+        tableHeader: tableHeader,
+    }
+    if (!items.Items || items.Items.length === 0) {
+        return response
+    }
+    tableColumnsNames.add(tableSchema.partitionKey.name)
+    if (tableSchema.sortKey) {
+        tableColumnsNames.add(tableSchema.sortKey.name)
+    }
     for (const item of items.Items ?? []) {
         for (const key of Object.keys(item)) {
-            tableColumnsNames.add(key)
+            if (!tableColumnsNames.has(key)) {
+                tableColumnsNames.add(key)
+            }
         }
     }
     for (const columnName of tableColumnsNames) {
         tableHeader.push({ columnDataKey: columnName, title: columnName })
     }
 
-    return {
-        columnNames: tableColumnsNames,
-        tableHeader: tableHeader,
-    }
+    return response
 }
 
 export function getTableItems(tableColumnsNames: Set<string>, items: DynamoDB.Types.ScanOutput) {
@@ -92,24 +107,30 @@ export function getTableItems(tableColumnsNames: Set<string>, items: DynamoDB.Ty
  * @param {DynamoDbTableNode} node - The DynamoDB table node containing table and region information.
  */
 export async function copyDynamoDbArn(node: DynamoDbTableNode, client = new DynamoDbClient(node.regionCode)) {
-    const response = await client.getTableInformation({ TableName: node.dynamoDbtable })
-    if (response.TableArn !== undefined) {
-        await copyToClipboard(response.TableArn, 'ARN')
-    }
+    return telemetry.dynamodb_view.run(async (span) => {
+        const response = await client.getTableInformation({ TableName: node.dynamoDbtable })
+        if (response.TableArn !== undefined) {
+            span.emit({ dynamoDbTarget: 'tableProperties', result: 'Succeeded' })
+            await copyToClipboard(response.TableArn, 'ARN')
+        } else {
+            span.emit({ dynamoDbTarget: 'tableProperties', result: 'Failed', reason: 'Table ARN is undefined' })
+        }
+    })
 }
 
 export async function queryTableContent(
     queryRequest: { partitionKey: string; sortKey: string },
     regionCode: string,
     tableName: string,
+    tableSchema: TableSchema,
     lastEvaluatedKey?: Key,
     client = new DynamoDbClient(regionCode)
 ) {
     const queryRequestObject = await prepareQueryRequestObject(tableName, regionCode, client, queryRequest)
     queryRequestObject.Limit = await getMaxItemsPerPage()
     queryRequestObject.ExclusiveStartKey = lastEvaluatedKey
     const queryResponse = await client.queryTable(queryRequestObject)
-    const { columnNames, tableHeader } = getTableColumnsNames(queryResponse)
+    const { columnNames, tableHeader } = getTableColumnsNames(queryResponse, tableSchema)
     const tableItems = getTableItems(columnNames, queryResponse)
 
     const tableData: TableData = {