medusa-product-helper 0.0.13 → 0.0.18

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

@@ -0,0 +1,525 @@
+"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");
+class DynamicFilterService {
+    constructor(container) {
+        this.registry = this.resolveRegistry(container);
+        this.query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    async applyFilters(options) {
+        const { filterParams, options: pluginOptions, pagination, projection, context = {} } = options;
+        const filterContext = { ...context, options: pluginOptions };
+        const { queryFilters, priceRangeFilter, promotionFilter } = await this.processFilters(filterParams, filterContext);
+        const fields = this.buildFields(projection?.fields);
+        const queryContext = this.buildQueryContext(context);
+        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);
+        products = await this.applyPostQueryFilters(products, priceRangeFilter, promotionFilter);
+        // 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;
+        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),
+            },
+        };
+    }
+    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;
+        for (const [identifier, value] of Object.entries(filterParams)) {
+            if (value == null)
+                continue;
+            const provider = this.registry.get(identifier);
+            if (!provider) {
+                console.warn(`[DynamicFilterService] No filter provider found for: "${identifier}"`);
+                continue;
+            }
+            try {
+                this.validateWithProvider(provider, value);
+                const result = await Promise.resolve(provider.apply(queryFilters, value, filterContext));
+                queryFilters = result;
+                priceRangeFilter = queryFilters.__price_range_filter__;
+                promotionFilter = queryFilters.__promotion_filter__;
+                delete queryFilters.__price_range_filter__;
+                delete queryFilters.__promotion_filter__;
+            }
+            catch (error) {
+                throw new Error(`Error applying filter "${identifier}": ${error}`);
+            }
+        }
+        return { queryFilters, priceRangeFilter, promotionFilter };
+    }
+    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) {
+        const essentialRelations = [
+            "variants.*", "variants.prices.*",
+            "options.*", "options.values.*",
+            "images.*", "collection.*", "type.*"
+        ];
+        if (!requestedFields?.length || requestedFields.includes("*")) {
+            return ["*", ...essentialRelations];
+        }
+        const fields = [...requestedFields];
+        const has = (prefix) => fields.some(f => f.startsWith(prefix));
+        if (!has("variants"))
+            fields.push("variants.*", "variants.prices.*");
+        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.*");
+        return fields;
+    }
+    buildQueryContext(context) {
+        if (context?.pricingContext) {
+            return { variants: { calculated_price: context.pricingContext } };
+        }
+        return {};
+    }
+    buildQueryOptions(filters, fields, pagination, queryContext) {
+        const options = {
+            entity: "product",
+            fields,
+            ...(Object.keys(filters).length > 0 && { filters }),
+        };
+        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 {
+            // If no pagination provided, set default
+            options.pagination = {
+                take: 20,
+                skip: 0
+            };
+        }
+        if (queryContext && Object.keys(queryContext).length > 0) {
+            options.context = queryContext;
+        }
+        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) {
+        let filteredProducts = products;
+        if (priceRangeFilter && filteredProducts.length > 0) {
+            filteredProducts = this.filterByPriceRange(filteredProducts, priceRangeFilter);
+        }
+        if (promotionFilter && filteredProducts.length > 0) {
+            filteredProducts = await this.filterByPromotion(filteredProducts, promotionFilter);
+        }
+        return filteredProducts;
+    }
+    filterByPriceRange(products, priceRangeFilter) {
+        return products.filter(product => {
+            if (!product.variants?.length)
+                return false;
+            return product.variants.some((variant) => {
+                const priceInfo = this.getPriceInfo(variant);
+                if (!priceInfo.price)
+                    return false;
+                if (priceRangeFilter.currency_code && priceInfo.currency !== priceRangeFilter.currency_code) {
+                    return false;
+                }
+                const { min, max } = priceRangeFilter;
+                if (min !== undefined && priceInfo.price < min)
+                    return false;
+                if (max !== undefined && priceInfo.price > max)
+                    return false;
+                return true;
+            });
+        });
+    }
+    getPriceInfo(variant) {
+        if (variant.calculated_price?.calculated_amount !== undefined) {
+            return {
+                price: variant.calculated_price.calculated_amount,
+                currency: variant.calculated_price.currency_code
+            };
+        }
+        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 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;
+                // If promotion has no rules (universal), it applies to all products
+                // Otherwise, check if product is in the promotion's product list
+                if (hasProductIds && !productPromotionData.productIds.has(productId)) {
+                    return false;
+                }
+                // Get discount for this product (from specific promotion or universal promotion)
+                let discount = productPromotionData.discounts.get(productId) || 0;
+                // If no specific discount found but we have universal promotions, use the universal discount
+                if (discount === 0 && hasUniversalPromotions) {
+                    // Use the discount from the first universal promotion
+                    discount = productPromotionData.universalDiscount || 0;
+                }
+                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})`);
+                }
+                return meetsCriteria;
+            });
+            console.log(`[DynamicFilterService] Filtered ${products.length} products down to ${filtered.length} matching promotion criteria`);
+            return filtered;
+        }
+        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.*", "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 = 0;
+        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;
+                if (discount !== undefined && discount > universalDiscount) {
+                    universalDiscount = 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}`);
+                }
+            }
+            // Only add product IDs if promotion has rules
+            // Universal promotions (no rules) apply to all products
+            if (!hasNoRules) {
+                ids.forEach(id => {
+                    productIds.add(id);
+                    if (discount !== undefined) {
+                        const currentMax = discounts.get(id) || 0;
+                        discounts.set(id, Math.max(currentMax, discount));
+                    }
+                });
+            }
+        }
+        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;
+    }
+    async extractProductIdsFromPromotion(promotion) {
+        const productIds = new Set();
+        // 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)
+                // In Medusa v2, rules.values can be:
+                // - An array of strings (product IDs)
+                // - An array of objects with id/value fields
+                // - A single value
+                let values = [];
+                if (Array.isArray(rule.values)) {
+                    values = rule.values;
+                }
+                else if (rule.values !== undefined && rule.values !== null) {
+                    values = [rule.values];
+                }
+                console.log(`[DynamicFilterService] Processing ${values.length} values from rule ${ruleType}`);
+                for (const value of values) {
+                    if (typeof value === "string") {
+                        // String values could be product IDs
+                        if (value.length > 0) {
+                            console.log(`[DynamicFilterService] Adding product ID from string: ${value}`);
+                            productIds.add(value);
+                        }
+                    }
+                    else if (typeof value === "object" && value !== null) {
+                        // Handle object values - could be { id: "prod_123" } or similar
+                        console.log(`[DynamicFilterService] Processing object value:`, value);
+                        if ("id" in value && typeof value.id === "string") {
+                            console.log(`[DynamicFilterService] Adding product ID from object.id: ${value.id}`);
+                            productIds.add(value.id);
+                        }
+                        else if ("value" in value && typeof value.value === "string") {
+                            console.log(`[DynamicFilterService] Adding product ID from object.value: ${value.value}`);
+                            productIds.add(value.value);
+                        }
+                        else if ("product_id" in value && typeof value.product_id === "string") {
+                            console.log(`[DynamicFilterService] Adding product ID from object.product_id: ${value.product_id}`);
+                            productIds.add(value.product_id);
+                        }
+                        else {
+                            // Try to extract any string field that looks like an ID
+                            for (const [key, val] of Object.entries(value)) {
+                                if (typeof val === "string" && val.length > 0 && (val.startsWith("prod_") || key.toLowerCase().includes("id"))) {
+                                    console.log(`[DynamicFilterService] Adding product ID from object.${key}: ${val}`);
+                                    productIds.add(val);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        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) {
+        if (promotionFilter.min_discount_percentage !== undefined &&
+            discount < promotionFilter.min_discount_percentage) {
+            return false;
+        }
+        if (promotionFilter.max_discount_percentage !== undefined &&
+            discount > promotionFilter.max_discount_percentage) {
+            return false;
+        }
+        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 }),
+            });
+            return countResult.metadata?.count ||
+                (Array.isArray(countResult.data) ? countResult.data.length : productsLength);
+        }
+        catch (error) {
+            console.warn("[DynamicFilterService] Could not determine count:", error);
+            return productsLength;
+        }
+    }
+}
+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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"}