sda/lib/getEnvironment.js

Software development assistant

"use strict";
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;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const path = __importStar(require("path"));
const withId_1 = __importDefault(require("./interfaces/withId"));
const Log_1 = __importDefault(require("./Log"));
function getEnvironment(config, envId, currentDir) {
    let environment;
    if (config.environments[envId]) {
        environment = withId_1.default(envId, config.environments[envId]);
    }
    // Find environments from the current path
    if (!environment && currentDir) {
        for (const currentEnvName of Object.keys(config.environments)) {
            const currentEnv = config.environments[currentEnvName];
            if (isDirInsideEnvironment(currentDir, currentEnv.path)) {
                environment = withId_1.default(currentEnvName, currentEnv);
                Log_1.default.verbose(`Using environment "${environment.id}" from current folder.`);
                break;
            }
        }
    }
    if (!environment) {
        // tslint:disable-next-line:max-line-length
        throw new Error('Environment not found. Make sure to run sda inside of the environment, or pass the environment id');
    }
    if (!config.templates[environment.templateId]) {
        throw new Error(`There is no template with id "${environment.templateId}"`);
    }
    addDefaultCommands(environment, config);
    addDefaultAliases(environment, config);
    return {
        ...environment,
        template: withId_1.default(environment.templateId, config.templates[environment.templateId])
    };
}
exports.getEnvironment = getEnvironment;
function getAllEnvironments(config) {
    const envs = [];
    Object.keys(config.environments).forEach((envId) => {
        const env = withId_1.default(envId, config.environments[envId]);
        addDefaultCommands(env, config);
        addDefaultAliases(env, config);
        envs.push({
            ...env,
            template: withId_1.default(env.templateId, config.templates[env.templateId])
        });
    });
    return envs;
}
exports.getAllEnvironments = getAllEnvironments;
function isDirInsideEnvironment(dir, envDir) {
    const relativePath = path.relative(envDir, dir);
    if (!relativePath) {
        return true;
    } // Same directory
    if (relativePath === dir) {
        return false;
    } // Different drives
    if (relativePath.indexOf('..') !== 0) {
        return true;
    } // Dir is inside envDir
    return false;
}
function addDefaultCommands(environment, config) {
    const defaultTemplate = config.templates.default;
    const envTemplate = config.templates[environment.templateId];
    if (defaultTemplate) {
        Object.keys(defaultTemplate.commands).forEach((commandName) => {
            if (!envTemplate.commands[commandName]) {
                envTemplate.commands[commandName] = defaultTemplate.commands[commandName];
            }
        });
    }
}
function addDefaultAliases(environment, config) {
    const defaultTemplate = config.templates.default;
    const envTemplate = config.templates[environment.templateId];
    if (defaultTemplate && defaultTemplate.aliases) {
        if (!envTemplate.aliases) {
            envTemplate.aliases = {};
        }
        Object.keys(defaultTemplate.aliases).forEach((aliasName) => {
            if (!envTemplate.aliases[aliasName]) {
                envTemplate.aliases[aliasName] = defaultTemplate.aliases[aliasName];
            }
        });
    }
}
//# sourceMappingURL=getEnvironment.js.map