project/lib/validation/ValidationError.js

  1. const chalk = require("chalk");
  2. const escapeStringRegExp = require("escape-string-regexp");
  4. /**
  5.  * Error class for validation of project configuration.
  6.  *
  7.  * @public
  8.  * @hideconstructor
  9.  * @augments Error
  10.  * @memberof module:@ui5/project.validation
  11.  */
  12. class ValidationError extends Error {
  13. 	constructor({errors, project, yaml}) {
  14. 		super();
  16. 		/**
  17. 		 * ValidationError
  18. 		 *
  19. 		 * @constant
  20. 		 * @default
  21. 		 * @type {string}
  22. 		 * @readonly
  23. 		 * @public
  24. 		 */
  25. 		this.name = "ValidationError";
  27. 		this.project = project;
  28. 		this.yaml = yaml;
  30. 		this.errors = ValidationError.filterErrors(errors);
  32. 		/**
  33. 		 * Formatted error message
  34. 		 *
  35. 		 * @type {string}
  36. 		 * @readonly
  37. 		 * @public
  38. 		 */
  39. 		this.message = this.formatErrors();
  41. 		Error.captureStackTrace(this, this.constructor);
  42. 	}
  44. 	formatErrors() {
  45. 		let separator = "\n\n";
  46. 		if (process.stdout.isTTY) {
  47. 			// Add a horizontal separator line between errors in case a terminal is used
  48. 			separator += chalk.grey.dim("\u2500".repeat(process.stdout.columns || 80));
  49. 		}
  50. 		separator += "\n\n";
  51. 		let message = chalk.red(`Invalid ui5.yaml configuration for project ${this.project.id}`) + "\n\n";
  52. 		message += this.errors.map((error) => {
  53. 			return this.formatError(error);
  54. 		}).join(separator);
  55. 		return message;
  56. 	}
  58. 	formatError(error) {
  59. 		let errorMessage = ValidationError.formatMessage(error);
  60. 		if (this.yaml && this.yaml.path && this.yaml.source) {
  61. 			const yamlExtract = ValidationError.getYamlExtract({error, yaml: this.yaml});
  62. 			const errorLines = errorMessage.split("\n");
  63. 			errorLines.splice(1, 0, "\n" + yamlExtract);
  64. 			errorMessage = errorLines.join("\n");
  65. 		}
  66. 		return errorMessage;
  67. 	}
  69. 	static formatMessage(error) {
  70. 		if (error.keyword === "errorMessage") {
  71. 			return error.message;
  72. 		}
  74. 		let message = "Configuration ";
  75. 		if (error.dataPath) {
  76. 			message += chalk.underline(chalk.red(error.dataPath.substr(1))) + " ";
  77. 		}
  79. 		switch (error.keyword) {
  80. 		case "additionalProperties":
  81. 			message += `property ${error.params.additionalProperty} must not be provided here`;
  82. 			break;
  83. 		case "type":
  84. 			message += `must be of type '${error.params.type}'`;
  85. 			break;
  86. 		case "required":
  87. 			message += `must have required property '${error.params.missingProperty}'`;
  88. 			break;
  89. 		case "enum":
  90. 			message += "must be equal to one of the allowed values\n";
  91. 			message += "Allowed values: " + error.params.allowedValues.join(", ");
  92. 			break;
  93. 		default:
  94. 			message += error.message;
  95. 		}
  97. 		return message;
  98. 	}
  100. 	static _findDuplicateError(error, errorIndex, errors) {
  101. 		const foundIndex = errors.findIndex(($) => {
  102. 			if ($.dataPath !== error.dataPath) {
  103. 				return false;
  104. 			} else if ($.keyword !== error.keyword) {
  105. 				return false;
  106. 			} else if (JSON.stringify($.params) !== JSON.stringify(error.params)) {
  107. 				return false;
  108. 			} else {
  109. 				return true;
  110. 			}
  111. 		});
  112. 		return foundIndex !== errorIndex;
  113. 	}
  115. 	static filterErrors(allErrors) {
  116. 		return allErrors.filter((error, i, errors) => {
  117. 			if (error.keyword === "if" || error.keyword === "oneOf") {
  118. 				return false;
  119. 			}
  121. 			return !ValidationError._findDuplicateError(error, i, errors);
  122. 		});
  123. 	}
  125. 	static analyzeYamlError({error, yaml}) {
  126. 		if (error.dataPath === "" && error.keyword === "required") {
  127. 			// There is no line/column for a missing required property on root level
  128. 			return {line: -1, column: -1};
  129. 		}
  131. 		// Skip leading /
  132. 		const objectPath = error.dataPath.substr(1).split("/");
  134. 		if (error.keyword === "additionalProperties") {
  135. 			objectPath.push(error.params.additionalProperty);
  136. 		}
  138. 		let currentSubstring;
  139. 		let currentIndex;
  140. 		if (yaml.documentIndex) {
  141. 			const matchDocumentSeparator = /^---/gm;
  142. 			let currentDocumentIndex = 0;
  143. 			let document;
  144. 			while ((document = matchDocumentSeparator.exec(yaml.source)) !== null) {
  145. 				// If the first separator is not at the beginning of the file
  146. 				// we are already at document index 1
  147. 				// Using String#trim() to remove any whitespace characters
  148. 				if (currentDocumentIndex === 0 && yaml.source.substring(0, document.index).trim().length > 0) {
  149. 					currentDocumentIndex = 1;
  150. 				}
  152. 				if (currentDocumentIndex === yaml.documentIndex) {
  153. 					currentIndex = document.index;
  154. 					currentSubstring = yaml.source.substring(currentIndex);
  155. 					break;
  156. 				}
  158. 				currentDocumentIndex++;
  159. 			}
  160. 			// Document could not be found
  161. 			if (!currentSubstring) {
  162. 				return {line: -1, column: -1};
  163. 			}
  164. 		} else {
  165. 			// In case of index 0 or no index, use whole source
  166. 			currentIndex = 0;
  167. 			currentSubstring = yaml.source;
  168. 		}
  170. 		const matchArrayElementIndentation = /([ ]*)-/;
  172. 		for (let i = 0; i < objectPath.length; i++) {
  173. 			const property = objectPath[i];
  174. 			let newIndex;
  176. 			if (isNaN(property)) {
  177. 				// Try to find a property
  179. 				// Creating a regular expression that matches the property name a line
  180. 				// except for comments, indicated by a hash sign "#".
  181. 				const propertyRegExp = new RegExp(`^[^#]*?${escapeStringRegExp(property)}`, "m");
  183. 				const propertyMatch = propertyRegExp.exec(currentSubstring);
  184. 				if (!propertyMatch) {
  185. 					return {line: -1, column: -1};
  186. 				}
  187. 				newIndex = propertyMatch.index + propertyMatch[0].length;
  188. 			} else {
  189. 				// Try to find the right index within an array definition.
  190. 				// This currently only works for arrays defined with "-" in multiple lines.
  191. 				// Arrays using square brackets are not supported.
  193. 				const matchArrayElement = /(^|\r?\n)([ ]*-[^\r\n]*)/g;
  194. 				const arrayIndex = parseInt(property);
  195. 				let a = 0;
  196. 				let firstIndentation = -1;
  197. 				let match;
  198. 				while ((match = matchArrayElement.exec(currentSubstring)) !== null) {
  199. 					const indentationMatch = match[2].match(matchArrayElementIndentation);
  200. 					if (!indentationMatch) {
  201. 						return {line: -1, column: -1};
  202. 					}
  203. 					const currentIndentation = indentationMatch[1].length;
  204. 					if (firstIndentation === -1) {
  205. 						firstIndentation = currentIndentation;
  206. 					} else if (currentIndentation !== firstIndentation) {
  207. 						continue;
  208. 					}
  209. 					if (a === arrayIndex) {
  210. 						// match[1] might be a line-break
  211. 						newIndex = match.index + match[1].length + currentIndentation;
  212. 						break;
  213. 					}
  214. 					a++;
  215. 				}
  216. 				if (!newIndex) {
  217. 					// Could not find array element
  218. 					return {line: -1, column: -1};
  219. 				}
  220. 			}
  221. 			currentIndex += newIndex;
  222. 			currentSubstring = yaml.source.substring(currentIndex);
  223. 		}
  225. 		const linesUntilMatch = yaml.source.substring(0, currentIndex).split(/\r?\n/);
  226. 		const line = linesUntilMatch.length;
  227. 		let column = linesUntilMatch[line - 1].length + 1;
  228. 		const lastPathSegment = objectPath[objectPath.length - 1];
  229. 		if (isNaN(lastPathSegment)) {
  230. 			column -= lastPathSegment.length;
  231. 		}
  233. 		return {
  234. 			line,
  235. 			column
  236. 		};
  237. 	}
  239. 	static getSourceExtract(yamlSource, line, column) {
  240. 		let source = "";
  241. 		const lines = yamlSource.split(/\r?\n/);
  243. 		// Using line numbers instead of array indices
  244. 		const startLine = Math.max(line - 2, 1);
  245. 		const endLine = Math.min(line, lines.length);
  246. 		const padLength = String(endLine).length;
  248. 		for (let currentLine = startLine; currentLine <= endLine; currentLine++) {
  249. 			const currentLineContent = lines[currentLine - 1];
  250. 			let string = chalk.gray(
  251. 				String(currentLine).padStart(padLength, " ") + ":"
  252. 			) + " " + currentLineContent + "\n";
  253. 			if (currentLine === line) {
  254. 				string = chalk.bgRed(string);
  255. 			}
  256. 			source += string;
  257. 		}
  259. 		source += " ".repeat(column + padLength + 1) + chalk.red("^");
  261. 		return source;
  262. 	}
  264. 	static getYamlExtract({error, yaml}) {
  265. 		const {line, column} = ValidationError.analyzeYamlError({error, yaml});
  266. 		if (line !== -1 && column !== -1) {
  267. 			return chalk.grey(yaml.path + ":" + line) +
  268. 				"\n\n" + ValidationError.getSourceExtract(yaml.source, line, column);
  269. 		} else {
  270. 			return chalk.grey(yaml.path) + "\n";
  271. 		}
  272. 	}
  273. }
  275. module.exports = ValidationError;