@lodashventure/medusa-campaign 1.1.5 → 1.1.7

package/src/api/admin/test-campaign/route.ts

@@ -0,0 +1,141 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import { Modules } from "@medusajs/framework/utils";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../../modules/custom-campaigns/service";
+import { CampaignTypeEnum } from "../../../modules/custom-campaigns/types/campaign-type.enum";
+import { createBuyXGetYCampaignWorkflow } from "../../../workflows/custom-campaign/createBuyXGetYCampaignWorkflow";
+
+/**
+ * POST handler to create a test Buy X Get Y campaign
+ * This creates a campaign with test data to verify the system is working
+ */
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const productService = container.resolve(Modules.PRODUCT);
+
+  try {
+    // Get first two products from the system
+    const products = await productService.listProducts({}, { take: 2 });
+
+    if (products.length < 2) {
+      return res.status(400).json({
+        error: "Need at least 2 products in the system to create a test campaign",
+        productsFound: products.length
+      });
+    }
+
+    const [triggerProduct, rewardProduct] = products;
+
+    // Create a test campaign that is active for the whole year
+    const testCampaignData = {
+      name: `Test BOGO Campaign ${Date.now()}`,
+      description: "Test Buy 1 Get 1 Free campaign for debugging",
+      type: CampaignTypeEnum.BuyXGetY,
+      starts_at: new Date("2024-01-01T00:00:00Z"),
+      ends_at: new Date("2025-12-31T23:59:59Z"),
+      rules: [
+        {
+          triggerProduct: {
+            id: triggerProduct.id,
+            title: triggerProduct.title || "Test Product A"
+          },
+          triggerQuantity: 1,
+          rewardProduct: {
+            id: rewardProduct.id,
+            title: rewardProduct.title || "Test Product B"
+          },
+          rewardQuantity: 1,
+          rewardType: "free" as const,
+          rewardValue: undefined,
+          limit: undefined
+        }
+      ]
+    };
+
+    console.log("Creating test campaign with data:", JSON.stringify(testCampaignData, null, 2));
+
+    const result = await createBuyXGetYCampaignWorkflow.run({
+      input: testCampaignData
+    });
+
+    console.log("Test campaign created successfully:", result);
+
+    res.status(201).json({
+      success: true,
+      message: "Test campaign created successfully",
+      campaign: result.result?.campaign,
+      promotions: result.result?.promotions,
+      configs: result.result?.buyXGetYConfigs,
+      testData: {
+        triggerProduct: {
+          id: triggerProduct.id,
+          title: triggerProduct.title
+        },
+        rewardProduct: {
+          id: rewardProduct.id,
+          title: rewardProduct.title
+        }
+      }
+    });
+  } catch (error) {
+    console.error("Error creating test campaign:", error);
+    res.status(500).json({
+      error: "Failed to create test campaign",
+      details: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined
+    });
+  }
+};
+
+/**
+ * GET handler to verify test campaign exists
+ */
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  try {
+    // Get all Buy X Get Y campaigns
+    const customCampaignTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({
+        type: CampaignTypeEnum.BuyXGetY
+      });
+
+    const campaignDetails = [];
+
+    for (const ct of customCampaignTypes) {
+      try {
+        const campaign = await promotionService.retrieveCampaign(ct.campaign_id);
+        const configs = await customCampaignModuleService.listBuyXGetYConfigs({
+          campaign_id: ct.campaign_id
+        });
+
+        campaignDetails.push({
+          customCampaignType: ct,
+          campaign: {
+            id: campaign.id,
+            name: campaign.name,
+            description: campaign.description,
+            starts_at: campaign.starts_at,
+            ends_at: campaign.ends_at,
+            campaign_identifier: campaign.campaign_identifier
+          },
+          bogoConfigs: configs
+        });
+      } catch (e) {
+        console.error(`Error fetching campaign ${ct.campaign_id}:`, e);
+      }
+    }
+
+    res.status(200).json({
+      totalBuyXGetYCampaigns: customCampaignTypes.length,
+      campaigns: campaignDetails
+    });
+  } catch (error) {
+    console.error("Error verifying test campaigns:", error);
+    res.status(500).json({
+      error: "Failed to verify test campaigns",
+      details: error instanceof Error ? error.message : String(error)
+    });
+  }
+};

package/src/api/store/buy-x-get-y/[id]/route.ts

