exthos/dist/utils/utils.js

stream processing in nodejs using the power of golang

import { execaCommandSync } from "execa";
import axios from "axios";
import proxymise from "./proxymise.js";
import { IncomingMessage } from "http";
import { Stream } from "stream";
function checkExeExists() {
    try {
        execaCommandSync(`benthos -v`);
    }
    catch (err) {
        if (err.exitCode !== 0)
            return false;
    }
    return true;
}
function standardizeAxiosErrors(e) {
    if (axios.isAxiosError(e)) {
        if (e.response) {
            delete e.response.request;
            delete e.response["config"];
            let dataIsStream = e.response.data instanceof IncomingMessage &&
                e.response.data instanceof Stream;
            let toReturnError = {
                name: "Error",
                message: "axios response has an error",
                response: {
                    status: e.response.status,
                    statusText: e.response.statusText,
                    headers: e.response.headers,
                    data: dataIsStream ? "" : e.response.data,
                },
                request: {
                    host: e.request.getHeader("host"),
                    path: e.request.path,
                },
            };
            return toReturnError;
        }
        else if (e.request) {
            return new Error(e.message);
        }
    }
    return e;
}
async function sleep(ms) {
    let resolve;
    let p = new Promise((r) => {
        resolve = r;
    });
    setTimeout(resolve, ms);
    await p;
    return true;
}
class Deferred {
    constructor() {
        this.fulfilled = false;
        this.rejected = false;
        this.resolved = false;
        let self = this;
        this.promise = new Promise(function (resolve, reject) {
            self.reject = (reason) => {
                self.fulfilled = true;
                self.rejected = true;
                reject(reason);
            };
            self.resolve = (value) => {
                self.fulfilled = true;
                self.resolved = true;
                resolve(value);
            };
        });
    }
}
function replaceKeys(obj, keyMap) {
    let iterate = (obj) => {
        Object.keys(obj).forEach((key) => {
            if (Object.keys(keyMap).includes(key)) {
                let oldKey = key;
                let newKey = keyMap[oldKey];
                Object.defineProperty(obj, newKey(), Object.getOwnPropertyDescriptor(obj, oldKey));
                delete obj[oldKey];
                if (!(typeof obj[key] === "object" && obj[key] !== null)) {
                    return obj;
                }
            }
            if (typeof obj[key] === "object" &&
                obj[key] !== null &&
                !Array.isArray(obj[key])) {
                iterate(obj[key]);
            }
            else if (Array.isArray(obj[key])) {
                obj[key].forEach((el) => {
                    iterate(el);
                });
            }
        });
    };
    iterate(obj);
    return obj;
}
function replaceValueForKey(obj, kv) {
    let iterate = (obj) => {
        Object.keys(obj).forEach((key) => {
            if (Object.keys(kv).includes(key)) {
                obj[key] = kv[key](obj[key]);
                if (!(typeof obj[key] === "object" && obj[key] !== null)) {
                    return obj;
                }
            }
            if (typeof obj[key] === "object" &&
                obj[key] !== null &&
                !Array.isArray(obj[key])) {
                iterate(obj[key]);
            }
            else if (Array.isArray(obj[key])) {
                obj[key].forEach((el) => {
                    iterate(el);
                });
            }
        });
    };
    iterate(obj);
    return obj;
}
function proxyPromise(t) {
    return proxymise(t);
}
function getISOStringLocalTz(date = new Date()) {
    var tzo = -date.getTimezoneOffset(), dif = tzo >= 0 ? "+" : "-", pad = function (num) {
        return (num < 10 ? "0" : "") + num;
    };
    return (date.getFullYear() +
        "-" +
        pad(date.getMonth() + 1) +
        "-" +
        pad(date.getDate()) +
        "T" +
        pad(date.getHours()) +
        ":" +
        pad(date.getMinutes()) +
        ":" +
        pad(date.getSeconds()) +
        dif +
        pad(Math.floor(Math.abs(tzo) / 60)) +
        ":" +
        pad(Math.abs(tzo) % 60));
}
function getCaller() {
    return new Error().stack.split("at ")[3].trim();
}
function formatErrorForEvent(e) {
    let toReturn = {};
    Object.getOwnPropertyNames(e).forEach((p) => {
        toReturn[p] = e[p];
    });
    return toReturn;
}
export { checkExeExists, standardizeAxiosErrors, sleep, Deferred, replaceKeys, replaceValueForKey, proxyPromise, getISOStringLocalTz, getCaller, formatErrorForEvent, };
//# sourceMappingURL=utils.js.map