oc 0.49.6 → 0.49.9

package/src/cli/domain/handle-dependencies/install-missing-dependencies.ts

@@ -5,21 +5,23 @@ import * as npm from '../../../utils/npm-utils';
 import strings from '../../../resources/index';
 import { Logger } from '../../logger';
 
-export default function installMissingDependencies(
-  options: { dependencies: Record<string, string>; logger: Logger },
-  callback: (err: string | null) => void
-): void {
+export default async function installMissingDependencies(options: {
+  dependencies: Record<string, string>;
+  logger: Logger;
+}): Promise<void> {
   const { dependencies, logger } = options;
 
   const missing = getMissingDependencies(dependencies);
 
   if (!missing.length) {
-    return callback(null);
+    return;
   }
 
   const installPath = path.resolve('.');
-  
-  logger.warn(strings.messages.cli.INSTALLING_DEPS(missing.join(', '), installPath));
+
+  logger.warn(
+    strings.messages.cli.INSTALLING_DEPS(missing.join(', '), installPath)
+  );
 
   const npmOptions = {
     dependencies: missing,
@@ -29,14 +31,18 @@ export default function installMissingDependencies(
     usePrefix: true
   };
 
-  npm.installDependencies(npmOptions, err => {
-    if (err || getMissingDependencies(dependencies).length) {
+  try {
+    await npm.installDependencies(npmOptions);
+
+    if (getMissingDependencies(dependencies).length) {
       logger.err('FAIL');
-      if (err) logger.err(`${err}`);
-      return callback(strings.errors.cli.DEPENDENCIES_INSTALL_FAIL);
+      throw strings.errors.cli.DEPENDENCIES_INSTALL_FAIL;
     }
 
     logger.ok('OK');
-    callback(null);
-  });
+  } catch (err) {
+    logger.err('FAIL');
+    if (err) logger.err(String(err));
+    throw strings.errors.cli.DEPENDENCIES_INSTALL_FAIL;
+  }
 }

package/src/cli/domain/handle-dependencies/link-missing-dependencies.ts

@@ -5,20 +5,17 @@ import strings from '../../../resources/index';
 import stripVersion from '../../../utils/strip-version';
 import { Logger } from '../../logger';
 
-export default function linkMissingDependencies(
-  options: {
-    componentPath: string;
-    dependencies: Record<string, string>;
-    logger: Logger;
-  },
-  callback: (err: string | null) => void
-): void {
+export default async function linkMissingDependencies(options: {
+  componentPath: string;
+  dependencies: Record<string, string>;
+  logger: Logger;
+}): Promise<void> {
   const { componentPath, dependencies, logger } = options;
 
   const missingDependencies = getMissingDependencies(dependencies);
 
   if (!missingDependencies.length) {
-    return callback(null);
+    return;
   }
 
   logger.warn(
@@ -27,7 +24,6 @@ export default function linkMissingDependencies(
   );
 
   const symLinkType = 'dir';
-  let symLinkError = false;
 
   for (const dependency of missingDependencies) {
     const moduleName = stripVersion(dependency);
@@ -38,16 +34,12 @@ export default function linkMissingDependencies(
     );
     const pathToModule = path.resolve('.', 'node_modules', moduleName);
     try {
-      fs.ensureSymlinkSync(pathToComponentModule, pathToModule, symLinkType);
+      await fs.ensureSymlink(pathToComponentModule, pathToModule, symLinkType);
     } catch (err) {
-      symLinkError = true;
       logger.err(
         strings.errors.cli.DEPENDENCY_LINK_FAIL(moduleName, String(err))
       );
+      throw strings.errors.cli.DEPENDENCIES_LINK_FAIL;
     }
   }
-
-  return !symLinkError
-    ? callback(null)
-    : callback(strings.errors.cli.DEPENDENCIES_LINK_FAIL);
 }

package/src/cli/domain/init-template/index.ts

@@ -1,4 +1,3 @@
-import async from 'async';
 import fs from 'fs-extra';
 import path from 'path';
 
@@ -7,27 +6,21 @@ import * as npm from '../../../utils/npm-utils';
 import scaffold from './scaffold';
 import { Logger } from '../../logger';
 
-export default function initTemplate(
-  options: {
-    componentPath: string;
-    templateType: string;
-    componentName: string;
-    compiler: string;
-    logger: Logger;
-  },
-  callback: (err: string | null, data: { ok: true }) => void
-): void {
+export default async function initTemplate(options: {
+  componentPath: string;
+  templateType: string;
+  componentName: string;
+  compiler: string;
+  logger: Logger;
+}): Promise<{ ok: true }> {
   const { compiler, componentPath } = options;
   const compilerPath = path.join(componentPath, 'node_modules', compiler);
   const npmOptions = { initPath: componentPath, silent: true };
 
-  async.series(
-    [
-      cb => fs.ensureDir(componentPath, cb),
-      cb => npm.init(npmOptions, cb as any),
-      cb => installTemplate(options, cb as any),
-      cb => scaffold(Object.assign(options, { compilerPath }), cb as any)
-    ],
-    callback as any
-  );
+  await fs.ensureDir(componentPath);
+  await npm.init(npmOptions);
+  await installTemplate(options);
+  await scaffold(Object.assign(options, { compilerPath }));
+
+  return { ok: true };
 }

package/src/cli/domain/init-template/install-template.ts

@@ -12,11 +12,11 @@ interface Options {
   logger: Logger;
 }
 
-export default function installTemplate(
-  options: Options,
-  callback: (err: string | null, data: { ok: true }) => void
-): void {
+export default async function installTemplate(
+  options: Options
+): Promise<{ ok: true }> {
   const { compiler, componentPath, logger, templateType } = options;
+  const errorMessage = 'template type not valid';
 
   const npmOptions = {
     dependency: compiler,
@@ -28,16 +28,13 @@ export default function installTemplate(
 
   logger.log(strings.messages.cli.installCompiler(compiler));
 
-  npm.installDependency(npmOptions, (err, result) => {
-    const errorMessage = 'template type not valid';
-    if (err) {
-      return callback(errorMessage, undefined as any);
-    }
+  try {
+    const result = await npm.installDependency(npmOptions);
 
     const installedCompiler = tryRequire(result.dest);
 
     if (!isTemplateValid(installedCompiler, { compiler: true })) {
-      return callback(errorMessage, undefined as any);
+      throw errorMessage;
     }
     const version = installedCompiler.getInfo().version;
     logger.log(
@@ -48,6 +45,8 @@ export default function installTemplate(
       )
     );
 
-    return callback(null, { ok: true });
-  });
+    return { ok: true };
+  } catch (err) {
+    throw errorMessage;
+  }
 }

package/src/cli/domain/init-template/scaffold.ts

@@ -11,38 +11,35 @@ interface ScaffoldOptions {
   templateType: string;
 }
 
-export default function scaffold(
-  options: ScaffoldOptions,
-  callback: (err: string | null, data: { ok: true }) => void
-): void {
+export default async function scaffold(
+  options: ScaffoldOptions
+): Promise<{ ok: true }> {
   const { compiler, compilerPath, componentName, componentPath, templateType } =
     options;
 
   const baseComponentPath = path.join(compilerPath, 'scaffold');
   const baseComponentFiles = path.join(baseComponentPath, 'src');
-  const compilerPackage = fs.readJsonSync(
+  const compilerPackage = await fs.readJson(
     path.join(compilerPath, 'package.json')
   );
 
   try {
-    fs.copySync(baseComponentFiles, componentPath);
+    await fs.copy(baseComponentFiles, componentPath);
 
-    const componentPackage = fs.readJsonSync(
+    const componentPackage = await fs.readJson(
       path.join(componentPath, 'package.json')
     );
     componentPackage.name = componentName;
     componentPackage.devDependencies[compiler] = compilerPackage.version;
-    fs.writeJsonSync(componentPath + '/package.json', componentPackage, {
+    await fs.writeJson(componentPath + '/package.json', componentPackage, {
       spaces: 2
     });
 
-    return callback(null, { ok: true });
+    return { ok: true };
   } catch (error) {
     const url =
       (compilerPackage.bugs && compilerPackage.bugs.url) ||
       `the ${templateType} repo`;
-    return (callback as any)(
-      strings.errors.cli.scaffoldError(url, String(error))
-    );
+    throw strings.errors.cli.scaffoldError(url, String(error));
   }
 }

package/src/cli/domain/local.ts

@@ -1,5 +1,6 @@
 import fs from 'fs-extra';
 import targz from 'targz';
+import { promisify } from 'util';
 
 import * as clean from './clean';
 import getComponentsByDir from './get-components-by-dir';
@@ -14,31 +15,28 @@ import { Local } from '../../types';
 export default function local(): Local {
   return {
     clean,
-    cleanup(compressedPackagePath: string, callback) {
-      return fs.unlink(compressedPackagePath, callback);
+    cleanup(compressedPackagePath: string) {
+      return fs.unlink(compressedPackagePath);
     },
-    compress(input, output, callback) {
-      return targz.compress(
-        {
-          src: input,
-          dest: output,
-          tar: {
-            map: function (file) {
-              return Object.assign(file, {
-                name: `_package/${file.name}`
-              });
-            }
+    compress(input, output) {
+      return promisify(targz.compress)({
+        src: input,
+        dest: output,
+        tar: {
+          map: function (file) {
+            return Object.assign(file, {
+              name: `_package/${file.name}`
+            });
           }
-        },
-        callback
-      );
+        }
+      });
     },
     getComponentsByDir: getComponentsByDir(),
-    init(options, callback) {
+    async init(options) {
       const { componentName, logger } = options;
       let { templateType } = options;
       if (!validator.validateComponentName(componentName)) {
-        return callback('name not valid', undefined as any);
+        throw 'name not valid';
       }
 
       // LEGACY TEMPLATES WARNING
@@ -56,15 +54,14 @@ export default function local(): Local {
         );
       }
       try {
-        initTemplate(
+        await initTemplate(
           Object.assign(options, {
             templateType,
             compiler: `${templateType}-compiler`
-          }),
-          callback as any
+          })
         );
       } catch (e) {
-        return callback('template type not valid', undefined as any);
+        throw 'template type not valid';
       }
     },
     mock: mock(),

package/src/cli/domain/mock.ts

@@ -4,41 +4,37 @@ import path from 'path';
 import settings from '../../resources/settings';
 
 export default function mock() {
-  return function (
-    params: { targetType: string; targetValue: string; targetName: string },
-    callback: (err: Error) => void
-  ): void {
-    fs.readJson(settings.configFile.src, (_err, localConfig) => {
-      localConfig = localConfig || {};
-
-      const mockType = params.targetType + 's';
-
-      if (!localConfig.mocks) {
-        localConfig.mocks = {};
-      }
-
-      if (!localConfig.mocks[mockType]) {
-        localConfig.mocks[mockType] = {};
-      }
-
-      let pluginType = 'static';
-      if (fs.existsSync(path.resolve(params.targetValue.toString()))) {
-        pluginType = 'dynamic';
-      }
-
-      if (!localConfig.mocks[mockType][pluginType]) {
-        localConfig.mocks[mockType][pluginType] = {};
-      }
-
-      localConfig.mocks[mockType][pluginType][params.targetName] =
-        params.targetValue;
-
-      return fs.writeJson(
-        settings.configFile.src,
-        localConfig,
-        { spaces: 2 },
-        callback
-      );
-    });
+  return async function (params: {
+    targetType: string;
+    targetValue: string;
+    targetName: string;
+  }): Promise<void> {
+    const localConfig = await fs
+      .readJson(settings.configFile.src)
+      .catch(() => ({}));
+
+    const mockType = params.targetType + 's';
+
+    if (!localConfig.mocks) {
+      localConfig.mocks = {};
+    }
+
+    if (!localConfig.mocks[mockType]) {
+      localConfig.mocks[mockType] = {};
+    }
+
+    let pluginType = 'static';
+    if (fs.existsSync(path.resolve(params.targetValue.toString()))) {
+      pluginType = 'dynamic';
+    }
+
+    if (!localConfig.mocks[mockType][pluginType]) {
+      localConfig.mocks[mockType][pluginType] = {};
+    }
+
+    localConfig.mocks[mockType][pluginType][params.targetName] =
+      params.targetValue;
+
+    return fs.writeJson(settings.configFile.src, localConfig, { spaces: 2 });
   };
 }

package/src/cli/domain/package-components.ts

@@ -1,4 +1,5 @@
 import fs from 'fs-extra';
+import { promisify } from 'util';
 import path from 'path';
 
 import requireTemplate from './handle-dependencies/require-template';
@@ -14,10 +15,7 @@ interface PackageOptions {
 
 const packageComponents =
   () =>
-  (
-    options: PackageOptions,
-    callback: (err: Error | null, data: Component) => void
-  ): void => {
+  async (options: PackageOptions): Promise<Component> => {
     const production = options.production;
     const componentPath = options.componentPath;
     const minify = options.minify === true;
@@ -27,24 +25,18 @@ const packageComponents =
     const ocPackagePath = path.join(__dirname, '../../../package.json');
 
     if (!fs.existsSync(componentPackagePath)) {
-      return callback(
-        new Error('component does not contain package.json'),
-        undefined as any
-      );
+      throw new Error('component does not contain package.json');
     } else if (!fs.existsSync(ocPackagePath)) {
-      return callback(
-        new Error('error resolving oc internal dependencies'),
-        undefined as any
-      );
+      throw new Error('error resolving oc internal dependencies');
     }
 
-    fs.emptyDirSync(publishPath);
+    await fs.emptyDir(publishPath);
 
-    const componentPackage: Component = fs.readJsonSync(componentPackagePath);
-    const ocPackage = fs.readJsonSync(ocPackagePath);
+    const componentPackage: Component = await fs.readJson(componentPackagePath);
+    const ocPackage: Component = await fs.readJson(ocPackagePath);
 
     if (!validator.validateComponentName(componentPackage.name)) {
-      return callback(new Error('name not valid'), undefined as any);
+      throw new Error('name not valid');
     }
 
     const type = componentPackage.oc.files.template.type;
@@ -58,15 +50,12 @@ const packageComponents =
       production
     };
 
-    try {
-      const ocTemplate = requireTemplate(type, {
-        compiler: true,
-        componentPath
-      });
-      ocTemplate.compile(compileOptions, callback);
-    } catch (err) {
-      return callback(err as any, undefined as any);
-    }
+    const ocTemplate = requireTemplate(type, {
+      compiler: true,
+      componentPath
+    });
+    const compile = promisify(ocTemplate.compile);
+    return compile(compileOptions);
   };
 
 export default packageComponents;