introduce WorkspaceContentService to handle workspace file loading

vscode/microsoft-kiota/src/extension.ts

@@ -28,6 +28,7 @@ import { UriHandler } from './handlers/uriHandler';
 import {
   ClientOrPluginProperties
 } from "./kiotaInterop";
+import { WorkspaceContentService } from './modules/workspace';
 import { CodeLensProvider } from './providers/codelensProvider';
 import { DependenciesViewProvider } from "./providers/dependenciesViewProvider";
 import { OpenApiTreeNode, OpenApiTreeProvider } from "./providers/openApiTreeProvider";
@@ -36,7 +37,6 @@ import { loadTreeView, WorkspaceTreeItem, WorkspaceTreeProvider } from './provid
 import { getExtensionSettings } from "./types/extensionSettings";
 import { GeneratedOutputState } from './types/GeneratedOutputState';
 import { WorkspaceGenerationContext } from "./types/WorkspaceGenerationContext";
-import { isKiotaWorkspaceFilePresent } from './util';
 import { IntegrationParams } from './utilities/deep-linking';
 import { loadWorkspaceFile } from './utilities/file';
 import { updateStatusBarItem } from './utilities/status';
@@ -54,12 +54,13 @@ export async function activate(
     log: true,
   });
   const sharedService = SharedService.getInstance();
+  const workspaceContentService = new WorkspaceContentService();
   const openApiTreeProvider = new OpenApiTreeProvider(context, () => getExtensionSettings(extensionId), sharedService);
   const dependenciesInfoProvider = new DependenciesViewProvider(
     context.extensionUri
   );
   const reporter = new TelemetryReporter(context.extension.packageJSON.telemetryInstrumentationKey);
