oc 0.49.7 → 0.49.8

package/src/registry/app-start.ts

@@ -1,8 +1,7 @@
 import colors from 'colors/safe';
 import path from 'path';
-import _ from 'lodash';
 import fs from 'fs-extra';
-import { ComponentsDetails, Config, Repository } from '../types';
+import { Config, Repository } from '../types';
 
 const packageInfo = fs.readJsonSync(
   path.join(
@@ -15,16 +14,16 @@ const packageInfo = fs.readJsonSync(
   )
 );
 
-export default function appStart(
+export default async function appStart(
   repository: Repository,
-  options: Config,
-  callback: (err: any | null, data: ComponentsDetails | string) => void
-): void {
+  options: Config
+): Promise<void> {
   if (options.local) {
-    return callback(null, 'ok');
+    return;
   }
 
-  const logger = options.verbosity ? console : { log: _.noop };
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  const logger = options.verbosity ? console : { log: () => {} };
 
   logger.log(
     colors.yellow(
@@ -32,10 +31,8 @@ export default function appStart(
     )
   );
 
-  repository.getComponentVersions('oc-client', (err, componentInfo) => {
-    if (err) {
-      return logger.log(colors.red(err));
-    }
+  try {
+    const componentInfo = await repository.getComponentVersions('oc-client');
 
     logger.log(
       colors.yellow(
@@ -43,7 +40,7 @@ export default function appStart(
       )
     );
 
-    if (!_.includes(componentInfo, packageInfo.version)) {
+    if (!componentInfo.includes(packageInfo.version)) {
       logger.log(colors.yellow('Component not found. Publishing it...'));
 
       const pkgInfo = {
@@ -54,25 +51,24 @@ export default function appStart(
         packageJson: packageInfo
       };
 
-      repository.publishComponent(
-        pkgInfo,
-        'oc-client',
-        packageInfo.version,
-        (err, res) => {
-          if (!err) {
-            logger.log(colors.green('Component published.'));
-          } else {
-            logger.log(
-              colors.red(`Component not published: ${(err as any).message}`)
-            );
-          }
-
-          callback(err, res);
-        }
-      );
+      try {
+        await repository.publishComponent(
+          pkgInfo,
+          'oc-client',
+          packageInfo.version
+        );
+        logger.log(colors.green('Component published.'));
+      } catch (err) {
+        logger.log(
+          colors.red(`Component not published: ${(err as any).message}`)
+        );
+        throw err;
+      }
     } else {
       logger.log(colors.green('Component is available on library.'));
-      callback(null, 'ok');
     }
-  });
+  } catch (err) {
+    logger.log(colors.red(String(err)));
+    throw err;
+  }
 }

package/src/registry/domain/components-cache/components-list.ts

@@ -1,91 +1,69 @@
-import async from 'async';
 import semver from 'semver';
+import pLimit from 'p-limit';
 import getUnixUTCTimestamp from 'oc-get-unix-utc-timestamp';
-import { Cdn, ComponentsList, Config } from '../../../types';
+import { ComponentsList, Config } from '../../../types';
+import { StorageAdapter } from 'oc-storage-adapters-utils';
 
-export default function componentsList(conf: Config, cdn: Cdn) {
+export default function componentsList(conf: Config, cdn: StorageAdapter) {
   const filePath = (): string =>
     `${conf.storage.options.componentsDir}/components.json`;
 
   const componentsList = {
-    getFromJson: (callback: (err: string | null, data: any) => void) =>
-      cdn.getJson(filePath(), true, callback),
+    getFromJson: (): Promise<ComponentsList> => cdn.getJson(filePath(), true),
 
-    getFromDirectories: (
-      callback: (err: string | null, data: ComponentsList) => void
-    ) => {
+    getFromDirectories: async (): Promise<ComponentsList> => {
       const componentsInfo: Record<string, string[]> = {};
 
-      const getVersionsForComponent = (
-        componentName: string,
-        cb: (err: Error | null, data: string[]) => void
-      ) => {
-        cdn.listSubDirectories(
-          `${conf.storage.options.componentsDir}/${componentName}`,
-          (err, versions) => {
-            if (err) {
-              return cb(err, undefined as any);
-            }
-            cb(null, versions.sort(semver.compare));
-          }
+      const getVersionsForComponent = async (
+        componentName: string
+      ): Promise<string[]> => {
+        const versions = await cdn.listSubDirectories(
+          `${conf.storage.options.componentsDir}/${componentName}`
         );
-      };
 
-      cdn.listSubDirectories(
-        conf.storage.options.componentsDir,
-        (err, components) => {
-          if (err) {
-            if (err.code === 'dir_not_found') {
-              return callback(null, {
-                lastEdit: getUnixUTCTimestamp(),
-                components: [] as any
-              });
-            }
+        return versions.sort(semver.compare);
+      };
 
-            return callback(err as any, undefined as any);
-          }
+      try {
+        const components = await cdn.listSubDirectories(
+          conf.storage.options.componentsDir
+        );
+        const limit = pLimit(cdn.maxConcurrentRequests);
 
-          async.mapLimit(
-            components,
-            cdn.maxConcurrentRequests,
-            getVersionsForComponent,
-            (errors, versions) => {
-              if (errors) {
-                return callback(errors as any, undefined as any);
-              }
+        const versions = await Promise.all(
+          components.map(component =>
+            limit(() => getVersionsForComponent(component))
+          )
+        );
 
-              components.forEach((component, i) => {
-                componentsInfo[component] = (versions as any)[i];
-              });
+        components.forEach((component, i) => {
+          componentsInfo[component] = versions[i];
+        });
 
-              callback(null, {
-                lastEdit: getUnixUTCTimestamp(),
-                components: componentsInfo
-              });
-            }
-          );
+        return {
+          lastEdit: getUnixUTCTimestamp(),
+          components: componentsInfo
+        };
+      } catch (err: any) {
+        if (err.code === 'dir_not_found') {
+          throw {
+            lastEdit: getUnixUTCTimestamp(),
+            components: [] as any
+          };
         }
-      );
+        throw err;
+      }
     },
 
-    refresh(callback: (err: string | null, data: ComponentsList) => void) {
-      componentsList.getFromDirectories((err, components) => {
-        if (err) {
-          return callback(err, undefined as any);
-        }
-        componentsList.save(components, err => {
-          if (err) {
-            return callback(err, undefined as any);
-          }
-          callback(err, components);
-        });
-      });
+    async refresh(): Promise<ComponentsList> {
+      const components = await componentsList.getFromDirectories();
+      await componentsList.save(components);
+
+      return components;
     },
 
-    save: (
-      data: ComponentsList,
-      callback: (err: string | null, data: unknown) => void
-    ) => cdn.putFileContent(JSON.stringify(data), filePath(), true, callback)
+    save: (data: ComponentsList): Promise<unknown> =>
+      cdn.putFileContent(JSON.stringify(data), filePath(), true)
   };
 
   return componentsList;

package/src/registry/domain/components-cache/index.ts

@@ -2,94 +2,89 @@ import _ from 'lodash';
 import getComponentsList from './components-list';
 import eventsHandler from '../events-handler';
 import getUnixUTCTimestamp from 'oc-get-unix-utc-timestamp';
-import { Cdn, ComponentsList, Config } from '../../../types';
+import { ComponentsList, Config } from '../../../types';
+import { StorageAdapter } from 'oc-storage-adapters-utils';
 
-export default function componentsCache(conf: Config, cdn: Cdn) {
+export default function componentsCache(conf: Config, cdn: StorageAdapter) {
   let cachedComponentsList: ComponentsList;
   let refreshLoop: NodeJS.Timeout;
 
   const componentsList = getComponentsList(conf, cdn);
 
   const poll = () =>
-    setTimeout(() => {
-      componentsList.getFromJson((err, data) => {
-        if (err) {
-          eventsHandler.fire('error', {
-            code: 'components_list_get',
-            message: err
-          });
-        } else {
-          eventsHandler.fire('cache-poll', getUnixUTCTimestamp());
+    setTimeout(async () => {
+      try {
+        const data = await componentsList.getFromJson();
 
-          if (data.lastEdit > cachedComponentsList.lastEdit) {
-            cachedComponentsList = data;
-          }
+        eventsHandler.fire('cache-poll', getUnixUTCTimestamp());
+
+        if (data.lastEdit > cachedComponentsList.lastEdit) {
+          cachedComponentsList = data;
         }
-        refreshLoop = poll();
-      });
+      } catch (err: any) {
+        eventsHandler.fire('error', {
+          code: 'components_list_get',
+          message: err?.message || String(err)
+        });
+      }
+      refreshLoop = poll();
     }, conf.pollingInterval * 1000);
 
-  const cacheDataAndStartPolling = (
-    data: ComponentsList,
-    callback: (err: null, data: ComponentsList) => void
-  ) => {
+  const cacheDataAndStartPolling = (data: ComponentsList) => {
     cachedComponentsList = data;
     refreshLoop = poll();
-    callback(null, data);
+
+    return data;
   };
 
-  const returnError = (
-    code: string,
-    message: string,
-    callback: (err: any | null, data: any) => void
-  ) => {
-    eventsHandler.fire('error', { code, message });
-    return callback(code, undefined as any);
+  const throwError = (code: string, message: any) => {
+    eventsHandler.fire('error', { code, message: message?.message ?? message });
+    throw code;
   };
 
   return {
-    get(callback: (err: Error | null, data: ComponentsList) => void) {
+    get(): ComponentsList {
       if (!cachedComponentsList) {
-        return returnError(
+        return throwError(
           'components_cache_empty',
-          `The component's cache was empty`,
-          callback
+          `The component's cache was empty`
         );
       }
 
-      callback(null, cachedComponentsList);
+      return cachedComponentsList;
     },
 
-    load(callback: (err: Error | null, data: ComponentsList) => void) {
-      componentsList.getFromJson((jsonErr, jsonComponents) => {
-        componentsList.getFromDirectories((dirErr, dirComponents) => {
-          if (dirErr) {
-            return returnError('components_list_get', dirErr, callback);
-          } else if (
-            jsonErr ||
-            !_.isEqual(dirComponents.components, jsonComponents.components)
-          ) {
-            componentsList.save(dirComponents, saveErr => {
-              if (saveErr) {
-                return returnError('components_list_save', saveErr, callback);
-              }
-              cacheDataAndStartPolling(dirComponents, callback);
-            });
-          } else {
-            cacheDataAndStartPolling(jsonComponents, callback);
-          }
-        });
-      });
+    async load(): Promise<ComponentsList> {
+      const dirComponents = await componentsList
+        .getFromDirectories()
+        .catch(err => throwError('components_list_get', err));
+      const jsonComponents = await componentsList
+        .getFromJson()
+        .catch(() => null);
+
+      if (
+        !jsonComponents ||
+        !_.isEqual(dirComponents.components, jsonComponents.components)
+      ) {
+        await componentsList
+          .save(dirComponents)
+          .catch(err => throwError('components_list_save', err));
+      }
+      cacheDataAndStartPolling(dirComponents);
+
+      return dirComponents;
     },
-    refresh(callback: (err: Error | null, data: ComponentsList) => void) {
+
+    async refresh(): Promise<ComponentsList> {
       clearTimeout(refreshLoop);
-      componentsList.refresh((err, components) => {
-        if (err) {
-          return returnError('components_cache_refresh', err, callback);
-        }
+      try {
+        const components = await componentsList.refresh();
+        cacheDataAndStartPolling(components);
 
-        cacheDataAndStartPolling(components, callback);
-      });
+        return components;
+      } catch (err) {
+        return throwError('components_cache_refresh', err);
+      }
     }
   };
 }

package/src/registry/domain/components-details.ts

@@ -1,39 +1,34 @@
-import async from 'async';
+import pLimit from 'p-limit';
 import _ from 'lodash';
 import eventsHandler from './events-handler';
 import getUnixUTCTimestamp from 'oc-get-unix-utc-timestamp';
 import {
-  Cdn,
   Component,
   ComponentsDetails,
   ComponentsList,
   Config
 } from '../../types';
+import { StorageAdapter } from 'oc-storage-adapters-utils';
 
-export default function componentsDetails(conf: Config, cdn: Cdn) {
-  const returnError = (
-    code: string,
-    message: string | Error,
-    callback: (code: string) => void
-  ) => {
+export default function componentsDetails(conf: Config, cdn: StorageAdapter) {
+  const returnError = (code: string, message: string | Error) => {
     eventsHandler.fire('error', {
       code,
       message: (message as Error)?.message ?? message
     });
-    return callback(code);
+    throw code;
   };
 
   const filePath = (): string =>
     `${conf.storage.options.componentsDir}/components-details.json`;
 
-  const getFromJson = (
-    callback: (err: string | null, data: ComponentsDetails) => void
-  ) => cdn.getJson<ComponentsDetails>(filePath(), true, callback);
+  const getFromJson = (): Promise<ComponentsDetails> =>
+    cdn.getJson(filePath(), true);
 
-  const getFromDirectories = (
-    options: { componentsList: ComponentsList; details: ComponentsDetails },
-    callback: (err: Error | undefined | null, data: ComponentsDetails) => void
-  ) => {
+  const getFromDirectories = async (options: {
+    componentsList: ComponentsList;
+    details?: ComponentsDetails;
+  }): Promise<ComponentsDetails> => {
     const details = Object.assign({}, _.cloneDeep(options.details));
     details.components = details.components || {};
 
@@ -47,72 +42,51 @@ export default function componentsDetails(conf: Config, cdn: Cdn) {
       });
     });
 
-    async.eachLimit(
-      missing,
-      cdn.maxConcurrentRequests,
-      ({ name, version }, next) => {
-        cdn.getJson<Component>(
-          `${conf.storage.options.componentsDir}/${name}/${version}/package.json`,
-          true,
-          (err, content) => {
-            if (err) {
-              return next(err as any);
-            }
-            details.components[name][version] = {
-              publishDate: content.oc.date || 0
-            };
-            next();
-          }
-        );
-      },
-      err =>
-        callback(err, {
-          lastEdit: getUnixUTCTimestamp(),
-          components: details.components
+    const limit = pLimit(cdn.maxConcurrentRequests);
+
+    await Promise.all(
+      missing.map(({ name, version }) =>
+        limit(async () => {
+          const content: Component = await cdn.getJson(
+            `${conf.storage.options.componentsDir}/${name}/${version}/package.json`,
+            true
+          );
+          details.components[name][version] = {
+            publishDate: content.oc.date || 0
+          };
         })
+      )
     );
+
+    return {
+      lastEdit: getUnixUTCTimestamp(),
+      components: details.components
+    };
   };
 
-  const save = (
-    data: ComponentsDetails,
-    callback: (err: string | null, data: unknown) => void
-  ) => cdn.putFileContent(JSON.stringify(data), filePath(), true, callback);
+  const save = (data: ComponentsDetails): Promise<unknown> =>
+    cdn.putFileContent(JSON.stringify(data), filePath(), true);
 
-  const refresh = (
-    componentsList: ComponentsList,
-    callback: (err: Error | null, data: ComponentsDetails) => void
-  ) => {
-    getFromJson((jsonErr, details: ComponentsDetails) => {
-      getFromDirectories(
-        { componentsList, details },
-        (dirErr, dirDetails: ComponentsDetails) => {
-          if (dirErr) {
-            return returnError(
-              'components_details_get',
-              dirErr,
-              callback as any
-            );
-          } else if (
-            jsonErr ||
-            !_.isEqual(dirDetails.components, details.components)
-          ) {
-            save(dirDetails, saveErr => {
-              if (saveErr) {
-                return returnError(
-                  'components_details_save',
-                  saveErr,
-                  callback as any
-                );
-              }
+  const refresh = async (
+    componentsList: ComponentsList
+  ): Promise<ComponentsDetails> => {
+    const jsonDetails = await getFromJson().catch(() => undefined);
+    const dirDetails = await getFromDirectories({
+      componentsList,
+      details: jsonDetails
+    }).catch(err => returnError('components_details_get', err));
 
-              callback(null, dirDetails);
-            });
-          } else {
-            callback(null, details);
-          }
-        }
+    if (
+      !jsonDetails ||
+      !_.isEqual(dirDetails.components, jsonDetails.components)
+    ) {
+      await save(dirDetails).catch(err =>
+        returnError('components_details_save', err)
       );
-    });
+      return dirDetails;
+    }
+
+    return jsonDetails;
   };
 
   return {

package/src/registry/domain/extract-package.ts

@@ -1,23 +1,20 @@
 import path from 'path';
 import targz from 'targz';
+import { promisify } from 'util';
 import { PackageJson } from 'type-fest';
 
 import getPackageJsonFromTempDir from './get-package-json-from-temp-dir';
 
-export default function extractPackage(
+export default async function extractPackage(
   files:
     | Express.Multer.File[]
     | {
         [fieldname: string]: Express.Multer.File[];
-      },
-  callback: (
-    err: Error | null,
-    data: {
-      outputFolder: string;
-      packageJson: PackageJson;
-    }
-  ) => void
-): void {
+      }
+): Promise<{
+  outputFolder: string;
+  packageJson: PackageJson;
+}> {
   const packageFile: Express.Multer.File = (files as any)[0];
   const packagePath = path.resolve(packageFile.path);
   const packageUntarOutput = path.resolve(
@@ -27,22 +24,17 @@ export default function extractPackage(
   );
   const packageOutput = path.resolve(packageUntarOutput, '_package');
 
-  targz.decompress(
-    {
-      src: packagePath,
-      dest: packageUntarOutput
-    },
-    err => {
-      if (err) {
-        return (callback as any)(err);
-      }
+  const decompress = promisify(targz.decompress);
 
-      getPackageJsonFromTempDir(packageOutput, (err, packageJson) => {
-        callback(err, {
-          outputFolder: packageOutput,
-          packageJson: packageJson
-        });
-      });
-    }
-  );
+  await decompress({
+    src: packagePath,
+    dest: packageUntarOutput
+  });
+
+  const packageJson = await getPackageJsonFromTempDir(packageOutput);
+
+  return {
+    outputFolder: packageOutput,
+    packageJson: packageJson
+  };
 }

package/src/registry/domain/get-package-json-from-temp-dir.ts

@@ -3,8 +3,7 @@ import path from 'path';
 import { PackageJson } from 'type-fest';
 
 export default function getPackageJsonFromTempDir(
-  tempDirPath: string,
-  callback: (err: Error | null, data: PackageJson) => void
-): void {
-  return fs.readJson(path.join(tempDirPath, 'package.json'), callback);
+  tempDirPath: string
+): Promise<PackageJson> {
+  return fs.readJson(path.join(tempDirPath, 'package.json'));
 }