Move SQL 2019 extension's notebook code into Azure Data Studio (#4090)

extensions/notebook/src/prompts/adapter.ts

@@ -0,0 +1,173 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+
+import { window, OutputChannel } from 'vscode';
+import * as Constants from '../common/constants';
+import * as nodeUtil from 'util';
+import PromptFactory from './factory';
+import EscapeException from './escapeException';
+import { IQuestion, IPrompter, IPromptCallback } from './question';
+
+// Supports simple pattern for prompting for user input and acting on this
+export default class CodeAdapter implements IPrompter {
+
+	private outChannel: OutputChannel;
+	private outBuffer: string = '';
+	private messageLevelFormatters = {};
+	constructor() {
+		// TODO Decide whether output channel logging should be saved here?
+		this.outChannel = window.createOutputChannel(Constants.outputChannelName);
+		// this.outChannel.clear();
+	}
+
+	public logError(message: any): void {
+		let line = `error: ${message.message}\n    Code - ${message.code}`;
+
+		this.outBuffer += `${line}\n`;
+		this.outChannel.appendLine(line);
+	}
+
+	// private formatInfo(message: any) {
+	//     const prefix = `${message.level}: (${message.id}) `;
+	//     if (message.id === "json") {
+	//         let jsonString = JSON.stringify(message.data, undefined, 4);
+	//         return `${prefix}${message.message}\n${jsonString}`;
+	//     }
+	//     else {
+	//         return `${prefix}${message.message}`;
+	//     }
+	// }
+
+	// private formatAction(message: any) {
+	//     const prefix = `info: ${message.level}: (${message.id}) `;
+	//     return `${prefix}${message.message}`;
+	// }
+
+	private formatMessage(message: any): string {
+		const prefix = `${message.level}: (${message.id}) `;
+		return `${prefix}${message.message}`;
+	}
+
+	// private formatConflict(message: any) {
+	//     var msg = message.message + ':\n';
+	//     var picks = (<any[]>message.data.picks);
+	//     var pickCount = 1;
+	//     picks.forEach((pick) => {
+	//         let pickMessage = (pickCount++).toString() + "). " + pick.endpoint.name + "#" + pick.endpoint.target;
+	//         if (pick.pkgMeta._resolution && pick.pkgMeta._resolution.tag) {
+	//             pickMessage += " which resolved to " + pick.pkgMeta._resolution.tag
+	//         }
+	//         if (Array.isArray(pick.dependants) && pick.dependants.length > 0) {
+	//             pickMessage += " and is required by ";
+	//             pick.dependants.forEach((dep) => {
+	//                 pickMessage += " " + dep.endpoint.name + "#" + dep.endpoint.target;
+	//             });
+	//         }
+	//         msg += "    " + pickMessage + "\n";
+	//     });
+
+	//     var prefix = (message.id === "solved"? "info" : "warn") + `: ${message.level}: (${message.id}) `;
+	//     return prefix + msg;
+	// }
+
+	public log(message: any): void {
+		let line: string = '';
+		if (message && typeof (message.level) === 'string') {
+			let formatter: (a: any) => string = this.formatMessage;
+			if (this.messageLevelFormatters[message.level]) {
+				formatter = this.messageLevelFormatters[message.level];
+			}
+			line = formatter(message);
+		} else {
+			line = nodeUtil.format(arguments);
+		}
+
+		this.outBuffer += `${line}\n`;
+		this.outChannel.appendLine(line);
+	}
+
+	public clearLog(): void {
+		this.outChannel.clear();
+	}
+
+	public showLog(): void {
+		this.outChannel.show();
+	}
+
+	// TODO define question interface
+	private fixQuestion(question: any): any {
+		if (question.type === 'checkbox' && Array.isArray(question.choices)) {
+			// For some reason when there's a choice of checkboxes, they aren't formatted properly
+			// Not sure where the issue is
+			question.choices = question.choices.map(item => {
+				if (typeof (item) === 'string') {
+					return { checked: false, name: item, value: item };
+				} else {
+					return item;
+				}
+			});
+		}
+	}
+
+	public promptSingle<T>(question: IQuestion, ignoreFocusOut?: boolean): Promise<T> {
+		let questions: IQuestion[] = [question];
+		return this.prompt(questions, ignoreFocusOut).then((answers: { [key: string]: T }) => {
+			if (answers) {
+				let response: T = answers[question.name];
+				return response || undefined;
+			}
+		});
+	}
+
+	public prompt<T>(questions: IQuestion[], ignoreFocusOut?: boolean): Promise<{ [key: string]: T }> {
+		let answers: { [key: string]: T } = {};
+
+		// Collapse multiple questions into a set of prompt steps
+		let promptResult: Promise<{ [key: string]: T }> = questions.reduce((promise: Promise<{ [key: string]: T }>, question: IQuestion) => {
+			this.fixQuestion(question);
+
+			return promise.then(() => {
+				return PromptFactory.createPrompt(question, ignoreFocusOut);
+			}).then(prompt => {
+				// Original Code: uses jQuery patterns. Keeping for reference
+				// if (!question.when || question.when(answers) === true) {
+				//     return prompt.render().then(result => {
+				//         answers[question.name] = question.filter ? question.filter(result) : result;
+				//     });
+				// }
+
+				if (!question.shouldPrompt || question.shouldPrompt(answers) === true) {
+					return prompt.render().then(result => {
+						answers[question.name] = result;
+
+						if (question.onAnswered) {
+							question.onAnswered(result);
+						}
+						return answers;
+					});
+				}
+				return answers;
+			});
+		}, Promise.resolve());
+
+		return promptResult.catch(err => {
+			if (err instanceof EscapeException || err instanceof TypeError) {
+				return undefined;
+			}
+
+			window.showErrorMessage(err.message);
+		});
+	}
+
+	// Helper to make it possible to prompt using callback pattern. Generally Promise is a preferred flow
+	public promptCallback(questions: IQuestion[], callback: IPromptCallback): void {
+		// Collapse multiple questions into a set of prompt steps
+		this.prompt(questions).then(answers => {
+			if (callback) {
+				callback(answers);
+			}
+		});
+	}
+}

