@lodashventure/medusa-campaign 1.4.1 → 1.4.2

package/src/api/admin/coupons/route.ts

@@ -0,0 +1,109 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import {
+  MedusaError,
+  Modules,
+} from "@medusajs/framework/utils";
+import { createFindParams } from "@medusajs/medusa/api/utils/validators";
+import z from "zod";
+import { CampaignTypeEnum } from "../../../modules/custom-campaigns/types/campaign-type.enum";
+import { createCouponCampaignWorkflow } from "../../../workflows/custom-campaign/createCouponCampaignWorkflow";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../../modules/custom-campaigns/service";
+
+export const createCouponCampaignSchema = z
+  .object({
+    name: z.string().min(1, "Name is required"),
+    description: z.string().min(1, "Description is required"),
+    type: z.literal(CampaignTypeEnum.Coupon),
+    code: z.string().min(1, "Coupon code is required"),
+    starts_at: z.coerce.date(),
+    ends_at: z.coerce.date(),
+    discount_type: z.enum(["percentage", "fixed"]),
+    discount_value: z.number().positive("Discount value must be positive"),
+    currency_code: z.string().optional(),
+    allocation: z.enum(["each", "total"]).optional(),
+    target_type: z.enum(["order", "items"]).optional(),
+  })
+  .superRefine((data, ctx) => {
+    if (data.ends_at <= data.starts_at) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "End date must be after start date",
+        path: ["ends_at"],
+      });
+    }
+
+    if (data.discount_type === "fixed" && !data.currency_code) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "currency_code is required for fixed discount type",
+        path: ["currency_code"],
+      });
+    }
+  });
+
+export type CouponCampaignInput = z.infer<typeof createCouponCampaignSchema>;
+
+export const GetCouponCampaignsSchema = createFindParams({
+  order: "-created_at",
+});
+
+export const POST = async (
+  req: MedusaRequest<CouponCampaignInput>,
+  res: MedusaResponse,
+) => {
+  const body = req.body;
+
+  if (body.type !== CampaignTypeEnum.Coupon) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Invalid campaign type for coupons",
+    );
+  }
+
+  const { result } = await createCouponCampaignWorkflow.run({
+    input: {
+      ...body,
+    },
+  });
+
+  res.status(200).json(result);
+};
+
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  const customCampaignTypes =
+    await customCampaignModuleService.listCustomCampaignTypes({
+      type: CampaignTypeEnum.Coupon,
+    });
+
+  if (!customCampaignTypes.length) {
+    return res.status(200).json({
+      campaigns: [],
+      count: 0,
+      limit: 20,
+      offset: 0,
+    });
+  }
+
+  const campaignIds = customCampaignTypes.map((ct) => ct.campaign_id);
+
+  const campaigns = await promotionService.listCampaigns(
+    {
+      id: campaignIds,
+    },
+    {
+      relations: ["promotions", "promotions.application_method"],
+    },
+  );
+
+  res.status(200).json({
+    campaigns,
+    count: campaigns.length,
+    limit: campaigns.length,
+    offset: 0,
+  });
+};

package/src/api/middlewares.ts

@@ -7,7 +7,12 @@ import {
   createCustomCampaignSchema,
   GetFlashSalesSchema,
 } from "./admin/flash-sales/route";
+import {
+  createCouponCampaignSchema,
+  GetCouponCampaignsSchema,
+} from "./admin/coupons/route";
 import multer from "multer";
+import { collectCouponSchema } from "./store/customers/me/coupons/route";
 
 const upload = multer({
   storage: multer.memoryStorage(),
@@ -34,6 +39,30 @@ export default defineMiddlewares([
       }),
     ],
   },
+  {
+    methods: ["POST"],
+    matcher: "/admin/coupons",
+    middlewares: [
+      validateAndTransformBody(createCouponCampaignSchema as any),
+    ],
+  },
+  {
+    methods: ["PUT"],
+    matcher: "/admin/coupons/:id",
+    middlewares: [
+      validateAndTransformBody(createCouponCampaignSchema as any),
+    ],
+  },
+  {
+    methods: ["GET"],
+    matcher: "/admin/coupons",
+    middlewares: [
+      validateAndTransformQuery(GetCouponCampaignsSchema as any, {
+        defaults: ["*", "campaign.*"],
+        isList: true,
+      }),
+    ],
+  },
   {
     methods: ["POST"],
     matcher: "/admin/campaigns/:id/image",
@@ -50,4 +79,9 @@ export default defineMiddlewares([
       upload.single("file"),
     ],
   },
+  {
+    methods: ["POST"],
+    matcher: "/store/customers/me/coupons",
+    middlewares: [validateAndTransformBody(collectCouponSchema as any)],
+  },
 ]);

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

@@ -1,5 +1,5 @@
 import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
