@eui/tools 6.5.6 → 6.6.0

package/scripts/app/public/stats.js

@@ -0,0 +1,68 @@
+const getRequestBody = (items) => {
+    return {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(items),
+    };
+};
+
+new Vue({
+    el: "#app",
+    data() {
+        return {
+            allRemotesStats: true,
+            remotes: [],
+            selectedRemotes: [],
+            remoteStats: {},
+            remoteAllStats: {},
+        };
+    },
+    created() {
+        this.getRemotes();
+        this.getRemoteAllStats();
+    },
+    methods: {
+        changeStatsType(value) {
+            this.allRemotesStats = value;
+        },
+        async getRemotes() {
+            const res = await fetch("http://localhost:3000/api/remotes");
+            const finalRes = await res.json();
+            this.remotes = finalRes;
+        },
+        async getRemoteAllStats() {
+            const res = await fetch("http://localhost:3000/api/remotes/stats");
+            const finalRes = await res.json();
+            this.remoteAllStats = finalRes.stats;
+        },
+        remoteSelected(event) {
+            this.getRemoteStats();
+        },
+        async getRemoteStats() {
+            const res = await fetch("http://localhost:3000/api/remotes/stats", getRequestBody({ remote: this.selectedRemotes }));
+            const finalRes = await res.json();
+            this.remoteStats = finalRes;
+            this.genVersionsChart();
+        },
+        genVersionsChart() {
+            const ctx = document.getElementById("versions").getContext("2d");
+            var myChart = new Chart(ctx, {
+                type: "line",
+                data: {
+                    labels: this.remoteStats.versions.map((v) => `${v.version} - ${v.date}`),
+                    datasets: [
+                        {
+                            data: this.remoteStats.versions.map((v) => v.duration),
+                            label: "Duration",
+                            borderColor: "#3e95cd",
+                            backgroundColor: "#7bb6dd",
+                            fill: false,
+                        },
+                    ],
+                },
+            });
+        },
+    },
+});

package/scripts/app/routes/index.js

@@ -4,9 +4,16 @@ const router = require('express').Router();
 
 const configUtils = require('../../csdr/config/config-utils');
 const metadataUtils = require('../../csdr/metadata/metadata-utils');
+const cliUtils = require('../../csdr/cli/cli-utils');
 const tools = require('../../utils/tools');
 
 
+const handlerError = (res, e) => {
+  console.log(e);
+  res.status(500);
+  res.send({ error: e });
+}
+
 router.get('/remotes', function (req, res) {
   return Promise.resolve()
     .then(() => {
@@ -29,7 +36,7 @@ router.get('/remotes', function (req, res) {
       res.send(remotes);
     })
     .catch((e) => {
-      console.log(e);
+      handlerError(res, e);
     })
 });
 
@@ -42,7 +49,7 @@ router.get('/remotes/stats', function (req, res) {
       res.send(stats);
     })
     .catch((e) => {
-      console.log(e);
+      handlerError(res, e);
     })
 });
 
@@ -54,7 +61,7 @@ router.post('/remotes/packages', function (req, res) {
       res.send(depsPackages);
     })
     .catch((e) => {
-      console.log(e);
+      handlerError(res, e);
     })
 });
 
@@ -67,11 +74,10 @@ router.post('/remotes/stats', function (req, res) {
       res.send(remoteStats);
     })
     .catch((e) => {
-      console.log(e);
+      handlerError(res, e);
     })
 });
 
