@lodashventure/medusa-campaign 1.3.12 → 1.4.0

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

@@ -11,14 +11,14 @@ import CustomCampaignModuleService from "../../../../modules/custom-campaigns/se
 
 export const GET = async (
   req: MedusaRequest<{ id: string }>,
-  res: MedusaResponse
+  res: MedusaResponse,
 ) => {
   const { id } = req.params;
 
   if (!id) {
     throw new MedusaError(
       MedusaError.Types.INVALID_DATA,
-      "Campaign ID is required"
+      "Campaign ID is required",
     );
   }
 
@@ -39,7 +39,7 @@ export const GET = async (
     if (customCampaignTypes.length === 0) {
       throw new MedusaError(
         MedusaError.Types.NOT_FOUND,
-        `Campaign with ID ${id} not found`
+        `Campaign with ID ${id} not found`,
       );
     }
 
@@ -48,28 +48,38 @@ export const GET = async (
     // 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"],
+      relations: [
+        "promotions",
+        "promotions.application_method",
+        "promotions.application_method.target_rules",
+      ],
     });
 
     if (!campaign) {
       throw new MedusaError(
         MedusaError.Types.NOT_FOUND,
-        `Campaign with ID ${id} not found`
+        `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 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"
+        "This campaign is not currently active",
       );
     }
 
+    // Fetch campaign detail (images, content, etc.)
+    const [campaignDetail] =
+      await customCampaignModuleService.listCampaignDetails({
+        campaign_id: id,
+      });
+
     // Handle different campaign types
     if (campaignType === CampaignTypeEnum.FlashSale) {
       // Fetch promotion usage limits for Flash Sale
@@ -97,7 +107,7 @@ export const GET = async (
           {
             select: ["id", "title", "thumbnail", "handle", "description"],
             relations: ["images"],
-          }
+          },
         );
 
         if (promotion.application_method.value !== undefined) {
@@ -105,19 +115,11 @@ export const GET = async (
             product: {
               id: product.id,
               title: product.title,
-              thumbnail: product.thumbnail,
-              handle: product.handle,
-              description: product.description,
-              images: product.images,
             },
-            discountType: promotion.application_method?.type,
+            discountType: promotion.application_method?.type as "percentage",
             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,
+            maxQty: promotion.application_method?.max_quantity ?? 0,
+            limit: promotionLimit?.limit ?? 0,
           });
         }
       }
@@ -130,6 +132,20 @@ export const GET = async (
         starts_at: campaign.starts_at,
         ends_at: campaign.ends_at,
         products,
+        campaign_detail: campaignDetail
+          ? {
+              image_url: campaignDetail.image_url,
+              thumbnail_url: campaignDetail.thumbnail_url,
+              detail_content: campaignDetail.detail_content,
+              terms_and_conditions: campaignDetail.terms_and_conditions,
+              meta_title: campaignDetail.meta_title,
+              meta_description: campaignDetail.meta_description,
+              meta_keywords: campaignDetail.meta_keywords,
+              link_url: campaignDetail.link_url,
+              link_text: campaignDetail.link_text,
+              display_order: campaignDetail.display_order,
+            }
+          : null,
       });
     } else if (campaignType === CampaignTypeEnum.BuyXGetY) {
       // Get BOGO configs for this campaign
@@ -140,7 +156,7 @@ export const GET = async (
 
       // Filter out configs that have reached their limit
       const availableConfigs = buyXGetYConfigs.filter(
-        (config) => !config.limit || config.used < config.limit
+        (config) => !config.limit || config.used < config.limit,
       );
 
       // Build rules with product details
@@ -181,7 +197,7 @@ export const GET = async (
             rewardValue: config.reward_value,
             remaining: config.limit ? config.limit - config.used : null,
           };
-        })
+        }),
       );
 
       res.status(200).json({
@@ -192,11 +208,25 @@ export const GET = async (
         starts_at: campaign.starts_at,
         ends_at: campaign.ends_at,
         rules,
+        campaign_detail: campaignDetail
+          ? {
+              image_url: campaignDetail.image_url,
+              thumbnail_url: campaignDetail.thumbnail_url,
+              detail_content: campaignDetail.detail_content,
+              terms_and_conditions: campaignDetail.terms_and_conditions,
+              meta_title: campaignDetail.meta_title,
+              meta_description: campaignDetail.meta_description,
+              meta_keywords: campaignDetail.meta_keywords,
+              link_url: campaignDetail.link_url,
+              link_text: campaignDetail.link_text,
+              display_order: campaignDetail.display_order,
+            }
+          : null,
       });
     } else {
       throw new MedusaError(
         MedusaError.Types.INVALID_DATA,
-        "Unknown campaign type"
+        "Unknown campaign type",
       );
     }
   } catch (error) {
@@ -207,7 +237,7 @@ export const GET = async (
     console.error("Error fetching campaign:", error);
     throw new MedusaError(
       MedusaError.Types.UNEXPECTED_STATE,
-      "An error occurred while fetching the campaign"
+      "An error occurred while fetching the campaign",
     );
   }
 };

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

@@ -0,0 +1,53 @@
+import { Migration } from "@mikro-orm/migrations";
+
+export class Migration20251024000000 extends Migration {
+  override async up(): Promise<void> {
+    // Create campaign_detail table
+    this.addSql(`
+      create table if not exists "campaign_detail" (
+        "id" text not null,
+        "campaign_id" text not null,
+        "image_url" text null,
+        "image_file_id" text null,
+        "thumbnail_url" text null,
+        "thumbnail_file_id" text null,
+        "detail_content" text null,
+        "terms_and_conditions" text null,
+        "meta_title" text null,
+        "meta_description" text null,
+        "link_url" text null,
+        "link_text" text null,
+        "display_order" integer not null default 0,
+        "created_at" timestamptz not null default now(),
+        "updated_at" timestamptz not null default now(),
+        "deleted_at" timestamptz null,
+        constraint "campaign_detail_pkey" primary key ("id")
+      );
+    `);
+
+    // Create unique index on campaign_id
+    this.addSql(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "IDX_campaign_detail_campaign_id"
+      ON "campaign_detail" (campaign_id)
+      WHERE deleted_at IS NULL;
+    `);
+
+    // Create index for deleted_at
+    this.addSql(`
+      CREATE INDEX IF NOT EXISTS "IDX_campaign_detail_deleted_at"
+      ON "campaign_detail" (deleted_at)
+      WHERE deleted_at IS NULL;
+    `);
+
+    // Create index for display_order
+    this.addSql(`
+      CREATE INDEX IF NOT EXISTS "IDX_campaign_detail_display_order"
+      ON "campaign_detail" (display_order);
+    `);
+  }
+
+  override async down(): Promise<void> {
+    // Drop campaign_detail table
+    this.addSql(`drop table if exists "campaign_detail" cascade;`);
+  }
+}

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

