oc 0.49.6 → 0.49.9

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

@@ -1,34 +1,33 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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;
-const requireDependency = (requirePath) => {
-    const nodeModulesPath = path_1.default.resolve('.', 'node_modules');
-    const modulePath = path_1.default.resolve(nodeModulesPath, requirePath);
-    return (0, try_require_1.default)(modulePath);
-};
-const throwError = (requirePath) => {
-    throw {
-        code: resources_1.default.errors.registry.DEPENDENCY_NOT_FOUND_CODE,
-        missing: [requirePath]
-    };
-};
-exports.default = (injectedDependencies) => (requirePath) => {
-    const moduleName = (0, require_package_name_1.default)(requirePath);
-    const isAllowed = lodash_1.default.includes(injectedDependencies, moduleName);
-    if (!isAllowed) {
-        return throwError(requirePath);
-    }
-    return (requireDependency(requirePath) ||
-        requireCoreDependency(requirePath) ||
-        throwError(requirePath));
-};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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;
+const requireDependency = (requirePath) => {
+    const nodeModulesPath = path_1.default.resolve('.', 'node_modules');
+    const modulePath = path_1.default.resolve(nodeModulesPath, requirePath);
+    return (0, try_require_1.default)(modulePath);
+};
+const throwError = (requirePath) => {
+    throw {
+        code: resources_1.default.errors.registry.DEPENDENCY_NOT_FOUND_CODE,
+        missing: [requirePath]
+    };
+};
+exports.default = (injectedDependencies) => (requirePath) => {
+    const moduleName = (0, require_package_name_1.default)(requirePath);
+    const isAllowed = injectedDependencies.includes(moduleName);
+    if (!isAllowed) {
+        return throwError(requirePath);
+    }
+    return (requireDependency(requirePath) ||
+        requireCoreDependency(requirePath) ||
+        throwError(requirePath));
+};

package/dist/registry/domain/sanitiser.d.ts

@@ -1,2 +1,2 @@
-import { OcParameter } from '../../types';
-export declare function sanitiseComponentParameters(requestParameters: Record<string, string | number | boolean>, expectedParameters: Record<string, OcParameter>): Record<string, string | number | boolean>;
+import { OcParameter } from '../../types';
+export declare function sanitiseComponentParameters(requestParameters: Record<string, string | number | boolean>, expectedParameters: Record<string, OcParameter>): Record<string, string | number | boolean>;

package/dist/registry/domain/sanitiser.js

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitiseComponentParameters = void 0;
-const sanitise = {
-    booleanParameter(variable) {
-        if (typeof variable === 'string') {
-            if (variable === 'true') {
-                return true;
-            }
-            else if (variable === 'false') {
-                return false;
-            }
-        }
-        return variable;
-    },
-    numberParameter(variable) {
-        return Number(variable);
-    },
-    stringParameter(variable) {
-        return variable == null ? '' : variable;
-    },
-    parameter(variable, type) {
-        if (type === 'boolean') {
-            return sanitise.booleanParameter(variable);
-        }
-        else if (type === 'number') {
-            return sanitise.numberParameter(variable);
-        }
-        else if (type === 'string') {
-            return sanitise.stringParameter(variable);
-        }
-        return variable;
-    }
-};
-const toRemove = ['__ocAcceptLanguage'];
-function sanitiseComponentParameters(requestParameters, expectedParameters) {
-    const result = {};
-    for (const [requestParameterName, requestParameter] of Object.entries(requestParameters)) {
-        if (typeof expectedParameters === 'object' &&
-            // eslint-disable-next-line no-prototype-builtins
-            expectedParameters.hasOwnProperty(requestParameterName)) {
-            const expectedType = expectedParameters[requestParameterName].type;
-            const sanitised = sanitise.parameter(requestParameter, expectedType);
-            result[requestParameterName] = sanitised;
-        }
-        else if (!toRemove.includes(requestParameterName)) {
-            result[requestParameterName] = requestParameter;
-        }
-    }
-    return result;
-}
-exports.sanitiseComponentParameters = sanitiseComponentParameters;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitiseComponentParameters = void 0;
+const sanitise = {
+    booleanParameter(variable) {
+        if (typeof variable === 'string') {
+            if (variable === 'true') {
+                return true;
+            }
+            else if (variable === 'false') {
+                return false;
+            }
+        }
+        return variable;
+    },
+    numberParameter(variable) {
+        return Number(variable);
+    },
+    stringParameter(variable) {
+        return variable == null ? '' : variable;
+    },
+    parameter(variable, type) {
+        if (type === 'boolean') {
+            return sanitise.booleanParameter(variable);
+        }
+        else if (type === 'number') {
+            return sanitise.numberParameter(variable);
+        }
+        else if (type === 'string') {
+            return sanitise.stringParameter(variable);
+        }
+        return variable;
+    }
+};
+const toRemove = ['__ocAcceptLanguage'];
+function sanitiseComponentParameters(requestParameters, expectedParameters) {
+    const result = {};
+    for (const [requestParameterName, requestParameter] of Object.entries(requestParameters)) {
+        if (typeof expectedParameters === 'object' &&
+            // eslint-disable-next-line no-prototype-builtins
+            expectedParameters.hasOwnProperty(requestParameterName)) {
+            const expectedType = expectedParameters[requestParameterName].type;
+            const sanitised = sanitise.parameter(requestParameter, expectedType);
+            result[requestParameterName] = sanitised;
+        }
+        else if (!toRemove.includes(requestParameterName)) {
+            result[requestParameterName] = requestParameter;
+        }
+    }
+    return result;
+}
+exports.sanitiseComponentParameters = sanitiseComponentParameters;

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/domain/url-builder.d.ts

