project/lib/projectPreprocessor.js

  1. const log = require("@ui5/logger").getLogger("normalizer:projectPreprocessor");
  2. const fs = require("graceful-fs");
  3. const path = require("path");
  4. const {promisify} = require("util");
  5. const readFile = promisify(fs.readFile);
  6. const jsyaml = require("js-yaml");
  7. const typeRepository = require("@ui5/builder").types.typeRepository;
  8. const {validate} = require("./validation/validator");
  10. class ProjectPreprocessor {
  11. 	constructor({tree}) {
  12. 		this.tree = tree;
  13. 		this.processedProjects = {};
  14. 		this.configShims = {};
  15. 		this.collections = {};
  16. 		this.appliedExtensions = {};
  17. 	}
  19. 	/*
  20. 		Adapt and enhance the project tree:
  21. 			- Replace duplicate projects further away from the root with those closer to the root
  22. 			- Add configuration to projects
  23. 	*/
  24. 	async processTree() {
  25. 		const queue = [{
  26. 			projects: [this.tree],
  27. 			parent: null,
  28. 			level: 0
  29. 		}];
  30. 		const configPromises = [];
  31. 		let startTime;
  32. 		if (log.isLevelEnabled("verbose")) {
  33. 			startTime = process.hrtime();
  34. 		}
  36. 		// Breadth-first search to prefer projects closer to root
  37. 		while (queue.length) {
  38. 			const {projects, parent, level} = queue.shift(); // Get and remove first entry from queue
  40. 			// Before processing all projects on a level concurrently, we need to set all of them as being processed.
  41. 			// This prevents transitive dependencies pointing to the same projects from being processed first
  42. 			//	 by the dependency lookahead
  43. 			const projectsToProcess = projects.filter((project) => {
  44. 				if (!project.id) {
  45. 					const parentRefText = parent ? `(child of ${parent.id})` : `(root project)`;
  46. 					throw new Error(`Encountered project with missing id ${parentRefText}`);
  47. 				}
  48. 				if (this.isBeingProcessed(parent, project)) {
  49. 					return false;
  50. 				}
  51. 				// Flag this project as being processed
  52. 				this.processedProjects[project.id] = {
  53. 					project,
  54. 					// If a project is referenced multiple times in the dependency tree it is replaced
  55. 					//	with the instance that is closest to the root.
  56. 					// Here we track the parents referencing that project
  57. 					parents: [parent]
  58. 				};
  59. 				return true;
  60. 			});
  62. 			await Promise.all(projectsToProcess.map(async (project) => {
  63. 				project._level = level;
  64. 				if (level === 0) {
  65. 					project._isRoot = true;
  66. 				}
  67. 				log.verbose(`Processing project ${project.id} on level ${project._level}...`);
  69. 				if (project.dependencies && project.dependencies.length) {
  70. 					// Do a dependency lookahead to apply any extensions that might affect this project
  71. 					await this.dependencyLookahead(project, project.dependencies);
  72. 				} else {
  73. 					// When using the static translator for instance, dependencies is not defined and will
  74. 					// fail later access calls to it
  75. 					project.dependencies = [];
  76. 				}
  78. 				const {extensions} = await this.loadProjectConfiguration(project);
  79. 				if (extensions && extensions.length) {
  80. 					// Project contains additional extensions
  81. 					// => apply them
  82. 					// TODO: Check whether extensions get applied twice in case depLookahead already processed them
  83. 					await Promise.all(extensions.map((extProject) => {
  84. 						return this.applyExtension(extProject);
  85. 					}));
  86. 				}
  87. 				await this.applyShims(project);
  88. 				if (this.isConfigValid(project)) {
  89. 					// Do not apply transparent projects.
  90. 					// Their only purpose might be to have their dependencies processed
  91. 					if (!project._transparentProject) {
  92. 						await this.applyType(project);
  93. 						this.checkProjectMetadata(parent, project);
  94. 					}
  95. 					queue.push({
  96. 						// copy array, so that the queue is stable while ignored project dependencies are removed
  97. 						projects: [...project.dependencies],
  98. 						parent: project,
  99. 						level: level + 1
  100. 					});
  101. 				} else {
  102. 					if (project === this.tree) {
  103. 						throw new Error(
  104. 							`Failed to configure root project "${project.id}". Please check verbose log for details.`);
  105. 					}
  106. 					// No config available
  107. 					// => reject this project by removing it from its parents list of dependencies
  108. 					log.verbose(`Ignoring project ${project.id} with missing configuration ` +
  109. 						"(might be a non-UI5 dependency)");
  111. 					const parents = this.processedProjects[project.id].parents;
  112. 					for (let i = parents.length - 1; i >= 0; i--) {
  113. 						parents[i].dependencies.splice(parents[i].dependencies.indexOf(project), 1);
  114. 					}
  115. 					this.processedProjects[project.id] = {ignored: true};
  116. 				}
  117. 			}));
  118. 		}
  119. 		return Promise.all(configPromises).then(() => {
  120. 			if (log.isLevelEnabled("verbose")) {
  121. 				const prettyHrtime = require("pretty-hrtime");
  122. 				const timeDiff = process.hrtime(startTime);
  123. 				log.verbose(
  124. 					`Processed ${Object.keys(this.processedProjects).length} projects in ${prettyHrtime(timeDiff)}`);
  125. 			}
  126. 			return this.tree;
  127. 		});
  128. 	}
  130. 	async dependencyLookahead(parent, dependencies) {
  131. 		return Promise.all(dependencies.map(async (project) => {
  132. 			if (this.isBeingProcessed(parent, project)) {
  133. 				return;
  134. 			}
  135. 			log.verbose(`Processing dependency lookahead for ${parent.id}: ${project.id}`);
  136. 			// Temporarily flag project as being processed
  137. 			this.processedProjects[project.id] = {
  138. 				project,
  139. 				parents: [parent]
  140. 			};
  141. 			const {extensions} = await this.loadProjectConfiguration(project);
  142. 			if (extensions && extensions.length) {
  143. 				// Project contains additional extensions
  144. 				// => apply them
  145. 				await Promise.all(extensions.map((extProject) => {
  146. 					return this.applyExtension(extProject);
  147. 				}));
  148. 			}
  150. 			if (project.kind === "extension") {
  151. 				// Not a project but an extension
  152. 				// => remove it as from any known projects that depend on it
  153. 				const parents = this.processedProjects[project.id].parents;
  154. 				for (let i = parents.length - 1; i >= 0; i--) {
  155. 					parents[i].dependencies.splice(parents[i].dependencies.indexOf(project), 1);
  156. 				}
  157. 				// Also ignore it from further processing by other projects depending on it
  158. 				this.processedProjects[project.id] = {ignored: true};
  160. 				if (this.isConfigValid(project)) {
  161. 					// Finally apply the extension
  162. 					await this.applyExtension(project);
  163. 				} else {
  164. 					log.verbose(`Ignoring extension ${project.id} with missing configuration`);
  165. 				}
  166. 			} else {
  167. 				// Project is not an extension: Reset processing status of lookahead to allow the real processing
  168. 				this.processedProjects[project.id] = null;
  169. 			}
  170. 		}));
  171. 	}
  173. 	isBeingProcessed(parent, project) { // Check whether a project is currently being or has already been processed
  174. 		const processedProject = this.processedProjects[project.id];
  175. 		if (project.deduped) {
  176. 			// Ignore deduped modules
  177. 			return true;
  178. 		}
  179. 		if (processedProject) {
  180. 			if (processedProject.ignored) {
  181. 				log.verbose(`Dependency of project ${parent.id}, "${project.id}" is flagged as ignored.`);
  182. 				if (parent.dependencies.includes(project)) {
  183. 					parent.dependencies.splice(parent.dependencies.indexOf(project), 1);
  184. 				}
  185. 				return true;
  186. 			}
  187. 			log.verbose(
  188. 				`Dependency of project ${parent.id}, "${project.id}": ` +
  189. 				`Distance to root of ${parent._level + 1}. Will be replaced `+
  190. 				`by project with same ID and distance to root of ${processedProject.project._level}.`);
  192. 			// Replace with the already processed project (closer to root -> preferred)
  193. 			parent.dependencies[parent.dependencies.indexOf(project)] = processedProject.project;
  194. 			processedProject.parents.push(parent);
  196. 			// No further processing needed
  197. 			return true;
  198. 		}
  199. 		return false;
  200. 	}
  202. 	async loadProjectConfiguration(project) {
  203. 		if (project.specVersion) { // Project might already be configured
  204. 			// Currently, specVersion is the indicator for configured projects
  206. 			if (project._transparentProject) {
  207. 				// Assume that project is already processed
  208. 				return {};
  209. 			}
  211. 			await this.validateAndNormalizeExistingProject(project);
  213. 			return {};
  214. 		}
  216. 		const configs = await this.readConfigFile(project);
  218. 		if (!configs || !configs.length) {
  219. 			return {};
  220. 		}
  222. 		for (let i = configs.length - 1; i >= 0; i--) {
  223. 			this.normalizeConfig(configs[i]);
  224. 		}
  226. 		const projectConfigs = configs.filter((config) => {
  227. 			return config.kind === "project";
  228. 		});
  230. 		const extensionConfigs = configs.filter((config) => {
  231. 			return config.kind === "extension";
  232. 		});
  234. 		const projectClone = JSON.parse(JSON.stringify(project));
  236. 		// While a project can contain multiple configurations,
  237. 		//	from a dependency tree perspective it is always a single project
  238. 		// This means it can represent one "project", plus multiple extensions or
  239. 		//	one extension, plus multiple extensions
  241. 		if (projectConfigs.length === 1) {
  242. 			// All well, this is the one. Merge config into project
  243. 			Object.assign(project, projectConfigs[0]);
  244. 		} else if (projectConfigs.length > 1) {
  245. 			throw new Error(`Found ${projectConfigs.length} configurations of kind 'project' for ` +
  246. 								`project ${project.id}. There is only one project per configuration allowed.`);
  247. 		} else if (projectConfigs.length === 0 && extensionConfigs.length) {
  248. 			// No project, but extensions
  249. 			// => choose one to represent the project -> the first one
  250. 			Object.assign(project, extensionConfigs.shift());
  251. 		} else {
  252. 			throw new Error(`Found ${configs.length} configurations for ` +
  253. 								`project ${project.id}. None are of valid kind.`);
  254. 		}
  256. 		const extensionProjects = extensionConfigs.map((config) => {
  257. 			// Clone original project
  258. 			const configuredProject = JSON.parse(JSON.stringify(projectClone));
  260. 			// Enhance project with its configuration
  261. 			Object.assign(configuredProject, config);
  262. 			return configuredProject;
  263. 		});
  265. 		return {extensions: extensionProjects};
  266. 	}
  268. 	normalizeConfig(config) {
  269. 		if (!config.kind) {
  270. 			config.kind = "project"; // default
  271. 		}
  272. 	}
  274. 	isConfigValid(project) {
  275. 		if (!project.specVersion) {
  276. 			if (project._isRoot) {
  277. 				throw new Error(`No specification version defined for root project ${project.id}`);
  278. 			}
  279. 			log.verbose(`No specification version defined for project ${project.id}`);
  280. 			return false; // ignore this project
  281. 		}
  283. 		if (project.specVersion !== "0.1" && project.specVersion !== "1.0" &&
  284. 			project.specVersion !== "1.1" && project.specVersion !== "2.0" &&
  285. 			project.specVersion !== "2.1" && project.specVersion !== "2.2" &&
  286. 			project.specVersion !== "2.3" && project.specVersion !== "2.4" &&
  287. 			project.specVersion !== "2.5" && project.specVersion !== "2.6") {
  288. 			throw new Error(
  289. 				`Unsupported specification version ${project.specVersion} defined for project ` +
  290. 				`${project.id}. Your UI5 CLI installation might be outdated. ` +
  291. 				`For details see https://sap.github.io/ui5-tooling/pages/Configuration/#specification-versions`);
  292. 		}
  294. 		if (!project.type) {
  295. 			if (project._isRoot) {
  296. 				throw new Error(`No type configured for root project ${project.id}`);
  297. 			}
  298. 			log.verbose(`No type configured for project ${project.id}`);
  299. 			return false; // ignore this project
  300. 		}
  302. 		if (project.kind !== "project" && project._isRoot) {
  303. 			// This is arguable. It is not the concern of ui5-project to define the entry point of a project tree
  304. 			// On the other hand, there is no known use case for anything else right now and failing early here
  305. 			//	makes sense in that regard
  306. 			throw new Error(`Root project needs to be of kind "project". ${project.id} is of kind ${project.kind}`);
  307. 		}
  309. 		if (project.kind === "project" && project.type === "application") {
  310. 			// There must be exactly one application project per dependency tree
  311. 			// If multiple are found, all but the one closest to the root are rejected (ignored)
  312. 			// If there are two projects equally close to the root, an error is being thrown
  313. 			if (!this.qualifiedApplicationProject) {
  314. 				this.qualifiedApplicationProject = project;
  315. 			} else if (this.qualifiedApplicationProject._level === project._level) {
  316. 				throw new Error(`Found at least two projects ${this.qualifiedApplicationProject.id} and ` +
  317. 					`${project.id} of type application with the same distance to the root project. ` +
  318. 					"Only one project of type application can be used. Failed to decide which one to ignore.");
  319. 			} else {
  320. 				return false; // ignore this project
  321. 			}
  322. 		}
  324. 		return true;
  325. 	}
  327. 	async applyType(project) {
  328. 		let type;
  329. 		try {
  330. 			type = typeRepository.getType(project.type);
  331. 		} catch (err) {
  332. 			throw new Error(`Failed to retrieve type for project ${project.id}: ${err.message}`);
  333. 		}
  334. 		await type.format(project);
  335. 	}
  337. 	checkProjectMetadata(parent, project) {
  338. 		if (project.metadata.deprecated && parent && parent._isRoot) {
  339. 			// Only warn for direct dependencies of the root project
  340. 			log.warn(`Dependency ${project.metadata.name} is deprecated and should not be used for new projects!`);
  341. 		}
  343. 		if (project.metadata.sapInternal && parent && parent._isRoot && !parent.metadata.allowSapInternal) {
  344. 			// Only warn for direct dependencies of the root project, except it defines "allowSapInternal"
  345. 			log.warn(`Dependency ${project.metadata.name} is restricted for use by SAP internal projects only! ` +
  346. 				`If the project ${parent.metadata.name} is an SAP internal project, add the attribute ` +
  347. 				`"allowSapInternal: true" to its metadata configuration`);
  348. 		}
  349. 	}
  351. 	async applyExtension(extension) {
  352. 		if (!extension.metadata || !extension.metadata.name) {
  353. 			throw new Error(`metadata.name configuration is missing for extension ${extension.id}`);
  354. 		}
  355. 		log.verbose(`Applying extension ${extension.metadata.name}...`);
  357. 		if (!extension.specVersion) {
  358. 			throw new Error(`No specification version defined for extension ${extension.metadata.name}`);
  359. 		} else if (extension.specVersion !== "0.1" &&
  360. 				extension.specVersion !== "1.0" &&
  361. 				extension.specVersion !== "1.1" &&
  362. 				extension.specVersion !== "2.0" &&
  363. 				extension.specVersion !== "2.1" &&
  364. 				extension.specVersion !== "2.2" &&
  365. 				extension.specVersion !== "2.3" &&
  366. 				extension.specVersion !== "2.4" &&
  367. 				extension.specVersion !== "2.5" &&
  368. 				extension.specVersion !== "2.6") {
  369. 			throw new Error(
  370. 				`Unsupported specification version ${extension.specVersion} defined for extension ` +
  371. 				`${extension.metadata.name}. Your UI5 CLI installation might be outdated. ` +
  372. 				`For details see https://sap.github.io/ui5-tooling/pages/Configuration/#specification-versions`);
  373. 		} else if (this.appliedExtensions[extension.metadata.name]) {
  374. 			log.verbose(`Extension with the name ${extension.metadata.name} has already been applied. ` +
  375. 				"This might have been done during dependency lookahead.");
  376. 			log.verbose(`Already applied extension ID: ${this.appliedExtensions[extension.metadata.name].id}. ` +
  377. 				`New extension ID: ${extension.id}`);
  378. 			return;
  379. 		}
  380. 		this.appliedExtensions[extension.metadata.name] = extension;
  382. 		switch (extension.type) {
  383. 		case "project-shim":
  384. 			this.handleShim(extension);
  385. 			break;
  386. 		case "task":
  387. 			this.handleTask(extension);
  388. 			break;
  389. 		case "server-middleware":
  390. 			this.handleServerMiddleware(extension);
  391. 			break;
  392. 		default:
  393. 			throw new Error(`Unknown extension type '${extension.type}' for ${extension.id}`);
  394. 		}
  395. 	}
  397. 	async readConfigFile(project) {
  398. 		// A projects configPath property takes precedence over the default "<projectPath>/ui5.yaml" path
  399. 		const configPath = project.configPath || path.join(project.path, "ui5.yaml");
  400. 		let configFile;
  401. 		try {
  402. 			configFile = await readFile(configPath, {encoding: "utf8"});
  403. 		} catch (err) {
  404. 			const errorText = "Failed to read configuration for project " +
  405. 					`${project.id} at "${configPath}". Error: ${err.message}`;
  407. 			// Something else than "File or directory does not exist" or root project
  408. 			if (err.code !== "ENOENT" || project._isRoot) {
  409. 				throw new Error(errorText);
  410. 			} else {
  411. 				log.verbose(errorText);
  412. 				return null;
  413. 			}
  414. 		}
  416. 		let configs;
  418. 		try {
  419. 			configs = jsyaml.loadAll(configFile, undefined, {
  420. 				filename: configPath
  421. 			});
  422. 		} catch (err) {
  423. 			if (err.name === "YAMLException") {
  424. 				throw new Error("Failed to parse configuration for project " +
  425. 				`${project.id} at "${configPath}"\nError: ${err.message}`);
  426. 			} else {
  427. 				throw err;
  428. 			}
  429. 		}
  431. 		if (!configs || !configs.length) {
  432. 			return configs;
  433. 		}
  435. 		const validationResults = await Promise.all(
  436. 			configs.map(async (config, documentIndex) => {
  437. 				// Catch validation errors to ensure proper order of rejections within Promise.all
  438. 				try {
  439. 					await validate({
  440. 						config,
  441. 						project: {
  442. 							id: project.id
  443. 						},
  444. 						yaml: {
  445. 							path: configPath,
  446. 							source: configFile,
  447. 							documentIndex
  448. 						}
  449. 					});
  450. 				} catch (error) {
  451. 					return error;
  452. 				}
  453. 			})
  454. 		);
  456. 		const validationErrors = validationResults.filter(($) => $);
  458. 		if (validationErrors.length > 0) {
  459. 			// For now just throw the error of the first invalid document
  460. 			throw validationErrors[0];
  461. 		}
  463. 		return configs;
  464. 	}
  466. 	handleShim(extension) {
  467. 		if (!extension.shims) {
  468. 			throw new Error(`Project shim extension ${extension.id} is missing 'shims' configuration`);
  469. 		}
  470. 		const {configurations, dependencies, collections} = extension.shims;
  472. 		if (configurations) {
  473. 			log.verbose(`Project shim ${extension.id} contains ` +
  474. 				`${Object.keys(configurations)} configuration(s)`);
  475. 			for (const projectId of Object.keys(configurations)) {
  476. 				this.normalizeConfig(configurations[projectId]); // TODO: Clone object beforehand?
  477. 				if (this.configShims[projectId]) {
  478. 					log.verbose(`Project shim ${extension.id}: A configuration shim for project ${projectId} `+
  479. 							"has already been applied. Skipping.");
  480. 				} else if (this.isConfigValid(configurations[projectId])) {
  481. 					log.verbose(`Project shim ${extension.id}: Adding project configuration for ${projectId}...`);
  482. 					this.configShims[projectId] = configurations[projectId];
  483. 				} else {
  484. 					log.verbose(`Project shim ${extension.id}: Ignoring invalid ` +
  485. 							`configuration shim for project ${projectId}`);
  486. 				}
  487. 			}
  488. 		}
  490. 		if (dependencies) {
  491. 			// For the time being, shimmed dependencies only apply to shimmed project configurations
  492. 			for (const projectId of Object.keys(dependencies)) {
  493. 				if (this.configShims[projectId]) {
  494. 					log.verbose(`Project shim ${extension.id}: Adding dependencies ` +
  495. 							`to project shim '${projectId}'...`);
  496. 					this.configShims[projectId].dependencies = dependencies[projectId];
  497. 				} else {
  498. 					log.verbose(`Project shim ${extension.id}: No configuration shim found for ` +
  499. 							`project ID '${projectId}'. Dependency shims currently only apply ` +
  500. 							"to projects with configuration shims.");
  501. 				}
  502. 			}
  503. 		}
  505. 		if (collections) {
  506. 			log.verbose(`Project shim ${extension.id} contains ` +
  507. 				`${Object.keys(collections).length} collection(s)`);
  508. 			for (const projectId of Object.keys(collections)) {
  509. 				if (this.collections[projectId]) {
  510. 					log.verbose(`Project shim ${extension.id}: A collection with id '${projectId}' `+
  511. 							"is already known. Skipping.");
  512. 				} else {
  513. 					log.verbose(`Project shim ${extension.id}: Adding collection with id '${projectId}'...`);
  514. 					this.collections[projectId] = collections[projectId];
  515. 				}
  516. 			}
  517. 		}
  518. 	}
  520. 	async applyShims(project) {
  521. 		const configShim = this.configShims[project.id];
  522. 		// Apply configuration shims
  523. 		if (configShim) {
  524. 			log.verbose(`Applying configuration shim for project ${project.id}...`);
  526. 			if (configShim.dependencies && configShim.dependencies.length) {
  527. 				if (!configShim.shimDependenciesResolved) {
  528. 					configShim.dependencies = configShim.dependencies.map((depId) => {
  529. 						const depProject = this.processedProjects[depId].project;
  530. 						if (!depProject) {
  531. 							throw new Error(
  532. 								`Failed to resolve shimmed dependency '${depId}' for project ${project.id}. ` +
  533. 								`Is a dependency with ID '${depId}' part of the dependency tree?`);
  534. 						}
  535. 						return depProject;
  536. 					});
  537. 					configShim.shimDependenciesResolved = true;
  538. 				}
  539. 				configShim.dependencies.forEach((depProject) => {
  540. 					const parents = this.processedProjects[depProject.id].parents;
  541. 					if (parents.indexOf(project) === -1) {
  542. 						parents.push(project);
  543. 					} else {
  544. 						log.verbose(`Project ${project.id} is already parent of shimmed dependency ${depProject.id}`);
  545. 					}
  546. 				});
  547. 			}
  549. 			Object.assign(project, configShim);
  550. 			delete project.shimDependenciesResolved; // Remove shim processing metadata from project
  552. 			await this.validateAndNormalizeExistingProject(project);
  553. 		}
  555. 		// Apply collections
  556. 		for (let i = project.dependencies.length - 1; i >= 0; i--) {
  557. 			const depId = project.dependencies[i].id;
  558. 			if (this.collections[depId]) {
  559. 				log.verbose(`Project ${project.id} depends on collection ${depId}. Resolving...`);
  560. 				// This project depends on a collection
  561. 				// => replace collection dependency with first collection project.
  562. 				const collectionDep = project.dependencies[i];
  563. 				const collectionModules = this.collections[depId].modules;
  564. 				const projects = [];
  565. 				for (const projectId of Object.keys(collectionModules)) {
  566. 					// Clone and modify collection "project"
  567. 					const project = JSON.parse(JSON.stringify(collectionDep));
  568. 					project.id = projectId;
  569. 					project.path = path.join(project.path, collectionModules[projectId]);
  570. 					projects.push(project);
  571. 				}
  573. 				// Use first collection project to replace the collection dependency
  574. 				project.dependencies[i] = projects.shift();
  575. 				// Add any additional collection projects to end of dependency array (already processed)
  576. 				project.dependencies.push(...projects);
  577. 			}
  578. 		}
  579. 	}
  581. 	handleTask(extension) {
  582. 		if (!extension.metadata && !extension.metadata.name) {
  583. 			throw new Error(`Task extension ${extension.id} is missing 'metadata.name' configuration`);
  584. 		}
  585. 		if (!extension.task) {
  586. 			throw new Error(`Task extension ${extension.id} is missing 'task' configuration`);
  587. 		}
  588. 		const taskRepository = require("@ui5/builder").tasks.taskRepository;
  590. 		const taskPath = path.join(extension.path, extension.task.path);
  592. 		taskRepository.addTask({
  593. 			name: extension.metadata.name,
  594. 			specVersion: extension.specVersion,
  595. 			taskPath,
  596. 		});
  597. 	}
  599. 	handleServerMiddleware(extension) {
  600. 		if (!extension.metadata && !extension.metadata.name) {
  601. 			throw new Error(`Middleware extension ${extension.id} is missing 'metadata.name' configuration`);
  602. 		}
  603. 		if (!extension.middleware) {
  604. 			throw new Error(`Middleware extension ${extension.id} is missing 'middleware' configuration`);
  605. 		}
  606. 		const {middlewareRepository} = require("@ui5/server");
  608. 		const middlewarePath = path.join(extension.path, extension.middleware.path);
  609. 		middlewareRepository.addMiddleware({
  610. 			name: extension.metadata.name,
  611. 			specVersion: extension.specVersion,
  612. 			middlewarePath
  613. 		});
  614. 	}
  616. 	async validateAndNormalizeExistingProject(project) {
  617. 		// Validate project config, but exclude additional properties
  618. 		const excludedProperties = [
  619. 			"id",
  620. 			"version",
  621. 			"path",
  622. 			"dependencies",
  623. 			"_level",
  624. 			"_isRoot"
  625. 		];
  626. 		const config = {};
  627. 		for (const key of Object.keys(project)) {
  628. 			if (!excludedProperties.includes(key)) {
  629. 				config[key] = project[key];
  630. 			}
  631. 		}
  632. 		await validate({
  633. 			config,
  634. 			project: {
  635. 				id: project.id
  636. 			}
  637. 		});
  639. 		this.normalizeConfig(project);
  640. 	}
  641. }
  643. /**
  644.  * The Project Preprocessor enriches the dependency information with project configuration
  645.  *
  646.  * @public
  647.  * @namespace
  648.  * @alias module:@ui5/project.projectPreprocessor
  649.  */
  650. module.exports = {
  651. 	/**
  652. 	 * Collects project information and its dependencies to enrich it with project configuration
  653. 	 *
  654. 	 * @public
  655. 	 * @param {object} tree Dependency tree of the project
  656. 	 * @returns {Promise<object>} Promise resolving with the dependency tree and enriched project configuration
  657. 	 */
  658. 	processTree: function(tree) {
  659. 		return new ProjectPreprocessor({tree}).processTree();
  660. 	},
  661. 	_ProjectPreprocessor: ProjectPreprocessor
  662. };