-import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils";
+import { Modules } from "@medusajs/framework/utils";
 import { CampaignTypeEnum } from "../../../modules/custom-campaigns/types/campaign-type.enum";
 import { CUSTOM_CAMPAIGN_MODULE } from "../../../modules/custom-campaigns";
 import CustomCampaignModuleService from "../../../modules/custom-campaigns/service";
@@ -11,6 +11,7 @@ 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 now = new Date();
 
   try {
@@ -65,9 +66,24 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     const allCampaigns = await promotionService.listCampaigns({});
     console.log(`Total campaigns in system: ${allCampaigns.length}`);
 
-    // Then fetch specific campaigns
+    // Then fetch specific campaigns with relations
     const campaigns = campaignIds.length > 0
-      ? allCampaigns.filter((c: any) => campaignIds.includes(c.id))
+      ? await Promise.all(
+          campaignIds.map(async (campaignId) => {
+            try {
+              return await promotionService.retrieveCampaign(campaignId, {
+                relations: [
+                  "promotions",
+                  "promotions.application_method",
+                  "promotions.application_method.target_rules",
+                ],
+              });
+            } catch (error) {
+              console.error(`Error fetching campaign ${campaignId}:`, error);
+              return null;
+            }
+          })
+        ).then((results) => results.filter((c) => c !== null))
       : [];
 
     console.log(`Found ${campaigns.length} matching campaigns`);
@@ -83,27 +99,94 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     );
 
     // Process ALL campaigns first (without date filter) for debugging
-    const allProcessedCampaigns = campaigns.map((campaign: any) => {
-      const startsAt = new Date(campaign.starts_at);
-      const endsAt = new Date(campaign.ends_at);
-      const isActive = startsAt <= now && endsAt >= now;
-
-      console.log(`  Checking campaign "${campaign.name}":`);
-      console.log(`    Start: ${startsAt.toISOString()} (${startsAt <= now ? 'started' : 'not started'})`);
-      console.log(`    End: ${endsAt.toISOString()} (${endsAt >= now ? 'not ended' : 'ended'})`);
-      console.log(`    Active: ${isActive}`);
-
-      return {
-        id: campaign.id,
-        name: campaign.name,
-        description: campaign.description,
-        campaign_identifier: campaign.campaign_identifier,
-        starts_at: campaign.starts_at,
-        ends_at: campaign.ends_at,
-        campaign_type: campaignTypeMap.get(campaign.id),
-        is_active: isActive
-      };
-    });
+    const allProcessedCampaigns = await Promise.all(
+      campaigns.map(async (campaign: any) => {
+        const startsAt = new Date(campaign.starts_at);
+        const endsAt = new Date(campaign.ends_at);
+        const isActive = startsAt <= now && endsAt >= now;
+
+        console.log(`  Checking campaign "${campaign.name}":`);
+        console.log(`    Start: ${startsAt.toISOString()} (${startsAt <= now ? 'started' : 'not started'})`);
+        console.log(`    End: ${endsAt.toISOString()} (${endsAt >= now ? 'not ended' : 'ended'})`);
+        console.log(`    Active: ${isActive}`);
+
+        const campaignType = campaignTypeMap.get(campaign.id);
+
+        // Fetch products for flash-sale campaigns
+        let products: any[] = [];
+        if (campaignType === CampaignTypeEnum.FlashSale) {
+          try {
+            // Fetch promotion usage limits for this campaign
+            const promotionUsageLimits =
+              await customCampaignModuleService.listPromotionUsageLimits({
+                campaign_id: campaign.id,
+              });
+
+            // Create a map of promotion usage limits by promotion ID
+            const promotionLimitsMap = new Map();
+            promotionUsageLimits.forEach((limit) => {
+              promotionLimitsMap.set(limit.promotion_id, limit);
+            });
+
+            // Process promotions to extract product information
+            for (const promotion of campaign.promotions ?? []) {
+              if (!promotion.application_method?.target_rules?.length) {
+                continue;
+              }
+
+              const promotionLimit = promotionLimitsMap.get(promotion.id);
+              if (!promotionLimit?.product_id) {
+                continue;
+              }
+
+              try {
+                const product = await productService.retrieveProduct(
+                  promotionLimit.product_id,
+                  {
+                    select: ["id", "title", "thumbnail", "handle", "description"],
+                    relations: ["images"],
+                  },
+                );
+
+                if (promotion.application_method.value !== undefined) {
+                  products.push({
+                    product: {
+                      id: product.id,
+                      title: product.title,
+                      thumbnail: product.thumbnail,
+                      handle: product.handle,
+                      description: product.description,
+                      images: product.images,
+                    },
+                    discountType: promotion.application_method?.type as "percentage",
+                    discountValue: promotion.application_method?.value,
+                    maxQty: promotion.application_method?.max_quantity ?? 0,
+                    limit: promotionLimit?.limit ?? 0,
+                    used: promotionLimit?.used ?? 0,
+                  });
+                }
+              } catch (error) {
+                console.error(`Error fetching product ${promotionLimit.product_id}:`, error);
+              }
+            }
+          } catch (error) {
+            console.error(`Error fetching products for campaign ${campaign.id}:`, error);
+          }
+        }
+
+        return {
+          id: campaign.id,
+          name: campaign.name,
+          description: campaign.description,
+          campaign_identifier: campaign.campaign_identifier,
+          starts_at: campaign.starts_at,
+          ends_at: campaign.ends_at,
+          campaign_type: campaignType,
+          is_active: isActive,
+          ...(products.length > 0 && { products }),
+        };
+      })
+    );
 
     // Filter for active campaigns
     const activeCampaigns = allProcessedCampaigns.filter(c => c.is_active);

