@lodashventure/medusa-campaign 1.1.4 → 1.1.6

package/src/workflows/buy-x-get-y/applyBuyXGetYToCartWorkflow.ts

@@ -0,0 +1,222 @@
+import { container } from "@medusajs/framework";
+import { Modules } from "@medusajs/framework/utils";
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+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";
+
+interface ApplyBuyXGetYInput {
+  cart_id: string;
+}
+
+interface RewardItem {
+  product_id: string;
+  variant_id: string;
+  quantity: number;
+  metadata?: {
+    is_bogo_reward?: boolean;
+    bogo_config_id?: string;
+    reward_type?: string;
+    reward_value?: number;
+  };
+}
+
+const applyBuyXGetYToCartStep = createStep(
+  "apply-buy-x-get-y-to-cart-step",
+  async (data: ApplyBuyXGetYInput) => {
+    const customCampaignModuleService =
+      container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+    const cartService = container.resolve(Modules.CART);
+    const productService = container.resolve(Modules.PRODUCT);
+    const linkService = container.resolve("linkModuleService");
+
+    // Fetch the cart with items
+    const cart = await cartService.retrieve(data.cart_id, {
+      relations: ["items", "items.variant", "items.product"],
+    });
+
+    if (!cart || !cart.items || cart.items.length === 0) {
+      return new StepResponse({ rewardItemsAdded: [] });
+    }
+
+    // Get all active Buy X Get Y campaigns
+    const now = new Date();
+    const campaignTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({
+        type: CampaignTypeEnum.BuyXGetY,
+      });
+
+    if (campaignTypes.length === 0) {
+      return new StepResponse({ rewardItemsAdded: [] });
+    }
+
+    // Get campaigns through link service
+    const campaignLinks = await linkService.list({
+      [CUSTOM_CAMPAIGN_MODULE]: {
+        custom_campaign_type_id: campaignTypes.map((ct) => ct.id),
+      },
+    });
+
+    const campaignIds = campaignLinks.map(
+      (link: any) => link[Modules.PROMOTION].campaign_id
+    );
+
+    const promotionService = container.resolve(Modules.PROMOTION);
+    const campaigns = await promotionService.listCampaigns({
+      id: campaignIds,
+    });
+
+    // Filter active campaigns
+    const activeCampaigns = campaigns.filter(
+      (campaign: any) =>
+        new Date(campaign.starts_at) <= now &&
+        new Date(campaign.ends_at) >= now
+    );
+
+    if (activeCampaigns.length === 0) {
+      return new StepResponse({ rewardItemsAdded: [] });
+    }
+
+    // Get BOGO configurations for active campaigns
+    const buyXGetYConfigs =
+      await customCampaignModuleService.listBuyXGetYConfigs({
+        campaign_id: activeCampaigns.map((c: any) => c.id),
+      });
+
+    // Remove ALL existing BOGO reward items to recalculate from scratch
+    const existingBogoItems = cart.items.filter(
+      (item: any) => item.metadata?.is_bogo_reward === true
+    );
+
+    const removedItemIds: string[] = [];
+    for (const bogoItem of existingBogoItems) {
+      try {
+        await cartService.removeLineItems(data.cart_id, [bogoItem.id]);
+        removedItemIds.push(bogoItem.id);
+      } catch (error) {
+        console.error(`Failed to remove existing BOGO item:`, error);
+      }
+    }
+
+    // Group cart items by product (excluding BOGO items which are now removed)
+    const cartItemsByProduct = new Map<string, any[]>();
+    cart.items.forEach((item: any) => {
+      if (item.metadata?.is_bogo_reward) return; // Skip BOGO items (should be none now)
+      const productId = item.product_id;
+      if (!cartItemsByProduct.has(productId)) {
+        cartItemsByProduct.set(productId, []);
+      }
+      cartItemsByProduct.get(productId)!.push(item);
+    });
+
+    const rewardItemsToAdd: RewardItem[] = [];
+
+    // Check each BOGO configuration
+    for (const config of buyXGetYConfigs) {
+      // Check if usage limit reached
+      if (config.limit && config.used >= config.limit) {
+        continue;
+      }
+
+      // Get cart items for the trigger product
+      const triggerItems = cartItemsByProduct.get(config.trigger_product_id);
+      if (!triggerItems || triggerItems.length === 0) {
+        continue;
+      }
+
+      // Calculate total quantity of trigger product
+      const totalTriggerQuantity = triggerItems.reduce(
+        (sum, item) => sum + item.quantity,
+        0
+      );
+
+      // Check if trigger quantity is met
+      if (totalTriggerQuantity >= config.trigger_quantity) {
+        // Calculate how many times the reward should be given
+        const rewardMultiplier = Math.floor(
+          totalTriggerQuantity / config.trigger_quantity
+        );
+        const totalRewardQuantity = config.reward_quantity * rewardMultiplier;
+
+        // Get the reward product's default variant
+        const rewardProduct = await productService.retrieveProduct(
+          config.reward_product_id,
+          {
+            relations: ["variants"],
+          }
+        );
+
+        if (!rewardProduct.variants || rewardProduct.variants.length === 0) {
+          console.warn(
+            `No variants found for reward product ${config.reward_product_id}`
+          );
+          continue;
+        }
+
+        const defaultVariant = rewardProduct.variants[0];
+
+        rewardItemsToAdd.push({
+          product_id: config.reward_product_id,
+          variant_id: defaultVariant.id,
+          quantity: totalRewardQuantity,
+          metadata: {
+            is_bogo_reward: true,
+            bogo_config_id: config.id,
+            reward_type: config.reward_type,
+            reward_value: config.reward_value ?? undefined,
+          },
+        });
+      }
+    }
+
+    // Add reward items to cart
+    const addedItems: any[] = [];
+    for (const rewardItem of rewardItemsToAdd) {
+      try {
+        const addedItem = await cartService.addLineItems(data.cart_id, [
+          {
+            variant_id: rewardItem.variant_id,
+            quantity: rewardItem.quantity,
+            metadata: rewardItem.metadata,
+          },
+        ]);
+        addedItems.push(addedItem);
+      } catch (error) {
+        console.error(`Failed to add reward item:`, error);
+      }
+    }
+
+    return new StepResponse(
+      { rewardItemsAdded: addedItems },
+      { cart_id: data.cart_id, added_items: addedItems }
+    );
+  },
+  async (compensationData) => {
+    // Compensation: Remove added reward items if workflow fails
+    if (!compensationData || !compensationData.added_items) return;
+
+    const cartService = container.resolve(Modules.CART);
+
+    for (const item of compensationData.added_items) {
+      try {
+        await cartService.removeLineItems(compensationData.cart_id, [item.id]);
+      } catch (error) {
+        console.error(`Failed to remove reward item during compensation:`, error);
+      }
+    }
+  }
+);
+
+export const applyBuyXGetYToCartWorkflow = createWorkflow(
+  "apply-buy-x-get-y-to-cart",
+  (data: ApplyBuyXGetYInput) => {
+    const result = applyBuyXGetYToCartStep(data);
+
+    return new WorkflowResponse(result);
+  }
+);

