Schema compare publish (#5127)

* adding publish command

extensions/mssql/src/config.json

@@ -1,6 +1,6 @@
 {
 	"downloadUrl": "https://github.com/Microsoft/sqltoolsservice/releases/download/v{#version#}/microsoft.sqltools.servicelayer-{#fileName#}",
-	"version": "1.5.0-alpha.85",
+	"version": "1.5.0-alpha.87",
 	"downloadFileNames": {
 		"Windows_86": "win-x86-netcoreapp2.2.zip",
 		"Windows_64": "win-x64-netcoreapp2.2.zip",

extensions/mssql/src/contracts.ts

@@ -448,6 +448,13 @@ export interface SchemaCompareGenerateScriptParams {
 	taskExecutionMode: TaskExecutionMode;
 }
 
+export interface SchemaComparePublishChangesParams {
+	operationId: string;
+	targetServerName: string;
+	targetDatabaseName: string;
+	taskExecutionMode: TaskExecutionMode;
+}
+
 export namespace SchemaCompareRequest {
 	export const type = new RequestType<SchemaCompareParams, azdata.SchemaCompareResult, void, void>('schemaCompare/compare');
 }
@@ -455,4 +462,8 @@ export namespace SchemaCompareRequest {
 export namespace SchemaCompareGenerateScriptRequest {
 	export const type = new RequestType<SchemaCompareGenerateScriptParams, azdata.ResultStatus, void, void>('schemaCompare/generateScript');
 }
+
+export namespace SchemaComparePublishChangesRequest {
+	export const type = new RequestType<SchemaComparePublishChangesParams, azdata.ResultStatus, void, void>('schemaCompare/publish');
+}
 // ------------------------------- <Schema Compare> -----------------------------

extensions/mssql/src/features.ts

@@ -178,7 +178,7 @@ export class SchemaCompareServicesFeature extends SqlOpsFeature<undefined> {
 			);
 		};
 
-		let schemaCompareGenerateScript = (operationId: string, targetDatabaseName: string, scriptFilePath: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> => {
+		let schemaCompareGenerateScript = (operationId: string, targetDatabaseName: string, scriptFilePath: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.ResultStatus> => {
 			let params: contracts.SchemaCompareGenerateScriptParams = { operationId: operationId, targetDatabaseName: targetDatabaseName, scriptFilePath: scriptFilePath, taskExecutionMode: taskExecutionMode };
 			return client.sendRequest(contracts.SchemaCompareGenerateScriptRequest.type, params).then(
 				r => {
@@ -191,10 +191,24 @@ export class SchemaCompareServicesFeature extends SqlOpsFeature<undefined> {
 			);
 		};
 
+		let schemaComparePublishChanges = (operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.ResultStatus> => {
+			let params: contracts.SchemaComparePublishChangesParams = { operationId: operationId, targetServerName: targetServerName, targetDatabaseName: targetDatabaseName, taskExecutionMode: taskExecutionMode };
+			return client.sendRequest(contracts.SchemaComparePublishChangesRequest.type, params).then(
+				r => {
+					return r;
+				},
+				e => {
+					client.logFailedRequest(contracts.SchemaComparePublishChangesRequest.type, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
 		return azdata.dataprotocol.registerSchemaCompareServicesProvider({
 			providerId: client.providerId,
 			schemaCompare,
-			schemaCompareGenerateScript
+			schemaCompareGenerateScript,
+			schemaComparePublishChanges
 		});
 	}
 }

extensions/schema-compare/src/dialogs/schemaCompareDialog.ts

@@ -82,6 +82,7 @@ export class SchemaCompareDialog {
 			sourceName = this.sourceTextBox.value;
 			sourceEndpointInfo = {
 				endpointType: azdata.SchemaCompareEndpointType.dacpac,
+				serverName: '',
 				databaseName: '',
 				ownerUri: '',
 				packageFilePath: this.sourceTextBox.value
@@ -92,6 +93,7 @@ export class SchemaCompareDialog {
 
 			sourceEndpointInfo = {
 				endpointType: azdata.SchemaCompareEndpointType.database,
+				serverName: (this.sourceServerDropdown.value as ConnectionDropdownValue).name,
 				databaseName: (<azdata.CategoryValue>this.sourceDatabaseDropdown.value).name,
 				ownerUri: ownerUri,
 				packageFilePath: ''
@@ -103,6 +105,7 @@ export class SchemaCompareDialog {
 			targetName = this.targetTextBox.value;
 			targetEndpointInfo = {
 				endpointType: azdata.SchemaCompareEndpointType.dacpac,
+				serverName: '',
 				databaseName: '',
 				ownerUri: '',
 				packageFilePath: this.targetTextBox.value
@@ -113,6 +116,7 @@ export class SchemaCompareDialog {
 
 			targetEndpointInfo = {
 				endpointType: azdata.SchemaCompareEndpointType.database,
+				serverName: (this.targetServerDropdown.value as ConnectionDropdownValue).name,
 				databaseName: (<azdata.CategoryValue>this.targetDatabaseDropdown.value).name,
 				ownerUri: ownerUri,
 				packageFilePath: ''

extensions/schema-compare/src/media/start-inverse.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M14 8L4 15V1L14 8Z" fill="#4894FE"/>
+</svg>

extensions/schema-compare/src/media/start.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M14 8L4 15V1L14 8Z" fill="#015CDA"/>
+</svg>

extensions/schema-compare/src/schemaCompareResult.ts

@@ -22,6 +22,7 @@ export class SchemaCompareResult {
 	private switchButton: azdata.ButtonComponent;
 	private compareButton: azdata.ButtonComponent;
 	private generateScriptButton: azdata.ButtonComponent;
+	private applyButton: azdata.ButtonComponent;
 	private SchemaCompareActionMap: Map<Number, string>;
 	private comparisonResult: azdata.SchemaCompareResult;
 	private sourceNameComponent: azdata.TableComponent;
@@ -65,16 +66,18 @@ export class SchemaCompareResult {
 			this.createSwitchButton(view);
 			this.createCompareButton(view);
 			this.createGenerateScriptButton(view);
+			this.createApplyButton(view);
 			this.resetButtons();
 
 			let toolBar = view.modelBuilder.toolbarContainer();
 			toolBar.addToolbarItems([{
 				component: this.compareButton
 			}, {
-				component: this.generateScriptButton,
+				component: this.generateScriptButton
+			}, {
+				component: this.applyButton,
 				toolbarSeparatorAfter: true
-			},
+			}, {
-			{
 				component: this.switchButton
 			}]);
 
@@ -192,8 +195,10 @@ export class SchemaCompareResult {
 			// only enable generate script button if the target is a db
 			if (this.targetEndpointInfo.endpointType === azdata.SchemaCompareEndpointType.database) {
 				this.generateScriptButton.enabled = true;
+				this.applyButton.enabled = true;
 			} else {
 				this.generateScriptButton.title = localize('schemaCompare.generateScriptButtonDisabledTitle', 'Generate script is enabled when the target is a database');
+				this.applyButton.title = localize('schemaCompare.applyButtonDisabledTitle', 'Apply is enabled when the target is a database');
 			}
 		} else {
 			this.flexModel.addItem(this.noDifferencesLabel, { CSSStyles: { 'margin': 'auto' } });
@@ -310,11 +315,33 @@ export class SchemaCompareResult {
 		});
 	}
 
+	private createApplyButton(view: azdata.ModelView) {
+
+		this.applyButton = view.modelBuilder.button().withProperties({
+			label: localize('schemaCompare.updateButton', 'Apply'),
+			iconPath: {
+				light: path.join(__dirname, 'media', 'start.svg'),
+				dark: path.join(__dirname, 'media', 'start-inverse.svg')
+			},
+		}).component();
+
+		this.applyButton.onDidClick(async (click) => {
+			let service = await SchemaCompareResult.getService('MSSQL');
+			let result = await service.schemaComparePublishChanges(this.comparisonResult.operationId, this.targetEndpointInfo.serverName, this.targetEndpointInfo.databaseName, azdata.TaskExecutionMode.execute);
+			if (!result || !result.success) {
+				vscode.window.showErrorMessage(
+					localize('schemaCompare.updateErrorMessage', "Schema Compare Apply failed '{0}'", result.errorMessage ? result.errorMessage : 'Unknown'));
+			}
+		});
+	}
+
 	private resetButtons(): void {
 		this.compareButton.enabled = false;
 		this.switchButton.enabled = false;
 		this.generateScriptButton.enabled = false;
+		this.applyButton.enabled = false;
 		this.generateScriptButton.title = localize('schemaCompare.generateScriptEnabledButton', 'Generate script to deploy changes to target');
+		this.applyButton.title = localize('schemaCompare.applyButtonEnabledTitle', 'Apply changes to target');
 	}
 
 	private createSwitchButton(view: azdata.ModelView): void {

src/sql/azdata.proposed.d.ts

@@ -1737,6 +1737,7 @@ declare module 'azdata' {
 	export interface SchemaCompareEndpointInfo {
 		endpointType: SchemaCompareEndpointType;
 		packageFilePath: string;
+		serverName: string;
 		databaseName: string;
 		ownerUri: string;
 	}
@@ -1744,6 +1745,7 @@ declare module 'azdata' {
 	export interface SchemaCompareServicesProvider extends DataProvider {
 		schemaCompare(sourceEndpointInfo: SchemaCompareEndpointInfo, targetEndpointInfo: SchemaCompareEndpointInfo, taskExecutionMode: TaskExecutionMode): Thenable<SchemaCompareResult>;
 		schemaCompareGenerateScript(operationId: string, targetDatabaseName: string, scriptFilePath: string, taskExecutionMode: TaskExecutionMode): Thenable<ResultStatus>;
+		schemaComparePublishChanges(operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: TaskExecutionMode): Thenable<ResultStatus>;
 	}
 
 	// Security service interfaces ------------------------------------------------------------------------

src/sql/platform/schemaCompare/common/schemaCompareService.ts

@@ -19,6 +19,7 @@ export interface ISchemaCompareService {
 	registerProvider(providerId: string, provider: azdata.SchemaCompareServicesProvider): void;
 	schemaCompare(sourceEndpointInfo: azdata.SchemaCompareEndpointInfo, targetEndpointInfo: azdata.SchemaCompareEndpointInfo, taskExecutionMode: azdata.TaskExecutionMode): void;
 	schemaCompareGenerateScript(operationId: string, targetDatabaseName: string, scriptFilePath: string, taskExecutionMode: azdata.TaskExecutionMode): void;
+	schemaComparePublishChanges(operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): void;
 }
 
 export class SchemaCompareService implements ISchemaCompareService {
@@ -43,6 +44,12 @@ export class SchemaCompareService implements ISchemaCompareService {
 		});
 	}
 
+	schemaComparePublishChanges(operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.ResultStatus> {
+		return this._runAction('', (runner) => {
+			return runner.schemaComparePublishChanges(operationId, targetServerName, targetDatabaseName, taskExecutionMode);
+		});
+	}
+
 	private _runAction<T>(uri: string, action: (handler: azdata.SchemaCompareServicesProvider) => Thenable<T>): Thenable<T> {
 		let providerId: string = this._connectionService.getProviderIdFromUri(uri);
 

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

@@ -462,6 +462,9 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 			},
 			schemaCompareGenerateScript(operationId: string, targetDatabaseName: string, scriptFilePath: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.ResultStatus> {
 				return self._proxy.$schemaCompareGenerateScript(handle, operationId, targetDatabaseName, scriptFilePath, taskExecutionMode);
+			},
+			schemaComparePublishChanges(operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.ResultStatus> {
+				return self._proxy.$schemaComparePublishChanges(handle, operationId, targetServerName, targetDatabaseName, taskExecutionMode);
 			}
 		});
 

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

@@ -463,6 +463,11 @@ export abstract class ExtHostDataProtocolShape {
 	 * Schema compare generate script
 	 */
 	$schemaCompareGenerateScript(handle: number, operationId: string, targetDatabaseName: string, scriptFilePath: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.ResultStatus> { throw ni(); }
+
+	/**
+	 * Schema compare publish changes
+	 */
+	$schemaComparePublishChanges(handle: number, operationId: string, targetServerName: string, targetDatabaseName: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.SchemaCompareResult> { throw ni(); }
 }
 
 /**