@lodashventure/medusa-campaign 1.1.0 → 1.1.1

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

@@ -0,0 +1,181 @@
+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 { CustomCampaign } from "../../api/admin/flash-sales/route";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../modules/custom-campaigns/service";
+
+const createCustomCampaignStep = createStep(
+  "create-custom-campaign-step",
+  async (data: CustomCampaign) => {
+    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 promotionUsageLimit:
+      | Awaited<
+          ReturnType<CustomCampaignModuleService["createPromotionUsageLimits"]>
+        >
+      | undefined;
+
+    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 {
+      const { result: _promotions } = await createPromotionsWorkflow.run({
+        input: {
+          promotionsData: data.products.map(
+            (product) =>
+              ({
+                code: `${campaignIdentifier}-${product.product.id}`,
+                type: "standard",
+                status: "active",
+                is_automatic: true,
+                campaign_id: campaign.id,
+                application_method: {
+                  target_type: "items",
+                  allocation: "each",
+                  type: product.discountType,
+                  value: product.discountValue,
+                  max_quantity: product.maxQty,
+                  target_rules: [
+                    {
+                      attribute: "items.product.id",
+                      operator: "eq",
+                      values: [product.product.id],
+                    },
+                  ],
+                } satisfies CreateApplicationMethodDTO,
+              } satisfies CreatePromotionDTO)
+          ),
+        },
+      });
+      promotions = _promotions;
+
+      const productPromotionMap = new Map<string, string>();
+      promotions.forEach((promotion) => {
+        const productId = promotion.code?.split("-").at(-1);
+        if (!productId) {
+          throw new MedusaError(
+            MedusaError.Types.INVALID_DATA,
+            "Invalid product id"
+          );
+        }
+        productPromotionMap.set(productId, promotion.id);
+      });
+
+      customCampaignType =
+        await customCampaignModuleService.createCustomCampaignTypes({
+          campaign_id: campaign.id,
+          type: data.type,
+        });
+
+      promotionUsageLimit =
+        await customCampaignModuleService.createPromotionUsageLimits(
+          data.products.map((product) => ({
+            campaign_id: campaign.id,
+            promotion_id: productPromotionMap.get(product.product.id),
+            product_id: product.product.id,
+            limit: product.limit,
+            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,
+      });
+    } catch (error) {
+      console.log({ 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 (promotionUsageLimit) {
+        await customCampaignModuleService.deletePromotionUsageLimits(
+          promotionUsageLimit.map((limit) => limit.id)
+        );
+      }
+    }
+  }
+);
+
+export const createCustomCampaignWorkflow = createWorkflow(
+  "create-custom-campaign",
+  (data: CustomCampaign) => {
+    const customCampaign = createCustomCampaignStep(data);
+
+    return new WorkflowResponse(customCampaign);
+  }
+);

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

@@ -0,0 +1,185 @@
+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,
+  updatePromotionsWorkflow,
+} from "@medusajs/medusa/core-flows";
+import { CustomCampaign } from "../../api/admin/flash-sales/route";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../modules/custom-campaigns/service";
+
+interface UpdateFlashSaleInput extends CustomCampaign {
+  id: string;
+}
+
+const updateCustomFlashSaleStep = createStep(
+  "update-custom-flash-sale-step",
+  async (data: UpdateFlashSaleInput) => {
+    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 promotion usage limits
+    const promotionUsageLimits =
+      await customCampaignModuleService.listPromotionUsageLimits({
+        campaign_id: campaign_id,
+      });
+
+    // Create maps for existing promotions and usage limits
+    const existingPromotionUsageMapByProductId = new Map(
+      promotionUsageLimits.map((limit) => [limit.product_id, limit])
+    );
+    const promotionsToBeCreate = data.products.filter(
+      (product) => !existingPromotionUsageMapByProductId.has(product.product.id)
+    );
+    const productPromotionsToBeUpdate = data.products.filter((product) =>
+      existingPromotionUsageMapByProductId.has(product.product.id)
+    );
+
+    const inputProductIdSet = new Set(
+      data.products.map((product) => product.product.id)
+    );
+    const promotionsToBeDelete = promotionUsageLimits.filter(
+      (limit) => !inputProductIdSet.has(limit.product_id)
+    );
+
+    console.log("update campaign");
+    // 1. Update the 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.1 Update promotions to be updated
+    await promotionService.updatePromotions(
+      productPromotionsToBeUpdate.map((product) => {
+        const promotion_id =
+          existingPromotionUsageMapByProductId.get(product.product.id)
+            ?.promotion_id ?? "";
+
+        return {
+          id: promotion_id,
+          application_method: {
+            value: product.discountValue,
+            max_quantity: product.maxQty,
+          },
+        } satisfies UpdatePromotionDTO;
+      })
+    );
+
+    // 2.2 Update promotion usage limits to be updated
+    await customCampaignModuleService.updatePromotionUsageLimits(
+      productPromotionsToBeUpdate.map((product) => ({
+        id:
+          existingPromotionUsageMapByProductId.get(product.product.id)?.id ??
+          "",
+        limit: product.limit,
+      }))
+    );
+
+    // 3. Delete promotions to be deleted
+    await deletePromotionsWorkflow.run({
+      input: {
+        ids: promotionsToBeDelete.map((limit) => limit.promotion_id),
+      },
+    });
+    await customCampaignModuleService.softDeletePromotionUsageLimits(
+      promotionsToBeDelete.map((limit) => limit.id)
+    );
+
+    // 4. Create promotions to be created
+    const { result: createdPromotions } = await createPromotionsWorkflow.run({
+      input: {
+        promotionsData: promotionsToBeCreate.map(
+          (product) =>
+            ({
+              code: `${campaign.campaign_identifier}-${product.product.id}`,
+              type: "standard",
+              status: "active",
+              is_automatic: true,
+              campaign_id: campaign_id,
+              application_method: {
+                target_type: "items",
+                allocation: "each",
+                type: product.discountType,
+                value: product.discountValue,
+                max_quantity: product.maxQty,
+                target_rules: [
+                  {
+                    attribute: "items.product.id",
+                    operator: "eq",
+                    values: [product.product.id],
+                  },
+                ],
+              } satisfies CreateApplicationMethodDTO,
+            } satisfies CreatePromotionDTO)
+        ),
+      },
+    });
+    const productPromotionMap = new Map<string, string>();
+    createdPromotions.forEach((promotion) => {
+      const productId = promotion.code?.split("-").at(-1);
+      if (!productId) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          "Invalid product id"
+        );
+      }
+      productPromotionMap.set(productId, promotion.id);
+    });
+    await customCampaignModuleService.createPromotionUsageLimits(
+      promotionsToBeCreate.map((product) => ({
+        campaign_id: campaign.id,
+        promotion_id: productPromotionMap.get(product.product.id) ?? "",
+        product_id: product.product.id,
+        limit: product.limit,
+        used: 0,
+      }))
+    );
+    return new StepResponse();
+  }
+);
+
+export const updateCustomFlashSaleWorkflow = createWorkflow(
+  "update-custom-flash-sale",
+  (data: UpdateFlashSaleInput) => {
+    const updatedFlashSale = updateCustomFlashSaleStep(data);
+
+    return new WorkflowResponse(updatedFlashSale);
+  }
+);

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

@@ -0,0 +1,70 @@
+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 UpdatePromotionUsageInput {
+  order_id: string;
+}
+
+const updatePromotionUsageStep = createStep(
+  "update-promotion-usage-step",
+  async ({ order_id }: UpdatePromotionUsageInput, { 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.adjustments"],
+    });
+
+    const promotionSet = new Set(
+      order.items
+        ?.map((item) =>
+          item.adjustments?.map((adjustment) => adjustment.promotion_id)
+        )
+        .flat()
+    );
+    const promotionIds = Array.from(promotionSet);
+    const promotionUsageLimits =
+      await customCampaignTypeService.listPromotionUsageLimits({
+        promotion_id: promotionIds,
+      });
+
+    const updatePromotionUsagePayload = promotionUsageLimits.map((limit) => ({
+      ...limit,
+      used: limit.used + 1,
+    }));
+
+    const limitReachedPromotions = updatePromotionUsagePayload.filter(
+      (limit) => limit.used >= limit.limit
+    );
+
+    if (limitReachedPromotions.length > 0) {
+      await promotionService.updatePromotions(
+        limitReachedPromotions.map((limit) => ({
+          id: limit.promotion_id,
+          status: "inactive",
+        }))
+      );
+    }
+
+    await customCampaignTypeService.updatePromotionUsageLimits(
+      updatePromotionUsagePayload
+    );
+  }
+);
+
+export const updatePromotionUsageWorkflow = createWorkflow(
+  "update-promotion-usage",
+  (data: UpdatePromotionUsageInput) => {
+    updatePromotionUsageStep(data);
+    return new WorkflowResponse({ success: true });
+  }
+);