package/src/workflows/custom-campaign/createBuyXGetYCampaignWorkflow.ts

@@ -0,0 +1,210 @@
+import { container } from "@medusajs/framework";
+import {
+  CampaignDTO,
+  CreateApplicationMethodDTO,
+  CreatePromotionDTO,
+  PromotionDTO,
+} from "@medusajs/framework/types";
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+  Modules,
+} from "@medusajs/framework/utils";
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import {
+  createCampaignsWorkflow,
+  createPromotionsWorkflow,
+  deleteCampaignsWorkflow,
+  deletePromotionsWorkflow,
+} from "@medusajs/medusa/core-flows";
+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";
+
+export interface BuyXGetYProduct {
+  triggerProduct: {
+    id: string;
+    title: string;
+  };
+  triggerQuantity: number;
+  rewardProduct: {
+    id: string;
+    title: string;
+  };
+  rewardQuantity: number;
+  rewardType: "free" | "percentage" | "fixed";
+  rewardValue?: number;
+  limit?: number;
+}
+
+export interface BuyXGetYCampaign {
+  name: string;
+  description: string;
+  type: CampaignTypeEnum.BuyXGetY;
+  starts_at: Date;
+  ends_at: Date;
+  rules: BuyXGetYProduct[];
+}
+
+const createBuyXGetYCampaignStep = createStep(
+  "create-buy-x-get-y-campaign-step",
+  async (data: BuyXGetYCampaign) => {
+    const link = container.resolve(ContainerRegistrationKeys.LINK);
+    const customCampaignModuleService =
+      container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+    const campaignIdentifier = `${data.type}-${Date.now()}`;
+
+    let campaign: CampaignDTO | undefined;
+    let promotions: PromotionDTO[] | undefined;
+    let customCampaignType:
+      | Awaited<
+          ReturnType<CustomCampaignModuleService["createCustomCampaignTypes"]>
+        >[number]
+      | undefined;
+    let buyXGetYConfigs:
+      | Awaited<
+          ReturnType<CustomCampaignModuleService["createBuyXGetYConfigs"]>
+        >
+      | undefined;
+
+    // Create campaign
+    const {
+      result: [_campaign],
+    } = await createCampaignsWorkflow.run({
+      input: {
+        campaignsData: [
+          {
+            name: data.name,
+            campaign_identifier: campaignIdentifier,
+            description: data.description,
+            starts_at: new Date(data.starts_at),
+            ends_at: new Date(data.ends_at),
+          },
+        ],
+      },
+    });
+    campaign = _campaign;
+
+    try {
+      // Create promotions for each BOGO rule
+      // Store BOGO configuration in promotion code for easy lookup
+      const { result: _promotions } = await createPromotionsWorkflow.run({
+        input: {
+          promotionsData: data.rules.map(
+            (rule) =>
+              ({
+                code: `${campaignIdentifier}-${rule.triggerProduct.id}-${rule.rewardProduct.id}`,
+                type: "buyget",
+                status: "active",
+                is_automatic: true,
+                campaign_id: campaign.id,
+                application_method: {
+                  target_type: "items",
+                  allocation: "each",
+                  type: rule.rewardType === "percentage" ? "percentage" : "fixed",
+                  value: rule.rewardType === "free" ? 0 : (rule.rewardValue ?? 0),
+                  buy_rules_min_quantity: rule.triggerQuantity,
+                  apply_to_quantity: rule.rewardQuantity,
+                  target_rules: [
+                    {
+                      attribute: "items.product.id",
+                      operator: "eq",
+                      values: [rule.triggerProduct.id],
+                    },
+                  ],
+                } satisfies CreateApplicationMethodDTO,
+              } satisfies CreatePromotionDTO)
+          ),
+        },
+      });
+      promotions = _promotions;
+
+      // Create custom campaign type
+      customCampaignType =
+        await customCampaignModuleService.createCustomCampaignTypes({
+          campaign_id: campaign.id,
+          type: data.type,
+        });
+
+      // Create Buy X Get Y configurations
+      buyXGetYConfigs =
+        await customCampaignModuleService.createBuyXGetYConfigs(
+          data.rules.map((rule, index) => ({
+            campaign_id: campaign.id,
+            promotion_id: promotions[index].id,
+            trigger_product_id: rule.triggerProduct.id,
+            trigger_quantity: rule.triggerQuantity,
+            reward_product_id: rule.rewardProduct.id,
+            reward_quantity: rule.rewardQuantity,
+            reward_type: rule.rewardType,
+            reward_value: rule.rewardValue ?? null,
+            limit: rule.limit ?? null,
+            used: 0,
+          }))
+        );
+
+      // Link campaign type
+      await link.create([
+        {
+          [Modules.PROMOTION]: {
+            campaign_id: campaign.id,
+          },
+          [CUSTOM_CAMPAIGN_MODULE]: {
+            custom_campaign_type_id: customCampaignType.id,
+          },
+        },
+      ]);
+
+      return new StepResponse({
+        campaign,
+        promotions,
+        buyXGetYConfigs,
+      });
+    } catch (error) {
+      console.log({ error });
+
+      // Cleanup on error
+      await deleteCampaignsWorkflow.run({
+        input: {
+          ids: campaign.id,
+        },
+      });
+
+      if (promotions) {
+        await deletePromotionsWorkflow.run({
+          input: {
+            ids: promotions.map((promotion) => promotion.id),
+          },
+        });
+      }
+
+      if (customCampaignType) {
+        await customCampaignModuleService.deleteCustomCampaignTypes(
+          customCampaignType.id
+        );
+      }
+
+      if (buyXGetYConfigs) {
+        await customCampaignModuleService.deleteBuyXGetYConfigs(
+          buyXGetYConfigs.map((config) => config.id)
+        );
+      }
+
+      throw error;
+    }
+  }
+);
+
+export const createBuyXGetYCampaignWorkflow = createWorkflow(
+  "create-buy-x-get-y-campaign",
+  (data: BuyXGetYCampaign) => {
+    const campaign = createBuyXGetYCampaignStep(data);
+
+    return new WorkflowResponse(campaign);
+  }
+);