@@ -0,0 +1,19 @@
+import { Migration } from "@mikro-orm/migrations";
+
+export class Migration20251025000000 extends Migration {
+  override async up(): Promise<void> {
+    // Add meta_keywords column to campaign_detail table
+    this.addSql(`
+      ALTER TABLE "campaign_detail"
+      ADD COLUMN IF NOT EXISTS "meta_keywords" text null;
+    `);
+  }
+
+  override async down(): Promise<void> {
+    // Remove meta_keywords column from campaign_detail table
+    this.addSql(`
+      ALTER TABLE "campaign_detail"
+      DROP COLUMN IF EXISTS "meta_keywords";
+    `);
+  }
+}

package/src/modules/custom-campaigns/models/campaign-detail.ts

@@ -0,0 +1,25 @@
+import { model } from "@medusajs/framework/utils";
+
+const CampaignDetail = model.define("campaign_detail", {
+  id: model.id().primaryKey(),
+  campaign_id: model.text().unique(),
+  // Image fields
+  image_url: model.text().nullable(),
+  image_file_id: model.text().nullable(),
+  thumbnail_url: model.text().nullable(),
+  thumbnail_file_id: model.text().nullable(),
+  // Rich text content fields
+  detail_content: model.text().nullable(), // Markdown content
+  terms_and_conditions: model.text().nullable(), // Markdown content
+  // SEO and meta fields
+  meta_title: model.text().nullable(),
+  meta_description: model.text().nullable(),
+  meta_keywords: model.text().nullable(),
+  // Link field
+  link_url: model.text().nullable(),
+  link_text: model.text().nullable(),
+  // Display order
+  display_order: model.number().default(0),
+});
+
+export default CampaignDetail;

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

@@ -2,11 +2,13 @@ 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";
+import CampaignDetail from "./models/campaign-detail";
 
 class CustomCampaignModuleService extends MedusaService({
   CustomCampaignType,
   PromotionUsageLimit,
   BuyXGetYConfig,
+  CampaignDetail,
 }) {}
 
 export default CustomCampaignModuleService;

