Refact/idea lastknown (#501)

* close

* connection is working

* formatting

* adds all

* formatting

* removed unneeded logging

* readd npm shrinkwrap

* addressed comments

* fix capabilities cacheing

* updated shrinkwrap

* fixed tests

* remove dead code

* vbump sqltools

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

@@ -20,7 +20,7 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	private _proxy: MainThreadDataProtocolShape;
 
 	private static _handlePool: number = 0;
-	private _adapter = new Map<number, data.DataProtocolProvider>();
+	private _adapter = new Map<number, data.DataProvider>();
 
 	constructor(
 		threadService: IThreadService
@@ -40,71 +40,121 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 		return ExtHostDataProtocol._handlePool++;
 	}
 
-	private _runWithProvider<T>(handle: number, action: (p: data.DataProtocolProvider) => Thenable<T>): Thenable<T> {
-		let provider = this._adapter.get(handle);
-		return provider !== undefined
-			? action(provider)
-			: undefined;
+	private _resolveProvider<P extends data.DataProvider>(handle: number): P {
+		let provider = this._adapter.get(handle) as P;
+		if (provider) {
+			return provider;
+		} else {
+			throw new Error(`Unfound provider ${handle}`);
+		}
 	}
 
-
-	$registerProvider(provider: data.DataProtocolProvider): vscode.Disposable {
+	private registerProvider(provider: data.DataProvider): vscode.Disposable {
 		provider.handle = this._nextHandle();
 		this._adapter.set(provider.handle, provider);
-
-		this._proxy.$registerProvider(provider.providerId, provider.handle);
 		return this._createDisposable(provider.handle);
+	};
+
+	$registerConnectionProvider(provider: data.ConnectionProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerConnectionProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerBackupProvider(provider: data.BackupProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerBackupProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerRestoreProvider(provider: data.RestoreProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerRestoreProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerScriptingProvider(provider: data.ScriptingProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerScriptingProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerQueryProvider(provider: data.QueryProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerQueryProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerMetadataProvider(provider: data.MetadataProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerMetadataProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerTaskServicesProvider(provider: data.TaskServicesProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerTaskServicesProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerFileBrowserProvider(provider: data.FileBrowserProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerFileBrowserProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerObjectExplorerProvider(provider: data.ObjectExplorerProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerObjectExplorerProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerProfilerProvider(provider: data.ProfilerProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerProfilerProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerAdminServicesProvider(provider: data.AdminServicesProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerAdminServicesProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
+	$registerCapabilitiesServiceProvider(provider: data.CapabilitiesProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider);
+		this._proxy.$registerCapabilitiesServiceProvider(provider.providerId, provider.handle);
+		return rt;
 	}
 
 	// Capabilities Discovery handlers
 	$getServerCapabilities(handle: number, client: data.DataProtocolClientCapabilities): Thenable<data.DataProtocolServerCapabilities> {
-		return this._runWithProvider(handle, provider => {
-			return provider.capabilitiesProvider ? provider.capabilitiesProvider.getServerCapabilities(client)
-				: undefined;
-		});
+		return this._resolveProvider<data.CapabilitiesProvider>(handle).getServerCapabilities(client);
 	}
 
 	// Connection Management handlers
 	$connect(handle: number, connectionUri: string, connection: data.ConnectionInfo): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.connectionProvider ? provider.connectionProvider.connect(connectionUri, connection)
-				: undefined;
-		});
+		return this._resolveProvider<data.ConnectionProvider>(handle).connect(connectionUri, connection);
 	}
 
 	$disconnect(handle: number, connectionUri: string): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.connectionProvider ? provider.connectionProvider.disconnect(connectionUri)
-				: undefined;
-		});
+		return this._resolveProvider<data.ConnectionProvider>(handle).disconnect(connectionUri);
 	}
 
 	$cancelConnect(handle: number, connectionUri: string): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.connectionProvider ? provider.connectionProvider.cancelConnect(connectionUri)
-				: undefined;
-		});
+		return this._resolveProvider<data.ConnectionProvider>(handle).cancelConnect(connectionUri);
 	}
 
 	$changeDatabase(handle: number, connectionUri: string, newDatabase: string): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.connectionProvider ? provider.connectionProvider.changeDatabase(connectionUri, newDatabase)
-				: undefined;
-		});
+		return this._resolveProvider<data.ConnectionProvider>(handle).changeDatabase(connectionUri, newDatabase);
 	}
 
 	$listDatabases(handle: number, connectionUri: string): Thenable<data.ListDatabasesResult> {
-		return this._runWithProvider(handle, provider => {
-			return provider.connectionProvider ? provider.connectionProvider.listDatabases(connectionUri)
-				: undefined;
-		});
+		return this._resolveProvider<data.ConnectionProvider>(handle).listDatabases(connectionUri);
 	}
 
 	$rebuildIntelliSenseCache(handle: number, connectionUri: string): Thenable<void> {
-		return this._runWithProvider(handle, provider => {
-			return provider.connectionProvider ? provider.connectionProvider.rebuildIntelliSenseCache(connectionUri)
-				: undefined;
-		});
+		return this._resolveProvider<data.ConnectionProvider>(handle).rebuildIntelliSenseCache(connectionUri);
 	}
 
 	$onConnectComplete(handle: number, connectionInfoSummary: data.ConnectionInfoSummary): void {
@@ -127,45 +177,31 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	// Query Management handlers
 
 	$cancelQuery(handle: number, ownerUri: string): Thenable<data.QueryCancelResult> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.cancelQuery(ownerUri);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).cancelQuery(ownerUri);
 	}
 
 	$runQuery(handle: number, ownerUri: string, selection: data.ISelectionData, runOptions?: data.ExecutionPlanOptions): Thenable<void> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.runQuery(ownerUri, selection, runOptions);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).runQuery(ownerUri, selection, runOptions);
 	}
 
 	$runQueryStatement(handle: number, ownerUri: string, line: number, column: number): Thenable<void> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.runQueryStatement(ownerUri, line, column);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).runQueryStatement(ownerUri, line, column);
 	}
 
 	$runQueryString(handle: number, ownerUri: string, queryString: string): Thenable<void> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.runQueryString(ownerUri, queryString);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).runQueryString(ownerUri, queryString);
 	}
 
 	$runQueryAndReturn(handle: number, ownerUri: string, queryString: string): Thenable<data.SimpleExecuteResult> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.runQueryAndReturn(ownerUri, queryString);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).runQueryAndReturn(ownerUri, queryString);
 	}
 
 	$getQueryRows(handle: number, rowData: data.QueryExecuteSubsetParams): Thenable<data.QueryExecuteSubsetResult> {
-		return this._runWithProvider(handle, (provider) => {
-			return provider.queryProvider.getQueryRows(rowData);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).getQueryRows(rowData);
 	}
 
 	$disposeQuery(handle: number, ownerUri: string): Thenable<void> {
-		return this._runWithProvider(handle, (provider) => {
-			return provider.queryProvider.disposeQuery(ownerUri);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).disposeQuery(ownerUri);
 	}
 
 	$onQueryComplete(handle: number, result: data.QueryExecuteCompleteNotificationResult): void {
@@ -185,64 +221,44 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	}
 
 	$saveResults(handle: number, requestParams: data.SaveResultsRequestParams): Thenable<data.SaveResultRequestResult> {
-		return this._runWithProvider(handle, (provider) => {
-			return provider.queryProvider.saveResults(requestParams);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).saveResults(requestParams);
 	}
 
 	// Edit Data handlers
 	$commitEdit(handle: number, ownerUri: string): Thenable<void> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.commitEdit(ownerUri);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).commitEdit(ownerUri);
 	}
 
 	$createRow(handle: number, ownerUri: string): Thenable<data.EditCreateRowResult> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.createRow(ownerUri);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).createRow(ownerUri);
 	}
 
 	$deleteRow(handle: number, ownerUri: string, rowId: number): Thenable<void> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.deleteRow(ownerUri, rowId);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).deleteRow(ownerUri, rowId);
 	}
 
 	$disposeEdit(handle: number, ownerUri: string): Thenable<void> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.disposeEdit(ownerUri);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).disposeEdit(ownerUri);
 	}
 
 	$initializeEdit(handle: number, ownerUri: string, schemaName: string, objectName: string, objectType: string, rowLimit: number): Thenable<void> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.initializeEdit(ownerUri, schemaName, objectName, objectType, rowLimit);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).initializeEdit(ownerUri, schemaName, objectName, objectType, rowLimit);
 	}
 
 	$revertCell(handle: number, ownerUri: string, rowId: number, columnId: number): Thenable<data.EditRevertCellResult> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.revertCell(ownerUri, rowId, columnId);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).revertCell(ownerUri, rowId, columnId);
 	}
 
 	$revertRow(handle: number, ownerUri: string, rowId: number): Thenable<void> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.revertRow(ownerUri, rowId);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).revertRow(ownerUri, rowId);
 	}
 
 	$updateCell(handle: number, ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<data.EditUpdateCellResult> {
-		return this._runWithProvider(handle, provider => {
-			return provider.queryProvider.updateCell(ownerUri, rowId, columnId, newValue);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).updateCell(ownerUri, rowId, columnId, newValue);
 	}
 
 	$getEditRows(handle: number, rowData: data.EditSubsetParams): Thenable<data.EditSubsetResult> {
-		return this._runWithProvider(handle, (provider) => {
-			return provider.queryProvider.getEditRows(rowData);
-		});
+		return this._resolveProvider<data.QueryProvider>(handle).getEditRows(rowData);
 	}
 
 	$onEditSessionReady(handle: number, ownerUri: string, success: boolean, message: string): void {
@@ -251,39 +267,36 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 
 	// Metadata handlers
 	public $getMetadata(handle: number, connectionUri: string): Thenable<data.ProviderMetadata> {
-		return this._runWithProvider(handle, provider => {
-			return provider.metadataProvider ? provider.metadataProvider.getMetadata(connectionUri)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.MetadataProvider>(handle).getMetadata(connectionUri);
+	}
+
+	public $getDatabases(handle: number, connectionUri: string): Thenable<string[]> {
+		return this._resolveProvider<data.MetadataProvider>(handle).getDatabases(connectionUri);
+	}
+
+	public $getTableInfo(handle: number, connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
+		return this._resolveProvider<data.MetadataProvider>(handle).getTableInfo(connectionUri, metadata);
+	}
+
+	public $getViewInfo(handle: number, connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
+		return this._resolveProvider<data.MetadataProvider>(handle).getViewInfo(connectionUri, metadata);
 	}
 
 	// Object Explorer Service
 	public $createObjectExplorerSession(handle: number, connInfo: data.ConnectionInfo): Thenable<data.ObjectExplorerSessionResponse> {
-		return this._runWithProvider(handle, provider => {
-			return provider.objectExplorerProvider ? provider.objectExplorerProvider.createNewSession(connInfo)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.ObjectExplorerProvider>(handle).createNewSession(connInfo);
 	}
 
 	public $expandObjectExplorerNode(handle: number, nodeInfo: data.ExpandNodeInfo): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.objectExplorerProvider ? provider.objectExplorerProvider.expandNode(nodeInfo)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.ObjectExplorerProvider>(handle).expandNode(nodeInfo);
 	}
 
 	public $refreshObjectExplorerNode(handle: number, nodeInfo: data.ExpandNodeInfo): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.objectExplorerProvider ? provider.objectExplorerProvider.refreshNode(nodeInfo)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.ObjectExplorerProvider>(handle).refreshNode(nodeInfo);
 	}
 
 	public $closeObjectExplorerSession(handle: number, closeSessionInfo: data.ObjectExplorerCloseSessionInfo): Thenable<data.ObjectExplorerCloseSessionResponse> {
-		return this._runWithProvider(handle, provider => {
-			return provider.objectExplorerProvider ? provider.objectExplorerProvider.closeSession(closeSessionInfo)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.ObjectExplorerProvider>(handle).closeSession(closeSessionInfo);
 	}
 
 	public $onObjectExplorerSessionCreated(handle: number, response: data.ObjectExplorerSession): void {
@@ -296,17 +309,11 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 
 	// Task Service
 	public $getAllTasks(handle: number, listTasksParams: data.ListTasksParams): Thenable<data.ListTasksResponse> {
-		return this._runWithProvider(handle, provider => {
-			return provider.taskServicesProvider ? provider.taskServicesProvider.getAllTasks(listTasksParams)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.TaskServicesProvider>(handle).getAllTasks(listTasksParams);
 	}
 
 	public $cancelTask(handle: number, cancelTaskParams: data.CancelTaskParams): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.taskServicesProvider ? provider.taskServicesProvider.cancelTask(cancelTaskParams)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.TaskServicesProvider>(handle).cancelTask(cancelTaskParams);
 	}
 
 	public $onTaskStatusChanged(handle: number, response: data.TaskProgressInfo): void {
@@ -317,34 +324,10 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 		this._proxy.$onTaskCreated(handle, response);
 	}
 
-	public $getDatabases(handle: number, connectionUri: string): Thenable<string[]> {
-		return this._runWithProvider(handle, provider => {
-			return provider.metadataProvider ? provider.metadataProvider.getDatabases(connectionUri)
-				: Promise.resolve(undefined);
-		});
-	}
-
-	public $getTableInfo(handle: number, connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
-		return this._runWithProvider(handle, provider => {
-			return provider.metadataProvider ? provider.metadataProvider.getTableInfo(connectionUri, metadata)
-				: Promise.resolve(undefined);
-		});
-	}
-
-	public $getViewInfo(handle: number, connectionUri: string, metadata: data.ObjectMetadata): Thenable<data.ColumnMetadata[]> {
-		return this._runWithProvider(handle, provider => {
-			return provider.metadataProvider ? provider.metadataProvider.getViewInfo(connectionUri, metadata)
-				: Promise.resolve(undefined);
-		});
-	}
-
 	// Scripting handlers
 
 	public $scriptAsOperation(handle: number, connectionUri: string, operation: data.ScriptOperation, metadata: data.ObjectMetadata, paramDetails: data.ScriptingParamDetails): Thenable<data.ScriptingResult> {
-		return this._runWithProvider(handle, provider => {
-			return provider.scriptingProvider ? provider.scriptingProvider.scriptAsOperation(connectionUri, operation, metadata, paramDetails)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.ScriptingProvider>(handle).scriptAsOperation(connectionUri, operation, metadata, paramDetails);
 	}
 
 	public $onScriptingComplete(handle: number, scriptingCompleteResult: data.ScriptingCompleteResult): void {
@@ -355,110 +338,77 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	 * Create a new database on the provided connection
 	 */
 	public $createDatabase(handle: number, connectionUri: string, database: data.DatabaseInfo): Thenable<data.CreateDatabaseResponse> {
-		return this._runWithProvider(handle, provider => {
-			return provider.adminServicesProvider ? provider.adminServicesProvider.createDatabase(connectionUri, database)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.AdminServicesProvider>(handle).createDatabase(connectionUri, database);
 	}
 
 	/**
 	 * Create a new database on the provided connection
 	 */
 	public $getDefaultDatabaseInfo(handle: number, connectionUri: string): Thenable<data.DatabaseInfo> {
-		return this._runWithProvider(handle, provider => {
-			return provider.adminServicesProvider ? provider.adminServicesProvider.getDefaultDatabaseInfo(connectionUri)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.AdminServicesProvider>(handle).getDefaultDatabaseInfo(connectionUri);
 	}
 
 	/**
 	 * Get the info on a database
 	 */
 	public $getDatabaseInfo(handle: number, connectionUri: string): Thenable<data.DatabaseInfo> {
-		return this._runWithProvider(handle, provider => {
-			return provider.adminServicesProvider ? provider.adminServicesProvider.getDatabaseInfo(connectionUri)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.AdminServicesProvider>(handle).getDatabaseInfo(connectionUri);
 	}
 
 	/**
 	 * Create a new login on the provided connection
 	 */
 	public $createLogin(handle: number, connectionUri: string, login: data.LoginInfo): Thenable<data.CreateLoginResponse> {
-		return this._runWithProvider(handle, provider => {
-			return provider.adminServicesProvider ? provider.adminServicesProvider.createLogin(connectionUri, login)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.AdminServicesProvider>(handle).createLogin(connectionUri, login);
 	}
 
 	/**
 	 * Backup a database
 	 */
 	public $backup(handle: number, connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: data.TaskExecutionMode): Thenable<data.BackupResponse> {
-		return this._runWithProvider(handle, provider => {
-			return provider.disasterRecoveryProvider ? provider.disasterRecoveryProvider.backup(connectionUri, backupInfo, taskExecutionMode)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.BackupProvider>(handle).backup(connectionUri, backupInfo, taskExecutionMode);
 	}
 
 	/**
 	* Create a new database on the provided connection
 	*/
 	public $getBackupConfigInfo(handle: number, connectionUri: string): Thenable<data.BackupConfigInfo> {
-		return this._runWithProvider(handle, provider => {
-			return provider.disasterRecoveryProvider ? provider.disasterRecoveryProvider.getBackupConfigInfo(connectionUri)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.BackupProvider>(handle).getBackupConfigInfo(connectionUri);
 	}
 
 	/**
 	 * Restores a database
 	 */
 	public $restore(handle: number, connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse> {
-		return this._runWithProvider(handle, provider => {
-			return provider.disasterRecoveryProvider ? provider.disasterRecoveryProvider.restore(connectionUri, restoreInfo)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.RestoreProvider>(handle).restore(connectionUri, restoreInfo);
 	}
 
 	/**
 	 * Gets a plan for restoring a database
 	 */
 	public $getRestorePlan(handle: number, connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse> {
-		return this._runWithProvider(handle, provider => {
-			return provider.disasterRecoveryProvider ? provider.disasterRecoveryProvider.getRestorePlan(connectionUri, restoreInfo)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.RestoreProvider>(handle).getRestorePlan(connectionUri, restoreInfo);
 	}
 
 	/**
 	 * cancels a restore plan
 	 */
 	public $cancelRestorePlan(handle: number, connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.disasterRecoveryProvider ? provider.disasterRecoveryProvider.cancelRestorePlan(connectionUri, restoreInfo)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.RestoreProvider>(handle).cancelRestorePlan(connectionUri, restoreInfo);
 	}
 
 	/**
 	 * Gets restore config Info
 	 */
 	public $getRestoreConfigInfo(handle: number, connectionUri: string): Thenable<data.RestoreConfigInfo> {
-		return this._runWithProvider(handle, provider => {
-			return provider.disasterRecoveryProvider ? provider.disasterRecoveryProvider.getRestoreConfigInfo(connectionUri)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.RestoreProvider>(handle).getRestoreConfigInfo(connectionUri);
 	}
 
 	/**
 	 * Open a file browser
 	 */
 	public $openFileBrowser(handle: number, ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.fileBrowserProvider ? provider.fileBrowserProvider.openFileBrowser(ownerUri, expandPath, fileFilters, changeFilter)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.FileBrowserProvider>(handle).openFileBrowser(ownerUri, expandPath, fileFilters, changeFilter);
 	}
 
 	/**
@@ -472,10 +422,7 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	 * Expand a folder node
 	 */
 	public $expandFolderNode(handle: number, ownerUri: string, expandPath: string): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.fileBrowserProvider ? provider.fileBrowserProvider.expandFolderNode(ownerUri, expandPath)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.FileBrowserProvider>(handle).expandFolderNode(ownerUri, expandPath);
 	}
 
 	/**
@@ -489,10 +436,7 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	 * Validate selected file path
 	 */
 	public $validateFilePaths(handle: number, ownerUri: string, serviceType: string, selectedFiles: string[]): Thenable<boolean> {
-		return this._runWithProvider(handle, provider => {
-			return provider.fileBrowserProvider ? provider.fileBrowserProvider.validateFilePaths(ownerUri, serviceType, selectedFiles)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.FileBrowserProvider>(handle).validateFilePaths(ownerUri, serviceType, selectedFiles);
 	}
 
 	/**
@@ -506,10 +450,7 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	 * Close file browser
 	 */
 	public $closeFileBrowser(handle: number, ownerUri: string): Thenable<data.FileBrowserCloseResponse> {
-		return this._runWithProvider(handle, provider => {
-			return provider.fileBrowserProvider ? provider.fileBrowserProvider.closeFileBrowser(ownerUri)
-				: Promise.resolve(undefined);
-		});
+		return this._resolveProvider<data.FileBrowserProvider>(handle).closeFileBrowser(ownerUri);
 	}
 
 	/**
@@ -519,21 +460,15 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	/**
 	 * Start a profiler session
 	 */
-	public $startSession(handle: number, sessionId: string): Thenable<boolean>  {
-		return this._runWithProvider(handle, provider => {
-			return provider.profilerProvider ? provider.profilerProvider.startSession(sessionId)
-				: Promise.resolve(undefined);
-		});
+	public $startSession(handle: number, sessionId: string): Thenable<boolean> {
+		return this._resolveProvider<data.ProfilerProvider>(handle).startSession(sessionId);
 	}
 
 	/**
 	 * Stop a profiler session
 	 */
-	public $stopSession(handle: number, sessionId: string): Thenable<boolean>  {
-		return this._runWithProvider(handle, provider => {
-			return provider.profilerProvider ? provider.profilerProvider.stopSession(sessionId)
-				: Promise.resolve(undefined);
-		});
+	public $stopSession(handle: number, sessionId: string): Thenable<boolean> {
+		return this._resolveProvider<data.ProfilerProvider>(handle).stopSession(sessionId);
 	}
 
 	/**

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

@@ -18,7 +18,8 @@ import { IMetadataService } from 'sql/services/metadata/metadataService';
 import { IObjectExplorerService } from 'sql/parts/registeredServer/common/objectExplorerService';
 import { IScriptingService } from 'sql/services/scripting/scriptingService';
 import { IAdminService } from 'sql/parts/admin/common/adminService';
-import { IDisasterRecoveryService } from 'sql/parts/disasterRecovery/common/interfaces';
+import { IBackupService } from 'sql/parts/disasterRecovery/backup/common/backupService';
+import { IRestoreService } from 'sql/parts/disasterRecovery/restore/common/restoreService';
 import { ITaskService } from 'sql/parts/taskHistory/common/taskService';
 import { IProfilerService } from 'sql/parts/profiler/service/interfaces';
 import { ISerializationService } from 'sql/services/serialization/serializationService';
@@ -47,7 +48,8 @@ export class MainThreadDataProtocol extends MainThreadDataProtocolShape {
 		@IObjectExplorerService private _objectExplorerService: IObjectExplorerService,
 		@IScriptingService private _scriptingService: IScriptingService,
 		@IAdminService private _adminService: IAdminService,
-		@IDisasterRecoveryService private _disasterRecoveryService: IDisasterRecoveryService,
+		@IBackupService private _backupService: IBackupService,
+		@IRestoreService private _restoreService: IRestoreService,
 		@ITaskService private _taskService: ITaskService,
 		@IProfilerService private _profilerService: IProfilerService,
 		@ISerializationService private _serializationService: ISerializationService,
@@ -66,10 +68,8 @@ export class MainThreadDataProtocol extends MainThreadDataProtocolShape {
 		this._toDispose = dispose(this._toDispose);
 	}
 
-	public $registerProvider(providerId: string, handle: number): TPromise<any> {
-		let self = this;
-
-		// register connection management provider
+	public $registerConnectionProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
 		this._connectionManagementService.registerProvider(providerId, <data.ConnectionProvider>{
 			connect(connectionUri: string, connectionInfo: data.ConnectionInfo): Thenable<boolean> {
 				return self._proxy.$connect(handle, connectionUri, connectionInfo);
@@ -91,13 +91,11 @@ export class MainThreadDataProtocol extends MainThreadDataProtocolShape {
 			}
 		});
 
-		this._capabilitiesService.registerProvider(<data.CapabilitiesProvider>{
-			getServerCapabilities(client: data.DataProtocolClientCapabilities): Thenable<data.DataProtocolServerCapabilities> {
-				return self._proxy.$getServerCapabilities(handle, client);
-			}
-		});
+		return undefined;
+	}
 
-		// register query provider
+	public $registerQueryProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
 		this._queryManagementService.addQueryRequestHandler(providerId, {
 			cancelQuery(ownerUri: string): Thenable<data.QueryCancelResult> {
 				return self._proxy.$cancelQuery(handle, ownerUri);
@@ -161,6 +159,45 @@ export class MainThreadDataProtocol extends MainThreadDataProtocolShape {
 			}
 		});
 
+		return undefined;
+	}
+
+	public $registerBackupProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
+		this._backupService.registerProvider(providerId, <data.BackupProvider>{
+			backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: data.TaskExecutionMode): Thenable<data.BackupResponse> {
+				return self._proxy.$backup(handle, connectionUri, backupInfo, taskExecutionMode);
+			},
+			getBackupConfigInfo(connectionUri: string): Thenable<data.BackupConfigInfo> {
+				return self._proxy.$getBackupConfigInfo(handle, connectionUri);
+			}
+		});
+
+		return undefined;
+	}
+
+	public $registerRestoreProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
+		this._restoreService.registerProvider(providerId, <data.RestoreProvider>{
+			getRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse> {
+				return self._proxy.$getRestorePlan(handle, connectionUri, restoreInfo);
+			},
+			cancelRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean> {
+				return self._proxy.$cancelRestorePlan(handle, connectionUri, restoreInfo);
+			},
+			restore(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse> {
+				return self._proxy.$restore(handle, connectionUri, restoreInfo);
+			},
+			getRestoreConfigInfo(connectionUri: string): Thenable<data.RestoreConfigInfo> {
+				return self._proxy.$getRestoreConfigInfo(handle, connectionUri);
+			}
+		});
+
+		return undefined;
+	}
+
+	public $registerMetadataProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
 		this._metadataService.registerProvider(providerId, <data.MetadataProvider>{
 			getMetadata(connectionUri: string): Thenable<data.ProviderMetadata> {
 				return self._proxy.$getMetadata(handle, connectionUri);
@@ -176,6 +213,11 @@ export class MainThreadDataProtocol extends MainThreadDataProtocolShape {
 			}
 		});
 
+		return undefined;
+	}
+
+	public $registerObjectExplorerProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
 		this._objectExplorerService.registerProvider(providerId, <data.ObjectExplorerProvider>{
 			createNewSession(connection: data.ConnectionInfo): Thenable<data.ObjectExplorerSessionResponse> {
 				return self._proxy.$createObjectExplorerSession(handle, connection);
@@ -191,6 +233,11 @@ export class MainThreadDataProtocol extends MainThreadDataProtocolShape {
 			}
 		});
 
+		return undefined;
+	}
+
+	public $registerTaskServicesProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
 		this._taskService.registerProvider(providerId, <data.TaskServicesProvider>{
 			getAllTasks(listTasksParams: data.ListTasksParams): Thenable<data.ListTasksResponse> {
 				return self._proxy.$getAllTasks(handle, listTasksParams);
@@ -200,48 +247,22 @@ export class MainThreadDataProtocol extends MainThreadDataProtocolShape {
 			}
 		});
 
+		return undefined;
+	}
+
+	public $registerScriptingProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
 		this._scriptingService.registerProvider(providerId, <data.ScriptingProvider>{
 			scriptAsOperation(connectionUri: string, operation: data.ScriptOperation, metadata: data.ObjectMetadata, paramDetails: data.ScriptingParamDetails): Thenable<data.ScriptingResult> {
 				return self._proxy.$scriptAsOperation(handle, connectionUri, operation, metadata, paramDetails);
 			}
 		});
 
-		this._adminService.registerProvider(providerId, <data.AdminServicesProvider>{
-			createDatabase(connectionUri: string, database: data.DatabaseInfo): Thenable<data.CreateDatabaseResponse> {
-				return self._proxy.$createDatabase(handle, connectionUri, database);
-			},
-			getDefaultDatabaseInfo(connectionUri: string): Thenable<data.DatabaseInfo> {
-				return self._proxy.$getDefaultDatabaseInfo(handle, connectionUri);
-			},
-			getDatabaseInfo(connectionUri: string): Thenable<data.DatabaseInfo> {
-				return self._proxy.$getDatabaseInfo(handle, connectionUri);
-			},
-			createLogin(connectionUri: string, login: data.LoginInfo): Thenable<data.CreateLoginResponse> {
-				return self._proxy.$createLogin(handle, connectionUri, login);
-			}
-		});
-
-		this._disasterRecoveryService.registerProvider(providerId, <data.DisasterRecoveryProvider>{
-			backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: data.TaskExecutionMode): Thenable<data.BackupResponse> {
-				return self._proxy.$backup(handle, connectionUri, backupInfo, taskExecutionMode);
-			},
-			getBackupConfigInfo(connectionUri: string): Thenable<data.BackupConfigInfo> {
-				return self._proxy.$getBackupConfigInfo(handle, connectionUri);
-			},
-			getRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestorePlanResponse> {
-				return self._proxy.$getRestorePlan(handle, connectionUri, restoreInfo);
-			},
-			cancelRestorePlan(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<boolean> {
-				return self._proxy.$cancelRestorePlan(handle, connectionUri, restoreInfo);
-			},
-			restore(connectionUri: string, restoreInfo: data.RestoreInfo): Thenable<data.RestoreResponse> {
-				return self._proxy.$restore(handle, connectionUri, restoreInfo);
-			},
-			getRestoreConfigInfo(connectionUri: string): Thenable<data.RestoreConfigInfo> {
-				return self._proxy.$getRestoreConfigInfo(handle, connectionUri);
-			}
-		});
+		return undefined;
+	}
 
+	public $registerFileBrowserProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
 		this._fileBrowserService.registerProvider(providerId, <data.FileBrowserProvider>{
 			openFileBrowser(ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable<boolean> {
 				return self._proxy.$openFileBrowser(handle, ownerUri, expandPath, fileFilters, changeFilter);
@@ -257,6 +278,11 @@ export class MainThreadDataProtocol extends MainThreadDataProtocolShape {
 			}
 		});
 
+		return undefined;
+	}
+
+	public $registerProfilerProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
 		this._profilerService.registerProvider(providerId, <data.ProfilerProvider>{
 			startSession(sessionId: string): Thenable<boolean> {
 				return self._proxy.$startSession(handle, sessionId);
@@ -278,6 +304,37 @@ export class MainThreadDataProtocol extends MainThreadDataProtocolShape {
 		return undefined;
 	}
 
+	public $registerAdminServicesProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
+		this._adminService.registerProvider(providerId, <data.AdminServicesProvider>{
+			createDatabase(connectionUri: string, database: data.DatabaseInfo): Thenable<data.CreateDatabaseResponse> {
+				return self._proxy.$createDatabase(handle, connectionUri, database);
+			},
+			getDefaultDatabaseInfo(connectionUri: string): Thenable<data.DatabaseInfo> {
+				return self._proxy.$getDefaultDatabaseInfo(handle, connectionUri);
+			},
+			getDatabaseInfo(connectionUri: string): Thenable<data.DatabaseInfo> {
+				return self._proxy.$getDatabaseInfo(handle, connectionUri);
+			},
+			createLogin(connectionUri: string, login: data.LoginInfo): Thenable<data.CreateLoginResponse> {
+				return self._proxy.$createLogin(handle, connectionUri, login);
+			}
+		});
+
+		return undefined;
+	}
+
+	public $registerCapabilitiesServiceProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
+		this._capabilitiesService.registerProvider(<data.CapabilitiesProvider>{
+			getServerCapabilities(client: data.DataProtocolClientCapabilities): Thenable<data.DataProtocolServerCapabilities> {
+				return self._proxy.$getServerCapabilities(handle, client);
+			}
+		});
+
+		return undefined;
+	}
+
 	// Connection Management handlers
 	public $onConnectionComplete(handle: number, connectionInfoSummary: data.ConnectionInfoSummary): void {
 		this._connectionManagementService.onConnectionComplete(handle, connectionInfoSummary);

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

@@ -22,7 +22,7 @@ import { ExtHostDataProtocol } from 'sql/workbench/api/node/extHostDataProtocol'
 import { ExtHostSerializationProvider } from 'sql/workbench/api/node/extHostSerializationProvider';
 import { ExtHostResourceProvider } from 'sql/workbench/api/node/extHostResourceProvider';
 import { ExtHostThreadService } from 'vs/workbench/services/thread/node/extHostThreadService';
-import * as sqlExtHostTypes from 'sql/workbench/api/node/sqlExtHostTypes';
+import * as sqlExtHostTypes from 'sql/workbench/api/common/sqlExtHostTypes';
 import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
 import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
 
@@ -95,92 +95,141 @@ export function createApiFactory(
 				}
 			};
 
+			let registerConnectionProvider = (provider: data.ConnectionProvider): vscode.Disposable => {
+				// Connection callbacks
+				provider.registerOnConnectionComplete((connSummary: data.ConnectionInfoSummary) => {
+					extHostDataProvider.$onConnectComplete(provider.handle, connSummary);
+				});
+
+				provider.registerOnIntelliSenseCacheComplete((connectionUri: string) => {
+					extHostDataProvider.$onIntelliSenseCacheComplete(provider.handle, connectionUri);
+				});
+
+				provider.registerOnConnectionChanged((changedConnInfo: data.ChangedConnectionInfo) => {
+					extHostDataProvider.$onConnectionChanged(provider.handle, changedConnInfo);
+				});
+
+				return extHostDataProvider.$registerConnectionProvider(provider);
+			};
+
+			let registerQueryProvider = (provider: data.QueryProvider): vscode.Disposable => {
+				provider.registerOnQueryComplete((result: data.QueryExecuteCompleteNotificationResult) => {
+					extHostDataProvider.$onQueryComplete(provider.handle, result);
+				});
+
+				provider.registerOnBatchStart((batchInfo: data.QueryExecuteBatchNotificationParams) => {
+					extHostDataProvider.$onBatchStart(provider.handle, batchInfo);
+				});
+
+				provider.registerOnBatchComplete((batchInfo: data.QueryExecuteBatchNotificationParams) => {
+					extHostDataProvider.$onBatchComplete(provider.handle, batchInfo);
+				});
+
+				provider.registerOnResultSetComplete((resultSetInfo: data.QueryExecuteResultSetCompleteNotificationParams) => {
+					extHostDataProvider.$onResultSetComplete(provider.handle, resultSetInfo);
+				});
+
+				provider.registerOnMessage((message: data.QueryExecuteMessageParams) => {
+					extHostDataProvider.$onQueryMessage(provider.handle, message);
+				});
+
+				provider.registerOnEditSessionReady((ownerUri: string, success: boolean, message: string) => {
+					extHostDataProvider.$onEditSessionReady(provider.handle, ownerUri, success, message);
+				});
+
+				return extHostDataProvider.$registerQueryProvider(provider);
+			};
+
+			let registerObjectExplorerProvider = (provider: data.ObjectExplorerProvider): vscode.Disposable => {
+				provider.registerOnSessionCreated((response: data.ObjectExplorerSession) => {
+					extHostDataProvider.$onObjectExplorerSessionCreated(provider.handle, response);
+				});
+
+				provider.registerOnExpandCompleted((response: data.ObjectExplorerExpandInfo) => {
+					extHostDataProvider.$onObjectExplorerNodeExpanded(provider.handle, response);
+				});
+
+				return extHostDataProvider.$registerObjectExplorerProvider(provider);
+			};
+
+			let registerTaskServicesProvider = (provider: data.TaskServicesProvider): vscode.Disposable => {
+				provider.registerOnTaskCreated((response: data.TaskInfo) => {
+					extHostDataProvider.$onTaskCreated(provider.handle, response);
+				});
+
+				provider.registerOnTaskStatusChanged((response: data.TaskProgressInfo) => {
+					extHostDataProvider.$onTaskStatusChanged(provider.handle, response);
+				});
+
+				return extHostDataProvider.$registerTaskServicesProvider(provider);
+			};
+
+			let registerFileBrowserProvider = (provider: data.FileBrowserProvider): vscode.Disposable => {
+				provider.registerOnFileBrowserOpened((response: data.FileBrowserOpenedParams) => {
+					extHostDataProvider.$onFileBrowserOpened(provider.handle, response);
+				});
+
+				provider.registerOnFolderNodeExpanded((response: data.FileBrowserExpandedParams) => {
+					extHostDataProvider.$onFolderNodeExpanded(provider.handle, response);
+				});
+
+				provider.registerOnFilePathsValidated((response: data.FileBrowserValidatedParams) => {
+					extHostDataProvider.$onFilePathsValidated(provider.handle, response);
+				});
+
+				return extHostDataProvider.$registerFileBrowserProvider(provider);
+			};
+
+			let registerScriptingProvider = (provider: data.ScriptingProvider): vscode.Disposable => {
+				provider.registerOnScriptingComplete((response: data.ScriptingCompleteResult) => {
+					extHostDataProvider.$onScriptingComplete(provider.handle, response);
+				});
+
+				return extHostDataProvider.$registerScriptingProvider(provider);
+			};
+
+			let registerProfilerProvider = (provider: data.ProfilerProvider): vscode.Disposable => {
+				provider.registerOnSessionEventsAvailable((response: data.ProfilerSessionEvents) => {
+					extHostDataProvider.$onSessionEventsAvailable(provider.handle, response);
+				});
+
+				return extHostDataProvider.$registerProfilerProvider(provider);
+			};
+
+			let registerBackupProvider = (provider: data.BackupProvider): vscode.Disposable => {
+				return extHostDataProvider.$registerBackupProvider(provider);
+			};
+
+			let registerRestoreProvider = (provider: data.RestoreProvider): vscode.Disposable => {
+				return extHostDataProvider.$registerRestoreProvider(provider);
+			};
+
+			let registerMetadataProvider = (provider: data.MetadataProvider): vscode.Disposable => {
+				return extHostDataProvider.$registerMetadataProvider(provider);
+			};
+
+			let registerCapabilitiesServiceProvider = (provider: data.CapabilitiesProvider): vscode.Disposable => {
+				return extHostDataProvider.$registerCapabilitiesServiceProvider(provider);
+			};
+
+			let registerAdminServicesProvider = (provider: data.AdminServicesProvider): vscode.Disposable => {
+				return extHostDataProvider.$registerAdminServicesProvider(provider);
+			};
+
 			// namespace: dataprotocol
 			const dataprotocol: typeof data.dataprotocol = {
-				registerProvider(provider: data.DataProtocolProvider): vscode.Disposable {
-					// Connection callbacks
-					provider.connectionProvider.registerOnConnectionComplete((connSummary: data.ConnectionInfoSummary) => {
-						extHostDataProvider.$onConnectComplete(provider.handle, connSummary);
-					});
-
-					provider.connectionProvider.registerOnIntelliSenseCacheComplete((connectionUri: string) => {
-						extHostDataProvider.$onIntelliSenseCacheComplete(provider.handle, connectionUri);
-					});
-
-					provider.connectionProvider.registerOnConnectionChanged((changedConnInfo: data.ChangedConnectionInfo) => {
-						extHostDataProvider.$onConnectionChanged(provider.handle, changedConnInfo);
-					});
-
-					// Query callbacks
-					provider.queryProvider.registerOnQueryComplete((result: data.QueryExecuteCompleteNotificationResult) => {
-						extHostDataProvider.$onQueryComplete(provider.handle, result);
-					});
-
-					provider.queryProvider.registerOnBatchStart((batchInfo: data.QueryExecuteBatchNotificationParams) => {
-						extHostDataProvider.$onBatchStart(provider.handle, batchInfo);
-					});
-
-					provider.queryProvider.registerOnBatchComplete((batchInfo: data.QueryExecuteBatchNotificationParams) => {
-						extHostDataProvider.$onBatchComplete(provider.handle, batchInfo);
-					});
-
-					provider.queryProvider.registerOnResultSetComplete((resultSetInfo: data.QueryExecuteResultSetCompleteNotificationParams) => {
-						extHostDataProvider.$onResultSetComplete(provider.handle, resultSetInfo);
-					});
-
-					provider.queryProvider.registerOnMessage((message: data.QueryExecuteMessageParams) => {
-						extHostDataProvider.$onQueryMessage(provider.handle, message);
-					});
-
-					//OE callbacks
-					provider.objectExplorerProvider.registerOnSessionCreated((response: data.ObjectExplorerSession) => {
-						extHostDataProvider.$onObjectExplorerSessionCreated(provider.handle, response);
-					});
-
-					provider.objectExplorerProvider.registerOnExpandCompleted((response: data.ObjectExplorerExpandInfo) => {
-						extHostDataProvider.$onObjectExplorerNodeExpanded(provider.handle, response);
-					});
-
-					//Tasks callbacks
-					provider.taskServicesProvider.registerOnTaskCreated((response: data.TaskInfo) => {
-						extHostDataProvider.$onTaskCreated(provider.handle, response);
-					});
-
-					provider.taskServicesProvider.registerOnTaskStatusChanged((response: data.TaskProgressInfo) => {
-						extHostDataProvider.$onTaskStatusChanged(provider.handle, response);
-					});
-
-					// Edit Data callbacks
-					provider.queryProvider.registerOnEditSessionReady((ownerUri: string, success: boolean, message: string) => {
-						extHostDataProvider.$onEditSessionReady(provider.handle, ownerUri, success, message);
-					});
-
-					// File browser callbacks
-					provider.fileBrowserProvider.registerOnFileBrowserOpened((response: data.FileBrowserOpenedParams) => {
-						extHostDataProvider.$onFileBrowserOpened(provider.handle, response);
-					});
-
-					provider.fileBrowserProvider.registerOnFolderNodeExpanded((response: data.FileBrowserExpandedParams) => {
-						extHostDataProvider.$onFolderNodeExpanded(provider.handle, response);
-					});
-
-					provider.fileBrowserProvider.registerOnFilePathsValidated((response: data.FileBrowserValidatedParams) => {
-						extHostDataProvider.$onFilePathsValidated(provider.handle, response);
-					});
-
-					// Scripting callbacks
-					provider.scriptingProvider.registerOnScriptingComplete((response: data.ScriptingCompleteResult) => {
-						extHostDataProvider.$onScriptingComplete(provider.handle, response);
-					});
-
-					// Profiler callbacks
-					provider.profilerProvider.registerOnSessionEventsAvailable((response: data.ProfilerSessionEvents) => {
-						extHostDataProvider.$onSessionEventsAvailable(provider.handle, response);
-					});
-
-					// Complete registration
-					return extHostDataProvider.$registerProvider(provider);
-				},
+				registerBackupProvider,
+				registerConnectionProvider,
+				registerFileBrowserProvider,
+				registerMetadataProvider,
+				registerObjectExplorerProvider,
+				registerProfilerProvider,
+				registerRestoreProvider,
+				registerScriptingProvider,
+				registerTaskServicesProvider,
+				registerQueryProvider,
+				registerAdminServicesProvider,
+				registerCapabilitiesServiceProvider,
 				onDidChangeLanguageFlavor(listener: (e: data.DidChangeLanguageFlavorParams) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
 					return extHostDataProvider.onDidChangeLanguageFlavor(listener, thisArgs, disposables);
 				}

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

@@ -352,7 +352,18 @@ export abstract class MainThreadResourceProviderShape {
 }
 
 export abstract class MainThreadDataProtocolShape {
-	$registerProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerConnectionProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerBackupProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerRestoreProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerScriptingProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerQueryProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerProfilerProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerObjectExplorerProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerMetadataProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerTaskServicesProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerFileBrowserProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerCapabilitiesServiceProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
+	$registerAdminServicesProvider(providerId: string, handle: number): TPromise<any> { throw ni(); }
 	$unregisterProvider(handle: number): TPromise<any> { throw ni(); }
 	$onConnectionComplete(handle: number, connectionInfoSummary: data.ConnectionInfoSummary): void { throw ni(); }
 	$onIntelliSenseCacheComplete(handle: number, connectionUri: string): void { throw ni(); }

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

@@ -1,66 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-'use strict';
-
-// SQL added extension host types
-export enum ServiceOptionType {
-	string = 0,
-	multistring = 1,
-	password = 2,
-	number = 3,
-	category = 4,
-	boolean = 5,
-	object = 6
-}
-
-export enum ConnectionOptionSpecialType {
-	serverName = 0,
-	databaseName = 1,
-	authType = 2,
-	userName = 3,
-	password = 4,
-	appName = 5
-}
-
-
-export enum MetadataType {
-	Table = 0,
-	View = 1,
-	SProc = 2,
-	Function = 3
-}
-
-export enum EditRowState {
-	clean = 0,
-	dirtyInsert = 1,
-	dirtyDelete = 2,
-	dirtyUpdate = 3
-}
-
-
-export enum TaskStatus {
-	notStarted = 0,
-	inProgress = 1,
-	succeeded = 2,
-	succeededWithWarning = 3,
-	failed = 4,
-	canceled = 5
-}
-
-export enum TaskExecutionMode {
-	execute = 0,
-	script = 1,
-	executeAndScript = 2,
-}
-
-export enum ScriptOperation {
-	Select = 0,
-	Create = 1,
-	Insert = 2,
-	Update = 3,
-	Delete = 4,
-	Execute = 5,
-	Alter = 6
-}