project/lib/validation/ValidationError.js

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