project/lib/graph/Workspace.js

  1. import fs from "graceful-fs";
  2. import {globby, isDynamicPattern} from "globby";
  3. import path from "node:path";
  4. import {promisify} from "node:util";
  5. import {getLogger} from "@ui5/logger";
  6. import Module from "./Module.js";
  7. import {validateWorkspace} from "../validation/validator.js";
  9. const readFile = promisify(fs.readFile);
  10. const log = getLogger("graph:Workspace");
  13. /**
  14.  * Workspace configuration. For details, refer to the
  15.  * [UI5 Workspaces documentation]{@link https://sap.github.io/ui5-tooling/v3/pages/Workspace/#configuration}
  16.  *
  17.  * @public
  18.  * @typedef {object} @ui5/project/graph/Workspace~Configuration
  19.  * @property {string} node.specVersion Workspace Specification Version
  20.  * @property {object} node.metadata
  21.  * @property {string} node.metadata.name Name of the workspace configuration
  22.  * @property {object} node.dependencyManagement
  23.  * @property {@ui5/project/graph/Workspace~DependencyManagementResolutions[]} node.dependencyManagement.resolutions
  24.  */
  26. /**
  27.  * A resolution entry for the dependency management section of the workspace configuration
  28.  *
  29.  * @public
  30.  * @typedef {object} @ui5/project/graph/Workspace~DependencyManagementResolution
  31.  * @property {string} path Relative path to use for the workspace resolution process
  32.  */
  34. /**
  35.  * UI5 Workspace
  36.  *
  37.  * @public
  38.  * @class
  39.  * @alias @ui5/project/graph/Workspace
  40.  */
  41. class Workspace {
  42. 	#visitedNodePaths = new Set();
  43. 	#configValidated = false;
  44. 	#configuration;
  45. 	#cwd;
  47. 	/**
  48. 	 * @public
  49. 	 * @param {object} options
  50. 	 * @param {string} options.cwd Path to use for resolving all paths of the workspace configuration from.
  51. 	 *   This should contain platform-specific path separators (i.e. must not be POSIX on non-POSIX systems)
  52. 	 * @param {@ui5/project/graph/Workspace~Configuration} options.configuration
  53. 	 *   Workspace configuration
  54. 	 */
  55. 	constructor({cwd, configuration}) {
  56. 		if (!cwd) {
  57. 			throw new Error(`Could not create Workspace: Missing or empty parameter 'cwd'`);
  58. 		}
  59. 		if (!configuration) {
  60. 			throw new Error(`Could not create Workspace: Missing or empty parameter 'configuration'`);
  61. 		}
  63. 		this.#cwd = cwd;
  64. 		this.#configuration = configuration;
  65. 	}
  67. 	/**
  68. 	 * Get the name of this workspace
  69. 	 *
  70. 	 * @public
  71. 	 * @returns {string} Name of this workspace configuration
  72. 	 */
  73. 	getName() {
  74. 		return this.#configuration.metadata.name;
  75. 	}
  77. 	/**
  78. 	 * Returns an array of [Module]{@ui5/project/graph/Module} instances found in the configured
  79. 	 * dependency-management resolution paths of this workspace, sorted by module ID.
  80. 	 *
  81. 	 * @public
  82. 	 * @returns {Promise<@ui5/project/graph/Module[]>}
  83. 	 *   Array of Module instances sorted by module ID
  84. 	 */
  85. 	async getModules() {
  86. 		const {moduleIdMap} = await this._getResolvedModules();
  87. 		const sortedMap = new Map([...moduleIdMap].sort((a, b) => String(a[0]).localeCompare(b[0])));
  88. 		return Array.from(sortedMap.values());
  89. 	}
  91. 	/**
  92. 	 * For a given project name (e.g. the value of the <code>metadata.name</code> property in a ui5.yaml),
  93. 	 * returns a [Module]{@ui5/project/graph/Module} instance or <code>undefined</code> depending on whether the project
  94. 	 * has been found in the configured dependency-management resolution paths of this workspace
  95. 	 *
  96. 	 * @public
  97. 	 * @param {string} projectName Name of the project
  98. 	 * @returns {Promise<@ui5/project/graph/Module|undefined>}
  99. 	 *   Module instance, or <code>undefined</code> if none is found
  100. 	 */
  101. 	async getModuleByProjectName(projectName) {
  102. 		const {projectNameMap} = await this._getResolvedModules();
  103. 		return projectNameMap.get(projectName);
  104. 	}
  106. 	/**
  107. 	 * For a given node id (e.g. the value of the name property in a package.json),
  108. 	 * returns a [Module]{@ui5/project/graph/Module} instance or <code>undefined</code> depending on whether the module
  109. 	 * has been found in the configured dependency-management resolution paths of this workspace
  110. 	 * and contains at least one project or extension
  111. 	 *
  112. 	 * @public
  113. 	 * @param {string} nodeId Node ID of the module
  114. 	 * @returns {Promise<@ui5/project/graph/Module|undefined>}
  115. 	 *   Module instance, or <code>undefined</code> if none is found
  116. 	 */
  117. 	async getModuleByNodeId(nodeId) {
  118. 		const {moduleIdMap} = await this._getResolvedModules();
  119. 		return moduleIdMap.get(nodeId);
  120. 	}
  122. 	_getResolvedModules() {
  123. 		if (this._pResolvedModules) {
  124. 			return this._pResolvedModules;
  125. 		}
  127. 		return this._pResolvedModules = this._resolveModules();
  128. 	}
  130. 	async _resolveModules() {
  131. 		await this._validateConfig();
  132. 		const resolutions = this.#configuration.dependencyManagement?.resolutions;
  133. 		if (!resolutions?.length) {
  134. 			return {
  135. 				projectNameMap: new Map(),
  136. 				moduleIdMap: new Map()
  137. 			};
  138. 		}
  140. 		let resolvedModules = await Promise.all(resolutions.map(async (resolutionConfig) => {
  141. 			if (!resolutionConfig.path) {
  142. 				throw new Error(
  143. 					`Missing property 'path' in dependency resolution configuration of workspace ${this.getName()}`);
  144. 			}
  145. 			return await this._getModulesFromPath(
  146. 				this.#cwd, resolutionConfig.path);
  147. 		}));
  149. 		// Flatten array since package-workspaces might have resolved to multiple modules for a single resolution
  150. 		resolvedModules = Array.prototype.concat.apply([], resolvedModules);
  152. 		const projectNameMap = new Map();
  153. 		const moduleIdMap = new Map();
  154. 		await Promise.all(resolvedModules.map(async (module) => {
  155. 			const {project, extensions} = await module.getSpecifications();
  156. 			if (project || extensions.length) {
  157. 				moduleIdMap.set(module.getId(), module);
  158. 			} else {
  159. 				log.warn(
  160. 					`Failed to create a project or extensions from module ${module.getId()} at ${module.getPath()}`);
  161. 			}
  162. 			if (project) {
  163. 				projectNameMap.set(project.getName(), module);
  164. 				log.verbose(`Module ${module.getId()} contains project ${project.getName()}`);
  165. 			}
  166. 			if (extensions.length) {
  167. 				const extensionNames = extensions.map((e) => e.getName()).join(", ");
  168. 				log.verbose(`Module ${module.getId()} contains extensions: ${extensionNames}`);
  169. 			}
  170. 		}));
  171. 		return {
  172. 			projectNameMap,
  173. 			moduleIdMap
  174. 		};
  175. 	}
  177. 	async _getModulesFromPath(cwd, relPath, failOnMissingFiles = true) {
  178. 		const nodePath = path.join(cwd, relPath);
  179. 		if (this.#visitedNodePaths.has(nodePath)) {
  180. 			log.verbose(`Module located at ${nodePath} has already been visited`);
  181. 			return [];
  182. 		}
  183. 		this.#visitedNodePaths.add(nodePath);
  184. 		let pkg;
  185. 		try {
  186. 			pkg = await this._readPackageJson(nodePath);
  187. 			if (!pkg?.name || !pkg?.version) {
  188. 				throw new Error(
  189. 					`package.json must contain fields 'name' and 'version'`);
  190. 			}
  191. 		} catch (err) {
  192. 			if (!failOnMissingFiles && err.code === "ENOENT") {
  193. 				// When resolving a dynamic workspace pattern (not a static path), ignore modules that
  194. 				// are missing a package.json (this might simply indicate an empty directory)
  195. 				log.verbose(`Ignoring module at path ${nodePath}: Directory does not contain a package.json`);
  196. 				return [];
  197. 			}
  198. 			throw new Error(
  199. 				`Failed to resolve workspace dependency resolution path ${relPath} to ${nodePath}: ${err.message}`);
  200. 		}
  202. 		// If the package.json defines an npm "workspaces", or an equivalent "ui5.workspaces" configuration,
  203. 		// resolve the workspace and only use the resulting modules. The root package is ignored.
  204. 		const packageWorkspaceConfig = pkg.ui5?.workspaces || pkg.workspaces;
  205. 		if (packageWorkspaceConfig?.length) {
  206. 			log.verbose(`Module ${pkg.name} provides a package.json workspaces configuration. ` +
  207. 				`Ignoring the module and resolving workspaces instead...`);
  208. 			const staticPatterns = [];
  209. 			// Split provided patterns into dynamic and static patterns
  210. 			// This is necessary, since fast-glob currently behaves different from
  211. 			// 	"glob" (used by @npmcli/map-workspaces) in that it does not match the
  212. 			// 	base directory in case it is equal to the pattern (https://github.com/mrmlnc/fast-glob/issues/47)
  213. 			// For example a pattern "package-a" would not match a directory called
  214. 			// 	"package-a" in the root directory of the project.
  215. 			// 	We therefore detect the static pattern and resolve it directly
  216. 			const dynamicPatterns = packageWorkspaceConfig.filter((pattern) => {
  217. 				if (isDynamicPattern(pattern)) {
  218. 					return true;
  219. 				} else {
  220. 					staticPatterns.push(pattern);
  221. 					return false;
  222. 				}
  223. 			});
  225. 			let searchPaths = [];
  226. 			if (dynamicPatterns.length) {
  227. 				searchPaths = await globby(dynamicPatterns, {
  228. 					cwd: nodePath,
  229. 					followSymbolicLinks: false,
  230. 					onlyDirectories: true,
  231. 				});
  232. 			}
  233. 			searchPaths.push(...staticPatterns);
  235. 			const resolvedModules = new Map();
  236. 			await Promise.all(searchPaths.map(async (pkgPath) => {
  237. 				const modules = await this._getModulesFromPath(nodePath, pkgPath, staticPatterns.includes(pkgPath));
  238. 				modules.forEach((module) => {
  239. 					const id = module.getId();
  240. 					if (!resolvedModules.get(id)) {
  241. 						resolvedModules.set(id, module);
  242. 					}
  243. 				});
  244. 			}));
  245. 			return Array.from(resolvedModules.values());
  246. 		} else {
  247. 			return [new Module({
  248. 				id: pkg.name,
  249. 				version: pkg.version,
  250. 				modulePath: nodePath
  251. 			})];
  252. 		}
  253. 	}
  255. 	/**
  256. 	 * Reads the package.json file and returns its content
  257. 	 *
  258. 	 * @private
  259. 	 * @param {string} modulePath Path to the module containing the package.json
  260. 	 * @returns {object} Package json content
  261. 	 */
  262. 	async _readPackageJson(modulePath) {
  263. 		const content = await readFile(path.join(modulePath, "package.json"), "utf8");
  264. 		return JSON.parse(content);
  265. 	}
  267. 	async _validateConfig() {
  268. 		if (this.#configValidated) {
  269. 			return;
  270. 		}
  271. 		await validateWorkspace({
  272. 			config: this.#configuration
  273. 		});
  274. 		this.#configValidated = true;
  275. 	}
  276. }
  278. export default Workspace;