project/lib/specifications/types/Application.js

  1. import fsPath from "node:path";
  2. import ComponentProject from "../ComponentProject.js";
  3. import {createReader} from "@ui5/fs/resourceFactory";
  5. /**
  6.  * Application
  7.  *
  8.  * @public
  9.  * @class
  10.  * @alias @ui5/project/specifications/types/Application
  11.  * @extends @ui5/project/specifications/ComponentProject
  12.  * @hideconstructor
  13.  */
  14. class Application extends ComponentProject {
  15. 	constructor(parameters) {
  16. 		super(parameters);
  18. 		this._pManifests = Object.create(null);
  20. 		this._webappPath = "webapp";
  22. 		this._isRuntimeNamespaced = false;
  23. 	}
  26. 	/* === Attributes === */
  28. 	/**
  29. 	* Get the cachebuster signature type configuration of the project
  30. 	*
  31. 	* @returns {string} <code>time</code> or <code>hash</code>
  32. 	*/
  33. 	getCachebusterSignatureType() {
  34. 		return this._config.builder && this._config.builder.cachebuster &&
  35. 			this._config.builder.cachebuster.signatureType || "time";
  36. 	}
  38. 	/**
  39. 	 * Get the path of the project's source directory. This might not be POSIX-style on some platforms.
  40. 	 *
  41. 	 * @public
  42. 	 * @returns {string} Absolute path to the source directory of the project
  43. 	 */
  44. 	getSourcePath() {
  45. 		return fsPath.join(this.getRootPath(), this._webappPath);
  46. 	}
  48. 	/* === Resource Access === */
  49. 	/**
  50. 	* Get a resource reader for the sources of the project (excluding any test resources)
  51. 	*
  52. 	* @param {string[]} excludes List of glob patterns to exclude
  53. 	* @returns {@ui5/fs/ReaderCollection} Reader collection
  54. 	*/
  55. 	_getSourceReader(excludes) {
  56. 		return createReader({
  57. 			fsBasePath: this.getSourcePath(),
  58. 			virBasePath: `/resources/${this._namespace}/`,
  59. 			name: `Source reader for application project ${this.getName()}`,
  60. 			project: this,
  61. 			excludes
  62. 		});
  63. 	}
  65. 	_getTestReader() {
  66. 		return null; // Applications do not have a dedicated test directory
  67. 	}
  69. 	/**
  70. 	 * Get a resource reader for the sources of the project (excluding any test resources)
  71. 	 * without a virtual base path
  72. 	 *
  73. 	 * @returns {@ui5/fs/ReaderCollection} Reader collection
  74. 	*/
  75. 	_getRawSourceReader() {
  76. 		return createReader({
  77. 			fsBasePath: this.getSourcePath(),
  78. 			virBasePath: "/",
  79. 			name: `Raw source reader for application project ${this.getName()}`,
  80. 			project: this
  81. 		});
  82. 	}
  84. 	/* === Internals === */
  85. 	/**
  86. 	 * @private
  87. 	 * @param {object} config Configuration object
  88. 	*/
  89. 	async _configureAndValidatePaths(config) {
  90. 		await super._configureAndValidatePaths(config);
  92. 		if (config.resources && config.resources.configuration &&
  93. 			config.resources.configuration.paths && config.resources.configuration.paths.webapp) {
  94. 			this._webappPath = config.resources.configuration.paths.webapp;
  95. 		}
  97. 		this._log.verbose(`Path mapping for application project ${this.getName()}:`);
  98. 		this._log.verbose(`  Physical root path: ${this.getRootPath()}`);
  99. 		this._log.verbose(`  Mapped to: ${this._webappPath}`);
  101. 		if (!(await this._dirExists("/" + this._webappPath))) {
  102. 			throw new Error(
  103. 				`Unable to find source directory '${this._webappPath}' in application project ${this.getName()}`);
  104. 		}
  105. 	}
  107. 	/**
  108. 	 * @private
  109. 	 * @param {object} config Configuration object
  110. 	 * @param {object} buildDescription Cache metadata object
  111. 	*/
  112. 	async _parseConfiguration(config, buildDescription) {
  113. 		await super._parseConfiguration(config, buildDescription);
  115. 		if (buildDescription) {
  116. 			this._namespace = buildDescription.namespace;
  117. 			return;
  118. 		}
  119. 		this._namespace = await this._getNamespace();
  120. 	}
  122. 	/**
  123. 	 * Determine application namespace either based on a project`s
  124. 	 * manifest.json or manifest.appdescr_variant (fallback if present)
  125. 	 *
  126. 	 * @returns {string} Namespace of the project
  127. 	 * @throws {Error} if namespace can not be determined
  128. 	 */
  129. 	async _getNamespace() {
  130. 		try {
  131. 			return await this._getNamespaceFromManifestJson();
  132. 		} catch (manifestJsonError) {
  133. 			if (manifestJsonError.code !== "ENOENT") {
  134. 				throw manifestJsonError;
  135. 			}
  136. 			// No manifest.json present
  137. 			// => attempt fallback to manifest.appdescr_variant (typical for App Variants)
  138. 			try {
  139. 				return await this._getNamespaceFromManifestAppDescVariant();
  140. 			} catch (appDescVarError) {
  141. 				if (appDescVarError.code === "ENOENT") {
  142. 					// Fallback not possible: No manifest.appdescr_variant present
  143. 					// => Throw error indicating missing manifest.json
  144. 					// 	(do not mention manifest.appdescr_variant since it is only
  145. 					// 	relevant for the rather "uncommon" App Variants)
  146. 					throw new Error(
  147. 						`Could not find required manifest.json for project ` +
  148. 						`${this.getName()}: ${manifestJsonError.message}\n\n` +
  149. 						`If you are about to start a new project, please refer to:\n` +
  150. 						`https://sap.github.io/ui5-tooling/v3/pages/GettingStarted/#starting-a-new-project`, {
  151. 							cause: manifestJsonError
  152. 						});
  153. 				}
  154. 				throw appDescVarError;
  155. 			}
  156. 		}
  157. 	}
  159. 	/**
  160. 	 * Determine application namespace by checking manifest.json.
  161. 	 * Any maven placeholders are resolved from the projects pom.xml
  162. 	 *
  163. 	 * @returns {string} Namespace of the project
  164. 	 * @throws {Error} if namespace can not be determined
  165. 	 */
  166. 	async _getNamespaceFromManifestJson() {
  167. 		const manifest = await this._getManifest("/manifest.json");
  168. 		let appId;
  169. 		// check for a proper sap.app/id in manifest.json to determine namespace
  170. 		if (manifest["sap.app"] && manifest["sap.app"].id) {
  171. 			appId = manifest["sap.app"].id;
  172. 		} else {
  173. 			throw new Error(
  174. 				`No sap.app/id configuration found in manifest.json of project ${this.getName()}`);
  175. 		}
  177. 		if (this._hasMavenPlaceholder(appId)) {
  178. 			try {
  179. 				appId = await this._resolveMavenPlaceholder(appId);
  180. 			} catch (err) {
  181. 				throw new Error(
  182. 					`Failed to resolve namespace of project ${this.getName()}: ${err.message}`);
  183. 			}
  184. 		}
  185. 		const namespace = appId.replace(/\./g, "/");
  186. 		this._log.verbose(
  187. 			`Namespace of project ${this.getName()} is ${namespace} (from manifest.json)`);
  188. 		return namespace;
  189. 	}
  191. 	/**
  192. 	 * Determine application namespace by checking manifest.appdescr_variant.
  193. 	 *
  194. 	 * @returns {string} Namespace of the project
  195. 	 * @throws {Error} if namespace can not be determined
  196. 	 */
  197. 	async _getNamespaceFromManifestAppDescVariant() {
  198. 		const manifest = await this._getManifest("/manifest.appdescr_variant");
  199. 		let appId;
  200. 		// check for the id property in manifest.appdescr_variant to determine namespace
  201. 		if (manifest && manifest.id) {
  202. 			appId = manifest.id;
  203. 		} else {
  204. 			throw new Error(
  205. 				`No "id" property found in manifest.appdescr_variant of project ${this.getName()}`);
  206. 		}
  208. 		const namespace = appId.replace(/\./g, "/");
  209. 		this._log.verbose(
  210. 			`Namespace of project ${this.getName()} is ${namespace} (from manifest.appdescr_variant)`);
  211. 		return namespace;
  212. 	}
  214. 	/**
  215. 	 * Reads and parses a JSON file with the provided name from the projects source directory
  216. 	 *
  217. 	 * @param {string} filePath Name of the JSON file to read. Typically "manifest.json" or "manifest.appdescr_variant"
  218. 	 * @returns {Promise<object>} resolves with an object containing the content requested manifest file
  219. 	 */
  220. 	async _getManifest(filePath) {
  221. 		if (this._pManifests[filePath]) {
  222. 			return this._pManifests[filePath];
  223. 		}
  224. 		return this._pManifests[filePath] = this._getRawSourceReader().byPath(filePath)
  225. 			.then(async (resource) => {
  226. 				if (!resource) {
  227. 					const error = new Error(
  228. 						`Could not find resource ${filePath} in project ${this.getName()}`);
  229. 					error.code = "ENOENT"; // "File or directory does not exist"
  230. 					throw error;
  231. 				}
  232. 				return JSON.parse(await resource.getString());
  233. 			}).catch((err) => {
  234. 				if (err.code === "ENOENT") {
  235. 					throw err;
  236. 				}
  237. 				throw new Error(
  238. 					`Failed to read ${filePath} for project ` +
  239. 					`${this.getName()}: ${err.message}`);
  240. 			});
  241. 	}
  242. }
  244. export default Application;