project/lib/specifications/ComponentProject.js

  1. import {promisify} from "node:util";
  2. import Project from "./Project.js";
  3. import * as resourceFactory from "@ui5/fs/resourceFactory";
  5. /**
  6.  * Subclass for projects potentially containing Components
  7.  *
  8.  * @public
  9.  * @abstract
  10.  * @class
  11.  * @alias @ui5/project/specifications/ComponentProject
  12.  * @extends @ui5/project/specifications/Project
  13.  * @hideconstructor
  14.  */
  15. class ComponentProject extends Project {
  16. 	constructor(parameters) {
  17. 		super(parameters);
  18. 		if (new.target === ComponentProject) {
  19. 			throw new TypeError("Class 'ComponentProject' is abstract. Please use one of the 'types' subclasses");
  20. 		}
  22. 		this._pPom = null;
  23. 		this._namespace = null;
  24. 		this._isRuntimeNamespaced = true;
  25. 	}
  27. 	/* === Attributes === */
  28. 	/**
  29. 	 * Get the project namespace
  30. 	 *
  31. 	 * @public
  32. 	 * @returns {string} Project namespace in slash notation (e.g. <code>my/project/name</code>)
  33. 	 */
  34. 	getNamespace() {
  35. 		return this._namespace;
  36. 	}
  38. 	/**
  39. 	* @private
  40. 	*/
  41. 	getCopyright() {
  42. 		return this._config.metadata.copyright;
  43. 	}
  45. 	/**
  46. 	* @private
  47. 	*/
  48. 	getComponentPreloadPaths() {
  49. 		return this._config.builder && this._config.builder.componentPreload &&
  50. 			this._config.builder.componentPreload.paths || [];
  51. 	}
  53. 	/**
  54. 	* @private
  55. 	*/
  56. 	getComponentPreloadNamespaces() {
  57. 		return this._config.builder && this._config.builder.componentPreload &&
  58. 			this._config.builder.componentPreload.namespaces || [];
  59. 	}
  61. 	/**
  62. 	* @private
  63. 	*/
  64. 	getComponentPreloadExcludes() {
  65. 		return this._config.builder && this._config.builder.componentPreload &&
  66. 			this._config.builder.componentPreload.excludes || [];
  67. 	}
  69. 	/**
  70. 	* @private
  71. 	*/
  72. 	getMinificationExcludes() {
  73. 		return this._config.builder && this._config.builder.minification &&
  74. 			this._config.builder.minification.excludes || [];
  75. 	}
  77. 	/**
  78. 	* @private
  79. 	*/
  80. 	getBundles() {
  81. 		return this._config.builder && this._config.builder.bundles || [];
  82. 	}
  84. 	/**
  85. 	* @private
  86. 	*/
  87. 	getPropertiesFileSourceEncoding() {
  88. 		return this._config.resources && this._config.resources.configuration &&
  89. 			this._config.resources.configuration.propertiesFileSourceEncoding || "UTF-8";
  90. 	}
  92. 	/* === Resource Access === */
  94. 	/**
  95. 	 * Get a [ReaderCollection]{@link @ui5/fs/ReaderCollection} for accessing all resources of the
  96. 	 * project in the specified "style":
  97. 	 *
  98. 	 * <ul>
  99. 	 * <li><b>buildtime:</b> Resource paths are always prefixed with <code>/resources/</code>
  100. 	 *  or <code>/test-resources/</code> followed by the project's namespace.
  101. 	 *  Any configured build-excludes are applied</li>
  102. 	 * <li><b>dist:</b> Resource paths always match with what the UI5 runtime expects.
  103. 	 *  This means that paths generally depend on the project type. Applications for example use a "flat"-like
  104. 	 *  structure, while libraries use a "buildtime"-like structure.
  105. 	 *  Any configured build-excludes are applied</li>
  106. 	 * <li><b>runtime:</b> Resource paths always match with what the UI5 runtime expects.
  107. 	 *  This means that paths generally depend on the project type. Applications for example use a "flat"-like
  108. 	 *  structure, while libraries use a "buildtime"-like structure.
  109. 	 *  This style is typically used for serving resources directly. Therefore, build-excludes are not applied
  110. 	 * <li><b>flat:</b> Resource paths are never prefixed and namespaces are omitted if possible. Note that
  111. 	 *  project types like "theme-library", which can have multiple namespaces, can't omit them.
  112. 	 *  Any configured build-excludes are applied</li>
  113. 	 * </ul>
  114. 	 *
  115. 	 * If project resources have been changed through the means of a workspace, those changes
  116. 	 * are reflected in the provided reader too.
  117. 	 *
  118. 	 * Resource readers always use POSIX-style paths.
  119. 	 *
  120. 	 * @public
  121. 	 * @param {object} [options]
  122. 	 * @param {string} [options.style=buildtime] Path style to access resources.
  123. 	 *   Can be "buildtime", "dist", "runtime" or "flat"
  124. 	 * @returns {@ui5/fs/ReaderCollection} A reader collection instance
  125. 	 */
  126. 	getReader({style = "buildtime"} = {}) {
  127. 		// TODO: Additional style 'ABAP' using "sap.platform.abap".uri from manifest.json?
  129. 		// Apply builder excludes to all styles but "runtime"
  130. 		const excludes = style === "runtime" ? [] : this.getBuilderResourcesExcludes();
  132. 		if ((style === "runtime" || style === "dist") && this._isRuntimeNamespaced) {
  133. 			// If the project's type requires a namespace at runtime, the
  134. 			// dist- and runtime-style paths are identical to buildtime-style paths
  135. 			style = "buildtime";
  136. 		}
  137. 		let reader = this._getReader(excludes);
  138. 		switch (style) {
  139. 		case "buildtime":
  140. 			break;
  141. 		case "runtime":
  142. 		case "dist":
  143. 			// Use buildtime reader and link it to /
  144. 			// No test-resources for runtime resource access,
  145. 			// unless runtime is namespaced
  146. 			reader = resourceFactory.createFlatReader({
  147. 				reader,
  148. 				namespace: this._namespace
  149. 			});
  150. 			break;
  151. 		case "flat":
  152. 			// Use buildtime reader and link it to /
  153. 			// No test-resources for runtime resource access,
  154. 			// unless runtime is namespaced
  155. 			reader = resourceFactory.createFlatReader({
  156. 				reader,
  157. 				namespace: this._namespace
  158. 			});
  159. 			break;
  160. 		default:
  161. 			throw new Error(`Unknown path mapping style ${style}`);
  162. 		}
  164. 		reader = this._addWriter(reader, style);
  165. 		return reader;
  166. 	}
  168. 	/**
  169. 	* Get a resource reader for the resources of the project
  170. 	*
  171. 	* @returns {@ui5/fs/ReaderCollection} Reader collection
  172. 	*/
  173. 	_getSourceReader() {
  174. 		throw new Error(`_getSourceReader must be implemented by subclass ${this.constructor.name}`);
  175. 	}
  177. 	/**
  178. 	* Get a resource reader for the test resources of the project
  179. 	*
  180. 	* @returns {@ui5/fs/ReaderCollection} Reader collection
  181. 	*/
  182. 	_getTestReader() {
  183. 		throw new Error(`_getTestReader must be implemented by subclass ${this.constructor.name}`);
  184. 	}
  186. 	/**
  187. 	 * Get a resource reader/writer for accessing and modifying a project's resources
  188. 	 *
  189. 	 * @public
  190. 	 * @returns {@ui5/fs/ReaderCollection} A reader collection instance
  191. 	 */
  192. 	getWorkspace() {
  193. 		// Workspace is always of style "buildtime"
  194. 		// Therefore builder resource-excludes are always to be applied
  195. 		const excludes = this.getBuilderResourcesExcludes();
  196. 		return resourceFactory.createWorkspace({
  197. 			name: `Workspace for project ${this.getName()}`,
  198. 			reader: this._getReader(excludes),
  199. 			writer: this._getWriter().collection
  200. 		});
  201. 	}
  203. 	_getWriter() {
  204. 		if (!this._writers) {
  205. 			// writer is always of style "buildtime"
  206. 			const namespaceWriter = resourceFactory.createAdapter({
  207. 				virBasePath: "/",
  208. 				project: this
  209. 			});
  211. 			const generalWriter = resourceFactory.createAdapter({
  212. 				virBasePath: "/",
  213. 				project: this
  214. 			});
  216. 			const collection = resourceFactory.createWriterCollection({
  217. 				name: `Writers for project ${this.getName()}`,
  218. 				writerMapping: {
  219. 					[`/resources/${this._namespace}/`]: namespaceWriter,
  220. 					[`/test-resources/${this._namespace}/`]: namespaceWriter,
  221. 					[`/`]: generalWriter
  222. 				}
  223. 			});
  225. 			this._writers = {
  226. 				namespaceWriter,
  227. 				generalWriter,
  228. 				collection
  229. 			};
  230. 		}
  231. 		return this._writers;
  232. 	}
  234. 	_getReader(excludes) {
  235. 		let reader = this._getSourceReader(excludes);
  236. 		const testReader = this._getTestReader(excludes);
  237. 		if (testReader) {
  238. 			reader = resourceFactory.createReaderCollection({
  239. 				name: `Reader collection for project ${this.getName()}`,
  240. 				readers: [reader, testReader]
  241. 			});
  242. 		}
  243. 		return reader;
  244. 	}
  246. 	_addWriter(reader, style) {
  247. 		const {namespaceWriter, generalWriter} = this._getWriter();
  249. 		if ((style === "runtime" || style === "dist") && this._isRuntimeNamespaced) {
  250. 			// If the project's type requires a namespace at runtime, the
  251. 			// dist- and runtime-style paths are identical to buildtime-style paths
  252. 			style = "buildtime";
  253. 		}
  254. 		const readers = [];
  255. 		switch (style) {
  256. 		case "buildtime":
  257. 			// Writer already uses buildtime style
  258. 			readers.push(namespaceWriter);
  259. 			readers.push(generalWriter);
  260. 			break;
  261. 		case "runtime":
  262. 		case "dist":
  263. 			// Runtime is not namespaced: link namespace to /
  264. 			readers.push(resourceFactory.createFlatReader({
  265. 				reader: namespaceWriter,
  266. 				namespace: this._namespace
  267. 			}));
  268. 			// Add general writer as is
  269. 			readers.push(generalWriter);
  270. 			break;
  271. 		case "flat":
  272. 			// Rewrite paths from "flat" to "buildtime"
  273. 			readers.push(resourceFactory.createFlatReader({
  274. 				reader: namespaceWriter,
  275. 				namespace: this._namespace
  276. 			}));
  277. 			// General writer resources can't be flattened, so they are not available
  278. 			break;
  279. 		default:
  280. 			throw new Error(`Unknown path mapping style ${style}`);
  281. 		}
  282. 		readers.push(reader);
  284. 		return resourceFactory.createReaderCollectionPrioritized({
  285. 			name: `Reader/Writer collection for project ${this.getName()}`,
  286. 			readers
  287. 		});
  288. 	}
  290. 	/* === Internals === */
  291. 	/**
  292. 	 * @private
  293. 	 * @param {object} config Configuration object
  294. 	*/
  295. 	async _parseConfiguration(config) {
  296. 		await super._parseConfiguration(config);
  297. 	}
  299. 	async _getNamespace() {
  300. 		throw new Error(`_getNamespace must be implemented by subclass ${this.constructor.name}`);
  301. 	}
  303. 	/* === Helper === */
  304. 	/**
  305. 	 * Checks whether a given string contains a maven placeholder.
  306. 	 * E.g. <code>${appId}</code>.
  307. 	 *
  308. 	 * @param {string} value String to check
  309. 	 * @returns {boolean} True if given string contains a maven placeholder
  310. 	 */
  311. 	_hasMavenPlaceholder(value) {
  312. 		return !!value.match(/^\$\{(.*)\}$/);
  313. 	}
  315. 	/**
  316. 	 * Resolves a maven placeholder in a given string using the projects pom.xml
  317. 	 *
  318. 	 * @param {string} value String containing a maven placeholder
  319. 	 * @returns {Promise<string>} Resolved string
  320. 	 */
  321. 	async _resolveMavenPlaceholder(value) {
  322. 		const parts = value && value.match(/^\$\{(.*)\}$/);
  323. 		if (parts) {
  324. 			this._log.verbose(
  325. 				`"${value}" contains a maven placeholder "${parts[1]}". Resolving from projects pom.xml...`);
  326. 			const pom = await this._getPom();
  327. 			let mvnValue;
  328. 			if (pom.project && pom.project.properties && pom.project.properties[parts[1]]) {
  329. 				mvnValue = pom.project.properties[parts[1]];
  330. 			} else {
  331. 				let obj = pom;
  332. 				parts[1].split(".").forEach((part) => {
  333. 					obj = obj && obj[part];
  334. 				});
  335. 				mvnValue = obj;
  336. 			}
  337. 			if (!mvnValue) {
  338. 				throw new Error(`"${value}" couldn't be resolved from maven property ` +
  339. 					`"${parts[1]}" of pom.xml of project ${this.getName()}`);
  340. 			}
  341. 			return mvnValue;
  342. 		} else {
  343. 			throw new Error(`"${value}" is not a maven placeholder`);
  344. 		}
  345. 	}
  347. 	/**
  348. 	 * Reads the projects pom.xml file
  349. 	 *
  350. 	 * @returns {Promise<object>} Resolves with a JSON representation of the content
  351. 	 */
  352. 	async _getPom() {
  353. 		if (this._pPom) {
  354. 			return this._pPom;
  355. 		}
  357. 		return this._pPom = this.getRootReader().byPath("/pom.xml")
  358. 			.then(async (resource) => {
  359. 				if (!resource) {
  360. 					throw new Error(
  361. 						`Could not find pom.xml in project ${this.getName()}`);
  362. 				}
  363. 				const content = await resource.getString();
  364. 				const {
  365. 					default: xml2js
  366. 				} = await import("xml2js");
  367. 				const parser = new xml2js.Parser({
  368. 					explicitArray: false,
  369. 					ignoreAttrs: true
  370. 				});
  371. 				const readXML = promisify(parser.parseString);
  372. 				return readXML(content);
  373. 			}).catch((err) => {
  374. 				throw new Error(
  375. 					`Failed to read pom.xml for project ${this.getName()}: ${err.message}`);
  376. 			});
  377. 	}
  378. }
  380. export default ComponentProject;