medusa-product-helper 0.0.13 → 0.0.16

package/.medusa/server/src/providers/filter-providers/promotion-window-provider.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromotionWindowFilterProvider = void 0;
+const base_filter_provider_1 = require("./base-filter-provider");
+/**
+ * Filter provider for filtering products by promotion window.
+ *
+ * Handles promotion date range filtering based on metadata keys
+ * configured in plugin options. Supports filtering by:
+ * - Promotion start/end dates
+ * - Active on a specific date
+ * - Including open-ended promotions
+ *
+ * @example
+ * ```ts
+ * { promotion_window: { start: "2024-01-01", end: "2024-12-31" } }
+ * ```
+ */
+class PromotionWindowFilterProvider extends base_filter_provider_1.BaseFilterProvider {
+    apply(filters, value, context) {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return filters;
+        }
+        const promotionWindow = value;
+        // Get metadata keys from options
+        const startKey = context?.options?.promotion_window?.start_metadata_key || "promotion_start";
+        const endKey = context?.options?.promotion_window?.end_metadata_key || "promotion_end";
+        const includeOpen = promotionWindow.includeOpen !== undefined
+            ? promotionWindow.includeOpen
+            : context?.options?.promotion_window?.treat_open_ended_as_active ?? true;
+        // Build metadata filter for promotion window
+        // Note: Medusa's RemoteQuery doesn't support MongoDB-style operators ($gte, $lte, $or)
+        // For date range filtering in metadata, we can only do exact matches or array matching
+        // Date range filtering will need to be handled via post-query filtering or a different approach
+        // For now, we'll store the promotion window criteria in the filter context
+        // and let the service layer handle date comparisons after fetching results
+        // This is a limitation of Medusa's query system for metadata date filtering
+        const metadataFilters = {};
+        if (promotionWindow.start || promotionWindow.end) {
+            // Store date range in metadata - exact match only (limitation)
+            // Actual date range filtering should be done post-query
+            if (promotionWindow.start) {
+                const startDate = promotionWindow.start instanceof Date
+                    ? promotionWindow.start
+                    : new Date(promotionWindow.start);
+                // Store as ISO string for exact matching
+                // Note: This only matches exact dates, not ranges
+                metadataFilters[startKey] = startDate.toISOString();
+            }
+            if (promotionWindow.end) {
+                const endDate = promotionWindow.end instanceof Date
+                    ? promotionWindow.end
+                    : new Date(promotionWindow.end);
+                // Store as ISO string for exact matching
+                metadataFilters[endKey] = endDate.toISOString();
+            }
+        }
+        else if (promotionWindow.activeOn) {
+            // Filter by active on specific date - exact match only
+            const activeDate = promotionWindow.activeOn instanceof Date
+                ? promotionWindow.activeOn
+                : new Date(promotionWindow.activeOn);
+            // Store active date for exact matching
+            // Note: Full date range logic requires post-query filtering
+            metadataFilters[startKey] = activeDate.toISOString();
+            if (!includeOpen) {
+                metadataFilters[endKey] = activeDate.toISOString();
+            }
+            // Note: Open-ended promotion logic requires post-query filtering
+        }
+        else {
+            // No promotion window filter
+            return filters;
+        }
+        // Log warning about date range filtering limitation
+        console.warn(`[PromotionWindowFilterProvider] Date range filtering in metadata is limited. ` +
+            `Only exact date matches are supported. For date ranges, consider post-query filtering.`);
+        // Merge with existing metadata filters
+        const existingMetadata = filters.metadata || {};
+        return {
+            ...filters,
+            metadata: {
+                ...existingMetadata,
+                ...metadataFilters,
+            },
+        };
+    }
+    validate(value) {
+        if (value === undefined || value === null) {
+            return;
+        }
+        if (typeof value !== "object" || Array.isArray(value)) {
+            throw new Error("promotion_window must be an object");
+        }
+        const promotionWindow = value;
+        if (promotionWindow.start !== undefined) {
+            if (!(promotionWindow.start instanceof Date) &&
+                typeof promotionWindow.start !== "string") {
+                throw new Error("promotion_window.start must be a Date or ISO string");
+            }
+        }
+        if (promotionWindow.end !== undefined) {
+            if (!(promotionWindow.end instanceof Date) &&
+                typeof promotionWindow.end !== "string") {
+                throw new Error("promotion_window.end must be a Date or ISO string");
+            }
+        }
+        if (promotionWindow.activeOn !== undefined) {
+            if (!(promotionWindow.activeOn instanceof Date) &&
+                typeof promotionWindow.activeOn !== "string") {
+                throw new Error("promotion_window.activeOn must be a Date or ISO string");
+            }
+        }
+        if (promotionWindow.includeOpen !== undefined) {
+            if (typeof promotionWindow.includeOpen !== "boolean") {
+                throw new Error("promotion_window.includeOpen must be a boolean");
+            }
+        }
+    }
+}
+exports.PromotionWindowFilterProvider = PromotionWindowFilterProvider;
+PromotionWindowFilterProvider.identifier = "promotion_window";
+PromotionWindowFilterProvider.displayName = "Promotion Window Filter";
+PromotionWindowFilterProvider.description = "Filters products by promotion date windows using metadata";
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/providers/filter-providers/rating-provider.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatingFilterProvider = void 0;
+const base_filter_provider_1 = require("./base-filter-provider");
+/**
+ * Filter provider for filtering products by rating.
+ *
+ * Handles rating filtering with min/max values. Only applies
+ * if rating is enabled in plugin options. Requires reviews
+ * if configured.
+ *
+ * @example
+ * ```ts
+ * { rating: { min: 4, max: 5, require_reviews: true } }
+ * ```
+ */
+class RatingFilterProvider extends base_filter_provider_1.BaseFilterProvider {
+    apply(filters, value, context) {
+        // Check if rating is enabled
+        if (!context?.options?.rating?.enabled) {
+            return filters;
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return filters;
+        }
+        const rating = value;
+        // Get defaults from options
+        const min = rating.min !== undefined
+            ? rating.min
+            : context.options.rating.min ?? 0;
+        const max = rating.max !== undefined
+            ? rating.max
+            : context.options.rating.max ?? 5;
+        const requireReviews = rating.require_reviews !== undefined
+            ? rating.require_reviews
+            : context.options.rating.require_reviews ?? false;
+        // Build rating filter
+        // Note: Medusa's RemoteQuery doesn't support comparison operators ($gt, $lt, etc.)
+        // We can only filter by exact values or use post-query filtering for ranges
+        // For rating range filtering, we need to:
+        // 1. Filter products that have reviews (if requireReviews is true)
+        // 2. Calculate average_rating post-query and filter by range
+        const ratingFilters = {};
+        if (requireReviews) {
+            // Filter products that have at least one review
+            // Since we can't use $gt, we'll filter for products with count > 0
+            // This is a limitation - exact filtering requires post-query processing
+            // For now, we'll skip this filter and handle it post-query
+            console.warn(`[RatingFilterProvider] Rating range filtering (min: ${min}, max: ${max}) ` +
+                `requires post-query filtering. Medusa's query system doesn't support comparison operators.`);
+        }
+        // Note: Rating range filtering (min/max) requires:
+        // 1. Fetching products with total_rating_count and total_rating_sum
+        // 2. Calculating average_rating = total_rating_sum / total_rating_count
+        // 3. Filtering results post-query by the calculated average
+        // Return filters unchanged - rating filtering will be handled post-query
+        // This is a known limitation of Medusa's query system
+        return filters;
+    }
+    validate(value) {
+        if (value === undefined || value === null) {
+            return;
+        }
+        if (typeof value !== "object" || Array.isArray(value)) {
+            throw new Error("rating must be an object with min and/or max");
+        }
+        const rating = value;
+        if (rating.min !== undefined) {
+            if (typeof rating.min !== "number" || rating.min < 0 || rating.min > 5) {
+                throw new Error("rating.min must be a number between 0 and 5");
+            }
+        }
+        if (rating.max !== undefined) {
+            if (typeof rating.max !== "number" || rating.max < 0 || rating.max > 5) {
+                throw new Error("rating.max must be a number between 0 and 5");
+            }
+        }
+        if (rating.min !== undefined && rating.max !== undefined && rating.min > rating.max) {
+            throw new Error("rating.min must be less than or equal to rating.max");
+        }
+        if (rating.require_reviews !== undefined) {
+            if (typeof rating.require_reviews !== "boolean") {
+                throw new Error("rating.require_reviews must be a boolean");
+            }
+        }
+    }
+}
+exports.RatingFilterProvider = RatingFilterProvider;
+RatingFilterProvider.identifier = "rating";
+RatingFilterProvider.displayName = "Rating Filter";
+RatingFilterProvider.description = "Filters products by rating (min/max)";
+//# sourceMappingURL=data:application/json;base64,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