Start implementation of compat shim

src/api/registerApplicationResourceResolver.ts

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

src/api/registerWorkspaceResourceProvider.ts

@@ -3,23 +3,35 @@
 *  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 { BranchDataProvider, WorkspaceResource } from "@microsoft/vscode-azext-utils/hostapi.v2";
 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";
 
 export const workspaceResourceProviders: Record<string, WorkspaceResourceProvider> = {};
 
 export function registerWorkspaceResourceProvider(resourceType: string, provider: WorkspaceResourceProvider): Disposable {
     workspaceResourceProviders[resourceType] = provider;
 
-    return callWithTelemetryAndErrorHandlingSync('registerWorkspaceResourceProvider', (context) => {
+    return callWithTelemetryAndErrorHandlingSync('registerWorkspaceResourceProvider', () => {
+        const disposables: Disposable[] = [];
 
-        void refreshWorkspace(context);
+        refreshWorkspace();
+
+        disposables.push(ext.v2.api.registerWorkspaceResourceProvider(new CompatibilityWorkspaceResourceProvider(resourceType, provider)));
+        disposables.push(ext.v2.api.registerWorkspaceResourceBranchDataProvider(resourceType, new CompatibleWorkspaceResourceBranchDataProvider('azureWorkspace.loadMore') as unknown as BranchDataProvider<WorkspaceResource, AzExtTreeItem>));
 
         return new Disposable(() => {
+            for (const disposable of disposables) {
+                disposable.dispose();
+            }
             delete workspaceResourceProviders[resourceType];
-            void refreshWorkspace(context);
+            refreshWorkspace();
         });
     }) as Disposable;
 }
+

src/api/v2/compatibility/CompatibleBranchDataProviderBase.ts

@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------------------------
+*  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, IFindTreeItemContext, ITreeItemPickerContext } from "@microsoft/vscode-azext-utils";
+import { BranchDataProvider, ResourceBase, ResourceModelBase } from "@microsoft/vscode-azext-utils/hostapi.v2";
+import * as vscode from 'vscode';
+
+export abstract class CompatibleBranchDataProviderBase<TResource extends ResourceBase, TModel extends AzExtTreeItem & ResourceModelBase> extends AzExtTreeDataProvider implements BranchDataProvider<TResource, TModel>, vscode.Disposable {
+    protected readonly overrideOnDidChangeTreeDataEmitter = new vscode.EventEmitter<TModel | undefined>();
+
+    public constructor(loadMoreCommandId: string) {
+        // Using `{}` here so property assignment doesn't throw
+        super({} as unknown as AzExtParentTreeItem, loadMoreCommandId);
+    }
+
+    abstract getResourceItem(element: TResource): TModel | Thenable<TModel>;
+
+    //#region TreeDataProvider
+
+    // @ts-expect-error overriding a property with an accessor
+    public override get onDidChangeTreeData(): vscode.Event<TModel | undefined> {
+        return this.overrideOnDidChangeTreeDataEmitter.event;
+    }
+
+    public override set onDidChangeTreeData(_: vscode.Event<TModel | undefined>) {
+        // Do nothing
+    }
+
+    public override getParent(_treeItem: TModel): Promise<TModel> {
+        throw new Error('Use the Resources extension API to do getParent');
+    }
+
+    public override async getChildren(treeItem: TModel & AzExtParentTreeItem): Promise<TModel[]> {
+        // This method is redeclared to make TypeScript happier, but it's no more than a super call with extra casts
+        return super.getChildren(treeItem) as Promise<TModel[]>;
+    }
+
+    //#endregion
+
+    //#region AzExtTreeDataProvider
+
+    public override refreshUIOnly(treeItem?: TModel): void {
+        // Override the default behavior to remain scoped to specific elements, like it ought
+        // And also, use overrideOnDidChangeTreeDataEmitter
+        this.overrideOnDidChangeTreeDataEmitter.fire(treeItem);
+    }
+
+    public override async showTreeItemPicker<T extends AzExtTreeItem>(expectedContextValues: string | RegExp | (string | RegExp)[], context: ITreeItemPickerContext & { canPickMany: true; }, startingTreeItem?: AzExtTreeItem): Promise<T[]>;
+    public override async showTreeItemPicker<T extends AzExtTreeItem>(_expectedContextValues: string | RegExp | (string | RegExp)[], _context: ITreeItemPickerContext, _startingTreeItem?: AzExtTreeItem): Promise<T> {
+        throw new Error('Use the Resources extension API to do showTreeItemPicker');
+    }
+
+    public override async findTreeItem<T extends AzExtTreeItem>(_fullId: string, _context: IFindTreeItemContext): Promise<T | undefined> {
+        throw new Error('Use the Resources extension API to do findTreeItem');
+    }
+
+    // TODO: this (probably?) shouldn't remain in the code we release, but will be helpful in testing to ensure we never access the root
+    // @ts-expect-error TypeScript is unhappy that we're overriding something that it doesn't know is secretly on the base class
+    private override get _rootTreeItem(): AzExtParentTreeItem {
+        throw new Error('The root tree item should not be accessed in a BranchDataProvider');
+    }
+
+    // This is assigned to in the constructor of AzExtTreeDataProvider
+    // @ts-expect-error TypeScript is unhappy that we're overriding something that it doesn't know is secretly on the base class
+    private override set _rootTreeItem(_value: AzExtParentTreeItem) {
+        // Do nothing!
+    }
+
+    //#endregion AzExtTreeDataProvider
+
+    public dispose(): void {
+        super.dispose();
+        this.overrideOnDidChangeTreeDataEmitter.dispose();
+    }
+}

src/api/v2/compatibility/application/CompatibleApplicationResourceBranchDataProvider.ts

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AzExtTreeItem, ISubscriptionContext } from '@microsoft/vscode-azext-utils';
+import type { AppResource, AppResourceResolver } from '@microsoft/vscode-azext-utils/hostapi';
+import type { AzureResource, ResourceModelBase } from '@microsoft/vscode-azext-utils/hostapi.v2';
+import { createSubscriptionContext } from '../../../../utils/v2/credentialsUtils';
+import { CompatibleBranchDataProviderBase } from '../CompatibleBranchDataProviderBase';
+import { CompatibleResolvedApplicationResourceTreeItem } from './CompatibleApplicationResourceTreeItem';
+
+/**
+ * Provides compatibility between an `AppResourceResolver` (v1) and a `BranchDataProvider` (v2)
+ */
+export class CompatibleApplicationResourceBranchDataProvider<TResource extends AzureResource, TModel extends AzExtTreeItem & ResourceModelBase> extends CompatibleBranchDataProviderBase<TResource, TModel> {
+    public constructor(private readonly resolver: AppResourceResolver, loadMoreCommandId: string) {
+        super(loadMoreCommandId);
+    }
+
+    public async getResourceItem(element: TResource): Promise<TModel> {
+        const oldAppResource: AppResource = {
+            ...element,
+            type: element.azureResourceType.type,
+            kind: element.azureResourceType.kinds?.join(';'),
+        };
+        const subscriptionContext: ISubscriptionContext = createSubscriptionContext(element.subscription);
+
+        const resolved = await this.resolver.resolveResource(subscriptionContext, oldAppResource);
+        const result = CompatibleResolvedApplicationResourceTreeItem.Create(element, resolved!, subscriptionContext, this, element) as unknown as TModel;
+        Object.defineProperty(result, 'fullId', {
+            get: () => {
+                return element.id;
+            }
+        });
+
+        return result;
+    }
+}

