@lodashventure/medusa-campaign 1.1.4 → 1.1.6

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

@@ -6,6 +6,8 @@ import {
 } from "@medusajs/framework/utils";
 import { CampaignTypeEnum } from "../../../../modules/custom-campaigns/types/campaign-type.enum";
 import { CustomCampaign } from "../../../admin/flash-sales/route";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../../../modules/custom-campaigns/service";
 
 export const GET = async (
   req: MedusaRequest<{ id: string }>,
@@ -22,112 +24,190 @@ export const GET = async (
 
   const query = container.resolve(ContainerRegistrationKeys.QUERY);
   const productService = container.resolve(Modules.PRODUCT);
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
 
   try {
-    // First, find the custom campaign type by campaign ID
-    const {
-      data: [customCampaignTypes],
-    } = await query.graph({
-      entity: "custom_campaign_type",
-      fields: [
-        "id",
-        "campaign.*",
-        "campaign.promotions.*",
-        "campaign.promotions.application_method.*",
-        "campaign.promotions.application_method.target_rules.*",
-      ],
-      filters: {
-        type: CampaignTypeEnum.FlashSale,
+    const now = new Date();
+
+    // Find the custom campaign type by campaign ID
+    const customCampaignTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({
         campaign_id: id,
-      },
-    });
+      });
+
+    if (customCampaignTypes.length === 0) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        `Campaign with ID ${id} not found`
+      );
+    }
 
-    const campaign = customCampaignTypes.campaign;
+    const campaignType = customCampaignTypes[0].type;
+
+    // Get campaign from promotion service
+    const promotionService = container.resolve(Modules.PROMOTION);
+    const campaign = await promotionService.retrieveCampaign(id, {
+      relations: ["promotions", "promotions.application_method", "promotions.application_method.target_rules"],
+    });
 
     if (!campaign) {
       throw new MedusaError(
         MedusaError.Types.NOT_FOUND,
-        `Flash sale with ID ${id} not found`
+        `Campaign with ID ${id} not found`
       );
     }
 
-    // Fetch promotion usage limits for the campaign
-    const { data: promotionUsageLimits } = await query.graph({
-      entity: "promotion_usage_limit",
-      fields: ["id", "promotion_id", "product_id", "limit", "used"],
-      filters: {
-        campaign_id: id,
-      },
-    });
+    // Check if campaign is active
+    const startsAt = new Date(campaign.starts_at);
+    const endsAt = new Date(campaign.ends_at);
+    const isActive = startsAt <= now && endsAt >= now;
 
-    // Create a map of promotion usage limits by promotion ID
-    const promotionLimitsMap = new Map();
-    promotionUsageLimits.forEach((limit) => {
-      promotionLimitsMap.set(limit.promotion_id, limit);
-    });
+    if (!isActive) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_ALLOWED,
+        "This campaign is not currently active"
+      );
+    }
+
+    // Handle different campaign types
+    if (campaignType === CampaignTypeEnum.FlashSale) {
+      // Fetch promotion usage limits for Flash Sale
+      const promotionUsageLimits =
+        await customCampaignModuleService.listPromotionUsageLimits({
+          campaign_id: id,
+        });
 
-    // Process promotions to extract product information
-    const products: CustomCampaign["products"] = [];
-    for await (const promotion of campaign.promotions ?? []) {
-      if (!promotion.application_method?.target_rules?.length) {
-        continue;
+      // 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
+      const products: CustomCampaign["products"] = [];
+      for await (const promotion of campaign.promotions ?? []) {
+        if (!promotion.application_method?.target_rules?.length) {
+          continue;
+        }
+
+        const promotionLimit = promotionLimitsMap.get(promotion.id);
+        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,
+            discountValue: promotion.application_method?.value,
+            maxQty: promotion.application_method?.max_quantity,
+            limit: promotionLimit?.limit,
+            used: promotionLimit?.used,
+            remaining: promotionLimit?.limit
+              ? promotionLimit.limit - promotionLimit.used
+              : null,
+          });
+        }
       }
 
