remove sql ops (#8805)

build/gulpfile.vscode.js

@@ -236,7 +236,6 @@ function packageTask(platform, arch, sourceFolderName, destinationFolderName, op
 		const api = gulp.src('src/vs/vscode.d.ts').pipe(rename('out/vs/vscode.d.ts'));
 		// {{SQL CARBON EDIT}}
 		const dataApi = gulp.src('src/sql/azdata.d.ts').pipe(rename('out/sql/azdata.d.ts'));
-		const sqlopsAPI = gulp.src('src/sql/sqlops.d.ts').pipe(rename('out/sql/sqlops.d.ts'));
 
 		const telemetry = gulp.src('.build/telemetry/**', { base: '.build/telemetry', dot: true });
 
@@ -253,8 +252,7 @@ function packageTask(platform, arch, sourceFolderName, destinationFolderName, op
 			productJsonStream,
 			license,
 			api,
-			dataApi,
+			dataApi, // {{SQL CARBON EDIT}}
-			sqlopsAPI, // {{SQL CARBON EDIT}}
 			telemetry,
 			sources,
 			deps

extensions/dacpac/src/typings/ref.d.ts

@@ -4,8 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 /// <reference path='../../../../src/vs/vscode.d.ts'/>
-/// <reference path='../../../../src/sql/sqlops.d.ts'/>
-/// <reference path='../../../../src/sql/sqlops.proposed.d.ts'/>
 /// <reference path='../../../../src/sql/azdata.d.ts'/>
 /// <reference path='../../../../src/sql/azdata.proposed.d.ts'/>
-/// <reference types='@types/node'/>
+/// <reference types='@types/node'/>

extensions/import/src/typings/ref.d.ts

@@ -4,8 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 /// <reference path='../../../../src/vs/vscode.d.ts'/>
-/// <reference path='../../../../src/sql/sqlops.d.ts'/>
-/// <reference path='../../../../src/sql/sqlops.proposed.d.ts'/>
 /// <reference path='../../../../src/sql/azdata.d.ts'/>
 /// <reference path='../../../../src/sql/azdata.proposed.d.ts'/>
-/// <reference types='@types/node'/>
+/// <reference types='@types/node'/>

extensions/mssql/src/typings/refs.d.ts

@@ -3,8 +3,6 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-/// <reference path='../../../../src/sql/sqlops.d.ts'/>
-/// <reference path='../../../../src/sql/sqlops.proposed.d.ts'/>
 /// <reference path='../../../../src/sql/azdata.d.ts'/>
 /// <reference path='../../../../src/sql/azdata.proposed.d.ts'/>
 /// <reference path='../../../../src/vs/vscode.d.ts'/>

extensions/shared.webpack.config.js

@@ -57,8 +57,7 @@ module.exports = function withDefaults(/**@type WebpackConfig*/extConfig) {
 		},
 		externals: {
 			'vscode': 'commonjs vscode', // ignored because it doesn't exist
-			'azdata': 'commonjs azdata',
+			'azdata': 'commonjs azdata'
-			'sqlops': 'commonjs sqlops'
 		},
 		output: {
 			// all output goes into `dist`.

samples/extensionSamples/src/controllers/mainController.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as Utils from '../utils';
 import ControllerBase from './controllerBase';
 import * as fs from 'fs';
@@ -15,47 +15,43 @@ import * as path from 'path';
  * The main controller class that initializes the extension
  */
 export default class MainController extends ControllerBase {
-    // PUBLIC METHODS //////////////////////////////////////////////////////
+	public deactivate(): void {
-    /**
+		Utils.logDebug('Main controller deactivated');
-     * Deactivates the extension
+	}
-     */
-    public deactivate(): void {
-        Utils.logDebug('Main controller deactivated');
-    }
 
-    public activate(): Promise<boolean> {
+	public activate(): Promise<boolean> {
-        const webviewExampleHtml = fs.readFileSync(path.join(__dirname, 'webviewExample.html')).toString();
+		const webviewExampleHtml = fs.readFileSync(path.join(__dirname, 'webviewExample.html')).toString();
-        const buttonHtml = fs.readFileSync(path.join(__dirname, 'button.html')).toString();
+		const buttonHtml = fs.readFileSync(path.join(__dirname, 'button.html')).toString();
-        const counterHtml = fs.readFileSync(path.join(__dirname, 'counter.html')).toString();
+		const counterHtml = fs.readFileSync(path.join(__dirname, 'counter.html')).toString();
 
-        let countWidget: sqlops.DashboardWebview;
+		let countWidget: azdata.DashboardWebview;
-        let buttonWidget: sqlops.DashboardWebview;
+		let buttonWidget: azdata.DashboardWebview;
-        let count = 0;
+		let count = 0;
 
-        let dialog: sqlops.ModalDialog = sqlops.window.createWebViewDialog('Flyout extension');
+		let dialog: azdata.ModalDialog = azdata.window.createWebViewDialog('Flyout extension');
-        dialog.html = '<div>This is a flyout extension.</div>';
+		dialog.html = '<div>This is a flyout extension.</div>';
 
-        sqlops.dashboard.registerWebviewProvider('webview-count', e => {
+		azdata.dashboard.registerWebviewProvider('webview-count', e => {
-            e.html = counterHtml;
+			e.html = counterHtml;
-            countWidget = e;
+			countWidget = e;
-        });
+		});
-        sqlops.dashboard.registerWebviewProvider('webview-button', e => {
+		azdata.dashboard.registerWebviewProvider('webview-button', e => {
-            e.html = buttonHtml;
+			e.html = buttonHtml;
-            buttonWidget = e;
+			buttonWidget = e;
-            e.onMessage(event => {
+			e.onMessage(event => {
-                if (event === 'openFlyout') {
+				if (event === 'openFlyout') {
-                    dialog.open();
+					dialog.open();
-                } else {
+				} else {
-                    count++;
+					count++;
-                    countWidget.postMessage(count);
+					countWidget.postMessage(count);
-                }
+				}
-            });
+			});
-        });
+		});
-        sqlops.dashboard.registerWebviewProvider('webviewExample', e => {
+		azdata.dashboard.registerWebviewProvider('webviewExample', e => {
-            e.html = webviewExampleHtml;
+			e.html = webviewExampleHtml;
-        });
+		});
 
-        return Promise.resolve(true);
+		return Promise.resolve(true);
-    }
+	}
 }
 

samples/extensionSamples/src/typings/ref.d.ts

@@ -3,4 +3,5 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-/// <reference path='../../../../src/sql/sqlops.proposed.d.ts'/>
+/// <reference path='../../../../src/sql/azdata.d.ts'/>
+/// <reference path='../../../../src/sql/azdata.proposed.d.ts'/>

samples/serverReports/tasks/buildtasks.js

@@ -118,6 +118,6 @@ gulp.task('test', (done) => {
 });
 
 gulp.task('copytypings', function () {
-	return gulp.src(config.paths.project.root + '/../../src/sql/sqlops.proposed.d.ts')
+	return gulp.src(config.paths.project.root + '/../../src/sql/azdata.proposed.d.ts')
 		.pipe(gulp.dest('typings/'));
 });

samples/sqlservices/.gitignore

@@ -1,3 +1,2 @@
 node_modules
 *.vsix
-typings/sqlops.proposed.d.ts

samples/sqlservices/src/controllers/mainController.ts

@@ -5,13 +5,13 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as Utils from '../utils';
 import * as vscode from 'vscode';
 import SplitPropertiesPanel from './splitPropertiesPanel';
 import * as fs from 'fs';
 import * as path from 'path';
-import {TreeNode, TreeDataProvider} from './treeDataProvider';
+import { TreeNode, TreeDataProvider } from './treeDataProvider';
 
 /**
  * The main controller class that initializes the extension
@@ -41,7 +41,7 @@ export default class MainController implements vscode.Disposable {
 		this.registerSqlServicesModelView();
 		this.registerSplitPanelModelView();
 
-		sqlops.tasks.registerTask('sqlservices.clickTask', (profile) => {
+		azdata.tasks.registerTask('sqlservices.clickTask', (profile) => {
 			vscode.window.showInformationMessage(`Clicked from profile ${profile.serverName}.${profile.databaseName}`);
 		});
 
@@ -50,7 +50,7 @@ export default class MainController implements vscode.Disposable {
 		});
 
 		vscode.commands.registerCommand('sqlservices.openConnectionDialog', async () => {
-			let connection = await sqlops.connection.openConnectionDialog();
+			let connection = await azdata.connection.openConnectionDialog();
 			if (connection) {
 				console.info('Connection Opened: ' + connection.options['server']);
 			}
@@ -75,7 +75,7 @@ export default class MainController implements vscode.Disposable {
 		return Promise.resolve(true);
 	}
 
-	private async getTab3Content(view: sqlops.ModelView): Promise<void> {
+	private async getTab3Content(view: azdata.ModelView): Promise<void> {
 		let treeData = {
 			label: '1',
 			children: [
@@ -118,7 +118,7 @@ export default class MainController implements vscode.Disposable {
 
 		let treeDataProvider = new TreeDataProvider(root);
 
-		let tree: sqlops.TreeComponent<TreeNode> = view.modelBuilder.tree<TreeNode>().withProperties({
+		let tree: azdata.TreeComponent<TreeNode> = view.modelBuilder.tree<TreeNode>().withProperties({
 			'withCheckbox': true
 		}).component();
 		let treeView = tree.registerDataProvider(treeDataProvider);
@@ -139,16 +139,16 @@ export default class MainController implements vscode.Disposable {
 				component: tree,
 				title: 'Tree'
 			}], {
-					horizontal: false,
+				horizontal: false,
-					componentWidth: 800,
+				componentWidth: 800,
-					componentHeight: 800
+				componentHeight: 800
-				}).component();
+			}).component();
 		let formWrapper = view.modelBuilder.loadingComponent().withItem(formModel).component();
 		formWrapper.loading = false;
 
 		await view.initializeModel(formWrapper);
 	}
-	private async getTabContent(view: sqlops.ModelView, customButton1: sqlops.window.Button, customButton2: sqlops.window.Button, componentWidth: number | string
+	private async getTabContent(view: azdata.ModelView, customButton1: azdata.window.Button, customButton2: azdata.window.Button, componentWidth: number | string
 	): Promise<void> {
 		let inputBox = view.modelBuilder.inputBox()
 			.withProperties({
@@ -226,8 +226,8 @@ export default class MainController implements vscode.Disposable {
 				component: inputBox4,
 				title: 'inputBox4'
 			}], {
-					horizontal: true
+				horizontal: true
-				}).component();
+			}).component();
 		let groupModel1 = view.modelBuilder.groupContainer()
 			.withLayout({
 			}).withItems([
@@ -255,22 +255,22 @@ export default class MainController implements vscode.Disposable {
 			.withProperties({
 				columns: [{
 					displayName: 'Column 1',
-					valueType: sqlops.DeclarativeDataType.string,
+					valueType: azdata.DeclarativeDataType.string,
 					width: '20px',
 					isReadOnly: true
 				}, {
 					displayName: 'Column 2',
-					valueType: sqlops.DeclarativeDataType.string,
+					valueType: azdata.DeclarativeDataType.string,
 					width: '100px',
 					isReadOnly: false
 				}, {
 					displayName: 'Column 3',
-					valueType: sqlops.DeclarativeDataType.boolean,
+					valueType: azdata.DeclarativeDataType.boolean,
 					width: '20px',
 					isReadOnly: false
 				}, {
 					displayName: 'Column 4',
-					valueType: sqlops.DeclarativeDataType.category,
+					valueType: azdata.DeclarativeDataType.category,
 					isReadOnly: false,
 					width: '120px',
 					categoryValues: [
@@ -317,23 +317,24 @@ export default class MainController implements vscode.Disposable {
 				title: 'Declarative Table'
 			}], formItemLayout);
 		let groupItems = {
-				components: [{
+			components: [{
-					component: table,
+				component: table,
-					title: 'Table'
+				title: 'Table'
-					}, {
+			}, {
-							component: listBox,
+				component: listBox,
-							title: 'List Box'
+				title: 'List Box'
-				}], title: 'group'};
+			}], title: 'group'
+		};
 		formBuilder.addFormItem(groupItems, formItemLayout);
 
 		formBuilder.insertFormItem({
 			component: inputBoxWrapper,
 			title: 'Backup name'
-			}, 0, formItemLayout);
+		}, 0, formItemLayout);
 		formBuilder.insertFormItem({
 			component: inputBox2,
 			title: 'Recovery model'
-			}, 1, formItemLayout);
+		}, 1, formItemLayout);
 		formBuilder.insertFormItem({
 			component: dropdown,
 			title: 'Backup type'
@@ -375,20 +376,20 @@ export default class MainController implements vscode.Disposable {
 	}
 
 	private openDialog(): void {
-		let dialog = sqlops.window.createModelViewDialog('Test dialog');
+		let dialog = azdata.window.createModelViewDialog('Test dialog');
-		let tab1 = sqlops.window.createTab('Test tab 1');
+		let tab1 = azdata.window.createTab('Test tab 1');
 
-		let tab2 = sqlops.window.createTab('Test tab 2');
+		let tab2 = azdata.window.createTab('Test tab 2');
-		let tab3 = sqlops.window.createTab('Test tab 3');
+		let tab3 = azdata.window.createTab('Test tab 3');
 		tab2.content = 'sqlservices';
 		dialog.content = [tab1, tab2, tab3];
 		dialog.okButton.onClick(() => console.log('ok clicked!'));
 		dialog.cancelButton.onClick(() => console.log('cancel clicked!'));
 		dialog.okButton.label = 'ok';
 		dialog.cancelButton.label = 'no';
-		let customButton1 = sqlops.window.createButton('Load name');
+		let customButton1 = azdata.window.createButton('Load name');
 		customButton1.onClick(() => console.log('button 1 clicked!'));
-		let customButton2 = sqlops.window.createButton('Load all');
+		let customButton2 = azdata.window.createButton('Load all');
 		customButton2.onClick(() => console.log('button 2 clicked!'));
 		dialog.customButtons = [customButton1, customButton2];
 		tab1.registerContent(async (view) => {
@@ -398,17 +399,17 @@ export default class MainController implements vscode.Disposable {
 		tab3.registerContent(async (view) => {
 			await this.getTab3Content(view);
 		});
-		sqlops.window.openDialog(dialog);
+		azdata.window.openDialog(dialog);
 	}
 
 	private openWizard(): void {
-		let wizard = sqlops.window.createWizard('Test wizard');
+		let wizard = azdata.window.createWizard('Test wizard');
-		let page1 = sqlops.window.createWizardPage('First wizard page');
+		let page1 = azdata.window.createWizardPage('First wizard page');
-		let page2 = sqlops.window.createWizardPage('Second wizard page');
+		let page2 = azdata.window.createWizardPage('Second wizard page');
 		page2.content = 'sqlservices';
-		let customButton1 = sqlops.window.createButton('Load name');
+		let customButton1 = azdata.window.createButton('Load name');
 		customButton1.onClick(() => console.log('button 1 clicked!'));
-		let customButton2 = sqlops.window.createButton('Load all');
+		let customButton2 = azdata.window.createButton('Load all');
 		customButton2.onClick(() => console.log('button 2 clicked!'));
 		wizard.customButtons = [customButton1, customButton2];
 		page1.registerContent(async (view) => {
@@ -421,10 +422,10 @@ export default class MainController implements vscode.Disposable {
 			isCancelable: true,
 			connection: undefined,
 			operation: op => {
-				op.updateStatus(sqlops.TaskStatus.InProgress);
+				op.updateStatus(azdata.TaskStatus.InProgress);
-				op.updateStatus(sqlops.TaskStatus.InProgress, 'Task is running');
+				op.updateStatus(azdata.TaskStatus.InProgress, 'Task is running');
 				setTimeout(() => {
-					op.updateStatus(sqlops.TaskStatus.Succeeded);
+					op.updateStatus(azdata.TaskStatus.Succeeded);
 				}, 5000);
 			}
 		});
@@ -433,7 +434,7 @@ export default class MainController implements vscode.Disposable {
 	}
 
 	private openEditor(): void {
-		let editor = sqlops.workspace.createModelViewEditor('Test Model View');
+		let editor = azdata.workspace.createModelViewEditor('Test Model View');
 		editor.registerContent(async view => {
 			let inputBox = view.modelBuilder.inputBox()
 				.withValidation(component => component.value !== 'valid')
@@ -452,7 +453,7 @@ export default class MainController implements vscode.Disposable {
 	}
 
 	private openEditorWithWebview(html1: string, html2: string): void {
-		let editor = sqlops.workspace.createModelViewEditor('Editor webview', { retainContextWhenHidden: true });
+		let editor = azdata.workspace.createModelViewEditor('Editor webview', { retainContextWhenHidden: true });
 		editor.registerContent(async view => {
 			let count = 0;
 			let webview1 = view.modelBuilder.webView()
@@ -502,7 +503,7 @@ export default class MainController implements vscode.Disposable {
 	}
 
 	private openEditorWithWebview2(): void {
-		let editor = sqlops.workspace.createModelViewEditor('Editor webview2', { retainContextWhenHidden: true });
+		let editor = azdata.workspace.createModelViewEditor('Editor webview2', { retainContextWhenHidden: true });
 		editor.registerContent(async view => {
 
 			let inputBox = view.modelBuilder.inputBox().component();
@@ -571,7 +572,7 @@ export default class MainController implements vscode.Disposable {
 
 
 	private registerSqlServicesModelView(): void {
-		sqlops.ui.registerModelViewProvider('sqlservices', async (view) => {
+		azdata.ui.registerModelViewProvider('sqlservices', async (view) => {
 			let flexModel = view.modelBuilder.flexContainer()
 				.withLayout({
 					flexFlow: 'row',
@@ -586,7 +587,7 @@ export default class MainController implements vscode.Disposable {
 						})
 						.withItems([
 							view.modelBuilder.card()
-								.withProperties<sqlops.CardProperties>({
+								.withProperties<azdata.CardProperties>({
 									label: 'label1',
 									value: 'value1',
 									actions: [{ label: 'action' }]
@@ -598,7 +599,7 @@ export default class MainController implements vscode.Disposable {
 						.withLayout({ flexFlow: 'column' })
 						.withItems([
 							view.modelBuilder.card()
-								.withProperties<sqlops.CardProperties>({
+								.withProperties<azdata.CardProperties>({
 									label: 'label2',
 									value: 'value2',
 									actions: [{ label: 'action' }]
@@ -612,7 +613,7 @@ export default class MainController implements vscode.Disposable {
 	}
 
 	private registerSplitPanelModelView(): void {
-		sqlops.ui.registerModelViewProvider('splitPanel', async (view) => {
+		azdata.ui.registerModelViewProvider('splitPanel', async (view) => {
 			let numPanels = 3;
 			let splitPanel = new SplitPropertiesPanel(view, numPanels);
 			await view.initializeModel(splitPanel.modelBase);

samples/sqlservices/src/controllers/splitPropertiesPanel.ts

@@ -5,15 +5,15 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
 /**
  * The main controller class that initializes the extension
  */
 export default class SplitPropertiesPanel {
-	private panels: sqlops.FlexContainer[];
+	private panels: azdata.FlexContainer[];
-	private _modelBase: sqlops.FlexContainer;
+	private _modelBase: azdata.FlexContainer;
-	constructor(view: sqlops.ModelView, numPanels: number) {
+	constructor(view: azdata.ModelView, numPanels: number) {
 		this.panels = [];
 		let ratio = Math.round(100 / numPanels);
 		for (let i = 0; i < numPanels; i++) {
@@ -29,11 +29,11 @@ export default class SplitPropertiesPanel {
 			.component();
 	}
 
-	public get modelBase(): sqlops.Component {
+	public get modelBase(): azdata.Component {
 		return this._modelBase;
 	}
 
-	public addItem(item: sqlops.Component, panel: number): void {
+	public addItem(item: azdata.Component, panel: number): void {
 		if (panel >= this.panels.length) {
 			throw new Error(`Cannot add to panel ${panel} as only ${this.panels.length - 1} panels defined`);
 		}

samples/sqlservices/src/controllers/treeDataProvider.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as vscode from 'vscode';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as path from 'path';
 
 export enum TreeCheckboxState {
@@ -22,7 +22,7 @@ export interface TreeComponentDataModel {
 	checked?: boolean;
 }
 
-export class TreeNode implements sqlops.TreeComponentItem {
+export class TreeNode implements azdata.TreeComponentItem {
 	private _onNodeChange = new vscode.EventEmitter<void>();
 	private _onTreeChange = new vscode.EventEmitter<TreeNode>();
 	private _data: TreeComponentDataModel;
@@ -252,7 +252,7 @@ export class TreeNode implements sqlops.TreeComponentItem {
 	}
 }
 
-export class TreeDataProvider implements sqlops.TreeComponentDataProvider<TreeNode> {
+export class TreeDataProvider implements azdata.TreeComponentDataProvider<TreeNode> {
 		private _onDidChangeTreeData = new vscode.EventEmitter<TreeNode>();
 		constructor(private _root: TreeNode) {
 			if (this._root) {
@@ -269,8 +269,8 @@ export class TreeDataProvider implements sqlops.TreeComponentDataProvider<TreeNo
 		 * @param element The element for which [TreeItem](#TreeItem) representation is asked for.
 		 * @return [TreeItem](#TreeItem) representation of the element
 		 */
-		getTreeItem(element: TreeNode): sqlops.TreeComponentItem | Thenable<sqlops.TreeComponentItem> {
+		getTreeItem(element: TreeNode): azdata.TreeComponentItem | Thenable<azdata.TreeComponentItem> {
-			let item: sqlops.TreeComponentItem = {};
+			let item: azdata.TreeComponentItem = {};
 			item.label = element.label;
 			item.checked = element.checked;
 			item.collapsibleState = element.collapsibleState;

samples/sqlservices/tasks/buildtasks.js

@@ -18,68 +18,68 @@ let tsProject = ts.createProject('tsconfig.json');
 
 
 // GULP TASKS //////////////////////////////////////////////////////////////
-gulp.task('clean', function(done) {
+gulp.task('clean', function (done) {
-    return del('out', done);
+	return del('out', done);
 });
 
 gulp.task('lint', () => {
-    return gulp.src([
+	return gulp.src([
-        config.paths.project.root + '/src/**/*.ts',
+		config.paths.project.root + '/src/**/*.ts',
-        config.paths.project.root + '/test/**/*.ts'
+		config.paths.project.root + '/test/**/*.ts'
-    ])
+	])
-    .pipe((tslint({
+		.pipe((tslint({
-        formatter: "verbose"
+			formatter: "verbose"
-    })))
+		})))
-    .pipe(tslint.report());
+		.pipe(tslint.report());
 });
 
-gulp.task('compile:src', function(done) {
+gulp.task('compile:src', function (done) {
-    gulp.src([
+	gulp.src([
-        config.paths.project.root + '/src/**/*.sql',
+		config.paths.project.root + '/src/**/*.sql',
-        config.paths.project.root + '/src/**/*.svg',
+		config.paths.project.root + '/src/**/*.svg',
-        config.paths.project.root + '/src/**/*.html'
+		config.paths.project.root + '/src/**/*.html'
-    ]).pipe(gulp.dest('out/src/'));
+	]).pipe(gulp.dest('out/src/'));
 
-    let srcFiles = [
+	let srcFiles = [
-        config.paths.project.root + '/src/**/*.ts',
+		config.paths.project.root + '/src/**/*.ts',
-        config.paths.project.root + '/src/**/*.js',
+		config.paths.project.root + '/src/**/*.js',
-        config.paths.project.root + '/typings/**/*.ts'
+		config.paths.project.root + '/typings/**/*.ts'
-    ];
+	];
 
-    return gulp.src(srcFiles)
+	return gulp.src(srcFiles)
-        .pipe(srcmap.init())
+		.pipe(srcmap.init())
-        .pipe(tsProject())
+		.pipe(tsProject())
-        .on('error', function() {
+		.on('error', function () {
-            if (process.env.BUILDMACHINE) {
+			if (process.env.BUILDMACHINE) {
-                done('Extension Tests failed to build. See Above.');
+				done('Extension Tests failed to build. See Above.');
-                process.exit(1);
+				process.exit(1);
-            }
+			}
-        })
+		})
-        .pipe(srcmap.write('.', {
+		.pipe(srcmap.write('.', {
-            sourceRoot: function(file) {
+			sourceRoot: function (file) {
-                return file.cwd + '/src';
+				return file.cwd + '/src';
-            }
+			}
-        }))
+		}))
-        .pipe(gulp.dest('out/src/'));
+		.pipe(gulp.dest('out/src/'));
 });
 
-gulp.task('compile:test', function(done) {
+gulp.task('compile:test', function (done) {
-    let srcFiles = [
+	let srcFiles = [
-        config.paths.project.root + '/test/**/*.ts',
+		config.paths.project.root + '/test/**/*.ts',
-        config.paths.project.root + '/typings/**/*.ts'
+		config.paths.project.root + '/typings/**/*.ts'
-    ];
+	];
 
-    return gulp.src(srcFiles)
+	return gulp.src(srcFiles)
-        .pipe(srcmap.init())
+		.pipe(srcmap.init())
-        .pipe(tsProject())
+		.pipe(tsProject())
-        .on('error', function() {
+		.on('error', function () {
-            if(process.env.BUILDMACHINE) {
+			if (process.env.BUILDMACHINE) {
-                done('Failed to compile test source, see above.');
+				done('Failed to compile test source, see above.');
-                process.exit(1);
+				process.exit(1);
-            }
+			}
-        })
+		})
-        .pipe(srcmap.write('.', {sourceRoot: function(file) { return file.cwd + '/test'; }}))
+		.pipe(srcmap.write('.', { sourceRoot: function (file) { return file.cwd + '/test'; } }))
-        .pipe(gulp.dest('out/test/'));
+		.pipe(gulp.dest('out/test/'));
 });
 
 // COMPOSED GULP TASKS /////////////////////////////////////////////////////
@@ -87,38 +87,38 @@ gulp.task("compile", gulp.series("compile:src", "compile:test"));
 
 gulp.task("build", gulp.series("clean", "lint", "compile"));
 
-gulp.task("watch", function() {
+gulp.task("watch", function () {
-    gulp.watch([config.paths.project.root + '/src/**/*',
+	gulp.watch([config.paths.project.root + '/src/**/*',
-                config.paths.project.root + '/test/**/*.ts'],
+	config.paths.project.root + '/test/**/*.ts'],
-        gulp.series('build'));
+		gulp.series('build'));
 });
 
 gulp.task('test', (done) => {
-    let workspace = process.env['WORKSPACE'];
+	let workspace = process.env['WORKSPACE'];
-    if (!workspace) {
+	if (!workspace) {
-        workspace = process.cwd();
+		workspace = process.cwd();
-    }
+	}
-    process.env.JUNIT_REPORT_PATH = workspace + '/test-reports/ext_xunit.xml';
+	process.env.JUNIT_REPORT_PATH = workspace + '/test-reports/ext_xunit.xml';
 
-    let azuredatastudioPath = 'azuredatastudio';
+	let azuredatastudioPath = 'azuredatastudio';
-    if (process.env['SQLOPS_DEV']) {
+	if (process.env['SQLOPS_DEV']) {
-        let suffix = os.platform === 'win32' ? 'bat' : 'sh';
+		let suffix = os.platform === 'win32' ? 'bat' : 'sh';
-        azuredatastudioPath = `${process.env['SQLOPS_DEV']}/scripts/sql-cli.${suffix}`;
+		azuredatastudioPath = `${process.env['SQLOPS_DEV']}/scripts/sql-cli.${suffix}`;
-    }
+	}
-    console.log(`Using SQLOPS Path of ${azuredatastudioPath}`);
+	console.log(`Using SQLOPS Path of ${azuredatastudioPath}`);
 
-    cproc.exec(`${azuredatastudioPath} --extensionDevelopmentPath="${workspace}" --extensionTestsPath="${workspace}/out/test" --verbose`, (error, stdout, stderr) => {
+	cproc.exec(`${azuredatastudioPath} --extensionDevelopmentPath="${workspace}" --extensionTestsPath="${workspace}/out/test" --verbose`, (error, stdout, stderr) => {
-        if (error) {
+		if (error) {
-            console.error(`exec error: ${error}`);
+			console.error(`exec error: ${error}`);
-            process.exit(1);
+			process.exit(1);
-        }
+		}
-        console.log(`stdout: ${stdout}`);
+		console.log(`stdout: ${stdout}`);
-        console.log(`stderr: ${stderr}`);
+		console.log(`stderr: ${stderr}`);
-        done();
+		done();
-    });
+	});
 });
 
-gulp.task('copytypings', function() {
+gulp.task('copytypings', function () {
-    return gulp.src(config.paths.project.root + '/../../src/sql/sqlops.proposed.d.ts')
+	return gulp.src(config.paths.project.root + '/../../src/sql/azdata.proposed.d.ts')
-    .pipe(gulp.dest('typings/'));
+		.pipe(gulp.dest('typings/'));
 });

src/sql/sqlops.test.d.ts

@@ -1,23 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-// This is the place for APIs used for testing
-
-import * as core from 'sqlops';
-import * as vscode from 'vscode';
-
-declare module 'sqlops' {
-
-	export namespace extensions {
-		export function install(vsixPath: string): Thenable<string>;
-	}
-
-	export namespace objectexplorer {
-		/**
-		 * get object explorer node context menu actions
-		 */
-		export function getNodeActions(connectionId: string, nodePath: string): Thenable<string[]>;
-	}
-}

src/sql/workbench/api/common/extHostRequireInterceptor.ts

@@ -8,8 +8,7 @@ import { URI } from 'vs/base/common/uri';
 import { nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 import { ExtensionIdentifier, IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import * as azdata from 'azdata';
-import * as sqlops from 'sqlops';
+import { IAzdataExtensionApiFactory } from 'sql/workbench/api/common/sqlExtHost.api.impl';
-import { IAzdataExtensionApiFactory, ISqlopsExtensionApiFactory } from 'sql/workbench/api/common/sqlExtHost.api.impl';
 import { INodeModuleFactory } from 'vs/workbench/api/common/extHostRequireInterceptor';
 
 export class AzdataNodeModuleFactory implements INodeModuleFactory {
@@ -47,39 +46,3 @@ export class AzdataNodeModuleFactory implements INodeModuleFactory {
 		return this._defaultApiImpl;
 	}
 }
-
-export class SqlopsNodeModuleFactory implements INodeModuleFactory {
-	public readonly nodeModuleName = 'sqlops';
-
-	private readonly _extApiImpl = new Map<string, typeof sqlops>();
-	private _defaultApiImpl: typeof sqlops;
-
-	constructor(
-		private readonly _apiFactory: ISqlopsExtensionApiFactory,
-		private readonly _extensionPaths: TernarySearchTree<IExtensionDescription>
-	) {
-	}
-
-	public load(request: string, parent: URI): any {
-
-		// get extension id from filename and api for extension
-		const ext = this._extensionPaths.findSubstr(parent.fsPath);
-		if (ext) {
-			let apiImpl = this._extApiImpl.get(ExtensionIdentifier.toKey(ext.identifier));
-			if (!apiImpl) {
-				apiImpl = this._apiFactory(ext);
-				this._extApiImpl.set(ExtensionIdentifier.toKey(ext.identifier), apiImpl);
-			}
-			return apiImpl;
-		}
-
-		// fall back to a default implementation
-		if (!this._defaultApiImpl) {
-			let extensionPathsPretty = '';
-			this._extensionPaths.forEach((value, index) => extensionPathsPretty += `\t${index} -> ${value.identifier.value}\n`);
-			console.warn(`Could not identify extension for 'sqlops' require call from ${parent.fsPath}. These are the extension path mappings: \n${extensionPathsPretty}`);
-			this._defaultApiImpl = this._apiFactory(nullExtensionDescription);
-		}
-		return this._defaultApiImpl;
-	}
-}

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

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as azdata from 'azdata';
-import * as sqlops from 'sqlops';
 import * as vscode from 'vscode';
 import { SqlExtHostContext } from 'sql/workbench/api/common/sqlExtHost.protocol';
 import { ExtHostAccountManagement } from 'sql/workbench/api/common/extHostAccountManagement';
@@ -29,40 +28,32 @@ import { ExtHostExtensionManagement } from 'sql/workbench/api/common/extHostExte
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import * as extHostTypes from 'vs/workbench/api/common/extHostTypes';
 import { mssqlProviderName } from 'sql/platform/connection/common/constants';
-import { localize } from 'vs/nls';
 import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { IURITransformerService } from 'vs/workbench/api/common/extHostUriTransformerService';
 import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
 import { ILogService } from 'vs/platform/log/common/log';
 import { IExtensionApiFactory as vsIApiFactory, createApiFactoryAndRegisterActors as vsApiFactory } from 'vs/workbench/api/common/extHost.api.impl';
 
-export interface ISqlopsExtensionApiFactory {
-	(extension: IExtensionDescription): typeof sqlops;
-}
-
 export interface IAzdataExtensionApiFactory {
 	(extension: IExtensionDescription): typeof azdata;
 }
 
 export interface IExtensionApiFactory {
 	azdata: IAzdataExtensionApiFactory;
-	sqlops: ISqlopsExtensionApiFactory;
 	vscode: vsIApiFactory;
 }
 
 export interface IAdsExtensionApiFactory {
 	azdata: IAzdataExtensionApiFactory;
-	sqlops: ISqlopsExtensionApiFactory;
 }
 
 /**
  * This method instantiates and returns the extension API surface
  */
 export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): IExtensionApiFactory {
-	const { azdata, sqlops } = createAdsApiFactory(accessor);
+	const { azdata } = createAdsApiFactory(accessor);
 	return {
 		azdata,
-		sqlops,
 		vscode: vsApiFactory(accessor)
 	};
 }
@@ -70,7 +61,6 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 
 export interface IAdsExtensionApiFactory {
 	azdata: IAzdataExtensionApiFactory;
-	sqlops: ISqlopsExtensionApiFactory;
 }
 
 /**
@@ -561,371 +551,6 @@ export function createAdsApiFactory(accessor: ServicesAccessor): IAdsExtensionAp
 				ColumnSizingMode: sqlExtHostTypes.ColumnSizingMode,
 				DatabaseEngineEdition: sqlExtHostTypes.DatabaseEngineEdition
 			};
-		},
-
-		// "sqlops" namespace provided for back-compat only, add new interfaces to "azdata"
-		sqlops: function (extension: IExtensionDescription): typeof sqlops {
-
-			extHostExtensionManagement.$showObsoleteExtensionApiUsageNotification(localize('ObsoleteApiModuleMessage', "The extension \"{0}\" is using sqlops module which has been replaced by azdata module, the sqlops module will be removed in a future release.", extension.identifier.value));
-			// namespace: connection
-			const connection: typeof sqlops.connection = {
-				getActiveConnections(): Thenable<sqlops.connection.Connection[]> {
-					return extHostConnectionManagement.$getActiveConnections();
-				},
-				getCurrentConnection(): Thenable<sqlops.connection.Connection> {
-					return extHostConnectionManagement.$getSqlOpsCurrentConnection();
-				},
-				getCredentials(connectionId: string): Thenable<{ [name: string]: string }> {
-					return extHostConnectionManagement.$getCredentials(connectionId);
-				},
-				getServerInfo(connectionId: string): Thenable<sqlops.ServerInfo> {
-					return extHostConnectionManagement.$getServerInfo(connectionId);
-				},
-				openConnectionDialog(providers?: string[], initialConnectionProfile?: sqlops.IConnectionProfile, connectionCompletionOptions?: sqlops.IConnectionCompletionOptions): Thenable<sqlops.connection.Connection> {
-					return extHostConnectionManagement.$openConnectionDialog(providers, initialConnectionProfile, connectionCompletionOptions);
-				},
-				listDatabases(connectionId: string): Thenable<string[]> {
-					return extHostConnectionManagement.$listDatabases(connectionId);
-				},
-				getConnectionString(connectionId: string, includePassword: boolean): Thenable<string> {
-					return extHostConnectionManagement.$getConnectionString(connectionId, includePassword);
-				},
-				getUriForConnection(connectionId: string): Thenable<string> {
-					return extHostConnectionManagement.$getUriForConnection(connectionId);
-				},
-				connect(connectionProfile: sqlops.IConnectionProfile, saveConnection: boolean, showDashboard: boolean): Thenable<sqlops.ConnectionResult> {
-					return extHostConnectionManagement.$connect(connectionProfile, saveConnection, showDashboard);
-				}
-			};
-
-			// namespace: credentials
-			const credentials: typeof sqlops.credentials = {
-				registerProvider(provider: sqlops.CredentialProvider): vscode.Disposable {
-					return extHostCredentialManagement.$registerCredentialProvider(provider);
-				},
-				getProvider(namespaceId: string): Thenable<sqlops.CredentialProvider> {
-					return extHostCredentialManagement.$getCredentialProvider(namespaceId);
-				}
-			};
-
-			// namespace: objectexplorer
-			const objectExplorer: typeof sqlops.objectexplorer = {
-				getNode(connectionId: string, nodePath?: string): Thenable<sqlops.objectexplorer.ObjectExplorerNode> {
-					return extHostObjectExplorer.$getNode(connectionId, nodePath);
-				},
-				getActiveConnectionNodes(): Thenable<sqlops.objectexplorer.ObjectExplorerNode[]> {
-					return extHostObjectExplorer.$getActiveConnectionNodes();
-				},
-				findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable<sqlops.objectexplorer.ObjectExplorerNode[]> {
-					return extHostObjectExplorer.$findNodes(connectionId, type, schema, name, database, parentObjectNames);
-				},
-				getNodeActions(connectionId: string, nodePath: string): Thenable<string[]> {
-					return extHostObjectExplorer.$getNodeActions(connectionId, nodePath);
-				},
-				getSessionConnectionProfile(sessionId: string): Thenable<sqlops.IConnectionProfile> {
-					return extHostObjectExplorer.$getSessionConnectionProfile(sessionId);
-				}
-			};
-
-			// namespace: serialization
-			const serialization: typeof sqlops.serialization = {
-				registerProvider(provider: sqlops.SerializationProvider): vscode.Disposable {
-					// No-op this to avoid breaks in existing applications. Tested on Github - no examples,
-					// but I think it's safer to avoid breaking this
-					return undefined;
-				},
-			};
-
-
-			let registerConnectionProvider = (provider: sqlops.ConnectionProvider): vscode.Disposable => {
-				// Connection callbacks
-				provider.registerOnConnectionComplete((connSummary: sqlops.ConnectionInfoSummary) => {
-					extHostDataProvider.$onConnectComplete(provider.handle, connSummary);
-				});
-
-				provider.registerOnIntelliSenseCacheComplete((connectionUri: string) => {
-					extHostDataProvider.$onIntelliSenseCacheComplete(provider.handle, connectionUri);
-				});
-
-				provider.registerOnConnectionChanged((changedConnInfo: sqlops.ChangedConnectionInfo) => {
-					extHostDataProvider.$onConnectionChanged(provider.handle, changedConnInfo);
-				});
-
-				return extHostDataProvider.$registerConnectionProvider(provider);
-			};
-
-			let registerQueryProvider = (provider: sqlops.QueryProvider): vscode.Disposable => {
-				provider.registerOnQueryComplete((result: sqlops.QueryExecuteCompleteNotificationResult) => {
-					extHostDataProvider.$onQueryComplete(provider.handle, result);
-				});
-
-				provider.registerOnBatchStart((batchInfo: sqlops.QueryExecuteBatchNotificationParams) => {
-					extHostDataProvider.$onBatchStart(provider.handle, batchInfo);
-				});
-
-				provider.registerOnBatchComplete((batchInfo: sqlops.QueryExecuteBatchNotificationParams) => {
-					extHostDataProvider.$onBatchComplete(provider.handle, batchInfo);
-				});
-
-				provider.registerOnResultSetAvailable((resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams) => {
-					extHostDataProvider.$onResultSetAvailable(provider.handle, resultSetInfo);
-				});
-
-				provider.registerOnResultSetUpdated((resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams) => {
-					extHostDataProvider.$onResultSetUpdated(provider.handle, resultSetInfo);
-				});
-
-				provider.registerOnMessage((message: sqlops.QueryExecuteMessageParams) => {
-					extHostDataProvider.$onQueryMessage(provider.handle, message);
-				});
-
-				provider.registerOnEditSessionReady((ownerUri: string, success: boolean, message: string) => {
-					extHostDataProvider.$onEditSessionReady(provider.handle, ownerUri, success, message);
-				});
-
-				return extHostDataProvider.$registerQueryProvider(<azdata.QueryProvider>provider);
-			};
-
-			let registerObjectExplorerProvider = (provider: sqlops.ObjectExplorerProvider): vscode.Disposable => {
-				provider.registerOnSessionCreated((response: sqlops.ObjectExplorerSession) => {
-					extHostDataProvider.$onObjectExplorerSessionCreated(provider.handle, response);
-				});
-
-				if (provider.registerOnSessionDisconnected) {
-					provider.registerOnSessionDisconnected((response: sqlops.ObjectExplorerSession) => {
-						extHostDataProvider.$onObjectExplorerSessionDisconnected(provider.handle, response);
-					});
-				}
-
-				provider.registerOnExpandCompleted((response: sqlops.ObjectExplorerExpandInfo) => {
-					extHostDataProvider.$onObjectExplorerNodeExpanded(provider.providerId, response);
-				});
-
-				return extHostDataProvider.$registerObjectExplorerProvider(provider);
-			};
-
-			let registerObjectExplorerNodeProvider = (provider: sqlops.ObjectExplorerNodeProvider): vscode.Disposable => {
-				provider.registerOnExpandCompleted((response: sqlops.ObjectExplorerExpandInfo) => {
-					extHostDataProvider.$onObjectExplorerNodeExpanded(provider.providerId, response);
-				});
-
-				return extHostDataProvider.$registerObjectExplorerNodeProvider(provider);
-			};
-
-			let registerTaskServicesProvider = (provider: sqlops.TaskServicesProvider): vscode.Disposable => {
-				provider.registerOnTaskCreated((response: sqlops.TaskInfo) => {
-					extHostDataProvider.$onTaskCreated(provider.handle, response);
-				});
-
-				provider.registerOnTaskStatusChanged((response: sqlops.TaskProgressInfo) => {
-					extHostDataProvider.$onTaskStatusChanged(provider.handle, response);
-				});
-
-				return extHostDataProvider.$registerTaskServicesProvider(provider);
-			};
-
-			let registerFileBrowserProvider = (provider: sqlops.FileBrowserProvider): vscode.Disposable => {
-				provider.registerOnFileBrowserOpened((response: sqlops.FileBrowserOpenedParams) => {
-					extHostDataProvider.$onFileBrowserOpened(provider.handle, response);
-				});
-
-				provider.registerOnFolderNodeExpanded((response: sqlops.FileBrowserExpandedParams) => {
-					extHostDataProvider.$onFolderNodeExpanded(provider.handle, response);
-				});
-
-				provider.registerOnFilePathsValidated((response: sqlops.FileBrowserValidatedParams) => {
-					extHostDataProvider.$onFilePathsValidated(provider.handle, response);
-				});
-
-				return extHostDataProvider.$registerFileBrowserProvider(provider);
-			};
-
-			let registerScriptingProvider = (provider: sqlops.ScriptingProvider): vscode.Disposable => {
-				provider.registerOnScriptingComplete((response: sqlops.ScriptingCompleteResult) => {
-					extHostDataProvider.$onScriptingComplete(provider.handle, response);
-				});
-
-				return extHostDataProvider.$registerScriptingProvider(provider);
-			};
-
-			let registerMetadataProvider = (provider: sqlops.MetadataProvider): vscode.Disposable => {
-				return extHostDataProvider.$registerMetadataProvider(provider);
-			};
-
-			let registerCapabilitiesServiceProvider = (provider: sqlops.CapabilitiesProvider): vscode.Disposable => {
-				return extHostDataProvider.$registerCapabilitiesServiceProvider(provider);
-			};
-
-			let registerAdminServicesProvider = (provider: sqlops.AdminServicesProvider): vscode.Disposable => {
-				return extHostDataProvider.$registerAdminServicesProvider(provider);
-			};
-
-
-			// namespace: dataprotocol
-			const dataprotocol: typeof sqlops.dataprotocol = {
-				registerConnectionProvider,
-				registerFileBrowserProvider,
-				registerMetadataProvider,
-				registerObjectExplorerProvider,
-				registerObjectExplorerNodeProvider,
-				registerScriptingProvider,
-				registerTaskServicesProvider,
-				registerQueryProvider,
-				registerAdminServicesProvider,
-				registerCapabilitiesServiceProvider,
-				onDidChangeLanguageFlavor(listener: (e: sqlops.DidChangeLanguageFlavorParams) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
-					return extHostDataProvider.onDidChangeLanguageFlavor(listener, thisArgs, disposables);
-				},
-				getProvider<T extends sqlops.DataProvider>(providerId: string, providerType: sqlops.DataProviderType) {
-					return extHostDataProvider.getProvider<T>(providerId, providerType);
-				},
-				getProvidersByType<T extends sqlops.DataProvider>(providerType: sqlops.DataProviderType) {
-					return extHostDataProvider.getProvidersByType<T>(providerType);
-				}
-			};
-
-			const modelViewDialog: typeof sqlops.window.modelviewdialog = {
-				createDialog(title: string, dialogName?: string): sqlops.window.modelviewdialog.Dialog {
-					console.warn('the method sqlops.window.modelviewdialog.createDialog has been deprecated, replace it with azdata.window.createModelViewDialog');
-					return extHostModelViewDialog.createDialog(title, dialogName, extension);
-				},
-				createTab(title: string): sqlops.window.modelviewdialog.DialogTab {
-					console.warn('the method sqlops.window.modelviewdialog.createTab has been deprecated, replace it with azdata.window.createTab');
-					return extHostModelViewDialog.createTab(title, extension);
-				},
-				createButton(label: string): sqlops.window.modelviewdialog.Button {
-					console.warn('the method sqlops.window.modelviewdialog.createButton has been deprecated, replace it with azdata.window.createButton');
-					return extHostModelViewDialog.createButton(label);
-				},
-				openDialog(dialog: sqlops.window.modelviewdialog.Dialog) {
-					console.warn('the method sqlops.window.modelviewdialog.openDialog has been deprecated, replace it with azdata.window.openDialog');
-					return extHostModelViewDialog.openDialog(dialog as azdata.window.Dialog);
-				},
-				closeDialog(dialog: sqlops.window.modelviewdialog.Dialog) {
-					console.warn('the method sqlops.window.modelviewdialog.closeDialog has been deprecated, replace it with azdata.window.closeDialog');
-					return extHostModelViewDialog.closeDialog(dialog as azdata.window.Dialog);
-				},
-				createWizardPage(title: string): sqlops.window.modelviewdialog.WizardPage {
-					console.warn('the method sqlops.window.modelviewdialog.createWizardPage has been deprecated, replace it with azdata.window.createWizardPage');
-					return extHostModelViewDialog.createWizardPage(title);
-				},
-				createWizard(title: string): sqlops.window.modelviewdialog.Wizard {
-					console.warn('the method sqlops.window.modelviewdialog.createWizard has been deprecated, replace it with azdata.window.createWizard');
-					return extHostModelViewDialog.createWizard(title);
-				},
-				MessageLevel: sqlExtHostTypes.MessageLevel
-			};
-
-			const window: typeof sqlops.window = {
-				createDialog(name: string) {
-					console.warn('the method sqlops.window.createDialog has been deprecated, replace it with azdata.window.createWebViewDialog');
-					return extHostModalDialogs.createDialog(name);
-				},
-				modelviewdialog: modelViewDialog,
-				createWebViewDialog(name: string) {
-					return extHostModalDialogs.createDialog(name);
-				},
-				createModelViewDialog(title: string, dialogName?: string): sqlops.window.Dialog {
-					return extHostModelViewDialog.createDialog(title, dialogName, extension);
-				},
-				createTab(title: string): sqlops.window.DialogTab {
-					return extHostModelViewDialog.createTab(title, extension);
-				},
-				createButton(label: string): sqlops.window.Button {
-					return extHostModelViewDialog.createButton(label);
-				},
-				openDialog(dialog: sqlops.window.Dialog) {
-					return extHostModelViewDialog.openDialog(dialog as azdata.window.Dialog);
-				},
-				closeDialog(dialog: sqlops.window.Dialog) {
-					return extHostModelViewDialog.closeDialog(dialog as azdata.window.Dialog);
-				},
-				createWizardPage(title: string): sqlops.window.WizardPage {
-					return extHostModelViewDialog.createWizardPage(title);
-				},
-				createWizard(title: string): sqlops.window.Wizard {
-					return extHostModelViewDialog.createWizard(title);
-				},
-				MessageLevel: sqlExtHostTypes.MessageLevel
-			};
-
-			const tasks: typeof sqlops.tasks = {
-				registerTask(id: string, task: (...args: any[]) => any, thisArgs?: any): vscode.Disposable {
-					return extHostTasks.registerTask(id, task, thisArgs);
-				},
-				startBackgroundOperation(operationInfo: sqlops.BackgroundOperationInfo): void {
-					extHostBackgroundTaskManagement.$registerTask(operationInfo);
-				}
-			};
-
-			const workspace: typeof sqlops.workspace = {
-				onDidOpenDashboard: extHostDashboard.onDidOpenDashboard,
-				onDidChangeToDashboard: extHostDashboard.onDidChangeToDashboard,
-				createModelViewEditor(title: string, options?: sqlops.ModelViewEditorOptions): sqlops.workspace.ModelViewEditor {
-					return extHostModelViewDialog.createModelViewEditor(title, extension, options);
-				}
-			};
-
-			const dashboard = {
-				registerWebviewProvider(widgetId: string, handler: (webview: sqlops.DashboardWebview) => void) {
-					extHostWebviewWidgets.$registerProvider(widgetId, handler);
-				}
-			};
-
-			const ui = {
-				registerModelViewProvider(modelViewId: string, handler: (view: sqlops.ModelView) => void): void {
-					extHostModelView.$registerProvider(modelViewId, handler, extension);
-				}
-			};
-
-			// namespace: queryeditor
-			const queryEditor: typeof sqlops.queryeditor = {
-
-				connect(fileUri: string, connectionId: string): Thenable<void> {
-					return extHostQueryEditor.$connect(fileUri, connectionId);
-				},
-
-				runQuery(fileUri: string): void {
-					extHostQueryEditor.$runQuery(fileUri);
-				}
-			};
-
-			const extensions: typeof sqlops.extensions = {
-				install(vsixPath: string): Thenable<string> {
-					return extHostExtensionManagement.$install(vsixPath);
-				}
-			};
-
-			return {
-				connection,
-				credentials,
-				objectexplorer: objectExplorer,
-				serialization,
-				dataprotocol,
-				DataProviderType: sqlExtHostTypes.DataProviderType,
-				DeclarativeDataType: sqlExtHostTypes.DeclarativeDataType,
-				ServiceOptionType: sqlExtHostTypes.ServiceOptionType,
-				ConnectionOptionSpecialType: sqlExtHostTypes.ConnectionOptionSpecialType,
-				EditRowState: sqlExtHostTypes.EditRowState,
-				MetadataType: sqlExtHostTypes.MetadataType,
-				TaskStatus: sqlExtHostTypes.TaskStatus,
-				TaskExecutionMode: sqlExtHostTypes.TaskExecutionMode,
-				ScriptOperation: sqlExtHostTypes.ScriptOperation,
-				window,
-				tasks,
-				dashboard,
-				workspace,
-				queryeditor: queryEditor,
-				ui: ui,
-				StatusIndicator: sqlExtHostTypes.StatusIndicator,
-				CardType: sqlExtHostTypes.CardType,
-				Orientation: sqlExtHostTypes.Orientation,
-				SqlThemeIcon: sqlExtHostTypes.SqlThemeIcon,
-				TreeComponentItem: sqlExtHostTypes.TreeComponentItem,
-				AzureResource: sqlExtHostTypes.AzureResource,
-				extensions: extensions,
-				TreeItem: sqlExtHostTypes.TreeItem
-			};
 		}
 	};
 }

src/sql/workbench/contrib/objectExplorer/common/treeNode.ts

@@ -5,7 +5,7 @@
 
 import { ConnectionProfile } from 'sql/platform/connection/common/connectionProfile';
 import { NodeType, SqlThemeIcon } from 'sql/workbench/contrib/objectExplorer/common/nodeType';
-import * as azdata from 'sqlops';
+import * as azdata from 'azdata';
 
 import * as UUID from 'vs/base/common/uuid';
 import { URI } from 'vs/base/common/uri';

src/vs/workbench/api/common/extHostRequireInterceptor.ts

@@ -20,7 +20,7 @@ import { IExtHostExtensionService } from 'vs/workbench/api/common/extHostExtensi
 import { platform } from 'vs/base/common/process';
 import { ILogService } from 'vs/platform/log/common/log';
 
-import { AzdataNodeModuleFactory, SqlopsNodeModuleFactory } from 'sql/workbench/api/common/extHostRequireInterceptor'; // {{SQL CARBON EDIT}}
+import { AzdataNodeModuleFactory } from 'sql/workbench/api/common/extHostRequireInterceptor'; // {{SQL CARBON EDIT}}
 import { IExtensionApiFactory as sqlIApiFactory } from 'sql/workbench/api/common/sqlExtHost.api.impl'; // {{SQL CARBON EDIT}}
 
 
@@ -61,7 +61,6 @@ export abstract class RequireInterceptor {
 
 		this.register(new VSCodeNodeModuleFactory(this._apiFactory.vscode, extensionPaths, this._extensionRegistry, configProvider, this._logService)); // {{SQL CARBON EDIT}} // add node module
 		this.register(new AzdataNodeModuleFactory(this._apiFactory.azdata, extensionPaths)); // {{SQL CARBON EDIT}} // add node module
-		this.register(new SqlopsNodeModuleFactory(this._apiFactory.sqlops, extensionPaths)); // {{SQL CARBON EDIT}} // add node module
 		this.register(this._instaService.createInstance(KeytarNodeModuleFactory));
 		if (this._initData.remote.isRemote) {
 			this.register(this._instaService.createInstance(OpenNodeModuleFactory, extensionPaths, this._initData.environment.appUriScheme));