project/lib/ui5Framework/Sapui5MavenSnapshotResolver.js

  1. import path from "node:path";
  2. import os from "node:os";
  3. import semver from "semver";
  4. import AbstractResolver from "./AbstractResolver.js";
  5. import Installer from "./maven/Installer.js";
  6. import {getLogger} from "@ui5/logger";
  7. const log = getLogger("ui5Framework:Sapui5MavenSnapshotResolver");
  9. const DIST_PKG_NAME = "@sapui5/distribution-metadata";
  10. const DIST_GROUP_ID = "com.sap.ui5.dist";
  11. const DIST_ARTIFACT_ID = "sapui5-sdk-dist";
  13. /**
  14.  * Resolver for the SAPUI5 framework
  15.  *
  16.  * This Resolver downloads and installs SNAPSHOTS of UI5 libraries from
  17.  * a Maven repository. It's meant for internal usage only as no use cases
  18.  * outside of SAP are known.
  19.  *
  20.  * @public
  21.  * @class
  22.  * @alias @ui5/project/ui5Framework/Sapui5MavenSnapshotResolver
  23.  * @extends @ui5/project/ui5Framework/AbstractResolver
  24.  */
  25. class Sapui5MavenSnapshotResolver extends AbstractResolver {
  26. 	/**
  27. 	 * @param {*} options options
  28. 	 * @param {string} [options.snapshotEndpointUrl] Maven Repository Snapshot URL. Can by overruled
  29. 	 *	by setting the <code>UI5_MAVEN_SNAPSHOT_ENDPOINT_URL</code> environment variable. If neither is provided,
  30. 	 *	falling back to the standard Maven settings.xml file (if existing).
  31. 	 * @param {string} options.version SAPUI5 version to use
  32. 	 * @param {boolean} [options.sources=false] Whether to install framework libraries as sources or
  33. 	 * pre-built (with build manifest)
  34. 	 * @param {string} [options.cwd=process.cwd()] Current working directory
  35. 	 * @param {string} [options.ui5HomeDir="~/.ui5"] UI5 home directory location. This will be used to store packages,
  36. 	 * metadata and configuration used by the resolvers. Relative to `process.cwd()`
  37. 	 * @param {module:@ui5/project/ui5Framework/maven/CacheMode} [options.cacheMode=Default]
  38. 	 * Cache mode to use
  39. 	 */
  40. 	constructor(options) {
  41. 		super(options);
  43. 		const {
  44. 			cacheMode,
  45. 		} = options;
  47. 		this._installer = new Installer({
  48. 			ui5HomeDir: this._ui5HomeDir,
  49. 			snapshotEndpointUrlCb:
  50. 				Sapui5MavenSnapshotResolver._createSnapshotEndpointUrlCallback(options.snapshotEndpointUrl),
  51. 			cacheMode,
  52. 		});
  53. 		this._loadDistMetadata = null;
  55. 		// TODO 4.0: Remove support for legacy snapshot versions
  56. 		this._isLegacySnapshotVersion = semver.lt(this._version, "1.116.0-SNAPSHOT", {
  57. 			includePrerelease: true
  58. 		});
  59. 	}
  60. 	loadDistMetadata() {
  61. 		if (!this._loadDistMetadata) {
  62. 			this._loadDistMetadata = Promise.resolve().then(async () => {
  63. 				const version = this._version;
  64. 				log.verbose(
  65. 					`Installing ${DIST_ARTIFACT_ID} in version ${version}...`
  66. 				);
  68. 				const {pkgPath: distPkgPath} = await this._installer.installPackage({
  69. 					pkgName: DIST_PKG_NAME,
  70. 					groupId: DIST_GROUP_ID,
  71. 					artifactId: DIST_ARTIFACT_ID,
  72. 					version,
  73. 					classifier: "npm-sources",
  74. 					extension: "zip",
  75. 				});
  77. 				return await this._installer.readJson(
  78. 					path.join(distPkgPath, "metadata.json")
  79. 				);
  80. 			});
  81. 		}
  82. 		return this._loadDistMetadata;
  83. 	}
  84. 	async getLibraryMetadata(libraryName) {
  85. 		const distMetadata = await this.loadDistMetadata();
  86. 		const metadata = distMetadata.libraries[libraryName];
  88. 		if (!metadata) {
  89. 			throw new Error(`Could not find library "${libraryName}"`);
  90. 		}
  92. 		return metadata;
  93. 	}
  94. 	async handleLibrary(libraryName) {
  95. 		const metadata = await this.getLibraryMetadata(libraryName);
  96. 		if (!metadata.gav) {
  97. 			throw new Error(
  98. 				"Metadata is missing GAV (group, artifact and version) " +
  99. 					"information. This might indicate an unsupported SNAPSHOT version."
  100. 			);
  101. 		}
  102. 		const gav = metadata.gav.split(":");
  103. 		let pkgName = metadata.npmPackageName;
  105. 		// Use "npm-dist" artifact by default
  106. 		let classifier;
  107. 		let extension;
  108. 		if (this._sources) {
  109. 			// Use npm-sources artifact if sources are requested
  110. 			classifier = "npm-sources";
  111. 			extension = "zip";
  112. 		} else {
  113. 			// Add "prebuilt" suffix to package name
  114. 			pkgName += "-prebuilt";
  116. 			if (this._isLegacySnapshotVersion) {
  117. 				// For legacy versions < 1.116.0-SNAPSHOT where npm-dist artifact is not
  118. 				// yet available, use "default" JAR
  119. 				classifier = null;
  120. 				extension = "jar";
  121. 			} else {
  122. 				// Use "npm-dist" artifact by default
  123. 				classifier = "npm-dist";
  124. 				extension = "zip";
  125. 			}
  126. 		}
  128. 		return {
  129. 			metadata: Promise.resolve({
  130. 				id: pkgName,
  131. 				version: metadata.version,
  132. 				dependencies: metadata.dependencies,
  133. 				optionalDependencies: metadata.optionalDependencies,
  134. 			}),
  135. 			// Trigger installation of package
  136. 			install: this._installer.installPackage({
  137. 				pkgName,
  138. 				groupId: gav[0],
  139. 				artifactId: gav[1],
  140. 				version: metadata.version,
  141. 				classifier,
  142. 				extension,
  143. 			}),
  144. 		};
  145. 	}
  147. 	static async fetchAllVersions({ui5HomeDir, cwd, snapshotEndpointUrl} = {}) {
  148. 		const installer = new Installer({
  149. 			cwd: cwd ? path.resolve(cwd) : process.cwd(),
  150. 			ui5HomeDir: path.resolve(
  151. 				ui5HomeDir || path.join(os.homedir(), ".ui5")
  152. 			),
  153. 			snapshotEndpointUrlCb: Sapui5MavenSnapshotResolver._createSnapshotEndpointUrlCallback(snapshotEndpointUrl),
  154. 		});
  155. 		return await installer.fetchPackageVersions({
  156. 			groupId: DIST_GROUP_ID,
  157. 			artifactId: DIST_ARTIFACT_ID,
  158. 		});
  159. 	}
  161. 	static _createSnapshotEndpointUrlCallback(snapshotEndpointUrl) {
  162. 		snapshotEndpointUrl = process.env.UI5_MAVEN_SNAPSHOT_ENDPOINT_URL || snapshotEndpointUrl;
  164. 		if (!snapshotEndpointUrl) {
  165. 			// Here we return a function which returns a promise that resolves with the URL.
  166. 			// If we would already start resolving the settings.xml at this point, we'd need to always ask the
  167. 			// end user for confirmation whether the resolved URL should be used. In some cases where the resources
  168. 			// are already cached, this is actually not necessary and could be skipped
  169. 			return Sapui5MavenSnapshotResolver._resolveSnapshotEndpointUrl;
  170. 		} else {
  171. 			return () => Promise.resolve(snapshotEndpointUrl);
  172. 		}
  173. 	}
  175. 	/**
  176. 	 * Read the Maven repository snapshot endpoint URL from the central
  177. 	 * UI5 Tooling configuration, with a fallback to central Maven configuration (is existing)
  178. 	 *
  179. 	 * @returns {Promise<string>} The resolved snapshotEndpointUrl
  180. 	 */
  181. 	static async _resolveSnapshotEndpointUrl() {
  182. 		const {default: Configuration} = await import("../config/Configuration.js");
  183. 		const config = await Configuration.fromFile();
  184. 		let url = config.getMavenSnapshotEndpointUrl();
  185. 		if (url) {
  186. 			log.verbose(`Using UI5 Tooling configuration for mavenSnapshotEndpointUrl: ${url}`);
  187. 		} else {
  188. 			log.verbose(`No mavenSnapshotEndpointUrl configuration found`);
  189. 			url = await Sapui5MavenSnapshotResolver._resolveSnapshotEndpointUrlFromMaven();
  190. 			if (url) {
  191. 				log.verbose(`Updating UI5 Tooling configuration with new mavenSnapshotEndpointUrl: ${url}`);
  192. 				const configJson = config.toJson();
  193. 				configJson.mavenSnapshotEndpointUrl = url;
  194. 				await Configuration.toFile(new Configuration(configJson));
  195. 			}
  196. 		}
  197. 		return url;
  198. 	}
  200. 	/**
  201. 	 * Tries to detect whether ~/.m2/settings.xml exist, and if so, whether
  202. 	 * the snapshot.build URL is extracted from there
  203. 	 *
  204. 	 * @param {string} [settingsXML=~/.m2/settings.xml] Path to the settings.xml.
  205. 	 * 				If not provided, the default location is used
  206. 	 * @returns {Promise<string>} The resolved snapshot.build URL from ~/.m2/settings.xml
  207. 	 */
  208. 	static async _resolveSnapshotEndpointUrlFromMaven(settingsXML) {
  209. 		if (!process.stdout.isTTY) {
  210. 			// We can't prompt the user if stdout is non-interactive (i.e. in CI environments)
  211. 			// Therefore skip resolution from Maven settings.xml altogether
  212. 			return null;
  213. 		}
  215. 		settingsXML =
  216. 			settingsXML || path.resolve(path.join(os.homedir(), ".m2", "settings.xml"));
  218. 		const {default: fs} = await import("graceful-fs");
  219. 		const {promisify} = await import("node:util");
  220. 		const readFile = promisify(fs.readFile);
  221. 		const xml2js = await import("xml2js");
  222. 		const parser = new xml2js.Parser({
  223. 			preserveChildrenOrder: true,
  224. 			xmlns: true,
  225. 		});
  226. 		let url;
  228. 		log.verbose(`Attempting to resolve snapshot endpoint URL from Maven configuration file at ${settingsXML}...`);
  229. 		try {
  230. 			const fileContent = await readFile(settingsXML);
  231. 			const xmlContents = await parser.parseStringPromise(fileContent);
  233. 			const snapshotBuildChunk = xmlContents?.settings?.profiles[0]?.profile.filter(
  234. 				(prof) => prof.id[0]._ === "snapshot.build"
  235. 			)[0];
  237. 			url =
  238. 				snapshotBuildChunk?.repositories?.[0]?.repository?.[0]?.url?.[0]?._ ||
  239. 				snapshotBuildChunk?.pluginRepositories?.[0]?.pluginRepository?.[0]?.url?.[0]?._;
  241. 			if (!url) {
  242. 				log.verbose(`"snapshot.build" attribute could not be found in ${settingsXML}`);
  243. 				return null;
  244. 			}
  245. 		} catch (err) {
  246. 			if (err.code === "ENOENT") {
  247. 				// "File or directory does not exist"
  248. 				log.verbose(`File does not exist: ${settingsXML}`);
  249. 			} else {
  250. 				log.warning(`Failed to read Maven configuration file from ${settingsXML}: ${err.message}`);
  251. 			}
  252. 			return null;
  253. 		}
  255. 		const {default: yesno} = await import("yesno");
  256. 		const ok = await yesno({
  257. 			question:
  258. 				"\nA Maven repository endpoint URL is required for consuming snapshot versions of UI5 libraries.\n" +
  259. 				"You can configure one using the command: 'ui5 config set mavenSnapshotEndpointUrl <url>'\n\n" +
  260. 				`The following URL has been found in a Maven configuration file at ${settingsXML}:\n${url}\n\n` +
  261. 				`Continue with this endpoint URL and remember it for the future? (yes)`,
  262. 			defaultValue: true,
  263. 		});
  265. 		if (ok) {
  266. 			log.verbose(`Using Maven snapshot endpoint URL resolved from Maven configuration file: ${url}`);
  267. 			return url;
  268. 		} else {
  269. 			log.verbose(`User rejected usage of the resolved URL`);
  270. 			return null;
  271. 		}
  272. 	}
  273. }
  275. export default Sapui5MavenSnapshotResolver;