oc 0.49.6 → 0.49.9

package/src/registry/domain/nested-renderer.ts

@@ -1,145 +1,87 @@
-import async from 'async';
-import _ from 'lodash';
-
 import settings from '../../resources/settings';
 import strings from '../../resources';
 import { Config } from '../../types';
+import {
+  GetComponentResult,
+  RendererOptions
+} from '../routes/helpers/get-component';
 
-type Cb = (err: string | null, data: string) => void;
-type Options = {
+interface Options {
+  ip?: string;
   version?: string;
   name?: string;
   headers?: Record<string, string>;
   parameters?: Record<string, string>;
-};
-type Params = {
-  components: Options[];
-  options: Options;
-  callback: Cb;
-};
-
-const sanitise = {
-  componentParams(component: string, options: Options | Cb, callback?: Cb) {
-    return {
-      ...sanitise.options(options, callback),
-      componentName: component
-    };
-  },
-  componentsParams(
-    components: Options[],
-    options: Options | Cb,
-    callback: Cb
-  ): Params {
-    return {
-      ...sanitise.options(options, callback),
-      components: components
-    };
-  },
-  headers(h = {}) {
-    return {
-      ...h,
-      accept: settings.registry.acceptRenderedHeader
-    };
-  },
-  options(
-    options: Options | Cb,
-    callback?: Cb
-  ): { options: Options; callback: Cb } {
-    const cb = !callback && typeof options === 'function' ? options : callback;
-    const opts = typeof options === 'function' ? {} : options;
-
-    return { callback: cb!, options: opts };
-  }
-};
-
-const validate = {
-  callback(c: Cb) {
-    if (!c || typeof c !== 'function') {
-      throw new Error(
-        strings.errors.registry.NESTED_RENDERER_CALLBACK_IS_NOT_VALID
-      );
-    }
-  },
-  componentParams(params: { componentName: string; callback: Cb }) {
-    if (!params.componentName) {
-      throw new Error(
-        strings.errors.registry.NESTED_RENDERER_COMPONENT_NAME_IS_NOT_VALID
-      );
-    }
-
-    validate.callback(params.callback);
-  },
-  componentsParams(params: Params) {
-    if (_.isEmpty(params.components)) {
-      throw new Error(
-        strings.errors.registry.NESTED_RENDERER_COMPONENTS_IS_NOT_VALID
-      );
-    }
+}
 
-    validate.callback(params.callback);
-  }
-};
+export default function nestedRenderer(
+  rendererWithCallback: (
+    options: RendererOptions,
+    cb: (result: GetComponentResult) => void
+  ) => void,
+  conf: Config
+) {
+  const renderer = (options: RendererOptions) =>
+    new Promise<string>((res, rej) => {
+      rendererWithCallback(options, result => {
+        if (result.response.error) {
+          rej(result.response.error);
+        } else {
+          res(result.response.html!);
+        }
+      });
+    });
 
-export default function nestedRenderer(renderer: any, conf: Config) {
   return {
     renderComponent(
       componentName: string,
-      renderOptions: Options | Cb,
-      callback?: Cb
-    ) {
-      const p = sanitise.componentParams(
-        componentName,
-        renderOptions,
-        callback
-      );
-      validate.componentParams(p);
+      options: Options = {}
+    ): Promise<string> {
+      if (!componentName) {
+        throw new Error(
+          strings.errors.registry.NESTED_RENDERER_COMPONENT_NAME_IS_NOT_VALID
+        );
+      }
 
-      return renderer(
-        {
-          conf: conf,
-          headers: sanitise.headers(p.options.headers),
-          name: componentName,
-          parameters: p.options.parameters || {},
-          version: p.options.version || ''
+      return renderer({
+        conf: conf,
+        ip: options.ip || '',
+        headers: {
+          ...options.headers,
+          accept: settings.registry.acceptRenderedHeader
         },
-        (result: any) => {
-          if (result.response.error) {
-            return p.callback(result.response.error, undefined as any);
-          } else {
-            return p.callback(null, result.response.html);
-          }
-        }
-      );
+        name: componentName,
+        parameters: options.parameters || {},
+        version: options.version || ''
+      });
     },
     renderComponents(
       components: Options[],
-      renderOptions: Options,
-      callback: Cb
-    ) {
-      const p = sanitise.componentsParams(components, renderOptions, callback);
-      validate.componentsParams(p);
+      options: Options = {}
+    ): Promise<Array<string | Error>> {
+      if (!components || !components.length) {
+        throw new Error(
+          strings.errors.registry.NESTED_RENDERER_COMPONENTS_IS_NOT_VALID
+        );
+      }
 
-      async.map(
-        p.components,
-        (component, cb) => {
-          renderer(
-            {
-              conf: conf,
-              headers: sanitise.headers(p.options.headers),
-              name: component.name,
-              parameters: {
-                ...p.options.parameters,
-                ...component.parameters
-              },
-              version: component.version || ''
+      return Promise.all(
+        components.map(component => {
+          return renderer({
+            conf: conf,
+            headers: {
+              ...options.headers,
+              accept: settings.registry.acceptRenderedHeader
             },
-            (result: any) => {
-              const error = result.response.error;
-              cb(null, error ? new Error(error) : result.response.html);
-            }
-          );
-        },
-        p.callback as any
+            ip: component.ip || '',
+            name: component.name!,
+            parameters: {
+              ...options.parameters,
+              ...component.parameters
+            },
+            version: component.version || ''
+          }).catch(err => new Error(err));
+        })
       );
     }
   };

package/src/registry/domain/options-sanitiser.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import settings from '../../resources/settings';
 import { Config } from '../../types';
 import * as auth from './authentication';
@@ -10,7 +9,7 @@ interface Input extends Partial<Omit<Config, 'beforePublish'>> {
 }
 
 export default function optionsSanitiser(input: Input): Config {
-  const options = _.clone(input);
+  const options = { ...input };
 
   if (!options.publishAuth) {
     (options as Config).beforePublish = (_req, _res, next) => next();
@@ -57,9 +56,13 @@ export default function optionsSanitiser(input: Input): Config {
     options.templates = [];
   }
 
+  if (!options.dependencies) {
+    options.dependencies = [];
+  }
+
   if (
     typeof options.fallbackRegistryUrl !== 'undefined' &&
-    _.last(options.fallbackRegistryUrl) !== '/'
+    !options.fallbackRegistryUrl.endsWith('/')
   ) {
     options.fallbackRegistryUrl += '/';
   }

package/src/registry/domain/plugins-initialiser.ts

@@ -1,15 +1,14 @@
-import async from 'async';
+import pLimit from 'p-limit';
 import _ from 'lodash';
 import { DepGraph } from 'dependency-graph';
+import { promisify } from 'util';
 
 import strings from '../../resources';
 import { Plugin } from '../../types';
 
 function validatePlugins(plugins: unknown[]): asserts plugins is Plugin[] {
-  let c = 0;
-
-  plugins.forEach(plugin => {
-    c++;
+  for (let idx = 0; idx < plugins.length; idx++) {
+    const plugin = plugins[idx];
     if (
       !_.isObject((plugin as Plugin).register) ||
       typeof (plugin as Plugin).register.register !== 'function' ||
@@ -18,11 +17,11 @@ function validatePlugins(plugins: unknown[]): asserts plugins is Plugin[] {
     ) {
       throw new Error(
         strings.errors.registry.PLUGIN_NOT_VALID(
-          (plugin as Plugin).name || String(c)
+          (plugin as Plugin).name || String(idx + 1)
         )
       );
     }
-  });
+  }
 }
 
 function checkDependencies(plugins: Plugin[]) {
@@ -48,26 +47,16 @@ function checkDependencies(plugins: Plugin[]) {
 }
 
 let deferredLoads: Plugin[] = [];
-const defer = function (plugin: Plugin, cb: (err?: Error) => void) {
-  deferredLoads.push(plugin);
-  return cb();
-};
-
-export function init(
-  pluginsToRegister: unknown[],
-  callback: (
-    err: unknown,
-    data: Record<string, (...args: unknown[]) => void>
-  ) => void
-): void {
-  const registered: Record<string, (...args: unknown[]) => void> = {};
-
-  try {
-    validatePlugins(pluginsToRegister);
-    checkDependencies(pluginsToRegister);
-  } catch (err) {
-    return callback(err, undefined as any);
-  }
+
+type PluginFunctions = Record<string, (...args: unknown[]) => void>;
+
+export async function init(
+  pluginsToRegister: unknown[]
+): Promise<PluginFunctions> {
+  const registered: PluginFunctions = {};
+
+  validatePlugins(pluginsToRegister);
+  checkDependencies(pluginsToRegister);
 
   const dependenciesRegistered = (dependencies: string[]) => {
     if (dependencies.length === 0) {
@@ -84,11 +73,9 @@ export function init(
     return present;
   };
 
-  const loadPlugin = (plugin: Plugin, cb: (err?: Error) => void) => {
-    const done = _.once(cb);
-
+  const loadPlugin = async (plugin: Plugin): Promise<void> => {
     if (registered[plugin.name]) {
-      return done();
+      return;
     }
 
     if (!plugin.register.dependencies) {
@@ -96,36 +83,45 @@ export function init(
     }
 
     if (!dependenciesRegistered(plugin.register.dependencies)) {
-      return defer(plugin, done);
+      deferredLoads.push(plugin);
+      return;
     }
 
     const dependencies = _.pick(registered, plugin.register.dependencies);
 
-    plugin.register.register(
-      plugin.options || {},
-      dependencies,
-      (err?: Error) => {
-        const pluginCallback = plugin.callback || _.noop;
-        pluginCallback(err);
-        // Overriding toString so implementation details of plugins do not
-        // leak to OC consumers
-        plugin.register.execute.toString = () => plugin.description || '';
-        registered[plugin.name] = plugin.register.execute;
-        done(err);
-      }
-    );
+    const register = promisify(plugin.register.register);
+
+    const pluginCallback = plugin.callback || _.noop;
+    await register(plugin.options || {}, dependencies).catch(err => {
+      pluginCallback(err);
+      throw err;
+    });
+    // Overriding toString so implementation details of plugins do not
+    // leak to OC consumers
+    plugin.register.execute.toString = () => plugin.description || '';
+    registered[plugin.name] = plugin.register.execute;
+    pluginCallback();
   };
 
-  const terminator = function (err: Error) {
+  const terminator = async (): Promise<PluginFunctions> => {
     if (deferredLoads.length > 0) {
       const deferredPlugins = _.clone(deferredLoads);
       deferredLoads = [];
 
-      return async.mapSeries(deferredPlugins, loadPlugin, terminator as any);
+      await Promise.all(
+        deferredPlugins.map(plugin => onSeries(() => loadPlugin(plugin)))
+      );
+      return terminator();
     }
 
-    callback(err, registered);
+    return registered;
   };
 
-  async.mapSeries(pluginsToRegister, loadPlugin, terminator as any);
+  const onSeries = pLimit(1);
+
+  await Promise.all(
+    pluginsToRegister.map(plugin => onSeries(() => loadPlugin(plugin)))
+  );
+
+  return terminator();
 }