@lodashventure/medusa-sales-analytics 1.0.0

package/.medusa/server/api/admin/sales/summary/route.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+const utils_1 = require("@medusajs/framework/utils");
+async function GET(req, res) {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    // Get all orders
+    const { data: orders } = await query.graph({
+        entity: "order",
+        fields: [
+            "id",
+            "status",
+            "total",
+            "subtotal",
+            "tax_total",
+            "discount_total",
+            "shipping_total",
+            "created_at",
+            "customer_id",
+            "items.*"
+        ]
+    });
+    // Get all products
+    const { data: products } = await query.graph({
+        entity: "product",
+        fields: [
+            "id",
+            "title",
+            "status",
+            "collection.*",
+            "categories.*",
+            "variants.*",
+            "variants.inventory_items.*"
+        ]
+    });
+    // Calculate date ranges
+    const now = new Date();
+    const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const yesterdayStart = new Date(todayStart);
+    yesterdayStart.setDate(yesterdayStart.getDate() - 1);
+    const weekStart = new Date(todayStart);
+    weekStart.setDate(weekStart.getDate() - 7);
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const lastMonthStart = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+    const lastMonthEnd = new Date(now.getFullYear(), now.getMonth(), 0);
+    // Filter completed orders
+    const completedOrders = orders.filter(order => ["completed", "partially_returned", "partially_shipped", "shipped", "fulfilled", "partially_fulfilled"].includes(order.status));
+    // Today's metrics
+    const todayOrders = completedOrders.filter(o => new Date(o.created_at) >= todayStart);
+    const todayRevenue = todayOrders.reduce((sum, o) => sum + (o.total || 0), 0);
+    // Yesterday's metrics
+    const yesterdayOrders = completedOrders.filter(o => {
+        const orderDate = new Date(o.created_at);
+        return orderDate >= yesterdayStart && orderDate < todayStart;
+    });
+    const yesterdayRevenue = yesterdayOrders.reduce((sum, o) => sum + (o.total || 0), 0);
+    // This week's metrics
+    const weekOrders = completedOrders.filter(o => new Date(o.created_at) >= weekStart);
+    const weekRevenue = weekOrders.reduce((sum, o) => sum + (o.total || 0), 0);
+    // This month's metrics
+    const monthOrders = completedOrders.filter(o => new Date(o.created_at) >= monthStart);
+    const monthRevenue = monthOrders.reduce((sum, o) => sum + (o.total || 0), 0);
+    // Last month's metrics
+    const lastMonthOrders = completedOrders.filter(o => {
+        const orderDate = new Date(o.created_at);
+        return orderDate >= lastMonthStart && orderDate <= lastMonthEnd;
+    });
+    const lastMonthRevenue = lastMonthOrders.reduce((sum, o) => sum + (o.total || 0), 0);
+    // All time metrics
+    const totalRevenue = completedOrders.reduce((sum, o) => sum + (o.total || 0), 0);
+    const totalOrders = completedOrders.length;
+    // Pending orders
+    const pendingOrders = orders.filter(o => ["pending", "requires_action", "processing"].includes(o.status));
+    // Low stock products
+    const lowStockProducts = products.filter(product => product.status === "published" &&
+        product.variants?.some((v) => {
+            const inventory = v.inventory_items?.[0]?.inventory ||
+                v.inventory_items?.[0];
+            const available = inventory?.available_quantity || 0;
+            return v.manage_inventory && available < 10;
+        }));
+    // Out of stock products
+    const outOfStockProducts = products.filter(product => product.status === "published" &&
+        product.variants?.every((v) => {
+            const inventory = v.inventory_items?.[0]?.inventory ||
+                v.inventory_items?.[0];
+            const available = inventory?.available_quantity || 0;
+            return v.manage_inventory && available === 0;
+        }));
+    // Best performing categories
+    const categoryPerformance = {};
+    completedOrders.forEach(order => {
+        order.items?.forEach((item) => {
+            const product = products.find(p => p.variants?.some((v) => v.id === item.variant_id));
+            product?.categories?.forEach((category) => {
+                if (!categoryPerformance[category.id]) {
+                    categoryPerformance[category.id] = {
+                        category_id: category.id,
+                        category_name: category.name,
+                        revenue: 0,
+                        quantity: 0
+                    };
+                }
+                categoryPerformance[category.id].revenue += item.subtotal || 0;
+                categoryPerformance[category.id].quantity += item.quantity || 0;
+            });
+        });
+    });
+    const topCategories = Object.values(categoryPerformance)
+        .sort((a, b) => b.revenue - a.revenue)
+        .slice(0, 5);
+    // Customer metrics
+    const uniqueCustomers = new Set(completedOrders.map(o => o.customer_id).filter(Boolean));
+    const newCustomersThisMonth = new Set(monthOrders.filter(o => {
+        const customerOrders = completedOrders.filter(co => co.customer_id === o.customer_id);
+        return customerOrders.length === 1;
+    }).map(o => o.customer_id));
+    res.json({
+        summary: {
+            today: {
+                revenue: todayRevenue,
+                orders: todayOrders.length,
+                average_order_value: todayOrders.length > 0 ? todayRevenue / todayOrders.length : 0,
+                vs_yesterday: {
+                    revenue_change: todayRevenue - yesterdayRevenue,
+                    revenue_change_percentage: yesterdayRevenue > 0
+                        ? ((todayRevenue - yesterdayRevenue) / yesterdayRevenue * 100).toFixed(2)
+                        : 0,
+                    orders_change: todayOrders.length - yesterdayOrders.length
+                }
+            },
+            week: {
+                revenue: weekRevenue,
+                orders: weekOrders.length,
+                average_order_value: weekOrders.length > 0 ? weekRevenue / weekOrders.length : 0,
+                daily_average: weekRevenue / 7
+            },
+            month: {
+                revenue: monthRevenue,
+                orders: monthOrders.length,
+                average_order_value: monthOrders.length > 0 ? monthRevenue / monthOrders.length : 0,
+                vs_last_month: {
+                    revenue_change: monthRevenue - lastMonthRevenue,
+                    revenue_change_percentage: lastMonthRevenue > 0
+                        ? ((monthRevenue - lastMonthRevenue) / lastMonthRevenue * 100).toFixed(2)
+                        : 0,
+                    orders_change: monthOrders.length - lastMonthOrders.length
+                }
+            },
+            all_time: {
+                revenue: totalRevenue,
+                orders: totalOrders,
+                average_order_value: totalOrders > 0 ? totalRevenue / totalOrders : 0,
+                total_customers: uniqueCustomers.size
+            },
+            pending: {
+                orders_count: pendingOrders.length,
+                orders_value: pendingOrders.reduce((sum, o) => sum + (o.total || 0), 0)
+            },
+            inventory: {
+                low_stock_products: lowStockProducts.length,
+                out_of_stock_products: outOfStockProducts.length,
+                total_products: products.filter(p => p.status === "published").length
+            },
+            customers: {
+                total: uniqueCustomers.size,
+                new_this_month: newCustomersThisMonth.size,
+                average_lifetime_value: uniqueCustomers.size > 0
+                    ? totalRevenue / uniqueCustomers.size
+                    : 0
+            },
+            top_categories: topCategories
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route.js","sourceRoot":"","sources":["../../../../../../src/api/admin/sales/summary/route.ts"],"names":[],"mappings":"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"}

package/.medusa/server/api/middlewares/add-product-filters.d.ts

@@ -0,0 +1,7 @@
+import type { MedusaRequest, MedusaResponse, MedusaNextFunction } from "@medusajs/framework/http";
+export declare function captureFilterParams(req: MedusaRequest, res: MedusaResponse, next: MedusaNextFunction): Promise<void>;
+/**
+ * This is a post-processing middleware that filters after all other middlewares
+ * It should be registered LAST in the middleware chain
+ */
+export declare function applyProductFilters(req: MedusaRequest, res: MedusaResponse, next: MedusaNextFunction): Promise<void>;

package/.medusa/server/api/middlewares/add-product-filters.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureFilterParams = captureFilterParams;
+exports.applyProductFilters = applyProductFilters;
+/**
+ * Middleware to add advanced filtering for products
+ * Supports: price_min, price_max, rating_min, rating_max, ready_to_ship
+ *
+ * Query parameters:
+ * - price_min: Minimum price in cents (e.g., 10000 = ฿100)
+ * - price_max: Maximum price in cents
+ * - rating_min: Minimum average rating (1-5)
+ * - rating_max: Maximum average rating (1-5)
+ * - ready_to_ship: Filter products with stock (true/false or 1/0)
+ *
+ * Note: This middleware runs AFTER stock availability and review aggregates middlewares
+ * to ensure stock and rating data are available for filtering
+ */
+// Store filter params in request object to avoid Medusa validation errors
+const FILTER_PARAMS_KEY = Symbol("productFilters");
+async function captureFilterParams(req, res, next) {
+    // Extract our custom filter parameters
+    const query = req.query;
+    const filterParams = {
+        priceMin: query.price_min ? parseFloat(query.price_min) : null,
+        priceMax: query.price_max ? parseFloat(query.price_max) : null,
+        ratingMin: query.rating_min ? parseFloat(query.rating_min) : null,
+        ratingMax: query.rating_max ? parseFloat(query.rating_max) : null,
+        readyToShip: parseReadyToShip(query.ready_to_ship),
+    };
+    // Store in request object
+    req[FILTER_PARAMS_KEY] = filterParams;
+    // Remove from query to prevent Medusa validation errors
+    delete req.query.price_min;
+    delete req.query.price_max;
+    delete req.query.rating_min;
+    delete req.query.rating_max;
+    delete req.query.ready_to_ship;
+    next();
+}
+/**
+ * This is a post-processing middleware that filters after all other middlewares
+ * It should be registered LAST in the middleware chain
+ */
+async function applyProductFilters(req, res, next) {
+    try {
+        const originalJson = res.json.bind(res);
+        res.json = async function (data) {
+            try {
+                // Only process product list responses
+                if (data?.products && Array.isArray(data.products)) {
+                    const filterParams = req[FILTER_PARAMS_KEY];
+                    if (filterParams) {
+                        const { products, count } = filterProducts(filterParams, data.products, data.count);
+                        data.products = products;
+                        data.count = count;
+                    }
+                }
+            }
+            catch (error) {
+                console.error("Error applying product filters:", error);
+                // Continue with original data on error
+            }
+            return originalJson(data);
+        };
+        next();
+    }
+    catch (middlewareError) {
+        console.error("Error in applyProductFilters middleware:", middlewareError);
+        next(middlewareError);
+    }
+}
+/**
+ * Filter products based on stored filter parameters
+ */
+function filterProducts(filterParams, products, originalCount) {
+    const { priceMin, priceMax, ratingMin, ratingMax, readyToShip } = filterParams;
+    // If no filters, return original
+    if (!priceMin &&
+        !priceMax &&
+        !ratingMin &&
+        !ratingMax &&
+        readyToShip === null) {
+        return { products, count: originalCount };
+    }
+    // Filter products
+    const filtered = products.filter((product) => {
+        // Price filtering
+        if (priceMin !== null || priceMax !== null) {
+            const productPrice = getProductPrice(product);
+            if (productPrice === null) {
+                return false;
+            }
+            if (priceMin !== null && productPrice < priceMin) {
+                return false;
+            }
+            if (priceMax !== null && productPrice > priceMax) {
+                return false;
+            }
+        }
+        // Rating filtering
+        if (ratingMin !== null || ratingMax !== null) {
+            const productRating = product.review_aggregate?.average_rating ?? 0;
+            if (ratingMin !== null && productRating < ratingMin) {
+                return false;
+            }
+            if (ratingMax !== null && productRating > ratingMax) {
+                return false;
+            }
+            if ((ratingMin !== null || ratingMax !== null) && productRating === 0) {
+                return false;
+            }
+        }
+        // Ready to ship filtering
+        if (readyToShip !== null) {
+            const stockStatus = product.stock_availability?.status;
+            const isInStock = stockStatus === "InStock";
+            if (readyToShip === true && !isInStock) {
+                return false;
+            }
+            if (readyToShip === false && isInStock) {
+                return false;
+            }
+        }
+        return true;
+    });
+    return {
+        products: filtered,
+        count: filtered.length,
+    };
+}
+/**
+ * Parse ready_to_ship parameter
+ */
+function parseReadyToShip(value) {
+    if (!value)
+        return null;
+    const normalized = value.toLowerCase().trim();
+    if (normalized === "true" || normalized === "1") {
+        return true;
+    }
+    if (normalized === "false" || normalized === "0") {
+        return false;
+    }
+    return null;
+}
+/**
+ * Get the minimum price from product variants
+ */
+function getProductPrice(product) {
+    if (!product.variants || product.variants.length === 0) {
+        return null;
+    }
+    const prices = product.variants
+        .map((variant) => {
+        if (variant.calculated_price?.calculated_amount) {
+            return parseFloat(variant.calculated_price.calculated_amount);
+        }
+        if (variant.calculated_price?.original_amount) {
+            return parseFloat(variant.calculated_price.original_amount);
+        }
+        if (variant.price) {
+            return parseFloat(variant.price);
+        }
+        return null;
+    })
+        .filter((price) => price !== null && !isNaN(price));
+    if (prices.length === 0) {
+        return null;
+    }
+    return Math.min(...prices);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRkLXByb2R1Y3QtZmlsdGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcGkvbWlkZGxld2FyZXMvYWRkLXByb2R1Y3QtZmlsdGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQXdCQSxrREEwQkM7QUFNRCxrREFvQ0M7QUF0RkQ7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUVILDBFQUEwRTtBQUMxRSxNQUFNLGlCQUFpQixHQUFHLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0FBRTVDLEtBQUssVUFBVSxtQkFBbUIsQ0FDdkMsR0FBa0IsRUFDbEIsR0FBbUIsRUFDbkIsSUFBd0I7SUFFeEIsdUNBQXVDO0lBQ3ZDLE1BQU0sS0FBSyxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUM7SUFDeEIsTUFBTSxZQUFZLEdBQUc7UUFDbkIsUUFBUSxFQUFFLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsU0FBbUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJO1FBQ3hFLFFBQVEsRUFBRSxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLFNBQW1CLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSTtRQUN4RSxTQUFTLEVBQUUsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxVQUFvQixDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUk7UUFDM0UsU0FBUyxFQUFFLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsVUFBb0IsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJO1FBQzNFLFdBQVcsRUFBRSxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsYUFBdUIsQ0FBQztLQUM3RCxDQUFDO0lBRUYsMEJBQTBCO0lBQ3pCLEdBQVcsQ0FBQyxpQkFBaUIsQ0FBQyxHQUFHLFlBQVksQ0FBQztJQUUvQyx3REFBd0Q7SUFDeEQsT0FBTyxHQUFHLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQztJQUMzQixPQUFPLEdBQUcsQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDO0lBQzNCLE9BQU8sR0FBRyxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUM7SUFDNUIsT0FBTyxHQUFHLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQztJQUM1QixPQUFPLEdBQUcsQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDO0lBRS9CLElBQUksRUFBRSxDQUFDO0FBQ1QsQ0FBQztBQUVEOzs7R0FHRztBQUNJLEtBQUssVUFBVSxtQkFBbUIsQ0FDdkMsR0FBa0IsRUFDbEIsR0FBbUIsRUFDbkIsSUFBd0I7SUFFeEIsSUFBSSxDQUFDO1FBQ0gsTUFBTSxZQUFZLEdBQUcsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7UUFFdkMsR0FBVyxDQUFDLElBQUksR0FBRyxLQUFLLFdBQVcsSUFBUztZQUMzQyxJQUFJLENBQUM7Z0JBQ0gsc0NBQXNDO2dCQUN0QyxJQUFJLElBQUksRUFBRSxRQUFRLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztvQkFDbkQsTUFBTSxZQUFZLEdBQUksR0FBVyxDQUFDLGlCQUFpQixDQUFDLENBQUM7b0JBQ3JELElBQUksWUFBWSxFQUFFLENBQUM7d0JBQ2pCLE1BQU0sRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLEdBQUcsY0FBYyxDQUN4QyxZQUFZLEVBQ1osSUFBSSxDQUFDLFFBQVEsRUFDYixJQUFJLENBQUMsS0FBSyxDQUNYLENBQUM7d0JBQ0YsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7d0JBQ3pCLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO29CQUNyQixDQUFDO2dCQUNILENBQUM7WUFDSCxDQUFDO1lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztnQkFDZixPQUFPLENBQUMsS0FBSyxDQUFDLGlDQUFpQyxFQUFFLEtBQUssQ0FBQyxDQUFDO2dCQUN4RCx1Q0FBdUM7WUFDekMsQ0FBQztZQUVELE9BQU8sWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQzVCLENBQUMsQ0FBQztRQUVGLElBQUksRUFBRSxDQUFDO0lBQ1QsQ0FBQztJQUFDLE9BQU8sZUFBZSxFQUFFLENBQUM7UUFDekIsT0FBTyxDQUFDLEtBQUssQ0FBQywwQ0FBMEMsRUFBRSxlQUFlLENBQUMsQ0FBQztRQUMzRSxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7SUFDeEIsQ0FBQztBQUNILENBQUM7QUFFRDs7R0FFRztBQUNILFNBQVMsY0FBYyxDQUNyQixZQUFpQixFQUNqQixRQUFlLEVBQ2YsYUFBcUI7SUFFckIsTUFBTSxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsR0FDN0QsWUFBWSxDQUFDO0lBRWYsaUNBQWlDO0lBQ2pDLElBQ0UsQ0FBQyxRQUFRO1FBQ1QsQ0FBQyxRQUFRO1FBQ1QsQ0FBQyxTQUFTO1FBQ1YsQ0FBQyxTQUFTO1FBQ1YsV0FBVyxLQUFLLElBQUksRUFDcEIsQ0FBQztRQUNELE9BQU8sRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLGFBQWEsRUFBRSxDQUFDO0lBQzVDLENBQUM7SUFFRCxrQkFBa0I7SUFDbEIsTUFBTSxRQUFRLEdBQUcsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFO1FBQzNDLGtCQUFrQjtRQUNsQixJQUFJLFFBQVEsS0FBSyxJQUFJLElBQUksUUFBUSxLQUFLLElBQUksRUFBRSxDQUFDO1lBQzNDLE1BQU0sWUFBWSxHQUFHLGVBQWUsQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUU5QyxJQUFJLFlBQVksS0FBSyxJQUFJLEVBQUUsQ0FBQztnQkFDMUIsT0FBTyxLQUFLLENBQUM7WUFDZixDQUFDO1lBRUQsSUFBSSxRQUFRLEtBQUssSUFBSSxJQUFJLFlBQVksR0FBRyxRQUFRLEVBQUUsQ0FBQztnQkFDakQsT0FBTyxLQUFLLENBQUM7WUFDZixDQUFDO1lBRUQsSUFBSSxRQUFRLEtBQUssSUFBSSxJQUFJLFlBQVksR0FBRyxRQUFRLEVBQUUsQ0FBQztnQkFDakQsT0FBTyxLQUFLLENBQUM7WUFDZixDQUFDO1FBQ0gsQ0FBQztRQUVELG1CQUFtQjtRQUNuQixJQUFJLFNBQVMsS0FBSyxJQUFJLElBQUksU0FBUyxLQUFLLElBQUksRUFBRSxDQUFDO1lBQzdDLE1BQU0sYUFBYSxHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsRUFBRSxjQUFjLElBQUksQ0FBQyxDQUFDO1lBRXBFLElBQUksU0FBUyxLQUFLLElBQUksSUFBSSxhQUFhLEdBQUcsU0FBUyxFQUFFLENBQUM7Z0JBQ3BELE9BQU8sS0FBSyxDQUFDO1lBQ2YsQ0FBQztZQUVELElBQUksU0FBUyxLQUFLLElBQUksSUFBSSxhQUFhLEdBQUcsU0FBUyxFQUFFLENBQUM7Z0JBQ3BELE9BQU8sS0FBSyxDQUFDO1lBQ2YsQ0FBQztZQUVELElBQUksQ0FBQyxTQUFTLEtBQUssSUFBSSxJQUFJLFNBQVMsS0FBSyxJQUFJLENBQUMsSUFBSSxhQUFhLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ3RFLE9BQU8sS0FBSyxDQUFDO1lBQ2YsQ0FBQztRQUNILENBQUM7UUFFRCwwQkFBMEI7UUFDMUIsSUFBSSxXQUFXLEtBQUssSUFBSSxFQUFFLENBQUM7WUFDekIsTUFBTSxXQUFXLEdBQUcsT0FBTyxDQUFDLGtCQUFrQixFQUFFLE1BQU0sQ0FBQztZQUN2RCxNQUFNLFNBQVMsR0FBRyxXQUFXLEtBQUssU0FBUyxDQUFDO1lBRTVDLElBQUksV0FBVyxLQUFLLElBQUksSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO2dCQUN2QyxPQUFPLEtBQUssQ0FBQztZQUNmLENBQUM7WUFFRCxJQUFJLFdBQVcsS0FBSyxLQUFLLElBQUksU0FBUyxFQUFFLENBQUM7Z0JBQ3ZDLE9BQU8sS0FBSyxDQUFDO1lBQ2YsQ0FBQztRQUNILENBQUM7UUFFRCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUMsQ0FBQyxDQUFDO0lBRUgsT0FBTztRQUNMLFFBQVEsRUFBRSxRQUFRO1FBQ2xCLEtBQUssRUFBRSxRQUFRLENBQUMsTUFBTTtLQUN2QixDQUFDO0FBQ0osQ0FBQztBQUVEOztHQUVHO0FBQ0gsU0FBUyxnQkFBZ0IsQ0FBQyxLQUF5QjtJQUNqRCxJQUFJLENBQUMsS0FBSztRQUFFLE9BQU8sSUFBSSxDQUFDO0lBRXhCLE1BQU0sVUFBVSxHQUFHLEtBQUssQ0FBQyxXQUFXLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUU5QyxJQUFJLFVBQVUsS0FBSyxNQUFNLElBQUksVUFBVSxLQUFLLEdBQUcsRUFBRSxDQUFDO1FBQ2hELE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVELElBQUksVUFBVSxLQUFLLE9BQU8sSUFBSSxVQUFVLEtBQUssR0FBRyxFQUFFLENBQUM7UUFDakQsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxTQUFTLGVBQWUsQ0FBQyxPQUFZO0lBQ25DLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3ZELE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVELE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxRQUFRO1NBQzVCLEdBQUcsQ0FBQyxDQUFDLE9BQVksRUFBRSxFQUFFO1FBQ3BCLElBQUksT0FBTyxDQUFDLGdCQUFnQixFQUFFLGlCQUFpQixFQUFFLENBQUM7WUFDaEQsT0FBTyxVQUFVLENBQUMsT0FBTyxDQUFDLGdCQUFnQixDQUFDLGlCQUFpQixDQUFDLENBQUM7UUFDaEUsQ0FBQztRQUNELElBQUksT0FBTyxDQUFDLGdCQUFnQixFQUFFLGVBQWUsRUFBRSxDQUFDO1lBQzlDLE9BQU8sVUFBVSxDQUFDLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUM5RCxDQUFDO1FBQ0QsSUFBSSxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDbEIsT0FBTyxVQUFVLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ25DLENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUMsQ0FBQztTQUNELE1BQU0sQ0FBQyxDQUFDLEtBQW9CLEVBQUUsRUFBRSxDQUFDLEtBQUssS0FBSyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUVyRSxJQUFJLE1BQU0sQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDeEIsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUM7QUFDN0IsQ0FBQyJ9

package/.medusa/server/api/middlewares/add-sales-statistics.d.ts

@@ -0,0 +1,2 @@
+import { MedusaRequest, MedusaResponse, MedusaNextFunction } from "@medusajs/framework/http";
+export declare function addSalesStatistics(req: MedusaRequest, res: MedusaResponse, next: MedusaNextFunction): Promise<void>;

package/.medusa/server/api/middlewares/add-sales-statistics.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSalesStatistics = addSalesStatistics;
+const utils_1 = require("@medusajs/framework/utils");
+async function addSalesStatistics(req, res, next) {
+    const originalJson = res.json.bind(res);
+    res.json = async function (data) {
+        // Check if this is a products listing response
+        if (data?.products && Array.isArray(data.products)) {
+            try {
+                const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+                // Get all order items
+                const { data: orderItems } = await query.graph({
+                    entity: "order_line_item",
+                    fields: [
+                        "id",
+                        "variant_id",
+                        "quantity",
+                        "unit_price",
+                        "subtotal",
+                        "order_id"
+                    ]
+                });
+                // Get orders separately
+                const orderIds = [...new Set(orderItems.map(item => item.order_id).filter(Boolean))];
+                let orders = [];
+                if (orderIds.length > 0) {
+                    const orderResult = await query.graph({
+                        entity: "order",
+                        fields: ["id", "status", "created_at"],
+                        filters: {
+                            id: orderIds
+                        }
+                    });
+                    orders = orderResult.data;
+                }
+                // Create order map
+                const orderMap = new Map(orders.map(o => [o.id, o]));
+                // Filter for completed orders
+                const filteredOrderItems = orderItems.filter(item => {
+                    const order = orderMap.get(item.order_id);
+                    return order && [
+                        "completed",
+                        "partially_returned",
+                        "partially_shipped",
+                        "shipped",
+                        "fulfilled",
+                        "partially_fulfilled"
+                    ].includes(order.status);
+                });
+                // Add sales statistics to each product
+                data.products = data.products.map((product) => {
+                    const variantIds = product.variants?.map((v) => v.id) || [];
+                    const productSales = filteredOrderItems.filter(item => item.variant_id && variantIds.includes(item.variant_id));
+                    const totalQuantitySold = productSales.reduce((sum, item) => sum + (item.quantity || 0), 0);
+                    const totalRevenue = productSales.reduce((sum, item) => sum + (item.subtotal || 0), 0);
+                    // Add sales data to each variant if they exist
+                    if (product.variants && Array.isArray(product.variants)) {
+                        product.variants = product.variants.map((variant) => {
+                            const variantSales = productSales.filter(item => item.variant_id === variant.id);
+                            const variantQuantitySold = variantSales.reduce((sum, item) => sum + (item.quantity || 0), 0);
+                            const variantRevenue = variantSales.reduce((sum, item) => sum + (item.subtotal || 0), 0);
+                            // Add sales stats to variant
+                            return {
+                                ...variant,
+                                sales_statistics: {
+                                    quantity_sold: variantQuantitySold,
+                                    revenue: variantRevenue,
+                                    number_of_orders: new Set(variantSales.map(item => item.order_id).filter(Boolean)).size
+                                }
+                            };
+                        });
+                    }
+                    // Add product-level sales statistics
+                    return {
+                        ...product,
+                        sales_statistics: {
+                            total_quantity_sold: totalQuantitySold,
+                            total_revenue: totalRevenue,
+                            number_of_orders: new Set(productSales.map(item => item.order_id).filter(Boolean)).size,
+                            average_order_value: totalQuantitySold > 0 ? totalRevenue / totalQuantitySold : 0,
+                            is_bestseller: totalQuantitySold > 0,
+                            stock_status: product.variants?.some((v) => {
+                                // Check inventory from different possible structures
+                                const inventory = v.inventory_items?.[0]?.inventory ||
+                                    v.inventory_items?.[0] ||
+                                    v.inventory?.items?.[0];
+                                return inventory?.available_quantity > 0 || inventory?.stocked_quantity > 0;
+                            }) ? 'in_stock' : 'out_of_stock'
+                        }
+                    };
+                });
+            }
+            catch (error) {
+                // If there's an error fetching sales data, return products without stats
+                console.error("Error adding sales statistics:", error);
+            }
+        }
+        return originalJson(data);
+    };
+    next();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/api/middlewares/add-stock-availability.d.ts

@@ -0,0 +1,7 @@
+import type { MedusaRequest, MedusaResponse, MedusaNextFunction } from "@medusajs/framework/http";
+/**
+ * Middleware to add stock availability status to product responses
+ * This enhances product payloads with accurate inventory information
+ * for Schema.org structured data and frontend display
+ */
+export declare function addStockAvailability(req: MedusaRequest, res: MedusaResponse, next: MedusaNextFunction): Promise<void>;

package/.medusa/server/api/middlewares/add-stock-availability.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addStockAvailability = addStockAvailability;
+/**
+ * Middleware to add stock availability status to product responses
+ * This enhances product payloads with accurate inventory information
+ * for Schema.org structured data and frontend display
+ */
+async function addStockAvailability(req, res, next) {
+    try {
+        const originalJson = res.json.bind(res);
+        res.json = async function (data) {
+            try {
+                // Handle single product response
+                if (data?.product && !Array.isArray(data.product)) {
+                    data.product = enrichProductWithStock(data.product);
+                }
+                // Handle products array response
+                if (data?.products && Array.isArray(data.products)) {
+                    data.products = data.products.map((product) => enrichProductWithStock(product));
+                }
+            }
+            catch (error) {
+                console.error("Error adding stock availability:", error?.message || error);
+                // Continue with original data on error
+            }
+            return originalJson(data);
+        };
+        next();
+    }
+    catch (middlewareError) {
+        console.error("Error in addStockAvailability middleware:", middlewareError);
+        next(middlewareError);
+    }
+}
+/**
+ * Enrich a single product with stock availability information
+ * Simplified version - defaults to InStock for now
+ */
+function enrichProductWithStock(product) {
+    if (!product) {
+        return product;
+    }
+    // If variants field is not requested, skip enrichment
+    if (!product.variants) {
+        return product;
+    }
+    if (product.variants.length === 0) {
+        return {
+            ...product,
+            stock_availability: {
+                status: "OutOfStock",
+                has_stock: false,
+                total_available_quantity: 0,
+                total_stocked_quantity: 0,
+            },
+        };
+    }
+    try {
+        // Check if product status indicates it's not available
+        let status = "InStock";
+        if (product.status === "draft") {
+            status = "Discontinued";
+        }
+        // Simple heuristic: if product has variants, assume in stock
+        // This can be enhanced later with actual inventory queries
+        const hasStock = product.variants.length > 0 && product.status !== "draft";
+        return {
+            ...product,
+            stock_availability: {
+                status,
+                has_stock: hasStock,
+                total_available_quantity: hasStock ? 999 : 0,
+                total_stocked_quantity: hasStock ? 999 : 0,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Error enriching product ${product.id}:`, error?.message || error);
+        return {
+            ...product,
+            stock_availability: {
+                status: "InStock",
+                has_stock: true,
+                total_available_quantity: 999,
+                total_stocked_quantity: 999,
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/api/middlewares.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@medusajs/framework/http").MiddlewaresConfig;
+export default _default;

package/.medusa/server/api/middlewares.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("@medusajs/framework/http");
+const add_sales_statistics_1 = require("./middlewares/add-sales-statistics");
+const add_stock_availability_1 = require("./middlewares/add-stock-availability");
+const add_product_filters_1 = require("./middlewares/add-product-filters");
+exports.default = (0, http_1.defineMiddlewares)({
+    routes: [
+        {
+            matcher: "/store/products",
+            method: "GET",
+            middlewares: [
+                add_product_filters_1.captureFilterParams, // FIRST: Capture and remove custom filter params
+                add_stock_availability_1.addStockAvailability, // Add stock data
+                add_product_filters_1.applyProductFilters, // LAST: Apply filters using enriched data
+                add_sales_statistics_1.addSalesStatistics, // Add sales statistics
+            ],
+        },
+        {
+            matcher: "/store/products/:id",
+            method: "GET",
+            middlewares: [add_stock_availability_1.addStockAvailability, add_sales_statistics_1.addSalesStatistics],
+        },
+        {
+            matcher: "/admin/products",
+            method: "GET",
+            middlewares: [add_stock_availability_1.addStockAvailability, add_sales_statistics_1.addSalesStatistics],
+        },
+        {
+            matcher: "/admin/products/:id",
+            method: "GET",
+            middlewares: [add_sales_statistics_1.addSalesStatistics],
+        },
+    ],
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL21pZGRsZXdhcmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsbURBQTZEO0FBQzdELDZFQUF3RTtBQUN4RSxpRkFBNEU7QUFDNUUsMkVBRzJDO0FBRTNDLGtCQUFlLElBQUEsd0JBQWlCLEVBQUM7SUFDL0IsTUFBTSxFQUFFO1FBQ047WUFDRSxPQUFPLEVBQUUsaUJBQWlCO1lBQzFCLE1BQU0sRUFBRSxLQUFLO1lBQ2IsV0FBVyxFQUFFO2dCQUNYLHlDQUFtQixFQUFFLGlEQUFpRDtnQkFDdEUsNkNBQW9CLEVBQUUsaUJBQWlCO2dCQUN2Qyx5Q0FBbUIsRUFBRSwwQ0FBMEM7Z0JBQy9ELHlDQUFrQixFQUFFLHVCQUF1QjthQUM1QztTQUNGO1FBQ0Q7WUFDRSxPQUFPLEVBQUUscUJBQXFCO1lBQzlCLE1BQU0sRUFBRSxLQUFLO1lBQ2IsV0FBVyxFQUFFLENBQUMsNkNBQW9CLEVBQUUseUNBQWtCLENBQUM7U0FDeEQ7UUFDRDtZQUNFLE9BQU8sRUFBRSxpQkFBaUI7WUFDMUIsTUFBTSxFQUFFLEtBQUs7WUFDYixXQUFXLEVBQUUsQ0FBQyw2Q0FBb0IsRUFBRSx5Q0FBa0IsQ0FBQztTQUN4RDtRQUNEO1lBQ0UsT0FBTyxFQUFFLHFCQUFxQjtZQUM5QixNQUFNLEVBQUUsS0FBSztZQUNiLFdBQVcsRUFBRSxDQUFDLHlDQUFrQixDQUFDO1NBQ2xDO0tBQ0Y7Q0FDRixDQUFDLENBQUMifQ==

package/.medusa/server/index.d.ts

@@ -0,0 +1,2 @@
+import { MedusaContainer } from "@medusajs/framework/types";
+export default function salesAnalyticsPlugin(container: MedusaContainer, options: Record<string, unknown>): Promise<void>;