@lodashventure/medusa-campaign 1.4.1 → 1.4.2

package/src/api/store/customers/me/coupons/route.ts

@@ -0,0 +1,244 @@
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+  container,
+} from "@medusajs/framework";
+import { MedusaError, Modules } from "@medusajs/framework/utils";
+import z from "zod";
+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";
+
+type PromotionCacheService = {
+  scan: <T>(pattern: string) => Promise<T[]>;
+  set: (key: string, value: unknown, ttl?: number) => Promise<void>;
+  exists: (key: string) => Promise<boolean>;
+};
+
+type UsablePromoModuleService = {
+  listUsablePromotions: (
+    selector: Record<string, unknown>,
+  ) => Promise<
+    Array<{
+      id: string;
+      promotion_id: string;
+      enabled: boolean;
+    }>
+  >;
+};
+
+const PROMOTION_CACHE_MODULE = "promotion_cache";
+const USABLE_PROMO_MODULE = "usable_promotion";
+
+const resolveOptional = <T>(token: string): T | null => {
+  try {
+    return container.resolve<T>(token);
+  } catch {
+    return null;
+  }
+};
+
+export const collectCouponSchema = z.object({
+  coupon_id: z.string().min(1, "coupon_id is required"),
+});
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse,
+) => {
+  const customerId = req.auth_context.actor_id;
+
+  if (!customerId) {
+    throw new MedusaError(
+      MedusaError.Types.NOT_ALLOWED,
+      "Customer must be authenticated",
+    );
+  }
+
+  const promoCacheService =
+    container.resolve<PromotionCacheService>(PROMOTION_CACHE_MODULE);
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  const cacheKey = `user:${customerId}:promotion:*`;
+  const cachedPromotionIds = await promoCacheService.scan<string>(cacheKey);
+
+  if (!cachedPromotionIds.length) {
+    return res.status(200).json({
+      coupons: [],
+      count: 0,
+    });
+  }
+
+  const promotions = await promotionService.listPromotions(
+    {
+      id: cachedPromotionIds,
+    },
+    {
+      relations: ["campaign", "application_method"],
+    },
+  );
+
+  const campaignIds = promotions
+    .map((promotion) => promotion.campaign_id)
+    .filter((id): id is string => Boolean(id));
+
+  const campaignTypes =
+    await customCampaignModuleService.listCustomCampaignTypes({
+      campaign_id: campaignIds,
+    });
+
+  const couponCampaignIds = new Set(
+    campaignTypes
+      .filter((type) => type.type === CampaignTypeEnum.Coupon)
+      .map((type) => type.campaign_id),
+  );
+
+  const campaignDetails =
+    await customCampaignModuleService.listCampaignDetails({
+      campaign_id: Array.from(couponCampaignIds),
+    });
+
+  const detailMap = new Map(
+    campaignDetails.map((detail) => [detail.campaign_id, detail]),
+  );
+
+  const coupons = promotions
+    .filter(
+      (promotion) =>
+        promotion.campaign_id && couponCampaignIds.has(promotion.campaign_id),
+    )
+    .map((promotion) => {
+      const campaign = promotion.campaign!;
+      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: true,
+        is_collected: true,
+        detail: detailMap.get(campaign.id) ?? null,
+      };
+    });
+
+  res.status(200).json({
+    coupons,
+    count: coupons.length,
+  });
+};
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse,
+) => {
+  const body = collectCouponSchema.parse(req.body);
+  const customerId = req.auth_context.actor_id;
+
+  if (!customerId) {
+    throw new MedusaError(
+      MedusaError.Types.NOT_ALLOWED,
+      "Customer must be authenticated",
+    );
+  }
+
+  const promotionService = container.resolve(Modules.PROMOTION);
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const promoCacheService =
+    container.resolve<PromotionCacheService>(PROMOTION_CACHE_MODULE);
+  const usablePromoService = resolveOptional<UsablePromoModuleService>(
+    USABLE_PROMO_MODULE,
+  );
+
+  const promotion = await promotionService.retrievePromotion(
+    body.coupon_id,
+    {
+      relations: ["campaign", "application_method"],
+    },
+  );
+
+  if (!promotion?.campaign_id) {
+    throw new MedusaError(
+      MedusaError.Types.NOT_FOUND,
+      "Coupon promotion not found",
+    );
+  }
+
+  const [campaignType] =
+    await customCampaignModuleService.listCustomCampaignTypes({
+      campaign_id: promotion.campaign_id,
+    });
+
+  if (!campaignType || campaignType.type !== CampaignTypeEnum.Coupon) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Promotion is not registered as a coupon",
+    );
+  }
+
+  if (promotion.is_automatic) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Automatic promotions cannot be collected",
+    );
+  }
+
+  if (promotion.status !== "active") {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Promotion is not active",
+    );
+  }
+
+  if (usablePromoService) {
+    const [usable] = await usablePromoService.listUsablePromotions({
+      promotion_id: promotion.id,
+    });
+
+    if (!usable || !usable.enabled) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "This coupon is not available for collection",
+      );
+    }
+  }
+
+  const cacheKey = `user:${customerId}:promotion:${promotion.id}`;
+  const alreadyCollected = await promoCacheService.exists(cacheKey);
+
+  if (alreadyCollected) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Coupon already collected",
+    );
+  }
+
+  await promoCacheService.set(cacheKey, promotion.id);
+
+  res.status(201).json({
+    message: "Coupon collected",
+    coupon: {
+      id: promotion.id,
+      code: promotion.code,
+      name: promotion.campaign?.name,
+      description: promotion.campaign?.description,
+      starts_at: promotion.campaign?.starts_at,
+      ends_at: promotion.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: promotion.campaign_id,
+    },
+  });
+};

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

