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

src/vs/base/common/errorMessage.ts

@@ -0,0 +1,249 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 nls = require('vs/nls');
+import objects = require('vs/base/common/objects');
+import types = require('vs/base/common/types');
+import arrays = require('vs/base/common/arrays');
+import strings = require('vs/base/common/strings');
+
+export interface IXHRResponse {
+	responseText: string;
+	status: number;
+
+	readyState: number;
+	getResponseHeader: (header: string) => string;
+}
+
+export interface IConnectionErrorData {
+	status: number;
+	statusText?: string;
+	responseText?: string;
+}
+
+/**
+ * The base class for all connection errors originating from XHR requests.
+ */
+export class ConnectionError implements Error {
+	public status: number;
+	public statusText: string;
+	public responseText: string;
+	public errorMessage: string;
+	public errorCode: string;
+	public errorObject: any;
+	public name: string;
+
+	constructor(mixin: IConnectionErrorData);
+	constructor(request: IXHRResponse);
+	constructor(arg: any) {
+		this.status = arg.status;
+		this.statusText = arg.statusText;
+		this.name = 'ConnectionError';
+
+		try {
+			this.responseText = arg.responseText;
+		} catch (e) {
+			this.responseText = '';
+		}
+
+		this.errorMessage = null;
+		this.errorCode = null;
+		this.errorObject = null;
+
+		if (this.responseText) {
+			try {
+				let errorObj = JSON.parse(this.responseText);
+				this.errorMessage = errorObj.message;
+				this.errorCode = errorObj.code;
+				this.errorObject = errorObj;
+			} catch (error) {
+				// Ignore
+			}
+		}
+	}
+
+	public get message(): string {
+		return this.connectionErrorToMessage(this, false);
+	}
+
+	public get verboseMessage(): string {
+		return this.connectionErrorToMessage(this, true);
+	}
+
+	private connectionErrorDetailsToMessage(error: ConnectionError, verbose: boolean): string {
+		let errorCode = error.errorCode;
+		let errorMessage = error.errorMessage;
+
+		if (errorCode !== null && errorMessage !== null) {
+			return nls.localize(
+				{
+					key: 'message',
+					comment: [
+						'{0} represents the error message',
+						'{1} represents the error code'
+					]
+				},
+				"{0}. Error code: {1}",
+				strings.rtrim(errorMessage, '.'), errorCode);
+		}
+
+		if (errorMessage !== null) {
+			return errorMessage;
+		}
+
+		if (verbose && error.responseText !== null) {
+			return error.responseText;
+		}
+
+		return null;
+	}
+
+	private connectionErrorToMessage(error: ConnectionError, verbose: boolean): string {
+		let details = this.connectionErrorDetailsToMessage(error, verbose);
+
+		// Status Code based Error
+		if (error.status === 401) {
+			if (details !== null) {
+				return nls.localize(
+					{
+						key: 'error.permission.verbose',
+						comment: [
+							'{0} represents detailed information why the permission got denied'
+						]
+					},
+					"Permission Denied (HTTP {0})",
+					details);
+			}
+
+			return nls.localize('error.permission', "Permission Denied");
+		}
+
+		// Return error details if present
+		if (details) {
+			return details;
+		}
+
+		// Fallback to HTTP Status and Code
+		if (error.status > 0 && error.statusText !== null) {
+			if (verbose && error.responseText !== null && error.responseText.length > 0) {
+				return nls.localize('error.http.verbose', "{0} (HTTP {1}: {2})", error.statusText, error.status, error.responseText);
+			}
+
+			return nls.localize('error.http', "{0} (HTTP {1})", error.statusText, error.status);
+		}
+
+		// Finally its an Unknown Connection Error
+		if (verbose && error.responseText !== null && error.responseText.length > 0) {
+			return nls.localize('error.connection.unknown.verbose', "Unknown Connection Error ({0})", error.responseText);
+		}
+
+		return nls.localize('error.connection.unknown', "An unknown connection error occurred. Either you are no longer connected to the internet or the server you are connected to is offline.");
+	}
+}
+
+// Bug: Can not subclass a JS Type. Do it manually (as done in WinJS.Class.derive)
+objects.derive(Error, ConnectionError);
+
+function xhrToErrorMessage(xhr: IConnectionErrorData, verbose: boolean): string {
+	let ce = new ConnectionError(xhr);
+	if (verbose) {
+		return ce.verboseMessage;
+	} else {
+		return ce.message;
+	}
+}
+
+function exceptionToErrorMessage(exception: any, verbose: boolean): string {
+	if (exception.message) {
+		if (verbose && (exception.stack || exception.stacktrace)) {
+			return nls.localize('stackTrace.format', "{0}: {1}", detectSystemErrorMessage(exception), exception.stack || exception.stacktrace);
+		}
+
+		return detectSystemErrorMessage(exception);
+	}
+
+	return nls.localize('error.defaultMessage', "An unknown error occurred. Please consult the log for more details.");
+}
+
+function detectSystemErrorMessage(exception: any): string {
+
+	// See https://nodejs.org/api/errors.html#errors_class_system_error
+	if (typeof exception.code === 'string' && typeof exception.errno === 'number' && typeof exception.syscall === 'string') {
+		return nls.localize('nodeExceptionMessage', "A system error occurred ({0})", exception.message);
+	}
+
+	return exception.message;
+}
+
+/**
+ * Tries to generate a human readable error message out of the error. If the verbose parameter
+ * is set to true, the error message will include stacktrace details if provided.
+ * @returns A string containing the error message.
+ */
+export function toErrorMessage(error: any = null, verbose: boolean = false): string {
+	if (!error) {
+		return nls.localize('error.defaultMessage', "An unknown error occurred. Please consult the log for more details.");
+	}
+
+	if (Array.isArray(error)) {
+		let errors: any[] = arrays.coalesce(error);
+		let msg = toErrorMessage(errors[0], verbose);
+
+		if (errors.length > 1) {
+			return nls.localize('error.moreErrors', "{0} ({1} errors in total)", msg, errors.length);
+		}
+
+		return msg;
+	}
+
+	if (types.isString(error)) {
+		return error;
+	}
+
+	if (!types.isUndefinedOrNull(error.status)) {
+		return xhrToErrorMessage(error, verbose);
+	}
+
+	if (error.detail) {
+		let detail = error.detail;
+
+		if (detail.error) {
+			if (detail.error && !types.isUndefinedOrNull(detail.error.status)) {
+				return xhrToErrorMessage(detail.error, verbose);
+			}
+
+			if (types.isArray(detail.error)) {
+				for (let i = 0; i < detail.error.length; i++) {
+					if (detail.error[i] && !types.isUndefinedOrNull(detail.error[i].status)) {
+						return xhrToErrorMessage(detail.error[i], verbose);
+					}
+				}
+			}
+
+			else {
+				return exceptionToErrorMessage(detail.error, verbose);
+			}
+		}
+
+		if (detail.exception) {
+			if (!types.isUndefinedOrNull(detail.exception.status)) {
+				return xhrToErrorMessage(detail.exception, verbose);
+			}
+
+			return exceptionToErrorMessage(detail.exception, verbose);
+		}
+	}
+
+	if (error.stack) {
+		return exceptionToErrorMessage(error, verbose);
+	}
+
+	if (error.message) {
+		return error.message;
+	}
+
+	return nls.localize('error.defaultMessage', "An unknown error occurred. Please consult the log for more details.");
+}