extensions/notebook/src/prompts/checkbox.ts

@@ -0,0 +1,52 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+
+import { window } from 'vscode';
+import Prompt from './prompt';
+import EscapeException from './escapeException';
+
+const figures = require('figures');
+
+export default class CheckboxPrompt extends Prompt {
+
+	constructor(question: any, ignoreFocusOut?: boolean) {
+		super(question, ignoreFocusOut);
+	}
+
+	public render(): any {
+		let choices = this._question.choices.reduce((result, choice) => {
+			let choiceName = choice.name || choice;
+			result[`${choice.checked === true ? figures.radioOn : figures.radioOff} ${choiceName}`] = choice;
+			return result;
+		}, {});
+
+		let options = this.defaultQuickPickOptions;
+		options.placeHolder = this._question.message;
+
+		let quickPickOptions = Object.keys(choices);
+		quickPickOptions.push(figures.tick);
+
+		return window.showQuickPick(quickPickOptions, options)
+			.then(result => {
+				if (result === undefined) {
+					throw new EscapeException();
+				}
+
+				if (result !== figures.tick) {
+					choices[result].checked = !choices[result].checked;
+
+					return this.render();
+				}
+
+				return this._question.choices.reduce((result2, choice) => {
+					if (choice.checked === true) {
+						result2.push(choice.value);
+					}
+
+					return result2;
+				}, []);
+			});
+	}
+}

extensions/notebook/src/prompts/confirm.ts

@@ -0,0 +1,34 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+
+import { window } from 'vscode';
+import Prompt from './prompt';
+import LocalizedConstants = require('../common/localizedConstants');
+import EscapeException from './escapeException';
+
+export default class ConfirmPrompt extends Prompt {
+
+	constructor(question: any, ignoreFocusOut?: boolean) {
+		super(question, ignoreFocusOut);
+	}
+
+	public render(): any {
+		let choices: { [id: string]: boolean } = {};
+		choices[LocalizedConstants.msgYes] = true;
+		choices[LocalizedConstants.msgNo] = false;
+
+		let options = this.defaultQuickPickOptions;
+		options.placeHolder = this._question.message;
+
+		return window.showQuickPick(Object.keys(choices), options)
+			.then(result => {
+				if (result === undefined) {
+					throw new EscapeException();
+				}
+
+				return choices[result] || false;
+			});
+	}
+}

