@klevu/core/dist/mjs/connection/klevuFetch.js

Typescript SDK that simplifies development on Klevu backend. Klevu provides advanced AI-powered search and discovery solutions for online retailers.

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());
    });
};
import { KlevuConfig } from "../index.js";
import { KlevuTypeOfRequest, } from "../models/index.js";
import { injectFilterResult } from "../modifiers/injectFilterResult/injectFilterResult.js";
import { KlevuFetchCache } from "../store/klevuFetchCache.js";
import { post } from "./fetch.js";
import { KlevuResponseObject } from "./responseObject.js";
export const klevuFetchCache = new KlevuFetchCache();
export class KlevuFetchOption {
    constructor(params = {}) {
        this.params = params;
    }
}
/**
 * Function that makes query to KlevuBackend. It can take amount of queries.
 *
 * @category KlevuFetch
 * @param functions list of functions to execute
 * @returns Tools to operate results
 */
export function KlevuFetch(...functionPromises) {
    var _a, _b, _c, _d, _e;
    return __awaiter(this, void 0, void 0, function* () {
        if (functionPromises.length < 1) {
            throw new Error("At least one fetch function should be provided to fetch.");
        }
        const option = functionPromises.find((f) => f instanceof KlevuFetchOption);
        const functionPromisesWithoutOptions = functionPromises.filter((f) => !(f instanceof KlevuFetchOption));
        const functions = yield Promise.all(functionPromisesWithoutOptions);
        const { recordQueries, suggestionQueries } = yield cleanAndProcessFunctions(functions);
        const withOverride = functions.find((f) => Boolean(f.configOverride));
        const payload = {
            context: {
                apiKeys: [
                    (_b = (_a = withOverride === null || withOverride === void 0 ? void 0 : withOverride.configOverride) === null || _a === void 0 ? void 0 : _a.apiKey) !== null && _b !== void 0 ? _b : KlevuConfig.getDefault().apiKey,
                ],
            },
            recordQueries: recordQueries.length > 0 ? recordQueries : undefined,
            suggestions: suggestionQueries.length > 0 ? suggestionQueries : undefined,
        };
        const cached = klevuFetchCache.check(payload);
        let response;
        const withoutSkip = recordQueries.filter((q) => q.typeOfRequest !== KlevuTypeOfRequest.Skip);
        if (withoutSkip.length > 0 || suggestionQueries.length > 0) {
            if (cached) {
                response = cached;
            }
            else {
                const res = yield post((_d = (_c = withOverride === null || withOverride === void 0 ? void 0 : withOverride.configOverride) === null || _c === void 0 ? void 0 : _c.url) !== null && _d !== void 0 ? _d : KlevuConfig.getDefault().url, payload);
                if (!res) {
                    throw new Error("Couldn't fetch data");
                }
                response = res;
                if (((_e = res.meta) === null || _e === void 0 ? void 0 : _e.responseCode) == 200) {
                    klevuFetchCache.cache(payload, response);
                }
            }
        }
        return new KlevuResponseObject(response !== null && response !== void 0 ? response : {
            meta: {
                qTime: 0,
                responseCode: 204,
            },
            queryResults: recordQueries.map((r) => ({
                id: r.id,
                meta: {},
                records: [],
            })),
            suggestionResults: [],
        }, functions, option);
    });
}
function cleanAndProcessFunctions(functions) {
    return __awaiter(this, void 0, void 0, function* () {
        const recordQueries = [];
        const suggestionQueries = [];
        for (const f of functions) {
            if (f.queries) {
                let qs = [...f.queries];
                if (f.modifiers) {
                    for (const modifier of f.modifiers) {
                        if (modifier.modifyAfter) {
                            qs = yield modifier.modifyAfter(qs, f);
                        }
                    }
                }
                recordQueries.push(...qs);
            }
            if (f.suggestions) {
                suggestionQueries.push(...f.suggestions);
            }
        }
        // Check for duplicate id's
        for (const query of recordQueries) {
            if (recordQueries.filter((q) => q.id === query.id).length !== 1) {
                throw new Error("Duplicate ids in request. Please provider unique ids for requests");
            }
        }
        return {
            recordQueries,
            suggestionQueries,
        };
    });
}
/**
 * Removes list filters from query
 *
 * @param f
 * @param prevQueryResult
 * @returns
 */
export function removeListFilters(f, prevQueryResult) {
    var _a;
    f.queries = (_a = f.queries) === null || _a === void 0 ? void 0 : _a.map((q) => {
        var _a, _b;
        if ((_a = q.filters) === null || _a === void 0 ? void 0 : _a.filtersToReturn) {
            (_b = q.filters) === null || _b === void 0 ? true : delete _b.filtersToReturn;
        }
        return q;
    });
    if (f.modifiers) {
        const index = f.modifiers.findIndex((m) => m.klevuModifierId == "listfilters");
        if (index > -1) {
            f.modifiers.splice(index, 1);
        }
        f.modifiers.push(injectFilterResult(prevQueryResult));
    }
    return f;
}