-      const productRule = promotion.application_method.target_rules.find(
-        (rule) =>
-          rule.attribute === "items.product.id" && rule.operator === "eq"
+      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,
+        products,
+      });
+    } else if (campaignType === CampaignTypeEnum.BuyXGetY) {
+      // Get BOGO configs for this campaign
+      const buyXGetYConfigs =
+        await customCampaignModuleService.listBuyXGetYConfigs({
+          campaign_id: id,
+        });
+
+      // Filter out configs that have reached their limit
+      const availableConfigs = buyXGetYConfigs.filter(
+        (config) => !config.limit || config.used < config.limit
       );
-      const promotionLimit = promotionLimitsMap.get(promotion.id);
 
-      const product = await productService.retrieveProduct(
-        promotionLimit?.product_id
+      // Build rules with product details
+      const rules = await Promise.all(
+        availableConfigs.map(async (config) => {
+          const [triggerProduct, rewardProduct] = await Promise.all([
+            productService.retrieveProduct(config.trigger_product_id, {
+              select: ["id", "title", "description", "thumbnail", "handle"],
+              relations: ["images"],
+            }),
+            productService.retrieveProduct(config.reward_product_id, {
+              select: ["id", "title", "description", "thumbnail", "handle"],
+              relations: ["images"],
+            }),
+          ]);
+
+          return {
+            id: config.id,
+            triggerProduct: {
+              id: triggerProduct.id,
+              title: triggerProduct.title,
+              description: triggerProduct.description,
+              thumbnail: triggerProduct.thumbnail,
+              handle: triggerProduct.handle,
+              images: triggerProduct.images,
+            },
+            triggerQuantity: config.trigger_quantity,
+            rewardProduct: {
+              id: rewardProduct.id,
+              title: rewardProduct.title,
+              description: rewardProduct.description,
+              thumbnail: rewardProduct.thumbnail,
+              handle: rewardProduct.handle,
+              images: rewardProduct.images,
+            },
+            rewardQuantity: config.reward_quantity,
+            rewardType: config.reward_type,
+            rewardValue: config.reward_value,
+            remaining: config.limit ? config.limit - config.used : null,
+          };
+        })
       );
 
-      if (productRule && promotion.application_method.value) {
-        products.push({
-          product: {
-            id: product.id,
-            title: product.title,
-          },
-          discountType: promotion.application_method?.type,
-          discountValue: promotion.application_method?.value,
-          maxQty: promotion.application_method?.max_quantity,
-          limit: promotionLimitsMap.get(promotion.id)?.limit,
-        });
-      }
+      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,
+        rules,
+      });
+    } else {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Unknown campaign type"
+      );
     }
-
-    const campaignData = {
-      id: campaign.id,
-      name: campaign.name,
-      description: campaign.description,
-      type: campaign.type,
-      startsAt: campaign.starts_at,
-      endsAt: campaign.ends_at,
-    };
-
-    const productData = products.map((product) => ({
-      id: product.product.id,
-      title: product.product.title,
-      discountType: product.discountType,
-      discountValue: product.discountValue,
-      maxQty: product.maxQty,
-      limit: product.limit,
-    }));
-
-    res.status(200).json({
-      ...campaignData,
-      products: productData,
-    });
   } catch (error) {
     if (error instanceof MedusaError) {
       throw error;
     }
 
-    console.error("Error fetching flash sale:", error);
+    console.error("Error fetching campaign:", error);
     throw new MedusaError(
       MedusaError.Types.UNEXPECTED_STATE,
-      "An error occurred while fetching the flash sale"
+      "An error occurred while fetching the campaign"
     );
   }
 };

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

@@ -1,36 +1,147 @@
 import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