package/src/workflows/custom-campaign/updateBuyXGetYCampaignWorkflow.ts

@@ -0,0 +1,190 @@
+import { container } from "@medusajs/framework";
+import {
+  CreateApplicationMethodDTO,
+  CreatePromotionDTO,
+  UpdateCampaignDTO,
+  UpdatePromotionDTO,
+} from "@medusajs/framework/types";
+import { MedusaError, Modules } from "@medusajs/framework/utils";
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import {
+  createPromotionsWorkflow,
+  deletePromotionsWorkflow,
+  updateCampaignsWorkflow,
+} from "@medusajs/medusa/core-flows";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../modules/custom-campaigns/service";
+import { BuyXGetYCampaign } from "./createBuyXGetYCampaignWorkflow";
+
+interface UpdateBuyXGetYInput extends BuyXGetYCampaign {
+  id: string;
+}
+
+const updateBuyXGetYCampaignStep = createStep(
+  "update-buy-x-get-y-campaign-step",
+  async (data: UpdateBuyXGetYInput) => {
+    const campaign_id = data.id;
+
+    const customCampaignModuleService =
+      container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+    const promotionService = container.resolve(Modules.PROMOTION);
+
+    if (!campaign_id) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Campaign ID is required"
+      );
+    }
+
+    // Fetch the existing campaign
+    const campaign = await promotionService.retrieveCampaign(campaign_id);
+
+    // Fetch existing Buy X Get Y configurations
+    const existingConfigs =
+      await customCampaignModuleService.listBuyXGetYConfigs({
+        campaign_id: campaign_id,
+      });
+
+    // Create maps for existing configs
+    const existingConfigMapByKey = new Map(
+      existingConfigs.map((config) => [
+        `${config.trigger_product_id}-${config.reward_product_id}`,
+        config,
+      ])
+    );
+
+    const rulesToCreate = data.rules.filter(
+      (rule) =>
+        !existingConfigMapByKey.has(
+          `${rule.triggerProduct.id}-${rule.rewardProduct.id}`
+        )
+    );
+
+    const rulesToUpdate = data.rules.filter((rule) =>
+      existingConfigMapByKey.has(
+        `${rule.triggerProduct.id}-${rule.rewardProduct.id}`
+      )
+    );
+
+    const inputRuleKeySet = new Set(
+      data.rules.map(
+        (rule) => `${rule.triggerProduct.id}-${rule.rewardProduct.id}`
+      )
+    );
+
+    const configsToDelete = existingConfigs.filter(
+      (config) =>
+        !inputRuleKeySet.has(
+          `${config.trigger_product_id}-${config.reward_product_id}`
+        )
+    );
+
+    // 1. Update campaign details
+    await updateCampaignsWorkflow.run({
+      input: {
+        campaignsData: [
+          {
+            id: campaign_id,
+            name: data.name,
+            description: data.description,
+            starts_at: new Date(data.starts_at),
+            ends_at: new Date(data.ends_at),
+          } satisfies UpdateCampaignDTO,
+        ],
+      },
+    });
+
+    // 2. Update existing rules
+    await customCampaignModuleService.updateBuyXGetYConfigs(
+      rulesToUpdate.map((rule) => {
+        const key = `${rule.triggerProduct.id}-${rule.rewardProduct.id}`;
+        const config = existingConfigMapByKey.get(key);
+
+        return {
+          id: config?.id ?? "",
+          trigger_quantity: rule.triggerQuantity,
+          reward_quantity: rule.rewardQuantity,
+          reward_type: rule.rewardType,
+          reward_value: rule.rewardValue ?? null,
+          limit: rule.limit ?? null,
+        };
+      })
+    );
+
+    // 3. Delete old configurations and their promotions
+    if (configsToDelete.length > 0) {
+      await deletePromotionsWorkflow.run({
+        input: {
+          ids: configsToDelete.map((config) => config.promotion_id),
+        },
+      });
+      await customCampaignModuleService.softDeleteBuyXGetYConfigs(
+        configsToDelete.map((config) => config.id)
+      );
+    }
+
+    // 4. Create new rules
+    if (rulesToCreate.length > 0) {
+      const { result: createdPromotions } = await createPromotionsWorkflow.run({
+        input: {
+          promotionsData: rulesToCreate.map(
+            (rule) =>
+              ({
+                code: `${campaign.campaign_identifier}-${rule.triggerProduct.id}-${rule.rewardProduct.id}`,
+                type: "buyget",
+                status: "active",
+                is_automatic: true,
+                campaign_id: campaign_id,
+                application_method: {
+                  target_type: "items",
+                  allocation: "each",
+                  type: rule.rewardType === "percentage" ? "percentage" : "fixed",
+                  value: rule.rewardType === "free" ? 0 : (rule.rewardValue ?? 0),
+                  buy_rules_min_quantity: rule.triggerQuantity,
+                  apply_to_quantity: rule.rewardQuantity,
+                  target_rules: [
+                    {
+                      attribute: "items.product.id",
+                      operator: "eq",
+                      values: [rule.triggerProduct.id],
+                    },
+                  ],
+                } satisfies CreateApplicationMethodDTO,
+              } satisfies CreatePromotionDTO)
+          ),
+        },
+      });
+
+      await customCampaignModuleService.createBuyXGetYConfigs(
+        rulesToCreate.map((rule, index) => ({
+          campaign_id: campaign.id,
+          promotion_id: createdPromotions[index].id,
+          trigger_product_id: rule.triggerProduct.id,
+          trigger_quantity: rule.triggerQuantity,
+          reward_product_id: rule.rewardProduct.id,
+          reward_quantity: rule.rewardQuantity,
+          reward_type: rule.rewardType,
+          reward_value: rule.rewardValue ?? null,
+          limit: rule.limit ?? null,
+          used: 0,
+        }))
+      );
+    }
+
+    return new StepResponse();
+  }
+);
+
+export const updateBuyXGetYCampaignWorkflow = createWorkflow(
+  "update-buy-x-get-y-campaign",
+  (data: UpdateBuyXGetYInput) => {
+    const updatedCampaign = updateBuyXGetYCampaignStep(data);
+
+    return new WorkflowResponse(updatedCampaign);
+  }
+);