@@ -1,4 +1,4 @@
-import { Migration } from "@mikro-orm/migrations";
+import { Migration } from "@medusajs/framework/mikro-orm/migrations";
 
 export class Migration20251024000000 extends Migration {
   override async up(): Promise<void> {

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

@@ -1,4 +1,4 @@
-import { Migration } from "@mikro-orm/migrations";
+import { Migration } from "@medusajs/framework/mikro-orm/migrations";
 
 export class Migration20251025000000 extends Migration {
   override async up(): Promise<void> {

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

@@ -0,0 +1,21 @@
+import { Migration } from "@medusajs/framework/mikro-orm/migrations";
+
+export class Migration20251101000000 extends Migration {
+  override async up(): Promise<void> {
+    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', 'coupon'));`,
+    );
+  }
+
+  override async down(): Promise<void> {
+    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'));`,
+    );
+  }
+}

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

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

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

@@ -0,0 +1,176 @@
+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 type CreateCouponCampaignInput = {
+  name: string;
+  description: string;
+  code: string;
+  type: CampaignTypeEnum.Coupon;
+  starts_at: Date;
+  ends_at: Date;
+  discount_type: "percentage" | "fixed";
+  discount_value: number;
+  currency_code?: string | null;
+  allocation?: "each" | "total";
+  target_type?: "order" | "items";
+};
+
+const createCouponCampaignStep = createStep(
+  "create-coupon-campaign-step",
+  async (input: CreateCouponCampaignInput) => {
+    if (new Date(input.ends_at) < new Date(input.starts_at)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "End date must be after start date",
+      );
+    }
+
+    if (input.discount_type === "fixed" && !input.currency_code) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "currency_code is required for fixed discount type",
+      );
+    }
+
+    const link = container.resolve(ContainerRegistrationKeys.LINK);
+    const customCampaignModuleService =
+      container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+
+    const campaignIdentifier = `${input.type}-${Date.now()}`;
+
+    let campaign: CampaignDTO | undefined;
+    let promotion: PromotionDTO | undefined;
+    let customCampaignType:
+      | Awaited<
+          ReturnType<CustomCampaignModuleService["createCustomCampaignTypes"]>
+        >[number]
+      | undefined;
+
+    try {
+      const {
+        result: [createdCampaign],
+      } = await createCampaignsWorkflow.run({
+        input: {
+          campaignsData: [
+            {
+              name: input.name,
+              description: input.description,
+              campaign_identifier: campaignIdentifier,
+              starts_at: new Date(input.starts_at),
+              ends_at: new Date(input.ends_at),
+            },
+          ],
+        },
+      });
+
+      campaign = createdCampaign;
+
+      const {
+        result: [createdPromotion],
+      } = await createPromotionsWorkflow.run({
+        input: {
+          promotionsData: [
+            {
+              code: input.code,
+              type: "standard",
+              status: "active",
+              is_automatic: false,
+              campaign_id: campaign.id,
+              application_method: {
+                target_type: input.target_type ?? "order",
+                allocation: (input.allocation ?? "across") as any,
+                type: input.discount_type,
+                value: input.discount_value,
+                currency_code:
+                  input.discount_type === "fixed" && input.currency_code
+                    ? input.currency_code
+                    : undefined,
+              } satisfies CreateApplicationMethodDTO,
+            } satisfies CreatePromotionDTO,
+          ],
+        },
+      });
+
+      promotion = createdPromotion;
+
+      customCampaignType =
+        await customCampaignModuleService.createCustomCampaignTypes({
+          campaign_id: campaign.id,
+          type: input.type,
+        });
+
+      await link.create([
+        {
+          [Modules.PROMOTION]: {
+            campaign_id: campaign.id,
+          },
+          [CUSTOM_CAMPAIGN_MODULE]: {
+            custom_campaign_type_id: customCampaignType.id,
+          },
+        },
+      ]);
+
+      return new StepResponse({
+        campaign,
+        promotion,
+      });
+    } catch (error) {
+      if (campaign) {
+        await deleteCampaignsWorkflow.run({
+          input: {
+            ids: campaign.id,
+          },
+        });
+      }
+
+      if (promotion) {
+        await deletePromotionsWorkflow.run({
+          input: {
+            ids: promotion.id,
+          },
+        });
+      }
+
+      if (customCampaignType) {
+        await customCampaignModuleService.deleteCustomCampaignTypes(
+          customCampaignType.id,
+        );
+      }
+
+      throw error;
+    }
+  },
+);
+
+export const createCouponCampaignWorkflow = createWorkflow(
+  "create-coupon-campaign",
+  (input: CreateCouponCampaignInput) => {
+    const couponCampaign = createCouponCampaignStep(input);
+    return new WorkflowResponse(couponCampaign);
+  },
+);

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

