@techsio/storefront-data/dist/medusa/preset.js

Medusa-first storefront data layer built on TanStack Query.

import { createAuthHooks } from "../auth/hooks.js";
import { createMedusaAuthService } from "../auth/medusa-service.js";
import { createCartHooks } from "../cart/hooks.js";
import { createMedusaCartService } from "../cart/medusa-service.js";
import { createCatalogHooks } from "../catalog/hooks.js";
import { createCategoryHooks } from "../categories/hooks.js";
import { createCheckoutHooks } from "../checkout/hooks.js";
import { createMedusaCheckoutService } from "../checkout/medusa-service.js";
import { createCollectionHooks } from "../collections/hooks.js";
import { createCustomerHooks } from "../customers/hooks.js";
import { createMedusaCustomerService } from "../customers/medusa-service.js";
import { createOrderHooks } from "../orders/hooks.js";
import { createProductAttributeHooks } from "../product-attributes/hooks.js";
import { createProductListHooks } from "../product-lists/hooks.js";
import { createProductLocationAvailabilityHooks } from "../product-location-availability/hooks.js";
import { createProductHooks } from "../products/hooks.js";
import { createRegionHooks } from "../regions/hooks.js";
import { createProductReviewHooks } from "../reviews/hooks.js";
import { createMedusaCartFlow } from "./cart-flow.js";
import { createMedusaCheckoutFlow } from "./checkout-flow.js";
import { createMedusaStorefrontQueryKeys, resolveMedusaStorefrontFoundation } from "./foundation.js";
import { createMedusaStorefrontServerReadPreset } from "./server-read.js";
const createDefaultCatalogFacets = ()=>({
        status: [],
        form: [],
        brand: [],
        ingredient: [],
        price: {
            min: null,
            max: null
        }
    });