extensions/notebook/src/prompts/escapeException.ts

@@ -0,0 +1,3 @@
+'use strict';
+
+export default require('error-ex')('EscapeException');

extensions/notebook/src/prompts/expand.ts

@@ -0,0 +1,78 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+
+import vscode = require('vscode');
+import Prompt from './prompt';
+import EscapeException from './escapeException';
+import { INameValueChoice } from './question';
+
+const figures = require('figures');
+
+export default class ExpandPrompt extends Prompt {
+
+	constructor(question: any, ignoreFocusOut?: boolean) {
+		super(question, ignoreFocusOut);
+	}
+
+	public render(): any {
+		// label indicates this is a quickpick item. Otherwise it's a name-value pair
+		if (this._question.choices[0].label) {
+			return this.renderQuickPick(this._question.choices);
+		} else {
+			return this.renderNameValueChoice(this._question.choices);
+		}
+	}
+
+	private renderQuickPick(choices: vscode.QuickPickItem[]): any {
+		let options = this.defaultQuickPickOptions;
+		options.placeHolder = this._question.message;
+
+		return vscode.window.showQuickPick(choices, options)
+			.then(result => {
+				if (result === undefined) {
+					throw new EscapeException();
+				}
+
+				return this.validateAndReturn(result || false);
+			});
+	}
+	private renderNameValueChoice(choices: INameValueChoice[]): any {
+		const choiceMap = this._question.choices.reduce((result, choice) => {
+			result[choice.name] = choice.value;
+			return result;
+		}, {});
+
+		let options = this.defaultQuickPickOptions;
+		options.placeHolder = this._question.message;
+
+		return vscode.window.showQuickPick(Object.keys(choiceMap), options)
+			.then(result => {
+				if (result === undefined) {
+					throw new EscapeException();
+				}
+
+				// Note: cannot be used with 0 or false responses
+				let returnVal = choiceMap[result] || false;
+				return this.validateAndReturn(returnVal);
+			});
+	}
+
+	private validateAndReturn(value: any): any {
+		if (!this.validate(value)) {
+			return this.render();
+		}
+		return value;
+	}
+
+	private validate(value: any): boolean {
+		const validationError = this._question.validate ? this._question.validate(value || '') : undefined;
+
+		if (validationError) {
+			this._question.message = `${figures.warning} ${validationError}`;
+			return false;
+		}
+		return true;
+	}
+}

extensions/notebook/src/prompts/factory.ts

@@ -0,0 +1,39 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+
+import Prompt from './prompt';
+import InputPrompt from './input';
+import PasswordPrompt from './password';
+import ListPrompt from './list';
+import ConfirmPrompt from './confirm';
+import CheckboxPrompt from './checkbox';
+import ExpandPrompt from './expand';
+
+export default class PromptFactory {
+
+	public static createPrompt(question: any, ignoreFocusOut?: boolean): Prompt {
+		/**
+		 * TODO:
+		 *   - folder
+		 */
+		switch (question.type || 'input') {
+			case 'string':
+			case 'input':
+				return new InputPrompt(question, ignoreFocusOut);
+			case 'password':
+				return new PasswordPrompt(question, ignoreFocusOut);
+			case 'list':
+				return new ListPrompt(question, ignoreFocusOut);
+			case 'confirm':
+				return new ConfirmPrompt(question, ignoreFocusOut);
+			case 'checkbox':
+				return new CheckboxPrompt(question, ignoreFocusOut);
+			case 'expand':
+				return new ExpandPrompt(question, ignoreFocusOut);
+			default:
+				throw new Error(`Could not find a prompt for question type ${question.type}`);
+		}
+	}
+}

extensions/notebook/src/prompts/input.ts

