Callback to promises

package.json

@@ -53,6 +53,7 @@
     "@types/errorhandler": "1.5.0",
     "@types/express": "4.17.13",
     "@types/fs-extra": "9.0.13",
+    "@types/got": "^9.6.12",
     "@types/livereload": "0.9.1",
     "@types/lodash": "4.14.177",
     "@types/morgan": "1.9.3",
@@ -78,6 +79,7 @@
     "minimist": "1.2.5",
     "mocha": "9.1.3",
     "node-emoji": "1.11.0",
+    "p-limit": "^3.1.0",
     "prettier": "2.5.0",
     "rimraf": "3.0.2",
     "semver-sort": "0.0.4",
@@ -98,9 +100,11 @@
     "dependency-graph": "0.11.0",
     "errorhandler": "1.5.1",
     "express": "4.17.1",
+    "express-promise-router": "^4.1.0",
     "form-data": "4.0.0",
     "fs-extra": "10.0.0",
     "getport": "0.1.0",
+    "got": "^11.8.2",
     "livereload": "0.9.3",
     "lodash": "4.17.21",
     "minimal-request": "3.0.0",
@@ -129,6 +133,7 @@
     "serialize-error": "8.1.0",
     "targz": "1.0.1",
     "try-require": "1.2.1",
+    "universalify": "^2.0.0",
     "yargs": "17.3.0"
   }
 }

src/cli/domain/clean.ts

@@ -1,31 +1,21 @@
-import async from 'async';
 import fs from 'fs-extra';
 import makeGetComponentsByDir from './get-components-by-dir';
 import path from 'path';
 
 const getComponentsByDir = makeGetComponentsByDir();
 