@@ -0,0 +1,105 @@
+import { container } from "@medusajs/framework";
+import {
+  UpdateCampaignDTO,
+  UpdatePromotionDTO,
+} from "@medusajs/framework/types";
+import { MedusaError, Modules } from "@medusajs/framework/utils";
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { updateCampaignsWorkflow } from "@medusajs/medusa/core-flows";
+
+export type UpdateCouponCampaignInput = {
+  id: string;
+  name: string;
+  description: string;
+  code: string;
+  starts_at: Date;
+  ends_at: Date;
+  discount_type: "percentage" | "fixed";
+  discount_value: number;
+  currency_code?: string | null;
+  allocation?: "each" | "total";
+  target_type?: "order" | "items";
+};
+
+const updateCouponCampaignStep = createStep(
+  "update-coupon-campaign-step",
+  async (input: UpdateCouponCampaignInput) => {
+    if (new Date(input.ends_at) < new Date(input.starts_at)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "End date must be after start date",
+      );
+    }
+
+    if (input.discount_type === "fixed" && !input.currency_code) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "currency_code is required for fixed discount type",
+      );
+    }
+
+    const promotionService = container.resolve(Modules.PROMOTION);
+
+    const promotions = await promotionService.listPromotions({
+      campaign_id: input.id,
+    } as any);
+
+    if (!promotions.length) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        "Coupon promotion not found for campaign",
+      );
+    }
+
+    const promotion = promotions[0];
+
+    await updateCampaignsWorkflow.run({
+      input: {
+        campaignsData: [
+          {
+            id: input.id,
+            name: input.name,
+            description: input.description,
+            starts_at: new Date(input.starts_at),
+            ends_at: new Date(input.ends_at),
+          } satisfies UpdateCampaignDTO,
+        ],
+      },
+    });
+
+    const updateData: UpdatePromotionDTO = {
+      id: promotion.id,
+      code: input.code,
+      application_method: {
+        type: input.discount_type,
+        target_type: input.target_type ?? "order",
+        allocation: (input.allocation ?? "across") as any,
+        value: input.discount_value,
+        currency_code:
+          input.discount_type === "fixed" && input.currency_code
+            ? input.currency_code
+            : undefined,
+      },
+    };
+
+    await promotionService.updatePromotions([updateData]);
+
+    return new StepResponse({
+      campaign_id: input.id,
+      promotion_id: promotion.id,
+    });
+  },
+);
+
+export const updateCouponCampaignWorkflow = createWorkflow(
+  "update-coupon-campaign",
+  (input: UpdateCouponCampaignInput) => {
+    const result = updateCouponCampaignStep(input);
+    return new WorkflowResponse(result);
+  },
+);

package/src/workflows/index.ts

@@ -1,4 +1,6 @@
 export { createCustomCampaignWorkflow, createCustomCampaignWorkflow as createCustomFlashSaleWorkflow } from "./custom-campaign/createCustomCampaignWorkflow";
 export { updateCustomFlashSaleWorkflow } from "./custom-campaign/updateCustomFlashSaleWorkflow";
 export { updatePromotionUsageWorkflow } from "./custom-campaign/updatePromotionUsageWorkflow";
-export { applyBuyXGetYToCartWorkflow } from "./buy-x-get-y/applyBuyXGetYToCartWorkflow";
+export { applyBuyXGetYToCartWorkflow } from "./buy-x-get-y/applyBuyXGetYToCartWorkflow";
+export { createCouponCampaignWorkflow } from "./custom-campaign/createCouponCampaignWorkflow";
+export { updateCouponCampaignWorkflow } from "./custom-campaign/updateCouponCampaignWorkflow";