veendor/lib/validateConfig.js

a tool for stroing your npm dependencies in arbitraty storage

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = __importDefault(require("lodash"));
const semver_1 = __importDefault(require("semver"));
const errors = __importStar(require("./errors"));
const npmWrapper = __importStar(require("./commandWrappers/npmWrapper"));
function validateConfig(config) {
    const validationPromises = [];
    if (!(config.backends instanceof Array) || config.backends.length === 0) {
        return Promise.reject(new EmptyBackendsPropertyError());
    }
    const aliases = lodash_1.default.map(config.backends, 'alias');
    if (lodash_1.default.uniq(aliases).length < aliases.length) {
        return Promise.reject(new AliasesNotUniqueError(`backends aliases are not unique`));
    }
    for (const [position, backend] of config.backends.entries()) {
        validationPromises.push(validateBackend(backend, position));
    }
    if (config.fallbackToNpm === undefined) {
        config.fallbackToNpm = true;
    }
    if (config.packageHash === undefined) {
        config.packageHash = {};
    }
    if (config.installDiff === undefined) {
        config.installDiff = true;
    }
    if (!(config.installDiff) && config.useGitHistory) {
        return Promise.reject(new InvalidUseGitHistoryError('Setting both \'installDiff\' and \'useGitHistory\' doesn\'t make any sense'));
    }
    if (config.useGitHistory) {
        if (!lodash_1.default.isNumber(config.useGitHistory.depth)) {
            return Promise.reject(new InvalidUseGitHistoryError('\'useGitHistory\' should be used with \'depth\' option'));
        }
        if (config.useGitHistory.depth < 1) {
            return Promise.reject(new InvalidUseGitHistoryError('\'useGitHistory.depth\' should be positive number'));
        }
    }
    if (typeof config.npmVersion === 'string') {
        const npmVersion = config.npmVersion;
        validationPromises.push(npmWrapper.version()
            .then(version => {
            if (!semver_1.default.satisfies(version, npmVersion)) {
                throw new InvalidNpmVersionError(npmVersion, version);
            }
        }));
    }
    if (config.dedupe === undefined) {
        config.dedupe = false;
    }
    if (config.clearSharedCache === undefined) {
        config.clearSharedCache = false;
    }
    if (config.veendorVersion !== undefined) {
        if (!semver_1.default.satisfies(global.VEENDOR_VERSION, config.veendorVersion)) {
            return Promise.reject(new InvalidVeendorVersionError(config.veendorVersion));
        }
    }
    return Promise.all(validationPromises).then(() => config);
}
exports.default = validateConfig;
;
function validateBackend(backendConfig, position) {
    if (!(typeof backendConfig.alias === 'string' && backendConfig.alias.length > 0)) {
        return Promise.reject(new EmptyBackendAliasError(position));
    }
    if (typeof backendConfig.backend === 'string') {
        backendConfig.backend = require(`./backends/${backendConfig.backend}`);
    }
    else if (!(backendConfig.backend instanceof Object)) {
        return Promise.reject(new InvalidBackendError(backendConfig.alias, 'backend'));
    }
    if (typeof backendConfig.backend.pull !== 'function') {
        return Promise.reject(new InvalidBackendError(backendConfig.alias, 'pull'));
    }
    if (typeof backendConfig.backend.push !== 'function') {
        return Promise.reject(new InvalidBackendError(backendConfig.alias, 'push'));
    }
    if (typeof backendConfig.backend.validateOptions !== 'function') {
        return Promise.reject(new InvalidBackendError(backendConfig.alias, 'validateOptions'));
    }
    if (backendConfig.push === undefined) {
        backendConfig.push = false;
    }
    if (typeof backendConfig.push !== 'boolean') {
        return Promise.reject(new InvalidBackendOptionError(backendConfig.alias, 'push'));
    }
    if (backendConfig.pushMayFail === undefined) {
        backendConfig.pushMayFail = false;
    }
    if (typeof backendConfig.pushMayFail !== 'boolean') {
        return Promise.reject(new InvalidBackendOptionError(backendConfig.alias, 'pushMayFail'));
    }
    let validationResult;
    try {
        validationResult = backendConfig.backend.validateOptions(backendConfig.options);
    }
    catch (e) {
        return Promise.reject(e);
    }
    if (validationResult instanceof Promise) {
        return validationResult;
    }
    return Promise.resolve();
}
class EmptyBackendsPropertyError extends errors.VeendorError {
    constructor() {
        super('no backends found in config');
    }
}
exports.EmptyBackendsPropertyError = EmptyBackendsPropertyError;
class InvalidBackendError extends errors.VeendorError {
    constructor(alias, field) {
        super(`backend '${alias}' has lacks of has invalid '${field}' field`);
    }
}
exports.InvalidBackendError = InvalidBackendError;
class InvalidBackendOptionError extends errors.VeendorError {
    constructor(alias, field) {
        super(`backend\'s '${alias}' '${field}' option in invalid`);
    }
}
exports.InvalidBackendOptionError = InvalidBackendOptionError;
class EmptyBackendAliasError extends errors.VeendorError {
    constructor(position) {
        super(`backend at position '${position}' lacks or has invalid 'alias' field`);
    }
}
exports.EmptyBackendAliasError = EmptyBackendAliasError;
class InvalidNpmVersionError extends errors.VeendorError {
    constructor(expected, actual) {
        super(`npm version '${actual}' does not comply with '${expected}' constraint`);
    }
}
exports.InvalidNpmVersionError = InvalidNpmVersionError;
class InvalidVeendorVersionError extends errors.VeendorError {
    constructor(expected) {
        super(`veendor version '${global.VEENDOR_VERSION}' does not comply with '${expected}' constraint`);
    }
}
exports.InvalidVeendorVersionError = InvalidVeendorVersionError;
class AliasesNotUniqueError extends errors.VeendorError {
}
exports.AliasesNotUniqueError = AliasesNotUniqueError;
class InvalidUseGitHistoryError extends errors.VeendorError {
}
exports.InvalidUseGitHistoryError = InvalidUseGitHistoryError;