-export function fetchList(
-  dirPath: string,
-  callback: (err: Error | null, data: string[]) => void
-): void {
-  return getComponentsByDir(dirPath, (err, list) => {
-    if (err) return (callback as any)(err);
-    if (list.length === 0) return callback(null, []);
+export async function fetchList(dirPath: string): Promise<string[]> {
+  const list = await getComponentsByDir(dirPath);
 
-    const toRemove = list.map(folder => path.join(folder, 'node_modules'));
-    const folderExists = (
-      folder: string,
-      cb: (err: Error | null, data: boolean) => void
-    ) => fs.exists(folder, exists => cb(null, exists));
+  if (list.length === 0) return [];
 
-    async.filterSeries(toRemove, folderExists, callback as any);
-  });
+  const toRemove = list.map(folder => path.join(folder, 'node_modules'));
+
+  return toRemove.filter(fs.existsSync);
 }
 
-export function remove(
-  list: string[],
-  callback: (err: Error | null, data: string) => void
-): void {
-  return async.eachSeries(list, fs.remove, callback as any);
+export async function remove(list: string[]): Promise<void> {
+  for (const item of list) {
+    await fs.remove(item);
+  }
 }

src/cli/domain/get-components-by-dir.ts

@@ -3,23 +3,11 @@ import path from 'path';
 import { Component } from '../../types';
 
 export default function getComponentsByDir() {
-  return (
+  return async (
     componentsDir: string,
-    componentsToRunOrCb:
-      | string[]
-      | ((err: Error | null, data: string[]) => void),
-    callbackMaybe?: (err: Error | null, data: string[]) => void
-  ): void => {
-    const componentsToRun =
-      typeof componentsToRunOrCb === 'function'
-        ? undefined
-        : componentsToRunOrCb;
-    const callback =
-      typeof componentsToRunOrCb === 'function'
-        ? componentsToRunOrCb
-        : callbackMaybe!;
-
-    const isOcComponent = function (file: string) {
+    componentsToRun?: string[]
+  ): Promise<string[]> => {
+    const isOcComponent = (file: string) => {
       const filePath = path.resolve(componentsDir, file);
       const packagePath = path.join(filePath, 'package.json');
       let content: Component;
@@ -39,23 +27,21 @@ export default function getComponentsByDir() {
       return typeof packagedProperty === 'undefined';
     };
 
-    let dirContent: string[];
-
     try {
-      dirContent = fs.readdirSync(componentsDir);
+      let dirContent = await fs.readdir(componentsDir);
       if (componentsToRun) {
         dirContent = dirContent.filter(content =>
           componentsToRun.includes(content)
         );
       }
-    } catch (err) {
-      return callback(null, []);
-    }
 
-    const components = dirContent
-      .filter(isOcComponent)
-      .map(component => path.resolve(componentsDir, component));
+      const components = dirContent
+        .filter(isOcComponent)
+        .map(component => path.resolve(componentsDir, component));
 
-    callback(null, components);
+      return components;
+    } catch (err) {
+      return [];
+    }
   };
 }

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

@@ -1,21 +1,17 @@
 import strings from '../../../resources';
 import { Component } from '../../../types';
 
-export default function ensureCompilerIsDeclaredAsDevDependency(
-  options: {
-    componentPath: string;
-    pkg: Component;
-    template: string;
-  },
-  cb: (err: string | null, data: string) => void
-): void {
+export default function ensureCompilerIsDeclaredAsDevDependency(options: {
+  componentPath: string;
+  pkg: Component;
+  template: string;
+}): string {
   const { componentPath, pkg, template } = options;
   const compilerDep = `${template}-compiler`;
   const isOk = pkg.devDependencies?.[compilerDep];
 
-  const err = isOk
-    ? null
-    : strings.errors.cli.TEMPLATE_DEP_MISSING(template, componentPath);
+  if (!isOk)
+    throw strings.errors.cli.TEMPLATE_DEP_MISSING(template, componentPath);
 
-  cb(err, compilerDep);
+  return compilerDep;
 }

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

@@ -5,21 +5,18 @@ import cleanRequire from '../../../utils/clean-require';
 import { Logger } from '../../logger';
 import installCompiler from './install-compiler';
 
-export default function getCompiler(
-  options: {
-    compilerDep: string;
-    componentPath: string;
-    logger: Logger;
-    pkg: { devDependencies: Record<string, string> };
-  },
-  cb: (err: string | number | null, data: Template) => void
-): void {
+export default function getCompiler(options: {
+  compilerDep: string;
+  componentPath: string;
+  logger: Logger;
+  pkg: { devDependencies: Record<string, string> };
+}): Promise<Template> {
   const { compilerDep, componentPath, logger, pkg } = options;
   const compilerPath = path.join(componentPath, 'node_modules', compilerDep);
   const compiler = cleanRequire<Template>(compilerPath, { justTry: true });
 
   if (compiler) {
-    return cb(null, compiler);
+    return Promise.resolve(compiler);
   }
 
   let dependency = compilerDep;
@@ -34,5 +31,5 @@ export default function getCompiler(
     logger
   };
 
-  installCompiler(installOptions, cb);
+  return installCompiler(installOptions);
 }

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

@@ -1,4 +1,3 @@
-import async from 'async';
 import coreModules from 'builtin-modules';
 import fs from 'fs-extra';
 import path from 'path';
@@ -10,31 +9,23 @@ 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';
+import { Component, Template } from '../../../types';
 
-const getComponentPackageJson = (
-  componentPath: string,
-  cb: (err: Error | null, data: Component) => void
-) => fs.readJson(path.join(componentPath, 'package.json'), cb);
+const getComponentPackageJson = (componentPath: string): Promise<Component> =>
+  fs.readJson(path.join(componentPath, 'package.json'));
 
 const union = (a: ReadonlyArray<string>, b: ReadonlyArray<string>) => [
   ...new Set([...a, ...b])
 ];
 
-export default function handleDependencies(
-  options: {
-    components: string[];
-    logger: Logger;
-    useComponentDependencies?: boolean;
-  },
-  callback: (
-    err: string | null,
-    data: {
-      modules: string[];
-      templates: Array<(...args: unknown[]) => unknown>;
-    }
-  ) => void
-): void {
+export default async function handleDependencies(options: {
+  components: string[];
+  logger: Logger;
+  useComponentDependencies?: boolean;
+}): Promise<{
+  modules: string[];
+  templates: Array<Template>;
+}> {
   const { components, logger, useComponentDependencies } = options;
 
   const dependencies: Record<string, string> = {};
@@ -45,103 +36,58 @@ export default function handleDependencies(
       }
     );
 
-  const templates: Record<string, (...args: unknown[]) => unknown> = {};
-  const addTemplate = (
-    templateName: string,
-    template: (...args: unknown[]) => unknown
-  ) => {
+  const templates: Record<string, Template> = {};
+  const addTemplate = (templateName: string, template: Template) => {
     templates[templateName] = template;
   };
 
-  const setupComponentDependencies = (
-    componentPath: string,
-    done: (err?: unknown) => void
-  ) =>
-    async.waterfall(
-      [
-        (cb: (err: Error | null, data: Component) => void) =>
-          getComponentPackageJson(componentPath, cb),
-        (
-          pkg: Component,
-          cb: (
-            err: Error | null,
-            data: {
-              componentPath: string;
-              logger: Logger;
-              pkg: Component;
-              template: string;
-            }
-          ) => void
-        ) => {
-          addDependencies(pkg.dependencies);
+  const setupComponentDependencies = async (
+    componentPath: string
+  ): Promise<void> => {
+    const pkg = await getComponentPackageJson(componentPath);
+    addDependencies(pkg.dependencies);
 
-          const template = pkg.oc.files.template.type;
-          if (isTemplateLegacy(template)) {
-            return done();
-          }
+    const template = pkg.oc.files.template.type;
+    if (isTemplateLegacy(template)) {
+      return;
+    }
 
-          cb(null, { componentPath, logger, pkg, template });
-        },
+    const compilerDep = ensureCompilerIsDeclaredAsDevDependency({
+      componentPath,
+      pkg,
+      template
+    });
+    Object.assign(options, { compilerDep });
 
-        (
-          options: {
-            componentPath: string;
-            logger: Logger;
-            pkg: Component;
-            template: string;
-          },
-          cb: any
-        ) =>
-          ensureCompilerIsDeclaredAsDevDependency(options, (err, compilerDep) =>
-            cb(err, Object.assign(options, { compilerDep }))
-          ),
+    const compiler = await getCompiler({
+      compilerDep,
+      componentPath,
+      logger,
+      pkg: pkg as { devDependencies: Record<string, string> }
+    });
+    Object.assign(options, { compiler });
+    addTemplate(template, compiler);
+  };
 
-        (
-          options: {
-            componentPath: string;
-            logger: Logger;
-            pkg: Component & { devDependencies: Record<string, string> };
-            template: string;
-            compilerDep: string;
-          },
-          cb: any
-        ) =>
-          getCompiler(options, (err, compiler) =>
-            cb(err, Object.assign(options, { compiler }))
-          ),
+  logger.warn(strings.messages.cli.CHECKING_DEPENDENCIES);
 
-        (
-          options: {
-            compiler: (...args: unknown[]) => unknown;
-            template: string;
-          },
-          cb: any
-        ) => {
-          const { compiler, template } = options;
-          addTemplate(template, compiler);
-          cb();
-        }
-      ],
-      done
-    );
+  for (const component of components) {
+    await setupComponentDependencies(component);
+  }
 
-  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)
+  };
+  if (useComponentDependencies) {
+    linkMissingDependencies({
+      componentPath: components[0],
+      dependencies,
+      logger
+    });
+    return result;
+  }
 
-    const result = {
-      modules: union(coreModules, Object.keys(dependencies)).sort(),
-      templates: Object.values(templates)
-    };
-    const options = { dependencies, logger };
-    if (useComponentDependencies) {
-      return linkMissingDependencies(
-        { ...options, componentPath: components[0] },
-        err => callback(err, result)
-      );
-    }
-    installMissingDependencies(options, err => callback(err, result));
-  });
+  await installMissingDependencies({ dependencies, logger });
+  return result;
 }