package/src/api/store/coupons/public/route.ts

@@ -0,0 +1,165 @@
+import { MedusaRequest, MedusaResponse, container } from "@medusajs/framework";
+import { Modules } from "@medusajs/framework/utils";
+import { CampaignTypeEnum } from "../../../../modules/custom-campaigns/types/campaign-type.enum";
+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, res: MedusaResponse) => {
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  const usablePromoService =
+    resolveOptional<UsablePromoModuleService>(USABLE_PROMO_MODULE);
+  const promotionCacheService = resolveOptional<PromotionCacheService>(
+    PROMOTION_CACHE_MODULE,
+  );
+
+  const now = new Date();
+  const customerId = (
+    req as unknown as { auth_context?: { actor_id?: string } }
+  )?.auth_context?.actor_id;
+
+  const parsedLimit = req.query?.limit ? Number(req.query.limit) : 20;
+  const parsedOffset = req.query?.offset ? Number(req.query.offset) : 0;
+
+  const limit = Number.isNaN(parsedLimit) ? 20 : parsedLimit;
+  const offset = Number.isNaN(parsedOffset) ? 0 : parsedOffset;
+
+  const couponCampaignTypes =
+    await customCampaignModuleService.listCustomCampaignTypes({
+      type: CampaignTypeEnum.Coupon,
+    });
+
+  if (!couponCampaignTypes.length) {
+    return res.status(200).json({
+      coupons: [],
+      count: 0,
+      limit,
+      offset,
+    });
+  }
+
+  const campaignIds = couponCampaignTypes.map((ct) => ct.campaign_id);
+
+  const promotions = await promotionService.listPromotions(
+    {
+      campaign_id: { $in: campaignIds },
+    } as any,
+    {
+      relations: ["campaign", "application_method"],
+    },
+  );
+
+  const campaignDetails = await customCampaignModuleService.listCampaignDetails(
+    {
+      campaign_id: campaignIds,
+    },
+  );
+
+  const detailMap = new Map(
+    campaignDetails.map((detail) => [detail.campaign_id, detail]),
+  );
+
+  const usablePromotions = usablePromoService
+    ? await usablePromoService.listUsablePromotions({
+        promotion_id: promotions.map((promo) => promo.id),
+      })
+    : [];
+
+  const usableMap = new Map(
+    usablePromotions.map((usable) => [usable.promotion_id, usable.enabled]),
+  );
+
+  const filteredPromotions = promotions.filter((promotion) => {
+    const campaign = promotion.campaign;
+    if (!campaign) {
+      return false;
+    }
+
+    const startsAt = campaign.starts_at ? new Date(campaign.starts_at) : null;
+    const endsAt = campaign.ends_at ? new Date(campaign.ends_at) : null;
+
+    const withinWindow =
+      (!startsAt || startsAt <= now) && (!endsAt || endsAt >= now);
+
+    const isCollectable = usableMap.has(promotion.id)
+      ? usableMap.get(promotion.id)!
+      : true;
+
+    return (
+      campaign &&
+      withinWindow &&
+      promotion.status === "active" &&
+      !promotion.is_automatic &&
+      isCollectable
+    );
+  });
+
+  const paginated = filteredPromotions.slice(offset, offset + limit);
+
+  const coupons = await Promise.all(
+    paginated.map(async (promotion) => {
+      const campaign = promotion.campaign!;
+      const detail = detailMap.get(campaign.id);
+      let isCollected = false;
+
+      if (customerId && promotionCacheService) {
+        const key = `user:${customerId}:promotion:${promotion.id}`;
+        isCollected = await promotionCacheService.exists(key);
+      }
+
+      return {
+        id: promotion.id,
+        code: promotion.code,
+        name: campaign.name,
+        description: campaign.description,
+        starts_at: campaign.starts_at,
+        ends_at: campaign.ends_at,
+        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,
+        campaign_id: campaign.id,
+        is_collectable: usableMap.has(promotion.id)
+          ? usableMap.get(promotion.id)!
+          : true,
+        is_collected: isCollected,
+        detail: detail ?? null,
+      };
+    }),
+  );
+
+  res.status(200).json({
+    coupons,
+    count: filteredPromotions.length,
+    limit,
+    offset,
+  });
+};