src/api/v2/compatibility/application/CompatibleApplicationResourceTreeItem.ts

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AzExtParentTreeItem, AzExtResourceType, AzExtTreeDataProvider, AzExtTreeItem, IActionContext, ISubscriptionContext, nonNullProp, TreeItemIconPath } from "@microsoft/vscode-azext-utils";
+import type { ResolvedAppResourceBase } from "@microsoft/vscode-azext-utils/hostapi";
+import { AzureResource } from "@microsoft/vscode-azext-utils/hostapi.v2";
+import { TreeItemCollapsibleState } from "vscode";
+import { createResolvableProxy } from "../../../../tree/AppResourceTreeItem";
+import { getIconPath } from "../../../../utils/azureUtils";
+
+/**
+ * Must imitate the behavior of ResolvedAppResourceBase
+ */
+export class CompatibleResolvedApplicationResourceTreeItem extends AzExtParentTreeItem {
+    public static contextValue: string = 'azureResource';
+    protected readonly contextValues: Set<string> = new Set<string>();
+    public get contextValue(): string {
+        return Array.from(this.contextValues.values()).sort().join(';');
+    }
+
+    // override
+    public get effectiveId(): string | undefined {
+        return undefined;
+    }
+
+    public valuesToMask: string[] = [];
+
+    public readonly resolveResult: ResolvedAppResourceBase;
+    public data: AzureResource;
+    public readonly azExtResourceType: AzExtResourceType;
+
+    public readonly cTime: number = Date.now();
+    public mTime: number = Date.now();
+    public tags?: { [propertyName: string]: string; } | undefined;
+
+    public get id(): string | undefined {
+        return undefined;
+    }
+
+    public get label(): string {
+        return nonNullProp(this.data, 'name');
+    }
+
+    public get iconPath(): TreeItemIconPath {
+        return getIconPath(this.data.resourceType);
+    }
+
+    public get description(): string | undefined {
+        return this.resolveResult?.description;
+    }
+
+    public get collapsibleState(): TreeItemCollapsibleState | undefined {
+        return this.resolveResult?.initialCollapsibleState ?? !!this.resolveResult?.loadMoreChildrenImpl ? TreeItemCollapsibleState.Collapsed : TreeItemCollapsibleState.None;
+    }
+
+    public static Create(resource: AzureResource, resolveResult: ResolvedAppResourceBase, subscription: ISubscriptionContext, treeDataProvider: AzExtTreeDataProvider, azureResource: AzureResource): CompatibleResolvedApplicationResourceTreeItem {
+        const resolvable: CompatibleResolvedApplicationResourceTreeItem = new CompatibleResolvedApplicationResourceTreeItem(resource, resolveResult, subscription, treeDataProvider, azureResource);
+        return createResolvableProxy(resolvable);
+    }
+
+    public readonly resource: AzureResource;
+
+    private constructor(resource: AzureResource, resolved: ResolvedAppResourceBase, __subscription: ISubscriptionContext, __treeDataProvider: AzExtTreeDataProvider, azureResource: AzureResource) {
+        super(
+            (<Partial<AzExtParentTreeItem>>{
+                treeDataProvider: __treeDataProvider,
+                valuesToMask: [],
+                subscription: __subscription,
+                parent: undefined,
+                removeChildFromCache: () => {
+                    //
+                },
+            }) as unknown as AzExtParentTreeItem
+        );
+
+        this.resource = azureResource;
+        this.resolveResult = resolved;
+        this.data = resource;
+        this.tags = resource.tags;
+
+        this.contextValues.add(CompatibleResolvedApplicationResourceTreeItem.contextValue);
+        if (azureResource.resourceType) {
+            this.contextValues.add(azureResource.resourceType);
+        }
+        resolved.contextValuesToAdd?.forEach((value: string) => this.contextValues.add(value));
+    }
+
+    public async loadMoreChildrenImpl(clearCache: boolean, context: IActionContext): Promise<AzExtTreeItem[]> {
+        if (this.resolveResult?.loadMoreChildrenImpl) {
+            // this is actually calling resolveResult.loadMoreChildrenImpl through the Proxy so that the function has the correct thisArg
+            return await this.loadMoreChildrenImpl(clearCache, context);
+        } else {
+            return [];
+        }
+    }
+
+    public hasMoreChildrenImpl(): boolean {
+        return false;
+    }
+
+    public async refreshImpl(): Promise<void> {
+        this.mTime = Date.now();
+    }
+}
+
+