-  const workspaceTreeProvider = new WorkspaceTreeProvider(await isKiotaWorkspaceFilePresent(), sharedService);
+  const workspaceTreeProvider = new WorkspaceTreeProvider(workspaceContentService, sharedService);
 
   const setWorkspaceGenerationContext = (params: Partial<WorkspaceGenerationContext>) => {
     workspaceGenerationContext = { ...workspaceGenerationContext, ...params };

vscode/microsoft-kiota/src/modules/workspace/index.ts

@@ -0,0 +1,9 @@
+import { ClientOrPluginProperties } from "../../kiotaInterop";
+import WorkspaceContentService from "./workspaceContentService";
+
+export interface WorkspaceContent {
+  version: string;
+  clients: Record<string, ClientOrPluginProperties>;
+  plugins: Record<string, ClientOrPluginProperties>;
+}
+export { WorkspaceContentService };

vscode/microsoft-kiota/src/modules/workspace/workspaceContentService.ts

@@ -0,0 +1,43 @@
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+
+import { WorkspaceContent } from ".";
+import { KIOTA_WORKSPACE_FILE } from "../../constants";
+import { getWorkspaceJsonPath } from '../../util';
+
+class WorkspaceContentService {
+  constructor() { }
+
+  public async load(): Promise<WorkspaceContent | undefined> {
+    const isWorkspacePresent = await this.isKiotaWorkspaceFilePresent();
+    if (!isWorkspacePresent) {
+      return;
+    }
+    try {
+      const workspaceJson = vscode.workspace.textDocuments.find(doc => doc.fileName.endsWith(KIOTA_WORKSPACE_FILE));
+      if (!workspaceJson) {
+        throw new Error('Workspace file not found');
+      }
+      const content = workspaceJson.getText();
+      return JSON.parse(content);
+    } catch (error) {
+      console.error('Error loading workspace.json:', error);
+    }
+  }
+
+  async isKiotaWorkspaceFilePresent(): Promise<boolean> {
+    if (!vscode.workspace.workspaceFolders || vscode.workspace.workspaceFolders.length === 0) {
+      return false;
+    }
+    const workspaceFileDir = path.resolve(getWorkspaceJsonPath());
+    try {
+      await fs.promises.access(workspaceFileDir);
+    } catch (error) {
+      return false;
+    }
+    return true;
+  }
+}
+
+export default WorkspaceContentService;

vscode/microsoft-kiota/src/providers/workspaceTreeProvider.ts

@@ -2,15 +2,10 @@ import * as vscode from 'vscode';
 
 import { CLIENTS, KIOTA_WORKSPACE_FILE, PLUGINS } from '../constants';
 import { ClientOrPluginProperties } from '../kiotaInterop';
-import { getWorkspaceJsonPath, isClientType, isKiotaWorkspaceFilePresent, isPluginType } from '../util';
+import { WorkspaceContent, WorkspaceContentService } from '../modules/workspace';
+import { getWorkspaceJsonPath, isClientType, isPluginType } from '../util';
 import { SharedService } from './sharedService';
 
-interface WorkspaceContent {
-  version: string;
-  clients: Record<string, ClientOrPluginProperties>;
-  plugins: Record<string, ClientOrPluginProperties>;
-}
-
 export class WorkspaceTreeItem extends vscode.TreeItem {
   constructor(
     public readonly label: string,
@@ -26,25 +21,28 @@ export class WorkspaceTreeItem extends vscode.TreeItem {
 }
 
 export class WorkspaceTreeProvider implements vscode.TreeDataProvider<WorkspaceTreeItem> {
-  public isWorkspacePresent: boolean;
   private _onDidChangeTreeData: vscode.EventEmitter<WorkspaceTreeItem | undefined | null | void> = new vscode.EventEmitter<WorkspaceTreeItem | undefined | null | void>();
   readonly onDidChangeTreeData: vscode.Event<WorkspaceTreeItem | undefined | null | void> = this._onDidChangeTreeData.event;
-  private workspaceContent: WorkspaceContent | null = null;
-  private sharedService: SharedService;
+  private workspaceContent: WorkspaceContent | undefined = undefined;
 
-  constructor(isWSPresent: boolean, _sharedService: SharedService) {
-    this.isWorkspacePresent = isWSPresent;
-    this.sharedService = _sharedService;
-    this.loadWorkspaceContent();
+  constructor(
+    private workspaceContentService: WorkspaceContentService,
+    private sharedService: SharedService
+  ) {
+    void this.loadContent();
   }
 
   async refreshView(): Promise<void> {
-    this.loadWorkspaceContent();
-    this._onDidChangeTreeData.fire(); 
+    this.workspaceContent = await this.workspaceContentService.load();
+    this._onDidChangeTreeData.fire();
+  }
+
+  async loadContent(): Promise<void> {
+    this.workspaceContent = await this.workspaceContentService.load();
   }
 
   async getChildren(element?: WorkspaceTreeItem): Promise<WorkspaceTreeItem[]> {
-    if (!this.isWorkspacePresent) {
+    if (!this.workspaceContent) {
       return [];
     }
 
@@ -89,9 +87,9 @@ export class WorkspaceTreeProvider implements vscode.TreeDataProvider<WorkspaceT
 
   getProperties(name: string, category: string): ClientOrPluginProperties | undefined {
     if (category && category === CLIENTS) {
-      return this.workspaceContent?.plugins[name];
+      return this.workspaceContent?.clients[name];
     }
-    return this.workspaceContent?.clients[name];
+    return this.workspaceContent?.plugins[name];
   }
 
   getTreeItem(element: WorkspaceTreeItem): WorkspaceTreeItem {
@@ -120,22 +118,6 @@ export class WorkspaceTreeProvider implements vscode.TreeDataProvider<WorkspaceT
     return element;
   }
 
-  public loadWorkspaceContent(): void {
-    if (!this.isWorkspacePresent) {
-      this.workspaceContent = null;
-      return;
-    }
-    try {
-      const workspaceJson = vscode.workspace.textDocuments.find(doc => doc.fileName.endsWith(KIOTA_WORKSPACE_FILE));
-      if (!workspaceJson) {
-        throw new Error('Workspace file not found');
-      }
-      const content = workspaceJson.getText();
-      this.workspaceContent = JSON.parse(content);
-    } catch (error) {
-      console.error('Error loading workspace.json:', error);
-    }
-  }
 }
 
 async function openResource(resource: vscode.Uri): Promise<void> {
@@ -144,13 +126,11 @@ async function openResource(resource: vscode.Uri): Promise<void> {
 
 export async function loadTreeView(context: vscode.ExtensionContext, treeDataProvider: WorkspaceTreeProvider): Promise<void> {
   context.subscriptions.push(vscode.workspace.onDidChangeWorkspaceFolders(async () => {
-    treeDataProvider.isWorkspacePresent = await isKiotaWorkspaceFilePresent();
     await vscode.commands.executeCommand('kiota.workspace.refresh'); // Refresh the tree view when workspace folders change
   }));
   context.subscriptions.push(vscode.window.createTreeView('kiota.workspace', { treeDataProvider }));
   context.subscriptions.push(vscode.commands.registerCommand('kiota.workspace.openWorkspaceFile', openResource));
   context.subscriptions.push(vscode.commands.registerCommand('kiota.workspace.refresh', async () => {
-    treeDataProvider.isWorkspacePresent = await isKiotaWorkspaceFilePresent();
     await treeDataProvider.refreshView();
   }));
   context.subscriptions.push(
@@ -159,6 +139,4 @@ export async function loadTreeView(context: vscode.ExtensionContext, treeDataPro
       await vscode.commands.executeCommand('kiota.editPaths', label, properties, category);
     })
   );
-
-}
-;
+};

vscode/microsoft-kiota/src/util.ts

@@ -172,15 +172,4 @@ export function isValidUrl(url: string): boolean {
   }
 }
 
-export async function isKiotaWorkspaceFilePresent(): Promise<boolean> {
-  if (!vscode.workspace.workspaceFolders || vscode.workspace.workspaceFolders.length === 0) {
-    return false;
-  }
-  const workspaceFileDir = path.resolve(getWorkspaceJsonPath());
-  try {
-    await fs.promises.access(workspaceFileDir);
-  } catch (error) {
-    return false;
-  }
-  return true;
-}
+