medusa-product-helper 0.0.13 → 0.0.16

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

@@ -0,0 +1,814 @@
+"use strict";
+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.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,
+        };
+        // Start with empty filters object
+        let queryFilters = {};
+        let priceRangeFilter;
+        let promotionFilter;
+        // Apply each filter using its provider
+        for (const [identifier, value] of Object.entries(filterParams)) {
+            // Skip undefined/null values
+            if (value === undefined || 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(", ")}`);
+                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__) {
+                    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__) {
+                    promotionFilter = queryFilters.__promotion_filter__;
+                    // Remove from queryFilters so it doesn't get passed to the query
+                    delete queryFilters.__promotion_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.*",
+            ];
+        }
+        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),
+                };
+            }
+        }
+        const queryOptions = {
+            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 }),
+        };
+        // 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);
+        }
+        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,
+            });
+        }
+        // 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) {
+                    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;
+                    }
+                    // If no price found, exclude this variant
+                    if (price === undefined) {
+                        return false;
+                    }
+                    // If currency_code is specified in filter, check it matches
+                    if (priceRangeFilter.currency_code && currencyCode !== priceRangeFilter.currency_code) {
+                        return false;
+                    }
+                    // Check if price is within range
+                    const min = priceRangeFilter.min;
+                    const max = priceRangeFilter.max;
+                    if (min !== undefined && price < min) {
+                        return false;
+                    }
+                    if (max !== undefined && price > max) {
+                        return false;
+                    }
+                    return true;
+                });
+            });
+            // Update metadata count after filtering
+            if (metadata) {
+                metadata.count = products.length;
+            }
+        }
+        // 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
+                            }
+                        }
+                        if (promotionFilter.ends_at) {
+                            const filterEnd = new Date(promotionFilter.ends_at);
+                            if (startsAt && startsAt > filterEnd) {
+                                return false; // Promotion starts after filter end
+                            }
+                        }
+                    }
+                    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
+                        }
+                    }
+                    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));
+                        }
+                    }
+                }
+                // 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`);
+                        }
+                    }
+                }
+                // 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));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        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);
+                }
+                // 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;
+                    }
+                    // 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;
+                        }
+                    }
+                    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));
+            }
+        }
+        // Get count from metadata if available, otherwise query separately
+        let count = metadata?.count;
+        if (count === undefined) {
+            // Query for count without pagination
+            const countQueryOptions = {
+                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 {
+            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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"}