@@ -1,10 +1,10 @@
-declare type Component = {
-    name: string;
-    version?: string;
-    parameters?: Record<string, string>;
-};
-export declare function component(component: Component | string, baseUrl: string): string;
-export declare function componentInfo(component: Component, baseUrl: string): string;
-export declare function componentPreview(component: Component, baseUrl: string): string;
-export declare function queryString(parameters?: Record<string, string>): string;
-export {};
+declare type Component = {
+    name: string;
+    version?: string;
+    parameters?: Record<string, string>;
+};
+export declare function component(component: Component | string, baseUrl: string): string;
+export declare function componentInfo(component: Component, baseUrl: string): string;
+export declare function componentPreview(component: Component, baseUrl: string): string;
+export declare function queryString(parameters?: Record<string, string>): string;
+export {};

package/dist/registry/domain/url-builder.js

@@ -1,60 +1,60 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.queryString = exports.componentPreview = exports.componentInfo = exports.component = void 0;
-const querystring_1 = __importDefault(require("querystring"));
-const url_1 = __importDefault(require("url"));
-function componentForType(component, baseUrl, type) {
-    if (typeof component === 'string') {
-        component = { name: component };
-    }
-    let href = url_1.default.resolve(baseUrl, component.name) + '/';
-    if (component.version) {
-        href += component.version + '/';
-    }
-    href += '~' + type;
-    return href;
-}
-function component(component, baseUrl) {
-    if (typeof component === 'string') {
-        component = { name: component };
-    }
-    let componentUrl = url_1.default.resolve(baseUrl, component.name);
-    if (component.version) {
-        componentUrl += '/' + component.version;
-    }
-    componentUrl += queryString(component.parameters);
-    return componentUrl;
-}
-exports.component = component;
-function componentInfo(component, baseUrl) {
-    return componentForType(component, baseUrl, 'info');
-}
-exports.componentInfo = componentInfo;
-function componentPreview(component, baseUrl) {
-    let href = componentForType(component, baseUrl, 'preview');
-    if (!!component.parameters && Object.keys(component.parameters).length) {
-        href += '/?' + querystring_1.default.stringify(component.parameters);
-    }
-    else {
-        href += '/';
-    }
-    return href;
-}
-exports.componentPreview = componentPreview;
-function queryString(parameters = {}) {
-    let qs = '';
-    if (Object.keys(parameters).length > 0) {
-        qs += '?';
-        for (const [key, parameter] of Object.entries(parameters)) {
-            qs += key + '=' + encodeURIComponent(parameter) + '&';
-        }
-        if (Object.keys(parameters).length > 0) {
-            qs = qs.slice(0, -1);
-        }
-    }
-    return qs;
-}
-exports.queryString = queryString;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryString = exports.componentPreview = exports.componentInfo = exports.component = void 0;
+const querystring_1 = __importDefault(require("querystring"));
+const url_1 = __importDefault(require("url"));
+function componentForType(component, baseUrl, type) {
+    if (typeof component === 'string') {
+        component = { name: component };
+    }
+    let href = url_1.default.resolve(baseUrl, component.name) + '/';
+    if (component.version) {
+        href += component.version + '/';
+    }
+    href += '~' + type;
+    return href;
+}
+function component(component, baseUrl) {
+    if (typeof component === 'string') {
+        component = { name: component };
+    }
+    let componentUrl = url_1.default.resolve(baseUrl, component.name);
+    if (component.version) {
+        componentUrl += '/' + component.version;
+    }
+    componentUrl += queryString(component.parameters);
+    return componentUrl;
+}
+exports.component = component;
+function componentInfo(component, baseUrl) {
+    return componentForType(component, baseUrl, 'info');
+}
+exports.componentInfo = componentInfo;
+function componentPreview(component, baseUrl) {
+    let href = componentForType(component, baseUrl, 'preview');
+    if (!!component.parameters && Object.keys(component.parameters).length) {
+        href += '/?' + querystring_1.default.stringify(component.parameters);
+    }
+    else {
+        href += '/';
+    }
+    return href;
+}
+exports.componentPreview = componentPreview;
+function queryString(parameters = {}) {
+    let qs = '';
+    if (Object.keys(parameters).length > 0) {
+        qs += '?';
+        for (const [key, parameter] of Object.entries(parameters)) {
+            qs += key + '=' + encodeURIComponent(parameter) + '&';
+        }
+        if (Object.keys(parameters).length > 0) {
+            qs = qs.slice(0, -1);
+        }
+    }
+    return qs;
+}
+exports.queryString = queryString;

