Merge branch 'master' into ts-routes

Author: ricardo-devis-agullo

src/registry/domain/components-cache/components-list.js

@@ -0,0 +1,88 @@
+import async from 'async';
+import semver from 'semver';
+import getUnixUTCTimestamp from 'oc-get-unix-utc-timestamp';
+import { Cdn, ComponentsList, Config } from '../../../types';
+
+export default function componentsList(conf: Config, cdn: Cdn) {
+  const filePath = (): string =>
+    `${conf.storage.options.componentsDir}/components.json`;
+
+  const componentsList = {
+    getFromJson: (callback: Callback<any, string>) =>
+      cdn.getJson(filePath(), true, callback),
+
+    getFromDirectories: (callback: Callback<ComponentsList, string>) => {
+      const componentsInfo: Dictionary<string[]> = {};
+
+      const getVersionsForComponent = (
+        componentName: string,
+        cb: Callback<string[]>
+      ) => {
+        cdn.listSubDirectories(
+          `${conf.storage.options.componentsDir}/${componentName}`,
+          (err, versions) => {
+            if (err) {
+              return cb(err, undefined as any);
+            }
+            cb(null, versions.sort(semver.compare));
+          }
+        );
+      };
+
+      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 callback(err as any, undefined as any);
+          }
+
+          async.mapLimit(
+            components,
+            cdn.maxConcurrentRequests,
+            getVersionsForComponent,
+            (errors, versions) => {
+              if (errors) {
+                return callback(errors as any, undefined as any);
+              }
+
+              components.forEach((component, i) => {
+                componentsInfo[component] = (versions as any)[i];
+              });
+
+              callback(null, {
+                lastEdit: getUnixUTCTimestamp(),
+                components: componentsInfo
+              });
+            }
+          );
+        }
+      );
+    },
+
+    refresh(callback: Callback<ComponentsList, string>) {
+      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);
+        });
+      });
+    },
+
+    save: (data: ComponentsList, callback: Callback<unknown, string>) =>
+      cdn.putFileContent(JSON.stringify(data), filePath(), true, callback)
+  };
+
+  return componentsList;
+}

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

@@ -1,15 +1,14 @@
-'use strict';
+import _ from 'lodash';
+import getComponentsList from './components-list';
+import * as eventsHandler from '../events-handler';
+import getUnixUTCTimestamp from 'oc-get-unix-utc-timestamp';
+import { Cdn, ComponentsList, Config } from '../../../types';
 
-const _ = require('lodash');
+export default function componentsCache(conf: Config, cdn: Cdn) {
+  let cachedComponentsList: ComponentsList;
+  let refreshLoop: NodeJS.Timeout;
 
-const ComponentsList = require('./components-list');
-const eventsHandler = require('../events-handler');
-const getUnixUTCTimestamp = require('oc-get-unix-utc-timestamp');
-
-module.exports = (conf, cdn) => {
-  let cachedComponentsList, refreshLoop;
-
-  const componentsList = ComponentsList(conf, cdn);
+  const componentsList = getComponentsList(conf, cdn);
 
   const poll = () =>
     setTimeout(() => {
@@ -30,19 +29,26 @@ module.exports = (conf, cdn) => {
       });
     }, conf.pollingInterval * 1000);
 
-  const cacheDataAndStartPolling = (data, callback) => {
+  const cacheDataAndStartPolling = (
+    data: ComponentsList,
+    callback: (err: null, data: ComponentsList) => void
+  ) => {
     cachedComponentsList = data;
     refreshLoop = poll();
     callback(null, data);
   };
 
-  const returnError = (code, message, callback) => {
+  const returnError = (
+    code: string,
+    message: string,
+    callback: Callback<any, any>
+  ) => {
     eventsHandler.fire('error', { code, message });
-    return callback(code);
+    return callback(code, undefined as any);
   };
 
   return {
-    get: callback => {
+    get(callback: Callback<ComponentsList>) {
       if (!cachedComponentsList) {
         return returnError(
           'components_cache_empty',
@@ -54,7 +60,7 @@ module.exports = (conf, cdn) => {
       callback(null, cachedComponentsList);
     },
 
-    load: callback => {
+    load(callback: Callback<ComponentsList>) {
       componentsList.getFromJson((jsonErr, jsonComponents) => {
         componentsList.getFromDirectories((dirErr, dirComponents) => {
           if (dirErr) {
@@ -75,7 +81,7 @@ module.exports = (conf, cdn) => {
         });
       });
     },
-    refresh: callback => {
+    refresh(callback: Callback<ComponentsList>) {
       clearTimeout(refreshLoop);
       componentsList.refresh((err, components) => {
         if (err) {
@@ -86,4 +92,4 @@ module.exports = (conf, cdn) => {
       });
     }
   };
-};
+}