@atomist/skill/lib/util.js

"use strict";
/*
 * Copyright © 2020 Atomist, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs-extra");
const path = require("path");
const uuid = require("uuid/v4");
const log_1 = require("./log");
function toArray(value) {
    if (value) {
        if (Array.isArray(value)) {
            return value;
        }
        else {
            return [value];
        }
    }
    else {
        return undefined;
    }
}
exports.toArray = toArray;
async function handlerLoader(name) {
    const path = await requirePath(name);
    return require(path).handler;
}
exports.handlerLoader = handlerLoader;
async function requirePath(folderOrFile) {
    const p = __dirname.split("/node_modules/");
    const rp = path.join(p[0], folderOrFile);
    const lp = path.join(p[0], "lib", folderOrFile);
    if (await fs.pathExists(rp + ".js")) {
        return rp;
    }
    else if (await fs.pathExists(lp + ".js")) {
        return lp;
    }
    throw new Error(`'${folderOrFile}' not found in '${p[0]}' or '${p[0]}/lib'`);
}
exports.requirePath = requirePath;
function extractParameters(intent) {
    const args = [];
    const regexp = /^[a-zA-Z\s]*(\s+--([a-z.A-Z_]*)=(?:'([^']*?)'|"([^"]*?)"|([\w]*?)))*$/g;
    let intentToMatch = intent.trim();
    let match = regexp.exec(intentToMatch);
    while (!!match && !!match[1] && !!match[2]) {
        const name = match[2];
        const value = match[3] || match[4] || match[5];
        args.push({ name, value });
        intentToMatch = intentToMatch.replace(match[1], "").trim();
        regexp.lastIndex = 0;
        match = regexp.exec(intentToMatch);
    }
    return args.reduce((p, c) => {
        if (!p.some(e => e.name === c.name)) {
            p.push(c);
        }
        return p;
    }, []).reverse();
}
exports.extractParameters = extractParameters;
function replacer(key, value) {
    if (key === "secrets" && value) {
        return value.map(v => ({ uri: v.uri, value: hideString(v.value) }));
    }
    else if (/token|password|jwt|url|secret|authorization|key|cert|pass|user/i.test(key)) {
        return hideString(value);
    }
    else {
        return value;
    }
}
exports.replacer = replacer;
function hideString(value) {
    if (!value) {
        return value;
    }
    if (typeof value === "string") {
        let newValue = "";
        for (let i = 0; i < value.length; i++) {
            if (i === 0) {
                newValue = value.charAt(0);
            }
            else if (i < value.length - 1) {
                newValue += "*";
            }
            else {
                newValue += value.slice(-1);
            }
        }
        return newValue;
    }
    else if (Array.isArray(value)) {
        return value.map(hideString);
    }
    return value;
}
exports.hideString = hideString;
function guid() {
    return uuid();
}
exports.guid = guid;
async function handleError(f, cb = exports.DefaultErrorHandler) {
    try {
        const result = await f();
        return result;
    }
    catch (e) {
        return cb(e);
    }
}
exports.handleError = handleError;
function handleErrorSync(f, cb = exports.DefaultErrorHandler) {
    try {
        return f();
    }
    catch (e) {
        return cb(e);
    }
}
exports.handleErrorSync = handleErrorSync;
exports.DefaultErrorHandler = err => {
    log_1.error(`Error occurred: %s`, err.message);
    if (err.stack) {
        log_1.error(err.stack);
    }
    return undefined;
};
//# sourceMappingURL=util.js.map