package/dist/registry/domain/validators/component-parameters.d.ts

@@ -1,11 +1,11 @@
-import { OcParameter } from '../../../types';
-interface ValidationResult {
-    isValid: boolean;
-    errors: {
-        mandatory?: Record<string, string>;
-        types?: Record<string, string>;
-        message?: string;
-    };
-}
-export default function componentParameters(requestParameters: Record<string, string | number | boolean>, expectedParameters?: Record<string, OcParameter>): ValidationResult;
-export {};
+import { OcParameter } from '../../../types';
+interface ValidationResult {
+    isValid: boolean;
+    errors: {
+        mandatory?: Record<string, string>;
+        types?: Record<string, string>;
+        message?: string;
+    };
+}
+export default function componentParameters(requestParameters: Record<string, string | number | boolean>, expectedParameters?: Record<string, OcParameter>): ValidationResult;
+export {};

package/dist/registry/domain/validators/component-parameters.js

@@ -1,79 +1,79 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const resources_1 = __importDefault(require("../../../resources"));
-const validateParameter = function (parameter, expectedType) {
-    const expected = expectedType.toLowerCase();
-    if (expected === 'boolean') {
-        return typeof parameter === 'boolean';
-    }
-    else if (expected === 'number') {
-        return typeof parameter === 'number';
-    }
-    else if (expected === 'string') {
-        return typeof parameter === 'string';
-    }
-    return false;
-};
-function componentParameters(requestParameters, expectedParameters = {}) {
-    const result = { isValid: true, errors: {} };
-    const mandatoryParameters = [];
-    for (const [expectedParameterName, expectedParameter] of Object.entries(expectedParameters)) {
-        if (expectedParameter.mandatory) {
-            mandatoryParameters.push(expectedParameterName);
-        }
-    }
-    for (const mandatoryParameterName of mandatoryParameters) {
-        if (typeof requestParameters === 'object' &&
-            // eslint-disable-next-line no-prototype-builtins
-            !requestParameters.hasOwnProperty(mandatoryParameterName)) {
-            if (!result.errors.mandatory) {
-                result.errors.mandatory = {};
-                result.isValid = false;
-            }
-            result.errors.mandatory[mandatoryParameterName] =
-                resources_1.default.errors.registry.MANDATORY_PARAMETER_MISSING_CODE;
-        }
-    }
-    for (const [requestParameterName, requestParameter] of Object.entries(requestParameters)) {
-        if (typeof expectedParameters === 'object' &&
-            // eslint-disable-next-line no-prototype-builtins
-            expectedParameters.hasOwnProperty(requestParameterName)) {
-            const expectedType = expectedParameters[requestParameterName].type;
-            if (!validateParameter(requestParameter, expectedType)) {
-                if (!result.errors.types) {
-                    result.errors.types = {};
-                    result.isValid = false;
-                }
-                result.errors.types[requestParameterName] =
-                    resources_1.default.errors.registry.PARAMETER_WRONG_FORMAT_CODE;
-            }
-        }
-    }
-    result.errors.message = (function () {
-        let errorString = '';
-        if (Object.keys(result.errors.mandatory || {}).length > 0) {
-            const missingParams = Object.keys(result.errors.mandatory || {})
-                .map(mandatoryParameterName => mandatoryParameterName + ', ')
-                .join('')
-                .slice(0, -2);
-            errorString +=
-                resources_1.default.errors.registry.MANDATORY_PARAMETER_MISSING(missingParams);
-        }
-        if (Object.keys(result.errors.types || {}).length > 0) {
-            if (errorString.length > 0) {
-                errorString += '; ';
-            }
-            const badParams = Object.keys(result.errors.types || {})
-                .map(parameterName => parameterName + ', ')
-                .join('')
-                .slice(0, -2);
-            errorString += resources_1.default.errors.registry.PARAMETER_WRONG_FORMAT(badParams);
-        }
-        return errorString;
-    })();
-    return result;
-}
-exports.default = componentParameters;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const resources_1 = __importDefault(require("../../../resources"));
+const validateParameter = function (parameter, expectedType) {
+    const expected = expectedType.toLowerCase();
+    if (expected === 'boolean') {
+        return typeof parameter === 'boolean';
+    }
+    else if (expected === 'number') {
+        return typeof parameter === 'number';
+    }
+    else if (expected === 'string') {
+        return typeof parameter === 'string';
+    }
+    return false;
+};
+function componentParameters(requestParameters, expectedParameters = {}) {
+    const result = { isValid: true, errors: {} };
+    const mandatoryParameters = [];
+    for (const [expectedParameterName, expectedParameter] of Object.entries(expectedParameters)) {
+        if (expectedParameter.mandatory) {
+            mandatoryParameters.push(expectedParameterName);
+        }
+    }
+    for (const mandatoryParameterName of mandatoryParameters) {
+        if (typeof requestParameters === 'object' &&
+            // eslint-disable-next-line no-prototype-builtins
+            !requestParameters.hasOwnProperty(mandatoryParameterName)) {
+            if (!result.errors.mandatory) {
+                result.errors.mandatory = {};
+                result.isValid = false;
+            }
+            result.errors.mandatory[mandatoryParameterName] =
+                resources_1.default.errors.registry.MANDATORY_PARAMETER_MISSING_CODE;
+        }
+    }
+    for (const [requestParameterName, requestParameter] of Object.entries(requestParameters)) {
+        if (typeof expectedParameters === 'object' &&
+            // eslint-disable-next-line no-prototype-builtins
+            expectedParameters.hasOwnProperty(requestParameterName)) {
+            const expectedType = expectedParameters[requestParameterName].type;
+            if (!validateParameter(requestParameter, expectedType)) {
+                if (!result.errors.types) {
+                    result.errors.types = {};
+                    result.isValid = false;
+                }
+                result.errors.types[requestParameterName] =
+                    resources_1.default.errors.registry.PARAMETER_WRONG_FORMAT_CODE;
+            }
+        }
+    }
+    result.errors.message = (function () {
+        let errorString = '';
+        if (Object.keys(result.errors.mandatory || {}).length > 0) {
+            const missingParams = Object.keys(result.errors.mandatory || {})
+                .map(mandatoryParameterName => mandatoryParameterName + ', ')
+                .join('')
+                .slice(0, -2);
+            errorString +=
+                resources_1.default.errors.registry.MANDATORY_PARAMETER_MISSING(missingParams);
+        }
+        if (Object.keys(result.errors.types || {}).length > 0) {
+            if (errorString.length > 0) {
+                errorString += '; ';
+            }
+            const badParams = Object.keys(result.errors.types || {})
+                .map(parameterName => parameterName + ', ')
+                .join('')
+                .slice(0, -2);
+            errorString += resources_1.default.errors.registry.PARAMETER_WRONG_FORMAT(badParams);
+        }
+        return errorString;
+    })();
+    return result;
+}
+exports.default = componentParameters;

