SQL Operations Studio Public Preview 1 (0.23) release source code

dataprotocol-node/client/src/protocolConverter.ts

@@ -0,0 +1,769 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the Source EULA. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+'use strict';
+
+import * as code from 'vscode';
+import * as data from 'data';
+import * as ls from 'dataprotocol-languageserver-types';
+import * as is from './utils/is';
+import ProtocolCompletionItem from './protocolCompletionItem';
+import ProtocolCodeLens from './protocolCodeLens';
+
+export interface Converter {
+
+	asUri(value: string): code.Uri;
+
+	asDiagnostics(diagnostics: ls.Diagnostic[]): code.Diagnostic[];
+
+	asDiagnostic(diagnostic: ls.Diagnostic): code.Diagnostic;
+
+	asRange(value: ls.Range): code.Range;
+
+	asPosition(value: ls.Position): code.Position;
+
+	asDiagnosticSeverity(value: number): code.DiagnosticSeverity;
+
+	asHover(hover: ls.Hover): code.Hover;
+
+	asCompletionResult(result: ls.CompletionItem[] | ls.CompletionList): code.CompletionItem[] | code.CompletionList
+
+	asCompletionItem(item: ls.CompletionItem): ProtocolCompletionItem;
+
+	asTextEdit(edit: ls.TextEdit): code.TextEdit;
+
+	asTextEdits(items: ls.TextEdit[]): code.TextEdit[];
+
+	asSignatureHelp(item: ls.SignatureHelp): code.SignatureHelp;
+
+	asSignatureInformations(items: ls.SignatureInformation[]): code.SignatureInformation[];
+
+	asSignatureInformation(item: ls.SignatureInformation): code.SignatureInformation;
+
+	asParameterInformations(item: ls.ParameterInformation[]): code.ParameterInformation[];
+
+	asParameterInformation(item: ls.ParameterInformation): code.ParameterInformation;
+
+	asDefinitionResult(item: ls.Definition): code.Definition;
+
+	asLocation(item: ls.Location): code.Location;
+
+	asReferences(values: ls.Location[]): code.Location[];
+
+	asDocumentHighlights(values: ls.DocumentHighlight[]): code.DocumentHighlight[];
+
+	asDocumentHighlight(item: ls.DocumentHighlight): code.DocumentHighlight;
+
+	asDocumentHighlightKind(item: ls.DocumentHighlightKind): code.DocumentHighlightKind;
+
+	asSymbolInformations(values: ls.SymbolInformation[], uri?: code.Uri): code.SymbolInformation[];
+
+	asSymbolInformation(item: ls.SymbolInformation, uri?: code.Uri): code.SymbolInformation;
+
+	asCommand(item: ls.Command): code.Command;
+
+	asCommands(items: ls.Command[]): code.Command[];
+
+	asCodeLens(item: ls.CodeLens): code.CodeLens;
+
+	asCodeLenses(items: ls.CodeLens[]): code.CodeLens[];
+
+	asWorkspaceEdit(item: ls.WorkspaceEdit): code.WorkspaceEdit;
+
+	asDocumentLink(item: ls.DocumentLink): code.DocumentLink;
+
+	asDocumentLinks(items: ls.DocumentLink[]): code.DocumentLink[];
+
+	asConnectionSummary(params: ls.ConnectionCompleteParams): data.ConnectionInfoSummary;
+
+	asServerCapabilities(params: ls.CapabiltiesDiscoveryResult): data.DataProtocolServerCapabilities;
+
+	asProviderMetadata(params: ls.MetadataQueryResult): data.ProviderMetadata;
+
+	asScriptingResult(params: ls.ScriptingResult): data.ScriptingResult;
+
+	asObjectExplorerSession(params: ls.SessionCreatedParameters): data.ObjectExplorerSession;
+
+	asObjectExplorerCreateSessionResponse(params: ls.CreateSessionResponse): data.ObjectExplorerSessionResponse;
+
+	asObjectExplorerNodeInfo(params: ls.ExpandResponse): data.ObjectExplorerExpandInfo;
+
+	asObjectExplorerCloseSessionResponse(params: ls.CloseSessionResponse): data.ObjectExplorerCloseSessionResponse;
+
+	asListTasksResponse(response: ls.ListTasksResponse): data.ListTasksResponse;
+
+	asTaskInfo(params: ls.TaskInfo): data.TaskInfo;
+
+	asRestorePlanResponse(params: ls.RestorePlanResponse): data.RestorePlanResponse;
+
+	asRestoreResponse(params: ls.RestoreResponse): data.RestoreResponse;
+
+	asRestoreConfigInfo(params: ls.RestoreConfigInfoResponse): data.RestoreConfigInfo;
+}
+
+export interface URIConverter {
+	(value: string): code.Uri;
+}
+
+export function createConverter(uriConverter?: URIConverter): Converter {
+
+	const nullConverter = (value: string) => code.Uri.parse(value);
+
+	const _uriConverter: URIConverter = uriConverter || nullConverter;
+
+	function asUri(value: string): code.Uri {
+		return _uriConverter(value);
+	}
+
+	function asDiagnostics(diagnostics: ls.Diagnostic[]): code.Diagnostic[] {
+		return diagnostics.map(asDiagnostic);
+	}
+
+	function asDiagnostic(diagnostic: ls.Diagnostic): code.Diagnostic {
+		let result = new code.Diagnostic(asRange(diagnostic.range), diagnostic.message, asDiagnosticSeverity(diagnostic.severity));
+		if (is.defined(diagnostic.code)) {
+			result.code = diagnostic.code;
+		}
+		if (is.defined(diagnostic.source)) {
+			result.source = diagnostic.source;
+		}
+		return result;
+	}
+
+	function asRange(value: ls.Range): code.Range {
+		if (is.undefined(value)) {
+			return undefined;
+		} else if (is.nil(value)) {
+			return null;
+		}
+		return new code.Range(asPosition(value.start), asPosition(value.end));
+	}
+
+	function asPosition(value: ls.Position): code.Position {
+		if (is.undefined(value)) {
+			return undefined;
+		} else if (is.nil(value)) {
+			return null;
+		}
+		return new code.Position(value.line, value.character);
+	}
+
+	function asDiagnosticSeverity(value: number): code.DiagnosticSeverity {
+		if (is.undefined(value) || is.nil(value)) {
+			return code.DiagnosticSeverity.Error;
+		}
+		switch (value) {
+			case ls.DiagnosticSeverity.Error:
+				return code.DiagnosticSeverity.Error;
+			case ls.DiagnosticSeverity.Warning:
+				return code.DiagnosticSeverity.Warning;
+			case ls.DiagnosticSeverity.Information:
+				return code.DiagnosticSeverity.Information;
+			case ls.DiagnosticSeverity.Hint:
+				return code.DiagnosticSeverity.Hint;
+		}
+		return code.DiagnosticSeverity.Error;
+	}
+
+	function asHover(hover: ls.Hover): code.Hover {
+		if (is.undefined(hover)) {
+			return undefined;
+		}
+		if (is.nil(hover)) {
+			return null;
+		}
+		if (is.nil(hover.contents) || is.undefined(hover.contents)) {
+			// Contents must be defined or hover will throw
+			return null;
+		}
+		return new code.Hover(hover.contents, is.defined(hover.range) ? asRange(hover.range) : undefined);
+	}
+
+	function asCompletionResult(result: ls.CompletionItem[] | ls.CompletionList): code.CompletionItem[] | code.CompletionList {
+		if (is.undefined(result)) {
+			return undefined;
+		} else if (is.nil(result)) {
+			return null;
+		}
+		if (Array.isArray(result)) {
+			let items = <ls.CompletionItem[]>result;
+			return items.map(asCompletionItem);
+		}
+		let list = <ls.CompletionList>result;
+		return new code.CompletionList(list.items.map(asCompletionItem), list.isIncomplete);
+	}
+
+	function set<T>(value: T, func: () => void): void {
+		if (is.defined(value)) {
+			func();
+		}
+	}
+
+	function asCompletionItem(item: ls.CompletionItem): ProtocolCompletionItem {
+		let result = new ProtocolCompletionItem(item.label);
+		set(item.detail, () => result.detail = item.detail);
+		set(item.documentation, () => result.documentation = item.documentation);
+		set(item.filterText, () => result.filterText = item.filterText);
+		set(item.insertText, () => result.insertText = item.insertText);
+		// Protocol item kind is 1 based, codes item kind is zero based.
+		set(item.kind, () => result.kind = item.kind - 1);
+		set(item.sortText, () => result.sortText = item.sortText);
+		set(item.textEdit, () => result.textEdit = asTextEdit(item.textEdit));
+		set(item.additionalTextEdits, () => result.additionalTextEdits = asTextEdits(item.additionalTextEdits));
+		set(item.command, () => result.command = asCommand(item.command));
+		set(item.data, () => result.data = item.data);
+		return result;
+	}
+
+	function asTextEdit(edit: ls.TextEdit): code.TextEdit {
+		return new code.TextEdit(asRange(edit.range), edit.newText);
+	}
+
+	function asTextEdits(items: ls.TextEdit[]): code.TextEdit[] {
+		if (is.undefined(items)) {
+			return undefined;
+		} else if (is.nil(items)) {
+			return null;
+		}
+		return items.map(asTextEdit);
+	}
+
+	function asSignatureHelp(item: ls.SignatureHelp): code.SignatureHelp {
+		if (is.undefined(item)) {
+			return undefined;
+		} else if (is.nil(item)) {
+			return null;
+		}
+		let result = new code.SignatureHelp();
+		set(item.activeParameter, () => result.activeParameter = item.activeParameter);
+		set(item.activeSignature, () => result.activeSignature = item.activeSignature);
+		set(item.signatures, () => result.signatures = asSignatureInformations(item.signatures));
+		return result;
+	}
+
+	function asSignatureInformations(items: ls.SignatureInformation[]): code.SignatureInformation[] {
+		return items ? items.map(asSignatureInformation) : undefined;
+	}
+
+	function asSignatureInformation(item: ls.SignatureInformation): code.SignatureInformation {
+		if (!item) {
+			return undefined;
+		}
+		let result = new code.SignatureInformation(item.label);
+		set(item.documentation, () => result.documentation = item.documentation);
+		set(item.parameters, () => result.parameters = asParameterInformations(item.parameters));
+		return result;
+	}
+
+	function asParameterInformations(item: ls.ParameterInformation[]): code.ParameterInformation[] {
+		return item.map(asParameterInformation);
+	}
+
+	function asParameterInformation(item: ls.ParameterInformation): code.ParameterInformation {
+		let result = new code.ParameterInformation(item.label);
+		set(item.documentation, () => result.documentation = item.documentation);
+		return result;
+	}
+
+	function asDefinitionResult(item: ls.Definition): code.Definition {
+		if (is.undefined(item)) {
+			return undefined;
+		} else if (is.nil(item)) {
+			return null;
+		}
+		if (is.array(item)) {
+			return item.map(asLocation);
+		} else {
+			return asLocation(item);
+		}
+	}
+
+	function asLocation(item: ls.Location): code.Location {
+		if (is.undefined(item)) {
+			return undefined;
+		}
+		if (is.nil(item)) {
+			return null;
+		}
+		return new code.Location(_uriConverter(item.uri), asRange(item.range));
+	}
+
+	function asReferences(values: ls.Location[]): code.Location[] {
+		if (is.undefined(values)) {
+			return undefined;
+		}
+		if (is.nil(values)) {
+			return null;
+		}
+		return values.map(asLocation);
+	}
+
+	function asDocumentHighlights(values: ls.DocumentHighlight[]): code.DocumentHighlight[] {
+		if (is.undefined(values)) {
+			return undefined;
+		}
+		if (is.nil(values)) {
+			return null;
+		}
+		return values.map(asDocumentHighlight);
+	}
+
+	function asDocumentHighlight(item: ls.DocumentHighlight): code.DocumentHighlight {
+		let result = new code.DocumentHighlight(asRange(item.range));
+		set(item.kind, () => result.kind = asDocumentHighlightKind(item.kind));
+		return result;
+	}
+
+	function asDocumentHighlightKind(item: ls.DocumentHighlightKind): code.DocumentHighlightKind {
+		switch (item) {
+			case ls.DocumentHighlightKind.Text:
+				return code.DocumentHighlightKind.Text;
+			case ls.DocumentHighlightKind.Read:
+				return code.DocumentHighlightKind.Read;
+			case ls.DocumentHighlightKind.Write:
+				return code.DocumentHighlightKind.Write;
+		}
+		return code.DocumentHighlightKind.Text;
+	}
+
+	function asSymbolInformations(values: ls.SymbolInformation[], uri?: code.Uri): code.SymbolInformation[] {
+		if (is.undefined(values)) {
+			return undefined;
+		}
+		if (is.nil(values)) {
+			return null;
+		}
+		return values.map(information => asSymbolInformation(information, uri));
+	}
+
+	function asSymbolInformation(item: ls.SymbolInformation, uri?: code.Uri): code.SymbolInformation {
+		// Symbol kind is one based in the protocol and zero based in code.
+		let result = new code.SymbolInformation(
+			item.name, item.kind - 1,
+			asRange(item.location.range),
+			item.location.uri ? _uriConverter(item.location.uri) : uri);
+		set(item.containerName, () => result.containerName = item.containerName);
+		return result;
+	}
+
+	function asCommand(item: ls.Command): code.Command {
+		let result: code.Command = { title: item.title, command: item.command };
+		set(item.arguments, () => result.arguments = item.arguments);
+		return result;
+	}
+
+	function asCommands(items: ls.Command[]): code.Command[] {
+		if (is.undefined(items)) {
+			return undefined;
+		}
+		if (is.nil(items)) {
+			return null;
+		}
+		return items.map(asCommand);
+	}
+
+	function asCodeLens(item: ls.CodeLens): code.CodeLens {
+		let result: ProtocolCodeLens = new ProtocolCodeLens(asRange(item.range));
+		if (is.defined(item.command)) { result.command = asCommand(item.command); }
+		if (is.defined(item.data)) { result.data = item.data; }
+		return result;
+	}
+
+	function asCodeLenses(items: ls.CodeLens[]): code.CodeLens[] {
+		if (is.undefined(items)) {
+			return undefined;
+		}
+		if (is.nil(items)) {
+			return null;
+		}
+		return items.map(asCodeLens);
+	}
+
+	function asWorkspaceEdit(item: ls.WorkspaceEdit): code.WorkspaceEdit {
+		if (is.undefined(item)) {
+			return undefined;
+		}
+		if (is.nil(item)) {
+			return null;
+		}
+		let result = new code.WorkspaceEdit();
+		let keys = Object.keys(item.changes);
+		keys.forEach(key => result.set(_uriConverter(key), asTextEdits(item.changes[key])));
+		return result;
+	}
+
+	function asDocumentLink(item: ls.DocumentLink): code.DocumentLink {
+		let range = asRange(item.range);
+		let target = is.defined(item.target) && asUri(item.target);
+		return new code.DocumentLink(range, target);
+	}
+
+	function asDocumentLinks(items: ls.DocumentLink[]): code.DocumentLink[] {
+		if (is.undefined(items)) {
+			return undefined;
+		}
+		if (is.nil(items)) {
+			return null;
+		}
+		return items.map(asDocumentLink);
+	}
+
+	function asConnectionSummary(params: ls.ConnectionCompleteParams): data.ConnectionInfoSummary {
+		let connSummary: data.ConnectionInfoSummary = {
+			ownerUri: params.ownerUri,
+			connectionId: params.connectionId,
+			messages: params.messages,
+			errorMessage: params.errorMessage,
+			errorNumber: params.errorNumber,
+			serverInfo: params.serverInfo,
+			connectionSummary: params.connectionSummary
+		};
+		return connSummary;
+	}
+
+	function asServiceOptionType(val: string): data.ServiceOptionType {
+		if (val === 'string') {
+			return data.ServiceOptionType.string;
+		} else if (val === 'multistring') {
+			return data.ServiceOptionType.multistring;
+		} else if (val === 'password') {
+			return data.ServiceOptionType.password;
+		} else if (val === 'number') {
+			return data.ServiceOptionType.number;
+		} else if (val === 'boolean') {
+			return data.ServiceOptionType.boolean;
+		} else if (val === 'category') {
+			return data.ServiceOptionType.category;
+		} else if (val === 'object') {
+			return data.ServiceOptionType.object;
+		}
+
+		// assume string for unknown value types
+		return data.ServiceOptionType.string;
+	}
+
+	function asServerCapabilities(result: ls.CapabiltiesDiscoveryResult): data.DataProtocolServerCapabilities {
+		let capabilities: data.DataProtocolServerCapabilities = {
+			protocolVersion: result.capabilities.protocolVersion,
+			providerName: result.capabilities.providerName,
+			providerDisplayName: result.capabilities.providerDisplayName,
+			connectionProvider: undefined,
+			adminServicesProvider: undefined,
+			features: []
+		};
+
+		if (result.capabilities.adminServicesProvider) {
+			capabilities.adminServicesProvider = <data.AdminServicesOptions>{
+				databaseInfoOptions: new Array<data.ServiceOption>(),
+				databaseFileInfoOptions: new Array<data.ServiceOption>(),
+				fileGroupInfoOptions: new Array<data.ServiceOption>()
+			};
+
+			if (result.capabilities.adminServicesProvider.databaseInfoOptions
+				&& result.capabilities.adminServicesProvider.databaseInfoOptions.length > 0) {
+				for (let i = 0; i < result.capabilities.adminServicesProvider.databaseInfoOptions.length; ++i) {
+					let srcOption: ls.ServiceOption = result.capabilities.adminServicesProvider.databaseInfoOptions[i];
+					let descOption: data.ServiceOption = buildServiceOption(srcOption);
+					capabilities.adminServicesProvider.databaseInfoOptions.push(descOption);
+				}
+			}
+
+			if (result.capabilities.adminServicesProvider.databaseFileInfoOptions
+				&& result.capabilities.adminServicesProvider.databaseFileInfoOptions.length > 0) {
+				for (let i = 0; i < result.capabilities.adminServicesProvider.databaseFileInfoOptions.length; ++i) {
+					let srcOption: ls.ServiceOption = result.capabilities.adminServicesProvider.databaseFileInfoOptions[i];
+					let descOption: data.ServiceOption = buildServiceOption(srcOption);
+					capabilities.adminServicesProvider.databaseFileInfoOptions.push(descOption);
+				}
+			}
+
+			if (result.capabilities.adminServicesProvider.fileGroupInfoOptions
+				&& result.capabilities.adminServicesProvider.fileGroupInfoOptions.length > 0) {
+				for (let i = 0; i < result.capabilities.adminServicesProvider.fileGroupInfoOptions.length; ++i) {
+					let srcOption: ls.ServiceOption = result.capabilities.adminServicesProvider.fileGroupInfoOptions[i];
+					let descOption: data.ServiceOption = buildServiceOption(srcOption);
+					capabilities.adminServicesProvider.fileGroupInfoOptions.push(descOption);
+				}
+			}
+		}
+
+		if (result.capabilities.connectionProvider
+			&& result.capabilities.connectionProvider.options
+			&& result.capabilities.connectionProvider.options.length > 0) {
+			capabilities.connectionProvider = <data.ConnectionProviderOptions>{
+				options: new Array<data.ConnectionOption>()
+			};
+			for (let i = 0; i < result.capabilities.connectionProvider.options.length; ++i) {
+				let srcOption: ls.ConnectionOption = result.capabilities.connectionProvider.options[i];
+				let descOption: data.ConnectionOption = {
+					name: srcOption.name,
+					displayName: srcOption.displayName ? srcOption.displayName : srcOption.name,
+					description: srcOption.description,
+					groupName: srcOption.groupName,
+					defaultValue: srcOption.defaultValue,
+					categoryValues: srcOption.categoryValues,
+					isIdentity: srcOption.isIdentity,
+					isRequired: srcOption.isRequired,
+					valueType: asServiceOptionType(srcOption.valueType),
+					specialValueType: undefined
+				};
+
+				if (srcOption.specialValueType === 'serverName') {
+					descOption.specialValueType = data.ConnectionOptionSpecialType.serverName;
+				} else if (srcOption.specialValueType === 'databaseName') {
+					descOption.specialValueType = data.ConnectionOptionSpecialType.databaseName;
+				} else if (srcOption.specialValueType === 'authType') {
+					descOption.specialValueType = data.ConnectionOptionSpecialType.authType;
+				} else if (srcOption.specialValueType === 'userName') {
+					descOption.specialValueType = data.ConnectionOptionSpecialType.userName;
+				} else if (srcOption.specialValueType === 'password') {
+					descOption.specialValueType = data.ConnectionOptionSpecialType.password;
+				} else if (srcOption.specialValueType === 'appName') {
+					descOption.specialValueType = data.ConnectionOptionSpecialType.appName;
+				}
+
+				capabilities.connectionProvider.options.push(descOption);
+			}
+		}
+
+		if (result.capabilities.features
+			&& result.capabilities.features.length > 0) {
+			result.capabilities.features.forEach(feature => {
+				let descFeature: data.FeatureMetadataProvider = {
+					enabled: feature.enabled,
+					featureName: feature.featureName,
+					optionsMetadata: []
+				};
+				capabilities.features.push(descFeature);
+				if (feature.optionsMetadata) {
+					feature.optionsMetadata.forEach(srcOption => {
+						descFeature.optionsMetadata.push(buildServiceOption(srcOption));
+					});
+				}
+			});
+		}
+
+		return capabilities;
+	}
+
+	function buildServiceOption(srcOption: ls.ServiceOption): data.ServiceOption {
+		return {
+			name: srcOption.name,
+			displayName: srcOption.displayName ? srcOption.displayName : srcOption.name,
+			description: srcOption.description,
+			groupName: srcOption.groupName,
+			defaultValue: srcOption.defaultValue,
+			categoryValues: srcOption.categoryValues,
+			isRequired: srcOption.isRequired,
+			isArray: srcOption.isArray,
+			objectType: srcOption.objectType,
+			valueType: asServiceOptionType(srcOption.valueType),
+		};
+	}
+
+	function asProviderMetadata(params: ls.MetadataQueryResult): data.ProviderMetadata {
+		let objectMetadata: data.ObjectMetadata[] = [];
+
+		if (!params.metadata || !params.metadata.length) {
+			return {
+				objectMetadata: objectMetadata
+			};
+		}
+
+		for (let i = 0; i < params.metadata.length; ++i) {
+			let metadata: ls.ObjectMetadata = params.metadata[i];
+
+			let metadataTypeName: string;
+			if (metadata.metadataTypeName) {
+				// Read from the provider since it's defined
+				metadataTypeName = metadata.metadataTypeName;
+			} else if (metadata.metadataType === ls.MetadataType.View) {
+				metadataTypeName = 'View';
+			} else if (metadata.metadataType === ls.MetadataType.SProc) {
+				metadataTypeName = 'StoredProcedure';
+			} else if (metadata.metadataType === ls.MetadataType.Function) {
+				metadataTypeName = 'Function';
+			} else {
+				metadataTypeName = 'Table';
+			}
+
+			objectMetadata.push({
+				metadataTypeName: metadataTypeName,
+				metadataType: metadata.metadataType,
+				name: metadata.name,
+				schema: metadata.schema,
+				urn: metadata.urn
+			});
+		}
+
+		return <data.ProviderMetadata>{
+			objectMetadata: objectMetadata
+		};
+	}
+
+	function asObjectExplorerSession(params: ls.SessionCreatedParameters): data.ObjectExplorerSession {
+		return <data.ObjectExplorerSession>{
+			success: params.success,
+			sessionId: params.sessionId,
+			rootNode: params.rootNode,
+			errorMessage: params.errorMessage
+		};
+	}
+
+	function asObjectExplorerCreateSessionResponse(params: ls.CreateSessionResponse): data.ObjectExplorerSessionResponse {
+		return <data.ObjectExplorerSessionResponse>{
+			sessionId: params.sessionId
+		};
+	}
+
+	function asObjectExplorerNodeInfo(params: ls.ExpandResponse): data.ObjectExplorerExpandInfo {
+		return <data.ObjectExplorerExpandInfo>{
+			sessionId: params.sessionId,
+			nodes: params.nodes,
+			errorMessage: params.errorMessage,
+			nodePath: params.nodePath
+		};
+	}
+
+	function asObjectExplorerCloseSessionResponse(params: ls.CloseSessionResponse): data.ObjectExplorerCloseSessionResponse {
+		return <data.ObjectExplorerCloseSessionResponse>{
+			sessionId: params.sessionId,
+			success: params.success
+		};
+	}
+
+	function asScriptingResult(params: ls.ScriptingResult): data.ScriptingResult {
+		return <data.ScriptingResult>{
+			operationId: params.operationId,
+			script: params.script
+		};
+	}
+
+	function asListTasksResponse(response: ls.ListTasksResponse): data.ListTasksResponse {
+		return <data.ListTasksResponse>{
+			tasks: response.tasks
+		};
+	}
+
+	function asTaskInfo(params: ls.TaskInfo): data.TaskInfo {
+		return <data.TaskInfo>{
+			taskId: params.taskId,
+			status: params.status,
+			taskExecutionMode: params.taskExecutionMode,
+			serverName: params.serverName,
+			name: params.name,
+			databaseName: params.databaseName,
+			description: params.description,
+			providerName: params.providerName,
+			isCancelable: params.isCancelable,
+		};
+	}
+
+	function asRestorePlanResponse(params: ls.RestorePlanResponse): data.RestorePlanResponse {
+		return <data.RestorePlanResponse>{
+			backupSetsToRestore: params.backupSetsToRestore,
+			canRestore: params.canRestore,
+			databaseNamesFromBackupSets: params.databaseNamesFromBackupSets,
+			dbFiles: params.dbFiles,
+			errorMessage: params.errorMessage,
+			planDetails: params.planDetails,
+			sessionId: params.sessionId
+		};
+	}
+
+	function asRestoreResponse(params: ls.RestoreResponse): data.RestoreResponse {
+		return <data.RestoreResponse>{
+			result: params.result,
+			errorMessage: params.errorMessage,
+			taskId: params.taskId
+		};
+	}
+
+	function asRestoreConfigInfo(params: ls.RestoreConfigInfoResponse): data.RestoreConfigInfo {
+		return <data.RestoreConfigInfo>{
+			configInfo: params.configInfo
+		};
+	}
+
+	return {
+		asUri,
+		asDiagnostics,
+		asDiagnostic,
+		asRange,
+		asPosition,
+		asDiagnosticSeverity,
+		asHover,
+		asCompletionResult,
+		asCompletionItem,
+		asTextEdit,
+		asTextEdits,
+		asSignatureHelp,
+		asSignatureInformations,
+		asSignatureInformation,
+		asParameterInformations,
+		asParameterInformation,
+		asDefinitionResult,
+		asLocation,
+		asReferences,
+		asDocumentHighlights,
+		asDocumentHighlight,
+		asDocumentHighlightKind,
+		asSymbolInformations,
+		asSymbolInformation,
+		asCommand,
+		asCommands,
+		asCodeLens,
+		asCodeLenses,
+		asWorkspaceEdit,
+		asDocumentLink,
+		asDocumentLinks,
+		asConnectionSummary,
+		asServerCapabilities,
+		asProviderMetadata,
+		asScriptingResult,
+		asObjectExplorerSession,
+		asObjectExplorerCreateSessionResponse,
+		asObjectExplorerNodeInfo,
+		asObjectExplorerCloseSessionResponse,
+		asListTasksResponse,
+		asTaskInfo,
+		asRestorePlanResponse,
+		asRestoreResponse,
+		asRestoreConfigInfo
+	};
+}
+
+// This for backward compatibility since we exported the converter functions as API.
+const defaultConverter = createConverter();
+
+export const asDiagnostics: (diagnostics: ls.Diagnostic[]) => code.Diagnostic[] = defaultConverter.asDiagnostics;
+export const asDiagnostic: (diagnostic: ls.Diagnostic) => code.Diagnostic = defaultConverter.asDiagnostic;
+export const asRange: (value: ls.Range) => code.Range = defaultConverter.asRange;
+export const asPosition: (value: ls.Position) => code.Position = defaultConverter.asPosition;
+export const asDiagnosticSeverity: (value: number) => code.DiagnosticSeverity = defaultConverter.asDiagnosticSeverity;
+export const asHover: (hover: ls.Hover) => code.Hover = defaultConverter.asHover;
+export const asCompletionResult: (result: ls.CompletionItem[] | ls.CompletionList) => code.CompletionItem[] | code.CompletionList = defaultConverter.asCompletionResult;
+export const asCompletionItem: (item: ls.CompletionItem) => ProtocolCompletionItem = defaultConverter.asCompletionItem;
+export const asTextEdit: (edit: ls.TextEdit) => code.TextEdit = defaultConverter.asTextEdit;
+export const asTextEdits: (items: ls.TextEdit[]) => code.TextEdit[] = defaultConverter.asTextEdits;
+export const asSignatureHelp: (item: ls.SignatureHelp) => code.SignatureHelp = defaultConverter.asSignatureHelp;
+export const asSignatureInformations: (items: ls.SignatureInformation[]) => code.SignatureInformation[] = defaultConverter.asSignatureInformations;
+export const asSignatureInformation: (item: ls.SignatureInformation) => code.SignatureInformation = defaultConverter.asSignatureInformation;
+export const asParameterInformations: (item: ls.ParameterInformation[]) => code.ParameterInformation[] = defaultConverter.asParameterInformations;
+export const asParameterInformation: (item: ls.ParameterInformation) => code.ParameterInformation = defaultConverter.asParameterInformation;
+export const asDefinitionResult: (item: ls.Definition) => code.Definition = defaultConverter.asDefinitionResult;
+export const asLocation: (item: ls.Location) => code.Location = defaultConverter.asLocation;
+export const asReferences: (values: ls.Location[]) => code.Location[] = defaultConverter.asReferences;
+export const asDocumentHighlights: (values: ls.DocumentHighlight[]) => code.DocumentHighlight[] = defaultConverter.asDocumentHighlights;
+export const asDocumentHighlight: (item: ls.DocumentHighlight) => code.DocumentHighlight = defaultConverter.asDocumentHighlight;
+export const asDocumentHighlightKind: (item: ls.DocumentHighlightKind) => code.DocumentHighlightKind = defaultConverter.asDocumentHighlightKind;
+export const asSymbolInformations: (values: ls.SymbolInformation[], uri?: code.Uri) => code.SymbolInformation[] = defaultConverter.asSymbolInformations;
+export const asSymbolInformation: (item: ls.SymbolInformation, uri?: code.Uri) => code.SymbolInformation = defaultConverter.asSymbolInformation;
+export const asCommand: (item: ls.Command) => code.Command = defaultConverter.asCommand;
+export const asCommands: (items: ls.Command[]) => code.Command[] = defaultConverter.asCommands;
+export const asCodeLens: (item: ls.CodeLens) => code.CodeLens = defaultConverter.asCodeLens;
+export const asCodeLenses: (items: ls.CodeLens[]) => code.CodeLens[] = defaultConverter.asCodeLenses;
+export const asWorkspaceEdit: (item: ls.WorkspaceEdit) => code.WorkspaceEdit = defaultConverter.asWorkspaceEdit;
+export const asDocumentLink: (item: ls.DocumentLink) => code.DocumentLink = defaultConverter.asDocumentLink;
+export const asDocumentLinks: (item: ls.DocumentLink[]) => code.DocumentLink[] = defaultConverter.asDocumentLinks;