@lodashventure/medusa-campaign 1.4.23 → 1.4.24

package/src/api/store/campaigns/[id]/route.ts

@@ -9,6 +9,33 @@ import { CustomCampaign } from "../../../admin/flash-sales/route";
 import { CUSTOM_CAMPAIGN_MODULE } from "../../../../modules/custom-campaigns";
 import CustomCampaignModuleService from "../../../../modules/custom-campaigns/service";
 
+type UsablePromoModuleService = {
+  listUsablePromotions: (
+    selector: Record<string, unknown>,
+  ) => Promise<
+    Array<{
+      id: string;
+      promotion_id: string;
+      enabled: boolean;
+    }>
+  >;
+};
+
+type PromotionCacheService = {
+  exists: (key: string) => Promise<boolean>;
+};
+
+const USABLE_PROMO_MODULE = "usable_promotion";
+const PROMOTION_CACHE_MODULE = "promotion_cache";
+
+const resolveOptional = <T>(token: string): T | null => {
+  try {
+    return container.resolve<T>(token);
+  } catch {
+    return null;
+  }
+};
+
 export const GET = async (
   req: MedusaRequest<{ id: string }>,
   res: MedusaResponse,
@@ -223,6 +250,117 @@ export const GET = async (
             }
           : null,
       });
