oc 0.49.7 → 0.49.8

package/src/cli/domain/registry.ts

@@ -1,6 +1,6 @@
 import fs from 'fs-extra';
 import path from 'path';
-import request from 'minimal-request';
+import got from 'got';
 import _ from 'lodash';
 
 import put from '../../utils/put';
@@ -28,100 +28,72 @@ export default function registry(opts: RegistryOptions = {}): RegistryCli {
   };
 
   return {
-    add(registry: string, callback: (err: string | null, data: null) => void) {
+    async add(registry: string) {
       if (registry.slice(registry.length - 1) !== '/') {
         registry += '/';
       }
+      try {
+        const apiResponse: { type: string } = await got(registry, {
+          headers: requestsHeaders
+        }).json();
 
-      request(
-        {
-          url: registry,
-          headers: requestsHeaders,
-          json: true
-        },
-        (err, apiResponse: { type: string }) => {
-          if (err || !apiResponse) {
-            return callback('oc registry not available', null);
-          } else if (apiResponse.type !== 'oc-registry') {
-            return callback('not a valid oc registry', null);
-          }
-
-          fs.readJson(settings.configFile.src, (err, res) => {
-            if (err) {
-              res = {};
-            }
-
-            if (!res.registries) {
-              res.registries = [];
-            }
-
-            if (!_.includes(res.registries, registry)) {
-              res.registries.push(registry);
-            }
-
-            fs.writeJson(settings.configFile.src, res, callback as any);
-          });
+        if (!apiResponse) throw 'oc registry not available';
+        if (apiResponse.type !== 'oc-registry') throw 'not a valid oc registry';
+
+        const res = await fs
+          .readJson(settings.configFile.src)
+          .catch(() => ({}));
+
+        if (!res.registries) {
+          res.registries = [];
+        }
+
+        if (!_.includes(res.registries, registry)) {
+          res.registries.push(registry);
         }
-      );
+
+        return fs.writeJson(settings.configFile.src, res);
+      } catch (err) {
+        throw 'oc registry not available';
+      }
     },
-    get(callback: (err: string | null, data: string[]) => void) {
+    async get() {
       if (opts.registry) {
-        return callback(null, [opts.registry]);
+        return [opts.registry];
       }
 
-      fs.readJson(settings.configFile.src, (err, res) => {
-        if (err || !res.registries || res.registries.length === 0) {
-          return callback('No oc registries', undefined as any);
-        }
+      try {
+        const res = await fs.readJson(settings.configFile.src);
 
-        return callback(null, res.registries);
-      });
+        if (!res.registries || res.registries.length === 0)
+          throw 'No oc registries';
+
+        return res.registries;
+      } catch (err) {
+        throw 'No oc registries';
+      }
     },
-    getApiComponentByHref(
-      href: string,
-      callback: (err: Error | number | null, data: unknown) => void
-    ) {
-      request(
-        {
-          url: href + settings.registry.componentInfoPath,
-          headers: requestsHeaders,
-          json: true
-        },
-        callback
-      );
+    getApiComponentByHref(href: string) {
+      return got(href + settings.registry.componentInfoPath, {
+        headers: requestsHeaders
+      }).json();
     },
-    getComponentPreviewUrlByUrl(
-      componentHref: string,
-      callback: (err: Error | number | null, data: string) => void
-    ) {
-      request(
-        {
-          url: componentHref,
-          headers: requestsHeaders,
-          json: true
-        },
-        (err, res: { requestVersion: string; href: string }) => {
-          if (err) {
-            return callback(err, undefined as any);
-          }
-
-          const parsed = urlParser.parse(res);
-          callback(
-            null,
-            urlBuilder.componentPreview(parsed as any, parsed.registryUrl)
-          );
-        }
-      );
+    async getComponentPreviewUrlByUrl(componentHref: string) {
+      const res: { requestVersion: string; href: string } = await got(
+        componentHref,
+        { headers: requestsHeaders }
+      ).json();
+
+      const parsed = urlParser.parse(res);
+
+      return urlBuilder.componentPreview(parsed as any, parsed.registryUrl);
     },
-    putComponent(
-      options: {
-        username?: string;
-        password?: string;
-        route: string;
-        path: string;
-      },
-      callback: (err: string | null, data: unknown) => void
-    ) {
+    async putComponent(options: {
+      username?: string;
+      password?: string;
+      route: string;
+      path: string;
+    }) {
       if (!!options.username && !!options.password) {
         requestsHeaders = Object.assign(requestsHeaders, {
           Authorization:
@@ -131,49 +103,41 @@ export default function registry(opts: RegistryOptions = {}): RegistryCli {
             )
         });
       }
+      try {
+        await put(options.route, options.path, requestsHeaders);
+      } catch (err) {
+        let parsedError = err as any as { code?: string; error?: string };
+        let errMsg = '';
+        if (!_.isObject(err)) {
+          try {
+            parsedError = JSON.parse(String(err));
+          } catch (er) {}
+        }
 
-      put(options.route, options.path, requestsHeaders, (err, res) => {
-        if (err) {
-          if (!_.isObject(err)) {
-            try {
-              err = JSON.parse(String(err));
-            } catch (er) {}
-          }
-          const parsedError = err as any as { code?: string; error?: string };
-
-          if (!!parsedError.code && parsedError.code === 'ECONNREFUSED') {
-            err = 'Connection to registry has not been established';
-          } else if (
-            parsedError.code !== 'cli_version_not_valid' &&
-            parsedError.code !== 'node_version_not_valid' &&
-            !!parsedError.error
-          ) {
-            err = parsedError.error;
-          }
-
-          return callback(err as any, undefined as any);
+        if (!!parsedError.code && parsedError.code === 'ECONNREFUSED') {
+          errMsg = 'Connection to registry has not been established';
+        } else if (
+          parsedError.code !== 'cli_version_not_valid' &&
+          parsedError.code !== 'node_version_not_valid' &&
+          !!parsedError.error
+        ) {
+          errMsg = parsedError.error;
         }
 
-        callback(err, res);
-      });
+        throw errMsg;
+      }
     },
-    remove(registry: string, callback: (err: Error | null) => void) {
+    async remove(registry: string) {
       if (registry.slice(registry.length - 1) !== '/') {
         registry += '/';
       }
 
-      fs.readJson(settings.configFile.src, (err, res) => {
-        if (err) {
-          res = {};
-        }
-
-        if (!res.registries) {
-          res.registries = [];
-        }
+      const res = await fs
+        .readJson(settings.configFile.src)
+        .catch(() => ({ registries: [] }));
+      res.registries = _.without(res.registries, registry);
 
-        res.registries = _.without(res.registries, registry);
-        fs.writeJson(settings.configFile.src, res, callback as any);
-      });
+      await fs.writeJson(settings.configFile.src, res);
     }
   };
 }

package/src/cli/domain/watch.ts

@@ -12,7 +12,7 @@ export default function watch(
     ignored: settings.filesToIgnoreOnDevWatch,
     persistent: true,
     ignoreInitial: true,
-    usePolling: false
+    usePolling: true
   });
   const onChange = (fileName: string) => {
     const componentDir = dirs.find(dir =>

package/src/cli/facade/clean.ts

@@ -1,8 +1,12 @@
-import read from 'read';
+import readCb from 'read';
+import { fromPromise } from 'universalify';
+import { promisify } from 'util';
 import strings from '../../resources/index';
 import { Local } from '../../types';
 import { Logger } from '../logger';
 
+const read = promisify(readCb);
+
 const clean = ({
   local: {
     clean: { fetchList, remove }
@@ -20,56 +24,52 @@ const clean = ({
     cleanSuccess
   } = strings.messages.cli;
 
-  const prompt = (cb: (proceed: boolean) => void) =>
-    read(
-      { prompt: cleanPrompt, default: cleanPromptDefault },
-      (err, result) => {
-        if (err) return cb(false);
-        const lowered = result.toLowerCase().trim();
-        const proceed = lowered === 'y' || lowered === 'yes';
-        cb(proceed);
-      }
-    );
-
-  const removeFolders = (list: string[], cb: (err?: unknown) => void) =>
-    remove(list, err => {
-      if (err) {
-        logger.err(strings.errors.cli.cleanRemoveError(String(err)));
-        return cb(err);
-      }
+  const prompt = async (): Promise<boolean> => {
+    try {
+      const result = await read({
+        prompt: cleanPrompt,
+        default: cleanPromptDefault
+      });
+      const lowered = result.toLowerCase().trim();
+      return lowered === 'y' || lowered === 'yes';
+    } catch (err) {
+      return false;
+    }
+  };
 
+  const removeFolders = async (list: string[]) => {
+    try {
+      await remove(list);
       logger.ok(cleanSuccess);
-      cb();
-    });
+    } catch (err) {
+      logger.err(strings.errors.cli.cleanRemoveError(String(err)));
+      throw err;
+    }
+  };
 
-  return (
-    opts: { dirPath: string; yes: boolean },
-    callback: (err?: unknown) => void
-  ) => {
-    fetchList(opts.dirPath, (err, list) => {
-      if (err) {
-        logger.err(strings.errors.generic(String(err)));
-        return callback(err);
-      }
+  return fromPromise(async (opts: { dirPath: string; yes: boolean }) => {
+    try {
+      const list = await fetchList(opts.dirPath);
 
       if (list.length === 0) {
         logger.ok(cleanAlreadyClean);
-        return callback();
+        return;
       }
 
       logger.warn(cleanList(list));
       const shouldConfirm = !opts.yes;
 
       if (shouldConfirm) {
-        return prompt(confirmed => {
-          if (!confirmed) return callback();
-          return removeFolders(list, callback);
-        });
+        const confirmed = await prompt();
+        if (!confirmed) return;
       }
 
-      removeFolders(list, callback);
-    });
-  };
+      await removeFolders(list);
+    } catch (err) {
+      logger.err(strings.errors.generic(String(err)));
+      throw err;
+    }
+  });
 };
 
 export default clean;