medusa-product-helper 0.0.16 → 0.0.19

package/.medusa/server/src/services/dynamic-filter-service.js

@@ -3,812 +3,898 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicFilterService = void 0;
 const utils_1 = require("@medusajs/framework/utils");
 const filter_provider_registry_1 = require("./filter-provider-registry");
-/**
- * Service that orchestrates filter application using filter providers.
- *
- * This service coordinates between filter providers and Medusa's RemoteQuery
- * to build and execute product queries with dynamic filters. It handles:
- * - Resolving providers for filter identifiers
- * - Validating filter values
- * - Applying filters to build query filters
- * - Executing queries with pagination and sorting
- *
- * @example
- * ```ts
- * const service = new DynamicFilterService(container)
- * const result = await service.applyFilters({
- *   filterParams: {
- *     category_id: ["cat_123"],
- *     price_range: { min: 10, max: 100 },
- *   },
- *   options: pluginOptions,
- *   pagination: { limit: 20, offset: 0 },
- * })
- * ```
- */
 class DynamicFilterService {
     constructor(container) {
-        // Try to resolve registry, create if not found
-        try {
-            this.registry = container.resolve("filterProviderRegistry");
-        }
-        catch {
-            // Registry not registered, create new one and register built-in providers
-            // This allows the service to work even if registry wasn't pre-registered
-            this.registry = new filter_provider_registry_1.FilterProviderRegistry();
-            // Auto-register built-in providers
-            try {
-                const { registerBuiltInProviders } = require("../providers/filter-providers");
-                registerBuiltInProviders(this.registry);
-            }
-            catch (error) {
-                // If registration fails, log but continue
-                console.warn("[DynamicFilterService] Failed to auto-register built-in providers:", error instanceof Error ? error.message : String(error));
-            }
-        }
+        this.registry = this.resolveRegistry(container);
         this.query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
     }
-    /**
-     * Get the filter provider registry.
-     * Useful for registering providers programmatically.
-     */
     getRegistry() {
         return this.registry;
     }
-    /**
-     * Apply filters to a product query and return results.
-     *
-     * This method:
-     * 1. Iterates through filter parameters
-     * 2. Resolves providers for each filter identifier
-     * 3. Validates filter values (if provider has validate method)
-     * 4. Applies filters to build the query filters object
-     * 5. Executes the query with pagination and sorting
-     * 6. Returns products and count
-     *
-     * @param options - Options for applying filters
-     * @returns Products and count matching the filters
-     * @throws Error if provider validation fails or provider application fails (fail-fast)
-     *
-     * @example
-     * ```ts
-     * const result = await service.applyFilters({
-     *   filterParams: {
-     *     category_id: ["cat_123", "cat_456"],
-     *     price_range: { min: 10, max: 100 },
-     *   },
-     *   options: pluginOptions,
-     *   pagination: { limit: 20, offset: 0 },
-     *   projection: { fields: ["id", "title", "handle"] },
-     * })
-     * ```
-     */
     async applyFilters(options) {
-        const { filterParams, options: pluginOptions, pagination, projection, context = {}, } = options;
-        // Build filter context
-        const filterContext = {
-            ...context,
-            options: pluginOptions,
+        const { filterParams, options: pluginOptions, pagination, projection, context = {} } = options;
+        const filterContext = { ...context, options: pluginOptions };
+        console.log(`[DynamicFilterService] applyFilters called with context:`, {
+            hasPricingContext: !!context.pricingContext,
+            pricingContextKeys: context.pricingContext ? Object.keys(context.pricingContext) : []
+        });
+        const { queryFilters, priceRangeFilter, promotionFilter, metadataFilter } = await this.processFilters(filterParams, filterContext);
+        // Check if pricing context has currency_code before including calculated_price
+        const pricingContext = context?.pricingContext;
+        console.log(`[DynamicFilterService] Pricing context check:`, {
+            hasPricingContext: !!pricingContext,
+            currencyCode: pricingContext?.currency_code,
+            currencyCodeType: typeof pricingContext?.currency_code
+        });
+        const hasValidPricingContext = !!pricingContext && typeof pricingContext.currency_code === "string" && pricingContext.currency_code.trim().length > 0;
+        console.log(`[DynamicFilterService] Has valid pricing context:`, hasValidPricingContext);
+        // Build query context first to verify it's valid
+        const queryContext = this.buildQueryContext(context);
+        console.log(`[DynamicFilterService] Query context built:`, {
+            hasVariants: !!queryContext.variants,
+            hasCalculatedPrice: !!queryContext.variants?.calculated_price,
+            calculatedPriceKeys: queryContext.variants?.calculated_price ? Object.keys(queryContext.variants.calculated_price) : []
+        });
+        // Only include calculated_price in fields if query context has the proper structure
+        // This ensures we don't request calculated_price if currency_code is missing
+        const hasValidQueryContext = !!(queryContext.variants?.calculated_price);
+        console.log(`[DynamicFilterService] Has valid query context for calculated_price:`, hasValidQueryContext);
+        const fields = this.buildFields(projection?.fields, hasValidQueryContext);
+        console.log(`[DynamicFilterService] Fields built, includes calculated_price:`, fields.some(f => f.includes("calculated_price")));
+        const queryOptions = this.buildQueryOptions(queryFilters, fields, pagination, queryContext);
+        const result = await this.query.graph(queryOptions);
+        const { data: productsRaw = [], metadata } = result;
+        let products = this.normalizeProducts(productsRaw);
+        // Extract currency_code from pricing context for currency filtering
+        const currencyCode = pricingContext?.currency_code;
+        products = await this.applyPostQueryFilters(products, priceRangeFilter, promotionFilter, metadataFilter, currencyCode);
+        // Count should reflect filtered products, not initial query count
+        // If post-query filters were applied, use filtered products length
+        // Otherwise, use metadata count or products length
+        const hasPostQueryFilters = priceRangeFilter || promotionFilter || metadataFilter;
+        const count = hasPostQueryFilters
+            ? products.length
+            : await this.getCount(queryFilters, metadata, products.length);
+        return {
+            products,
+            count,
+            metadata: {
+                count,
+                skip: pagination?.offset,
+                take: pagination?.limit || (hasPostQueryFilters ? undefined : 20),
+            },
         };
-        // Start with empty filters object
+    }
+    resolveRegistry(container) {
+        try {
+            return container.resolve("filterProviderRegistry");
+        }
+        catch {
+            const registry = new filter_provider_registry_1.FilterProviderRegistry();
+            this.autoRegisterBuiltInProviders(registry);
+            return registry;
+        }
+    }
+    autoRegisterBuiltInProviders(registry) {
+        try {
+            const { registerBuiltInProviders } = require("../providers/filter-providers");
+            registerBuiltInProviders(registry);
+        }
+        catch (error) {
+            console.warn("[DynamicFilterService] Failed to auto-register built-in providers:", error);
+        }
+    }
+    async processFilters(filterParams, filterContext) {
         let queryFilters = {};
         let priceRangeFilter;
         let promotionFilter;
-        // Apply each filter using its provider
+        let metadataFilter;
         for (const [identifier, value] of Object.entries(filterParams)) {
-            // Skip undefined/null values
-            if (value === undefined || value === null) {
+            if (value == null)
                 continue;
-            }
             const provider = this.registry.get(identifier);
             if (!provider) {
-                // Log warning but don't fail - allow unknown filters to be ignored
-                // This enables custom providers to be added without breaking existing code
-                console.warn(`[DynamicFilterService] No filter provider found for identifier: "${identifier}". ` +
-                    `Filter will be ignored. Available providers: ${this.registry.getIdentifiers().join(", ")}`);
+                console.warn(`[DynamicFilterService] No filter provider found for: "${identifier}"`);
                 continue;
             }
             try {
-                // Validate if provider has validation method
-                if (provider.validate) {
-                    const validationResult = provider.validate(value);
-                    if (validationResult && Array.isArray(validationResult)) {
-                        // Provider returned validation errors
-                        const errors = validationResult
-                            .map((err) => `${err.path ? `${err.path}: ` : ""}${err.message}`)
-                            .join(", ");
-                        throw new Error(`Filter validation failed for "${identifier}": ${errors}`);
-                    }
-                    // If validate() throws, it will be caught below
-                }
-                // Apply filter
-                const result = provider.apply(queryFilters, value, filterContext);
-                queryFilters = await Promise.resolve(result);
-                // Extract price range filter for post-query filtering
-                // Price filtering requires post-query filtering because Medusa's query API
-                // doesn't support price range filtering directly
-                if (queryFilters.__price_range_filter__) {
+                this.validateWithProvider(provider, value);
+                const result = await Promise.resolve(provider.apply(queryFilters, value, filterContext));
+                queryFilters = result;
+                // Extract special filter keys, but preserve existing values if not set by this provider
+                // This ensures filters work independently - each filter can be applied alone or with others
+                if (queryFilters.__price_range_filter__ !== undefined) {
                     priceRangeFilter = queryFilters.__price_range_filter__;
-                    // Remove from queryFilters so it doesn't get passed to the query
-                    delete queryFilters.__price_range_filter__;
                 }
-                // Extract promotion filter for post-query filtering
-                // Promotion filtering requires querying Medusa's promotion module and
-                // matching products via promotion rules/targets, which can't be done directly
-                if (queryFilters.__promotion_filter__) {
+                if (queryFilters.__promotion_filter__ !== undefined) {
                     promotionFilter = queryFilters.__promotion_filter__;
-                    // Remove from queryFilters so it doesn't get passed to the query
-                    delete queryFilters.__promotion_filter__;
                 }
+                if (queryFilters.__metadata_filter__ !== undefined) {
+                    metadataFilter = queryFilters.__metadata_filter__;
+                }
+                delete queryFilters.__price_range_filter__;
+                delete queryFilters.__promotion_filter__;
+                delete queryFilters.__metadata_filter__;
             }
             catch (error) {
-                // Fail-fast: throw immediately on provider errors
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                throw new Error(`Error applying filter "${identifier}": ${errorMessage}`);
-            }
-        }
-        // Build query options for Query.graph()
-        // Only include filters if they're not empty
-        // Important: Check if fields array is empty or undefined, not just truthy
-        let fields = (projection?.fields && projection.fields.length > 0)
-            ? [...projection.fields]
-            : ["*"];
-        // Ensure essential relations are included to match Medusa's official format
-        // Even when using ["*"], we need to explicitly ensure relations are included
-        // Medusa's RemoteQuery may not automatically include nested relations with "*"
-        if (fields.includes("*")) {
-            // When using "*", explicitly add relations to ensure they're included
-            // This ensures variants, options, images, collection, and type are returned
-            fields = [
-                "*",
-                "variants.*",
-                "variants.prices.*",
-                "options.*",
-                "options.values.*",
-                "images.*",
-                "collection.*",
-                "type.*",
-            ];
+                throw new Error(`Error applying filter "${identifier}": ${error}`);
+            }
+        }
+        return { queryFilters, priceRangeFilter, promotionFilter, metadataFilter };
+    }
+    validateWithProvider(provider, value) {
+        if (provider.validate) {
+            const validationResult = provider.validate(value);
+            if (Array.isArray(validationResult)) {
+                const errors = validationResult.map(err => `${err.path ? `${err.path}: ` : ""}${err.message}`).join(", ");
+                throw new Error(errors);
+            }
+        }
+    }
+    buildFields(requestedFields, hasPricingContext) {
+        console.log(`[DynamicFilterService] buildFields called:`, {
+            hasPricingContext,
+            requestedFieldsCount: requestedFields?.length || 0
+        });
+        const essentialRelations = [
+            "variants.*", "variants.prices.*", // Always include all prices for multi-currency support
+            "options.*", "options.values.*",
+            "images.*", "collection.*", "type.*"
+        ];
+        // Include calculated_price ONLY if pricing context is available AND valid
+        // This is a critical check - we should never include calculated_price without currency_code
+        if (hasPricingContext) {
+            essentialRelations.push("variants.calculated_price.*");
+            console.log(`[DynamicFilterService] Added calculated_price.* to essential relations`);
+        }
+        else {
+            console.log(`[DynamicFilterService] NOT adding calculated_price.* (hasPricingContext=false)`);
+        }
+        if (!requestedFields?.length || requestedFields.includes("*")) {
+            const result = ["*", ...essentialRelations];
+            console.log(`[DynamicFilterService] Returning all fields with essential relations, includes calculated_price:`, result.some(f => f.includes("calculated_price")));
+            return result;
+        }
+        const fields = [...requestedFields];
+        const has = (prefix) => fields.some(f => f.startsWith(prefix));
+        if (!has("variants")) {
+            fields.push("variants.*", "variants.prices.*"); // Always include all prices
+            if (hasPricingContext) {
+                fields.push("variants.calculated_price.*");
+                console.log(`[DynamicFilterService] Added calculated_price.* to fields`);
+            }
         }
         else {
-            // If specific fields are requested, ensure essential relations are included
-            const hasVariants = fields.some(f => f.startsWith("variants"));
-            const hasOptions = fields.some(f => f.startsWith("options"));
-            const hasImages = fields.some(f => f.startsWith("images"));
-            const hasCollection = fields.includes("collection") || fields.some(f => f.startsWith("collection"));
-            const hasType = fields.includes("type") || fields.some(f => f.startsWith("type"));
-            // Add missing essential relations
-            if (!hasVariants) {
-                fields.push("variants.*", "variants.prices.*");
-            }
-            if (!hasOptions) {
-                fields.push("options.*", "options.values.*");
-            }
-            if (!hasImages)
-                fields.push("images.*");
-            if (!hasCollection)
-                fields.push("collection.*");
-            if (!hasType)
-                fields.push("type.*");
-        }
-        // Build query context for pricing (similar to Medusa's official route)
-        const queryContext = {};
-        // Add pricing context if available
-        if (context && typeof context === "object" && "pricingContext" in context) {
-            const pricingContext = context.pricingContext;
-            if (pricingContext) {
-                queryContext.variants = {
-                    calculated_price: (0, utils_1.QueryContext)(pricingContext),
+            // Even if variants are requested, ensure prices are included
+            if (!has("variants.prices")) {
+                fields.push("variants.prices.*");
+            }
+            // Check if calculated_price is already in requested fields
+            if (hasPricingContext && !has("variants.calculated_price")) {
+                fields.push("variants.calculated_price.*");
+                console.log(`[DynamicFilterService] Added calculated_price.* to fields (variants already present)`);
+            }
+        }
+        if (!has("options"))
+            fields.push("options.*", "options.values.*");
+        if (!has("images"))
+            fields.push("images.*");
+        if (!has("collection"))
+            fields.push("collection.*");
+        if (!has("type"))
+            fields.push("type.*");
+        const includesCalculatedPrice = fields.some(f => f.includes("calculated_price"));
+        console.log(`[DynamicFilterService] Final fields include calculated_price:`, includesCalculatedPrice);
+        return fields;
+    }
+    buildQueryContext(context) {
+        const pricingContext = context?.pricingContext;
+        // Only include calculated_price if currency_code is present and valid in pricing context
+        // Medusa's calculatePrices method requires currency_code to be a non-empty string
+        if (pricingContext) {
+            const currencyCode = pricingContext.currency_code;
+            if (typeof currencyCode === "string" && currencyCode.trim().length > 0) {
+                // Ensure currency_code is trimmed and set in the context we pass to Medusa
+                const validPricingContext = {
+                    ...pricingContext,
+                    currency_code: currencyCode.trim()
                 };
+                // Double-check currency_code is present before returning
+                if (validPricingContext.currency_code) {
+                    // Use QueryContext() helper to properly wrap the pricing context
+                    // This is required by Medusa's query.graph() for calculated_price
+                    const pricingContextForLogging = validPricingContext;
+                    console.log(`[DynamicFilterService] Wrapping pricing context with QueryContext():`, {
+                        currency_code: pricingContextForLogging.currency_code,
+                        region_id: pricingContextForLogging.region_id,
+                        allKeys: Object.keys(pricingContextForLogging)
+                    });
+                    const wrappedContext = (0, utils_1.QueryContext)(validPricingContext);
+                    console.log(`[DynamicFilterService] QueryContext() returned:`, {
+                        type: typeof wrappedContext,
+                        isFunction: typeof wrappedContext === "function",
+                        keys: typeof wrappedContext === "object" && wrappedContext !== null ? Object.keys(wrappedContext) : "N/A"
+                    });
+                    return {
+                        variants: {
+                            calculated_price: wrappedContext
+                        }
+                    };
+                }
+            }
+            else {
+                console.warn("[DynamicFilterService] Pricing context exists but currency_code is missing or invalid:", {
+                    hasPricingContext: !!pricingContext,
+                    currencyCodeType: typeof currencyCode,
+                    currencyCodeValue: currencyCode
+                });
             }
         }
-        const queryOptions = {
+        return {};
+    }
+    buildQueryOptions(filters, fields, pagination, queryContext) {
+        console.log(`[DynamicFilterService] buildQueryOptions called`);
+        // Note: QueryContext() wraps the pricing context, so we can't directly access currency_code
+        // from the wrapped object. We trust that buildQueryContext() already validated it.
+        // If queryContext has calculated_price, it means currency_code was validated before wrapping.
+        let safeQueryContext = queryContext;
+        if (queryContext?.variants?.calculated_price) {
+            // QueryContext() wraps the context, so we can't check currency_code here
+            // But we know it was validated in buildQueryContext() before wrapping
+            console.log(`[DynamicFilterService] Query context includes calculated_price (wrapped with QueryContext())`);
+        }
+        const options = {
             entity: "product",
             fields,
-            ...(Object.keys(queryFilters).length > 0 && { filters: queryFilters }),
-            ...(pagination && {
-                pagination: {
-                    ...(pagination.limit !== undefined && { take: pagination.limit }),
-                    ...(pagination.offset !== undefined && { skip: pagination.offset }),
-                },
-            }),
-            ...(Object.keys(queryContext).length > 0 && { context: queryContext }),
+            ...(Object.keys(filters).length > 0 && { filters }),
         };
-        // Debug: Log query structure when metadata filters are present
-        if (Object.keys(queryFilters).some((k) => k === "metadata")) {
-            console.log("[DynamicFilterService] Query filters:", JSON.stringify(queryFilters, null, 2));
-            console.log("[DynamicFilterService] Query fields:", fields);
-            console.log("[DynamicFilterService] Query context:", JSON.stringify(queryContext, null, 2));
-        }
-        // Execute query with pagination
-        // Note: query.graph() returns { data: Product[], metadata: { count, skip, take } }
-        const result = await this.query.graph(queryOptions);
-        // Extract products from result.data
-        // Following the pattern used in other Medusa routes (e.g., medusa-review-rating)
-        // query.graph() returns { data: Product[], metadata: { count, skip, take } }
-        const { data: productsRaw = [], metadata } = result;
-        // Ensure products is always an array and filter out null/undefined
-        let products = [];
-        if (Array.isArray(productsRaw)) {
-            products = productsRaw.filter((p) => p !== null && p !== undefined);
+        if (pagination) {
+            options.pagination = {};
+            // Ensure default limit if limit is 0 or undefined
+            if (pagination.limit !== undefined && pagination.limit > 0) {
+                options.pagination.take = pagination.limit;
+            }
+            else {
+                // Default limit when limit is 0 or undefined
+                options.pagination.take = 20;
+            }
+            if (pagination.offset !== undefined) {
+                options.pagination.skip = pagination.offset;
+            }
         }
         else {
-            // Log unexpected structure for debugging
-            console.warn("[DynamicFilterService] Unexpected data structure from query.graph():", {
-                dataType: typeof productsRaw,
-                isArray: Array.isArray(productsRaw),
-                hasData: !!productsRaw,
-                sample: productsRaw,
-            });
+            // If no pagination provided, set default
+            options.pagination = {
+                take: 20,
+                skip: 0
+            };
+        }
+        if (safeQueryContext && Object.keys(safeQueryContext).length > 0) {
+            options.context = safeQueryContext;
+            console.log(`[DynamicFilterService] Query options include context with calculated_price:`, !!safeQueryContext.variants?.calculated_price);
         }
-        // Post-query filtering for price range
-        // This is done after the query because Medusa's query API doesn't support
-        // price range filtering directly - we need to filter based on variant prices
-        if (priceRangeFilter && products.length > 0) {
-            products = products.filter((product) => {
-                // A product matches if at least one variant has a price within the range
-                if (!product.variants || !Array.isArray(product.variants) || product.variants.length === 0) {
+        else {
+            console.log(`[DynamicFilterService] Query options do not include context`);
+        }
+        console.log(`[DynamicFilterService] Final query options:`, {
+            entity: options.entity,
+            fieldsCount: options.fields?.length || 0,
+            hasContext: !!options.context,
+            hasCalculatedPrice: !!options.context?.variants?.calculated_price,
+            filtersCount: Object.keys(options.filters || {}).length
+        });
+        return options;
+    }
+    normalizeProducts(productsRaw) {
+        if (Array.isArray(productsRaw)) {
+            return productsRaw.filter(p => p != null);
+        }
+        console.warn("[DynamicFilterService] Unexpected data structure from query.graph()");
+        return [];
+    }
+    async applyPostQueryFilters(products, priceRangeFilter, promotionFilter, metadataFilter, currencyCode) {
+        let filteredProducts = products;
+        // Apply currency filter first - only include products available in the selected currency
+        if (currencyCode && filteredProducts.length > 0) {
+            console.log(`[DynamicFilterService] Applying currency filter: ${currencyCode} to ${filteredProducts.length} products`);
+            filteredProducts = this.filterByCurrency(filteredProducts, currencyCode);
+            console.log(`[DynamicFilterService] Filtered to ${filteredProducts.length} products available in ${currencyCode}`);
+        }
+        if (metadataFilter && filteredProducts.length > 0) {
+            filteredProducts = this.filterByMetadata(filteredProducts, metadataFilter);
+        }
+        if (priceRangeFilter && filteredProducts.length > 0) {
+            console.log(`[DynamicFilterService] Applying price range filter:`, priceRangeFilter, `to ${filteredProducts.length} products`);
+            filteredProducts = this.filterByPriceRange(filteredProducts, priceRangeFilter, currencyCode);
+            console.log(`[DynamicFilterService] Filtered to ${filteredProducts.length} products`);
+        }
+        if (promotionFilter && filteredProducts.length > 0) {
+            filteredProducts = await this.filterByPromotion(filteredProducts, promotionFilter);
+        }
+        return filteredProducts;
+    }
+    filterByMetadata(products, metadataFilter) {
+        return products.filter(product => {
+            const productMetadata = product.metadata || {};
+            // Check each metadata filter criteria
+            for (const [key, filterValue] of Object.entries(metadataFilter)) {
+                const productValue = productMetadata[key];
+                // If product doesn't have this metadata key, it doesn't match
+                if (productValue === undefined || productValue === null) {
                     return false;
                 }
-                // Check each variant to see if it has a price within the range
-                return product.variants.some((variant) => {
-                    // Try calculated_price first (if pricing context was provided)
-                    let price;
-                    let currencyCode;
-                    if (variant.calculated_price?.calculated_amount !== undefined) {
-                        price = variant.calculated_price.calculated_amount;
-                        currencyCode = variant.calculated_price.currency_code;
-                    }
-                    else if (variant.prices && Array.isArray(variant.prices) && variant.prices.length > 0) {
-                        // Fall back to first price in prices array
-                        const firstPrice = variant.prices[0];
-                        price = firstPrice.amount;
-                        currencyCode = firstPrice.currency_code;
+                // Handle array filter values (e.g., metadata[color]=["red","blue"])
+                if (Array.isArray(filterValue)) {
+                    // Product value should be in the filter array
+                    if (Array.isArray(productValue)) {
+                        // Both are arrays - check if any product value matches any filter value
+                        const matches = productValue.some((pv) => filterValue.some((fv) => this.metadataValuesMatch(pv, fv)));
+                        if (!matches)
+                            return false;
                     }
-                    // If no price found, exclude this variant
-                    if (price === undefined) {
-                        return false;
+                    else {
+                        // Product value is single, filter is array - check if product value matches any filter value
+                        const matches = filterValue.some((fv) => this.metadataValuesMatch(productValue, fv));
+                        if (!matches)
+                            return false;
                     }
-                    // If currency_code is specified in filter, check it matches
-                    if (priceRangeFilter.currency_code && currencyCode !== priceRangeFilter.currency_code) {
-                        return false;
+                }
+                else {
+                    // Single value filter
+                    if (Array.isArray(productValue)) {
+                        // Product value is array, filter is single - check if any product value matches filter
+                        const matches = productValue.some((pv) => this.metadataValuesMatch(pv, filterValue));
+                        if (!matches)
+                            return false;
                     }
-                    // Check if price is within range
-                    const min = priceRangeFilter.min;
-                    const max = priceRangeFilter.max;
-                    if (min !== undefined && price < min) {
-                        return false;
+                    else {
+                        // Both are single values - direct comparison
+                        if (!this.metadataValuesMatch(productValue, filterValue)) {
+                            return false;
+                        }
                     }
-                    if (max !== undefined && price > max) {
-                        return false;
+                }
+            }
+            return true;
+        });
+    }
+    metadataValuesMatch(productValue, filterValue) {
+        // Normalize string comparison (case-insensitive)
+        if (typeof productValue === "string" && typeof filterValue === "string") {
+            return productValue.toLowerCase() === filterValue.toLowerCase();
+        }
+        // Direct equality for numbers and booleans
+        return productValue === filterValue;
+    }
+    filterByPriceRange(products, priceRangeFilter, currencyCode) {
+        const { min, max } = priceRangeFilter;
+        // Use currency_code from filter, context, or parameter (priority: filter > parameter > context)
+        const targetCurrency = priceRangeFilter.currency_code || currencyCode;
+        console.log(`[DynamicFilterService] Filtering ${products.length} products by price range: min=${min}, max=${max}, currency=${targetCurrency}`);
+        const filtered = products.filter(product => {
+            if (!product.variants?.length)
+                return false;
+            return product.variants.some((variant) => {
+                // Get all prices for this variant
+                const prices = variant.prices || [];
+                // Find price matching the target currency
+                const matchingPrice = prices.find((price) => {
+                    if (!targetCurrency)
+                        return true; // If no currency specified, use first price
+                    return price.currency_code === targetCurrency;
+                });
+                // If no matching price found and currency is required, exclude this variant
+                if (targetCurrency && !matchingPrice) {
+                    return false;
+                }
+                // Use calculated_price if available (includes price list overrides)
+                let priceToUse;
+                let currencyToUse;
+                if (variant.calculated_price?.calculated_amount !== undefined) {
+                    // Only use calculated_price if it matches the target currency
+                    if (!targetCurrency || variant.calculated_price.currency_code === targetCurrency) {
+                        priceToUse = variant.calculated_price.calculated_amount;
+                        currencyToUse = variant.calculated_price.currency_code;
                     }
+                }
+                // Fall back to regular price if calculated_price not available or doesn't match
+                if (priceToUse === undefined && matchingPrice) {
+                    priceToUse = matchingPrice.amount;
+                    currencyToUse = matchingPrice.currency_code;
+                }
+                if (priceToUse === undefined)
+                    return false;
+                // Ensure currency matches if target currency is specified
+                if (targetCurrency && currencyToUse !== targetCurrency) {
+                    return false;
+                }
+                if (min !== undefined && priceToUse < min)
+                    return false;
+                if (max !== undefined && priceToUse > max)
+                    return false;
+                return true;
+            });
+        });
+        console.log(`[DynamicFilterService] Filtered ${products.length} products down to ${filtered.length} matching price range`);
+        return filtered;
+    }
+    filterByCurrency(products, currencyCode) {
+        console.log(`[DynamicFilterService] Filtering ${products.length} products by currency: ${currencyCode}`);
+        const filtered = products.filter(product => {
+            if (!product.variants?.length)
+                return false;
+            // Check if at least one variant has a price in the target currency
+            return product.variants.some((variant) => {
+                // Check calculated_price first (if available and matches currency)
+                if (variant.calculated_price?.currency_code === currencyCode) {
                     return true;
-                });
+                }
+                // Check regular prices
+                const prices = variant.prices || [];
+                return prices.some((price) => price.currency_code === currencyCode);
             });
-            // Update metadata count after filtering
-            if (metadata) {
-                metadata.count = products.length;
+        });
+        console.log(`[DynamicFilterService] Filtered ${products.length} products down to ${filtered.length} available in ${currencyCode}`);
+        return filtered;
+    }
+    getPriceInfo(variant) {
+        // Prioritize calculated_price if available (includes price list overrides when pricing context is provided)
+        if (variant.calculated_price?.calculated_amount !== undefined) {
+            return {
+                price: variant.calculated_price.calculated_amount,
+                currency: variant.calculated_price.currency_code
+            };
+        }
+        // Fall back to regular price if calculated_price is not available
+        if (variant.prices?.[0]) {
+            const price = variant.prices[0];
+            return {
+                price: price.amount,
+                currency: price.currency_code
+            };
+        }
+        return {};
+    }
+    async filterByPromotion(products, promotionFilter) {
+        try {
+            const promotions = await this.fetchPromotions(promotionFilter);
+            // Debug logging
+            console.log(`[DynamicFilterService] Found ${promotions.length} promotions matching filter`);
+            if (promotions.length === 0) {
+                console.warn("[DynamicFilterService] No promotions found - returning empty array");
+                return [];
+            }
+            const productPromotionData = await this.extractProductPromotionData(promotions);
+            // Debug logging
+            console.log(`[DynamicFilterService] Extracted ${productPromotionData.productIds.size} unique product IDs from promotions`);
+            console.log(`[DynamicFilterService] Found discounts for ${productPromotionData.discounts.size} products`);
+            console.log(`[DynamicFilterService] Has universal promotions (no rules): ${productPromotionData.hasUniversalPromotions}`);
+            if (productPromotionData.universalDiscount !== undefined) {
+                console.log(`[DynamicFilterService] Universal discount: ${productPromotionData.universalDiscount}%`);
             }
+            // Log discount filter criteria
+            if (promotionFilter.min_discount_percentage !== undefined || promotionFilter.max_discount_percentage !== undefined) {
+                console.log(`[DynamicFilterService] Filtering by discount: min=${promotionFilter.min_discount_percentage}, max=${promotionFilter.max_discount_percentage}`);
+            }
+            // Log sample discounts for debugging
+            if (productPromotionData.discounts.size > 0) {
+                const sampleDiscounts = Array.from(productPromotionData.discounts.entries()).slice(0, 5);
+                console.log(`[DynamicFilterService] Sample product discounts:`, sampleDiscounts.map(([id, discount]) => `${id.substring(0, 8)}...: ${discount}%`).join(", "));
+            }
+            // If we have universal promotions (no rules = applies to all products)
+            // or if we have product IDs, filter accordingly
+            const hasProductIds = productPromotionData.productIds.size > 0;
+            const hasUniversalPromotions = productPromotionData.hasUniversalPromotions;
+            if (!hasProductIds && !hasUniversalPromotions) {
+                console.warn("[DynamicFilterService] No product IDs found and no universal promotions - returning empty array");
+                return [];
+            }
+            const filtered = products.filter(product => {
+                const productId = product?.id;
+                if (!productId)
+                    return false;
+                // Determine if this product should be included based on promotion rules
+                let shouldInclude = false;
+                let discount;
+                if (hasProductIds) {
+                    // If promotion has product-specific rules, only include products in the promotion
+                    if (productPromotionData.productIds.has(productId)) {
+                        shouldInclude = true;
+                        // Get discount for this product (from specific promotion)
+                        // Don't default to 0 - if discount is undefined, the product should be excluded
+                        discount = productPromotionData.discounts.get(productId);
+                    }
+                }
+                else if (hasUniversalPromotions) {
+                    // If promotion is universal (no product-specific rules), it applies to all products
+                    // Use the universal discount - don't default to 0
+                    discount = productPromotionData.universalDiscount;
+                    shouldInclude = true;
+                }
+                // If product is not in any promotion, exclude it
+                if (!shouldInclude) {
+                    console.log(`[DynamicFilterService] Product ${productId} is not in any promotion`);
+                    return false;
+                }
+                // If product is in promotion but discount is undefined, exclude it
+                // This happens when discount calculation failed or promotion has no valid discount
+                if (discount === undefined) {
+                    console.log(`[DynamicFilterService] Product ${productId} is in promotion but has no valid discount - excluding`);
+                    return false;
+                }
+                // Check if discount meets the filter criteria
+                const meetsCriteria = this.meetsDiscountCriteria(discount, promotionFilter);
+                if (!meetsCriteria) {
+                    console.log(`[DynamicFilterService] Product ${productId} discount ${discount}% does not meet criteria (min: ${promotionFilter.min_discount_percentage}, max: ${promotionFilter.max_discount_percentage})`);
+                }
+                else {
+                    console.log(`[DynamicFilterService] Product ${productId} discount ${discount}% meets criteria (min: ${promotionFilter.min_discount_percentage}, max: ${promotionFilter.max_discount_percentage})`);
+                }
+                return meetsCriteria;
+            });
+            console.log(`[DynamicFilterService] Filtered ${products.length} products down to ${filtered.length} matching promotion criteria`);
+            return filtered;
         }
-        // Post-query filtering for promotions
-        // This is done after the query because promotion-product relationships
-        // are complex and require querying the promotion module
-        if (promotionFilter && products.length > 0) {
-            try {
-                // Query all promotions (we'll filter in memory)
-                // This ensures we don't miss promotions due to query filter limitations
-                const promotionQueryOptions = {
-                    entity: "promotion",
-                    fields: [
-                        "id",
-                        "code",
-                        "type",
-                        "application_method.*",
-                        "campaign.*",
-                        "rules.*",
-                        "rules.values.*",
-                        "starts_at",
-                        "ends_at",
-                        "status",
-                    ],
-                };
-                // Add basic filters if specified
-                const promotionQueryFilters = {};
-                if (promotionFilter.status) {
-                    promotionQueryFilters.status = promotionFilter.status;
-                }
-                if (promotionFilter.promotion_type) {
-                    promotionQueryFilters.type = promotionFilter.promotion_type;
-                }
-                if (Object.keys(promotionQueryFilters).length > 0) {
-                    promotionQueryOptions.filters = promotionQueryFilters;
-                }
-                const promotionResult = await this.query.graph(promotionQueryOptions);
-                let allPromotions = Array.isArray(promotionResult.data)
-                    ? promotionResult.data
-                    : [];
-                // Debug: Log all promotions found
-                console.log(`[DynamicFilterService] Found ${allPromotions.length} total promotions`);
-                // Filter promotions by date range in memory
-                const now = new Date();
-                const promotions = allPromotions.filter((promotion) => {
-                    // Filter by date range if specified
-                    if (promotionFilter.starts_at || promotionFilter.ends_at) {
-                        const startsAt = promotion.starts_at
-                            ? new Date(promotion.starts_at)
-                            : null;
-                        const endsAt = promotion.ends_at ? new Date(promotion.ends_at) : null;
-                        if (promotionFilter.starts_at) {
-                            const filterStart = new Date(promotionFilter.starts_at);
-                            if (endsAt && endsAt < filterStart) {
-                                return false; // Promotion ends before filter start
-                            }
+        catch (error) {
+            console.warn("[DynamicFilterService] Error filtering by promotions:", error);
+            return products;
+        }
+    }
+    async fetchPromotions(promotionFilter) {
+        const queryOptions = {
+            entity: "promotion",
+            fields: [
+                "id", "code", "type", "application_method.*", "application_method.target_rules.*",
+                "application_method.target_rules.values.*", "application_method.buy_rules.*",
+                "application_method.buy_rules.values.*", "campaign.*",
+                "rules.*", "rules.values.*", "starts_at", "ends_at", "status", "metadata"
+            ],
+        };
+        const filters = {};
+        // Status filter (default to active if not specified)
+        if (promotionFilter.status) {
+            filters.status = promotionFilter.status;
+        }
+        else {
+            // Default to active promotions
+            filters.status = "active";
+        }
+        if (promotionFilter.promotion_type) {
+            filters.type = promotionFilter.promotion_type;
+        }
+        if (Object.keys(filters).length > 0) {
+            queryOptions.filters = filters;
+        }
+        // Fetch all promotions matching status/type filters
+        // Date filtering will be done in code since Medusa query API
+        // may not support complex date range queries
+        const result = await this.query.graph(queryOptions);
+        let promotions = Array.isArray(result.data) ? result.data : [];
+        // Filter by date ranges in code
+        const now = new Date();
+        promotions = promotions.filter((promo) => {
+            // Check starts_at
+            if (promo.starts_at) {
+                const startsAt = new Date(promo.starts_at);
+                if (promotionFilter.starts_at) {
+                    // If specific starts_at filter provided, check if promotion starts at or before it
+                    const filterStartsAt = new Date(promotionFilter.starts_at);
+                    if (startsAt > filterStartsAt)
+                        return false;
+                }
+                else {
+                    // Default: only include promotions that have started
+                    if (startsAt > now)
+                        return false;
+                }
+            }
+            // Check ends_at
+            if (promo.ends_at) {
+                const endsAt = new Date(promo.ends_at);
+                if (promotionFilter.ends_at) {
+                    // If specific ends_at filter provided, check if promotion ends at or after it
+                    const filterEndsAt = new Date(promotionFilter.ends_at);
+                    if (endsAt < filterEndsAt)
+                        return false;
+                }
+                else {
+                    // Default: only include promotions that haven't ended yet
+                    if (endsAt < now)
+                        return false;
+                }
+            }
+            else {
+                // Open-ended promotion (no ends_at)
+                // Include if include_open_ended is true (default) or not explicitly false
+                if (promotionFilter.include_open_ended === false) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        return promotions;
+    }
+    async extractProductPromotionData(promotions) {
+        const productIds = new Set();
+        const discounts = new Map();
+        let hasUniversalPromotions = false;
+        let universalDiscount = undefined;
+        for (const promotion of promotions) {
+            const discount = this.calculateDiscountPercentage(promotion);
+            // Debug: Log full promotion structure for first promotion
+            if (promotions.indexOf(promotion) === 0) {
+                console.log(`[DynamicFilterService] Promotion structure:`, JSON.stringify({
+                    id: promotion.id,
+                    code: promotion.code,
+                    type: promotion.type,
+                    rules: promotion.rules,
+                    application_method: promotion.application_method,
+                    metadata: promotion.metadata
+                }, null, 2));
+            }
+            // Check if promotion has no rules (universal promotion - applies to all products)
+            const hasNoRules = !promotion.rules || promotion.rules.length === 0;
+            if (hasNoRules) {
+                console.log(`[DynamicFilterService] Promotion ${promotion.id || promotion.code} has no rules - applies to all products`);
+                hasUniversalPromotions = true;
+                // Only update universal discount if it's valid and greater than current
+                if (discount !== undefined) {
+                    if (universalDiscount === undefined || discount > universalDiscount) {
+                        universalDiscount = discount;
+                    }
+                }
+                else {
+                    console.warn(`[DynamicFilterService] Universal promotion ${promotion.id || promotion.code} has no valid discount - products will be excluded if filtering by discount`);
+                }
+            }
+            const ids = await this.extractProductIdsFromPromotion(promotion);
+            // Debug logging for first promotion
+            if (promotions.indexOf(promotion) === 0) {
+                console.log(`[DynamicFilterService] Promotion ${promotion.id || promotion.code}: discount=${discount}%, productIds=${ids.length}, universal=${hasNoRules}`);
+                if (ids.length > 0) {
+                    console.log(`[DynamicFilterService] Sample product IDs: ${ids.slice(0, 3).join(", ")}`);
+                }
+                else if (!hasNoRules) {
+                    console.warn(`[DynamicFilterService] No product IDs extracted from promotion ${promotion.id || promotion.code}`);
+                }
+            }
+            // If we found product IDs (from rules, target_rules, or buy_rules), this is NOT a universal promotion
+            // Only treat as universal if there are no rules AND no product IDs found
+            const isActuallyUniversal = hasNoRules && ids.length === 0;
+            if (isActuallyUniversal) {
+                // Universal promotion - applies to all products
+                console.log(`[DynamicFilterService] Promotion ${promotion.id || promotion.code} is universal (no rules, no product IDs)`);
+            }
+            else {
+                // Product-specific promotion - only apply to the specified products
+                ids.forEach(id => {
+                    productIds.add(id);
+                    // Only store discount if it's valid (not undefined)
+                    // When multiple promotions apply to the same product, use the maximum discount
+                    if (discount !== undefined) {
+                        const currentDiscount = discounts.get(id);
+                        if (currentDiscount === undefined) {
+                            discounts.set(id, discount);
                         }
-                        if (promotionFilter.ends_at) {
-                            const filterEnd = new Date(promotionFilter.ends_at);
-                            if (startsAt && startsAt > filterEnd) {
-                                return false; // Promotion starts after filter end
-                            }
+                        else {
+                            discounts.set(id, Math.max(currentDiscount, discount));
                         }
                     }
                     else {
-                        // Default: only include promotions active now
-                        const startsAt = promotion.starts_at
-                            ? new Date(promotion.starts_at)
-                            : null;
-                        const endsAt = promotion.ends_at ? new Date(promotion.ends_at) : null;
-                        if (startsAt && startsAt > now) {
-                            return false; // Promotion hasn't started yet
-                        }
-                        if (endsAt && endsAt < now) {
-                            return false; // Promotion has ended
-                        }
-                        // Include open-ended promotions if include_open_ended is true
-                        if (!endsAt &&
-                            promotionFilter.include_open_ended === false) {
-                            return false; // Exclude open-ended promotions
-                        }
+                        console.warn(`[DynamicFilterService] Promotion ${promotion.id || promotion.code} has product ${id} but discount is undefined - product will be excluded if filtering by discount`);
                     }
-                    return true;
                 });
-                // Debug: Log filtered promotions
-                console.log(`[DynamicFilterService] Found ${promotions.length} promotions after date filtering`);
-                if (promotions.length > 0) {
-                    console.log(`[DynamicFilterService] Sample promotion:`, JSON.stringify({
-                        id: promotions[0].id,
-                        code: promotions[0].code,
-                        type: promotions[0].type,
-                        application_method: promotions[0].application_method,
-                        rules_count: promotions[0].rules?.length || 0,
-                        rules: promotions[0].rules,
-                    }, null, 2));
-                }
-                // Initialize product tracking sets before we start processing
-                const productIdsWithPromotions = new Set();
-                const promotionDiscountMap = new Map(); // productId -> max discount percentage
-                // If promotions have no rules, try querying promotion rules separately
-                // In Medusa v2, rules might be stored as a separate entity or relationship
-                const promotionsWithoutRules = promotions.filter((p) => !p.rules || p.rules.length === 0);
-                if (promotionsWithoutRules.length > 0) {
-                    console.log(`[DynamicFilterService] Found ${promotionsWithoutRules.length} promotions without rules, querying rules separately`);
-                    for (const promotion of promotionsWithoutRules) {
-                        try {
-                            // Try querying promotion_rule entity
-                            const ruleQueryResult = await this.query.graph({
-                                entity: "promotion_rule",
-                                fields: ["id", "attribute", "values", "operator", "promotion_id"],
-                                filters: {
-                                    promotion_id: [promotion.id],
-                                },
-                            });
-                            const rules = Array.isArray(ruleQueryResult.data)
-                                ? ruleQueryResult.data
-                                : [];
-                            if (rules.length > 0) {
-                                console.log(`[DynamicFilterService] Found ${rules.length} rules for promotion ${promotion.id}:`, JSON.stringify(rules, null, 2));
-                                // Attach rules to promotion object
-                                promotion.rules = rules;
-                            }
-                            else {
-                                // Try querying with different entity names or structures
-                                console.log(`[DynamicFilterService] No promotion_rule found for ${promotion.id}, trying alternative queries`);
-                                // Try querying promotion_rule_value entity
-                                try {
-                                    const ruleValueQueryResult = await this.query.graph({
-                                        entity: "promotion_rule_value",
-                                        fields: ["id", "value", "promotion_rule_id"],
-                                        filters: {
-                                            promotion_rule: {
-                                                promotion_id: [promotion.id],
-                                            },
-                                        },
-                                    });
-                                    const ruleValues = Array.isArray(ruleValueQueryResult.data)
-                                        ? ruleValueQueryResult.data
-                                        : [];
-                                    if (ruleValues.length > 0) {
-                                        console.log(`[DynamicFilterService] Found ${ruleValues.length} rule values for promotion ${promotion.id}`);
-                                        // Extract product IDs from rule values
-                                        for (const ruleValue of ruleValues) {
-                                            if (ruleValue && typeof ruleValue === "object" && "value" in ruleValue) {
-                                                const value = ruleValue.value;
-                                                if (typeof value === "string") {
-                                                    // This might be a product ID
-                                                    productIdsWithPromotions.add(value);
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                                catch (error) {
-                                    console.log(`[DynamicFilterService] Could not query promotion_rule_value:`, error instanceof Error ? error.message : String(error));
-                                }
-                                // Try querying the promotion again with deeper expansion
-                                try {
-                                    const deepPromotionQuery = await this.query.graph({
-                                        entity: "promotion",
-                                        fields: [
-                                            "id",
-                                            "rules.*",
-                                            "rules.values.*",
-                                            "rules.batch_rules.*",
-                                            "rules.batch_rules.values.*",
-                                        ],
-                                        filters: {
-                                            id: [promotion.id],
-                                        },
-                                    });
-                                    const deepPromotions = Array.isArray(deepPromotionQuery.data)
-                                        ? deepPromotionQuery.data
-                                        : [];
-                                    if (deepPromotions.length > 0 && deepPromotions[0].rules) {
-                                        console.log(`[DynamicFilterService] Found rules with deep expansion:`, JSON.stringify(deepPromotions[0].rules, null, 2));
-                                        promotion.rules = deepPromotions[0].rules;
-                                    }
-                                }
-                                catch (error) {
-                                    console.log(`[DynamicFilterService] Could not query promotion with deep expansion:`, error instanceof Error ? error.message : String(error));
-                                }
-                            }
-                        }
-                        catch (error) {
-                            // Entity might not exist or have different name - that's okay
-                            console.log(`[DynamicFilterService] Could not query promotion_rule entity (this is normal if rules are embedded):`, error instanceof Error ? error.message : String(error));
-                        }
-                    }
+                // If we found product IDs, this is not a universal promotion
+                if (ids.length > 0) {
+                    hasUniversalPromotions = false;
                 }
-                // Extract product IDs from promotion rules/targets
-                // (productIdsWithPromotions and promotionDiscountMap are already declared above)
-                for (const promotion of promotions) {
-                    // Check if promotion is active now (if date range not specified)
-                    if (!promotionFilter.starts_at && !promotionFilter.ends_at) {
-                        const startsAt = promotion.starts_at
-                            ? new Date(promotion.starts_at)
-                            : null;
-                        const endsAt = promotion.ends_at ? new Date(promotion.ends_at) : null;
-                        const now = new Date();
-                        if (startsAt && startsAt > now) {
-                            continue; // Promotion hasn't started yet
-                        }
-                        if (endsAt && endsAt < now) {
-                            continue; // Promotion has ended
-                        }
-                    }
-                    // Calculate discount percentage based on application_method type
-                    // In Medusa, the discount type is stored in application_method.type, not promotion.type
-                    let discountPercentage;
-                    const applicationMethod = promotion.application_method;
-                    if (applicationMethod &&
-                        typeof applicationMethod === "object" &&
-                        "type" in applicationMethod) {
-                        const appMethodType = applicationMethod.type;
-                        if (appMethodType === "fixed" &&
-                            "target_type" in applicationMethod &&
-                            applicationMethod.target_type === "items") {
-                            // Fixed amount discount on items (amount_off_product)
-                            // Will calculate percentage per product later
-                            discountPercentage = undefined;
-                        }
-                        else if (appMethodType === "percentage" &&
-                            "target_type" in applicationMethod &&
-                            applicationMethod.target_type === "items") {
-                            // Percentage discount on items (percentage_off_product)
-                            if ("value" in applicationMethod) {
-                                discountPercentage =
-                                    typeof applicationMethod.value === "number"
-                                        ? applicationMethod.value
-                                        : Number(applicationMethod.value);
-                            }
-                        }
-                        else if (appMethodType === "percentage" &&
-                            "target_type" in applicationMethod &&
-                            applicationMethod.target_type === "order") {
-                            // Order-level percentage discount
-                            if ("value" in applicationMethod) {
-                                discountPercentage =
-                                    typeof applicationMethod.value === "number"
-                                        ? applicationMethod.value
-                                        : Number(applicationMethod.value);
-                            }
-                        }
-                        else if (appMethodType === "free_shipping") {
-                            // Free shipping - consider as 0% for product filtering
-                            discountPercentage = 0;
-                        }
-                    }
-                    // Fallback: Check promotion.type for backward compatibility
-                    if (discountPercentage === undefined && promotion.type) {
-                        if (promotion.type === "percentage_off_product") {
-                            if (applicationMethod &&
-                                typeof applicationMethod === "object" &&
-                                "value" in applicationMethod) {
-                                discountPercentage =
-                                    typeof applicationMethod.value === "number"
-                                        ? applicationMethod.value
-                                        : Number(applicationMethod.value);
-                            }
-                        }
-                        else if (promotion.type === "amount_off_product") {
-                            // Will calculate per product
-                            discountPercentage = undefined;
-                        }
-                        else if (promotion.type === "percentage_off_order") {
-                            if (applicationMethod &&
-                                typeof applicationMethod === "object" &&
-                                "value" in applicationMethod) {
-                                discountPercentage =
-                                    typeof applicationMethod.value === "number"
-                                        ? applicationMethod.value
-                                        : Number(applicationMethod.value);
-                            }
-                        }
-                    }
-                    // Extract product IDs from promotion rules
-                    // Promotions use rules to target products (e.g., items, product_id, product_ids, collection_ids, etc.)
-                    if (promotion.rules && Array.isArray(promotion.rules) && promotion.rules.length > 0) {
-                        for (const rule of promotion.rules) {
-                            // Check rule attribute - Medusa uses various attribute names
-                            // Common ones: "items", "product_id", "product_ids", "product_collection_id", etc.
-                            const ruleAttribute = rule.attribute;
-                            if (ruleAttribute === "items" ||
-                                ruleAttribute === "product_id" ||
-                                ruleAttribute === "product_ids") {
-                                // Direct product targeting
-                                const productIds = Array.isArray(rule.values)
-                                    ? rule.values
-                                    : rule.values
-                                        ? [rule.values]
-                                        : [];
-                                for (const productId of productIds) {
-                                    if (typeof productId === "string") {
-                                        productIdsWithPromotions.add(productId);
-                                        // Track maximum discount percentage for this product
-                                        if (discountPercentage !== undefined) {
-                                            const currentMax = promotionDiscountMap.get(productId) || 0;
-                                            promotionDiscountMap.set(productId, Math.max(currentMax, discountPercentage));
-                                        }
-                                    }
-                                }
-                            }
-                            else if (ruleAttribute === "product_collection_id" ||
-                                ruleAttribute === "product_collection_ids" ||
-                                ruleAttribute === "collection_id" ||
-                                ruleAttribute === "collection_ids") {
-                                // Collection-based targeting - we'll need to get products from collections
-                                // For now, we'll query products by collection_id
-                                const collectionIds = Array.isArray(rule.values)
-                                    ? rule.values
-                                    : rule.values
-                                        ? [rule.values]
-                                        : [];
-                                // Query products in these collections
-                                for (const collectionId of collectionIds) {
-                                    if (typeof collectionId === "string") {
-                                        const collectionProductsResult = await this.query.graph({
-                                            entity: "product",
-                                            fields: ["id"],
-                                            filters: {
-                                                collection_id: [collectionId],
-                                            },
-                                        });
-                                        const collectionProducts = Array.isArray(collectionProductsResult.data)
-                                            ? collectionProductsResult.data
-                                            : [];
-                                        for (const product of collectionProducts) {
-                                            if (product && typeof product === "object" && "id" in product) {
-                                                const productId = product.id;
-                                                productIdsWithPromotions.add(productId);
-                                                if (discountPercentage !== undefined) {
-                                                    const currentMax = promotionDiscountMap.get(productId) || 0;
-                                                    promotionDiscountMap.set(productId, Math.max(currentMax, discountPercentage));
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        // No rules found - if target_type is "items", the promotion might apply to all products
-                        // OR the products might be stored in a different way (e.g., join table, metadata, etc.)
-                        const applicationMethod = promotion.application_method;
-                        if (applicationMethod &&
-                            typeof applicationMethod === "object" &&
-                            "target_type" in applicationMethod &&
-                            applicationMethod.target_type === "items") {
-                            console.log(`[DynamicFilterService] Promotion ${promotion.id} targets items but has no rules`);
-                            // Try to find products associated with this promotion through alternative methods
-                            // Option 1: Check if products are stored in promotion metadata
-                            if (promotion.metadata && typeof promotion.metadata === "object") {
-                                const metadata = promotion.metadata;
-                                if (metadata.product_ids && Array.isArray(metadata.product_ids)) {
-                                    console.log(`[DynamicFilterService] Found product_ids in promotion metadata`);
-                                    const productIds = metadata.product_ids;
-                                    for (const productId of productIds) {
-                                        if (typeof productId === "string") {
-                                            productIdsWithPromotions.add(productId);
-                                            if (discountPercentage !== undefined) {
-                                                const currentMax = promotionDiscountMap.get(productId) || 0;
-                                                promotionDiscountMap.set(productId, Math.max(currentMax, discountPercentage));
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            // Option 2: If no rules and no metadata product_ids, 
-                            // and the promotion is active, we might need to include all products
-                            // BUT this is risky - only do it if explicitly configured
-                            // For now, we'll log and skip products for promotions without rules
-                            console.log(`[DynamicFilterService] Skipping products for promotion ${promotion.id} - no rules found and no product_ids in metadata`);
-                        }
+            }
+        }
+        return { productIds, discounts, hasUniversalPromotions, universalDiscount };
+    }
+    calculateDiscountPercentage(promotion) {
+        const appMethod = promotion.application_method;
+        if (!appMethod || typeof appMethod !== "object") {
+            console.log(`[DynamicFilterService] Promotion ${promotion.id || promotion.code}: No application_method`);
+            return undefined;
+        }
+        // Try to get discount from application_method.type === "percentage"
+        if (appMethod.type === "percentage" && "value" in appMethod) {
+            const value = typeof appMethod.value === "number" ? appMethod.value : Number(appMethod.value);
+            if (!Number.isNaN(value)) {
+                console.log(`[DynamicFilterService] Promotion ${promotion.id || promotion.code}: Found percentage discount ${value}% from application_method.type=percentage`);
+                return value;
+            }
+        }
+        // Try to get discount from promotion type
+        if (promotion.type === "percentage_off_product" || promotion.type === "percentage_off_order") {
+            if ("value" in appMethod) {
+                const value = typeof appMethod.value === "number" ? appMethod.value : Number(appMethod.value);
+                if (!Number.isNaN(value)) {
+                    console.log(`[DynamicFilterService] Promotion ${promotion.id || promotion.code}: Found percentage discount ${value}% from promotion.type=${promotion.type}`);
+                    return value;
+                }
+            }
+        }
+        console.log(`[DynamicFilterService] Promotion ${promotion.id || promotion.code}: Could not calculate discount percentage. type=${promotion.type}, appMethod.type=${appMethod.type}, appMethod.value=${appMethod.value}`);
+        return undefined;
+    }
+    extractIdsFromRuleValues(values) {
+        const ids = [];
+        if (!values)
+            return ids;
+        let valueArray = [];
+        if (Array.isArray(values)) {
+            valueArray = values;
+        }
+        else {
+            valueArray = [values];
+        }
+        for (const value of valueArray) {
+            if (typeof value === "string") {
+                if (value.length > 0) {
+                    ids.push(value);
+                }
+            }
+            else if (typeof value === "object" && value !== null) {
+                // Prioritize "value" property if it looks like a product ID (starts with "prod_")
+                // This handles Medusa v2 promotion rule values where product IDs are in the "value" field
+                if ("value" in value && typeof value.value === "string" && value.value.startsWith("prod_")) {
+                    ids.push(value.value);
+                }
+                else if ("product_id" in value && typeof value.product_id === "string") {
+                    ids.push(value.product_id);
+                }
+                else if ("id" in value && typeof value.id === "string") {
+                    // Only use "id" if it looks like a product ID, otherwise it might be a rule value ID
+                    if (value.id.startsWith("prod_")) {
+                        ids.push(value.id);
                     }
                 }
-                // Debug: Log product IDs found with promotions
-                console.log(`[DynamicFilterService] Found ${productIdsWithPromotions.size} products with promotions`);
-                // FALLBACK: If no products found but we have promotions targeting items without rules,
-                // include all products (this is a workaround for when rules aren't queryable)
-                if (productIdsWithPromotions.size === 0 && promotions.length > 0) {
-                    const itemsTargetingPromotions = promotions.filter((p) => {
-                        const appMethod = p.application_method;
-                        return (appMethod &&
-                            typeof appMethod === "object" &&
-                            "target_type" in appMethod &&
-                            appMethod.target_type === "items" &&
-                            (!p.rules || p.rules.length === 0));
-                    });
-                    if (itemsTargetingPromotions.length > 0) {
-                        console.log(`[DynamicFilterService] FALLBACK: Found ${itemsTargetingPromotions.length} promotions targeting items with no rules. ` +
-                            `Including all products as fallback (promotion rules may be stored in a way we can't query yet).`);
-                        // Include all current products and set their discount percentages
-                        for (const product of products) {
-                            if (product && typeof product === "object" && "id" in product) {
-                                const productId = product.id;
-                                productIdsWithPromotions.add(productId);
-                                // Calculate and set discount percentage for each promotion
-                                for (const promo of itemsTargetingPromotions) {
-                                    const appMethod = promo.application_method;
-                                    if (appMethod &&
-                                        typeof appMethod === "object" &&
-                                        "type" in appMethod &&
-                                        appMethod.type === "percentage" &&
-                                        "value" in appMethod) {
-                                        const discount = typeof appMethod.value === "number"
-                                            ? appMethod.value
-                                            : Number(appMethod.value);
-                                        if (!Number.isNaN(discount)) {
-                                            const currentMax = promotionDiscountMap.get(productId) || 0;
-                                            promotionDiscountMap.set(productId, Math.max(currentMax, discount));
-                                        }
-                                    }
-                                }
-                            }
+                else {
+                    // Try to extract any string field that looks like a product ID
+                    for (const [key, val] of Object.entries(value)) {
+                        if (typeof val === "string" && val.length > 0 && val.startsWith("prod_")) {
+                            ids.push(val);
+                            break; // Found product ID, no need to check other fields
                         }
-                        console.log(`[DynamicFilterService] FALLBACK applied: ${productIdsWithPromotions.size} products now included`);
                     }
                 }
-                if (productIdsWithPromotions.size > 0) {
-                    const sampleProductIds = Array.from(productIdsWithPromotions).slice(0, 5);
-                    console.log(`[DynamicFilterService] Sample product IDs with promotions:`, sampleProductIds);
+            }
+        }
+        return ids;
+    }
+    async extractProductIdsFromPromotion(promotion) {
+        const productIds = new Set();
+        // Check application_method.target_rules for product IDs (Medusa v2 stores product selections here)
+        // This is where products are stored when you select "items" in the promotion configuration
+        if (promotion.application_method?.target_rules?.length) {
+            console.log(`[DynamicFilterService] Processing ${promotion.application_method.target_rules.length} target_rules for promotion ${promotion.id || promotion.code}`);
+            for (const rule of promotion.application_method.target_rules) {
+                const ruleType = rule.attribute || rule.type || "";
+                const normalizedType = String(ruleType).toLowerCase();
+                console.log(`[DynamicFilterService] Target rule: attribute=${ruleType}, values=`, rule.values);
+                // Extract product IDs from target_rules
+                // Attribute can be "items", "items.product.id", "product", etc.
+                // If it contains "item" or "product", extract IDs from values
+                if (rule.values && (normalizedType.includes("item") || normalizedType.includes("product"))) {
+                    const extracted = this.extractIdsFromRuleValues(rule.values);
+                    extracted.forEach(id => productIds.add(id));
+                    console.log(`[DynamicFilterService] Extracted ${extracted.length} product IDs from target_rules (attribute: ${ruleType})`);
                 }
-                // Filter products to only include those with matching promotions
-                products = products.filter((product) => {
-                    const productId = product?.id;
-                    if (!productId || typeof productId !== "string") {
-                        return false;
-                    }
-                    // Check if product has a matching promotion
-                    if (!productIdsWithPromotions.has(productId)) {
-                        return false;
+                else if (rule.values) {
+                    // Even if attribute doesn't match, try extracting IDs anyway (might be product-related)
+                    const extracted = this.extractIdsFromRuleValues(rule.values);
+                    if (extracted.length > 0) {
+                        console.log(`[DynamicFilterService] Extracted ${extracted.length} product IDs from target_rules (unknown attribute: ${ruleType})`);
+                        extracted.forEach(id => productIds.add(id));
                     }
-                    // If min_discount_percentage is specified, check discount
-                    if (promotionFilter.min_discount_percentage !== undefined) {
-                        const productDiscount = promotionDiscountMap.get(productId);
-                        // For amount_off_product (fixed amount discount), calculate percentage from product price
-                        if (productDiscount === undefined && product.variants) {
-                            // Try to find promotion with fixed amount discount on items
-                            // and calculate percentage from product price
-                            const productPrice = product.variants?.[0]?.prices?.[0]?.amount;
-                            if (productPrice && typeof productPrice === "number") {
-                                // Find matching promotion with amount discount
-                                for (const promotion of promotions) {
-                                    const applicationMethod = promotion.application_method;
-                                    const isAmountDiscount = (applicationMethod &&
-                                        typeof applicationMethod === "object" &&
-                                        "type" in applicationMethod &&
-                                        applicationMethod.type === "fixed" &&
-                                        "target_type" in applicationMethod &&
-                                        applicationMethod.target_type === "items") ||
-                                        promotion.type === "amount_off_product";
-                                    if (isAmountDiscount) {
-                                        if (applicationMethod &&
-                                            typeof applicationMethod === "object" &&
-                                            "value" in applicationMethod) {
-                                            const discountAmount = typeof applicationMethod.value === "number"
-                                                ? applicationMethod.value
-                                                : Number(applicationMethod.value);
-                                            if (!Number.isNaN(discountAmount) && productPrice > 0) {
-                                                const calculatedPercentage = (discountAmount / productPrice) * 100;
-                                                const currentMax = promotionDiscountMap.get(productId) || 0;
-                                                promotionDiscountMap.set(productId, Math.max(currentMax, calculatedPercentage));
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        const finalDiscount = promotionDiscountMap.get(productId) || 0;
-                        // Check if discount meets minimum threshold
-                        if (finalDiscount < promotionFilter.min_discount_percentage) {
-                            return false;
-                        }
+                }
+            }
+        }
+        // Check application_method.buy_rules for product IDs (buy-x-get-y promotions)
+        if (promotion.application_method?.buy_rules?.length) {
+            console.log(`[DynamicFilterService] Processing ${promotion.application_method.buy_rules.length} buy_rules for promotion ${promotion.id || promotion.code}`);
+            for (const rule of promotion.application_method.buy_rules) {
+                const ruleType = rule.attribute || rule.type || "";
+                const normalizedType = String(ruleType).toLowerCase();
+                console.log(`[DynamicFilterService] Buy rule: attribute=${ruleType}, values=`, rule.values);
+                // Extract product IDs from buy_rules
+                // Attribute can be "items", "items.product.id", "product", etc.
+                if (rule.values && (normalizedType.includes("item") || normalizedType.includes("product"))) {
+                    const extracted = this.extractIdsFromRuleValues(rule.values);
+                    extracted.forEach(id => productIds.add(id));
+                    console.log(`[DynamicFilterService] Extracted ${extracted.length} product IDs from buy_rules`);
+                }
+                else if (rule.values) {
+                    // Even if attribute doesn't match, try extracting IDs anyway
+                    const extracted = this.extractIdsFromRuleValues(rule.values);
+                    if (extracted.length > 0) {
+                        extracted.forEach(id => productIds.add(id));
+                        console.log(`[DynamicFilterService] Extracted ${extracted.length} product IDs from buy_rules (unknown attribute: ${ruleType})`);
                     }
-                    return true;
-                });
-                // Update metadata count after filtering
-                if (metadata) {
-                    metadata.count = products.length;
                 }
             }
-            catch (error) {
-                // Log error but don't fail - return products without promotion filtering
-                console.warn("[DynamicFilterService] Error filtering by promotions:", error instanceof Error ? error.message : String(error));
+        }
+        // Debug: Log rule structure
+        if (promotion.rules?.length) {
+            console.log(`[DynamicFilterService] Processing ${promotion.rules.length} rules for promotion ${promotion.id || promotion.code}`);
+            for (const rule of promotion.rules) {
+                const ruleType = rule.type || rule.attribute || "";
+                const normalizedType = String(ruleType).toLowerCase();
+                console.log(`[DynamicFilterService] Rule: type=${ruleType}, attribute=${rule.attribute}, values=`, rule.values);
+                // Skip rules that definitely don't contain product IDs
+                if (normalizedType &&
+                    (normalizedType === "customer_groups" ||
+                        normalizedType === "regions" ||
+                        normalizedType === "currency" ||
+                        normalizedType === "customer_group" ||
+                        normalizedType === "region")) {
+                    console.log(`[DynamicFilterService] Skipping non-product rule: ${ruleType}`);
+                    continue;
+                }
+                // Process all other rules (including product-related ones)
+                // Extract product IDs from rule values
+                const extracted = this.extractIdsFromRuleValues(rule.values);
+                extracted.forEach(id => productIds.add(id));
+                console.log(`[DynamicFilterService] Extracted ${extracted.length} product IDs from rule ${ruleType}`);
+            }
+        }
+        else {
+            console.log(`[DynamicFilterService] No rules found in promotion ${promotion.id || promotion.code}`);
+        }
+        // Also check metadata for product IDs (fallback)
+        if (promotion.metadata?.product_ids?.length) {
+            console.log(`[DynamicFilterService] Found product IDs in metadata:`, promotion.metadata.product_ids);
+            promotion.metadata.product_ids.forEach((id) => {
+                if (typeof id === "string") {
+                    productIds.add(id);
+                }
+            });
+        }
+        const result = Array.from(productIds);
+        console.log(`[DynamicFilterService] Extracted ${result.length} product IDs:`, result);
+        return result;
+    }
+    meetsDiscountCriteria(discount, promotionFilter) {
+        // Validate discount is a valid number
+        if (typeof discount !== "number" || Number.isNaN(discount)) {
+            console.warn(`[DynamicFilterService] Invalid discount value: ${discount}`);
+            return false;
+        }
+        // Check minimum discount percentage
+        if (promotionFilter.min_discount_percentage !== undefined) {
+            const minDiscount = Number(promotionFilter.min_discount_percentage);
+            if (!Number.isNaN(minDiscount) && discount < minDiscount) {
+                return false;
+            }
+        }
+        // Check maximum discount percentage
+        if (promotionFilter.max_discount_percentage !== undefined) {
+            const maxDiscount = Number(promotionFilter.max_discount_percentage);
+            if (!Number.isNaN(maxDiscount) && discount > maxDiscount) {
+                return false;
             }
         }
-        // Get count from metadata if available, otherwise query separately
-        let count = metadata?.count;
-        if (count === undefined) {
-            // Query for count without pagination
-            const countQueryOptions = {
+        return true;
+    }
+    async getCount(queryFilters, metadata, productsLength) {
+        if (metadata?.count !== undefined)
+            return metadata.count;
+        try {
+            const countResult = await this.query.graph({
                 entity: "product",
                 fields: ["id"],
                 ...(Object.keys(queryFilters).length > 0 && { filters: queryFilters }),
-            };
-            const countResult = await this.query.graph(countQueryOptions);
-            // Extract count from result - following same pattern as main query
-            const { data: countData = [], metadata: countMetadata } = countResult;
-            if (countMetadata?.count !== undefined) {
-                count = countMetadata.count;
-            }
-            else if (Array.isArray(countData)) {
-                count = countData.length;
-            }
-            else {
-                // Fallback: use products array length if count query also fails
-                console.warn("[DynamicFilterService] Could not determine count from query result, using products array length");
-                count = products.length;
-            }
+            });
+            return countResult.metadata?.count ||
+                (Array.isArray(countResult.data) ? countResult.data.length : productsLength);
+        }
+        catch (error) {
+            console.warn("[DynamicFilterService] Could not determine count:", error);
+            return productsLength;
         }
-        return {
-            products,
-            count: typeof count === "number" ? count : products.length,
-            metadata: {
-                count: typeof count === "number" ? count : products.length,
-                skip: pagination?.offset,
-                take: pagination?.limit,
-            },
-        };
     }
 }
 exports.DynamicFilterService = DynamicFilterService;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-filter-service.js","sourceRoot":"","sources":["../../../../src/services/dynamic-filter-service.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-filter-service.js","sourceRoot":"","sources":["../../../../src/services/dynamic-filter-service.ts"],"names":[],"mappings":"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"}