client.js

/* eslint-disable */

export default createClient;

export function createClient(url, globalOptions = {}) {
    if (typeof process === "undefined" && typeof window !== "undefined") {
        window.process = { env: {} };
    }

    var client = async function fql(name, args, options = {}) {
        if (!name) {
            throw new Error("NAME_REQUIRED");
        }

        options.endpoint = globalOptions.endpoint = url;
        if (globalOptions.connectionMode === "sockets") {
            return executeBySocket.apply(this, [name, args, options, globalOptions]);
        }
        return await executeByHttp.apply(this, [name, args, options, globalOptions]);
    };

    return client;
}

function getSocket(scope = {}) {
    const debug = getDebugInstance(`getSocket`, 4, scope);

    debug('GET SOCKET??')

    return new Promise((resolve, reject) => {
        if (scope.socket && scope.socket.isActive === true) {
            return scope.socket;
        } else {
            if (scope._isRetrievingSocket == true) {
                let start = Date.now();

                function checkSocketAvailable() {
                    if (scope.socket && scope.socket.isActive === true) {
                        resolve(scope.socket);
                    } else {
                        if (Date.now() - start > 1000 * 10) {
                            return reject("SOCKET_INIT_TIMEOUT");
                        }
                        setTimeout(() => checkSocketAvailable(), 20);
                    }
                }
            } else {
                scope._isRetrievingSocket = true;
                const io = (scope.io = scope.io || require("socket.io-client"));

                const socket =
                    scope.socket && scope.socket.on === true ?
                    scope.socket :
                    io(scope.endpoint);

                socket.on("connect", function() {
                    socket.isActive = true;
                    scope.socket = socket;
                    scope._isRetrievingSocket = false;
                    debug("Adding socket", socket.id);
                    resolve(socket);
                });

                socket.on("disconnect", function() {
                    socket.isActive = false;
                    debug("Disposing socket", socket.id);
                    delete scope.socket;
                });
            }
        }
    });
}

function executeBySocket(name, args, options, globalOptions) {
    const debug = getDebugInstance(`socket`, 4, globalOptions);
    return new Promise(async(resolve, reject) => {
        const elapsed = calculateElapsed();
        const socket = await getSocket(globalOptions);
        const request = {
            ...getRequestPayload(name, args, options, globalOptions),
            id: require("uniqid")()
        };
        socket.once("fn_" + request.id, response => {
            debug(name, elapsed(), {
                request,
                response
            });
            if (!!response.err) {
                return response.reject(response, response.err);
            }
            resolve(response);
        });
        socket.emit("executeFunction", request);
    });
}

function getRequestPayload(name, args = [], options = {}, globalOptions = {}) {
    options.transform = !!options.transform && typeof options.transform !== "string" ?
        options.transform.toString() :
        options.transform;
    const request = {
        ...options,
        name: name,
        args: args,
        ns: options.namespace || options.ns || globalOptions.namespace || globalOptions.ns || process.env.VUE_APP_FUNQL_NAMESPACE || process.env.FUNQL_DEFAULT_NAMESPACE
    };
    return request;
}

async function executeByHttp(
    name,
    args = [],
    options = {},
    globalOptions = {}
) {
    const debug = getDebugInstance(`http`, 4, globalOptions);



    const endpoint = options.endpoint || process.env.VUE_APP_FUNQL_ENDPOINT || process.env.FUNQL_ENDPOINT;
    const url = `${endpoint}/funql-api`;
    const request = getRequestPayload(name, args, options, globalOptions);
    const elapsed = calculateElapsed();


    let fetchMethod = null;
    if (typeof fetch !== 'undefined') {
        fetchMethod = fetch
    } else {
        const { fetch } = require('fetch-ponyfill')();
        fetchMethod = fetch
    }



    const rawResponse = await fetchMethod(`${url}?n=${name}&ns=${request.ns}`, {
        method: "POST",
        mode: "cors",
        headers: {
            Accept: "application/json",
            "Content-Type": "application/json"
        },
        body: JSON.stringify(request)
    });

    const response = await rawResponse.json();
    debug(name, elapsed(), {
        request,
        response
    });
    if (response.err) {
        response.err =
            typeof response.err === "object" ?
            JSON.stringify(response.err) :
            response.err;
        throw new Error(response.err);
    } else {
        return response;
    }
}

function calculateElapsed() {
    var startDate = new Date();
    return function() {
        var endDate = new Date();
        var seconds = (endDate.getTime() - startDate.getTime()) / 1000;
        return seconds + "s";
    };
}

function getDebugInstance(name, level = 4, options = {}) {
    let levelLabel = {
        1: "ERROR",
        2: "WARN",
        3: "INFO",
        4: "DEBUG"
    };

    let debugEnv = parseInt(process.env.VUE_APP_DEBUG) || "funql*";
    if (typeof window !== "undefined" && window.localStorage) {
        localStorage.debug = (localStorage.debug || "") + `,${debugEnv}`;
    }

    let _level = parseInt(process.env.VUE_APP_DEBUG_LEVEL) || 4;

    if (level > _level) {
        return () => {};
    } else {
        let debug = () => {};
        debug =
            options.debug ||
            (typeof require !== "undefined" ?
                require("debug") :
                (prefix = "") => {
                    return function() {
                        let args = Array.prototype.slice.call(arguments);
                        args.unshift(prefix);
                        console.log.apply(this, args);
                    };
                });
        return debug(
                `${`fql-client:${name}`.padEnd(15, " ")} ${levelLabel[level].padEnd(
        7,
        " "
      )} ${`${Date.now()}`}`
    );
  }
}