@lana-commerce/core 11.0.0

package/esm/modules/cart.js

@@ -0,0 +1,699 @@
+import { combine, createEvent, createStore, forward, guard, restore } from "effector";
+import { dequal } from "dequal/lite";
+import { klona } from "klona/json";
+import { prettyPrintRequestResponseError, request, } from "../request.js";
+import { compactCartOperations, filterOutNonCreateOpertions } from "../cartOperation.js";
+import { ControlledQueue } from "../controlledQueue.js";
+import { ErrorCode } from "../generated/codes.js";
+import { deserialize, serialize } from "./persist.js";
+import { firstResponseData } from "../mapResponseData.js";
+import { nonNull } from "../nonNull.js";
+class RelaxedCartActivityReporter {
+    delay;
+    onActivity;
+    lastReported = "idle";
+    timer;
+    constructor(delay, onActivity) {
+        this.delay = delay;
+        this.onActivity = onActivity;
+    }
+    reportDelayed(activity) {
+        const { onActivity } = this;
+        if (!onActivity)
+            return;
+        this.timer = setTimeout(() => {
+            this.lastReported = activity;
+            onActivity(activity);
+        }, this.delay);
+    }
+    report(activity) {
+        if (this.timer)
+            clearTimeout(this.timer);
+        if (this.lastReported !== "idle" && activity === "idle") {
+            this.reportDelayed("idle");
+        }
+        else {
+            this.lastReported = activity;
+            this.onActivity?.(activity);
+        }
+    }
+}
+function apiStateToLineItems(state, predictedLineItems) {
+    const out = [];
+    for (let i = 0; i < state.line_items.length; i++) {
+        const li = state.line_items[i];
+        const ci = li.custom_item_index >= 0 ? state.custom_items?.[li.custom_item_index] : undefined;
+        // we will use fake custom item id as variant id, variant id is used for addressing in the API
+        const variantID = ci ? ci.id : nonNull(li.variant_id, "line item variant_id");
+        const variant = li.variant || predictedLineItems?.find((pli) => pli.variantID === variantID)?.variant;
+        out.push({
+            quantity: li.quantity,
+            variant,
+            variantID,
+            discountPreview: li.discount_preview,
+            fieldSetID: li.field_set?.id || "",
+            fields: li.fields,
+            subscriptionPlanIndex: li.subscription_plan_index,
+            customItemIndex: li.custom_item_index,
+            customItem: ci ? { id: ci.id, title: ci.title, price: ci.price } : undefined,
+        });
+    }
+    return out;
+}
+function doApplyOperationsToLineItems(lineItems, operations) {
+    let newLineItems = klona(lineItems);
+    for (const op of operations) {
+        if (op.kind === "change") {
+            const li = newLineItems.find((li) => li.variantID === op.variantID);
+            if (li) {
+                const hasDiscountPreview = li.discountPreview > 0;
+                if (hasDiscountPreview) {
+                    li.discountPreview /= li.quantity;
+                }
+                li.quantity += op.quantityDelta;
+                if (hasDiscountPreview) {
+                    li.discountPreview *= li.quantity;
+                    li.discountPreview = Math.round(li.discountPreview);
+                }
+                if (op.fieldSetID !== undefined && op.fields !== undefined) {
+                    li.fields = op.fields;
+                    li.fieldSetID = op.fieldSetID;
+                }
+                if (op.subscriptionPlanIndex !== undefined) {
+                    li.subscriptionPlanIndex = op.subscriptionPlanIndex;
+                }
+                if (op.customItemIndex !== undefined) {
+                    li.customItemIndex = op.customItemIndex;
+                }
+            }
+            else if (op.quantityDelta > 0) {
+                newLineItems.push({
+                    quantity: op.quantityDelta,
+                    variant: op.variant,
+                    variantID: op.variantID,
+                    discountPreview: 0,
+                    fieldSetID: op.fieldSetID || "",
+                    fields: op.fields,
+                    subscriptionPlanIndex: op.subscriptionPlanIndex,
+                    customItemIndex: op.customItemIndex,
+                });
+            }
+            else {
+                // this should never happen
+                console.error(`line item not found (${op.variantID}) and quantity delta is ${op.quantityDelta}`);
+            }
+        }
+        else if (op.kind === "remove") {
+            newLineItems = newLineItems.filter((li) => li.variantID !== op.variantID);
+        }
+        else if (op.kind === "set") {
+            const li = newLineItems.find((li) => li.variantID === op.variantID);
+            if (op.quantity <= 0) {
+                // this should never happen
+                console.error(`negative quantity on set operation ${op.variantID}: ${op.quantity}`);
+            }
+            else if (li) {
+                if (li.discountPreview > 0) {
+                    li.discountPreview /= li.quantity;
+                    li.discountPreview *= op.quantity;
+                    li.discountPreview = Math.round(li.discountPreview);
+                }
+                li.quantity = op.quantity;
+                if (op.fieldSetID !== undefined && op.fields !== undefined) {
+                    li.fields = op.fields;
+                    li.fieldSetID = op.fieldSetID;
+                }
+                if (op.subscriptionPlanIndex !== undefined) {
+                    li.subscriptionPlanIndex = op.subscriptionPlanIndex;
+                }
+                if (op.customItemIndex !== undefined) {
+                    li.customItemIndex = op.customItemIndex;
+                }
+            }
+            else {
+                newLineItems.push({
+                    quantity: op.quantity,
+                    variant: op.variant,
+                    variantID: op.variantID,
+                    discountPreview: 0,
+                    fieldSetID: op.fieldSetID || "",
+                    fields: op.fields,
+                    subscriptionPlanIndex: op.subscriptionPlanIndex,
+                    customItemIndex: op.customItemIndex,
+                });
+            }
+        }
+    }
+    if (newLineItems.some((li) => li.quantity <= 0)) {
+        newLineItems = newLineItems.filter((li) => li.quantity > 0);
+    }
+    return newLineItems;
+}
+function lineItemsToAPIMutation(lineItems) {
+    return lineItems.map((li) => ({
+        variant_id: li.variantID.startsWith("ci_") ? "" : li.variantID,
+        quantity: li.quantity,
+        field_set_id: li.fieldSetID,
+        fields: li.fields,
+        subscription_plan_index: li.subscriptionPlanIndex !== undefined ? { value: li.subscriptionPlanIndex } : undefined,
+        custom_item_index: li.customItemIndex !== undefined ? { value: li.customItemIndex } : undefined,
+    }));
+}
+/**
+ * Create the Cart instance with a given config and init option. Note that if init option is not "new", cart
+ * will start fetching its state from the server right away.
+ */
+export function createCart(config, init) {
+    let initialized = false;
+    let configWithJWT = { ...config };
+    let savedCurrency = "";
+    const queue = new ControlledQueue();
+    const setActivity = createEvent();
+    const setLocked = createEvent();
+    const setCartData = createEvent();
+    const setLineItems = createEvent();
+    const setLineItemsIfChanged = createEvent();
+    const setCurrencyValue = createEvent();
+    const applyOperationsToLineItems = createEvent();
+    const setDiscountCodeResult = createEvent();
+    const setDiscountCodePending = createEvent();
+    const setDiscountCodeResultAndPending = createEvent();
+    const setDiscountCodeInput = createEvent();
+    const setAllState = createEvent();
+    const discountCodeInput = restore(setDiscountCodeInput, "")
+        .reset(guard({ source: setDiscountCodeResult, filter: (v) => v.kind === "ok" }))
+        .on(setAllState, (_, v) => v.discountCodeInput);
+    const activity = restore(setActivity, "idle").on(setAllState, (_, v) => v.activity);
+    const locked = restore(setLocked, false).on(setAllState, (_, v) => v.locked);
+    const lineItems = restore(setLineItems, [])
+        .on(applyOperationsToLineItems, doApplyOperationsToLineItems)
+        .on(setLineItemsIfChanged, (lineItems, newLineItems) => !dequal(lineItems, newLineItems) ? newLineItems : undefined)
+        .on(setAllState, (_, v) => v.lineItems);
+    const cartData = restore(setCartData, null).on(setAllState, (_, v) => v.cartData);
+    const discountCode = createStore("")
+        .on(setCartData, (_, v) => v?.cart.discount_code || "")
+        .on(setAllState, (_, v) => v.discountCode);
+    const discountCodePending = restore(setDiscountCodePending, false).on(setAllState, (_, v) => v.discountCodePending);
+    const discountCodeResult = restore(setDiscountCodeResult, { kind: "ok" }).on(setAllState, (_, v) => v.discountCodeResult);
+    const currency = restore(setCurrencyValue, "")
+        .on(setCartData, (_, v) => v?.cart.currency || "")
+        .on(setAllState, (_, v) => v.currency);
+    let persistLoaded = false;
+    if (config.persist) {
+        const VERSION = 1;
+        const { load, save, onChange, maxAgeMs } = config.persist;
+        const realMaxAgeMs = Math.max(maxAgeMs ?? 0, 0) || 1800000;
+        const allState = combine({
+            discountCodeInput,
+            activity,
+            locked,
+            lineItems,
+            cartData,
+            discountCode,
+            discountCodePending,
+            discountCodeResult,
+            currency,
+        });
+        if (init.kind === "load_or") {
+            const allState = deserialize(load(), VERSION, realMaxAgeMs);
+            if (allState) {
+                setAllState(allState);
+                persistLoaded = true;
+            }
+        }
+        allState.updates.watch((data) => {
+            if (data.activity === "idle") {
+                // We only save cart when it's idle.
+                save(serialize(data, VERSION));
+            }
+        });
+        onChange((data) => {
+            const newAllState = deserialize(data, VERSION, realMaxAgeMs);
+            if (newAllState) {
+                queue.exec(async () => {
+                    if (allState.getState().activity === "idle") {
+                        // Only set new state if the cart is idle. It's better to ignore state updates from other browser tabs
+                        // than to disrupt the current cart flow, whatever it is. Cart has recovery mechanisms for dealing with
+                        // out-of-date state.
+                        setAllState(newAllState);
+                    }
+                });
+            }
+        });
+    }
+    // api sync queue is drained as soon as possible and is used to update "lastAPIState"
+    const apiSyncQueue = [];
+    // prediction queue is drained as soon as possible and is used to produce "lineItems"
+    const predictionQueue = [];
+    const relaxedActivityReporter = new RelaxedCartActivityReporter(400, setActivity);
+    forward({
+        from: setDiscountCodeResultAndPending.map(([r, _code, _p]) => r),
+        to: setDiscountCodeResult,
+    });
+    forward({
+        from: setDiscountCodeResultAndPending.map(([_r, _code, p]) => p),
+        to: setDiscountCodePending,
+    });
+    // init never fails
+    queue.exec(async () => {
+        if (init.kind === "load_or") {
+            if (persistLoaded) {
+                initialized = true;
+                applyPredictionsIfInitialized();
+            }
+            else {
+                await initCart(init.init);
+            }
+        }
+        else {
+            await initCart(init);
+        }
+    });
+    function reportActivity(activity) {
+        relaxedActivityReporter.report(activity);
+    }
+    function applyLastAPIState(cart, predictedLineItems) {
+        const cartData = {
+            cart,
+            lineItems: apiStateToLineItems(cart, predictedLineItems),
+        };
+        setCartData(cartData);
+        return cartData;
+    }
+    async function initCart(init) {
+        const { graphql: { getCartQuery, getLastCartQuery }, shopID, opts, } = configWithJWT;
+        let resp;
+        if (init.kind === "fetch_by_id") {
+            reportActivity("init");
+            resp = firstResponseData(await request(getCartQuery)({ shopID, id: init.id, uuid: init.uuid }, opts));
+            reportActivity("idle");
+        }
+        else if (init.kind === "fetch_last") {
+            reportActivity("init");
+            resp = await request(getLastCartQuery)({ shopID }, opts);
+            reportActivity("idle");
+        }
+        else if (init.kind === "fetch_last_or_by_id") {
+            reportActivity("init");
+            resp = await request(getLastCartQuery)({ shopID }, opts);
+            if (resp.kind === "error" && resp.error.apiError?.code === ErrorCode.NotFound) {
+                resp = firstResponseData(await request(getCartQuery)({ shopID, id: init.id, uuid: init.uuid }, opts));
+            }
+            reportActivity("idle");
+        }
+        else if (init.kind === "new") {
+            // do nothing, new cart will be initialized lazily
+        }
+        if (resp) {
+            if (resp.kind === "data") {
+                if (resp.data.state === "cart") {
+                    setLineItems(applyLastAPIState(resp.data).lineItems);
+                }
+                else {
+                    // for non-cart state we also do nothing
+                    // TODO: unreserve reserved orders
+                    console.error("order is not in cart state");
+                }
+            }
+            else {
+                // print error and do nothing, we'll start a new cart
+                console.error(prettyPrintRequestResponseError(resp));
+            }
+        }
+        initialized = true;
+        applyPredictionsIfInitialized();
+    }
+    function drainPredictionQueue() {
+        const operations = compactCartOperations(predictionQueue);
+        predictionQueue.length = 0;
+        return operations;
+    }
+    function drainAPISyncQueue() {
+        const operations = compactCartOperations(apiSyncQueue);
+        apiSyncQueue.length = 0;
+        return operations;
+    }
+    function applyPredictionsIfInitialized() {
+        if (!initialized)
+            return;
+        const operations = drainPredictionQueue();
+        if (operations.length === 0)
+            return;
+        applyOperationsToLineItems(operations);
+    }
+    function launchLineItemsSyncTaskIfInitialized() {
+        if (!initialized)
+            return;
+        queue.exec(async (controller) => {
+            const respError = await lineItemsSync();
+            if (respError) {
+                controller.discard();
+            }
+            return respError;
+        });
+    }
+    async function submitOperationsToAPIOnce(operations) {
+        const { graphql: { createCartMutation, modifyCartMutation }, shopID, opts, } = configWithJWT;
+        let predictedLineItems;
+        let resp;
+        const cd = cartData.getState();
+        if (!cd) {
+            predictedLineItems = doApplyOperationsToLineItems([], filterOutNonCreateOpertions(operations));
+            resp = await request(createCartMutation)({
+                shopID,
+                data: { line_items: lineItemsToAPIMutation(predictedLineItems), currency: savedCurrency || undefined },
+            }, opts);
+        }
+        else {
+            predictedLineItems = doApplyOperationsToLineItems(cd.lineItems, operations);
+            resp = await request(modifyCartMutation)({
+                shopID,
+                id: cd.cart.id,
+                uuid: cd.cart.uuid,
+                updatedAt: cd.cart.updated_at,
+                data: { line_items: lineItemsToAPIMutation(predictedLineItems) },
+            }, opts);
+        }
+        if (resp.kind === "data") {
+            applyLastAPIState(resp.data[0], predictedLineItems);
+        }
+        else {
+            return resp;
+        }
+    }
+    async function submitOperationsToAPI(operations) {
+        while (true) {
+            const respError = await submitOperationsToAPIOnce(operations);
+            if (!respError) {
+                // if there was no error, return
+                return;
+            }
+            const cd = cartData.getState();
+            if (respError.kind === "error" && respError.error.apiError?.code === ErrorCode.VersionMismatch && cd) {
+                // if it was version mismatch, fetch the cart again and retry
+                const { id, uuid } = cd.cart;
+                const respError = await refetchCart(id, uuid);
+                if (respError) {
+                    return respError;
+                }
+                continue;
+            }
+            else {
+                // otherwise, some unknown error? return it
+                return respError;
+            }
+        }
+    }
+    async function refetchCart(id, uuid) {
+        const { graphql: { getCartQuery }, shopID, opts, } = configWithJWT;
+        const resp = await request(getCartQuery)({ shopID, id, uuid }, opts);
+        if (resp.kind === "data") {
+            // TODO: what if it's not in cart state?
+            applyLastAPIState(resp.data[0]);
+        }
+        else {
+            return resp;
+        }
+    }
+    async function lineItemsSync() {
+        // exit early if there is nothing to do
+        if (apiSyncQueue.length === 0)
+            return undefined;
+        let error;
+        reportActivity("sync");
+        while (true) {
+            const operations = drainAPISyncQueue();
+            if (operations.length === 0)
+                break;
+            error = await submitOperationsToAPI(operations);
+            if (error) {
+                // if there was an error, operations were not applied, return them to queue and break out of the loop
+                apiSyncQueue.splice(0, 0, ...operations);
+            }
+            break;
+        }
+        reportActivity("idle");
+        if (error) {
+            initialized = false;
+            setLocked(true);
+        }
+        else {
+            // correct prediction if it's required
+            const cd = cartData.getState();
+            if (cd) {
+                setLineItemsIfChanged(cd.lineItems);
+            }
+        }
+        return error;
+    }
+    function applyOp(op) {
+        predictionQueue.push(op);
+        apiSyncQueue.push(op);
+        applyPredictionsIfInitialized();
+        launchLineItemsSyncTaskIfInitialized();
+    }
+    function makeSureNotLocked() {
+        if (locked.getState()) {
+            throw new Error("Cart is locked due to synchronization error. Please reload() it before continuing its usage.");
+        }
+    }
+    function postInit() {
+        initialized = true;
+        applyPredictionsIfInitialized();
+        if (apiSyncQueue.length > 0) {
+            // successful init, we might have some items in the queue, let's drain them
+            launchLineItemsSyncTaskIfInitialized();
+        }
+        else {
+            // successful init, but no operations to apply, make sure there is no stale state
+            setLineItemsIfChanged(cartData.getState()?.lineItems || []);
+        }
+    }
+    async function applyDiscountCodeImpl(discount_code) {
+        if (discountCodePending.getState())
+            return;
+        setDiscountCodePending(true);
+        const result = await queue.exec(async () => {
+            const { shopID, opts, graphql: { createCartMutation, modifyCartMutation }, } = configWithJWT;
+            while (true) {
+                let resp;
+                reportActivity("discount");
+                const cd = cartData.getState();
+                if (!cd) {
+                    resp = await request(createCartMutation)({ shopID, data: { currency: savedCurrency || undefined, discount_code } }, opts);
+                }
+                else {
+                    const { id, uuid, updated_at: updatedAt } = cd.cart;
+                    resp = await request(modifyCartMutation)({ shopID, id, uuid, updatedAt, data: { discount_code } }, opts);
+                }
+                reportActivity("idle");
+                if (resp.kind === "data") {
+                    const lis = applyLastAPIState(resp.data[0], lineItems.getState()).lineItems;
+                    if (apiSyncQueue.length === 0) {
+                        // only sync items if there is nothing in the sync queue, otherwise let api sync loop to
+                        // do the job, this also plays better with prediction model
+                        setLineItemsIfChanged(lis);
+                    }
+                    return { kind: "ok" };
+                }
+                else if (resp.kind === "system_error" || resp.kind === "custom_error") {
+                    return { kind: "unexpected_error", error: resp };
+                }
+                else {
+                    const apiError = resp.error.apiError;
+                    if (apiError?.code === ErrorCode.VersionMismatch && cd) {
+                        const { id, uuid } = cd.cart;
+                        const respError = await refetchCart(id, uuid);
+                        if (respError) {
+                            return { kind: "unexpected_error", error: respError };
+                        }
+                        continue; // retry
+                    }
+                    else if (apiError?.code === ErrorCode.NotFound && apiError.field === "[0].discount_code") {
+                        return { kind: "not_found" };
+                    }
+                    else if (apiError?.code === ErrorCode.InvalidInput) {
+                        const fields = apiError.meta?.fields;
+                        if (fields &&
+                            fields.length === 1 &&
+                            fields[0].field === "[0].customer_id" &&
+                            fields[0].problem === "mandatory") {
+                            return { kind: "customer_id_required" };
+                        }
+                    }
+                    return { kind: "unexpected_error", error: resp };
+                }
+            }
+        });
+        setDiscountCodeResultAndPending([
+            result.kind === "discarded" ? { kind: "discarded" } : result.value,
+            discount_code,
+            false,
+        ]);
+    }
+    function reload() {
+        if (!locked.getState()) {
+            throw new Error("You can reload() the cart only if it was locked due to synchronization errors previously.");
+        }
+        const cd = cartData.getState();
+        if (!cd) {
+            // if cart failed during "create cart" operation, there is nothing to restore, just unlock
+            setLocked(false);
+            postInit();
+        }
+        else {
+            // if cart failed during "modify cart" operation, we should attempt to refetch it
+            const { id, uuid } = cd.cart;
+            setLocked(false);
+            queue.exec(async (controller) => {
+                reportActivity("init");
+                const respError = await refetchCart(id, uuid);
+                reportActivity("idle");
+                if (respError) {
+                    controller.discard();
+                    setLocked(true);
+                }
+                else {
+                    postInit();
+                }
+                return respError;
+            });
+        }
+    }
+    function setItem(variantID, variant, quantity, fieldSetID, fields, subscriptionPlanIndex) {
+        makeSureNotLocked();
+        applyOp({ kind: "set", quantity, variant, variantID, fieldSetID, fields, subscriptionPlanIndex });
+    }
+    function changeItem(variantID, variant, quantityDelta, fieldSetID, fields, subscriptionPlanIndex) {
+        makeSureNotLocked();
+        applyOp({ kind: "change", quantityDelta, variant, variantID, fieldSetID, fields, subscriptionPlanIndex });
+    }
+    function removeItem(variantID) {
+        makeSureNotLocked();
+        applyOp({ kind: "remove", variantID });
+    }
+    function removeDiscountCode() {
+        makeSureNotLocked();
+        applyDiscountCodeImpl("");
+    }
+    function applyDiscountCode() {
+        makeSureNotLocked();
+        applyDiscountCodeImpl(discountCodeInput.getState());
+    }
+    function checkout(callback) {
+        makeSureNotLocked();
+        queue.exec(async () => {
+            await callback();
+        });
+    }
+    function setCurrency(currency, mode) {
+        makeSureNotLocked();
+        queue.exec(async (controller) => {
+            const cd = cartData.getState();
+            if (cd && cd.cart.currency !== currency) {
+                // Soft mode means we only set currency if there is no cart yet.
+                if (mode === "soft")
+                    return;
+                const { shopID, opts, graphql: { modifyCartMutation }, } = configWithJWT;
+                const { id, uuid, updated_at: updatedAt } = cd.cart;
+                reportActivity("currency");
+                const resp = await request(modifyCartMutation)({ shopID, id, uuid, updatedAt, data: { currency } }, opts);
+                reportActivity("idle");
+                if (resp.kind === "data") {
+                    const lis = applyLastAPIState(resp.data[0], lineItems.getState()).lineItems;
+                    if (apiSyncQueue.length === 0) {
+                        // only sync items if there is nothing in the sync queue, otherwise let api sync loop to
+                        // do the job, this also plays better with prediction model
+                        setLineItemsIfChanged(lis);
+                    }
+                    savedCurrency = currency;
+                }
+                else {
+                    controller.discard();
+                    setLocked(true);
+                }
+            }
+            else {
+                savedCurrency = currency;
+                setCurrencyValue(currency);
+            }
+        });
+    }
+    config.locale.updates.watch((locale) => {
+        makeSureNotLocked();
+        queue.exec(async (controller) => {
+            configWithJWT = {
+                ...configWithJWT,
+                opts: {
+                    ...configWithJWT.opts,
+                    locale,
+                },
+            };
+            const cd = cartData.getState();
+            if (cd) {
+                const { id, uuid } = cd.cart;
+                reportActivity("init");
+                const respError = await refetchCart(id, uuid);
+                reportActivity("idle");
+                if (respError) {
+                    controller.discard();
+                    setLocked(true);
+                }
+                else {
+                    postInit();
+                }
+            }
+        });
+    });
+    config.jwt.updates.watch((jwt) => {
+        makeSureNotLocked();
+        queue.exec(async (controller) => {
+            configWithJWT = {
+                ...configWithJWT,
+                opts: {
+                    ...configWithJWT.opts,
+                    authToken: jwt,
+                },
+            };
+            // when there is no jwt, just apply it and we'll continue using id/uuid from now on
+            if (!jwt)
+                return;
+            const { graphql: { getLastCartQuery }, shopID, opts, } = configWithJWT;
+            reportActivity("init");
+            const resp = await request(getLastCartQuery)({ shopID }, opts);
+            reportActivity("idle");
+            if (resp.kind === "error" && resp.error.apiError?.code === ErrorCode.NotFound) {
+                // if there is no last cart, do nothing
+                return;
+            }
+            if (resp.kind === "data") {
+                applyLastAPIState(resp.data);
+                postInit();
+            }
+            else {
+                controller.discard();
+                setLocked(true);
+            }
+        });
+    });
+    return {
+        setDiscountCodeInput,
+        discountCodeInput,
+        activity,
+        locked,
+        lineItems,
+        cartData,
+        discountCode,
+        discountCodePending,
+        discountCodeResult,
+        reload,
+        setItem,
+        changeItem,
+        removeItem,
+        applyDiscountCode,
+        removeDiscountCode,
+        checkout,
+        currency,
+        setCurrency,
+    };
+}

package/esm/modules/config/defaultAdvancedSearchGraphQLConfig.js

@@ -0,0 +1,4 @@
+import searchProductsAdvancedQuery from "../../graphql/operations/SearchProductsAdvancedQuery.js";
+export const defaultAdvancedSearchGraphQLConfig = {
+    searchProductsQuery: searchProductsAdvancedQuery,
+};