@@ -0,0 +1,59 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+
+import { window, InputBoxOptions } from 'vscode';
+import Prompt from './prompt';
+import EscapeException from './escapeException';
+
+const figures = require('figures');
+
+export default class InputPrompt extends Prompt {
+
+	protected _options: InputBoxOptions;
+
+	constructor(question: any, ignoreFocusOut?: boolean) {
+		super(question, ignoreFocusOut);
+
+		this._options = this.defaultInputBoxOptions;
+		this._options.prompt = this._question.message;
+	}
+
+	// Helper for callers to know the right type to get from the type factory
+	public static get promptType(): string { return 'input'; }
+
+	public render(): any {
+		// Prefer default over the placeHolder, if specified
+		let placeHolder = this._question.default ? this._question.default : this._question.placeHolder;
+
+		if (this._question.default instanceof Error) {
+			placeHolder = this._question.default.message;
+			this._question.default = undefined;
+		}
+
+		this._options.placeHolder = placeHolder;
+
+		return window.showInputBox(this._options)
+			.then(result => {
+				if (result === undefined) {
+					throw new EscapeException();
+				}
+
+				if (result === '') {
+					// Use the default value, if defined
+					result = this._question.default || '';
+				}
+
+				const validationError = this._question.validate ? this._question.validate(result || '') : undefined;
+
+				if (validationError) {
+					this._question.default = new Error(`${figures.warning} ${validationError}`);
+
+					return this.render();
+				}
+
+				return result;
+			});
+	}
+}

extensions/notebook/src/prompts/list.ts

@@ -0,0 +1,34 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+
+import { window } from 'vscode';
+import Prompt from './prompt';
+import EscapeException from './escapeException';
+
+export default class ListPrompt extends Prompt {
+
+	constructor(question: any, ignoreFocusOut?: boolean) {
+		super(question, ignoreFocusOut);
+	}
+
+	public render(): any {
+		const choices = this._question.choices.reduce((result, choice) => {
+			result[choice.name] = choice.value;
+			return result;
+		}, {});
+
+		let options = this.defaultQuickPickOptions;
+		options.placeHolder = this._question.message;
+
+		return window.showQuickPick(Object.keys(choices), options)
+			.then(result => {
+				if (result === undefined) {
+					throw new EscapeException();
+				}
+
+				return choices[result];
+			});
+	}
+}

extensions/notebook/src/prompts/password.ts

@@ -0,0 +1,14 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+import InputPrompt from './input';
+
+export default class PasswordPrompt extends InputPrompt {
+
+	constructor(question: any, ignoreFocusOut?: boolean) {
+		super(question, ignoreFocusOut);
+
+		this._options.password = true;
+	}
+}

extensions/notebook/src/prompts/progressIndicator.ts

@@ -0,0 +1,70 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+
+import { window, StatusBarItem, StatusBarAlignment } from 'vscode';
+
+export default class ProgressIndicator {
+
+	private _statusBarItem: StatusBarItem;
+
+	constructor() {
+		this._statusBarItem = window.createStatusBarItem(StatusBarAlignment.Left);
+	}
+
+	private _tasks: string[] = [];
+	public beginTask(task: string): void {
+		this._tasks.push(task);
+		this.displayProgressIndicator();
+	}
+
+	public endTask(task: string): void {
+		if (this._tasks.length > 0) {
+			this._tasks.pop();
+		}
+
+		this.setMessage();
+	}
+
+	private setMessage(): void {
+		if (this._tasks.length === 0) {
+			this._statusBarItem.text = '';
+			this.hideProgressIndicator();
+			return;
+		}
+
+		this._statusBarItem.text = this._tasks[this._tasks.length - 1];
+		this._statusBarItem.show();
+	}
+
+	private _interval: any;
+	private displayProgressIndicator(): void {
+		this.setMessage();
+		this.hideProgressIndicator();
+		this._interval = setInterval(() => this.onDisplayProgressIndicator(), 100);
+	}
+	private hideProgressIndicator(): void {
+		if (this._interval) {
+			clearInterval(this._interval);
+			this._interval = undefined;
+		}
+		this.ProgressCounter = 0;
+	}
+
+	private ProgressText = ['|', '/', '-', '\\', '|', '/', '-', '\\'];
+	private ProgressCounter = 0;
+	private onDisplayProgressIndicator(): void {
+		if (this._tasks.length === 0) {
+			return;
+		}
+
+		let txt = this.ProgressText[this.ProgressCounter];
+		this._statusBarItem.text = this._tasks[this._tasks.length - 1] + ' ' + txt;
+		this.ProgressCounter++;
+
+		if (this.ProgressCounter >= this.ProgressText.length - 1) {
+			this.ProgressCounter = 0;
+		}
+	}
+}