-import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { ContainerRegistrationKeys, 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";
 
+/**
+ * GET handler for listing all active campaigns (Flash Sales + Buy X Get Y) for storefront
+ */
 export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
-  const query = container.resolve(ContainerRegistrationKeys.QUERY);
-  const {
-    data: customCampaigns,
-    metadata: { count, take, skip } = {
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const promotionService = container.resolve(Modules.PROMOTION);
+  const now = new Date();
+
+  try {
+    // Get the campaign type filter from query params (optional)
+    const campaignType = req.query?.type as CampaignTypeEnum | undefined;
+
+    const filters: any = {};
+    if (campaignType && Object.values(CampaignTypeEnum).includes(campaignType)) {
+      filters.type = campaignType;
+    }
+
+    console.log("=== Store Campaigns Debug ===");
+    console.log("Current time:", now.toISOString());
+    console.log("Requested type filter:", campaignType);
+
+    // Get all custom campaign types (including soft deleted check)
+    const allCustomCampaignTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({});
+
+    console.log(`Total custom campaign types (unfiltered): ${allCustomCampaignTypes.length}`);
+    allCustomCampaignTypes.forEach(ct => {
+      console.log(`  - Type: ${ct.type}, Campaign ID: ${ct.campaign_id}, Deleted: ${ct.deleted_at}`);
+    });
+
+    // Apply filters
+    const customCampaignTypes = filters.type
+      ? allCustomCampaignTypes.filter(ct => ct.type === filters.type && !ct.deleted_at)
+      : allCustomCampaignTypes.filter(ct => !ct.deleted_at);
+
+    console.log(`Filtered custom campaign types: ${customCampaignTypes.length}`);
+
+    if (customCampaignTypes.length === 0) {
+      console.log("No custom campaign types found after filtering");
+      return res.status(200).json({
+        campaigns: [],
+        count: 0,
+        limit: 20,
+        offset: 0,
+        debug: {
+          message: "No custom campaign types found",
+          filters: filters,
+          totalUnfiltered: allCustomCampaignTypes.length
+        }
+      });
+    }
+
+    // Get campaign IDs
+    const campaignIds = customCampaignTypes.map((ct) => ct.campaign_id);
+    console.log("Campaign IDs to fetch:", JSON.stringify(campaignIds));
+
+    // Fetch ALL campaigns first for debugging
+    const allCampaigns = await promotionService.listCampaigns({});
+    console.log(`Total campaigns in system: ${allCampaigns.length}`);
+
+    // Then fetch specific campaigns
+    const campaigns = campaignIds.length > 0
+      ? allCampaigns.filter((c: any) => campaignIds.includes(c.id))
+      : [];
+
+    console.log(`Found ${campaigns.length} matching campaigns`);
+    campaigns.forEach((c: any) => {
+      console.log(`  Campaign: ${c.name} (${c.id})`);
+      console.log(`    Starts: ${c.starts_at}`);
+      console.log(`    Ends: ${c.ends_at}`);
+    });
+
+    // Create a map of campaign_id to campaign_type
+    const campaignTypeMap = new Map(
+      customCampaignTypes.map((ct) => [ct.campaign_id, ct.type])
+    );
+
+    // 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
+      };
+    });
+
+    // Filter for active campaigns
+    const activeCampaigns = allProcessedCampaigns.filter(c => c.is_active);
+
+    console.log(`Returning ${activeCampaigns.length} active campaigns out of ${allProcessedCampaigns.length} total`);
+
+    res.status(200).json({
+      campaigns: activeCampaigns,
+      count: activeCampaigns.length,
+      limit: 20,
+      offset: 0,
+      debug: {
+        currentTime: now.toISOString(),
+        totalCustomCampaignTypes: allCustomCampaignTypes.length,
+        filteredCustomCampaignTypes: customCampaignTypes.length,
+        totalCampaigns: allCampaigns.length,
+        matchingCampaigns: campaigns.length,
+        allProcessedCampaigns: allProcessedCampaigns.length,
+        activeCampaigns: activeCampaigns.length,
+        inactiveCampaigns: allProcessedCampaigns.filter(c => !c.is_active).map(c => ({
+          name: c.name,
+          starts_at: c.starts_at,
+          ends_at: c.ends_at,
+          reason: new Date(c.starts_at) > now ? 'not_started' : 'ended'
+        }))
+      }
+    });
+  } catch (error) {
+    console.error("Error fetching campaigns for storefront:", error);
+    console.error("Stack:", error instanceof Error ? error.stack : 'No stack');
+    res.status(500).json({
+      campaigns: [],
       count: 0,
-      take: 20,
-      skip: 0,
-    },
-  } = await query.graph({
-    entity: "custom_campaign_type",
-    ...req.queryConfig,
-    fields: [
-      "id",
-      "campaign.name",
-      "campaign.description",
-      "campaign.type",
-      "campaign.starts_at",
-      "campaign.ends_at",
-    ],
-    filters: { type: CampaignTypeEnum.FlashSale },
-  });
-
-  const campaigns = customCampaigns.map((campaign) => campaign.campaign);
-
-  res.status(200).json({
-    campaigns,
-    count,
-    limit: take,
-    offset: skip,
-  });
+      limit: 20,
+      offset: 0,
+      error: "Failed to fetch campaigns",
+      details: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined
+    });
+  }
 };

package/src/index.ts

@@ -0,0 +1,10 @@
+import CustomCampaignModule from "./modules/custom-campaigns";
+
+// Export the module so MedusaJS can load it
+export default {
+  modules: [CustomCampaignModule],
+};
+
+// Also export individual modules for direct import
+export { CustomCampaignModule };
+export { CUSTOM_CAMPAIGN_MODULE } from "./modules/custom-campaigns";

package/src/modules/custom-campaigns/migrations/Migration20251018000000.ts