package/dist/registry/domain/validators/index.d.ts

@@ -1,16 +1,16 @@
-import ocCliVersionValidator from './oc-cli-version';
-import componentParametersValidator from './component-parameters';
-import packageJsonValidator from './package-json-validator';
-import pluginsRequirementsValidator from './plugins-requirements';
-import registryConfigurationValidator from './registry-configuration';
-import uploadedPackageValidator from './uploaded-package';
-import nodeVersionValidator from './node-version';
-export declare function validateComponentName(componentName: string): boolean;
-export declare const validateComponentParameters: typeof componentParametersValidator;
-export declare const validateNodeVersion: typeof nodeVersionValidator;
-export declare const validateOcCliVersion: typeof ocCliVersionValidator;
-export declare const validatePackage: typeof uploadedPackageValidator;
-export declare const validatePackageJson: typeof packageJsonValidator;
-export declare const validatePluginsRequirements: typeof pluginsRequirementsValidator;
-export declare const validateRegistryConfiguration: typeof registryConfigurationValidator;
-export declare function validateVersion(version: string): boolean;
+import ocCliVersionValidator from './oc-cli-version';
+import componentParametersValidator from './component-parameters';
+import packageJsonValidator from './package-json-validator';
+import pluginsRequirementsValidator from './plugins-requirements';
+import registryConfigurationValidator from './registry-configuration';
+import uploadedPackageValidator from './uploaded-package';
+import nodeVersionValidator from './node-version';
+export declare function validateComponentName(componentName: string): boolean;
+export declare const validateComponentParameters: typeof componentParametersValidator;
+export declare const validateNodeVersion: typeof nodeVersionValidator;
+export declare const validateOcCliVersion: typeof ocCliVersionValidator;
+export declare const validatePackage: typeof uploadedPackageValidator;
+export declare const validatePackageJson: typeof packageJsonValidator;
+export declare const validatePluginsRequirements: typeof pluginsRequirementsValidator;
+export declare const validateRegistryConfiguration: typeof registryConfigurationValidator;
+export declare function validateVersion(version: string): boolean;