oc 0.49.6 → 0.49.9

package/src/cli/facade/publish.ts

@@ -1,136 +1,112 @@
-import async from 'async';
 import colors from 'colors/safe';
 import path from 'path';
 import fs from 'fs-extra';
-import read from 'read';
-import _ from 'lodash';
+import readCb from 'read';
+import { promisify } from 'util';
 import { Logger } from '../logger';
 import { Component, RegistryCli, Local } from '../../types';
+import { fromPromise } from 'universalify';
 
 import handleDependencies from '../domain/handle-dependencies';
 import strings from '../../resources/index';
 
-const publish =
-  ({
-    logger,
-    registry,
-    local
-  }: {
-    logger: Logger;
-    registry: RegistryCli;
-    local: Local;
-  }) =>
-  (
-    opts: {
+const read = promisify(readCb);
+
+const publish = ({
+  logger,
+  registry,
+  local
+}: {
+  logger: Logger;
+  registry: RegistryCli;
+  local: Local;
+}) =>
+  fromPromise(
+    async (opts: {
       componentPath: string;
       skipPackage?: boolean;
       username?: string;
       password?: string;
       registries?: string[];
-    },
-    callback: (err?: Error | string) => void
-  ): void => {
-    const componentPath = opts.componentPath;
-    const skipPackage = opts.skipPackage;
-    const packageDir = path.resolve(componentPath, '_package');
-    const compressedPackagePath = path.resolve(componentPath, 'package.tar.gz');
-
-    let errorMessage;
-
-    const readPackageJson = (
-      cb: (err: Error | null, data: Component) => void
-    ) => fs.readJson(path.join(packageDir, 'package.json'), cb);
-
-    const getCredentials = (
-      cb: (
-        err: Error | null,
-        data: { username: string; password: string }
-      ) => void
-    ) => {
-      if (opts.username && opts.password) {
-        logger.ok(strings.messages.cli.USING_CREDS);
-        return cb(null, _.pick(opts, 'username', 'password') as any);
-      }
+    }): Promise<void> => {
+      const componentPath = opts.componentPath;
+      const skipPackage = opts.skipPackage;
+      const packageDir = path.resolve(componentPath, '_package');
+      const compressedPackagePath = path.resolve(
+        componentPath,
+        'package.tar.gz'
+      );
+
+      let errorMessage;
+
+      const readPackageJson = () =>
+        fs.readJson(path.join(packageDir, 'package.json'));
+
+      const getCredentials = async (): Promise<{
+        username: string;
+        password: string;
+      }> => {
+        if (opts.username && opts.password) {
+          logger.ok(strings.messages.cli.USING_CREDS);
+          const { username, password } = opts;
+          return { username, password };
+        }
 
-      logger.warn(strings.messages.cli.ENTER_USERNAME);
+        logger.warn(strings.messages.cli.ENTER_USERNAME);
 
-      read({}, (_err, username) => {
+        const username = await read({});
         logger.warn(strings.messages.cli.ENTER_PASSWORD);
+        const password = await read({ silent: true });
 
-        read({ silent: true }, (_err, password) => {
-          cb(null, { username, password });
-        });
-      });
-    };
-
-    const compress = (cb: (error: string | Error | null) => void) => {
-      local.compress(packageDir, compressedPackagePath, cb);
-    };
-
-    const packageAndCompress = (
-      cb: (err: Error | string | null, data: Component) => void
-    ) => {
-      logger.warn(strings.messages.cli.PACKAGING(packageDir));
-      const packageOptions = {
-        production: true,
-        componentPath: path.resolve(componentPath)
+        return { username, password };
       };
 
-      local.package(packageOptions, (err, component) => {
-        if (err) {
-          return cb(err, undefined as any);
-        }
+      const compress = () => local.compress(packageDir, compressedPackagePath);
 
-        logger.warn(strings.messages.cli.COMPRESSING(compressedPackagePath));
+      const packageAndCompress = async (): Promise<Component> => {
+        logger.warn(strings.messages.cli.PACKAGING(packageDir));
+        const packageOptions = {
+          production: true,
+          componentPath: path.resolve(componentPath)
+        };
 
-        compress(err => {
-          if (err) {
-            return cb(err, undefined as any);
-          }
-          cb(null, component);
-        });
-      });
-    };
-
-    const getRegistries = (
-      cb: (err: string | null, registryLocations: string[]) => void
-    ): void => {
-      if (opts.registries) return cb(null, opts.registries);
+        const component = await local.package(packageOptions);
+        logger.warn(strings.messages.cli.COMPRESSING(compressedPackagePath));
+        await compress();
 
-      registry.get(cb);
-    };
+        return component;
+      };
 
-    const putComponentToRegistry = (
-      options: {
+      const putComponentToRegistry = async (options: {
         route: string;
         path: string;
         username?: string;
         password?: string;
-      },
-      cb: (err: string | null, data: 'ok') => void
-    ) => {
-      logger.warn(strings.messages.cli.PUBLISHING(options.route));
-
-      registry.putComponent(options, err => {
-        if (err) {
-          if (err === 'Unauthorized') {
+      }): Promise<void> => {
+        logger.warn(strings.messages.cli.PUBLISHING(options.route));
+
+        try {
+          await registry.putComponent(options);
+          logger.ok(strings.messages.cli.PUBLISHED(options.route));
+        } catch (err: any) {
+          if (err === 'Unauthorized' || err.message === 'Unauthorized') {
             if (!!options.username || !!options.password) {
               logger.err(
                 strings.errors.cli.PUBLISHING_FAIL(
                   strings.errors.cli.INVALID_CREDENTIALS
                 )
               );
-              return cb(err, undefined as any);
+              throw err;
             }
 
             logger.warn(strings.messages.cli.REGISTRY_CREDENTIALS_REQUIRED);
 
-            return getCredentials((_err, credentials) => {
-              putComponentToRegistry(Object.assign(options, credentials), cb);
-            });
-          } else if ((err as any).code === 'cli_version_not_valid') {
+            const credentials = await getCredentials();
+
+            await putComponentToRegistry(Object.assign(options, credentials));
+          } else if (err.code === 'cli_version_not_valid') {
             const upgradeCommand = strings.commands.cli.UPGRADE(
-              (err as any).details.suggestedVersion
+              err.details.suggestedVersion
             );
             const errorDetails =
               strings.errors.cli.OC_CLI_VERSION_NEEDS_UPGRADE(
@@ -139,107 +115,93 @@ const publish =
 
             errorMessage = strings.errors.cli.PUBLISHING_FAIL(errorDetails);
             logger.err(errorMessage);
-            return cb(errorMessage, undefined as any);
-          } else if ((err as any).code === 'node_version_not_valid') {
+
+            throw errorMessage;
+          } else if (err.code === 'node_version_not_valid') {
             const details = strings.errors.cli.NODE_CLI_VERSION_NEEDS_UPGRADE(
-              (err as any).details.suggestedVersion
+              err.details.suggestedVersion
             );
 
             errorMessage = strings.errors.cli.PUBLISHING_FAIL(details);
             logger.err(errorMessage);
-            return cb(errorMessage, undefined as any);
+
+            throw errorMessage;
           } else {
-            if (_.isObject(err)) {
+            if (err.message) {
+              // eslint-disable-next-line no-ex-assign
+              err = err.message;
+            } else if (err && typeof err === 'object') {
               try {
+                // eslint-disable-next-line no-ex-assign
                 err = JSON.stringify(err);
               } catch (er) {}
             }
-            errorMessage = strings.errors.cli.PUBLISHING_FAIL(err);
+            errorMessage = strings.errors.cli.PUBLISHING_FAIL(String(err));
             logger.err(errorMessage);
-            return cb(errorMessage, undefined as any);
+
+            throw errorMessage;
           }
-        } else {
-          logger.ok(strings.messages.cli.PUBLISHED(options.route));
-          return cb(null, 'ok');
         }
-      });
-    };
-
-    const publishToRegistries = (
-      registryLocations: string[],
-      component: Component
-    ) => {
-      async.eachSeries(
-        registryLocations,
-        (registryUrl, next) => {
+      };
+
+      const publishToRegistries = async (
+        registryLocations: string[],
+        component: Component
+      ) => {
+        for (const registryUrl of registryLocations) {
           const registryNormalised = registryUrl.replace(/\/$/, '');
           const componentRoute = `${registryNormalised}/${component.name}/${component.version}`;
-          putComponentToRegistry(
-            { route: componentRoute, path: compressedPackagePath },
-            next as any
-          );
-        },
-        err => {
-          local.cleanup(compressedPackagePath, err2 => {
-            if (err) {
-              return callback(err);
-            }
-            callback(err2);
+
+          await putComponentToRegistry({
+            route: componentRoute,
+            path: compressedPackagePath
           });
         }
-      );
-    };
+        await local.cleanup(compressedPackagePath);
+      };
 
-    getRegistries((err: string | null, registryLocations: string[]) => {
-      if (err) {
-        logger.err(err);
-        return callback(err);
-      }
+      try {
+        const registryLocations = opts.registries || (await registry.get());
 
-      if (!skipPackage) {
-        handleDependencies(
-          { components: [path.resolve(componentPath)], logger },
-          err => {
-            if (err) {
-              logger.err(err);
-              return callback(err);
-            }
-            packageAndCompress((err, component) => {
-              if (err) {
-                errorMessage = strings.errors.cli.PACKAGE_CREATION_FAIL(
-                  String(err)
-                );
-                logger.err(errorMessage);
-                return callback(errorMessage);
-              }
-
-              publishToRegistries(registryLocations, component);
-            });
-          }
-        );
-      } else {
-        if (fs.existsSync(packageDir)) {
-          readPackageJson((err, component) => {
-            if (err) {
-              logger.err(String(err));
-              return callback(err);
-            }
-            compress(err => {
-              if (err) {
-                logger.err(String(err));
-                return callback(err);
-              }
+        if (!skipPackage) {
+          await handleDependencies({
+            components: [path.resolve(componentPath)],
+            logger
+          }).catch(err => {
+            logger.err(err);
+            return Promise.reject(err);
+          });
 
-              publishToRegistries(registryLocations, component);
-            });
+          const component = await packageAndCompress().catch(err => {
+            errorMessage = strings.errors.cli.PACKAGE_CREATION_FAIL(
+              String(err)
+            );
+            logger.err(errorMessage);
+            return Promise.reject(errorMessage);
           });
+          await publishToRegistries(registryLocations, component);
         } else {
-          errorMessage = strings.errors.cli.PACKAGE_FOLDER_MISSING;
-          logger.err(errorMessage);
-          return callback(errorMessage);
+          if (fs.existsSync(packageDir)) {
+            const component = await readPackageJson().catch(err => {
+              logger.err(String(err));
+              return Promise.reject(err);
+            });
+            await compress().catch(err => {
+              logger.err(String(err));
+              return Promise.reject(err);
+            });
+            await publishToRegistries(registryLocations, component);
+          } else {
+            errorMessage = strings.errors.cli.PACKAGE_FOLDER_MISSING;
+            logger.err(errorMessage);
+            throw errorMessage;
+          }
         }
+      } catch (err) {
+        logger.err(String(err));
+        throw err;
       }
-    });
-  };
+    }
+  );
 
 export default publish;

package/src/cli/facade/registry-add.ts

@@ -1,22 +1,23 @@
+import { fromPromise } from 'universalify';
 import strings from '../../resources/index';
 import { RegistryCli } from '../../types';
 import { Logger } from '../logger';
 
-const registryAdd =
-  ({ registry, logger }: { logger: Logger; registry: RegistryCli }) =>
-  (
-    opts: { registryUrl: string },
-    callback: (err: string | null, data: string) => void
-  ): void => {
-    registry.add(opts.registryUrl, err => {
-      if (err) {
-        logger.err(err);
-        return callback(err, undefined as any);
-      }
-
+const registryAdd = ({
+  registry,
+  logger
+}: {
+  logger: Logger;
+  registry: RegistryCli;
+}) =>
+  fromPromise(async (opts: { registryUrl: string }): Promise<void> => {
+    try {
+      await registry.add(opts.registryUrl);
       logger.ok(strings.messages.cli.REGISTRY_ADDED);
-      callback(null, 'ok');
-    });
-  };
+    } catch (err) {
+      logger.err(String(err));
+      throw err;
+    }
+  });
 
 export default registryAdd;

package/src/cli/facade/registry-ls.ts

@@ -1,31 +1,36 @@
+import { fromPromise } from 'universalify';
+
 import strings from '../../resources/index';
 import { RegistryCli } from '../../types';
 import { Logger } from '../logger';
 
-const registryLs =
-  ({ registry, logger }: { logger: Logger; registry: RegistryCli }) =>
-  (
-    _opts: unknown,
-    callback: (err: string | null, data: string[]) => void
-  ): void => {
-    registry.get((err, registries) => {
-      if (err) {
-        logger.err(strings.errors.generic(err));
-        return callback(err, undefined as any);
-      } else {
-        logger.warn(strings.messages.cli.REGISTRY_LIST);
-
-        if (registries.length === 0) {
-          err = strings.errors.cli.REGISTRY_NOT_FOUND;
-          logger.err(err);
-          return callback(err, undefined as any);
-        }
+const registryLs = ({
+  registry,
+  logger
+}: {
+  logger: Logger;
+  registry: RegistryCli;
+}) =>
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  fromPromise(async (_opts: unknown): Promise<string[]> => {
+    try {
+      const registries = await registry.get();
 
-        registries.forEach(registryLocation => logger.ok(registryLocation));
+      logger.warn(strings.messages.cli.REGISTRY_LIST);
 
-        callback(null, registries);
+      if (registries.length === 0) {
+        const err = strings.errors.cli.REGISTRY_NOT_FOUND;
+        logger.err(err);
+        throw err;
       }
-    });
-  };
+
+      registries.forEach(registryLocation => logger.ok(registryLocation));
+
+      return registries;
+    } catch (err) {
+      logger.err(strings.errors.generic(String(err)));
+      throw err;
+    }
+  });
 
 export default registryLs;

package/src/cli/facade/registry-remove.ts

@@ -1,22 +1,23 @@
+import { fromPromise } from 'universalify';
 import strings from '../../resources/index';
 import { RegistryCli } from '../../types';
 import { Logger } from '../logger';
 
-const registryRemove =
-  ({ registry, logger }: { logger: Logger; registry: RegistryCli }) =>
-  (
-    opts: { registryUrl: string },
-    callback: (err: Error | null, data: string) => void
-  ): void => {
-    registry.remove(opts.registryUrl, err => {
-      if (err) {
-        logger.err(String(err));
-        return callback(err, undefined as any);
-      }
-
+const registryRemove = ({
+  registry,
+  logger
+}: {
+  logger: Logger;
+  registry: RegistryCli;
+}) =>
+  fromPromise(async (opts: { registryUrl: string }): Promise<void> => {
+    try {
+      await registry.remove(opts.registryUrl);
       logger.ok(strings.messages.cli.REGISTRY_REMOVED);
-      callback(null, 'ok');
-    });
-  };
+    } catch (err) {
+      logger.err(String(err));
+      throw err;
+    }
+  });
 
 export default registryRemove;

package/src/cli/facade/registry.ts

@@ -1,7 +1,9 @@
-const registry =
-  () =>
-  (_opts: unknown, callback: (err: Error | null, data: 'ok') => void): void => {
-    callback(null, 'ok');
-  };
+import { fromPromise } from 'universalify';
+
+const registry = () =>
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  fromPromise((_opts: unknown): Promise<void> => {
+    return Promise.resolve();
+  });
 
 export default registry;

package/src/cli/index.ts

@@ -115,11 +115,9 @@ function processCommand(
       return yargs;
     },
     options => {
-      // @ts-ignore Not callable
-      facade(options, (error: unknown) => {
-        if (error) {
-          return process.exit(1);
-        }
+      // @ts-ignore not callable
+      facade(options).catch(() => {
+        process.exit(1);
       });
     }
   );

package/src/components/oc-client/_package/package.json

@@ -1 +1 @@
-{"name":"oc-client","description":"The OpenComponents client-side javascript client","version":"0.49.6","repository":"https://github.com/opencomponents/oc/tree/master/components/oc-client","author":"Matteo Figus <matteofigus@gmail.com>","oc":{"container":false,"renderInfo":false,"minify":false,"parameters":{},"files":{"template":{"type":"oc-template-es6","hashKey":"4bdbbf7249b210dee9a729e8a611eac3dc5eae82","src":"template.js","version":"1.0.7"},"static":["src"],"dataProvider":{"type":"node.js","hashKey":"96eb8b28d43ce2093e13753e54d3f2f938dd0f7d","src":"server.js"}},"version":"0.49.6","packaged":true,"date":1638862960928},"devDependencies":{"oc-template-es6-compiler":"^1.0.1"}}
+{"name":"oc-client","description":"The OpenComponents client-side javascript client","version":"0.49.9","repository":"https://github.com/opencomponents/oc/tree/master/components/oc-client","author":"Matteo Figus <matteofigus@gmail.com>","oc":{"container":false,"renderInfo":false,"minify":false,"parameters":{},"files":{"template":{"type":"oc-template-es6","hashKey":"4bdbbf7249b210dee9a729e8a611eac3dc5eae82","src":"template.js","version":"1.0.7"},"static":["src"],"dataProvider":{"type":"node.js","hashKey":"96eb8b28d43ce2093e13753e54d3f2f938dd0f7d","src":"server.js"}},"version":"0.49.9","packaged":true,"date":1648122168440},"devDependencies":{"oc-template-es6-compiler":"^1.0.1"}}

package/src/components/oc-client/package.json

@@ -1,7 +1,7 @@
 {
   "name": "oc-client",
   "description": "The OpenComponents client-side javascript client",
-  "version": "0.49.6",
+  "version": "0.49.9",
   "repository": "https://github.com/opencomponents/oc/tree/master/components/oc-client",
   "author": "Matteo Figus <matteofigus@gmail.com>",
   "oc": {

package/src/globals.d.ts

@@ -2,6 +2,44 @@ declare module 'oc-client';
 declare module 'try-require';
 declare module 'basic-auth-connect';
 
+declare module 'universalify' {
+  export function fromCallback<
+    Arguments extends readonly unknown[],
+    ErrorValue,
+    ReturnValue
+  >(
+    fn: (
+      ...arguments_: [
+        ...Arguments,
+        (error: ErrorValue, value: ReturnValue) => void
+      ]
+    ) => void
+  ): {
+    (...arguments_: Arguments): Promise<ReturnValue>;
+    (
+      ...arguments_: [
+        ...Arguments,
+        (error: ErrorValue, value: ReturnValue) => void
+      ]
+    ): void;
+  };
+
+  export function fromPromise<
+    Arguments extends readonly unknown[],
+    ReturnValue
+  >(
+    fn: (...arguments_: [...Arguments]) => Promise<ReturnValue>
+  ): {
+    (...arguments_: Arguments): Promise<ReturnValue>;
+    (
+      ...arguments_: [
+        ...Arguments,
+        (error: unknown, value: ReturnValue) => void
+      ]
+    ): void;
+  };
+}
+
 declare module 'semver-extra' {
   interface SemverExtra {
     max(versions: string[]): string;