@@ -0,0 +1,42 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20251018000000 extends Migration {
+
+  override async up(): Promise<void> {
+    // Update custom_campaign_type enum to include 'buy-x-get-y'
+    this.addSql(`alter table if exists "custom_campaign_type" drop constraint if exists "custom_campaign_type_type_check";`);
+    this.addSql(`alter table if exists "custom_campaign_type" add constraint "custom_campaign_type_type_check" check ("type" in ('flash-sale', 'buy-x-get-y'));`);
+
+    // Create buy_x_get_y_config table
+    this.addSql(`create table if not exists "buy_x_get_y_config" (
+      "id" text not null,
+      "campaign_id" text not null,
+      "promotion_id" text not null,
+      "trigger_product_id" text not null,
+      "trigger_quantity" integer not null,
+      "reward_product_id" text not null,
+      "reward_quantity" integer not null,
+      "reward_type" text check ("reward_type" in ('free', 'percentage', 'fixed')) not null,
+      "reward_value" integer null,
+      "limit" integer null,
+      "used" integer not null default 0,
+      "created_at" timestamptz not null default now(),
+      "updated_at" timestamptz not null default now(),
+      "deleted_at" timestamptz null,
+      constraint "buy_x_get_y_config_pkey" primary key ("id")
+    );`);
+
+    this.addSql(`CREATE UNIQUE INDEX IF NOT EXISTS "IDX_buy_x_get_y_config_campaign_promotion" ON "buy_x_get_y_config" (campaign_id, promotion_id) WHERE deleted_at IS NULL;`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_buy_x_get_y_config_deleted_at" ON "buy_x_get_y_config" (deleted_at) WHERE deleted_at IS NULL;`);
+  }
+
+  override async down(): Promise<void> {
+    // Drop buy_x_get_y_config table
+    this.addSql(`drop table if exists "buy_x_get_y_config" cascade;`);
+
+    // Revert custom_campaign_type enum
+    this.addSql(`alter table if exists "custom_campaign_type" drop constraint if exists "custom_campaign_type_type_check";`);
+    this.addSql(`alter table if exists "custom_campaign_type" add constraint "custom_campaign_type_type_check" check ("type" in ('flash-sale'));`);
+  }
+
+}

package/src/modules/custom-campaigns/models/buy-x-get-y-config.ts

@@ -0,0 +1,19 @@
+import { model } from "@medusajs/framework/utils";
+
+const BuyXGetYConfig = model
+  .define("buy_x_get_y_config", {
+    id: model.id().primaryKey(),
+    campaign_id: model.text(),
+    promotion_id: model.text(),
+    trigger_product_id: model.text(),
+    trigger_quantity: model.number(),
+    reward_product_id: model.text(),
+    reward_quantity: model.number(),
+    reward_type: model.enum(["free", "percentage", "fixed"]),
+    reward_value: model.number().nullable(),
+    limit: model.number().nullable(),
+    used: model.number().default(0),
+  })
+  .indexes([{ on: ["campaign_id", "promotion_id"], unique: true }]);
+
+export default BuyXGetYConfig;

package/src/modules/custom-campaigns/service.ts

@@ -1,10 +1,12 @@
 import { MedusaService } from "@medusajs/framework/utils";
 import CustomCampaignType from "./models/custom-campaign-type";
 import PromotionUsageLimit from "./models/promotion-usage-limit";
+import BuyXGetYConfig from "./models/buy-x-get-y-config";
 
 class CustomCampaignModuleService extends MedusaService({
   CustomCampaignType,
   PromotionUsageLimit,
+  BuyXGetYConfig,
 }) {}
 
 export default CustomCampaignModuleService;

package/src/modules/custom-campaigns/types/campaign-type.enum.ts

@@ -1,3 +1,4 @@
 export enum CampaignTypeEnum {
   FlashSale = "flash-sale",
+  BuyXGetY = "buy-x-get-y",
 }

package/src/subscribers/cart-updated.ts

@@ -0,0 +1,23 @@
+import type { SubscriberArgs, SubscriberConfig } from "@medusajs/framework";
+import { applyBuyXGetYToCartWorkflow } from "../workflows/buy-x-get-y/applyBuyXGetYToCartWorkflow";
+
+export default async function handleCartUpdated({
+  event: { data },
+}: SubscriberArgs<{ id: string }>) {
+  // Apply Buy X Get Y rules to the cart
+  await applyBuyXGetYToCartWorkflow.run({
+    input: {
+      cart_id: data.id,
+    },
+  });
+}
+
+export const config: SubscriberConfig = {
+  event: [
+    "cart.updated",
+    "cart.created",
+    "cart-line-item.created",
+    "cart-line-item.updated",
+    "cart-line-item.deleted",
+  ],
+};

package/src/subscribers/order-placed.ts

@@ -1,15 +1,23 @@
 import { SubscriberArgs, type SubscriberConfig } from "@medusajs/framework";
 import { updatePromotionUsageWorkflow } from "../workflows/custom-campaign/updatePromotionUsageWorkflow";
+import { updateBuyXGetYUsageWorkflow } from "../workflows/custom-campaign/updateBuyXGetYUsageWorkflow";
 
 export default async function updatePromotionUsage({
   event: { data },
 }: SubscriberArgs<{ id: string }>) {
-  // update promotion usage
+  // update promotion usage for flash sales
   await updatePromotionUsageWorkflow.run({
     input: {
       order_id: data.id,
     },
   });
+
+  // update promotion usage for Buy X Get Y campaigns
+  await updateBuyXGetYUsageWorkflow.run({
+    input: {
+      order_id: data.id,
+    },
+  });
 }
 
 export const config: SubscriberConfig = {