ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-16 10:58:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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>
This commit is contained in:
Benjin Dubishar
2023-04-14 16:08:07 -07:00
committed by GitHub
parent 47bf7efd4a
commit b1c2cc1740
22 changed files with 155 additions and 355 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
extensions/mssql/package.json
View File

@@ -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"

16
extensions/mssql/src/azureBlob/azureBlobService.ts
View File

@@ -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(
undefined,
e => {
this.client.logFailedRequest(contracts.CreateSasRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.CreateSasRequest.type, params);
}
}

30
extensions/mssql/src/baseService.ts
View File

@@ -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;
}
}
}

103
extensions/mssql/src/cms/cmsService.ts
View File

@@ -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> {
let connectparams: ConnectParams = { ownerUri: ownerUri, connection: connectiondetails };
let cmsparams: contracts.CreateCentralManagementServerParams = { registeredServerName: name, registeredServerDescription: description, connectParams: connectparams };
return this.client.sendRequest(contracts.CreateCentralManagementServerRequest.type, cmsparams).then(
r => {
return r;
},
e => {
this.client.logFailedRequest(contracts.CreateCentralManagementServerRequest.type, e);
return Promise.reject(e);
}
);
async createCmsServer(name: string, description: string, connectiondetails: azdata.ConnectionInfo, ownerUri: string): Promise<ListRegisteredServersResult> {
const params: contracts.CreateCentralManagementServerParams = { registeredServerName: name, registeredServerDescription: description, connectParams: { ownerUri: ownerUri, connection: connectiondetails } };
return this.runWithErrorHandling(contracts.CreateCentralManagementServerRequest.type, params);
}
getRegisteredServers(ownerUri: string, relativePath: string): Thenable<ListRegisteredServersResult> {
let params: contracts.ListRegisteredServersParams = { parentOwnerUri: ownerUri, relativePath: relativePath };
return this.client.sendRequest(contracts.ListRegisteredServersRequest.type, params).then(
r => {
return r;
},
e => {
this.client.logFailedRequest(contracts.ListRegisteredServersRequest.type, e);
return Promise.reject(e);
}
);
async getRegisteredServers(ownerUri: string, relativePath: string): Promise<ListRegisteredServersResult> {
const params: contracts.ListRegisteredServersParams = { parentOwnerUri: ownerUri, relativePath: relativePath };
return this.runWithErrorHandling(contracts.ListRegisteredServersRequest.type, params);
}
addRegisteredServer(ownerUri: string, relativePath: string, registeredServerName: string, registeredServerDescription: string, connectionDetails: azdata.ConnectionInfo): Thenable<boolean> {
let params: contracts.AddRegisteredServerParams = { parentOwnerUri: ownerUri, relativePath: relativePath, registeredServerName: registeredServerName, registeredServerDescription: registeredServerDescription, registeredServerConnectionDetails: connectionDetails };
return this.client.sendRequest(contracts.AddRegisteredServerRequest.type, params).then(
r => {
return r;
},
e => {
this.client.logFailedRequest(contracts.AddRegisteredServerRequest.type, e);
return Promise.reject(e);
}
);
async addRegisteredServer(ownerUri: string, relativePath: string, registeredServerName: string, registeredServerDescription: string, connectionDetails: azdata.ConnectionInfo): Promise<boolean> {
const params: contracts.AddRegisteredServerParams = { parentOwnerUri: ownerUri, relativePath: relativePath, registeredServerName: registeredServerName, registeredServerDescription: registeredServerDescription, registeredServerConnectionDetails: connectionDetails };
return this.runWithErrorHandling(contracts.AddRegisteredServerRequest.type, params);
}
removeRegisteredServer(ownerUri: string, relativePath: string, registeredServerName: string): Thenable<boolean> {
let params: contracts.RemoveRegisteredServerParams = { parentOwnerUri: ownerUri, relativePath: relativePath, registeredServerName: registeredServerName };
return this.client.sendRequest(contracts.RemoveRegisteredServerRequest.type, params).then(
r => {
return r;
},
e => {
this.client.logFailedRequest(contracts.RemoveRegisteredServerRequest.type, e);
return Promise.reject(e);
}
);
async removeRegisteredServer(ownerUri: string, relativePath: string, registeredServerName: string): Promise<boolean> {
const params: contracts.RemoveRegisteredServerParams = { parentOwnerUri: ownerUri, relativePath: relativePath, registeredServerName: registeredServerName };
return this.runWithErrorHandling(contracts.RemoveRegisteredServerRequest.type, params);
}
addServerGroup(ownerUri: string, relativePath: string, groupName: string, groupDescription: string): Thenable<boolean> {
let params: contracts.AddServerGroupParams = { parentOwnerUri: ownerUri, relativePath: relativePath, groupName: groupName, groupDescription: groupDescription };
return this.client.sendRequest(contracts.AddServerGroupRequest.type, params).then(
r => {
return r;
},
e => {
this.client.logFailedRequest(contracts.AddServerGroupRequest.type, e);
return Promise.reject(new Error(e.message));
}
);
async addServerGroup(ownerUri: string, relativePath: string, groupName: string, groupDescription: string): Promise<boolean> {
const params: contracts.AddServerGroupParams = { parentOwnerUri: ownerUri, relativePath: relativePath, groupName: groupName, groupDescription: groupDescription };
return this.runWithErrorHandling(contracts.AddServerGroupRequest.type, params);
}
removeServerGroup(ownerUri: string, relativePath: string, groupName: string): Thenable<boolean> {
let params: contracts.RemoveServerGroupParams = { parentOwnerUri: ownerUri, relativePath: relativePath, groupName: groupName };
return this.client.sendRequest(contracts.RemoveServerGroupRequest.type, params).then(
r => {
return r;
},
e => {
this.client.logFailedRequest(contracts.RemoveServerGroupRequest.type, e);
return Promise.reject(new Error(e.message));
}
);
async removeServerGroup(ownerUri: string, relativePath: string, groupName: string): Promise<boolean> {
const params: contracts.RemoveServerGroupParams = { parentOwnerUri: ownerUri, relativePath: relativePath, groupName: groupName };
return this.runWithErrorHandling(contracts.RemoveServerGroupRequest.type, params);
}
dispose() {
}
dispose() { }
}

21
extensions/mssql/src/dacfx/dacFxService.ts
View File

@@ -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);
}

45
extensions/mssql/src/languageExtension/languageExtensionService.ts
View File

@@ -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(
r => {
return r.languages;
},
e => {
this.client.logFailedRequest(contracts.LanguageExtensibilityListRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.LanguageExtensibilityListRequest.type, params).then((r) => r.languages);
}
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(
() => {
},
e => {
this.client.logFailedRequest(contracts.LanguageExtensibilityUpdateRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.LanguageExtensibilityUpdateRequest.type, params).then();
}
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(
() => {
},
e => {
this.client.logFailedRequest(contracts.LanguageExtensibilityDeleteRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.LanguageExtensibilityDeleteRequest.type, params).then();
}
}

30
extensions/mssql/src/notebookConvert/notebookConvertService.ts
View File

@@ -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.client.sendRequest(contracts.ConvertNotebookToSqlRequest.type, params);
}
catch (e) {
this.client.logFailedRequest(contracts.ConvertNotebookToSqlRequest.type, e);
}
return undefined;
return this.runWithErrorHandling(contracts.ConvertNotebookToSqlRequest.type, params);
}
async convertSqlToNotebook(content: string): Promise<contracts.ConvertSqlToNotebookResult | undefined> {
let params: contracts.ConvertSqlToNotebookParams = { clientUri: content };
try {
return this.client.sendRequest(contracts.ConvertSqlToNotebookRequest.type, params);
}
catch (e) {
this.client.logFailedRequest(contracts.ConvertSqlToNotebookRequest.type, e);
}
return undefined;
return this.runWithErrorHandling(contracts.ConvertSqlToNotebookRequest.type, params);
}
}

149
extensions/mssql/src/objectManagement/objectManagementService.ts
View File

@@ -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(
r => {
return r;
},
e => {
this.client.logFailedRequest(contracts.InitializeLoginViewRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.InitializeLoginViewRequest.type, params);
}
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(
r => { },
e => {
this.client.logFailedRequest(contracts.CreateLoginRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.CreateLoginRequest.type, params);
}
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(
r => { },
e => {
this.client.logFailedRequest(contracts.UpdateLoginRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.UpdateLoginRequest.type, params);
}
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(
r => { return r; },
e => {
this.client.logFailedRequest(contracts.ScriptLoginRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.ScriptLoginRequest.type, params);
}
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(
r => { },
e => {
this.client.logFailedRequest(contracts.DisposeLoginViewRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.DisposeLoginViewRequest.type, params);
}
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(
r => {
return r;
},
e => {
this.client.logFailedRequest(contracts.InitializeUserViewRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.InitializeUserViewRequest.type, params);
}
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(
r => { },
e => {
this.client.logFailedRequest(contracts.CreateUserRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.CreateUserRequest.type, params);
}
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(
r => { },
e => {
this.client.logFailedRequest(contracts.UpdateUserRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.UpdateUserRequest.type, params);
}
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(
r => { return r; },
e => {
this.client.logFailedRequest(contracts.ScriptUserRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.ScriptUserRequest.type, params);
}
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(
r => { },
e => {
this.client.logFailedRequest(contracts.DisposeUserViewRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.DisposeUserViewRequest.type, params);
}
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(
r => { },
e => {
this.client.logFailedRequest(contracts.RenameObjectRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.RenameObjectRequest.type, params);
}
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(
r => { },
e => {
this.client.logFailedRequest(contracts.DropObjectRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.DropObjectRequest.type, params);
}
}

26
extensions/mssql/src/schemaCompare/schemaCompareService.ts
View File

@@ -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);
}

38
extensions/mssql/src/sqlAssessment/sqlAssessmentService.ts
View File

@@ -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 await this.client.sendRequest(contracts.SqlAssessmentInvokeRequest.type, params);
}
catch (e) {
this.client.logFailedRequest(contracts.SqlAssessmentInvokeRequest.type, e);
throw e;
}
return this.runWithErrorHandling(contracts.SqlAssessmentInvokeRequest.type, params);
}
async getAssessmentItems(ownerUri: string, targetType: azdata.sqlAssessment.SqlAssessmentTargetType): Promise<azdata.SqlAssessmentResult> {
let params: contracts.SqlAssessmentParams = { ownerUri: ownerUri, targetType: targetType };
try {
return await this.client.sendRequest(contracts.GetSqlAssessmentItemsRequest.type, params);
}
catch (e) {
this.client.logFailedRequest(contracts.GetSqlAssessmentItemsRequest.type, e);
throw e;
}
return this.runWithErrorHandling(contracts.GetSqlAssessmentItemsRequest.type, params);
}
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 await this.client.sendRequest(contracts.GenerateSqlAssessmentScriptRequest.type, params);
}
catch (e) {
this.client.logFailedRequest(contracts.GenerateSqlAssessmentScriptRequest.type, e);
throw e;
}
return this.runWithErrorHandling(contracts.GenerateSqlAssessmentScriptRequest.type, params);
}
}

4
extensions/mssql/src/sqlProjects/sqlProjectsService.ts
View File

@@ -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 {

6
extensions/mssql/yarn.lock
View File

@@ -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":
version "1.3.2"
resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/e3be16cffbac882ef545e4da9654a82dc010d1b7"
"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#1.3.4":
version "1.3.4"
resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/fed4e05caadd89e1f635cc247b82a96a10bc837d"
dependencies:
vscode-languageclient "5.2.1"