unomi-sdk-node/dist/utils/index.js

Node module to interact with unomi.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * @function createUuid
 */
function generateUuid() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
        let r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
        return v.toString(16);
    });
}
exports.generateUuid = generateUuid;
/**
 * @function validateRequiredProps
 * @param {string[]} required
 * @param {{[key: string]: any}} props
 */
function validateRequiredProps(required, props) {
    let missing = [];
    for (const prop of required) {
        if (!Object.keys(props).includes(prop)
            || props[prop] === null
            || props[prop] === undefined) {
            missing.push(prop);
        }
    }
    return {
        valid: !missing.length,
        missing,
    };
}
exports.validateRequiredProps = validateRequiredProps;
/**
 * @function getComparisonOperators
 */
function getComparisonOperators() {
    // operators in comments don't work
    const operators = [
        "equals",
        "notEquals",
        "greaterThan",
        "greaterThanOrEqualTo",
        "lessThan",
        "lessThanOrEqualTo",
        "between",
        "exists",
        "missing",
        "contains",
        "notContains",
        "startsWith",
        "endsWith",
        // "matchesRegex",
        "in",
        "notIn",
        "all",
        // "inContains",
        "hasSomeOf",
        "hasNoneOf",
    ];
    return operators;
}
exports.getComparisonOperators = getComparisonOperators;
/**
 * @function callUnomi
 * @param {string} method
 * @param {string} url
 * @param {object} body
 * @param {string} auth
 * @param {string} successStatus
 * @returns {FilteredResponse}
 */
function callUnomi(method, url, body, auth, successStatus) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            let response;
            if (body === null) {
                response = yield fetch(url, {
                    method: method,
                    headers: {
                        "Authorization": "Basic " + btoa(auth.username + ":" + auth.password)
                    },
                    credentials: "omit",
                    mode: 'cors',
                });
            }
            else {
                response = yield fetch(url, {
                    method: method,
                    headers: {
                        "Authorization": "Basic " + btoa(auth.username + ":" + auth.password),
                        "Content-Type": "application/json"
                    },
                    body: JSON.stringify(body),
                    credentials: "omit",
                    mode: 'cors',
                });
            }
            var data;
            if (response.status != 204) {
                data = yield response.json();
            }
            else {
                data = "";
            }
            if (response.status === successStatus) {
                return {
                    statusCode: response.status,
                    responseData: data
                };
            }
            return {
                statusCode: response.status,
                errorMessage: "Something went wrong processing this request. Please try again later or contact support if this error persists.",
                response: response
            };
        }
        catch (err) {
            return {
                statusCode: 500,
                errorMessage: "Something went wrong processing this request. Please try again later or contact support if this error persists.",
                response: {
                    method: method,
                    url: url,
                    body: body,
                    successStatus: successStatus
                }
            };
        }
    });
}
exports.callUnomi = callUnomi;
/**
 * @function callElasticsearch
 * @param {string} method
 * @param {string} url
 * @param {object} body
 * @param {string} auth
 * @param {string} successStatus
 * @returns {FilteredResponse}
 */
function callElasticsearch(method, url, auth, successStatus) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            let response;
            response = yield fetch(url, {
                method: method,
                headers: {
                    "Authorization": "Basic " + btoa(auth.username + ":" + auth.password)
                },
                credentials: "omit",
                mode: 'cors',
            });
            var data = yield response.json();
            data = data["context-profile"]["mappings"]["properties"]["properties"]["properties"];
            if (response.status === successStatus) {
                return {
                    statusCode: response.status,
                    responseData: Object.keys(data) // list of the keys of the data object
                };
            }
            return {
                statusCode: response.status,
                errorMessage: "Something went wrong processing this request. Please try again later or contact support if this error persists.",
                response: response
            };
        }
        catch (err) {
            return {
                statusCode: 500,
                errorMessage: "Something went wrong processing this request. Please try again later or contact support if this error persists.",
                response: {
                    method: method,
                    url: url,
                    successStatus: successStatus
                }
            };
        }
    });
}
exports.callElasticsearch = callElasticsearch;