@@ -0,0 +1,146 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import { MedusaError, 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 fetching a specific Buy X Get Y campaign for storefront
+ */
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const { id } = req.params;
+
+  if (!id) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Campaign ID is required"
+    );
+  }
+
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const productService = container.resolve(Modules.PRODUCT);
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  try {
+    const now = new Date();
+
+    // Find the custom campaign type by campaign ID
+    const customCampaignTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({
+        type: CampaignTypeEnum.BuyXGetY,
+        campaign_id: id,
+      });
+
+    if (customCampaignTypes.length === 0) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        `Buy X Get Y campaign with ID ${id} not found`
+      );
+    }
+
+    // Get campaign from promotion service
+    const campaign = await promotionService.retrieveCampaign(id);
+
+    if (!campaign) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        `Buy X Get Y campaign with ID ${id} not found`
+      );
+    }
+
+    // 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;
+
+    if (!isActive) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_ALLOWED,
+        "This campaign is not currently active"
+      );
+    }
+
+    // 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
+    );
+
+    if (availableConfigs.length === 0) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_ALLOWED,
+        "This campaign has no available promotions"
+      );
+    }
+
+    // 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", "variants"],
+          }),
+          productService.retrieveProduct(config.reward_product_id, {
+            select: ["id", "title", "description", "thumbnail", "handle"],
+            relations: ["images", "variants"],
+          }),
+        ]);
+
+        return {
+          id: config.id,
+          triggerProduct: {
+            id: triggerProduct.id,
+            title: triggerProduct.title,
+            description: triggerProduct.description,
+            thumbnail: triggerProduct.thumbnail,
+            handle: triggerProduct.handle,
+            images: triggerProduct.images,
+            variants: triggerProduct.variants,
+          },
+          triggerQuantity: config.trigger_quantity,
+          rewardProduct: {
+            id: rewardProduct.id,
+            title: rewardProduct.title,
+            description: rewardProduct.description,
+            thumbnail: rewardProduct.thumbnail,
+            handle: rewardProduct.handle,
+            images: rewardProduct.images,
+            variants: rewardProduct.variants,
+          },
+          rewardQuantity: config.reward_quantity,
+          rewardType: config.reward_type,
+          rewardValue: config.reward_value,
+          remaining: config.limit ? config.limit - config.used : null,
+        };
+      })
+    );
+
+    res.status(200).json({
+      campaign: {
+        id: campaign.id,
+        name: campaign.name,
+        description: campaign.description,
+        starts_at: campaign.starts_at,
+        ends_at: campaign.ends_at,
+        rules,
+      },
+    });
+  } catch (error) {
+    if (error instanceof MedusaError) {
+      throw error;
+    }
+
+    console.error("Error fetching Buy X Get Y campaign:", error);
+    throw new MedusaError(
+      MedusaError.Types.UNEXPECTED_STATE,
+      "An error occurred while fetching the campaign"
+    );
+  }
+};

package/src/api/store/buy-x-get-y/products/[productId]/route.ts

@@ -0,0 +1,129 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import { MedusaError, Modules } from "@medusajs/framework/utils";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../../../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../../../../modules/custom-campaigns/service";
+import { CampaignTypeEnum } from "../../../../../modules/custom-campaigns/types/campaign-type.enum";
+
+/**
+ * GET handler to check if a product has any active BOGO promotions
+ * Useful for displaying BOGO badges on product cards and detail pages
+ */
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const { productId } = req.params;
+
+  if (!productId) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Product ID is required"
+    );
+  }
+
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const productService = container.resolve(Modules.PRODUCT);
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  try {
+    const now = new Date();
+
+    // Verify product exists
+    await productService.retrieveProduct(productId, {
+      select: ["id"],
+    });
+
+    // Get all BOGO configs where this product is the trigger
+    const buyXGetYConfigs =
+      await customCampaignModuleService.listBuyXGetYConfigs({
+        trigger_product_id: productId,
+      });
+
+    if (buyXGetYConfigs.length === 0) {
+      return res.status(200).json({
+        has_promotions: false,
+        promotions: [],
+      });
+    }
+
+    // Get campaign details for each config
+    const campaignIds = Array.from(
+      new Set(buyXGetYConfigs.map((config) => config.campaign_id))
+    );
+
+    const campaigns = await promotionService.listCampaigns({
+      id: campaignIds,
+    });
+
+    // Filter for active campaigns
+    const activeCampaignIds = new Set(
+      campaigns
+        .filter((campaign: any) => {
+          const startsAt = new Date(campaign.starts_at);
+          const endsAt = new Date(campaign.ends_at);
+          return startsAt <= now && endsAt >= now;
+        })
+        .map((campaign: any) => campaign.id)
+    );
+
+    // Filter configs by active campaigns and availability
+    const activeConfigs = buyXGetYConfigs.filter(
+      (config) =>
+        activeCampaignIds.has(config.campaign_id) &&
+        (!config.limit || config.used < config.limit)
+    );
+
+    if (activeConfigs.length === 0) {
+      return res.status(200).json({
+        has_promotions: false,
+        promotions: [],
+      });
+    }
+
+    // Build promotion details
+    const promotions = await Promise.all(
+      activeConfigs.map(async (config) => {
+        const campaign = campaigns.find(
+          (c: any) => c.id === config.campaign_id
+        );
+
+        const rewardProduct = await productService.retrieveProduct(
+          config.reward_product_id,
+          {
+            select: ["id", "title", "thumbnail", "handle"],
+          }
+        );
+
+        return {
+          campaign_id: campaign.id,
+          campaign_name: campaign.name,
+          trigger_quantity: config.trigger_quantity,
+          reward_product: {
+            id: rewardProduct.id,
+            title: rewardProduct.title,
+            thumbnail: rewardProduct.thumbnail,
+            handle: rewardProduct.handle,
+          },
+          reward_quantity: config.reward_quantity,
+          reward_type: config.reward_type,
+          reward_value: config.reward_value,
+          remaining: config.limit ? config.limit - config.used : null,
+          ends_at: campaign.ends_at,
+        };
+      })
+    );
+
+    res.status(200).json({
+      has_promotions: true,
+      promotions,
+    });
+  } catch (error) {
+    if (error instanceof MedusaError) {
+      throw error;
+    }
+
+    console.error("Error checking product BOGO promotions:", error);
+    throw new MedusaError(
+      MedusaError.Types.UNEXPECTED_STATE,
+      "An error occurred while checking promotions"
+    );
+  }
+};

