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

Changing dacFxService and schemaCompareService to use shared logic for error handling (#22718)

Browse Source 
* Move helper function to base class

* Switching DacFxService over

* Thenable -> Promise

* Converting SchemaCompareService
This commit is contained in:
Benjin Dubishar
2023-04-13 12:44:13 -07:00
committed by GitHub
parent 35e1d63871
commit 8202e1ec4e
5 changed files with 85 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -4,15 +4,17 @@
*--------------------------------------------------------------------------------------------*/
import * as mssql from 'mssql';
import { AppContext } from '../appContext';
import { ISqlOpsFeature, SqlOpsDataClient } from 'dataprotocol-client';
import { ClientCapabilities } from 'vscode-languageclient';
import * as constants from '../constants';
import * as Utils from '../utils';
import * as azdata from 'azdata';
import * as contracts from '../contracts';
export class DacFxService implements mssql.IDacFxService {
import { AppContext } from '../appContext';
import { 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 {
return class extends DacFxService {
constructor(client: SqlOpsDataClient) {
@@ -28,117 +30,58 @@ export class DacFxService implements mssql.IDacFxService {
};
}
private constructor(context: AppContext, protected readonly client: SqlOpsDataClient) {
private constructor(context: AppContext, client: SqlOpsDataClient) {
super(client);
context.registerService(constants.DacFxService, this);
}
public exportBacpac(databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.DacFxResult> {
public 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.client.sendRequest(contracts.ExportRequest.type, params).then(
undefined,
e => {
this.client.logFailedRequest(contracts.ExportRequest.type, e);
return Promise.reject(e);
}
);
return this.runWithErrorHandling(contracts.ExportRequest.type, params);
}
public importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.DacFxResult> {
public 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.client.sendRequest(contracts.ImportRequest.type, params).then(
undefined,
e => {
this.client.logFailedRequest(contracts.ImportRequest.type, e);
return Promise.reject(undefined);
}
);
return this.runWithErrorHandling(contracts.ImportRequest.type, params);
}
public extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.DacFxResult> {
public 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.client.sendRequest(contracts.ExtractRequest.type, params).then(
undefined,
e => {
this.client.logFailedRequest(contracts.ExtractRequest.type, e);
return Promise.reject(undefined);
}
);
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): Thenable<mssql.DacFxResult> {
public 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.client.sendRequest(contracts.ExtractRequest.type, params).then(
undefined,
e => {
this.client.logFailedRequest(contracts.ExtractRequest.type, e);
return Promise.reject(undefined);
}
);
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): Thenable<mssql.DacFxResult> {
public 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.client.sendRequest(contracts.DeployRequest.type, params).then(
undefined,
e => {
this.client.logFailedRequest(contracts.DeployRequest.type, e);
return Promise.reject(undefined);
}
);
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): Thenable<mssql.DacFxResult> {
public 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.client.sendRequest(contracts.GenerateDeployScriptRequest.type, params).then(
undefined,
e => {
this.client.logFailedRequest(contracts.GenerateDeployScriptRequest.type, e);
return Promise.reject(undefined);
}
);
return this.runWithErrorHandling(contracts.GenerateDeployScriptRequest.type, params);
}
public generateDeployPlan(packageFilePath: string, targetDatabaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<mssql.GenerateDeployPlanResult> {
public 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.client.sendRequest(contracts.GenerateDeployPlanRequest.type, params).then(
undefined,
e => {
this.client.logFailedRequest(contracts.GenerateDeployPlanRequest.type, e);
return Promise.reject(undefined);
}
);
return this.runWithErrorHandling(contracts.GenerateDeployPlanRequest.type, params);
}
public getOptionsFromProfile(profilePath: string): Thenable<mssql.DacFxOptionsResult> {
public getOptionsFromProfile(profilePath: string): Promise<mssql.DacFxOptionsResult> {
const params: contracts.GetOptionsFromProfileParams = { profilePath: profilePath };
return this.client.sendRequest(contracts.GetOptionsFromProfileRequest.type, params).then(
undefined,
e => {
this.client.logFailedRequest(contracts.GetOptionsFromProfileRequest.type, e);
return Promise.reject(undefined);
}
);
return this.runWithErrorHandling(contracts.GetOptionsFromProfileRequest.type, params);
}
public validateStreamingJob(packageFilePath: string, createStreamingJobTsql: string): Thenable<mssql.ValidateStreamingJobResult> {
public validateStreamingJob(packageFilePath: string, createStreamingJobTsql: string): Promise<mssql.ValidateStreamingJobResult> {
const params: contracts.ValidateStreamingJobParams = { packageFilePath: packageFilePath, createStreamingJobTsql: createStreamingJobTsql };
return this.client.sendRequest(contracts.ValidateStreamingJobRequest.type, params).then(
undefined,
e => {
this.client.logFailedRequest(contracts.ValidateStreamingJobRequest.type, e);
return Promise.reject(undefined);
}
);
return this.runWithErrorHandling(contracts.ValidateStreamingJobRequest.type, params);
}
public async parseTSqlScript(filePath: string, databaseSchemaProvider: string): Promise<mssql.ParseTSqlScriptResult> {
const params: contracts.ParseTSqlScriptParams = { filePath, databaseSchemaProvider };
try {
const result = await this.client.sendRequest(contracts.ParseTSqlScriptRequest.type, params);
return result;
} catch (e) {
this.client.logFailedRequest(contracts.ParseTSqlScriptRequest.type, e);
throw e;
}
return this.runWithErrorHandling(contracts.ParseTSqlScriptRequest.type, params);
}
}