+    } else if (campaignType === CampaignTypeEnum.Coupon) {
+      const usablePromoService = resolveOptional<UsablePromoModuleService>(
+        USABLE_PROMO_MODULE,
+      );
+      const promotionCacheService = resolveOptional<PromotionCacheService>(
+        PROMOTION_CACHE_MODULE,
+      );
+      const customerId = (
+        req as unknown as { auth_context?: { actor_id?: string } }
+      )?.auth_context?.actor_id;
+
+      const campaignPromotions = await promotionService.listPromotions(
+        {
+          campaign_id: campaign.id,
+        } as any,
+        {
+          relations: ["application_method"],
+        },
+      );
+
+      const promotions = campaignPromotions.filter(
+        (promotion) => promotion.status === "active" && !promotion.is_automatic,
+      );
+
+      const usablePromotions = usablePromoService
+        ? await usablePromoService.listUsablePromotions({
+            promotion_id: promotions.map((promotion) => promotion.id),
+          })
+        : [];
+
+      const usableMap = new Map(
+        usablePromotions.map((usable) => [usable.promotion_id, usable.enabled]),
+      );
+
+      const collectedMap = new Map<string, boolean>();
+      if (customerId && promotionCacheService) {
+        await Promise.all(
+          promotions.map(async (promotion) => {
+            try {
+              const cacheKey = `user:${customerId}:promotion:${promotion.id}`;
+              const collected = await promotionCacheService.exists(cacheKey);
+              collectedMap.set(promotion.id, collected);
+            } catch (error) {
+              console.error(
+                `[Campaign] Failed to resolve collected status for promotion ${promotion.id}:`,
+                error,
+              );
+            }
+          }),
+        );
+      }
+
+      const coupons = promotions.map((promotion) => {
+        const isCollectable = usableMap.has(promotion.id)
+          ? usableMap.get(promotion.id)!
+          : true;
+        const isCollected = collectedMap.get(promotion.id) ?? false;
+
+        return {
+          id: promotion.id,
+          code: promotion.code,
+          discount_type: promotion.application_method?.type,
+          discount_value: promotion.application_method?.value,
+          allocation: promotion.application_method?.allocation,
+          target_type: promotion.application_method?.target_type,
+          currency_code: promotion.application_method?.currency_code,
+          is_collectable: isCollectable,
+          is_collected: isCollected,
+          collect_endpoint: "/store/customers/me/coupons",
+          collect_payload: {
+            coupon_id: promotion.id,
+          },
+        };
+      });
+
+      const collectableCount = coupons.filter(
+        (coupon) => coupon.is_collectable && !coupon.is_collected,
+      ).length;
+      const collectedCount = coupons.filter(
+        (coupon) => coupon.is_collected,
+      ).length;
+
+      res.status(200).json({
+        id: campaign.id,
+        name: campaign.name,
+        description: campaign.description,
+        type: campaignType,
+        starts_at: campaign.starts_at,
+        ends_at: campaign.ends_at,
+        coupons,
+        summary: {
+          type: "coupon",
+          coupon_count: coupons.length,
+          collectable_count: collectableCount,
+          collected_count: collectedCount,
+        },
+        campaign_detail: campaignDetail
+          ? {
+              image_url: campaignDetail.image_url,
+              thumbnail_url: campaignDetail.thumbnail_url,
+              detail_content: campaignDetail.detail_content,
+              terms_and_conditions: campaignDetail.terms_and_conditions,
+              meta_title: campaignDetail.meta_title,
+              meta_description: campaignDetail.meta_description,
+              meta_keywords: campaignDetail.meta_keywords,
+              link_url: campaignDetail.link_url,
+              link_text: campaignDetail.link_text,
+              display_order: campaignDetail.display_order,
+            }
+          : null,
+      });
     } else {
       throw new MedusaError(
         MedusaError.Types.INVALID_DATA,

package/src/api/store/campaigns/route.ts

@@ -4,14 +4,47 @@ import { CampaignTypeEnum } from "../../../modules/custom-campaigns/types/campai
 import { CUSTOM_CAMPAIGN_MODULE } from "../../../modules/custom-campaigns";
 import CustomCampaignModuleService from "../../../modules/custom-campaigns/service";
 
+type UsablePromoModuleService = {
+  listUsablePromotions: (selector: Record<string, unknown>) => Promise<
+    Array<{
+      id: string;
+      promotion_id: string;
+      enabled: boolean;
+    }>
+  >;
+};
+
+type PromotionCacheService = {
+  exists: (key: string) => Promise<boolean>;
+};
+
+const USABLE_PROMO_MODULE = "usable_promotion";
+const PROMOTION_CACHE_MODULE = "promotion_cache";
+
+const resolveOptional = <T>(token: string): T | null => {
+  try {
+    return container.resolve<T>(token);
+  } catch {
+    return null;
+  }
+};
+
 /**
- * GET handler for listing all active campaigns (Flash Sales + Buy X Get Y) for storefront
+ * GET handler for listing all active campaigns (Flash Sales + Buy X Get Y + Coupon) for storefront
  */
 export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
   const customCampaignModuleService =
     container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
   const promotionService = container.resolve(Modules.PROMOTION);
   const productService = container.resolve(Modules.PRODUCT);
+  const usablePromoService =
+    resolveOptional<UsablePromoModuleService>(USABLE_PROMO_MODULE);
+  const promotionCacheService =
+    resolveOptional<PromotionCacheService>(PROMOTION_CACHE_MODULE);
+
+  const customerId = (
+    req as unknown as { auth_context?: { actor_id?: string } }
+  )?.auth_context?.actor_id;
   const now = new Date();
 
   try {
@@ -98,6 +131,74 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
       customCampaignTypes.map((ct) => [ct.campaign_id, ct.type])
     );
 
+    const campaignDetails =
+      await customCampaignModuleService.listCampaignDetails({
+        campaign_id: campaignIds,
+      });
+
+    const campaignDetailMap = new Map(
+      campaignDetails.map((detail) => [detail.campaign_id, detail]),
+    );
+
+    const couponCampaignIds = customCampaignTypes
+      .filter((ct) => ct.type === CampaignTypeEnum.Coupon)
+      .map((ct) => ct.campaign_id);
+
+    const couponPromotionsByCampaign = new Map<string, any[]>();
+    let couponPromotionIds: string[] = [];
+
+    if (couponCampaignIds.length > 0) {
+      const couponPromotions = await promotionService.listPromotions(
+        {
+          campaign_id: { $in: couponCampaignIds },
+        } as any,
+        {
+          relations: ["application_method"],
+        },
+      );
+
+      couponPromotionIds = couponPromotions.map((promotion) => promotion.id);
+      couponPromotions.forEach((promotion) => {
+        if (!promotion.campaign_id) {
+          return;
+        }
+        const existing = couponPromotionsByCampaign.get(promotion.campaign_id);
+        if (existing) {
+          existing.push(promotion);
+        } else {
+          couponPromotionsByCampaign.set(promotion.campaign_id, [promotion]);
+        }
+      });
+    }
+
+    const usablePromotions = usablePromoService
+      ? await usablePromoService.listUsablePromotions({
+          promotion_id: couponPromotionIds,
+        })
+      : [];
+
+    const usableMap = new Map(
+      usablePromotions.map((usable) => [usable.promotion_id, usable.enabled]),
+    );
+
+    const collectedMap = new Map<string, boolean>();
+    if (customerId && promotionCacheService) {
+      await Promise.all(
+        couponPromotionIds.map(async (promotionId) => {
+          try {
+            const cacheKey = `user:${customerId}:promotion:${promotionId}`;
+            const collected = await promotionCacheService.exists(cacheKey);
+            collectedMap.set(promotionId, collected);
+          } catch (error) {
+            console.error(
+              `[Campaign] Failed to determine collected status for promotion ${promotionId}:`,
+              error,
+            );
+          }
+        }),
+      );
+    }
+
     // Process ALL campaigns first (without date filter) for debugging
     const allProcessedCampaigns = await Promise.all(
       campaigns.map(async (campaign: any) => {
@@ -113,7 +214,9 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
         const campaignType = campaignTypeMap.get(campaign.id);
 
         // Fetch products for flash-sale campaigns
-        let products: any[] = [];
+        let products: any[] | undefined;
+        let summary: Record<string, unknown> | undefined;
+        let coupons: any[] | undefined;
         if (campaignType === CampaignTypeEnum.FlashSale) {
           try {
             // Fetch promotion usage limits for this campaign
@@ -128,6 +231,8 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
               promotionLimitsMap.set(limit.promotion_id, limit);
             });
 
+            const flashSaleProducts: any[] = [];
+
             // Process promotions to extract product information
             for (const promotion of campaign.promotions ?? []) {
               if (!promotion.application_method?.target_rules?.length) {
@@ -149,7 +254,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
                 );
 
                 if (promotion.application_method.value !== undefined) {
-                  products.push({
+                  flashSaleProducts.push({
                     product: {
                       id: product.id,
                       title: product.title,
@@ -163,15 +268,105 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
                     maxQty: promotion.application_method?.max_quantity ?? 0,
                     limit: promotionLimit?.limit ?? 0,
                     used: promotionLimit?.used ?? 0,
+                    remaining:
+                      typeof promotionLimit?.limit === "number" &&
+                      typeof promotionLimit?.used === "number"
+                        ? Math.max(
+                            promotionLimit.limit - promotionLimit.used,
+                            0,
+                          )
+                        : null,
                   });
                 }
               } catch (error) {
                 console.error(`Error fetching product ${promotionLimit.product_id}:`, error);
               }
             }
+
+            products = flashSaleProducts;
+
+            const aggregate = promotionUsageLimits.reduce(
+              (acc, limit) => {
+                acc.product_count += 1;
+                acc.total_limit += limit.limit ?? 0;
+                acc.total_used += limit.used ?? 0;
+                if (
+                  typeof limit.limit === "number" &&
+                  typeof limit.used === "number"
+                ) {
+                  const remaining = Math.max(limit.limit - limit.used, 0);
+                  acc.total_remaining += remaining;
+                  if (remaining > 0) {
+                    acc.active_product_count += 1;
+                  }
+                }
+                return acc;
+              },
+              {
+                product_count: 0,
+                active_product_count: 0,
+                total_limit: 0,
+                total_used: 0,
+                total_remaining: 0,
+              },
+            );
+
+            summary = {
+              type: "flash-sale",
+              ...aggregate,
+            };
           } catch (error) {
             console.error(`Error fetching products for campaign ${campaign.id}:`, error);
           }
+        } else if (campaignType === CampaignTypeEnum.Coupon) {
+          try {
+            const campaignCoupons =
+              couponPromotionsByCampaign.get(campaign.id) ?? [];
+
+            const availableCoupons = campaignCoupons
+              .filter(
+                (promotion: any) =>
+                  promotion.status === "active" && !promotion.is_automatic,
+              )
+              .map((promotion: any) => {
+                const isCollectable = usableMap.has(promotion.id)
+                  ? usableMap.get(promotion.id)!
+                  : true;
+                const isCollected = collectedMap.get(promotion.id) ?? false;
+
+                return {
+                  id: promotion.id,
+                  code: promotion.code,
+                  description: campaign.description,
+                  discount_type: promotion.application_method?.type,
+                  discount_value: promotion.application_method?.value,
+                  allocation: promotion.application_method?.allocation,
+                  target_type: promotion.application_method?.target_type,
+                  currency_code: promotion.application_method?.currency_code,
+                  is_collectable: isCollectable,
+                  is_collected: isCollected,
+                  collect_endpoint: "/store/customers/me/coupons",
+                  collect_payload: {
+                    coupon_id: promotion.id,
+                  },
+                };
+              });
+
+            coupons = availableCoupons;
+
+            summary = {
+              type: "coupon",
+              coupon_count: availableCoupons.length,
+              collectable_count: availableCoupons.filter(
+                (coupon) => coupon.is_collectable && !coupon.is_collected,
+              ).length,
+              collected_count: availableCoupons.filter(
+                (coupon) => coupon.is_collected,
+              ).length,
+            };
+          } catch (error) {
+            console.error(`Error building coupons for campaign ${campaign.id}:`, error);
+          }
         }
 
         return {
@@ -184,6 +379,9 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
           campaign_type: campaignType,
           is_active: isActive,
           products,
+          coupons,
+          summary,
+          campaign_detail: campaignDetailMap.get(campaign.id) ?? null,
         };
       })
     );