oc 0.49.7 → 0.49.8

package/dist/registry/domain/plugins-initialiser.js

@@ -4,21 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = void 0;
-const async_1 = __importDefault(require("async"));
+const p_limit_1 = __importDefault(require("p-limit"));
 const lodash_1 = __importDefault(require("lodash"));
 const dependency_graph_1 = require("dependency-graph");
+const util_1 = require("util");
 const resources_1 = __importDefault(require("../../resources"));
 function validatePlugins(plugins) {
-    let c = 0;
-    plugins.forEach(plugin => {
-        c++;
+    for (let idx = 0; idx < plugins.length; idx++) {
+        const plugin = plugins[idx];
         if (!lodash_1.default.isObject(plugin.register) ||
             typeof plugin.register.register !== 'function' ||
             typeof plugin.register.execute !== 'function' ||
             typeof plugin.name !== 'string') {
-            throw new Error(resources_1.default.errors.registry.PLUGIN_NOT_VALID(plugin.name || String(c)));
+            throw new Error(resources_1.default.errors.registry.PLUGIN_NOT_VALID(plugin.name || String(idx + 1)));
         }
-    });
+    }
 }
 function checkDependencies(plugins) {
     const graph = new dependency_graph_1.DepGraph();
@@ -39,19 +39,10 @@ function checkDependencies(plugins) {
     return graph.overallOrder();
 }
 let deferredLoads = [];
-const defer = function (plugin, cb) {
-    deferredLoads.push(plugin);
-    return cb();
-};
-function init(pluginsToRegister, callback) {
+async function init(pluginsToRegister) {
     const registered = {};
-    try {
-        validatePlugins(pluginsToRegister);
-        checkDependencies(pluginsToRegister);
-    }
-    catch (err) {
-        return callback(err, undefined);
-    }
+    validatePlugins(pluginsToRegister);
+    checkDependencies(pluginsToRegister);
     const dependenciesRegistered = (dependencies) => {
         if (dependencies.length === 0) {
             return true;
@@ -64,36 +55,41 @@ function init(pluginsToRegister, callback) {
         });
         return present;
     };
-    const loadPlugin = (plugin, cb) => {
-        const done = lodash_1.default.once(cb);
+    const loadPlugin = async (plugin) => {
         if (registered[plugin.name]) {
-            return done();
+            return;
         }
         if (!plugin.register.dependencies) {
             plugin.register.dependencies = [];
         }
         if (!dependenciesRegistered(plugin.register.dependencies)) {
-            return defer(plugin, done);
+            deferredLoads.push(plugin);
+            return;
         }
         const dependencies = lodash_1.default.pick(registered, plugin.register.dependencies);
-        plugin.register.register(plugin.options || {}, dependencies, (err) => {
-            const pluginCallback = plugin.callback || lodash_1.default.noop;
+        const register = (0, util_1.promisify)(plugin.register.register);
+        const pluginCallback = plugin.callback || lodash_1.default.noop;
+        await register(plugin.options || {}, dependencies).catch(err => {
             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);
+            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) {
+    const terminator = async () => {
         if (deferredLoads.length > 0) {
             const deferredPlugins = lodash_1.default.clone(deferredLoads);
             deferredLoads = [];
-            return async_1.default.mapSeries(deferredPlugins, loadPlugin, terminator);
+            await Promise.all(deferredPlugins.map(plugin => onSeries(() => loadPlugin(plugin))));
+            return terminator();
         }
-        callback(err, registered);
+        return registered;
     };
-    async_1.default.mapSeries(pluginsToRegister, loadPlugin, terminator);
+    const onSeries = (0, p_limit_1.default)(1);
+    await Promise.all(pluginsToRegister.map(plugin => onSeries(() => loadPlugin(plugin))));
+    return terminator();
 }
 exports.init = init;

package/dist/registry/domain/repository.js

@@ -25,18 +25,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const oc_get_unix_utc_timestamp_1 = __importDefault(require("oc-get-unix-utc-timestamp"));
 const path_1 = __importDefault(require("path"));
-const lodash_1 = __importDefault(require("lodash"));
 const components_cache_1 = __importDefault(require("./components-cache"));
 const components_details_1 = __importDefault(require("./components-details"));
 const register_templates_1 = __importDefault(require("./register-templates"));
 const settings_1 = __importDefault(require("../../resources/settings"));
 const resources_1 = __importDefault(require("../../resources"));
 const validator = __importStar(require("./validators"));
+const storage_adapter_1 = __importDefault(require("./storage-adapter"));
 const versionHandler = __importStar(require("./version-handler"));
 const error_to_string_1 = __importDefault(require("../../utils/error-to-string"));
 const packageInfo = fs_extra_1.default.readJsonSync(path_1.default.join(__dirname, '..', '..', '..', 'package.json'));
 function repository(conf) {
-    const cdn = !conf.local && conf.storage.adapter(conf.storage.options);
+    const cdn = !conf.local &&
+        (0, storage_adapter_1.default)(conf.storage.adapter(conf.storage.options));
     const options = !conf.local ? conf.storage.options : null;
     const repositorySource = conf.local
         ? 'local repository'
@@ -70,18 +71,21 @@ function repository(conf) {
             validComponents.push('oc-client');
             return validComponents;
         },
-        getComponentVersions(componentName, callback) {
+        getComponentVersions(componentName) {
             if (componentName === 'oc-client') {
-                return callback(null, [
-                    fs_extra_1.default.readJsonSync(path_1.default.join(__dirname, '../../../package.json')).version
+                return Promise.all([
+                    fs_extra_1.default
+                        .readJson(path_1.default.join(__dirname, '../../../package.json'))
+                        .then(x => x.version)
                 ]);
             }
-            if (!lodash_1.default.includes(local.getComponents(), componentName)) {
-                return callback(resources_1.default.errors.registry.COMPONENT_NOT_FOUND(componentName, repositorySource), undefined);
+            if (!local.getComponents().includes(componentName)) {
+                return Promise.reject(resources_1.default.errors.registry.COMPONENT_NOT_FOUND(componentName, repositorySource));
             }
-            callback(null, [
-                fs_extra_1.default.readJsonSync(path_1.default.join(conf.path, `${componentName}/package.json`))
-                    .version
+            return Promise.all([
+                fs_extra_1.default
+                    .readJson(path_1.default.join(conf.path, `${componentName}/package.json`))
+                    .then(x => x.version)
             ]);
         },
         getDataProvider(componentName) {
@@ -96,39 +100,29 @@ function repository(conf) {
         }
     };
     const repository = {
-        getCompiledView(componentName, componentVersion, callback) {
+        getCompiledView(componentName, componentVersion) {
             if (conf.local) {
-                return callback(null, local.getCompiledView(componentName));
+                return Promise.resolve(local.getCompiledView(componentName));
             }
-            cdn.getFile(getFilePath(componentName, componentVersion, 'template.js'), callback);
+            return cdn.getFile(getFilePath(componentName, componentVersion, 'template.js'));
         },
-        getComponent(componentName, componentVersionOrCallback, callbackMaybe) {
-            const componentVersion = typeof componentVersionOrCallback === 'function'
-                ? undefined
-                : componentVersionOrCallback;
-            const callback = typeof componentVersionOrCallback === 'function'
-                ? componentVersionOrCallback
-                : callbackMaybe;
-            repository.getComponentVersions(componentName, (err, allVersions) => {
-                if (err) {
-                    return callback(err, undefined);
-                }
-                if (allVersions.length === 0) {
-                    return callback(resources_1.default.errors.registry.COMPONENT_NOT_FOUND(componentName, repositorySource), undefined);
-                }
-                const version = versionHandler.getAvailableVersion(componentVersion, allVersions);
-                if (!version) {
-                    return callback(resources_1.default.errors.registry.COMPONENT_VERSION_NOT_FOUND(componentName, componentVersion || '', repositorySource), undefined);
-                }
-                repository.getComponentInfo(componentName, version, (err, component) => {
-                    if (err) {
-                        return callback(`component not available: ${(0, error_to_string_1.default)(err)}`, null);
-                    }
-                    callback(null, Object.assign(component, { allVersions }));
-                });
+        async getComponent(componentName, componentVersion) {
+            const allVersions = await repository.getComponentVersions(componentName);
+            if (allVersions.length === 0) {
+                throw resources_1.default.errors.registry.COMPONENT_NOT_FOUND(componentName, repositorySource);
+            }
+            const version = versionHandler.getAvailableVersion(componentVersion, allVersions);
+            if (!version) {
+                throw resources_1.default.errors.registry.COMPONENT_VERSION_NOT_FOUND(componentName, componentVersion || '', repositorySource);
+            }
+            const component = await repository
+                .getComponentInfo(componentName, version)
+                .catch(err => {
+                throw `component not available: ${(0, error_to_string_1.default)(err)}`;
             });
+            return Object.assign(component, { allVersions });
         },
-        getComponentInfo(componentName, componentVersion, callback) {
+        getComponentInfo(componentName, componentVersion) {
             if (conf.local) {
                 let componentInfo;
                 if (componentName === 'oc-client') {
@@ -138,13 +132,14 @@ function repository(conf) {
                     componentInfo = fs_extra_1.default.readJsonSync(path_1.default.join(conf.path, `${componentName}/_package/package.json`));
                 }
                 if (componentInfo.version === componentVersion) {
-                    return callback(null, componentInfo);
+                    return Promise.resolve(componentInfo);
                 }
                 else {
-                    return callback('version not available', undefined);
+                    // eslint-disable-next-line prefer-promise-reject-errors
+                    return Promise.reject('version not available');
                 }
             }
-            cdn.getJson(getFilePath(componentName, componentVersion, 'package.json'), callback);
+            return cdn.getJson(getFilePath(componentName, componentVersion, 'package.json'), false);
         },
         getComponentPath(componentName, componentVersion) {
             const prefix = conf.local
@@ -152,106 +147,89 @@ function repository(conf) {
                 : `${options['path']}${options.componentsDir}/`;
             return `${prefix}${componentName}/${componentVersion}/`;
         },
-        getComponents(callback) {
+        async getComponents() {
             if (conf.local) {
-                return callback(null, local.getComponents());
+                return local.getComponents();
             }
-            componentsCache.get((err, res) => callback(err, res ? Object.keys(res.components) : null));
+            const { components } = await componentsCache.get();
+            return Object.keys(components);
         },
-        getComponentsDetails(callback) {
+        getComponentsDetails() {
             if (conf.local) {
-                return callback();
+                // when in local this won't get called
+                return Promise.resolve(null);
             }
-            componentsDetails.get(callback);
+            return componentsDetails.get();
         },
-        getComponentVersions(componentName, callback) {
+        async getComponentVersions(componentName) {
             if (conf.local) {
-                return local.getComponentVersions(componentName, callback);
+                return local.getComponentVersions(componentName);
             }
-            componentsCache.get((err, res) => {
-                callback(err, !!res && !!lodash_1.default.has(res.components, componentName)
-                    ? res.components[componentName]
-                    : []);
-            });
+            const res = await componentsCache.get();
+            return res.components[componentName] ? res.components[componentName] : [];
         },
-        getDataProvider(componentName, componentVersion, callback) {
+        async getDataProvider(componentName, componentVersion) {
             if (conf.local) {
-                return callback(null, local.getDataProvider(componentName));
+                return local.getDataProvider(componentName);
             }
             const filePath = getFilePath(componentName, componentVersion, 'server.js');
-            cdn.getFile(filePath, (err, content) => callback(err, content ? { content, filePath } : null));
+            const content = await cdn.getFile(filePath);
+            return { content, filePath };
         },
         getStaticClientPath: () => `${options['path']}${getFilePath('oc-client', packageInfo.version, 'src/oc-client.min.js')}`,
         getStaticClientMapPath: () => `${options['path']}${getFilePath('oc-client', packageInfo.version, 'src/oc-client.min.map')}`,
         getStaticFilePath: (componentName, componentVersion, filePath) => `${repository.getComponentPath(componentName, componentVersion)}${conf.local ? settings_1.default.registry.localStaticRedirectorPath : ''}${filePath}`,
         getTemplatesInfo: () => templatesInfo,
         getTemplate: (type) => templatesHash[type],
-        init(callback) {
+        async init() {
             if (conf.local) {
-                return callback(null, 'ok');
+                // when in local this won't get called
+                return 'ok';
             }
-            componentsCache.load((err, componentsList) => {
-                if (err) {
-                    return callback(err, undefined);
-                }
-                componentsDetails.refresh(componentsList, err => callback(err, componentsList));
-            });
+            const componentsList = await componentsCache.load();
+            return componentsDetails.refresh(componentsList);
         },
-        publishComponent(pkgDetails, componentName, componentVersion, callback) {
+        async publishComponent(pkgDetails, componentName, componentVersion) {
             if (conf.local) {
-                return callback({
+                throw {
                     code: resources_1.default.errors.registry.LOCAL_PUBLISH_NOT_ALLOWED_CODE,
                     msg: resources_1.default.errors.registry.LOCAL_PUBLISH_NOT_ALLOWED
-                }, undefined);
+                };
             }
             if (!validator.validateComponentName(componentName)) {
-                return callback({
+                throw {
                     code: resources_1.default.errors.registry.COMPONENT_NAME_NOT_VALID_CODE,
                     msg: resources_1.default.errors.registry.COMPONENT_NAME_NOT_VALID
-                }, undefined);
+                };
             }
             if (!validator.validateVersion(componentVersion)) {
-                return callback({
+                throw {
                     code: resources_1.default.errors.registry.COMPONENT_VERSION_NOT_VALID_CODE,
                     msg: resources_1.default.errors.registry.COMPONENT_VERSION_NOT_VALID(componentVersion)
-                }, undefined);
+                };
             }
             const validationResult = validator.validatePackageJson(Object.assign(pkgDetails, {
                 componentName,
                 customValidator: conf.publishValidation
             }));
             if (!validationResult.isValid) {
-                return callback({
+                throw {
                     code: resources_1.default.errors.registry.COMPONENT_PUBLISHVALIDATION_FAIL_CODE,
                     msg: resources_1.default.errors.registry.COMPONENT_PUBLISHVALIDATION_FAIL(String(validationResult.error))
-                }, undefined);
+                };
             }
-            repository.getComponentVersions(componentName, (_err, componentVersions) => {
-                if (!versionHandler.validateNewVersion(componentVersion, componentVersions)) {
-                    return callback({
-                        code: resources_1.default.errors.registry
-                            .COMPONENT_VERSION_ALREADY_FOUND_CODE,
-                        msg: resources_1.default.errors.registry.COMPONENT_VERSION_ALREADY_FOUND(componentName, componentVersion, repositorySource)
-                    }, undefined);
-                }
-                pkgDetails.packageJson.oc.date = (0, oc_get_unix_utc_timestamp_1.default)();
-                fs_extra_1.default.writeJSON(path_1.default.join(pkgDetails.outputFolder, 'package.json'), pkgDetails.packageJson, err => {
-                    if (err) {
-                        return callback(err, undefined);
-                    }
-                    cdn.putDir(pkgDetails.outputFolder, `${options.componentsDir}/${componentName}/${componentVersion}`, err => {
-                        if (err) {
-                            return callback(err, undefined);
-                        }
-                        componentsCache.refresh((err, componentsList) => {
-                            if (err) {
-                                return callback(err, undefined);
-                            }
-                            componentsDetails.refresh(componentsList, callback);
-                        });
-                    });
-                });
-            });
+            const componentVersions = await repository.getComponentVersions(componentName);
+            if (!versionHandler.validateNewVersion(componentVersion, componentVersions)) {
+                throw {
+                    code: resources_1.default.errors.registry.COMPONENT_VERSION_ALREADY_FOUND_CODE,
+                    msg: resources_1.default.errors.registry.COMPONENT_VERSION_ALREADY_FOUND(componentName, componentVersion, repositorySource)
+                };
+            }
+            pkgDetails.packageJson.oc.date = (0, oc_get_unix_utc_timestamp_1.default)();
+            await fs_extra_1.default.writeJson(path_1.default.join(pkgDetails.outputFolder, 'package.json'), pkgDetails.packageJson);
+            await cdn.putDir(pkgDetails.outputFolder, `${options.componentsDir}/${componentName}/${componentVersion}`);
+            const componentsList = await componentsCache.refresh();
+            return componentsDetails.refresh(componentsList);
         }
     };
     return repository;

package/dist/registry/domain/require-wrapper.js

@@ -7,7 +7,6 @@ const builtin_modules_1 = __importDefault(require("builtin-modules"));
 const path_1 = __importDefault(require("path"));
 const require_package_name_1 = __importDefault(require("require-package-name"));
 const try_require_1 = __importDefault(require("try-require"));
-const lodash_1 = __importDefault(require("lodash"));
 const resources_1 = __importDefault(require("../../resources"));
 const isCoreDependency = (x) => builtin_modules_1.default.includes(x);
 const requireCoreDependency = (x) => (isCoreDependency(x) && (0, try_require_1.default)(x)) || undefined;
@@ -24,7 +23,7 @@ const throwError = (requirePath) => {
 };
 exports.default = (injectedDependencies) => (requirePath) => {
     const moduleName = (0, require_package_name_1.default)(requirePath);
-    const isAllowed = lodash_1.default.includes(injectedDependencies, moduleName);
+    const isAllowed = injectedDependencies.includes(moduleName);
     if (!isAllowed) {
         return throwError(requirePath);
     }

package/dist/registry/domain/storage-adapter.d.ts

@@ -0,0 +1,10 @@
+import { StorageAdapter } from 'oc-storage-adapters-utils';
+declare type RemovePromiseOverload<T> = T extends {
+    (...args: infer B): void;
+    (...args: any[]): Promise<any>;
+} ? (...args: B) => void : T;
+declare type LegacyStorageAdapter = {
+    [P in keyof StorageAdapter]: RemovePromiseOverload<StorageAdapter[P]>;
+};
+export default function getPromiseBasedAdapter(adapter: StorageAdapter | LegacyStorageAdapter): StorageAdapter;
+export {};

package/dist/registry/domain/storage-adapter.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const universalify_1 = require("universalify");
+const officialAdapters = {
+    s3: { name: 'oc-s3-storage-adapter', firstPromiseBasedVersion: '1.2.0' },
+    gs: { name: 'oc-gs-storage-adapter', firstPromiseBasedVersion: '1.1.0' },
+    'azure-blob-storage': {
+        name: 'oc-azure-storage-adapter',
+        firstPromiseBasedVersion: '0.1.0'
+    }
+};
+function isOfficialAdapter(adapter) {
+    return Object.keys(officialAdapters).includes(adapter.adapterType);
+}
+function isPromiseBased(tryFunction) {
+    try {
+        tryFunction().catch(() => {
+            // To not throw unhandled promise exceptions
+        });
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+function isLegacyAdapter(adapter) {
+    return !isPromiseBased(() => adapter.getFile(''));
+}
+function convertLegacyAdapter(adapter) {
+    return {
+        getFile: (0, universalify_1.fromCallback)(adapter.getFile),
+        getJson: (0, universalify_1.fromCallback)(adapter.getJson),
+        listSubDirectories: (0, universalify_1.fromCallback)(adapter.listSubDirectories),
+        putDir: (0, universalify_1.fromCallback)(adapter.putDir),
+        putFile: (0, universalify_1.fromCallback)(adapter.putFile),
+        putFileContent: (0, universalify_1.fromCallback)(adapter.putFileContent),
+        getUrl: adapter.getUrl,
+        maxConcurrentRequests: adapter.maxConcurrentRequests,
+        adapterType: adapter.adapterType
+    };
+}
+function getPromiseBasedAdapter(adapter) {
+    if (isLegacyAdapter(adapter)) {
+        if (isOfficialAdapter(adapter)) {
+            const pkg = officialAdapters[adapter.adapterType];
+            process.emitWarning(`Adapters now should work with promises. Consider upgrading your package ${pkg.name} to at least version ${pkg.firstPromiseBasedVersion}`, 'DeprecationWarning');
+        }
+        else {
+            process.emitWarning('Your adapter is using the old interface of working with callbacks. Consider upgrading it to work with promises, as the previous one will be deprecated.', 'DeprecationWarning');
+        }
+        return convertLegacyAdapter(adapter);
+    }
+    return adapter;
+}
+exports.default = getPromiseBasedAdapter;

package/dist/registry/index.d.ts

@@ -39,10 +39,10 @@ export default function registry(inputOptions: Input): {
         };
     }[T]) => void) => void;
     register: (plugin: Omit<Plugin, 'callback'>, callback?: ((...args: any[]) => void) | undefined) => void;
-    start: (callback: (err: Error | null, data: {
+    start: (callback: (err: unknown, data: {
         app: express.Express;
         server: http.Server;
-    }) => void) => void;
+    }) => void) => Promise<void>;
     app: express.Express;
 };
 export {};

package/dist/registry/index.js

@@ -22,7 +22,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const async_1 = __importDefault(require("async"));
 const safe_1 = __importDefault(require("colors/safe"));
 const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
@@ -32,7 +31,7 @@ const events_handler_1 = __importDefault(require("./domain/events-handler"));
 const middleware = __importStar(require("./middleware"));
 const pluginsInitialiser = __importStar(require("./domain/plugins-initialiser"));
 const repository_1 = __importDefault(require("./domain/repository"));
-const router = __importStar(require("./router"));
+const router_1 = require("./router");
 const options_sanitiser_1 = __importDefault(require("./domain/options-sanitiser"));
 const validator = __importStar(require("./domain/validators"));
 function registry(inputOptions) {
@@ -42,7 +41,7 @@ function registry(inputOptions) {
     }
     const options = (0, options_sanitiser_1.default)(inputOptions);
     const plugins = [];
-    const app = middleware.bind((0, express_1.default)(), options);
+    const { app, router } = middleware.bind((0, express_1.default)(), options);
     let server;
     const repository = (0, repository_1.default)(options);
     const close = (callback) => {
@@ -54,26 +53,15 @@ function registry(inputOptions) {
     const register = (plugin, callback) => {
         plugins.push(Object.assign(plugin, { callback }));
     };
-    const start = (callback) => {
+    const start = async (callback) => {
+        var _a;
         // eslint-disable-next-line no-console
         const ok = (msg) => console.log(safe_1.default.green(msg));
-        if (typeof callback !== 'function') {
-            callback = lodash_1.default.noop;
-        }
-        router.create(app, options, repository);
-        async_1.default.waterfall([
-            (cb) => pluginsInitialiser.init(plugins, cb),
-            (plugins, cb) => {
-                options.plugins = plugins;
-                repository.init(cb);
-            },
-            (componentsInfo, cb) => {
-                (0, app_start_1.default)(repository, options, (err) => cb(err ? err.msg : null, componentsInfo));
-            }
-        ], (err, componentsInfo) => {
-            if (err) {
-                return callback(err, undefined);
-            }
+        (0, router_1.create)(router, options, repository);
+        try {
+            options.plugins = await pluginsInitialiser.init(plugins);
+            const componentsInfo = await repository.init();
+            await (0, app_start_1.default)(repository, options);
             server = http_1.default.createServer(app);
             server.timeout = options.timeout;
             if (options.keepAliveTimeout) {
@@ -88,12 +76,8 @@ function registry(inputOptions) {
                 if (options.verbosity) {
                     ok(`Registry started at port ${app.get('port')}`);
                     if (lodash_1.default.isObject(componentsInfo)) {
-                        const componentsNumber = Object.keys(
-                        // @ts-ignore
-                        componentsInfo.components).length;
-                        const componentsReleases = lodash_1.default.reduce(
-                        // @ts-ignore
-                        componentsInfo.components, (memo, component) => parseInt(memo, 10) + component.length);
+                        const componentsNumber = Object.keys(componentsInfo.components).length;
+                        const componentsReleases = Object.values(componentsInfo.components).reduce((acc, component) => acc + component.length, 0);
                         ok(`Registry serving ${componentsNumber} components for a total of ${componentsReleases} releases.`);
                     }
                 }
@@ -107,7 +91,10 @@ function registry(inputOptions) {
                 });
                 callback(error, undefined);
             });
-        });
+        }
+        catch (err) {
+            callback(((_a = err) === null || _a === void 0 ? void 0 : _a.msg) || err, undefined);
+        }
     };
     return {
         close,

package/dist/registry/middleware/index.d.ts

@@ -1,3 +1,7 @@
-import { Express } from 'express';
+import express, { Express } from 'express';
+import Router from 'express-promise-router';
 import { Config } from '../../types';
-export declare const bind: (app: Express, options: Config) => Express;
+export declare const bind: (app: Express, options: Config) => {
+    app: Express;
+    router: express.Router;
+};

package/dist/registry/middleware/index.js

@@ -7,6 +7,7 @@ exports.bind = void 0;
 const express_1 = __importDefault(require("express"));
 const errorhandler_1 = __importDefault(require("errorhandler"));
 const morgan_1 = __importDefault(require("morgan"));
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
 const base_url_handler_1 = __importDefault(require("./base-url-handler"));
 const cors_1 = __importDefault(require("./cors"));
 const discovery_handler_1 = __importDefault(require("./discovery-handler"));
@@ -21,6 +22,7 @@ const bodyParserUrlEncodedArgument = {
 const bind = (app, options) => {
     app.set('port', options.port);
     app.set('json spaces', 0);
+    app.set('etag', 'strong');
     app.use((_req, res, next) => {
         res.conf = options;
         next();
@@ -42,6 +44,8 @@ const bind = (app, options) => {
     if (options.local) {
         app.use((0, errorhandler_1.default)());
     }
-    return app;
+    const router = (0, express_promise_router_1.default)();
+    app.use(router);
+    return { app, router };
 };
 exports.bind = bind;

package/dist/registry/router.d.ts

@@ -1,3 +1,3 @@
-import { Express } from 'express';
+import { Router } from 'express';
 import { Config, Repository } from '../types';
-export declare function create(app: Express, conf: Config, repository: Repository): Express;
+export declare function create(app: Router, conf: Config, repository: Repository): void;

package/dist/registry/router.js

@@ -52,7 +52,5 @@ function create(app, conf, repository) {
     if (conf.routes) {
         conf.routes.forEach(route => app[route.method.toLowerCase()](route.route, route.handler));
     }
-    app.set('etag', 'strong');
-    return app;
 }
 exports.create = create;