Converting remaining services to use runWithErrorHandling() (#22720)

* Converting remaining services to use `runWithErrorHandling()`

* Updating sqlops-dataprotocolclient to 1.3.3

* upgrading dataprotocol and swapping to that baseService

* Adding async to make thenable -> promise conversion happy

---------

Co-authored-by: Alan Ren <alanren@microsoft.com>

extensions/azuremonitor/package.json

@@ -209,7 +209,7 @@
     "update-grammar": "node ../../build/npm/update-grammar.js Microsoft/vscode-azuremonitor ./syntaxes/azuremonitor.tmLanguage"
   },
   "dependencies": {
-    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.1",
+    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.4",
     "figures": "^2.0.0",
     "find-remove": "1.2.1",
     "@microsoft/ads-service-downloader": "^1.2.1",

extensions/azuremonitor/yarn.lock

@@ -75,9 +75,9 @@ concat-map@0.0.1:
   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 
-"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.1":
+"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.4":
-  version "1.3.1"
+  version "1.3.4"
-  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/2df6982e07c0208c2b8a5f8cd4b3d65944138d15"
+  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/fed4e05caadd89e1f635cc247b82a96a10bc837d"
   dependencies:
     vscode-languageclient "5.2.1"
 

extensions/datavirtualization/package.json

@@ -107,7 +107,7 @@
   "dependencies": {
     "@microsoft/ads-extension-telemetry": "^3.0.1",
     "@microsoft/ads-service-downloader": "^1.2.1",
-    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.2",
+    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.4",
     "vscode-nls": "^5.2.0"
   },
   "devDependencies": {

extensions/datavirtualization/yarn.lock

@@ -489,9 +489,9 @@ crypt@0.0.2:
   resolved "https://registry.yarnpkg.com/crypt/-/crypt-0.0.2.tgz#88d7ff7ec0dfb86f713dc87bbb42d044d3e6c41b"
   integrity sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==
 
-"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.2":
+"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.4":
-  version "1.3.2"
+  version "1.3.4"
-  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/e3be16cffbac882ef545e4da9654a82dc010d1b7"
+  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/fed4e05caadd89e1f635cc247b82a96a10bc837d"
   dependencies:
     vscode-languageclient "5.2.1"
 

extensions/import/package.json

@@ -77,7 +77,7 @@
     }
   },
   "dependencies": {
-    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.1",
+    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.4",
     "htmlparser2": "^3.10.1",
     "@microsoft/ads-service-downloader": "^1.2.1",
     "@microsoft/ads-extension-telemetry": "^3.0.1",

extensions/import/yarn.lock

@@ -486,9 +486,9 @@ crypt@~0.0.1:
   resolved "https://registry.yarnpkg.com/crypt/-/crypt-0.0.2.tgz#88d7ff7ec0dfb86f713dc87bbb42d044d3e6c41b"
   integrity sha1-iNf/fsDfuG9xPch7u0LQRNPmxBs=
 
-"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.1":
+"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.4":
-  version "1.3.1"
+  version "1.3.4"
-  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/2df6982e07c0208c2b8a5f8cd4b3d65944138d15"
+  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/fed4e05caadd89e1f635cc247b82a96a10bc837d"
   dependencies:
     vscode-languageclient "5.2.1"
 

extensions/kusto/package.json

@@ -427,7 +427,7 @@
     }
   },
   "dependencies": {
-    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.1",
+    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.4",
     "figures": "^2.0.0",
     "find-remove": "1.2.1",
     "@microsoft/ads-service-downloader": "^1.2.1",

extensions/kusto/yarn.lock

@@ -124,9 +124,9 @@ concat-map@0.0.1:
   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 
-"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.1":
+"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.4":
-  version "1.3.1"
+  version "1.3.4"
-  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/2df6982e07c0208c2b8a5f8cd4b3d65944138d15"
+  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/fed4e05caadd89e1f635cc247b82a96a10bc837d"
   dependencies:
     vscode-languageclient "5.2.1"
 

extensions/mssql/package.json

@@ -1442,7 +1442,7 @@
   "dependencies": {
     "@microsoft/ads-extension-telemetry": "^3.0.1",
     "@microsoft/ads-service-downloader": "^1.2.1",
-    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.2",
+    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.4",
     "find-remove": "1.2.1",
     "vscode-languageclient": "5.2.1",
     "vscode-nls": "^4.0.0"

extensions/mssql/src/azureBlob/azureBlobService.ts

@@ -4,23 +4,19 @@
  *--------------------------------------------------------------------------------------------*/
 
 import type * as mssql from 'mssql';
-import { SqlOpsDataClient } from 'dataprotocol-client';
 import * as contracts from '../contracts';
+import { BaseService, SqlOpsDataClient } from 'dataprotocol-client';
 
-export class AzureBlobService implements mssql.IAzureBlobService {
+export class AzureBlobService extends BaseService implements mssql.IAzureBlobService {
 
-	public constructor(protected readonly client: SqlOpsDataClient) { }
+	public constructor(client: SqlOpsDataClient) {
+		super(client);
+	}
 
 	public async createSas(ownerUri: string, blobContainerUri: string, blobContainerKey: string, storageAccountName: string, expirationDate: string): Promise<mssql.CreateSasResponse> {
 		// This isn't registered as a feature since it's not something that we expect every tools client to implement currently since the usage is
 		// specifically for ADS and SqlToolsService.
 		const params: contracts.CreateSasParams = { ownerUri, blobContainerUri, blobContainerKey, storageAccountName, expirationDate };
-		return this.client.sendRequest(contracts.CreateSasRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.CreateSasRequest.type, params);
-			undefined,
-			e => {
-				this.client.logFailedRequest(contracts.CreateSasRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
 }

extensions/mssql/src/baseService.ts

@@ -1,30 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { RequestType } from 'vscode-languageclient';
-import { SqlOpsDataClient } from 'dataprotocol-client';
-
-/**
- * Base class containing shared code to reduce boilerplate for services
- */
-export abstract class BaseService {
-	constructor(protected readonly client: SqlOpsDataClient) { }
-
-	/**
-	 * Runs the specified request wrapped in the requisite try-catch
-	 * @param type RequestType, typically in the format 'contracts.DoThingRequest.type'
-	 * @param params parameters to be passed to the request
-	 * @returns result from the request
-	 */
-	protected async runWithErrorHandling<P, R, E, RO>(type: RequestType<P, R, E, RO>, params: P): Promise<R> {
-		try {
-			const result = await this.client.sendRequest(type, params);
-			return result;
-		} catch (e) {
-			this.client.logFailedRequest(type, e);
-			throw e;
-		}
-	}
-}

extensions/mssql/src/cms/cmsService.ts

@@ -6,13 +6,13 @@
 import * as azdata from 'azdata';
 import * as constants from '../constants';
 import * as contracts from '../contracts';
-import { AppContext } from '../appContext';
-import { ConnectParams, ClientCapabilities } from 'dataprotocol-client/lib/protocol';
-import { SqlOpsDataClient, ISqlOpsFeature } from 'dataprotocol-client';
-import { ListRegisteredServersResult, ICmsService } from 'mssql';
 import * as Utils from '../utils';
+import { AppContext } from '../appContext';
+import { ClientCapabilities } from 'dataprotocol-client/lib/protocol';
+import { SqlOpsDataClient, ISqlOpsFeature, BaseService } from 'dataprotocol-client';
+import { ListRegisteredServersResult, ICmsService } from 'mssql';
 
-export class CmsService implements ICmsService {
+export class CmsService extends BaseService implements ICmsService {
 	public static asFeature(context: AppContext): ISqlOpsFeature {
 		return class extends CmsService {
 			constructor(client: SqlOpsDataClient) {
@@ -28,91 +28,40 @@ export class CmsService implements ICmsService {
 		};
 	}
 
-	private constructor(context: AppContext, protected readonly client: SqlOpsDataClient) {
+	private constructor(context: AppContext, client: SqlOpsDataClient) {
+		super(client);
 		context.registerService(constants.CmsService, this);
 	}
 
-	createCmsServer(name: string, description: string, connectiondetails: azdata.ConnectionInfo, ownerUri: string): Thenable<ListRegisteredServersResult> {
+	async createCmsServer(name: string, description: string, connectiondetails: azdata.ConnectionInfo, ownerUri: string): Promise<ListRegisteredServersResult> {
-		let connectparams: ConnectParams = { ownerUri: ownerUri, connection: connectiondetails };
+		const params: contracts.CreateCentralManagementServerParams = { registeredServerName: name, registeredServerDescription: description, connectParams: { ownerUri: ownerUri, connection: connectiondetails } };
-		let cmsparams: contracts.CreateCentralManagementServerParams = { registeredServerName: name, registeredServerDescription: description, connectParams: connectparams };
+		return this.runWithErrorHandling(contracts.CreateCentralManagementServerRequest.type, params);
-
-		return this.client.sendRequest(contracts.CreateCentralManagementServerRequest.type, cmsparams).then(
-			r => {
-				return r;
-			},
-			e => {
-				this.client.logFailedRequest(contracts.CreateCentralManagementServerRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
 
-	getRegisteredServers(ownerUri: string, relativePath: string): Thenable<ListRegisteredServersResult> {
+	async getRegisteredServers(ownerUri: string, relativePath: string): Promise<ListRegisteredServersResult> {
-		let params: contracts.ListRegisteredServersParams = { parentOwnerUri: ownerUri, relativePath: relativePath };
+		const params: contracts.ListRegisteredServersParams = { parentOwnerUri: ownerUri, relativePath: relativePath };
-		return this.client.sendRequest(contracts.ListRegisteredServersRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.ListRegisteredServersRequest.type, params);
-			r => {
-				return r;
-			},
-			e => {
-				this.client.logFailedRequest(contracts.ListRegisteredServersRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
 
-	addRegisteredServer(ownerUri: string, relativePath: string, registeredServerName: string, registeredServerDescription: string, connectionDetails: azdata.ConnectionInfo): Thenable<boolean> {
+	async addRegisteredServer(ownerUri: string, relativePath: string, registeredServerName: string, registeredServerDescription: string, connectionDetails: azdata.ConnectionInfo): Promise<boolean> {
-		let params: contracts.AddRegisteredServerParams = { parentOwnerUri: ownerUri, relativePath: relativePath, registeredServerName: registeredServerName, registeredServerDescription: registeredServerDescription, registeredServerConnectionDetails: connectionDetails };
+		const params: contracts.AddRegisteredServerParams = { parentOwnerUri: ownerUri, relativePath: relativePath, registeredServerName: registeredServerName, registeredServerDescription: registeredServerDescription, registeredServerConnectionDetails: connectionDetails };
-		return this.client.sendRequest(contracts.AddRegisteredServerRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.AddRegisteredServerRequest.type, params);
-			r => {
-				return r;
-			},
-			e => {
-				this.client.logFailedRequest(contracts.AddRegisteredServerRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
 
-	removeRegisteredServer(ownerUri: string, relativePath: string, registeredServerName: string): Thenable<boolean> {
+	async removeRegisteredServer(ownerUri: string, relativePath: string, registeredServerName: string): Promise<boolean> {
-		let params: contracts.RemoveRegisteredServerParams = { parentOwnerUri: ownerUri, relativePath: relativePath, registeredServerName: registeredServerName };
+		const params: contracts.RemoveRegisteredServerParams = { parentOwnerUri: ownerUri, relativePath: relativePath, registeredServerName: registeredServerName };
-		return this.client.sendRequest(contracts.RemoveRegisteredServerRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.RemoveRegisteredServerRequest.type, params);
-			r => {
-				return r;
-			},
-			e => {
-				this.client.logFailedRequest(contracts.RemoveRegisteredServerRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
 
-	addServerGroup(ownerUri: string, relativePath: string, groupName: string, groupDescription: string): Thenable<boolean> {
+	async addServerGroup(ownerUri: string, relativePath: string, groupName: string, groupDescription: string): Promise<boolean> {
-		let params: contracts.AddServerGroupParams = { parentOwnerUri: ownerUri, relativePath: relativePath, groupName: groupName, groupDescription: groupDescription };
+		const params: contracts.AddServerGroupParams = { parentOwnerUri: ownerUri, relativePath: relativePath, groupName: groupName, groupDescription: groupDescription };
-		return this.client.sendRequest(contracts.AddServerGroupRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.AddServerGroupRequest.type, params);
-			r => {
-				return r;
-			},
-			e => {
-				this.client.logFailedRequest(contracts.AddServerGroupRequest.type, e);
-				return Promise.reject(new Error(e.message));
-			}
-		);
 	}
 
-	removeServerGroup(ownerUri: string, relativePath: string, groupName: string): Thenable<boolean> {
+	async removeServerGroup(ownerUri: string, relativePath: string, groupName: string): Promise<boolean> {
-		let params: contracts.RemoveServerGroupParams = { parentOwnerUri: ownerUri, relativePath: relativePath, groupName: groupName };
+		const params: contracts.RemoveServerGroupParams = { parentOwnerUri: ownerUri, relativePath: relativePath, groupName: groupName };
-		return this.client.sendRequest(contracts.RemoveServerGroupRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.RemoveServerGroupRequest.type, params);
-			r => {
-				return r;
-			},
-			e => {
-				this.client.logFailedRequest(contracts.RemoveServerGroupRequest.type, e);
-				return Promise.reject(new Error(e.message));
-			}
-		);
 	}
 
-	dispose() {
+	dispose() { }
-
-	}
 }

extensions/mssql/src/dacfx/dacFxService.ts

@@ -10,9 +10,8 @@ import * as azdata from 'azdata';
 import * as contracts from '../contracts';
 
 import { AppContext } from '../appContext';
-import { ISqlOpsFeature, SqlOpsDataClient } from 'dataprotocol-client';
+import { BaseService, ISqlOpsFeature, SqlOpsDataClient } from 'dataprotocol-client';
 import { ClientCapabilities } from 'vscode-languageclient';
-import { BaseService } from '../baseService';
 
 export class DacFxService extends BaseService implements mssql.IDacFxService {
 	public static asFeature(context: AppContext): ISqlOpsFeature {
@@ -35,47 +34,47 @@ export class DacFxService extends BaseService implements mssql.IDacFxService {
 		context.registerService(constants.DacFxService, this);
 	}
 
-	public exportBacpac(databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.DacFxResult> {
+	public async exportBacpac(databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.DacFxResult> {
 		const params: contracts.ExportParams = { databaseName: databaseName, packageFilePath: packageFilePath, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.ExportRequest.type, params);
 	}
 
-	public importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.DacFxResult> {
+	public async importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.DacFxResult> {
 		const params: contracts.ImportParams = { packageFilePath: packageFilePath, databaseName: databaseName, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.ImportRequest.type, params);
 	}
 
-	public extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.DacFxResult> {
+	public async extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.DacFxResult> {
 		const params: contracts.ExtractParams = { databaseName: databaseName, packageFilePath: packageFilePath, applicationName: applicationName, applicationVersion: applicationVersion, ownerUri: ownerUri, extractTarget: mssql.ExtractTarget.dacpac, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.ExtractRequest.type, params);
 	}
 
-	public createProjectFromDatabase(databaseName: string, targetFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, extractTarget: mssql.ExtractTarget, taskExecutionMode: azdata.TaskExecutionMode, includePermissions?: boolean): Promise<mssql.DacFxResult> {
+	public async createProjectFromDatabase(databaseName: string, targetFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, extractTarget: mssql.ExtractTarget, taskExecutionMode: azdata.TaskExecutionMode, includePermissions?: boolean): Promise<mssql.DacFxResult> {
 		const params: contracts.ExtractParams = { databaseName: databaseName, packageFilePath: targetFilePath, applicationName: applicationName, applicationVersion: applicationVersion, ownerUri: ownerUri, extractTarget: extractTarget, taskExecutionMode: taskExecutionMode, includePermissions: includePermissions };
 		return this.runWithErrorHandling(contracts.ExtractRequest.type, params);
 	}
 
-	public deployDacpac(packageFilePath: string, targetDatabaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<mssql.DacFxResult> {
+	public async deployDacpac(packageFilePath: string, targetDatabaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<mssql.DacFxResult> {
 		const params: contracts.DeployParams = { packageFilePath: packageFilePath, databaseName: targetDatabaseName, upgradeExisting: upgradeExisting, sqlCommandVariableValues: sqlCommandVariableValues, deploymentOptions: deploymentOptions, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.DeployRequest.type, params);
 	}
 
-	public generateDeployScript(packageFilePath: string, targetDatabaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<mssql.DacFxResult> {
+	public async generateDeployScript(packageFilePath: string, targetDatabaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode, sqlCommandVariableValues?: Record<string, string>, deploymentOptions?: mssql.DeploymentOptions): Promise<mssql.DacFxResult> {
 		const params: contracts.GenerateDeployScriptParams = { packageFilePath: packageFilePath, databaseName: targetDatabaseName, sqlCommandVariableValues: sqlCommandVariableValues, deploymentOptions: deploymentOptions, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.GenerateDeployScriptRequest.type, params);
 	}
 
-	public generateDeployPlan(packageFilePath: string, targetDatabaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.GenerateDeployPlanResult> {
+	public async generateDeployPlan(packageFilePath: string, targetDatabaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.GenerateDeployPlanResult> {
 		const params: contracts.GenerateDeployPlanParams = { packageFilePath: packageFilePath, databaseName: targetDatabaseName, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.GenerateDeployPlanRequest.type, params);
 	}
 
-	public getOptionsFromProfile(profilePath: string): Promise<mssql.DacFxOptionsResult> {
+	public async getOptionsFromProfile(profilePath: string): Promise<mssql.DacFxOptionsResult> {
 		const params: contracts.GetOptionsFromProfileParams = { profilePath: profilePath };
 		return this.runWithErrorHandling(contracts.GetOptionsFromProfileRequest.type, params);
 	}
 
-	public validateStreamingJob(packageFilePath: string, createStreamingJobTsql: string): Promise<mssql.ValidateStreamingJobResult> {
+	public async validateStreamingJob(packageFilePath: string, createStreamingJobTsql: string): Promise<mssql.ValidateStreamingJobResult> {
 		const params: contracts.ValidateStreamingJobParams = { packageFilePath: packageFilePath, createStreamingJobTsql: createStreamingJobTsql };
 		return this.runWithErrorHandling(contracts.ValidateStreamingJobRequest.type, params);
 	}

extensions/mssql/src/languageExtension/languageExtensionService.ts

@@ -3,16 +3,16 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AppContext } from '../appContext';
-import { SqlOpsDataClient, ISqlOpsFeature } from 'dataprotocol-client';
 import * as constants from '../constants';
 import * as mssql from 'mssql';
 import * as Utils from '../utils';
-import { ClientCapabilities } from 'vscode-languageclient';
 import * as contracts from '../contracts';
 
-export class LanguageExtensionService implements mssql.ILanguageExtensionService {
+import { AppContext } from '../appContext';
+import { ClientCapabilities } from 'vscode-languageclient';
+import { SqlOpsDataClient, ISqlOpsFeature, BaseService } from 'dataprotocol-client';
 
+export class LanguageExtensionService extends BaseService implements mssql.ILanguageExtensionService {
 	public static asFeature(context: AppContext): ISqlOpsFeature {
 		return class extends LanguageExtensionService {
 			constructor(client: SqlOpsDataClient) {
@@ -28,44 +28,23 @@ export class LanguageExtensionService implements mssql.ILanguageExtensionService
 		};
 	}
 
-	private constructor(context: AppContext, protected readonly client: SqlOpsDataClient) {
+	private constructor(context: AppContext, client: SqlOpsDataClient) {
+		super(client);
 		context.registerService(constants.LanguageExtensionService, this);
 	}
 
-	public listLanguages(ownerUri: string): Thenable<mssql.ExternalLanguage[]> {
+	public async listLanguages(ownerUri: string): Promise<mssql.ExternalLanguage[]> {
 		const params: contracts.LanguageExtensionRequestParam = { ownerUri: ownerUri };
-		return this.client.sendRequest(contracts.LanguageExtensibilityListRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.LanguageExtensibilityListRequest.type, params).then((r) => r.languages);
-			r => {
-				return r.languages;
-			},
-			e => {
-				this.client.logFailedRequest(contracts.LanguageExtensibilityListRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
 
-	public updateLanguage(ownerUri: string, language: mssql.ExternalLanguage): Thenable<void> {
+	public async updateLanguage(ownerUri: string, language: mssql.ExternalLanguage): Promise<void> {
 		const params: contracts.ExternalLanguageUpdateRequestParam = { ownerUri: ownerUri, language: language };
-		return this.client.sendRequest(contracts.LanguageExtensibilityUpdateRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.LanguageExtensibilityUpdateRequest.type, params).then();
-			() => {
-			},
-			e => {
-				this.client.logFailedRequest(contracts.LanguageExtensibilityUpdateRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
 
-	public deleteLanguage(ownerUri: string, languageName: string): Thenable<void> {
+	public async deleteLanguage(ownerUri: string, languageName: string): Promise<void> {
 		const params: contracts.ExternalLanguageRequestParam = { ownerUri: ownerUri, languageName: languageName };
-		return this.client.sendRequest(contracts.LanguageExtensibilityDeleteRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.LanguageExtensibilityDeleteRequest.type, params).then();
-			() => {
-			},
-			e => {
-				this.client.logFailedRequest(contracts.LanguageExtensibilityDeleteRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
 }

extensions/mssql/src/notebookConvert/notebookConvertService.ts

@@ -3,18 +3,19 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AppContext } from '../appContext';
-import { SqlOpsDataClient, ISqlOpsFeature } from 'dataprotocol-client';
-import { ClientCapabilities } from 'vscode-languageclient';
 import * as constants from '../constants';
 import * as contracts from '../contracts';
 
+import { AppContext } from '../appContext';
+import { SqlOpsDataClient, ISqlOpsFeature, BaseService } from 'dataprotocol-client';
+import { ClientCapabilities } from 'vscode-languageclient';
+
 export interface INotebookConvertService {
 	convertNotebookToSql(content: string): Promise<contracts.ConvertNotebookToSqlResult | undefined>;
 	convertSqlToNotebook(content: string): Promise<contracts.ConvertSqlToNotebookResult | undefined>;
 }
 
-export class NotebookConvertService implements INotebookConvertService {
+export class NotebookConvertService extends BaseService implements INotebookConvertService {
 	public static asFeature(context: AppContext): ISqlOpsFeature {
 		return class extends NotebookConvertService {
 			constructor(client: SqlOpsDataClient) {
@@ -29,30 +30,17 @@ export class NotebookConvertService implements INotebookConvertService {
 		};
 	}
 
-	private constructor(context: AppContext, protected readonly client: SqlOpsDataClient) {
+	private constructor(context: AppContext, client: SqlOpsDataClient) {
+		super(client);
 		context.registerService(constants.NotebookConvertService, this);
 	}
 
 	async convertNotebookToSql(content: string): Promise<contracts.ConvertNotebookToSqlResult | undefined> {
 		let params: contracts.ConvertNotebookToSqlParams = { content: content };
-		try {
+		return this.runWithErrorHandling(contracts.ConvertNotebookToSqlRequest.type, params);
-			return this.client.sendRequest(contracts.ConvertNotebookToSqlRequest.type, params);
-		}
-		catch (e) {
-			this.client.logFailedRequest(contracts.ConvertNotebookToSqlRequest.type, e);
-		}
-
-		return undefined;
 	}
 	async convertSqlToNotebook(content: string): Promise<contracts.ConvertSqlToNotebookResult | undefined> {
 		let params: contracts.ConvertSqlToNotebookParams = { clientUri: content };
-		try {
+		return this.runWithErrorHandling(contracts.ConvertSqlToNotebookRequest.type, params);
-			return this.client.sendRequest(contracts.ConvertSqlToNotebookRequest.type, params);
-		}
-		catch (e) {
-			this.client.logFailedRequest(contracts.ConvertSqlToNotebookRequest.type, e);
-		}
-
-		return undefined;
 	}
 }

extensions/mssql/src/objectManagement/objectManagementService.ts

@@ -3,16 +3,17 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ISqlOpsFeature, SqlOpsDataClient } from 'dataprotocol-client';
-import { ObjectManagement, IObjectManagementService } from 'mssql';
-import { ClientCapabilities } from 'vscode-languageclient';
-import { AppContext } from '../appContext';
 import * as Utils from '../utils';
 import * as constants from '../constants';
 import * as contracts from '../contracts';
+
+import { BaseService, ISqlOpsFeature, SqlOpsDataClient } from 'dataprotocol-client';
+import { ObjectManagement, IObjectManagementService } from 'mssql';
+import { ClientCapabilities } from 'vscode-languageclient';
+import { AppContext } from '../appContext';
 import { AuthenticationType, UserType } from './constants';
 
-export class ObjectManagementService implements IObjectManagementService {
+export class ObjectManagementService extends BaseService implements IObjectManagementService {
 	public static asFeature(context: AppContext): ISqlOpsFeature {
 		return class extends ObjectManagementService {
 			constructor(client: SqlOpsDataClient) {
@@ -28,132 +29,68 @@ export class ObjectManagementService implements IObjectManagementService {
 		};
 	}
 
-	private constructor(context: AppContext, protected readonly client: SqlOpsDataClient) {
+	private constructor(context: AppContext, client: SqlOpsDataClient) {
+		super(client);
 		context.registerService(constants.ObjectManagementService, this);
 	}
-	initializeLoginView(connectionUri: string, contextId: string, isNewObject: boolean, name: string | undefined): Thenable<ObjectManagement.LoginViewInfo> {
+
+	async initializeLoginView(connectionUri: string, contextId: string, isNewObject: boolean, name: string | undefined): Promise<ObjectManagement.LoginViewInfo> {
 		const params: contracts.InitializeLoginViewRequestParams = { connectionUri, contextId, isNewObject, name };
-		return this.client.sendRequest(contracts.InitializeLoginViewRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.InitializeLoginViewRequest.type, params);
-			r => {
-				return r;
-			},
-			e => {
-				this.client.logFailedRequest(contracts.InitializeLoginViewRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	createLogin(contextId: string, login: ObjectManagement.Login): Thenable<void> {
+
+	async createLogin(contextId: string, login: ObjectManagement.Login): Promise<void> {
 		const params: contracts.CreateLoginRequestParams = { contextId, login };
-		return this.client.sendRequest(contracts.CreateLoginRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.CreateLoginRequest.type, params);
-			r => { },
-			e => {
-				this.client.logFailedRequest(contracts.CreateLoginRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	updateLogin(contextId: string, login: ObjectManagement.Login): Thenable<void> {
+
+	async updateLogin(contextId: string, login: ObjectManagement.Login): Promise<void> {
 		const params: contracts.UpdateLoginRequestParams = { contextId, login };
-		return this.client.sendRequest(contracts.UpdateLoginRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.UpdateLoginRequest.type, params);
-			r => { },
-			e => {
-				this.client.logFailedRequest(contracts.UpdateLoginRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	scriptLogin(contextId: string, login: ObjectManagement.Login): Thenable<string> {
+
+	async scriptLogin(contextId: string, login: ObjectManagement.Login): Promise<string> {
 		const params: contracts.ScriptLoginRequestParams = { contextId, login };
-		return this.client.sendRequest(contracts.ScriptLoginRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.ScriptLoginRequest.type, params);
-			r => { return r; },
-			e => {
-				this.client.logFailedRequest(contracts.ScriptLoginRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	disposeLoginView(contextId: string): Thenable<void> {
+
+	async disposeLoginView(contextId: string): Promise<void> {
 		const params: contracts.DisposeLoginViewRequestParams = { contextId };
-		return this.client.sendRequest(contracts.DisposeLoginViewRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.DisposeLoginViewRequest.type, params);
-			r => { },
-			e => {
-				this.client.logFailedRequest(contracts.DisposeLoginViewRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	initializeUserView(connectionUri: string, database: string, contextId: string, isNewObject: boolean, name: string | undefined): Thenable<ObjectManagement.UserViewInfo> {
+
+	async initializeUserView(connectionUri: string, database: string, contextId: string, isNewObject: boolean, name: string | undefined): Promise<ObjectManagement.UserViewInfo> {
 		const params: contracts.InitializeUserViewRequestParams = { connectionUri, database, contextId, isNewObject, name };
-		return this.client.sendRequest(contracts.InitializeUserViewRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.InitializeUserViewRequest.type, params);
-			r => {
-				return r;
-			},
-			e => {
-				this.client.logFailedRequest(contracts.InitializeUserViewRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	createUser(contextId: string, user: ObjectManagement.User): Thenable<void> {
+
+	async createUser(contextId: string, user: ObjectManagement.User): Promise<void> {
 		const params: contracts.CreateUserRequestParams = { contextId, user };
-		return this.client.sendRequest(contracts.CreateUserRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.CreateUserRequest.type, params);
-			r => { },
-			e => {
-				this.client.logFailedRequest(contracts.CreateUserRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	updateUser(contextId: string, user: ObjectManagement.User): Thenable<void> {
+
+	async updateUser(contextId: string, user: ObjectManagement.User): Promise<void> {
 		const params: contracts.UpdateUserRequestParams = { contextId, user };
-		return this.client.sendRequest(contracts.UpdateUserRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.UpdateUserRequest.type, params);
-			r => { },
-			e => {
-				this.client.logFailedRequest(contracts.UpdateUserRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	scriptUser(contextId: string, user: ObjectManagement.User): Thenable<string> {
+
+	async scriptUser(contextId: string, user: ObjectManagement.User): Promise<string> {
 		const params: contracts.ScriptUserRequestParams = { contextId, user };
-		return this.client.sendRequest(contracts.ScriptUserRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.ScriptUserRequest.type, params);
-			r => { return r; },
-			e => {
-				this.client.logFailedRequest(contracts.ScriptUserRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	disposeUserView(contextId: string): Thenable<void> {
+
+	async disposeUserView(contextId: string): Promise<void> {
 		const params: contracts.DisposeUserViewRequestParams = { contextId };
-		return this.client.sendRequest(contracts.DisposeUserViewRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.DisposeUserViewRequest.type, params);
-			r => { },
-			e => {
-				this.client.logFailedRequest(contracts.DisposeUserViewRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	rename(connectionUri: string, objectUrn: string, newName: string): Thenable<void> {
+
+	async rename(connectionUri: string, objectUrn: string, newName: string): Promise<void> {
 		const params: contracts.RenameObjectRequestParams = { connectionUri, objectUrn, newName };
-		return this.client.sendRequest(contracts.RenameObjectRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.RenameObjectRequest.type, params);
-			r => { },
-			e => {
-				this.client.logFailedRequest(contracts.RenameObjectRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
-	drop(connectionUri: string, objectUrn: string): Thenable<void> {
+	async drop(connectionUri: string, objectUrn: string): Promise<void> {
 		const params: contracts.DropObjectRequestParams = { connectionUri, objectUrn };
-		return this.client.sendRequest(contracts.DropObjectRequest.type, params).then(
+		return this.runWithErrorHandling(contracts.DropObjectRequest.type, params);
-			r => { },
-			e => {
-				this.client.logFailedRequest(contracts.DropObjectRequest.type, e);
-				return Promise.reject(e);
-			}
-		);
 	}
 }
 

extensions/mssql/src/schemaCompare/schemaCompareService.ts

@@ -3,15 +3,15 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AppContext } from '../appContext';
-import { SqlOpsDataClient, ISqlOpsFeature } from 'dataprotocol-client';
 import * as constants from '../constants';
 import * as mssql from 'mssql';
 import * as Utils from '../utils';
-import { ClientCapabilities } from 'vscode-languageclient';
 import * as azdata from 'azdata';
 import * as contracts from '../contracts';
-import { BaseService } from '../baseService';
+
+import { ClientCapabilities } from 'vscode-languageclient';
+import { AppContext } from '../appContext';
+import { SqlOpsDataClient, ISqlOpsFeature, BaseService } from 'dataprotocol-client';
 
 export class SchemaCompareService extends BaseService implements mssql.ISchemaCompareService {
 	public static asFeature(context: AppContext): ISqlOpsFeature {
@@ -34,47 +34,47 @@ export class SchemaCompareService extends BaseService implements mssql.ISchemaCo
 		context.registerService(constants.SchemaCompareService, this);
 	}
 
-	public schemaCompare(operationId: string, sourceEndpointInfo: mssql.SchemaCompareEndpointInfo, targetEndpointInfo: mssql.SchemaCompareEndpointInfo, taskExecutionMode: azdata.TaskExecutionMode, deploymentOptions: mssql.DeploymentOptions): Promise<mssql.SchemaCompareResult> {
+	public async schemaCompare(operationId: string, sourceEndpointInfo: mssql.SchemaCompareEndpointInfo, targetEndpointInfo: mssql.SchemaCompareEndpointInfo, taskExecutionMode: azdata.TaskExecutionMode, deploymentOptions: mssql.DeploymentOptions): Promise<mssql.SchemaCompareResult> {
 		const params: contracts.SchemaCompareParams = { operationId: operationId, sourceEndpointInfo: sourceEndpointInfo, targetEndpointInfo: targetEndpointInfo, taskExecutionMode: taskExecutionMode, deploymentOptions: deploymentOptions };
 		return this.runWithErrorHandling(contracts.SchemaCompareRequest.type, params);
 	}
 
-	public schemaCompareGenerateScript(operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<azdata.ResultStatus> {
+	public async schemaCompareGenerateScript(operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<azdata.ResultStatus> {
 		const params: contracts.SchemaCompareGenerateScriptParams = { operationId: operationId, targetServerName: targetServerName, targetDatabaseName: targetDatabaseName, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.SchemaCompareGenerateScriptRequest.type, params);
 	}
 
-	public schemaComparePublishDatabaseChanges(operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<azdata.ResultStatus> {
+	public async schemaComparePublishDatabaseChanges(operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<azdata.ResultStatus> {
 		const params: contracts.SchemaComparePublishDatabaseChangesParams = { operationId: operationId, targetServerName: targetServerName, targetDatabaseName: targetDatabaseName, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.SchemaComparePublishDatabaseChangesRequest.type, params);
 	}
 
-	public schemaComparePublishProjectChanges(operationId: string, targetProjectPath: string, targetFolderStructure: mssql.ExtractTarget, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.SchemaComparePublishProjectResult> {
+	public async schemaComparePublishProjectChanges(operationId: string, targetProjectPath: string, targetFolderStructure: mssql.ExtractTarget, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.SchemaComparePublishProjectResult> {
 		const params: contracts.SchemaComparePublishProjectChangesParams = { operationId: operationId, targetProjectPath: targetProjectPath, targetFolderStructure: targetFolderStructure, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.SchemaComparePublishProjectChangesRequest.type, params);
 	}
 
-	public schemaCompareGetDefaultOptions(): Promise<mssql.SchemaCompareOptionsResult> {
+	public async schemaCompareGetDefaultOptions(): Promise<mssql.SchemaCompareOptionsResult> {
 		const params: contracts.SchemaCompareGetOptionsParams = {};
 		return this.runWithErrorHandling(contracts.SchemaCompareGetDefaultOptionsRequest.type, params);
 	}
 
-	public schemaCompareIncludeExcludeNode(operationId: string, diffEntry: mssql.DiffEntry, includeRequest: boolean, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.SchemaCompareIncludeExcludeResult> {
+	public async schemaCompareIncludeExcludeNode(operationId: string, diffEntry: mssql.DiffEntry, includeRequest: boolean, taskExecutionMode: azdata.TaskExecutionMode): Promise<mssql.SchemaCompareIncludeExcludeResult> {
 		const params: contracts.SchemaCompareNodeParams = { operationId: operationId, diffEntry, includeRequest, taskExecutionMode: taskExecutionMode };
 		return this.runWithErrorHandling(contracts.SchemaCompareIncludeExcludeNodeRequest.type, params);
 	}
 
-	public schemaCompareOpenScmp(filePath: string): Promise<mssql.SchemaCompareOpenScmpResult> {
+	public async schemaCompareOpenScmp(filePath: string): Promise<mssql.SchemaCompareOpenScmpResult> {
 		const params: contracts.SchemaCompareOpenScmpParams = { filePath: filePath };
 		return this.runWithErrorHandling(contracts.SchemaCompareOpenScmpRequest.type, params);
 	}
 
-	public schemaCompareSaveScmp(sourceEndpointInfo: mssql.SchemaCompareEndpointInfo, targetEndpointInfo: mssql.SchemaCompareEndpointInfo, taskExecutionMode: azdata.TaskExecutionMode, deploymentOptions: mssql.DeploymentOptions, scmpFilePath: string, excludedSourceObjects: mssql.SchemaCompareObjectId[], excludedTargetObjects: mssql.SchemaCompareObjectId[]): Promise<azdata.ResultStatus> {
+	public async schemaCompareSaveScmp(sourceEndpointInfo: mssql.SchemaCompareEndpointInfo, targetEndpointInfo: mssql.SchemaCompareEndpointInfo, taskExecutionMode: azdata.TaskExecutionMode, deploymentOptions: mssql.DeploymentOptions, scmpFilePath: string, excludedSourceObjects: mssql.SchemaCompareObjectId[], excludedTargetObjects: mssql.SchemaCompareObjectId[]): Promise<azdata.ResultStatus> {
 		const params: contracts.SchemaCompareSaveScmpParams = { sourceEndpointInfo: sourceEndpointInfo, targetEndpointInfo: targetEndpointInfo, taskExecutionMode: taskExecutionMode, deploymentOptions: deploymentOptions, scmpFilePath: scmpFilePath, excludedSourceObjects: excludedSourceObjects, excludedTargetObjects: excludedTargetObjects };
 		return this.runWithErrorHandling(contracts.SchemaCompareSaveScmpRequest.type, params);
 	}
 
-	public schemaCompareCancel(operationId: string): Promise<azdata.ResultStatus> {
+	public async schemaCompareCancel(operationId: string): Promise<azdata.ResultStatus> {
 		const params: contracts.SchemaCompareCancelParams = { operationId: operationId };
 		return this.runWithErrorHandling(contracts.SchemaCompareCancellationRequest.type, params);
 	}

extensions/mssql/src/sqlAssessment/sqlAssessmentService.ts

@@ -4,15 +4,15 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as mssql from 'mssql';
-import { AppContext } from '../appContext';
-import { SqlOpsDataClient, ISqlOpsFeature } from 'dataprotocol-client';
-import { ClientCapabilities } from 'vscode-languageclient';
-import * as constants from '../constants';
 import * as azdata from 'azdata';
 import * as contracts from '../contracts';
+import * as constants from '../constants';
 
+import { AppContext } from '../appContext';
+import { SqlOpsDataClient, ISqlOpsFeature, BaseService } from 'dataprotocol-client';
+import { ClientCapabilities } from 'vscode-languageclient';
 
-export class SqlAssessmentService implements mssql.ISqlAssessmentService {
+export class SqlAssessmentService extends BaseService implements mssql.ISqlAssessmentService {
 	public static asFeature(context: AppContext): ISqlOpsFeature {
 		return class extends SqlAssessmentService {
 			constructor(client: SqlOpsDataClient) {
@@ -27,38 +27,20 @@ export class SqlAssessmentService implements mssql.ISqlAssessmentService {
 		};
 	}
 
-	private constructor(context: AppContext, protected readonly client: SqlOpsDataClient) {
+	private constructor(context: AppContext, client: SqlOpsDataClient) {
+		super(client);
 		context.registerService(constants.SqlAssessmentService, this);
 	}
 	async assessmentInvoke(ownerUri: string, targetType: azdata.sqlAssessment.SqlAssessmentTargetType): Promise<azdata.SqlAssessmentResult> {
 		let params: contracts.SqlAssessmentParams = { ownerUri: ownerUri, targetType: targetType };
-		try {
+		return this.runWithErrorHandling(contracts.SqlAssessmentInvokeRequest.type, params);
-			return await this.client.sendRequest(contracts.SqlAssessmentInvokeRequest.type, params);
-		}
-		catch (e) {
-			this.client.logFailedRequest(contracts.SqlAssessmentInvokeRequest.type, e);
-			throw e;
-		}
 	}
 	async getAssessmentItems(ownerUri: string, targetType: azdata.sqlAssessment.SqlAssessmentTargetType): Promise<azdata.SqlAssessmentResult> {
 		let params: contracts.SqlAssessmentParams = { ownerUri: ownerUri, targetType: targetType };
-		try {
+		return this.runWithErrorHandling(contracts.GetSqlAssessmentItemsRequest.type, params);
-			return await this.client.sendRequest(contracts.GetSqlAssessmentItemsRequest.type, params);
-		}
-		catch (e) {
-			this.client.logFailedRequest(contracts.GetSqlAssessmentItemsRequest.type, e);
-			throw e;
-		}
 	}
 	async generateAssessmentScript(items: azdata.SqlAssessmentResultItem[], targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Promise<azdata.ResultStatus> {
 		let params: contracts.GenerateSqlAssessmentScriptParams = { items: items, targetServerName: targetServerName, targetDatabaseName: targetDatabaseName, taskExecutionMode: taskExecutionMode };
-		try {
+		return this.runWithErrorHandling(contracts.GenerateSqlAssessmentScriptRequest.type, params);
-			return await this.client.sendRequest(contracts.GenerateSqlAssessmentScriptRequest.type, params);
-		}
-		catch (e) {
-			this.client.logFailedRequest(contracts.GenerateSqlAssessmentScriptRequest.type, e);
-			throw e;
-		}
 	}
-
 }

extensions/mssql/src/sqlProjects/sqlProjectsService.ts

@@ -8,10 +8,10 @@ import * as constants from '../constants';
 import * as Utils from '../utils';
 import * as azdata from 'azdata';
 import * as contracts from '../contracts';
+
 import { AppContext } from '../appContext';
-import { ISqlOpsFeature, SqlOpsDataClient } from 'dataprotocol-client';
+import { BaseService, ISqlOpsFeature, SqlOpsDataClient } from 'dataprotocol-client';
 import { ClientCapabilities } from 'vscode-languageclient';
-import { BaseService } from '../baseService';
 
 export class SqlProjectsService extends BaseService implements mssql.ISqlProjectsService {
 	public static asFeature(context: AppContext): ISqlOpsFeature {

extensions/mssql/yarn.lock

@@ -425,9 +425,9 @@ crypt@~0.0.1:
   resolved "https://registry.yarnpkg.com/crypt/-/crypt-0.0.2.tgz#88d7ff7ec0dfb86f713dc87bbb42d044d3e6c41b"
   integrity sha1-iNf/fsDfuG9xPch7u0LQRNPmxBs=
 
-"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.2":
+"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.4":
-  version "1.3.2"
+  version "1.3.4"
-  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/e3be16cffbac882ef545e4da9654a82dc010d1b7"
+  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/fed4e05caadd89e1f635cc247b82a96a10bc837d"
   dependencies:
     vscode-languageclient "5.2.1"
 

extensions/sql-migration/package.json

@@ -162,7 +162,7 @@
     ]
   },
   "dependencies": {
-    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.1",
+    "dataprotocol-client": "github:Microsoft/sqlops-dataprotocolclient#1.3.4",
     "@microsoft/ads-service-downloader": "^1.2.1",
     "@microsoft/ads-extension-telemetry": "^3.0.1",
     "uuid": "^8.3.2",

extensions/sql-migration/yarn.lock

@@ -62,9 +62,9 @@ chownr@^2.0.0:
   resolved "https://registry.yarnpkg.com/chownr/-/chownr-2.0.0.tgz#15bfbe53d2eab4cf70f18a8cd68ebe5b3cb1dece"
   integrity sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==
 
-"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.1":
+"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.4":
-  version "1.3.1"
+  version "1.3.4"
-  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/2df6982e07c0208c2b8a5f8cd4b3d65944138d15"
+  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/fed4e05caadd89e1f635cc247b82a96a10bc837d"
   dependencies:
     vscode-languageclient "5.2.1"