src/api/v2/compatibility/workspace/CompatibilityWorkspaceResourceProvider.ts

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+
+import { AzExtParentTreeItem, AzExtTreeItem } from "@microsoft/vscode-azext-utils";
+import { WorkspaceResourceProvider } from "@microsoft/vscode-azext-utils/hostapi";
+import { WorkspaceResource, WorkspaceResourceProvider as V2WorkspaceResourceProvider } from "@microsoft/vscode-azext-utils/hostapi.v2";
+import { Event, WorkspaceFolder } from "vscode";
+import { CompatibleWorkspaceResourceBranchDataProvider } from "./CompatibleWorkspaceResourceBranchDataProvider";
+
+export class CompatibilityWorkspaceResourceProvider implements V2WorkspaceResourceProvider {
+    constructor(private readonly resourceType: string, private readonly provider: WorkspaceResourceProvider) { }
+
+    // No comparable mechanism in v1, leave as undefined
+    onDidChangeResource?: Event<WorkspaceResource | undefined> = undefined;
+
+    public async getResources(source: WorkspaceFolder): Promise<WorkspaceResource[]> {
+
+        const resources = await this.provider.provideResources(
+            // pass in stub parent
+            {
+                treeDataProvider: new CompatibleWorkspaceResourceBranchDataProvider('azureWorkspace.loadMore'),
+                valuesToMask: [],
+                parent: undefined,
+            } as unknown as AzExtParentTreeItem
+        );
+
+        if (resources) {
+            return resources.map((resource) => {
+                return Object.assign<AzExtTreeItem, WorkspaceResource>(resource,
+                    {
+                        // omit id because it's already in the treeItem
+                        folder: source,
+                        resourceType: this.resourceType,
+                        name: resource.label,
+                    } as WorkspaceResource
+                );
+            });
+        }
+
+        return [];
+    }
+}

src/api/v2/compatibility/workspace/CompatibleWorkspaceResourceBranchDataProvider.ts

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { WorkspaceResource } from '@microsoft/vscode-azext-utils/hostapi';
+import type { WorkspaceResource as v2WorkspaceResource } from '@microsoft/vscode-azext-utils/hostapi.v2';
+import { CompatibleBranchDataProviderBase } from '../CompatibleBranchDataProviderBase';
+
+export class CompatibleWorkspaceResourceBranchDataProvider<TResource extends WorkspaceResource & v2WorkspaceResource> extends CompatibleBranchDataProviderBase<TResource, TResource> {
+    public async getResourceItem(element: TResource): Promise<TResource> {
+        return element;
+    }
+}