package/src/subscribers/order-placed.ts

@@ -1,6 +1,4 @@
 import { SubscriberArgs, type SubscriberConfig } from "@medusajs/framework";
-import { updatePromotionUsageWorkflow } from "../workflows/custom-campaign/updatePromotionUsageWorkflow";
-import { SubscriberArgs, type SubscriberConfig } from "@medusajs/framework";
 import { updateBuyXGetYUsageWorkflow } from "../workflows/custom-campaign/updateBuyXGetYUsageWorkflow";
 import { updatePromotionUsageWorkflow } from "../workflows/custom-campaign/updatePromotionUsageWorkflow";
 

package/src/types/index.d.ts

@@ -0,0 +1,46 @@
+import { MedusaRequest as BaseMedusaRequest } from "@medusajs/framework/http";
+
+declare global {
+  namespace Express {
+    namespace Multer {
+      interface File {
+        fieldname: string;
+        originalname: string;
+        encoding: string;
+        mimetype: string;
+        destination: string;
+        filename: string;
+        path: string;
+        buffer: Buffer;
+        size: number;
+      }
+    }
+  }
+}
+
+export interface MedusaRequestWithFile<TBody = unknown> extends BaseMedusaRequest<TBody> {
+  file?: Express.Multer.File;
+}
+
+// Type definitions for brand requests
+export interface CreateBrandRequest {
+  name: string;
+  slug: string;
+  description?: string;
+  website?: string;
+  is_active?: boolean;
+  metadata?: Record<string, any>;
+}
+
+export interface UpdateBrandRequest {
+  name?: string;
+  slug?: string;
+  description?: string;
+  website?: string;
+  is_active?: boolean;
+  metadata?: Record<string, any>;
+}
+
+export interface SetBrandRequest {
+  brand_id: string;
+}

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

@@ -26,19 +26,29 @@ interface RewardItem {
   };
 }
 
