[FEATURE] Add ui5Framework translator and resolvers

index.js

@@ -5,6 +5,15 @@
 module.exports = {
  normalizer: require("./lib/normalizer"),
  projectPreprocessor: require("./lib/projectPreprocessor"),
+ /**
+ * @public
+ * @see module:@ui5/project.ui5Framework
+ * @namespace
+ */
+ ui5Framework: {
+ Openui5Resolver: require("./lib/ui5Framework/Openui5Resolver"),
+ Sapui5Resolver: require("./lib/ui5Framework/Sapui5Resolver")
+ },
  /**
  * @private
  * @see module:@ui5/project.translators

lib/normalizer.js

@@ -20,15 +20,28 @@ const Normalizer = {
  * @param {string} [options.configPath] Path to configuration file
  * @param {string} [options.translatorName] Translator to use
  * @param {Object} [options.translatorOptions] Options to pass to translator
+ * @param {Object} [options.frameworkOptions] Options to pass to the framework installer
  * @returns {Promise<Object>} Promise resolving to tree object
  */
  generateProjectTree: async function(options = {}) {
- const tree = await Normalizer.generateDependencyTree(options);
+ let tree = await Normalizer.generateDependencyTree(options);
 
  if (options.configPath) {
  tree.configPath = options.configPath;
  }
- return projectPreprocessor.processTree(tree);
+ tree = await projectPreprocessor.processTree(tree);
+
+ if (tree.framework) {
+ const ui5Framework = require("./translators/ui5Framework");
+ log.verbose(`Root project ${tree.metadata.name} defines framework ` +
+ `configuration. Installing UI5 dependencies...`);
+ let frameworkTree = await ui5Framework.generateDependencyTree(tree, options.frameworkOptions);
+ if (frameworkTree) {
+ frameworkTree = await projectPreprocessor.processTree(frameworkTree);
+ ui5Framework.mergeTrees(tree, frameworkTree);
+ }
+ }
+ return tree;
  },
 
  /**

lib/translators/npm.js

@@ -3,7 +3,7 @@ const path = require("path");
 const readPkgUp = require("read-pkg-up");
 const readPkg = require("read-pkg");
 const {promisify} = require("util");
-const fs = require("fs");
+const fs = require("graceful-fs");
 const realpath = promisify(fs.realpath);
 const resolveModulePath = promisify(require("resolve"));
 const parentNameRegExp = new RegExp(/:([^:]+):$/i);

lib/translators/ui5Framework.js

@@ -0,0 +1,221 @@
+const log = require("@ui5/logger").getLogger("normalizer:translators:ui5Framework");
+
+class ProjectProcessor {
+ constructor({libraryMetadata}) {
+ this._libraryMetadata = libraryMetadata;
+ this._projectCache = {};
+ }
+ getProject(libName) {
+ log.verbose(`Creating project for library ${libName}...`);
+
+ if (this._projectCache[libName]) {
+ log.verbose(`Returning cached project for library ${libName}`);
+ return this._projectCache[libName];
+ }
+
+ if (!this._libraryMetadata[libName]) {
+ throw new Error(`Failed to find library ${libName} in dist packages metadata.json`);
+ }
+
+ const depMetadata = this._libraryMetadata[libName];
+
+ const dependencies = [];
+ dependencies.push(...depMetadata.dependencies.map((depName) => {
+ return this.getProject(depName);
+ }));
+
+ if (depMetadata.optionalDependencies) {
+ const resolvedOptionals = depMetadata.optionalDependencies.map((depName) => {
+ if (this._libraryMetadata[depName]) {
+ log.verbose(`Resolving optional dependency ${depName} for project ${libName}...`);
+ return this.getProject(depName);
+ }
+ }).filter(($)=>$);
+
+ dependencies.push(...resolvedOptionals);
+ }
+
+ this._projectCache[libName] = {
+ id: depMetadata.id,
+ version: depMetadata.version,
+ path: depMetadata.path,
+ dependencies
+ };
+ return this._projectCache[libName];
+ }
+}
+
+const utils = {
+ getAllNodesOfTree(tree) {
+ const nodes = {};
+ const queue = [...tree];
+ while (queue.length) {
+ const project = queue.shift();
+ if (!nodes[project.metadata.name]) {
+ nodes[project.metadata.name] = project;
+ queue.push(...project.dependencies);
+ }
+ }
+ return nodes;
+ },
+ isFrameworkProject(project) {
+ return project.id.startsWith("@openui5/") || project.id.startsWith("@sapui5/");
+ },
+ shouldIncludeDependency({optional, development}, root) {
+ // Root project should include all dependencies
+ // Otherwise only non-optional and non-development dependencies should be included
+ return root || (optional !== true && development !== true);
+ },
+ getFrameworkLibrariesFromTree(project, ui5Dependencies = [], root = true) {
+ if (utils.isFrameworkProject(project)) {
+ // Ignoring UI5 Framework libraries in dependencies
+ return ui5Dependencies;
+ }
+ if (project.framework && project.framework.libraries) {
+ project.framework.libraries.forEach((dependency) => {
+ if (!ui5Dependencies.includes(dependency.name) && utils.shouldIncludeDependency(dependency, root)) {
+ ui5Dependencies.push(dependency.name);
+ }
+ });
+ } else {
+ log.verbose(`Project ${project.metadata.name} defines no framework.libraries configuration`);
+ // Possible future enhancement: Fallback to detect OpenUI5 framework dependencies in package.json
+ }
+ project.dependencies.map((depProject) => {
+ utils.getFrameworkLibrariesFromTree(depProject, ui5Dependencies, false);
+ });
+ return ui5Dependencies;
+ },
+ ProjectProcessor
+};
+
+/**
+ *
+ *
+ * @private
+ * @namespace
+ * @alias module:@ui5/project.translators.ui5Framework
+ */
+module.exports = {
+ /**
+ *
+ *
+ * @public
+ * @param {Object} tree
+ * @param {Object} [options]
+ * @param {Object} [options.versionOverride] Framework version to use instead of the root projects framework
+ * version from the provided <code>tree</code>
+ * @returns {Promise<Object|null>} Promise
+ */
+ generateDependencyTree: async function(tree, options = {}) {
+ // Don't create a tree when root project doesn't have a framework configuration
+ if (!tree.framework) {
+ return null;
+ }
+
+ const frameworkName = tree.framework.name;
+ if (frameworkName !== "SAPUI5" && frameworkName !== "OpenUI5") {
+ throw new Error(
+ `Unknown framework.name "${frameworkName}" for project ${tree.id}. Must be "OpenUI5" or "SAPUI5"`
+ );
+ }
+
+ let version;
+ if (!tree.framework.version) {
+ throw new Error(
+ `framework.version is not defined for project ${tree.id}`
+ );
+ } else if (options.versionOverride) {
+ log.info(
+ `Overriding configured ${frameworkName} version ` +
+ `${tree.framework.version} with supplied version ${options.versionOverride}`
+ );
+ version = options.versionOverride;
+ } else {
+ version = tree.framework.version;
+ }
+
+ log.info(`Using ${frameworkName} version: ${version}`);
+
+ const referencedLibraries = utils.getFrameworkLibrariesFromTree(tree);
+
+ let resolver;
+ if (frameworkName === "OpenUI5") {
+ const Openui5Resolver = require("../ui5Framework/Openui5Resolver");
+ resolver = new Openui5Resolver({cwd: tree.path, version});
+ } else if (frameworkName === "SAPUI5") {
+ const Sapui5Resolver = require("../ui5Framework/Sapui5Resolver");
+ resolver = new Sapui5Resolver({cwd: tree.path, version});
+ }
+
+ let startTime;
+ if (log.isLevelEnabled("verbose")) {
+ startTime = process.hrtime();
+ }
+
+ const {libraryMetadata} = await resolver.install(referencedLibraries);
+
+ if (log.isLevelEnabled("verbose")) {
+ const timeDiff = process.hrtime(startTime);
+ const prettyHrtime = require("pretty-hrtime");
+ log.verbose(`${frameworkName} dependencies ${referencedLibraries.join(", ")} resolved in ${prettyHrtime(timeDiff)}`);
+ }
+
+ const projectProcessor = new utils.ProjectProcessor({
+ libraryMetadata
+ });
+
+ const libraries = referencedLibraries.map((libName) => {
+ return projectProcessor.getProject(libName);
+ });
+
+ // Use root project (=requesting project) as root of framework tree
+ const frameworkTree = {
+ id: tree.id,
+ version: tree.version,
+ path: tree.path,
+ dependencies: libraries
+ };
+ return frameworkTree;
+ },
+
+ mergeTrees: function(projectTree, frameworkTree) {
+ const frameworkLibs = utils.getAllNodesOfTree(frameworkTree.dependencies);
+
+ log.verbose(`Merging framework tree into project tree "${projectTree.metadata.name}"`);
+
+ const queue = [projectTree];
+ while (queue.length) {
+ const project = queue.shift();
+
+ project.dependencies = project.dependencies.filter((depProject) => {
+ if (utils.isFrameworkProject(depProject)) {
+ log.verbose(
+ `A translator has already added the UI5 framework library ${depProject.metadata.name} ` +
+ `(id: ${depProject.id}) to the dependencies of project ${project.metadata.name}. ` +
+ `This dependency will be ignored.`);
+ log.info(`If project ${project.metadata.name} contains a package.json in which it defines a ` +
+ `dependency to the UI5 framework library ${depProject.id}, this dependency should be removed.`);
+ return false;
+ }
+ return true;
+ });
+ queue.push(...project.dependencies);
+
+ if (project.framework && project.framework.libraries) {
+ const frameworkDeps = project.framework.libraries.map((dependency) => {
+ if (!frameworkLibs[dependency.name]) {
+ throw new Error(`Missing framework library ${dependency.name} ` +
+ `required by project ${project.metadata.name}`);
+ }
+ return frameworkLibs[dependency.name];
+ });
+ project.dependencies.push(...frameworkDeps);
+ }
+ }
+ return projectTree;
+ },
+
+ // Export for testing only
+ _utils: process.env.NODE_ENV === "test" ? utils : undefined
+};