extensions/notebook/src/prompts/prompt.ts

@@ -0,0 +1,33 @@
+'use strict';
+
+// This code is originally from https://github.com/DonJayamanne/bowerVSCode
+// License: https://github.com/DonJayamanne/bowerVSCode/blob/master/LICENSE
+
+import { InputBoxOptions, QuickPickOptions } from 'vscode';
+
+abstract class Prompt {
+
+	protected _question: any;
+	protected _ignoreFocusOut?: boolean;
+
+	constructor(question: any, ignoreFocusOut?: boolean) {
+		this._question = question;
+		this._ignoreFocusOut = ignoreFocusOut ? ignoreFocusOut : false;
+	}
+
+	public abstract render(): any;
+
+	protected get defaultQuickPickOptions(): QuickPickOptions {
+		return {
+			ignoreFocusOut: this._ignoreFocusOut
+		};
+	}
+
+	protected get defaultInputBoxOptions(): InputBoxOptions {
+		return {
+			ignoreFocusOut: this._ignoreFocusOut
+		};
+	}
+}
+
+export default Prompt;

extensions/notebook/src/prompts/question.ts

@@ -0,0 +1,68 @@
+
+'use strict';
+
+import vscode = require('vscode');
+
+export class QuestionTypes {
+	public static get input(): string { return 'input'; }
+	public static get password(): string { return 'password'; }
+	public static get list(): string { return 'list'; }
+	public static get confirm(): string { return 'confirm'; }
+	public static get checkbox(): string { return 'checkbox'; }
+	public static get expand(): string { return 'expand'; }
+}
+
+// Question interface to clarify how to use the prompt feature
+// based on Bower Question format: https://github.com/bower/bower/blob/89069784bb46bfd6639b4a75e98a0d7399a8c2cb/packages/bower-logger/README.md
+export interface IQuestion {
+	// Type of question (see QuestionTypes)
+	type: string;
+	// Name of the question for disambiguation
+	name: string;
+	// Message to display to the user
+	message: string;
+	// Optional placeHolder to give more detailed information to the user
+	placeHolder?: any;
+	// Optional default value - this will be used instead of placeHolder
+	default?: any;
+	// optional set of choices to be used. Can be QuickPickItems or a simple name-value pair
+	choices?: Array<vscode.QuickPickItem | INameValueChoice>;
+	// Optional validation function that returns an error string if validation fails
+	validate?: (value: any) => string;
+	// Optional pre-prompt function. Takes in set of answers so far, and returns true if prompt should occur
+	shouldPrompt?: (answers: { [id: string]: any }) => boolean;
+	// Optional action to take on the question being answered
+	onAnswered?: (value: any) => void;
+	// Optional set of options to support matching choices.
+	matchOptions?: vscode.QuickPickOptions;
+}
+
+// Pair used to display simple choices to the user
+export interface INameValueChoice {
+	name: string;
+	value: any;
+}
+
+// Generic object that can be used to define a set of questions and handle the result
+export interface IQuestionHandler {
+	// Set of questions to be answered
+	questions: IQuestion[];
+	// Optional callback, since questions may handle themselves
+	callback?: IPromptCallback;
+}
+
+export interface IPrompter {
+	promptSingle<T>(question: IQuestion, ignoreFocusOut?: boolean): Promise<T>;
+	/**
+	 * Prompts for multiple questions
+	 *
+	 * @returns {[questionId: string]: T} Map of question IDs to results, or undefined if
+	 * the user canceled the question session
+	 */
+	prompt<T>(questions: IQuestion[], ignoreFocusOut?: boolean): Promise<{ [questionId: string]: any }>;
+	promptCallback(questions: IQuestion[], callback: IPromptCallback): void;
+}
+
+export interface IPromptCallback {
+	(answers: { [id: string]: any }): void;
+}