ggez-banking-sdk/dist/helper/api/axiosHelper.js

A Node.js package to handle GGEZ Banking API endpoints, Simplify the process of managing CRUD operations with this efficient and easy-to-use package.

import { generateSourceID } from "../../utils/data/generation";
import { isEntityEndpoint } from "../../utils/api/endpointUtils";
import { DateTimeHelper } from "../dateTimeHelper";
import qs from "qs";
import { HeaderKeys } from "../../constant/constant";
class AxiosHelper {
    static bearer = (token) => `Bearer ${token}`;
    static getAxiosConfig = (token, baseURL, lang, installationId) => {
        const config = {
            headers: {
                [HeaderKeys.ContentType]: "application/json",
                [HeaderKeys.Language]: lang,
                [HeaderKeys.InstallationID]: installationId,
                [HeaderKeys.ShowCustomField]: "1",
                [HeaderKeys.ShowTicket]: "1",
                [HeaderKeys.GenerateJwt]: "true",
            },
            baseURL: baseURL,
            withCredentials: true,
        };
        if (token && config.headers) {
            config.headers.Authorization = AxiosHelper.bearer(token);
        }
        return config;
    };
    static getAuthAxiosConfig = (baseURL, lang, installationId) => {
        const config = {
            headers: {
                [HeaderKeys.ContentType]: "application/x-www-form-urlencoded",
                [HeaderKeys.Language]: lang,
                [HeaderKeys.InstallationID]: installationId,
                [HeaderKeys.ShowCustomField]: "1",
                [HeaderKeys.ShowTicket]: "1",
                [HeaderKeys.GenerateJwt]: "true",
            },
            baseURL: baseURL,
        };
        return config;
    };
    static addAxiosConfigHeader = (config, key, value) => {
        if (!config.headers)
            config.headers = {};
        config.headers[key] = value;
    };
    static injectBaseHeaders = async (req, context, cookiesHelper) => {
        const token = await cookiesHelper.getAccessToken();
        const userId = await cookiesHelper.getUserId();
        const lang = context.getLang();
        const iid = await cookiesHelper.getIID();
        if (token && !req.headers.has(HeaderKeys.Authorization)) {
            req.headers.set(HeaderKeys.Authorization, AxiosHelper.bearer(token));
        }
        req.headers.set(HeaderKeys.SourceID, generateSourceID(userId ?? 0));
        if (lang)
            req.headers.set(HeaderKeys.Language, lang);
        if (iid)
            req.headers.set(HeaderKeys.InstallationID, iid);
        if (!req.baseURL)
            req.baseURL = context.getBaseUrl();
        req.headers.set(HeaderKeys.TimeZone, DateTimeHelper.getClientTimeZone());
        await AxiosHelper.injectGeoCoordinates(req, context.getGeoHelper());
        return req;
    };
    static injectBaseBodyProperties = (req) => {
        try {
            if (req.data) {
                if (typeof req.data == "string") {
                    const baseResult = qs.parse(req.data);
                    baseResult.time_zone = DateTimeHelper.getClientTimeZone();
                    baseResult.time_zone_name = DateTimeHelper.getClientTimeZoneName();
                    req.data = qs.stringify(baseResult);
                }
                else if (typeof req.data == "object") {
                    const baseResult = req.data;
                    baseResult.time_zone = DateTimeHelper.getClientTimeZone();
                    baseResult.time_zone_name = DateTimeHelper.getClientTimeZoneName();
                }
            }
        }
        catch (error) {
            console.error("Error parsing request data:", error);
        }
        finally {
            return req;
        }
    };
    static getLimitedToken = async (authService, cookiesHelper) => {
        const installationId = (await cookiesHelper.getIID()) ?? "";
        const res = await authService.generateLimitedToken({ installationId });
        return res.data?.data?.access_token ?? null;
    };
    static getLimitedAuthHeaders = async (authService, cookiesHelper) => {
        const token = await AxiosHelper.getLimitedToken(authService, cookiesHelper);
        return token
            ? { [HeaderKeys.Authorization]: AxiosHelper.bearer(token) }
            : undefined;
    };
    static injectLimitedToken = async (req, authService, cookiesHelper) => {
        const headers = await AxiosHelper.getLimitedAuthHeaders(authService, cookiesHelper);
        if (headers) {
            req.headers.set(HeaderKeys.Authorization, headers.Authorization);
        }
        return req;
    };
    static injectGeoCoordinates = async (req, geoHelper) => {
        if (!isEntityEndpoint(req.url))
            return req;
        const geoCoordinates = await geoHelper.getGeoCoordinates();
        if (req.data && typeof req.data === "object") {
            const data = req.data;
            data.geo_coordinates = geoCoordinates;
        }
        return req;
    };
}
export { AxiosHelper };