Task: Display client/plugin name on API explorer

vscode/microsoft-kiota/package.json

@@ -271,22 +271,22 @@
         },
         {
           "command": "kiota.openApiExplorer.addToSelectedEndpoints",
-          "when": "view == kiota.openApiExplorer && viewItem != apiTitle",
+          "when": "view == kiota.openApiExplorer && viewItem != apiTitle && viewItem != clientNameOrPluginName",
           "group": "inline@2"
         },
         {
           "command": "kiota.openApiExplorer.addAllToSelectedEndpoints",
-          "when": "view == kiota.openApiExplorer",
+          "when": "view == kiota.openApiExplorer && viewItem != clientNameOrPluginName",
           "group": "inline@4"
         },
         {
           "command": "kiota.openApiExplorer.removeFromSelectedEndpoints",
-          "when": "view == kiota.openApiExplorer && viewItem != apiTitle",
+          "when": "view == kiota.openApiExplorer && viewItem != apiTitle && viewItem != clientNameOrPluginName",
           "group": "inline@3"
         },
         {
           "command": "kiota.openApiExplorer.removeAllFromSelectedEndpoints",
-          "when": "view == kiota.openApiExplorer",
+          "when": "view == kiota.openApiExplorer && viewItem != clientNameOrPluginName",
           "group": "inline@5"
         }
       ],

vscode/microsoft-kiota/src/extension.ts

@@ -225,7 +225,7 @@ export async function activate(
      clientOrPluginKey = clientKey;
      clientOrPluginObject = clientObject;
      workspaceGenerationType = generationType;
-     await loadEditPaths(clientObject, openApiTreeProvider);
+     await loadEditPaths(clientOrPluginKey, clientObject, openApiTreeProvider);
      await vscode.commands.executeCommand('setContext',`${treeViewId}.showIcons`, false);
      await vscode.commands.executeCommand('setContext', `${treeViewId}.showRegenerateIcon`, true);
     }),
@@ -579,8 +579,8 @@ async function loadLockFile(node: { fsPath: string }, openApiTreeProvider: OpenA
   await vscode.commands.executeCommand('setContext',`${treeViewId}.showIcons`, true);
 }
 
-async function loadEditPaths(clientObject: any, openApiTreeProvider: OpenApiTreeProvider): Promise<void> {
-  await openTreeViewWithProgress(() => openApiTreeProvider.loadEditPaths(clientObject));
+async function loadEditPaths(clientOrPluginKey: string, clientObject: any, openApiTreeProvider: OpenApiTreeProvider): Promise<void> {
+  await openTreeViewWithProgress(() => openApiTreeProvider.loadEditPaths(clientOrPluginKey, clientObject));
 }
 
 async function exportLogsAndShowErrors(result: KiotaLogEntry[]) : Promise<void> {

vscode/microsoft-kiota/src/kiotaInterop.ts

@@ -41,6 +41,7 @@ export interface KiotaOpenApiNode {
     selected?: boolean,
     isOperation?: boolean;
     documentationUrl?: string;
+    clientNameOrPluginName?: string;
 }
 interface CacheClearableConfiguration {
     clearCache: boolean;

vscode/microsoft-kiota/src/openApiTreeProvider.ts

@@ -40,15 +40,16 @@ export class OpenApiTreeProvider implements vscode.TreeDataProvider<OpenApiTreeN
         }
       }
     }