const preset_createMedusaStorefrontQueryKeys = createMedusaStorefrontQueryKeys;
function createMedusaStorefrontPreset(config) {
    const { namespace, cacheConfig: resolvedCacheConfig, defaultQueryKeys } = resolveMedusaStorefrontFoundation(config);
    const resolveQueryKeys = ()=>({
            auth: config.auth?.queryKeys ?? defaultQueryKeys.auth,
            cart: config.cart?.queryKeys ?? defaultQueryKeys.cart,
            checkout: config.checkout?.queryKeys ?? defaultQueryKeys.checkout,
            products: config.products?.queryKeys ?? defaultQueryKeys.products,
            productLists: config.productLists?.queryKeys ?? defaultQueryKeys.productLists,
            productAttributes: config.productAttributes?.queryKeys ?? defaultQueryKeys.productAttributes,
            productLocationAvailability: config.productLocationAvailability?.queryKeys ?? defaultQueryKeys.productLocationAvailability,
            reviews: config.reviews?.queryKeys ?? defaultQueryKeys.reviews,
            orders: config.orders?.queryKeys ?? defaultQueryKeys.orders,
            customers: config.customers?.queryKeys ?? defaultQueryKeys.customers,
            regions: config.regions?.queryKeys ?? defaultQueryKeys.regions,
            categories: config.categories?.queryKeys ?? defaultQueryKeys.categories,
            collections: config.collections?.queryKeys ?? defaultQueryKeys.collections,
            catalog: config.catalog?.queryKeys ?? defaultQueryKeys.catalog
        });
    const queryKeys = resolveQueryKeys();
    const serverRead = createMedusaStorefrontServerReadPreset({
        sdk: config.sdk,
        queryKeyNamespace: namespace,
        cacheConfig: resolvedCacheConfig,
        products: {
            serviceConfig: config.products?.serviceConfig,
            hooks: config.products?.hooks,
            queryKeys: queryKeys.products
        },
        productLists: {
            service: config.productLists?.service,
            serviceConfig: config.productLists?.serviceConfig,
            hooks: config.productLists?.hooks,
            queryKeys: queryKeys.productLists
        },
        productAttributes: {
            service: config.productAttributes?.service,
            serviceConfig: config.productAttributes?.serviceConfig,
            hooks: config.productAttributes?.hooks,
            queryKeys: queryKeys.productAttributes
        },
        productLocationAvailability: {
            service: config.productLocationAvailability?.service,
            serviceConfig: config.productLocationAvailability?.serviceConfig,
            queryKeys: queryKeys.productLocationAvailability
        },
        reviews: {
            service: config.reviews?.service,
            serviceConfig: config.reviews?.serviceConfig,
            hooks: config.reviews?.hooks,
            queryKeys: queryKeys.reviews
        },
        orders: {
            service: config.orders?.service,
            serviceConfig: config.orders?.serviceConfig,
            hooks: config.orders?.hooks,
            queryKeys: queryKeys.orders
        },
        regions: {
            hooks: config.regions?.hooks,
            queryKeys: queryKeys.regions
        },
        categories: {
            serviceConfig: config.categories?.serviceConfig,
            hooks: config.categories?.hooks,
            queryKeys: queryKeys.categories
        },
        collections: {
            serviceConfig: config.collections?.serviceConfig,
            hooks: config.collections?.hooks,
            queryKeys: queryKeys.collections
        },
        catalog: {
            serviceConfig: config.catalog?.serviceConfig,
            hooks: config.catalog?.hooks,
            queryKeys: queryKeys.catalog
        }
    });
    const resolveServices = ()=>({
            auth: config.auth?.service ?? createMedusaAuthService(config.sdk, config.auth?.serviceConfig),
            cart: createMedusaCartService(config.sdk, config.cart?.serviceConfig),
            checkout: createMedusaCheckoutService(config.sdk, config.checkout?.serviceConfig),
            products: serverRead.services.products,
            productLists: serverRead.services.productLists,
            productAttributes: serverRead.services.productAttributes,
            productLocationAvailability: serverRead.services.productLocationAvailability,
            reviews: serverRead.services.reviews,
            orders: serverRead.services.orders,
            customers: config.customers?.service ?? createMedusaCustomerService(config.sdk),
            regions: serverRead.services.regions,
            categories: serverRead.services.categories,
            collections: serverRead.services.collections,
            catalog: serverRead.services.catalog
        });
    const services = resolveServices();
    const authHookOverrides = config.auth?.hooks;
    const authInvalidationOverrides = authHookOverrides?.invalidateOnAuthChange;
    const cartHookOverrides = config.cart?.hooks;
    const cartFlowOverrides = config.cart?.flow;
    const checkoutHookOverrides = config.checkout?.hooks;
    const customerHookOverrides = config.customers?.hooks;
    const resolvedCheckoutActiveCartQueryKey = checkoutHookOverrides?.isActiveCartQueryKey ?? cartFlowOverrides?.isActiveCartQueryKey;
    const resolveAuthInvalidateOnAuthChange = ()=>{
        const presetAuthInvalidateKeys = [
            queryKeys.customers.all(),
            queryKeys.orders.all(),
            queryKeys.productLists.all()
        ];
        const presetAuthRemoveOnLogoutKeys = [
            queryKeys.customers.all(),
            queryKeys.orders.all(),
            queryKeys.productLists.all()
        ];
        return {
            includeDefaults: authInvalidationOverrides?.includeDefaults ?? false,
            invalidate: [
                ...presetAuthInvalidateKeys,
                ...authInvalidationOverrides?.invalidate ?? []
            ],
            removeOnLogout: [
                ...presetAuthRemoveOnLogoutKeys,
                ...authInvalidationOverrides?.removeOnLogout ?? []
            ]
        };
    };
    const resolvedAuthInvalidateOnAuthChange = resolveAuthInvalidateOnAuthChange();
    const fallbackCatalogFacets = config.catalog?.fallbackFacets ?? createDefaultCatalogFacets();
    const buildMedusaAddLineItemParams = (input)=>({
            variant_id: input.variantId,
            quantity: input.quantity ?? 1,
            ...input.metadata ? {
                metadata: input.metadata
            } : {}
        });
    const createHooks = ()=>({
            auth: createAuthHooks({
                ...authHookOverrides ?? {},
                service: services.auth,
                queryKeys: queryKeys.auth,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig,
                invalidateOnAuthChange: resolvedAuthInvalidateOnAuthChange
            }),
            cart: createCartHooks({
                ...cartHookOverrides ?? {},
                service: services.cart,
                queryKeys: queryKeys.cart,
                buildAddParams: cartHookOverrides?.buildAddParams ?? buildMedusaAddLineItemParams,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            checkout: createCheckoutHooks({
                ...checkoutHookOverrides ?? {},
                isActiveCartQueryKey: resolvedCheckoutActiveCartQueryKey,
                service: services.checkout,
                queryKeys: queryKeys.checkout,
                cartQueryKeys: queryKeys.cart,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            products: createProductHooks({
                ...config.products?.hooks ?? {},
                service: services.products,
                queryKeys: queryKeys.products,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            productLists: createProductListHooks({
                ...config.productLists?.hooks ?? {},
                service: services.productLists,
                queryKeys: queryKeys.productLists,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig,
                cartQueryKeys: queryKeys.cart,
                cartStorage: cartHookOverrides?.cartStorage,
                isActiveCartQueryKey: resolvedCheckoutActiveCartQueryKey
            }),
            productAttributes: createProductAttributeHooks({
                ...config.productAttributes?.hooks ?? {},
                service: services.productAttributes,
                queryKeys: queryKeys.productAttributes,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            productLocationAvailability: createProductLocationAvailabilityHooks({
                ...config.productLocationAvailability?.hooks ?? {},
                service: services.productLocationAvailability,
                queryKeys: queryKeys.productLocationAvailability,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            reviews: createProductReviewHooks({
                ...config.reviews?.hooks ?? {},
                service: services.reviews,
                queryKeys: queryKeys.reviews,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            orders: createOrderHooks({
                ...config.orders?.hooks ?? {},
                service: services.orders,
                queryKeys: queryKeys.orders,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            customers: createCustomerHooks({
                ...customerHookOverrides ?? {},
                service: services.customers,
                queryKeys: queryKeys.customers,
                authQueryKeys: customerHookOverrides?.authQueryKeys ?? queryKeys.auth,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            regions: createRegionHooks({
                ...config.regions?.hooks ?? {},
                service: services.regions,
                queryKeys: queryKeys.regions,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            categories: createCategoryHooks({
                ...config.categories?.hooks ?? {},
                service: services.categories,
                queryKeys: queryKeys.categories,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            collections: createCollectionHooks({
                ...config.collections?.hooks ?? {},
                service: services.collections,
                queryKeys: queryKeys.collections,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            }),
            catalog: createCatalogHooks({
                ...config.catalog?.hooks ?? {},
                service: services.catalog,
                queryKeys: queryKeys.catalog,
                fallbackFacets: fallbackCatalogFacets,
                queryKeyNamespace: namespace,
                cacheConfig: resolvedCacheConfig
            })
        });
    const hooks = createHooks();
    const storefront = {
        namespace,
        cacheConfig: resolvedCacheConfig,
        queryKeys,
        services,
        hooks
    };
    const createFlows = ()=>({
            cart: createMedusaCartFlow({
                storefront,
                cartStorage: cartHookOverrides?.cartStorage,
                isActiveCartQueryKey: cartFlowOverrides?.isActiveCartQueryKey
            }),
            checkout: createMedusaCheckoutFlow({
                storefront,
                cartStorage: cartHookOverrides?.cartStorage,
                isActiveCartQueryKey: resolvedCheckoutActiveCartQueryKey
            })
        });
    const flows = createFlows();
    return {
        ...storefront,
        flows
    };
}
export { createMedusaStorefrontPreset, preset_createMedusaStorefrontQueryKeys as createMedusaStorefrontQueryKeys };