-const applyBuyXGetYToCartStep = createStep(
+const applyBuyXGetYToCartStep = createStep<
+  ApplyBuyXGetYInput,
+  { rewardItemsAdded: any[] },
+  { cart_id: string; added_items: any[] }
+>(
   "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");
+    const linkService = container.resolve("linkModuleService") as any;
 
     // Fetch the cart with items
-    const cart = await cartService.retrieve(data.cart_id, {
-      relations: ["items", "items.variant", "items.product"],
-    });
+    const carts = await cartService.listCarts(
+      {
+        id: [data.cart_id],
+      },
+      {
+        relations: ["items", "items.variant", "items.product"],
+      },
+    );
+    const cart = carts[0];
 
     if (!cart || !cart.items || cart.items.length === 0) {
       return new StepResponse({ rewardItemsAdded: [] });
@@ -63,7 +73,7 @@ const applyBuyXGetYToCartStep = createStep(
     });
 
     const campaignIds = campaignLinks.map(
-      (link: any) => link[Modules.PROMOTION].campaign_id
+      (link: any) => link[Modules.PROMOTION].campaign_id,
     );
 
     const promotionService = container.resolve(Modules.PROMOTION);
@@ -75,7 +85,7 @@ const applyBuyXGetYToCartStep = createStep(
     const activeCampaigns = campaigns.filter(
       (campaign: any) =>
         new Date(campaign.starts_at) <= now &&
-        new Date(campaign.ends_at) >= now
+        new Date(campaign.ends_at) >= now,
     );
 
     if (activeCampaigns.length === 0) {
@@ -90,13 +100,13 @@ const applyBuyXGetYToCartStep = createStep(
 
     // Remove ALL existing BOGO reward items to recalculate from scratch
     const existingBogoItems = cart.items.filter(
-      (item: any) => item.metadata?.is_bogo_reward === true
+      (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]);
+        await cartService.deleteLineItems([bogoItem.id]);
         removedItemIds.push(bogoItem.id);
       } catch (error) {
         console.error(`Failed to remove existing BOGO item:`, error);
@@ -132,14 +142,14 @@ const applyBuyXGetYToCartStep = createStep(
       // Calculate total quantity of trigger product
       const totalTriggerQuantity = triggerItems.reduce(
         (sum, item) => sum + item.quantity,
-        0
+        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
+          totalTriggerQuantity / config.trigger_quantity,
         );
         const totalRewardQuantity = config.reward_quantity * rewardMultiplier;
 
@@ -148,12 +158,12 @@ const applyBuyXGetYToCartStep = createStep(
           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}`
+            `No variants found for reward product ${config.reward_product_id}`,
           );
           continue;
         }
@@ -178,10 +188,20 @@ const applyBuyXGetYToCartStep = createStep(
     const addedItems: any[] = [];
     for (const rewardItem of rewardItemsToAdd) {
       try {
+        const variants = await (productService as any).listVariants({
+          id: [rewardItem.variant_id],
+        });
+        const products = await productService.listProducts({
+          id: [rewardItem.product_id],
+        });
+        const product = products[0];
+
         const addedItem = await cartService.addLineItems(data.cart_id, [
           {
             variant_id: rewardItem.variant_id,
             quantity: rewardItem.quantity,
+            title: product?.title || "Reward Item",
+            unit_price: 0,
             metadata: rewardItem.metadata,
           },
         ]);
@@ -193,7 +213,7 @@ const applyBuyXGetYToCartStep = createStep(
 
     return new StepResponse(
       { rewardItemsAdded: addedItems },
-      { cart_id: data.cart_id, added_items: addedItems }
+      { cart_id: data.cart_id, added_items: addedItems },
     );
   },
   async (compensationData) => {
@@ -204,12 +224,15 @@ const applyBuyXGetYToCartStep = createStep(
 
     for (const item of compensationData.added_items) {
       try {
-        await cartService.removeLineItems(compensationData.cart_id, [item.id]);
+        await cartService.deleteLineItems([item.id]);
       } catch (error) {
-        console.error(`Failed to remove reward item during compensation:`, error);
+        console.error(
+          `Failed to remove reward item during compensation:`,
+          error,
+        );
       }
     }
-  }
+  },
 );
 
 export const applyBuyXGetYToCartWorkflow = createWorkflow(
@@ -218,5 +241,5 @@ export const applyBuyXGetYToCartWorkflow = createWorkflow(
     const result = applyBuyXGetYToCartStep(data);
 
     return new WorkflowResponse(result);
-  }
+  },
 );

package/src/workflows/campaign-detail/update-campaign-detail.ts

@@ -0,0 +1,85 @@
+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";
+
+type UpdateCampaignDetailInput = {
+  campaign_id: string;
+  detail_content?: string;
+  terms_and_conditions?: string;
+  meta_title?: string;
+  meta_description?: string;
+  link_url?: string;
+  link_text?: string;
+  display_order?: number;
+};
+
+const updateCampaignDetailStep = createStep(
+  "update-campaign-detail",
+  async (input: UpdateCampaignDetailInput, { container }) => {
+    const logger = container.resolve("logger");
+    const customCampaignModuleService: CustomCampaignModuleService =
+      container.resolve(CUSTOM_CAMPAIGN_MODULE);
+
+    const { campaign_id, ...updateData } = input;
+
+    logger.info(`Updating campaign detail for campaign: ${campaign_id}`);
+
+    // Get or create campaign detail
+    const [existingDetail] =
+      await customCampaignModuleService.listCampaignDetails({
+        campaign_id,
+      });
+
+    let campaignDetail;
+
+    if (existingDetail) {
+      // Update existing detail
+      const updated = await customCampaignModuleService.updateCampaignDetails([
+        {
+          id: existingDetail.id,
+          ...updateData,
+        },
+      ]);
+      campaignDetail = updated[0];
+    } else {
+      // Create new detail
+      campaignDetail = await customCampaignModuleService.createCampaignDetails({
+        campaign_id,
+        ...updateData,
+      });
+    }
+
+    return new StepResponse(campaignDetail, existingDetail);
+  },
+  async (oldDetail, { container }) => {
+    const logger = container.resolve("logger");
+    const customCampaignModuleService: CustomCampaignModuleService =
+      container.resolve(CUSTOM_CAMPAIGN_MODULE);
+
+    if (oldDetail) {
+      try {
+        await customCampaignModuleService.updateCampaignDetails([
+          {
+            ...oldDetail,
+          },
+        ]);
+        logger.info("Rolled back campaign detail update");
+      } catch (error) {
+        logger.warn("Failed to rollback campaign detail update");
+      }
+    }
+  },
+);
+
+export const updateCampaignDetailWorkflow = createWorkflow(
+  "update-campaign-detail",
+  (input: UpdateCampaignDetailInput) => {
+    const detail = updateCampaignDetailStep(input);
+    return new WorkflowResponse(detail);
+  },
+);