package/src/workflows/hooks/deletePromotionOnCampaignDelete.ts

@@ -0,0 +1,49 @@
+import {
+  deleteCampaignsWorkflow,
+  deletePromotionsWorkflow
+} from "@medusajs/medusa/core-flows";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../modules/custom-campaigns/service";
+
+deleteCampaignsWorkflow.hooks.campaignsDeleted(
+  async ({ ids }, { container }) => {
+    const customCampaignModuleService =
+      container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+
+    const promotionLimits =
+      await customCampaignModuleService.listPromotionUsageLimits(
+        {
+          campaign_id: ids,
+        },
+        {
+          select: ["id", "promotion_id"],
+        }
+      );
+
+    await deletePromotionsWorkflow.run({
+      input: {
+        ids: promotionLimits.map((limit) => limit.promotion_id),
+      },
+    });
+
+    await customCampaignModuleService.softDeletePromotionUsageLimits(
+      promotionLimits.map((limit) => limit.id)
+    );
+
+    const customCampaignIds =
+      await customCampaignModuleService.listCustomCampaignTypes(
+        {
+          campaign_id: Array.from(
+            new Set(promotionLimits.map((limit) => limit.campaign_id))
+          ),
+        },
+        {
+          select: ["id"],
+        }
+      );
+
+    await customCampaignModuleService.softDeleteCustomCampaignTypes(
+      customCampaignIds.map((campaign) => campaign.id)
+    );
+  }
+);

package/src/workflows/index.ts

@@ -0,0 +1,3 @@
+export { createCustomFlashSaleWorkflow } from "./custom-campaign/createCustomCampaignWorkflow";
+export { updateCustomFlashSaleWorkflow } from "./custom-campaign/updateCustomFlashSaleWorkflow";
+export { updatePromotionUsageWorkflow } from "./custom-campaign/updatePromotionUsageWorkflow";