-    public async loadEditPaths(clientObject: any): Promise<void> {
+    public async loadEditPaths(clientOrPluginKey: string, clientObject: any): Promise<void> {
         this.closeDescription(false);
         this._lockFile = clientObject;
+        this._lockFile!.clientClassName = clientOrPluginKey;
         if (this._lockFile?.descriptionLocation) {
           this._descriptionUrl = this._lockFile.descriptionLocation;
           this.includeFilters = this._lockFile.includePatterns;
           this.excludeFilters = this._lockFile.excludePatterns;
           const settings = this.settingsGetter();
-          await this.loadNodes(settings.clearCache);
+          await this.loadNodes(settings.clearCache, clientOrPluginKey);
           if (this.rawRootNode) {
               this.refreshView();
           }
@@ -140,7 +141,15 @@ export class OpenApiTreeProvider implements vscode.TreeDataProvider<OpenApiTreeN
         }
         const segment = segments.shift();
         if (segment) {
-            let child = currentNode.children.find(x => x.segment === segment);
+            let child: KiotaOpenApiNode | undefined;
+        if (currentNode.clientNameOrPluginName) {
+            const rootChild = currentNode.children.find(x => x.segment === '/');
+            if (rootChild) {
+                child = rootChild.children.find(x => x.segment === segment);
+            }
+        } else {
+            child = currentNode.children.find(x => x.segment === segment);
+        }
             if (child) {
                 return this.findApiNode(segments, child);
             } else if (segment.startsWith('{') && segment.endsWith('}')) {
@@ -213,7 +222,7 @@ export class OpenApiTreeProvider implements vscode.TreeDataProvider<OpenApiTreeN
         }
         return [];
     }
-    private async loadNodes(clearCache: boolean): Promise<void> {
+    private async loadNodes(clearCache: boolean, clientNameOrPluginName?: string): Promise<void> {
         if (!this.descriptionUrl || this.descriptionUrl.length === 0) {
             return;
         }
@@ -233,6 +242,17 @@ export class OpenApiTreeProvider implements vscode.TreeDataProvider<OpenApiTreeN
                     this.setAllSelected(result.rootNode, false);
                 }
                 this.rawRootNode = result.rootNode;
+                if (clientNameOrPluginName) {
+                    this.rawRootNode = createKiotaOpenApiNode(
+                        clientNameOrPluginName,
+                        '/',
+                        [this.rawRootNode],
+                        false,
+                        false,
+                        undefined,
+                        clientNameOrPluginName
+                    );
+                }
                 await vscode.commands.executeCommand('setContext',`${treeViewId}.showIcons`, true);
                 await vscode.commands.executeCommand('setContext', `${treeViewId}.showRegenerateIcon`, false);
             }
@@ -256,6 +276,7 @@ export class OpenApiTreeProvider implements vscode.TreeDataProvider<OpenApiTreeN
             this.apiTitle,
             node.children.map(x => this.getTreeNodeFromKiotaNode(x)),
             node.documentationUrl,
+            node.clientNameOrPluginName
         );
     }
     getChildren(element?: OpenApiTreeNode): vscode.ProviderResult<OpenApiTreeNode[]> {
@@ -279,6 +300,26 @@ function getPathSegments(path: string): string[] {
 function trimOperation(path: string): string {
     return path.split(operationSeparator)[0];
 }
+
+function createKiotaOpenApiNode(
+    segment: string,
+    path: string,
+    children: KiotaOpenApiNode[] = [],
+    selected?: boolean,
+    isOperation?: boolean,
+    documentationUrl?: string,
+    clientNameOrPluginName?: string
+): KiotaOpenApiNode {
+    return {
+        segment,
+        path,
+        children,
+        selected,
+        isOperation,
+        documentationUrl,
+        clientNameOrPluginName
+    };
+}
 type IconSet = string | vscode.Uri | { light: string | vscode.Uri; dark: string | vscode.Uri } | vscode.ThemeIcon;
 export class OpenApiTreeNode extends vscode.TreeItem {
     private static readonly selectedSet: IconSet = new vscode.ThemeIcon('check');
@@ -293,12 +334,17 @@ export class OpenApiTreeNode extends vscode.TreeItem {
         filterTokens: string[],
         apiTitle: string | undefined,
         public readonly children: OpenApiTreeNode[] = [],
-        public readonly documentationUrl?: string
+        public readonly documentationUrl?: string,
+        public readonly clientNameOrPluginName?: string
     ) {
         super(label, collapsibleState);
         this.id = `${path}_${filterTokens.join('_')}`; // so the collapsed state is NOT persisted between filter changes
         this.contextValue = label === pathSeparator + " (" + apiTitle + ")" ? 'apiTitle' :  (this.documentationUrl ? 'documentationUrl' : '');
         this.iconPath = selected ? OpenApiTreeNode.selectedSet : OpenApiTreeNode.unselectedSet;
+        if(clientNameOrPluginName) {
+            this.label = clientNameOrPluginName;
+            this.contextValue = 'clientNameOrPluginName';
+        }
     }
     public isNodeVisible(tokenizedFilter: string[]): boolean {
         if (tokenizedFilter.length === 0) {