package/src/workflows/custom-campaign/updateBuyXGetYUsageWorkflow.ts

@@ -0,0 +1,86 @@
+import { Modules } from "@medusajs/framework/utils";
+import {
+  createStep,
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../modules/custom-campaigns/service";
+
+interface UpdateBuyXGetYUsageInput {
+  order_id: string;
+}
+
+const updateBuyXGetYUsageStep = createStep(
+  "update-buy-x-get-y-usage-step",
+  async ({ order_id }: UpdateBuyXGetYUsageInput, { container }) => {
+    const orderService = await container.resolve(Modules.ORDER);
+    const promotionService = await container.resolve(Modules.PROMOTION);
+    const customCampaignTypeService =
+      container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+
+    const order = await orderService.retrieveOrder(order_id, {
+      relations: ["items"],
+    });
+
+    // Find all BOGO reward items in the order
+    const bogoRewardItems = order.items?.filter(
+      (item) => item.metadata?.is_bogo_reward === true
+    );
+
+    if (!bogoRewardItems || bogoRewardItems.length === 0) {
+      return; // No BOGO items in this order
+    }
+
+    // Extract BOGO config IDs from reward items
+    const bogoConfigIds = Array.from(
+      new Set(
+        bogoRewardItems
+          .map((item) => item.metadata?.bogo_config_id as string)
+          .filter(Boolean)
+      )
+    );
+
+    if (bogoConfigIds.length === 0) {
+      return;
+    }
+
+    // Get the BOGO configurations
+    const buyXGetYConfigs =
+      await customCampaignTypeService.listBuyXGetYConfigs({
+        id: bogoConfigIds,
+      });
+
+    // Update usage count for each config
+    const updatePayload = buyXGetYConfigs.map((config) => ({
+      ...config,
+      used: config.used + 1,
+    }));
+
+    // Find configs that have reached their limit
+    const limitReachedConfigs = updatePayload.filter(
+      (config) => config.limit && config.used >= config.limit
+    );
+
+    // Mark promotions as inactive if limit reached
+    if (limitReachedConfigs.length > 0) {
+      await promotionService.updatePromotions(
+        limitReachedConfigs.map((config) => ({
+          id: config.promotion_id,
+          status: "inactive",
+        }))
+      );
+    }
+
+    // Update the usage counts
+    await customCampaignTypeService.updateBuyXGetYConfigs(updatePayload);
+  }
+);
+
+export const updateBuyXGetYUsageWorkflow = createWorkflow(
+  "update-buy-x-get-y-usage",
+  (data: UpdateBuyXGetYUsageInput) => {
+    updateBuyXGetYUsageStep(data);
+    return new WorkflowResponse({ success: true });
+  }
+);