oc 0.49.7 → 0.49.8

package/src/cli/facade/dev.ts

@@ -1,9 +1,9 @@
-import async from 'async';
 import colors from 'colors/safe';
-import getPort from 'getport';
+import getPortCb from 'getport';
 import livereload from 'livereload';
 import path from 'path';
-import _ from 'lodash';
+import { promisify } from 'util';
+import { fromPromise } from 'universalify';
 
 import getMockedPlugins from '../domain/get-mocked-plugins';
 import handleDependencies from '../domain/handle-dependencies';
@@ -18,70 +18,63 @@ type Registry = ReturnType<typeof oc.Registry>;
 const cliMessages = strings.messages.cli;
 const cliErrors = strings.errors.cli;
 
-const dev =
-  ({ local, logger }: { logger: Logger; local: Local }) =>
-  (
-    opts: {
+const delay = (time = 0) => new Promise(res => setTimeout(res, time));
+const getPort = promisify(getPortCb);
+
+const dev = ({ local, logger }: { logger: Logger; local: Local }) =>
+  fromPromise(
+    async (opts: {
       prefix: string;
       dirPath: string;
       port?: number;
       baseUrl: string;
       fallbackRegistryUrl: string;
       hotReloading?: boolean;
-      components: string[];
+      components?: string[];
       watch?: boolean;
       verbose?: boolean;
       production?: boolean;
-    },
-    callback: (err: Error | string | null, data: Registry) => void
-  ): void => {
-    const componentsDir = opts.dirPath;
-    const port = opts.port || 3000;
-    const baseUrl = opts.baseUrl || `http://localhost:${port}/`;
-    const fallbackRegistryUrl = opts.fallbackRegistryUrl;
-    const hotReloading =
-      typeof opts.hotReloading === 'undefined' ? true : opts.hotReloading;
-    const optWatch = typeof opts.watch === 'undefined' ? true : opts.watch;
-    let packaging = false;
-
-    const watchForChanges = function (
-      {
-        components,
-        refreshLiveReload
-      }: { components: string[]; refreshLiveReload: boolean },
-      cb: any
-    ) {
-      watch(components, componentsDir, (err, changedFile, componentDir) => {
-        if (err) {
-          logger.err(strings.errors.generic(String(err)));
-        } else {
-          logger.warn(cliMessages.CHANGES_DETECTED(changedFile));
-          if (!hotReloading) {
-            logger.warn(cliMessages.HOT_RELOADING_DISABLED);
-          } else if (!componentDir) {
-            cb(components, refreshLiveReload);
+    }): Promise<Registry> => {
+      const componentsDir = opts.dirPath;
+      const port = opts.port || 3000;
+      const baseUrl = opts.baseUrl || `http://localhost:${port}/`;
+      const fallbackRegistryUrl = opts.fallbackRegistryUrl;
+      const hotReloading =
+        typeof opts.hotReloading === 'undefined' ? true : opts.hotReloading;
+      const optWatch = typeof opts.watch === 'undefined' ? true : opts.watch;
+      let packaging = false;
+
+      const watchForChanges = function (
+        {
+          components,
+          refreshLiveReload
+        }: { components: string[]; refreshLiveReload: () => void },
+        cb: any
+      ) {
+        watch(components, componentsDir, (err, changedFile, componentDir) => {
+          if (err) {
+            logger.err(strings.errors.generic(String(err)));
           } else {
-            cb([componentDir], refreshLiveReload);
+            logger.warn(cliMessages.CHANGES_DETECTED(changedFile));
+            if (!hotReloading) {
+              logger.warn(cliMessages.HOT_RELOADING_DISABLED);
+            } else if (!componentDir) {
+              cb(components, refreshLiveReload);
+            } else {
+              cb([componentDir], refreshLiveReload);
+            }
           }
-        }
-      });
-    };
-
-    const packageComponents = (
-      componentsDirs: string[],
-      optCb?: () => void
-    ) => {
-      const cb = typeof optCb === 'function' ? optCb : _.noop;
-
-      let i = 0;
+        });
+      };
 
-      if (!packaging) {
-        packaging = true;
-        logger.warn(cliMessages.PACKAGING_COMPONENTS, false);
+      const packageComponents = async (
+        componentsDirs: string[]
+      ): Promise<void> => {
+        if (!packaging) {
+          packaging = true;
+          logger.warn(cliMessages.PACKAGING_COMPONENTS, false);
 
-        async.eachSeries(
-          componentsDirs,
-          (dir, cb) => {
+          for (const dir of componentsDirs) {
             logger.warn(cliMessages.PACKAGING(dir), false);
             const packageOptions = {
               componentPath: dir,
@@ -90,150 +83,134 @@ const dev =
               production: opts.production
             };
 
-            local.package(packageOptions, err => {
-              if (!err) i++;
-              cb(err);
-            });
-          },
-          error => {
-            if (error) {
+            try {
+              await local.package(packageOptions);
+              packaging = false;
+              logger.ok('OK');
+            } catch (error: any) {
               const errorDescription =
                 error instanceof SyntaxError || !!error.message
                   ? error.message
                   : error;
               logger.err(
-                cliErrors.PACKAGING_FAIL(
-                  componentsDirs[i],
-                  String(errorDescription)
-                )
+                cliErrors.PACKAGING_FAIL(dir, String(errorDescription))
               );
               logger.warn(cliMessages.RETRYING_10_SECONDS);
-              setTimeout(() => {
-                packaging = false;
-                packageComponents(componentsDirs);
-              }, 10000);
-            } else {
+              await delay(10000);
               packaging = false;
-              logger.ok('OK');
-              cb();
+              packageComponents(componentsDirs);
             }
           }
+        }
+      };
+
+      const registerPlugins = (registry: Registry) => {
+        const mockedPlugins = getMockedPlugins(logger, componentsDir);
+        mockedPlugins.forEach(p => registry.register(p));
+
+        registry.on('request', data => {
+          if (data.errorCode === 'PLUGIN_MISSING_FROM_REGISTRY') {
+            logger.err(
+              cliErrors.PLUGIN_MISSING_FROM_REGISTRY(
+                String(data.errorDetails),
+                colors.blue(strings.commands.cli.MOCK_PLUGIN)
+              )
+            );
+          }
+        });
+      };
+
+      logger.warn(cliMessages.SCANNING_COMPONENTS, true);
+      const components = await local.getComponentsByDir(
+        componentsDir,
+        opts.components
+      );
+
+      if (!components.length) {
+        const err = cliErrors.DEV_FAIL(cliErrors.COMPONENTS_NOT_FOUND);
+        logger.err(err);
+        throw err;
+      }
+
+      logger.ok('OK');
+      components.forEach(component =>
+        logger.log(colors.green('├── ') + component)
+      );
+
+      const dependencies = await handleDependencies({
+        components,
+        logger
+      }).catch(err => {
+        logger.err(err);
+        return Promise.reject(err);
+      });
+
+      await packageComponents(components);
+
+      let liveReload: { refresher: () => void; port: number | undefined } = {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        refresher: () => {},
+        port: undefined
+      };
+      if (hotReloading) {
+        const otherPort = await getPort(port + 1).catch(err => {
+          logger.err(String(err));
+          return Promise.reject(err);
+        });
+
+        const liveReloadServer = livereload.createServer({
+          port: otherPort
+        });
+        const refresher = () => liveReloadServer.refresh('/');
+        liveReload = { refresher, port: otherPort };
+      }
+
+      const registry = oc.Registry({
+        baseUrl,
+        prefix: opts.prefix || '',
+        dependencies: dependencies.modules,
+        discovery: true,
+        env: { name: 'local' },
+        fallbackRegistryUrl,
+        hotReloading,
+        liveReloadPort: liveReload.port,
+        local: true,
+        components: opts.components,
+        path: path.resolve(componentsDir),
+        port,
+        templates: dependencies.templates,
+        verbosity: 1
+      });
+
+      registerPlugins(registry);
+
+      logger.warn(cliMessages.REGISTRY_STARTING(baseUrl));
+      if (liveReload.port) {
+        logger.warn(
+          cliMessages.REGISTRY_LIVERELOAD_STARTING(String(liveReload.port))
         );
       }
-    };
-
-    const registerPlugins = (registry: Registry) => {
-      const mockedPlugins = getMockedPlugins(logger, componentsDir);
-      mockedPlugins.forEach(p => registry.register(p));
-
-      registry.on('request', data => {
-        if (data.errorCode === 'PLUGIN_MISSING_FROM_REGISTRY') {
-          logger.err(
-            cliErrors.PLUGIN_MISSING_FROM_REGISTRY(
-              data.errorDetails!,
-              colors.blue(strings.commands.cli.MOCK_PLUGIN)
-            )
+      try {
+        await promisify(registry.start);
+
+        if (optWatch) {
+          watchForChanges(
+            { components, refreshLiveReload: liveReload.refresher },
+            packageComponents
           );
         }
-      });
-    };
-
-    logger.warn(cliMessages.SCANNING_COMPONENTS, true);
-    local.getComponentsByDir(
-      componentsDir,
-      opts.components as any,
-      (err, components) => {
-        if (_.isEmpty(components)) {
-          err = cliErrors.DEV_FAIL(cliErrors.COMPONENTS_NOT_FOUND) as any;
-          callback(err, undefined as any);
-          return logger.err(String(err));
-        }
 
-        logger.ok('OK');
-        _.forEach(components, component =>
-          logger.log(colors.green('├── ') + component)
-        );
+        return registry;
+      } catch (err: any) {
+        if (err.code === 'EADDRINUSE') {
+          // eslint-disable-next-line no-ex-assign
+          err = cliErrors.PORT_IS_BUSY(port) as any;
+        }
 
-        handleDependencies({ components, logger }, (err, dependencies) => {
-          if (err) {
-            logger.err(err);
-            return callback(err, undefined as any);
-          }
-          packageComponents(components, () => {
-            async.waterfall(
-              [
-                (next: any) => {
-                  if (hotReloading) {
-                    getPort(port + 1, (error, otherPort) => {
-                      if (error) {
-                        return next(error);
-                      }
-                      const liveReloadServer = livereload.createServer({
-                        port: otherPort
-                      });
-                      const refresher = () => liveReloadServer.refresh('/');
-                      next(null, { refresher, port: otherPort });
-                    });
-                  } else {
-                    next(null, { refresher: _.noop, port: null });
-                  }
-                }
-              ],
-              (err, liveReload: any) => {
-                if (err) {
-                  logger.err(String(err));
-                  return callback(err, undefined as any);
-                }
-
-                const registry = oc.Registry({
-                  baseUrl,
-                  prefix: opts.prefix || '',
-                  dependencies: dependencies.modules,
-                  discovery: true,
-                  env: { name: 'local' },
-                  fallbackRegistryUrl,
-                  hotReloading,
-                  liveReloadPort: liveReload.port,
-                  local: true,
-                  components: opts.components,
-                  path: path.resolve(componentsDir),
-                  port,
-                  templates: dependencies.templates,
-                  verbosity: 1
-                });
-
-                registerPlugins(registry);
-
-                logger.warn(cliMessages.REGISTRY_STARTING(baseUrl));
-                if (liveReload.port) {
-                  logger.warn(
-                    cliMessages.REGISTRY_LIVERELOAD_STARTING(liveReload.port)
-                  );
-                }
-                registry.start(err => {
-                  if (err) {
-                    if ((err as any).code === 'EADDRINUSE') {
-                      err = cliErrors.PORT_IS_BUSY(port) as any;
-                    }
-
-                    logger.err(String(err));
-                    return callback(err, undefined as any);
-                  }
-
-                  if (optWatch) {
-                    watchForChanges(
-                      { components, refreshLiveReload: liveReload.refresher },
-                      packageComponents
-                    );
-                  }
-                  callback(null, registry);
-                });
-              }
-            );
-          });
-        });
+        logger.err(String(err));
+        throw err;
       }
-    );
-  };
+    }
+  );
 
 export default dev;

package/src/cli/facade/init.ts

@@ -1,52 +1,50 @@
 import path from 'path';
+import { fromPromise } from 'universalify';
 
 import strings from '../../resources/index';
 import { Local } from '../../types';
 import { Logger } from '../logger';
 
-const init =
-  ({ local, logger }: { local: Local; logger: Logger }) =>
-  (
-    opts: {
+const init = ({ local, logger }: { local: Local; logger: Logger }) =>
+  fromPromise(
+    async (opts: {
       componentName: string;
       componentPath: string;
       templateType: string;
-    },
-    callback: (err: Error | null, data: string) => void
-  ): void => {
-    const templateType =
-      typeof opts.templateType === 'undefined'
-        ? 'oc-template-es6'
-        : opts.templateType;
-    const errors = strings.errors.cli;
-    const messages = strings.messages.cli;
-    const componentPath = path.join(process.cwd(), opts.componentPath);
-    const componentName = path.basename(componentPath);
-
-    local.init(
-      {
-        componentName,
-        componentPath,
-        templateType,
-        logger
-      },
-      err => {
-        if (err) {
-          if (err === 'name not valid') {
-            err = errors.NAME_NOT_VALID;
-          }
-
-          if (err === 'template type not valid') {
-            err = errors.TEMPLATE_TYPE_NOT_VALID(templateType);
-          }
-          logger.err(errors.INIT_FAIL(err));
-        } else {
-          logger.log(messages.initSuccess(componentName, componentPath));
+    }): Promise<string> => {
+      const templateType =
+        typeof opts.templateType === 'undefined'
+          ? 'oc-template-es6'
+          : opts.templateType;
+      const errors = strings.errors.cli;
+      const messages = strings.messages.cli;
+      const componentPath = path.join(process.cwd(), opts.componentPath);
+      const componentName = path.basename(componentPath);
+
+      try {
+        await local.init({
+          componentName,
+          componentPath,
+          templateType,
+          logger
+        });
+
+        logger.log(messages.initSuccess(componentName, componentPath));
+
+        return componentName;
+      } catch (err) {
+        let errMsg = String(err);
+
+        if (err === 'name not valid') {
+          errMsg = errors.NAME_NOT_VALID;
+        } else if (err === 'template type not valid') {
+          errMsg = errors.TEMPLATE_TYPE_NOT_VALID(templateType);
         }
 
-        callback(err as any, componentName);
+        logger.err(errors.INIT_FAIL(errMsg));
+        throw err;
       }
-    );
-  };
+    }
+  );
 
 export default init;

package/src/cli/facade/mock.ts

@@ -1,19 +1,20 @@
+import { fromPromise } from 'universalify';
 import strings from '../../resources/index';
 import { Local } from '../../types';
 import { Logger } from '../logger';
 
-const mock =
-  ({ local, logger }: { local: Local; logger: Logger }) =>
-  (
-    opts: { targetType: string; targetValue: string; targetName: string },
-    callback: (err: unknown) => void
-  ): void => {
-    local.mock(opts, err => {
+const mock = ({ local, logger }: { local: Local; logger: Logger }) =>
+  fromPromise(
+    async (opts: {
+      targetType: string;
+      targetValue: string;
+      targetName: string;
+    }): Promise<void> => {
+      await local.mock(opts);
       logger.ok(
         strings.messages.cli.MOCKED_PLUGIN(opts.targetName, opts.targetValue)
       );
-      callback(err);
-    });
-  };
+    }
+  );
 
 export default mock;

package/src/cli/facade/package.ts

@@ -1,69 +1,64 @@
 import strings from '../../resources/index';
 import path from 'path';
+import { fromPromise } from 'universalify';
 import handleDependencies from '../domain/handle-dependencies';
 import { Logger } from '../logger';
 import { Component, Local } from '../../types';
 
-const cliPackage =
-  ({ local, logger }: { local: Local; logger: Logger }) =>
-  (
-    opts: {
+const cliPackage = ({ local, logger }: { local: Local; logger: Logger }) =>
+  fromPromise(
+    async (opts: {
       componentPath: string;
       useComponentDependencies?: boolean;
       compress?: boolean;
-    },
-    callback: (err: string | null, data: Component) => void
-  ): void => {
-    const componentPath = opts.componentPath;
-    const useComponentDependencies = opts.useComponentDependencies;
-    const packageDir = path.resolve(componentPath, '_package');
-    const compressedPackagePath = path.resolve(componentPath, 'package.tar.gz');
+    }): Promise<Component> => {
+      const componentPath = opts.componentPath;
+      const useComponentDependencies = opts.useComponentDependencies;
+      const packageDir = path.resolve(componentPath, '_package');
+      const compressedPackagePath = path.resolve(
+        componentPath,
+        'package.tar.gz'
+      );
+
+      logger.warn(strings.messages.cli.PACKAGING(packageDir));
+      try {
+        await handleDependencies({
+          components: [path.resolve(componentPath)],
+          logger,
+          useComponentDependencies
+        });
 
-    logger.warn(strings.messages.cli.PACKAGING(packageDir));
-    handleDependencies(
-      {
-        components: [path.resolve(componentPath)],
-        logger,
-        useComponentDependencies
-      },
-      err => {
-        if (err) {
-          logger.err(err);
-          return callback(err, undefined as any);
-        }
         const packageOptions = {
           production: true,
           componentPath: path.resolve(componentPath)
         };
-        local.package(packageOptions, (err, component) => {
-          if (err) {
-            logger.err(strings.errors.cli.PACKAGE_CREATION_FAIL(String(err)));
-            return callback(err as any, undefined as any);
-          }
 
-          logger.ok(strings.messages.cli.PACKAGED(packageDir));
+        const component = await local.package(packageOptions).catch(err => {
+          logger.err(strings.errors.cli.PACKAGE_CREATION_FAIL(String(err)));
+          return Promise.reject(err);
+        });
 
-          if (opts.compress) {
-            logger.warn(
-              strings.messages.cli.COMPRESSING(compressedPackagePath)
-            );
+        logger.ok(strings.messages.cli.PACKAGED(packageDir));
 
-            local.compress(packageDir, compressedPackagePath, err => {
-              if (err) {
-                logger.err(
-                  strings.errors.cli.PACKAGE_CREATION_FAIL(String(err))
-                );
-                return callback(err as any, undefined as any);
-              }
-              logger.ok(strings.messages.cli.COMPRESSED(compressedPackagePath));
-              callback(null, component);
-            });
-          } else {
-            callback(null, component);
-          }
-        });
+        if (opts.compress) {
+          logger.warn(strings.messages.cli.COMPRESSING(compressedPackagePath));
+
+          await local.compress(packageDir, compressedPackagePath).catch(err => {
+            logger.err(strings.errors.cli.PACKAGE_CREATION_FAIL(String(err)));
+            return Promise.reject(err);
+          });
+
+          logger.ok(strings.messages.cli.COMPRESSED(compressedPackagePath));
+
+          return component;
+        } else {
+          return component;
+        }
+      } catch (err) {
+        logger.err(String(err));
+        throw err;
       }
-    );
-  };
+    }
+  );
 
 export default cliPackage;

package/src/cli/facade/preview.ts

@@ -1,26 +1,28 @@
 import open from 'open';
+import { fromPromise } from 'universalify';
 
 import strings from '../../resources/index';
 import { RegistryCli } from '../../types';
 import { Logger } from '../logger';
 
-const preview =
-  ({ logger, registry }: { logger: Logger; registry: RegistryCli }) =>
-  (
-    opts: { componentHref: string },
-    callback: (err: string | null, data: string) => void
-  ): void => {
-    registry.getComponentPreviewUrlByUrl(opts.componentHref, (err, href) => {
-      if (err) {
-        logger.err(strings.errors.cli.COMPONENT_HREF_NOT_FOUND);
-        return callback(
-          strings.errors.cli.COMPONENT_HREF_NOT_FOUND,
-          undefined as any
-        );
-      }
-      open(href);
-      callback(null, href);
-    });
-  };
+const preview = ({
+  logger,
+  registry
+}: {
+  logger: Logger;
+  registry: RegistryCli;
+}) =>
+  fromPromise(async (opts: { componentHref: string }): Promise<string> => {
+    try {
+      const href = await registry.getComponentPreviewUrlByUrl(
+        opts.componentHref
+      );
+      await open(href);
+      return href;
+    } catch (err) {
+      logger.err(strings.errors.cli.COMPONENT_HREF_NOT_FOUND);
+      throw strings.errors.cli.COMPONENT_HREF_NOT_FOUND;
+    }
+  });
 
 export default preview;