Add Data Grid Provider API (#12097)

* Add RegisterResourceDataProvider API

* Change to data grid provider

* fixes

* updates

src/sql/azdata.proposed.d.ts

@@ -6,6 +6,7 @@
 // This is the place for API experiments and proposal.
 
 import * as vscode from 'vscode';
+import { DataProvider } from 'azdata';
 
 declare module 'azdata' {
 	/**
@@ -95,6 +96,61 @@ declare module 'azdata' {
 	export namespace dataprotocol {
 		export function registerSerializationProvider(provider: SerializationProvider): vscode.Disposable;
 		export function registerSqlAssessmentServicesProvider(provider: SqlAssessmentServicesProvider): vscode.Disposable;
+		/**
+		 * Registers a DataGridProvider which is used to provide lists of items to a data grid
+		 * @param provider The provider implementation
+		 */
+		export function registerDataGridProvider(provider: DataGridProvider): vscode.Disposable;
+	}
+
+	export enum DataProviderType {
+		DataGridProvider = 'DataGridProvider'
+	}
+
+	/**
+	 * A column in a data grid
+	 */
+	export interface DataGridColumn {
+		/**
+		* The text to display on the column heading.
+		**/
+		name: string;
+		/**
+		* The property name in the DataGridItem
+		**/
+		field: string;
+		/**
+		* A unique identifier for the column within the grid.
+		*/
+		id: string;
+	}
+
+	/**
+	 * An item for displaying in a data grid
+	 */
+	export interface DataGridItem {
+		/**
+		 * A unique identifier for this item
+		 */
+		id: string;
+		/**
+		 * The other properties that will be displayed in the grid
+		 */
+		[key: string]: string;
+	}
+
+	/**
+	 * A data provider that provides lists of resource items for a data grid
+	 */
+	export interface DataGridProvider extends DataProvider {
+		/**
+		 * Gets the list of data grid items for this provider
+		 */
+		getDataGridItems(): Thenable<DataGridItem[]>;
+		/**
+		 * Gets the list of data grid columns for this provider
+		 */
+		getDataGridColumns(): Thenable<DataGridColumn[]>;
 	}
 
 	export interface HyperlinkComponent {
@@ -532,5 +588,4 @@ declare module 'azdata' {
 		 */
 		delete?: boolean;
 	}
-
 }

src/sql/platform/telemetry/common/telemetryKeys.ts

@@ -25,6 +25,8 @@ export const CancelQuery = 'CancelQuery';
 export const NewQuery = 'NewQuery';
 export const FirewallRuleRequested = 'FirewallRuleCreated';
 export const DashboardNavigated = 'DashboardNavigated';
+export const GetDataGridItems = 'GetDataGridItems';
+export const GetDataGridColumns = 'GetDataGridColumns';
 
 // Telemetry Properties
 

src/sql/workbench/api/browser/mainThreadDataProtocol.ts

@@ -28,6 +28,7 @@ import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { assign } from 'vs/base/common/objects';
 import { serializableToMap } from 'sql/base/common/map';
 import { IAssessmentService } from 'sql/workbench/services/assessment/common/interfaces';
+import { IDataGridProviderService } from 'sql/workbench/services/dataGridProvider/common/dataGridProviderService';
 
 /**
  * Main thread class for handling data protocol management registration.
@@ -55,7 +56,8 @@ export class MainThreadDataProtocol extends Disposable implements MainThreadData
 		@IProfilerService private _profilerService: IProfilerService,
 		@ISerializationService private _serializationService: ISerializationService,
 		@IFileBrowserService private _fileBrowserService: IFileBrowserService,
-		@IAssessmentService private _assessmentService: IAssessmentService
+		@IAssessmentService private _assessmentService: IAssessmentService,
+		@IDataGridProviderService private _dataGridProviderService: IDataGridProviderService
 	) {
 		super();
 		if (extHostContext) {
@@ -466,6 +468,20 @@ export class MainThreadDataProtocol extends Disposable implements MainThreadData
 
 		return undefined;
 	}
+
+	public $registerDataGridProvider(providerId: string, handle: number): void {
+		const self = this;
+		this._dataGridProviderService.registerProvider(providerId, <azdata.DataGridProvider>{
+			providerId: providerId,
+			getDataGridItems(): Thenable<azdata.DataGridItem[]> {
+				return self._proxy.$getDataGridItems(handle);
+			},
+			getDataGridColumns(): Thenable<azdata.DataGridColumn[]> {
+				return self._proxy.$getDataGridColumns(handle);
+			}
+		});
+	}
+
 	public $registerCapabilitiesServiceProvider(providerId: string, handle: number): Promise<any> {
 		const self = this;
 		this._capabilitiesService.registerProvider(<azdata.CapabilitiesProvider>{

src/sql/workbench/api/common/extHostDataProtocol.ts

@@ -173,6 +173,11 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 		this._proxy.$registerSqlAssessmentServicesProvider(provider.providerId, provider.handle);
 		return rt;
 	}
+	$registerDataGridProvider(provider: azdata.DataGridProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider, DataProviderType.DataGridProvider);
+		this._proxy.$registerDataGridProvider(provider.providerId, provider.handle);
+		return rt;
+	}
 	$registerCapabilitiesServiceProvider(provider: azdata.CapabilitiesProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.CapabilitiesProvider);
 		this._proxy.$registerCapabilitiesServiceProvider(provider.providerId, provider.handle);
@@ -856,4 +861,12 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	public $generateAssessmentScript(handle: number, items: azdata.SqlAssessmentResultItem[]): Thenable<azdata.ResultStatus> {
 		return this._resolveProvider<azdata.SqlAssessmentServicesProvider>(handle).generateAssessmentScript(items);
 	}
+
+	public $getDataGridItems(handle: number): Thenable<azdata.DataGridItem[]> {
+		return this._resolveProvider<azdata.DataGridProvider>(handle).getDataGridItems();
+	}
+
+	public $getDataGridColumns(handle: number): Thenable<azdata.DataGridColumn[]> {
+		return this._resolveProvider<azdata.DataGridProvider>(handle).getDataGridColumns();
+	}
 }

src/sql/workbench/api/common/sqlExtHost.api.impl.ts

@@ -373,6 +373,10 @@ export function createAdsApiFactory(accessor: ServicesAccessor): IAdsExtensionAp
 				return extHostDataProvider.$registerSqlAssessmentServiceProvider(provider);
 			};
 
+			let registerDataGridProvider = (provider: azdata.DataGridProvider): vscode.Disposable => {
+				return extHostDataProvider.$registerDataGridProvider(provider);
+			};
+
 			// namespace: dataprotocol
 			const dataprotocol: typeof azdata.dataprotocol = {
 				registerBackupProvider,
@@ -392,6 +396,7 @@ export function createAdsApiFactory(accessor: ServicesAccessor): IAdsExtensionAp
 				registerCapabilitiesServiceProvider,
 				registerSerializationProvider,
 				registerSqlAssessmentServicesProvider,
+				registerDataGridProvider,
 				onDidChangeLanguageFlavor(listener: (e: azdata.DidChangeLanguageFlavorParams) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
 					return extHostDataProvider.onDidChangeLanguageFlavor(listener, thisArgs, disposables);
 				},

src/sql/workbench/api/common/sqlExtHost.protocol.ts

@@ -509,6 +509,16 @@ export abstract class ExtHostDataProtocolShape {
 	 * Generate an assessment script based on recent results
 	 */
 	$generateAssessmentScript(handle: number, items: azdata.SqlAssessmentResultItem[]): Thenable<azdata.ResultStatus> { throw ni(); }
+
+	/**
+	 * Gets the list of items for a data grid
+	 */
+	$getDataGridItems(handle: number): Thenable<azdata.DataGridItem[]> { throw ni(); }
+
+	/**
+	 * Gets the list of columns for a data grid
+	 */
+	$getDataGridColumns(handle: number): Thenable<azdata.DataGridColumn[]> { throw ni(); }
 }
 
 /**
@@ -573,6 +583,7 @@ export interface MainThreadDataProtocolShape extends IDisposable {
 	$registerAgentServicesProvider(providerId: string, handle: number): Promise<any>;
 	$registerSerializationProvider(providerId: string, handle: number): Promise<any>;
 	$registerSqlAssessmentServicesProvider(providerId: string, handle: number): Promise<any>;
+	$registerDataGridProvider(providerId: string, handle: number): void;
 	$unregisterProvider(handle: number): Promise<any>;
 	$onConnectionComplete(handle: number, connectionInfoSummary: azdata.ConnectionInfoSummary): void;
 	$onIntelliSenseCacheComplete(handle: number, connectionUri: string): void;

src/sql/workbench/api/common/sqlExtHostTypes.ts

@@ -354,7 +354,8 @@ export enum DataProviderType {
 	ObjectExplorerNodeProvider = 'ObjectExplorerNodeProvider',
 	SerializationProvider = 'SerializationProvider',
 	IconProvider = 'IconProvider',
-	SqlAssessmentServicesProvider = 'SqlAssessmentServicesProvider'
+	SqlAssessmentServicesProvider = 'SqlAssessmentServicesProvider',
+	DataGridProvider = 'DataGridProvider'
 }
 
 export enum DeclarativeDataType {

src/sql/workbench/services/dataGridProvider/browser/dataGridProviderService.ts

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdata from 'azdata';
+import { IAdsTelemetryService } from 'sql/platform/telemetry/common/telemetry';
+import { IDataGridProviderService } from 'sql/workbench/services/dataGridProvider/common/dataGridProviderService';
+import { invalidProvider } from 'sql/base/common/errors';
+import * as TelemetryKeys from 'sql/platform/telemetry/common/telemetryKeys';
+
+export class DataGridProviderService implements IDataGridProviderService {
+
+	public _serviceBrand: undefined;
+	private _providers = new Map<string, azdata.DataGridProvider>();
+
+	constructor(
+		@IAdsTelemetryService private _telemetryService: IAdsTelemetryService
+	) { }
+
+	/**
+	 * Register a data grid provider
+	 */
+	public registerProvider(providerId: string, provider: azdata.DataGridProvider): void {
+		if (this._providers.has(providerId)) {
+			throw new Error(`A DataGridProvider with id "${providerId}" is already registered`);
+		}
+		this._providers.set(providerId, provider);
+	}
+
+	public unregisterProvider(providerId: string): void {
+		this._providers.delete(providerId);
+	}
+
+	public async getDataGridItems(providerId: string): Promise<azdata.DataGridItem[]> {
+		const provider = this._providers.get(providerId);
+		if (provider) {
+			this._telemetryService.createActionEvent(TelemetryKeys.TelemetryView.Shell, TelemetryKeys.GetDataGridItems)
+				.withAdditionalProperties({
+					provider: providerId
+				}).send();
+			return provider.getDataGridItems();
+		}
+		throw invalidProvider(providerId);
+	}
+
+	public async getDataGridColumns(providerId: string): Promise<azdata.DataGridColumn[]> {
+		const provider = this._providers.get(providerId);
+		if (provider) {
+			this._telemetryService.createActionEvent(TelemetryKeys.TelemetryView.Shell, TelemetryKeys.GetDataGridColumns)
+				.withAdditionalProperties({
+					provider: providerId
+				}).send();
+			return provider.getDataGridColumns();
+		}
+		throw invalidProvider(providerId);
+	}
+}

src/sql/workbench/services/dataGridProvider/common/dataGridProviderService.ts

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azdata from 'azdata';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+
+export const SERVICE_ID = 'dataGridProviderService';
+export const IDataGridProviderService = createDecorator<IDataGridProviderService>(SERVICE_ID);
+
+export interface IDataGridProviderService {
+	_serviceBrand: undefined;
+
+	/**
+	 * Register a data grid provider
+	 */
+	registerProvider(providerId: string, provider: azdata.DataGridProvider): void;
+
+	/**
+	 * Unregister a resource data provider
+	 */
+	unregisterProvider(providerId: string): void;
+
+	/**
+	 * Gets a list of data grid items from the specified provider
+	 */
+	getDataGridItems(providerId: string): Promise<azdata.DataGridItem[]>;
+
+	/**
+	* Gets a list of data grid columns from the specified provider
+	*/
+	getDataGridColumns(providerId: string): Promise<azdata.DataGridColumn[]>;
+}