Merge branch 'master' into more-registry-domain-ts

Author: ricardo-devis-agullo

src/cli/domain/handle-dependencies/ensure-compiler-is-declared-as-devDependency.js renamed to src/cli/domain/handle-dependencies/ensure-compiler-is-declared-as-devDependency.ts

@@ -1,8 +1,13 @@
-'use strict';
+import strings from '../../../resources';
 
-const strings = require('../../../resources').default;
-
-module.exports = (options, cb) => {
+export default function ensureCompilerIsDeclaredAsDevDependency(
+  options: {
+    componentPath: string;
+    pkg: { devDependencies: Dictionary<string> };
+    template: string;
+  },
+  cb: Callback<string, string>
+): void {
   const { componentPath, pkg, template } = options;
   const compilerDep = `${template}-compiler`;
   const isOk = pkg.devDependencies[compilerDep];
@@ -12,4 +17,4 @@ module.exports = (options, cb) => {
     : strings.errors.cli.TEMPLATE_DEP_MISSING(template, componentPath);
 
   cb(err, compilerDep);
-};
+}

src/cli/domain/handle-dependencies/get-compiler.js renamed to src/cli/domain/handle-dependencies/get-compiler.ts

@@ -1,11 +1,18 @@
-'use strict';
+import path from 'path';
 
-const path = require('path');
+import cleanRequire from '../../../utils/clean-require';
+import { Logger } from '../../logger';
+import installCompiler from './install-compiler';
 
-const cleanRequire = require('../../../utils/clean-require').default;
-const installCompiler = require('./install-compiler');
-
-module.exports = (options, cb) => {
+export default function getCompiler(
+  options: {
+    compilerDep: string;
+    componentPath: string;
+    logger: Logger;
+    pkg: { name: string; devDependencies: Dictionary<string> };
+  },
+  cb: Callback<string, string | number>
+): void {
   const { compilerDep, componentPath, logger, pkg } = options;
   const compilerPath = path.join(componentPath, 'node_modules', compilerDep);
   const compiler = cleanRequire(compilerPath, { justTry: true });
@@ -28,4 +35,4 @@ module.exports = (options, cb) => {
   };
 
   installCompiler(installOptions, cb);
-};
+}

src/cli/domain/handle-dependencies/get-missing-dependencies.ts

@@ -3,7 +3,7 @@ import moduleExists from '../../../utils/module-exists';
 
 export default function getMissingDependencies(
   dependencies: Record<string, string> = {}
-) {
+): string[] {
   const missing: string[] = [];
 
   Object.entries(dependencies).forEach(([dependency, version]) => {

src/cli/domain/handle-dependencies/index.js

@@ -0,0 +1,137 @@
+import async from 'async';
+import coreModules from 'builtin-modules';
+import fs from 'fs-extra';
+import path from 'path';
+import _ from 'lodash';
+
+import ensureCompilerIsDeclaredAsDevDependency from './ensure-compiler-is-declared-as-devDependency';
+import getCompiler from './get-compiler';
+import installMissingDependencies from './install-missing-dependencies';
+import linkMissingDependencies from './link-missing-dependencies';
+import isTemplateLegacy from '../../../utils/is-template-legacy';
+import strings from '../../../resources';
+import { Logger } from '../../logger';
+import { Component } from '../../../types';
+
+const getComponentPackageJson = (componentPath: string, cb: Callback<any>) =>
+  fs.readJson(path.join(componentPath, 'package.json'), cb);
+
+export default function handleDependencies(
+  options: {
+    components: string[];
+    logger: Logger;
+    useComponentDependencies?: boolean;
+  },
+  callback: Callback<
+    {
+      modules: string[];
+      templates: Array<(...args: unknown[]) => unknown>;
+    },
+    string
+  >
+): void {
+  const { components, logger, useComponentDependencies } = options;
+
+  const dependencies: Dictionary<string> = {};
+  const addDependencies = (componentDependencies: Dictionary<string>) =>
+    _.each(componentDependencies || {}, (version, dependency) => {
+      dependencies[dependency] = version;
+    });
+
+  const templates: Dictionary<(...args: unknown[]) => unknown> = {};
+  const addTemplate = (
+    templateName: string,
+    template: (...args: unknown[]) => unknown
+  ) => {
+    templates[templateName] = template;
+  };
+
+  const setupComponentDependencies = (
+    componentPath: string,
+    done: (err?: unknown) => void
+  ) =>
+    async.waterfall(
+      [
+        (cb: Callback<Component>) => getComponentPackageJson(componentPath, cb),
+        (
+          pkg: Component,
+          cb: Callback<{
+            componentPath: string;
+            logger: Logger;
+            pkg: Component;
+            template: string;
+          }>
+        ) => {
+          addDependencies(pkg.dependencies);
+
+          const template = pkg.oc.files.template.type;
+          if (isTemplateLegacy(template)) {
+            return done();
+          }
+
+          cb(null, { componentPath, logger, pkg, template });
+        },
+
+        (
+          options: {
+            componentPath: string;
+            logger: Logger;
+            pkg: Component;
+            template: string;
+          },
+          cb: any
+        ) =>
+          ensureCompilerIsDeclaredAsDevDependency(options, (err, compilerDep) =>
+            cb(err, _.extend(options, { compilerDep }))
+          ),
+
+        (
+          options: {
+            componentPath: string;
+            logger: Logger;
+            pkg: Component;
+            template: string;
+            compilerDep: string;
+          },
+          cb: any
+        ) =>
+          getCompiler(options, (err, compiler) =>
+            cb(err, _.extend(options, { compiler }))
+          ),
+
+        (
+          options: {
+            compiler: (...args: unknown[]) => unknown;
+            template: string;
+          },
+          cb: any
+        ) => {
+          const { compiler, template } = options;
+          addTemplate(template, compiler);
+          cb();
+        }
+      ],
+      done
+    );
+
+  logger.warn(strings.messages.cli.CHECKING_DEPENDENCIES);
+  async.eachSeries(components, setupComponentDependencies, err => {
+    if (err) {
+      return callback(err as any, undefined as any);
+    }
+
+    const result = {
+      modules: _.union(coreModules, Object.keys(dependencies)).sort(),
+      templates: Object.values(templates)
+    };
+    const options = { dependencies, logger };
+    if (useComponentDependencies) {
+      // @ts-ignore
+      options.componentPath = components[0];
+      return linkMissingDependencies(options as any, err =>
+        callback(err, result)
+      );
+    }
+    installMissingDependencies(options, err => callback(err, result));
+  });
+}

src/cli/domain/handle-dependencies/index.ts

@@ -1,11 +1,18 @@
-'use strict';
+import cleanRequire from '../../../utils/clean-require';
+import isTemplateValid from '../../../utils/is-template-valid';
+import * as npm from '../../../utils/npm-utils';
+import strings from '../../../resources/index';
+import { Logger } from '../../logger';
 
-const cleanRequire = require('../../../utils/clean-require').default;
-const isTemplateValid = require('../../../utils/is-template-valid').default;
-const npm = require('../../../utils/npm-utils');
-const strings = require('../../../resources/index').default;
-
-module.exports = (options, cb) => {
+export default function installCompiler(
+  options: {
+    compilerPath: string;
+    componentPath: string;
+    dependency: string;
+    logger: Logger;
+  },
+  cb: Callback<string, string | number>
+): void {
   const { compilerPath, componentPath, dependency, logger } = options;
 
   logger.warn(strings.messages.cli.INSTALLING_DEPS(dependency), true);
@@ -24,4 +31,4 @@ module.exports = (options, cb) => {
     const errorMsg = 'There was a problem while installing the compiler';
     cb(!err && isOk ? null : errorMsg, compiler);
   });
-};
+}

src/cli/domain/handle-dependencies/install-compiler.js renamed to src/cli/domain/handle-dependencies/install-compiler.ts

@@ -1,18 +1,19 @@
-'use strict';
+import path from 'path';
 
-const path = require('path');
-const _ = require('lodash');
+import getMissingDependencies from './get-missing-dependencies';
+import * as npm from '../../../utils/npm-utils';
+import strings from '../../../resources/index';
+import { Logger } from '../../logger';
 
-const getMissingDependencies = require('./get-missing-dependencies').default;
-const npm = require('../../../utils/npm-utils');
-const strings = require('../../../resources/index').default;
-
-module.exports = (options, callback) => {
+export default function installMissingDependencies(
+  options: { dependencies: Dictionary<string>; logger: Logger },
+  callback: (err: string | null) => void
+): void {
   const { dependencies, logger } = options;
 
   const missing = getMissingDependencies(dependencies);
 
-  if (_.isEmpty(missing)) {
+  if (!missing.length) {
     return callback(null);
   }
 
@@ -26,11 +27,12 @@ module.exports = (options, callback) => {
   };
 
   npm.installDependencies(npmOptions, err => {
-    if (err || !_.isEmpty(getMissingDependencies(dependencies))) {
+    if (err || getMissingDependencies(dependencies).length) {
       logger.err('FAIL');
       return callback(strings.errors.cli.DEPENDENCIES_INSTALL_FAIL);
     }
+
     logger.ok('OK');
     callback(null);
   });
-};
+}