-
 router.get('/config', function (req, res) {
   return Promise.resolve()
     .then(() => {
@@ -81,25 +87,38 @@ router.get('/config', function (req, res) {
       res.send(customConfig);
     })
     .catch((e) => {
-      console.log(e);
+      handlerError(res, e);
     })
 });
 
-
-
 router.post('/config', function (req, res) {
   return Promise.resolve()
     .then(() => {
       return configUtils.global.generateCustomConfig(req.body);
     })
     .then(() => {
+      res.status(200);
       res.send({ status: 'OK'})
     })
     .catch((e) => {
-      console.log(e);
+      handlerError(res, e);
     })
 });
 
+router.post('/package-init', function (req, res) {
+  return Promise.resolve()
+    .then(() => {
+      const params = req.body.params;
+      return cliUtils.package.generateExternal(params);
+    })
+    .then(() => {
+      res.status(200);
+      res.send({ status: 'OK'})
+    })
+    .catch((e) => {
+      handlerError(res, e);
+    })
+});
 
 // Export API routes
 module.exports = router;

package/scripts/app/server.js

@@ -27,6 +27,8 @@ app.listen(app.get('port'), () => {
   if (prod) {
     if (stats) {
       open('http://localhost:3000/stats.html');
+    } else if (packageInit) {
+      open('http://localhost:3000/package-init.html');
     } else {
       open('http://localhost:3000');
     }

package/scripts/csdr/cli/cli-utils.js

@@ -1,32 +1,4 @@
 'use strict';
 
-// LOCAL
-const tools = require('../../../scripts/utils/tools');
-
-// INNER MODULES
-const innerApp = require('./app');
-const innerPackage = require('./package');
-
-// FETCH ARGS
-const args = tools.getArgs();
-
-
-module.exports.run = () => {
-
-  tools.logBigTitle('CSDR CLI');
-
-  return Promise.resolve()
-    .then(() => {
-      if (args.app) {
-        return innerApp.generate();
-
-      } else if (args.pkg) {
-        return innerPackage.generate();
-      }
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-
-}
+// INNER MODULES RE-EXPORTS
+module.exports.package = require('./package');

package/scripts/csdr/cli/constants.js

@@ -5,12 +5,7 @@ const path = require('path');
 module.exports.TARGET_ROOT_PATH = path.join(process.cwd(), 'packages');
 module.exports.TARGET_ROOT_REMOTES_PATH = path.join(process.cwd(), 'remotes');
 module.exports.SKELETONS_ROOT_PATH = path.join(__dirname, 'skeletons', 'package');
-module.exports.FRONTEND_SKELETON_EUI10_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-eui10');
-module.exports.FRONTEND_SKELETON_EUI13_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-eui13');
 module.exports.FRONTEND_SKELETON_EUI15_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-eui15');
-module.exports.FRONTEND_SKELETON_REMOTE_EUI10_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-remote-eui10');
-module.exports.FRONTEND_SKELETON_REMOTE_EUI15_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-remote-eui15');
-module.exports.FRONTEND_OPTION_ROUTE_PATH = path.join(this.SKELETONS_ROOT_PATH, 'frontend-option-route');
 module.exports.BACKEND_SKELETON_PATH = path.join(this.SKELETONS_ROOT_PATH, 'backend');
 module.exports.VIRTUAL_REMOTE_SKELETON_ROOT_PATH = path.join(__dirname, 'skeletons', 'virtual-remote');
 
@@ -24,8 +19,6 @@ module.exports.CONFIG_OPTIONS = {
     REMOTE: 'remote'
   },
   pkgFrontendVersion: {
-    EUI10: '10',
-    EUI13: '13',
     EUI15: '15',
   }
 }
@@ -33,14 +26,10 @@ module.exports.CONFIG_OPTIONS = {
 module.exports.DEFAULT_CONFIG = {
   pkgType: this.CONFIG_OPTIONS.pkgType.FRONTEND,
   pkgFrontendType: this.CONFIG_OPTIONS.pkgFrontendType.DEFAULT,
-  pkgFrontendVersion: this.CONFIG_OPTIONS.pkgFrontendVersion.EUI10,
+  pkgFrontendVersion: this.CONFIG_OPTIONS.pkgFrontendVersion.EUI15,
   pkgName: 'my-package',
   pkgScope: '@zzz',
-  isRouteModule: false,
   isCsdrRepo: true,
-  isEnvTargetRemote: true,
-  isVirtualRemote: true,
-  isFullVirtualRemote: true,
   externalRepoName: null,
   pkgGroupId: 'eu.europa.ec.cc'
 };

package/scripts/csdr/cli/package-build-backend.js

@@ -5,6 +5,7 @@ const path = require('path');
 
 // LOCAL
 const tools = require('../../../scripts/utils/tools');
+const configUtils = require('../config/config-utils');
 
 // CONSTANTS
 const constants = require('./constants');
@@ -57,6 +58,23 @@ module.exports.generate = (name, scope, groupId) => {
       return tools.move(path.join(targetPath, 'gitignore_TO_REPLACE'), path.join(targetPath, '.gitignore'));
     })
 
+    .then(() => {
+      const pkg = {
+        name: artifactId,
+        repoName: `${artifactId}.git`
+      };
+
+      // ADDING CONFIG ENTRY - specific csdr-remotes as of v15+
+      tools.logInfo('Adding CSDR config entry');
+      configUtils.register.registerCsdrPackage(
+        pkg,
+        scope, name, null,
+        false,
+        null,
+        true
+      );
+    })
+
     .then(() => {
       tools.logSuccess();
     })

package/scripts/csdr/cli/package-build-frontend.js

@@ -12,31 +12,6 @@ const initUtils = require('../init/init-utils');
 const constants = require('./constants');
 
 
-
-
-const init = (frontendType, rootPackagePath, targetPath, isFullVirtualRemote) => {
-  return Promise.resolve()
-
-    // CHECKING presence of UI package supporting the remote
-    .then(() => {
-      if (frontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE && !isFullVirtualRemote && !tools.isDirExists(rootPackagePath)) {
-        tools.logError(`${rootPackagePath} NOT FOUND, you must mount the root package ui before creating the remote`);
-        throw new Error('ROOT_PACKAGE_NOT_FOUND');
-      }
-    })
-
-    // CLEANING TARGET
-    .then(() => {
-      tools.logInfo('Cleaning target');
-      return tools.rimraf(targetPath + '/**/*');
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
 const replaceExtensions = (targetPath) => {
   return Promise.resolve()
 
@@ -71,76 +46,61 @@ const replaceContent = (targetPath, name, scope, fullName) => {
 
 
 
-const generateVirtualRemote = ({fullName, targetPath, rootPackagePath, pkg, args = constants.DEFAULT_CONFIG}) => {
+const generateRemote = (args = constants.DEFAULT_CONFIG) => {
+
+  const targetPath = path.join(constants.TARGET_ROOT_REMOTES_PATH, args.fullName);
 
   tools.logInfo('Generate virtual remote');
-  console.log(fullName);
+  console.log(args);
+  tools.logInfo('In target path');
   console.log(targetPath);
-  console.log(rootPackagePath);
-  console.log(pkg);
 
-  const remoteTargetPath = path.join(process.cwd(), 'packages', 'csdr-remotes-config', 'assets', fullName);
+  const remoteConfigTargetPath = path.join(process.cwd(), 'packages', 'csdr-remotes-config', 'assets', args.fullName);
 
   return Promise.resolve()
     // INIT and cleanup
     .then(() => {
-      return init(args.pkgFrontendType, rootPackagePath, targetPath, args.isFullVirtualRemote);
+      tools.logInfo('Cleaning target');
+      return tools.rimraf(targetPath + '/**/*');
     })
 
     // COPY FIRST THE REMOTE SKELETON TO TARGET
     .then(() => {
-      tools.logInfo('Copying skeleton to target');
-
-      if (!args.isFullVirtualRemote) {
-        // for the moment the virtual remotes are only activated for v15+
-        if (args.pkgFrontendVersion == constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15) {
-          tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI15_PATH, targetPath, true);
-        } else if (args.pkgFrontendVersion == constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI10) {
-          tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI10_PATH, targetPath, true);
+      // generating default package entries
+      const pkg = {
+        name: args.fullName,
+        repoName: args.repoName,
+        npmPkgName: args.npmPkgName,
+        paths: {
+          root: targetPath
         }
-
-        // REPLACING PLACEHOLDERS
-        tools.logInfo('Replace sources content');
-        replaceContent(targetPath, args.pkgName, args.pkgScope, fullName);
-
-        // REPLACE EXTENSIONS (package.json, .gitignore as the interfere with build of tools if release without name changes)
-        replaceExtensions(targetPath);
-      }
+      };
 
       // ADDING CONFIG ENTRY - specific csdr-remotes as of v15+
       tools.logInfo('Adding CSDR config entry');
       configUtils.register.registerCsdrPackage(
-        pkg, args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE,
+        pkg,
         args.pkgScope, args.pkgName, args.pkgFrontendVersion,
-        args.isVirtualRemote,
-        args.isFullVirtualRemote
+        true,
+        args.remoteConfig
       );
     })
 
-    // ENV TARGET / a-la-carte specific (always true as of v15+ remotes) - TRANSFER The sources from current remote sources
-    .then(() => {
-      // envTarget remote type specific
-      if (args.isEnvTargetRemote && !args.isFullVirtualRemote) {
-        tools.logInfo('Moving sources from remote to root package for envTarget remote type');
-        return tools.move(path.join(targetPath, 'src'), path.join(rootPackagePath, 'assets', 'remote-sources'));
-      }
-    })
-
     // CLEANING REMOTES CONFIG ENTRY
     .then(() => {
       tools.logInfo('Cleaning csdr-remotes-config target entry');
-      return tools.rimraf(remoteTargetPath + '/**/*');
+      return tools.rimraf(remoteConfigTargetPath + '/**/*');
     })
 
     // REPLACING CONTENT FOR VIRTUAL REMOTE CONFIG SKELETON
     .then(() => {
       tools.copy(
         path.join(constants.VIRTUAL_REMOTE_SKELETON_ROOT_PATH, `${args.pkgFrontendVersion}.x`),
-        remoteTargetPath
+        remoteConfigTargetPath
       );
 
       tools.logInfo('Replace sources content in csdr-remotes-config target entry');
-      replaceContent(remoteTargetPath, args.pkgName, args.pkgScope, fullName);
+      replaceContent(remoteConfigTargetPath, args.pkgName, args.pkgScope, args.fullName);
     })
 
     // CLEANING REMOTE CURRENT TARGET as this is completetely re-generated by the generateVirtualRemotes() function (same as init)
@@ -150,7 +110,7 @@ const generateVirtualRemote = ({fullName, targetPath, rootPackagePath, pkg, args
 
     // GENERATE THE VIRTUAL REMOTE (as it's dynamically generated, we use here the same fn call as the init)
     .then(() => {
-      return initUtils.remotes.generateVirtualRemote(fullName, false);
+      return initUtils.remotes.generateVirtualRemote(args.fullName, false);
     })
 
     .then(() => {
@@ -165,75 +125,54 @@ const generateVirtualRemote = ({fullName, targetPath, rootPackagePath, pkg, args
 
 
 
-const generateDefault = ({fullName, targetPath, rootPackagePath, pkg, args = constants.DEFAULT_CONFIG}) => {
+const generateDefault = (args = constants.DEFAULT_CONFIG) => {
+
+  const targetPath = path.join(constants.TARGET_ROOT_PATH, args.fullName);
 
   return Promise.resolve()
     // INIT and cleanup
     .then(() => {
-      return init(args.pkgFrontendType, rootPackagePath, targetPath);
+      tools.logInfo('Cleaning target');
+      return tools.rimraf(targetPath + '/**/*');
     })
 
     // COPY TO TARGET
     .then(() => {
       tools.logInfo('Copying skeleton to target');
-      if (args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE) {
-        if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI10) {
-          tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI10_PATH, targetPath, true);
-
-        } else if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15) {
-          tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI10_PATH, targetPath, true);
-          tools.copydir(constants.FRONTEND_SKELETON_REMOTE_EUI15_PATH, targetPath, true);
-        }
-
-      } else {
-        if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI10) {
-          tools.copydir(constants.FRONTEND_SKELETON_EUI10_PATH, targetPath, true);
-
-        } else if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI13) {
-          tools.copydir(constants.FRONTEND_SKELETON_EUI10_PATH, targetPath, true);
-          tools.copydir(constants.FRONTEND_SKELETON_EUI13_PATH, targetPath, true);
-
-        } else if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15) {
-          tools.copydir(constants.FRONTEND_SKELETON_EUI10_PATH, targetPath, true);
-          tools.copydir(constants.FRONTEND_SKELETON_EUI15_PATH, targetPath, true);
-        }
-      }
-
-      if (args.isRouteModule) {
-        tools.copydir(constants.FRONTEND_OPTION_ROUTE_PATH, targetPath, true);
+      if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15) {
+        tools.copydir(constants.FRONTEND_SKELETON_EUI15_PATH, targetPath, true);
       }
 
       // REPLACING PLACEHOLDERS
       tools.logInfo('Replace sources content');
-      replaceContent(targetPath, args.pkgName, args.pkgScope, fullName);
+      replaceContent(targetPath, args.pkgName, args.pkgScope, args.fullName);
 
       // REGISTERING PACKAGE in CSDR GLOBAL CONFIG
       tools.logInfo('Registering package');
 
+      // generating default package entries
+      const pkg = {
+        name: args.fullName,
+        repoName: args.repoName,
+        npmPkgName: args.npmPkgName,
+        paths: {
+          root: targetPath
+        }
+      };
+
       tools.logInfo('Adding CSDR config entry');
       configUtils.register.registerCsdrPackage(
-        pkg, args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE,
-        args.pkgScope, args.pkgName, args.pkgFrontendVersion
+        pkg, args.pkgScope, args.pkgName, args.pkgFrontendVersion
       );
 
-      if (args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.DEFAULT) {
-        configUtils.angular.registerAngularPackage(pkg);
-        configUtils.angular.registerModulePaths(pkg);
-      }
+      configUtils.angular.registerAngularPackage(pkg);
+      configUtils.angular.registerModulePaths(pkg);
 
       replaceExtensions(targetPath);
     })
 
-    .then(() => {
-      if (args.isEnvTargetRemote) {
-        tools.logInfo('Moving sources from remote to root package for envTarget remote type');
-        return tools.move(path.join(targetPath, 'src'), path.join(rootPackagePath, 'assets', 'remote-sources'));
-      }
-    })
-
     .then(() => {
       if (
-        args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.DEFAULT &&
         args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15
        ) {
         return tools.remove(path.join(targetPath, 'tslint.json'));
@@ -253,61 +192,12 @@ const generateDefault = ({fullName, targetPath, rootPackagePath, pkg, args = con
 module.exports.generate = (args = constants.DEFAULT_CONFIG) => {
   tools.logTitle('Generating frontend package');
 
-  let npmPkgName, repoName;
-  let fullName = args.pkgScope.substring(1) + '-' + args.pkgName;
-
-  if (args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.DEFAULT) {
-    fullName += '-ui';
-    npmPkgName = `${args.pkgScope}/${args.pkgName}`;
-
-  } else if (args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE) {
-    if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI10) {
-      fullName += '-eui10-remote-el-ui';
-      npmPkgName = `${args.pkgScope}/${args.pkgName}-eui10-remote-el`;
-
-    } else if (args.pkgFrontendVersion === constants.CONFIG_OPTIONS.pkgFrontendVersion.EUI15) {
-      fullName += '-eui15-remote-el-ui';
-      npmPkgName = `${args.pkgScope}/${args.pkgName}-eui15-remote-el`;
-    }
-  }
-
-  // generating default git repo
-  if (args.isCsdrRepo) {
-    repoName = `${fullName}.git`;
-  } else {
-    repoName = `${args.externalRepoName}/${fullName}.git`;
-  }
-
-  // generating target paths
-  let targetPath, rootPackagePath;
-
-  if (args.isVirtualRemote) {
-    // virtual remotes are generated into /remotes root folder
-    targetPath = path.join(constants.TARGET_ROOT_REMOTES_PATH, fullName);
-  } else {
-    // normal remote / packages are generated into /packages root folder
-    targetPath = path.join(constants.TARGET_ROOT_PATH, fullName);
-  }
-
-  // generating rootPackagePath : the linked package with the envTarget/a-la-carte remote setup (now default)
-  rootPackagePath = path.join(constants.TARGET_ROOT_PATH, `${args.pkgScope.substring(1)}-${args.pkgName}-ui`);
-
-  // generating default package entries
-  const pkg = {
-    name: fullName,
-    repoName: repoName,
-    npmPkgName: npmPkgName,
-    paths: {
-      root: rootPackagePath
-    }
-  };
-
   return Promise.resolve()
     .then(() => {
-      if (args.isVirtualRemote) {
-        return generateVirtualRemote({fullName, targetPath, rootPackagePath, pkg, args});
+      if (args.pkgFrontendType === constants.CONFIG_OPTIONS.pkgFrontendType.REMOTE) {
+        return generateRemote(args);
       } else {
-        return generateDefault({fullName, targetPath, rootPackagePath, pkg, args});
+        return generateDefault(args);
       }
     })
 
@@ -315,10 +205,3 @@ module.exports.generate = (args = constants.DEFAULT_CONFIG) => {
       throw e;
     })
 }
-
-
-
-
-
-
-