package/src/api/store/buy-x-get-y/route.ts

@@ -0,0 +1,134 @@
+import { container, MedusaRequest, MedusaResponse } 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";
+
+/**
+ * GET handler for listing active Buy X Get Y campaigns for storefront
+ */
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const productService = container.resolve(Modules.PRODUCT);
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  try {
+    const now = new Date();
+
+    // Get all Buy X Get Y campaign types
+    const customCampaignTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({
+        type: CampaignTypeEnum.BuyXGetY,
+      });
+
+    console.log(`Found ${customCampaignTypes.length} Buy X Get Y campaign types`);
+
+    if (customCampaignTypes.length === 0) {
+      return res.status(200).json({
+        campaigns: [],
+        count: 0,
+        limit: 20,
+        offset: 0,
+      });
+    }
+
+    // Get campaign IDs
+    const campaignIds = customCampaignTypes.map((ct) => ct.campaign_id);
+
+    // Fetch campaigns from promotion service
+    const allCampaigns = await promotionService.listCampaigns({
+      id: campaignIds,
+    });
+
+    // Filter for active campaigns only (time-based)
+    const activeCampaigns = allCampaigns.filter((campaign: any) => {
+      const startsAt = new Date(campaign.starts_at);
+      const endsAt = new Date(campaign.ends_at);
+      return startsAt <= now && endsAt >= now;
+    });
+
+    // Enrich with BOGO configuration details
+    const enrichedCampaigns = await Promise.all(
+      activeCampaigns.map(async (campaign: any) => {
+        // Get BOGO configs for this campaign
+        const buyXGetYConfigs =
+          await customCampaignModuleService.listBuyXGetYConfigs({
+            campaign_id: campaign.id,
+          });
+
+        // Filter out configs that have reached their limit
+        const availableConfigs = buyXGetYConfigs.filter(
+          (config) => !config.limit || config.used < config.limit
+        );
+
+        if (availableConfigs.length === 0) {
+          return null; // Skip campaigns with no available rules
+        }
+
+        // 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", "thumbnail", "handle"],
+              }),
+              productService.retrieveProduct(config.reward_product_id, {
+                select: ["id", "title", "thumbnail", "handle"],
+              }),
+            ]);
+
+            return {
+              id: config.id,
+              triggerProduct: {
+                id: triggerProduct.id,
+                title: triggerProduct.title,
+                thumbnail: triggerProduct.thumbnail,
+                handle: triggerProduct.handle,
+              },
+              triggerQuantity: config.trigger_quantity,
+              rewardProduct: {
+                id: rewardProduct.id,
+                title: rewardProduct.title,
+                thumbnail: rewardProduct.thumbnail,
+                handle: rewardProduct.handle,
+              },
+              rewardQuantity: config.reward_quantity,
+              rewardType: config.reward_type,
+              rewardValue: config.reward_value,
+              remaining: config.limit ? config.limit - config.used : null,
+            };
+          })
+        );
+
+        return {
+          id: campaign.id,
+          name: campaign.name,
+          description: campaign.description,
+          starts_at: campaign.starts_at,
+          ends_at: campaign.ends_at,
+          rules,
+        };
+      })
+    );
+
+    // Filter out null campaigns (those with no available rules)
+    const validCampaigns = enrichedCampaigns.filter((c) => c !== null);
+
+    res.status(200).json({
+      campaigns: validCampaigns,
+      count: validCampaigns.length,
+      limit: take,
+      offset: skip,
+    });
+  } catch (error) {
+    console.error("Error fetching Buy X Get Y campaigns for storefront:", error);
+    res.status(500).json({
+      campaigns: [],
+      count: 0,
+      limit: 20,
+      offset: 0,
+      error: "Failed to fetch campaigns",
+    });
+  }
+};