Start implementation of compat shim

package.json

@@ -579,7 +579,8 @@
         "@azure/arm-resources": "5.0.0",
         "@azure/arm-resources-profile-2020-09-01-hybrid": "^2.0.0",
         "@microsoft/vscode-azext-azureutils": "^0.3.4",
-        "@microsoft/vscode-azext-utils": "^0.3.14",
+        "@microsoft/vscode-azext-utils": "file:../vscode-azuretools/utils/microsoft-vscode-azext-utils-0.3.15.tgz",
+        "fs-extra": "^8.1.0",
         "jsonc-parser": "^2.2.1",
         "open": "^8.0.4",
         "semver": "^7.3.7",

src/api/AzureResourceGroupsExtensionApi.ts

@@ -8,13 +8,13 @@ import { Activity, AppResourceResolver, AzureHostExtensionApi, AzureResourceGrou
 import { Disposable, TreeView } from 'vscode';
 
 export class InternalAzureResourceGroupsExtensionApi implements AzureHostExtensionApi, AzureResourceGroupsExtensionApi {
-    public static apiVersion = '0.0.1';
+    public static apiVersion: '0.0.1' = '0.0.1';
 
     #appResourceTree: AzExtTreeDataProvider;
-    #appResourceTreeView: TreeView<AzExtTreeItem>;
+    #appResourceTreeView: TreeView<unknown>;
     #workspaceResourceTree: AzExtTreeDataProvider;
-    #workspaceResourceTreeView: TreeView<AzExtTreeItem>;
-    #apiVersion: string;
+    #workspaceResourceTreeView: TreeView<unknown>;
+    #apiVersion: '0.0.1';
     #revealTreeItem: (resourceId: string) => Promise<void>;
     #registerApplicationResourceResolver: (id: string, resolver: AppResourceResolver) => Disposable;
     #registerWorkspaceResourceProvider: (id: string, resolver: WorkspaceResourceProvider) => Disposable;
@@ -41,19 +41,19 @@ export class InternalAzureResourceGroupsExtensionApi implements AzureHostExtensi
         return this.#appResourceTree;
     }
 
-    public get appResourceTreeView(): TreeView<AzExtTreeItem> {
+    public get appResourceTreeView(): TreeView<unknown> {
         return this.#appResourceTreeView;
     }
 
     public get workspaceResourceTree(): AzExtTreeDataProvider {
         return this.#workspaceResourceTree;
     }
 
-    public get workspaceResourceTreeView(): TreeView<AzExtTreeItem> {
+    public get workspaceResourceTreeView(): TreeView<unknown> {
         return this.#workspaceResourceTreeView;
     }
 
-    public get apiVersion(): string {
+    public get apiVersion(): '0.0.1' {
         return this.#apiVersion;
     }
 
@@ -83,7 +83,7 @@ export class InternalAzureResourceGroupsExtensionApi implements AzureHostExtensi
         return this.appResourceTree;
     }
 
-    public get treeView(): TreeView<AzExtTreeItem> {
+    public get treeView(): TreeView<unknown> {
         return this.appResourceTreeView;
     }
 

src/api/pickAppResource.ts

@@ -3,18 +3,43 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 
-import { AzExtTreeItem, ITreeItemPickerContext } from "@microsoft/vscode-azext-utils";
+import { AzExtResourceType, AzExtTreeItem, compatibilityPickAppResourceExperience, ContextValueFilter, getAzExtResourceType, ITreeItemPickerContext } from "@microsoft/vscode-azext-utils";
 import { PickAppResourceOptions } from "@microsoft/vscode-azext-utils/hostapi";
 import { ext } from "../extensionVariables";
-import { SubscriptionTreeItem } from "../tree/SubscriptionTreeItem";
 
 export async function pickAppResource<T extends AzExtTreeItem>(context: ITreeItemPickerContext, options?: PickAppResourceOptions): Promise<T> {
-    const subscription: SubscriptionTreeItem = await ext.appResourceTree.showTreeItemPicker(SubscriptionTreeItem.contextValue, context);
-    const appResource = await subscription.pickAppResource(context, options);
+    return await compatibilityPickAppResourceExperience<T>(context, ext.v2.api.applicationResourceTreeDataProvider, {
+        resourceTypes: convertAppResourceFilterToAzExtResourceType(options?.filter),
+        childItemFilter: convertExpectedChildContextValueToContextValueFilter(options?.expectedChildContextValue)
+    });
+}
+
+function convertExpectedChildContextValueToContextValueFilter(expectedChildContextValue?: PickAppResourceOptions['expectedChildContextValue']): ContextValueFilter | undefined {
+    return expectedChildContextValue ? { include: expectedChildContextValue } : undefined
+}
 
-    if (options?.expectedChildContextValue) {
-        return ext.appResourceTree.showTreeItemPicker(options.expectedChildContextValue, context, appResource);
-    } else {
-        return appResource as unknown as T;
+function convertAppResourceFilterToAzExtResourceType(filter?: PickAppResourceOptions['filter']): AzExtResourceType[] | undefined {
+    if (!filter) {
+        return undefined;
     }
+
+    filter = Array.isArray(filter) ? filter : [filter];
+
+    return filterMap(filter, getAzExtResourceType);
+}
+
+function filterMap<T, TMapped>(
+    source: T[],
+    predicateMapper: (item: T, index: number) => TMapped | null | undefined,
+): TMapped[] {
+    let index = 0;
+    return source.reduce<TMapped[]>((accumulator, current) => {
+        const mapped = predicateMapper(current, index++);
+        // handles null or undefined
+        // eslint-disable-next-line eqeqeq
+        if (mapped != null) {
+            accumulator.push(mapped);
+        }
+        return accumulator;
+    }, []);
 }

src/api/registerApplicationResourceResolver.ts

@@ -3,21 +3,28 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 
+import { AzExtResourceType, AzExtTreeItem } from "@microsoft/vscode-azext-utils";
 import { AppResourceResolver } from "@microsoft/vscode-azext-utils/hostapi";
 import { Disposable } from "vscode";
 import { ext } from "../extensionVariables";
+import { CompatibleApplicationResourceBranchDataProvider } from "./v2/compatibility/application/CompatibleApplicationResourceBranchDataProvider";
+import { ApplicationResource, BranchDataProvider } from "./v2/v2AzureResourcesApi";
 
 export const applicationResourceResolvers: Record<string, AppResourceResolver> = {};
 
-export function registerApplicationResourceResolver(id: string, resolver: AppResourceResolver): Disposable {
-    if (applicationResourceResolvers[id]) {
-        throw new Error(`Application resource resolver with id '${id}' has already been registered.`);
+export function registerApplicationResourceResolver(type: AzExtResourceType, resolver: AppResourceResolver): Disposable {
+    if (applicationResourceResolvers[type]) {
+        throw new Error(`Application resource resolver with id '${type}' has already been registered.`);
     }
 
-    applicationResourceResolvers[id] = resolver;
+    applicationResourceResolvers[type] = resolver;
     ext.emitters.onDidRegisterResolver.fire(resolver);
 
+    const compat = new CompatibleApplicationResourceBranchDataProvider(resolver, 'azureResourceGroups.loadMore' /** TODO: what is the correct value for this? */);
+
+    ext.v2.api.registerApplicationResourceBranchDataProvider(type, compat as unknown as BranchDataProvider<ApplicationResource, AzExtTreeItem>);
+
     return new Disposable(() => {
-        delete applicationResourceResolvers[id];
+        delete applicationResourceResolvers[type];
     });
 }

src/api/registerWorkspaceResourceProvider.ts

@@ -3,23 +3,31 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 
-import { callWithTelemetryAndErrorHandlingSync } from "@microsoft/vscode-azext-utils";
+import { AzExtTreeItem, callWithTelemetryAndErrorHandlingSync } from "@microsoft/vscode-azext-utils";
 import { WorkspaceResourceProvider } from "@microsoft/vscode-azext-utils/hostapi";
 import { Disposable } from "vscode";
 import { refreshWorkspace } from "../commands/workspace/refreshWorkspace";
+import { ext } from "../extensionVariables";
+import { CompatibilityWorkspaceResourceProvider } from "./v2/compatibility/workspace/CompatibilityWorkspaceResourceProvider";
+import { CompatibleWorkspaceResourceBranchDataProvider } from "./v2/compatibility/workspace/CompatibleWorkspaceResourceBranchDataProvider";
+import { BranchDataProvider, WorkspaceResource } from "./v2/v2AzureResourcesApi";
 
 export const workspaceResourceProviders: Record<string, WorkspaceResourceProvider> = {};
 
 export function registerWorkspaceResourceProvider(resourceType: string, provider: WorkspaceResourceProvider): Disposable {
     workspaceResourceProviders[resourceType] = provider;
 
-    return callWithTelemetryAndErrorHandlingSync('registerWorkspaceResourceProvider', (context) => {
+    return callWithTelemetryAndErrorHandlingSync('registerWorkspaceResourceProvider', () => {
 
-        void refreshWorkspace(context);
+        refreshWorkspace();
+
+        ext.v2.api.registerWorkspaceResourceProvider(new CompatibilityWorkspaceResourceProvider(resourceType, provider));
+        ext.v2.api.registerWorkspaceResourceBranchDataProvider(resourceType, new CompatibleWorkspaceResourceBranchDataProvider('azureWorkspace.loadMore') as unknown as BranchDataProvider<WorkspaceResource, AzExtTreeItem>)
 
         return new Disposable(() => {
             delete workspaceResourceProviders[resourceType];
-            void refreshWorkspace(context);
+            refreshWorkspace();
         });
     }) as Disposable;
 }
+

src/api/v2/compatibility/CompatibleAzExtTreeDataProvider.ts

@@ -0,0 +1,114 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AzExtParentTreeItem, AzExtTreeDataProvider, AzExtTreeItem, compatibilitySubscriptionExperience, contextValueExperience, findByIdExperience, IActionContext, IFindTreeItemContext, isWrapper, ITreeItemPickerContext } from "@microsoft/vscode-azext-utils";
+import { Disposable, Event, TreeItem, TreeView } from "vscode";
+import { SubscriptionTreeItem } from "../../../tree/SubscriptionTreeItem";
+import { ResourceGroupsItem } from "../../../tree/v2/ResourceGroupsItem";
+import { ResourceTreeDataProviderBase } from "../../../tree/v2/ResourceTreeDataProviderBase";
+
+/**
+ * An intermediate class that exists just to redeclare several events as abstract, so they
+ * can be re-redeclared as a accessors in {@link CompatibleAzExtTreeDataProvider} below
+ */
+abstract class IntermediateCompatibleAzExtTreeDataProvider extends AzExtTreeDataProvider {
+    public abstract onDidChangeTreeData: Event<AzExtTreeItem | undefined>;
+    public abstract onTreeItemCreate: Event<AzExtTreeItem>;
+    public abstract onDidExpandOrRefreshExpandedTreeItem: Event<AzExtTreeItem>;
+}
+
+export class CompatibleAzExtTreeDataProvider extends IntermediateCompatibleAzExtTreeDataProvider {
+    public constructor(private readonly tdp: ResourceTreeDataProviderBase) {
+        super({} as unknown as AzExtParentTreeItem, undefined as unknown as string);
+    }
+
+    public override getParent(treeItem: AzExtTreeItem): Promise<AzExtTreeItem | undefined> {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return this.tdp.getParent(treeItem);
+    }
+
+    public override getTreeItem(treeItem: AzExtTreeItem): TreeItem {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return this.tdp.getTreeItem(treeItem);
+    }
+
+    public override getChildren(_treeItem?: AzExtParentTreeItem): Promise<AzExtTreeItem[]> {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return this.tdp.getChildren(_treeItem);
+    }
+
+    public override async findTreeItem<T>(fullId: string, context: IFindTreeItemContext): Promise<T | undefined> {
+        // Special handling for subscription tree item
+        // Use the new finder experience
+        // Unbox the item at the end
+
+        const result = await findByIdExperience(context, this.tdp, fullId);
+        return isWrapper(result) ? result.unwrap<T>() : result as unknown as T;
+    }
+
+    public override showTreeItemPicker<T>(expectedContextValues: string | RegExp | (string | RegExp)[], context: ITreeItemPickerContext & { canPickMany: true }, startingTreeItem?: AzExtTreeItem): Promise<T[]>;
+    public override async showTreeItemPicker<T>(expectedContextValues: string | RegExp | (string | RegExp)[], context: ITreeItemPickerContext, _startingTreeItem?: AzExtTreeItem): Promise<T> {
+        if (expectedContextValues === SubscriptionTreeItem.contextValue) {
+            const result = await compatibilitySubscriptionExperience(context, this.tdp);
+            const subscription = isWrapper(result) ? result.unwrap<T>() : result as unknown as T;
+            return { subscription } as unknown as T;
+        }
+
+        // TODO: support startingTreeItem
+
+        const result = await contextValueExperience(context, this.tdp, {
+            include: expectedContextValues,
+        });
+
+        return isWrapper(result) ? result.unwrap<T>() : result as unknown as T;
+    }
+
+    public override refresh(_context: IActionContext, treeItem?: AzExtTreeItem | undefined): Promise<void> {
+
+        // Flush the cache at and below the given treeItem
+        // Trigger a refresh at the given treeItem
+        this.tdp.onDidChangeTreeDataEmitter.fire(treeItem as unknown as ResourceGroupsItem);
+
+        return Promise.resolve();
+    }
+
+    public override refreshUIOnly(treeItem: AzExtTreeItem | undefined): void {
+
+        this.tdp.onDidChangeTreeDataEmitter.fire(treeItem as unknown as ResourceGroupsItem);
+
+    }
+
+    public override loadMore(_treeItem: AzExtTreeItem, _context: IActionContext): Promise<void> {
+        // TODO: unknown how this will be implemented?
+        throw new Error('TODO: Implement this using the new load more approach');
+    }
+
+    //#region Things that should not be called
+    public override trackTreeItemCollapsibleState(_treeView: TreeView<AzExtTreeItem>): Disposable {
+        throw new ShouldNeverBeCalledError('trackTreeItemCollapsibleState method');
+    }
+
+    public get onDidChangeTreeData(): Event<AzExtTreeItem | undefined> {
+        throw new ShouldNeverBeCalledError('onDidChangeTreeData accessor');
+    }
+
+    public get onTreeItemCreate(): Event<AzExtTreeItem> {
+        throw new ShouldNeverBeCalledError('onTreeItemCreate accessor');
+    }
+
+    public get onDidExpandOrRefreshExpandedTreeItem(): Event<AzExtTreeItem> {
+        throw new ShouldNeverBeCalledError('onDidExpandOrRefreshExpandedTreeItem accessor');
+    }
+    //#endregion Things that should not be called
+}
+
+class ShouldNeverBeCalledError extends Error {
+    constructor(methodName: string) {
+        super(`${methodName} should never be called.`);
+    }
+}