@lodashventure/medusa-campaign 1.3.12 → 1.4.0

package/src/api/admin/campaigns/[id]/thumbnail/route.ts

@@ -0,0 +1,87 @@
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+import { uploadCampaignImagesWorkflow } from "../../../../../workflows/campaign-detail/upload-campaign-images";
+import { deleteFilesWorkflow } from "@medusajs/medusa/core-flows";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../../../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../../../../modules/custom-campaigns/service";
+
+// POST upload campaign thumbnail
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const { id: campaign_id } = req.params;
+  const file = (req as any).file;
+
+  if (!file) {
+    return res.status(400).json({
+      error: "No file provided",
+    });
+  }
+
+  try {
+    const { result } = await uploadCampaignImagesWorkflow(req.scope).run({
+      input: {
+        campaign_id,
+        files: [
+          {
+            filename: Buffer.from(file.originalname, "latin1").toString("utf8"),
+            mimeType: file.mimetype,
+            content: file.buffer.toString("binary"),
+            access: "public" as const,
+          },
+        ],
+        image_type: "thumbnail",
+      },
+    });
+
+    res.status(200).json({ campaign_detail: result });
+  } catch (error) {
+    console.error("Error uploading campaign thumbnail:", error);
+    res.status(500).json({
+      error: "Failed to upload campaign thumbnail",
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
+};
+
+// DELETE campaign thumbnail
+export const DELETE = async (req: MedusaRequest, res: MedusaResponse) => {
+  const { id: campaign_id } = req.params;
+  const customCampaignModuleService =
+    req.scope.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+
+  try {
+    const [campaignDetail] =
+      await customCampaignModuleService.listCampaignDetails({
+        campaign_id,
+      });
+
+    if (!campaignDetail || !campaignDetail.thumbnail_file_id) {
+      return res.status(404).json({
+        error: "Campaign thumbnail not found",
+      });
+    }
+
+    // Delete file
+    await deleteFilesWorkflow(req.scope).run({
+      input: {
+        ids: [campaignDetail.thumbnail_file_id],
+      },
+    });
+
+    // Update campaign detail
+    const [updatedDetail] =
+      await customCampaignModuleService.updateCampaignDetails([
+        {
+          id: campaignDetail.id,
+          thumbnail_url: null,
+          thumbnail_file_id: null,
+        },
+      ]);
+
+    res.status(200).json({ campaign_detail: updatedDetail });
+  } catch (error) {
+    console.error("Error deleting campaign thumbnail:", error);
+    res.status(500).json({
+      error: "Failed to delete campaign thumbnail",
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
+};

package/src/api/admin/campaigns/sync/route.ts

@@ -19,12 +19,24 @@ export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
     console.log(`Found ${allCampaigns.length} total campaigns`);
 
     // Get existing custom campaign types
-    const existingTypes = await customCampaignModuleService.listCustomCampaignTypes({});
-    const existingCampaignIds = new Set(existingTypes.map((ct) => ct.campaign_id));
+    const existingTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({});
+    const existingCampaignIds = new Set(
+      existingTypes.map((ct) => ct.campaign_id),
+    );
     console.log(`Found ${existingTypes.length} existing custom campaign types`);
 
-    const created = [];
-    const skipped = [];
+    const created: Array<{
+      id: string;
+      name: string | undefined;
+      type: CampaignTypeEnum;
+      custom_type_id: string;
+    }> = [];
+    const skipped: Array<{
+      id: string;
+      name: string | undefined;
+      reason: string;
+    }> = [];
 
     // Create custom campaign types for campaigns that don't have them
     for (const campaign of allCampaigns) {
@@ -42,18 +54,22 @@ export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
         let type = CampaignTypeEnum.FlashSale; // Default to flash sale
 
         const nameLower = campaign.name?.toLowerCase() || "";
-        const identifierLower = campaign.campaign_identifier?.toLowerCase() || "";
-
-        if (nameLower.includes("bogo") ||
-            nameLower.includes("buy") && nameLower.includes("get") ||
-            identifierLower.includes("buy-x-get-y")) {
+        const identifierLower =
+          campaign.campaign_identifier?.toLowerCase() || "";
+
+        if (
+          nameLower.includes("bogo") ||
+          (nameLower.includes("buy") && nameLower.includes("get")) ||
+          identifierLower.includes("buy-x-get-y")
+        ) {
           type = CampaignTypeEnum.BuyXGetY;
         }
 
-        const result = await customCampaignModuleService.createCustomCampaignTypes({
-          campaign_id: campaign.id,
-          type: type,
-        });
+        const result =
+          await customCampaignModuleService.createCustomCampaignTypes({
+            campaign_id: campaign.id,
+            type: type,
+          });
 
         created.push({
           id: campaign.id,
@@ -62,9 +78,14 @@ export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
           custom_type_id: result.id,
         });
 
-        console.log(`✅ Created custom type for campaign: ${campaign.name} (${type})`);
+        console.log(
+          `✅ Created custom type for campaign: ${campaign.name} (${type})`,
+        );
       } catch (error) {
-        console.error(`❌ Failed to create custom type for campaign ${campaign.id}:`, error);
+        console.error(
+          `❌ Failed to create custom type for campaign ${campaign.id}:`,
+          error,
+        );
         skipped.push({
           id: campaign.id,
           name: campaign.name,
@@ -105,12 +126,11 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
   try {
     // Get all campaigns and custom types
     const allCampaigns = await promotionService.listCampaigns({});
-    const customTypes = await customCampaignModuleService.listCustomCampaignTypes({});
+    const customTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({});
 
     // Map custom types by campaign ID
-    const typeMap = new Map(
-      customTypes.map((ct) => [ct.campaign_id, ct])
-    );
+    const typeMap = new Map(customTypes.map((ct) => [ct.campaign_id, ct]));
 
     // Check which campaigns have custom types
     const campaignStatus = allCampaigns.map((campaign: any) => {
@@ -121,15 +141,19 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
         name: campaign.name,
         campaign_identifier: campaign.campaign_identifier,
         hasCustomType: !!customType,
-        customType: customType ? {
-          id: customType.id,
-          type: customType.type,
-        } : null,
+        customType: customType
+          ? {
+              id: customType.id,
+              type: customType.type,
+            }
+          : null,
       };
     });
 
     const withCustomType = campaignStatus.filter((c: any) => c.hasCustomType);
-    const withoutCustomType = campaignStatus.filter((c: any) => !c.hasCustomType);
+    const withoutCustomType = campaignStatus.filter(
+      (c: any) => !c.hasCustomType,
+    );
 
     res.status(200).json({
       summary: {
@@ -139,9 +163,10 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
       },
       withCustomType,
       withoutCustomType,
-      recommendation: withoutCustomType.length > 0
-        ? "Run POST /admin/campaigns/sync to create missing custom types"
-        : "All campaigns have custom types",
+      recommendation:
+        withoutCustomType.length > 0
+          ? "Run POST /admin/campaigns/sync to create missing custom types"
+          : "All campaigns have custom types",
     });
   } catch (error) {
     console.error("Error checking sync status:", error);
@@ -150,4 +175,4 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
       details: error instanceof Error ? error.message : String(error),
     });
   }
-};
+};

package/src/api/admin/flash-sales/[id]/route.ts

@@ -19,7 +19,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
   if (!id) {
     throw new MedusaError(
       MedusaError.Types.INVALID_DATA,
-      "Campaign ID is required"
+      "Campaign ID is required",
     );
   }
 
@@ -38,24 +38,30 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
         campaign_id: id,
       });
 
-    console.log(`Found ${customCampaignTypes.length} campaign types for ID ${id}`);
+    console.log(
+      `Found ${customCampaignTypes.length} campaign types for ID ${id}`,
+    );
 
     if (customCampaignTypes.length === 0) {
       throw new MedusaError(
         MedusaError.Types.NOT_FOUND,
-        `Flash sale with ID ${id} not found`
+        `Flash sale with ID ${id} not found`,
       );
     }
 
     // Fetch the campaign from promotion service
     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,
-        `Flash sale with ID ${id} not found`
+        `Flash sale with ID ${id} not found`,
       );
     }
 
@@ -72,9 +78,23 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     const promotionLimitsMap = new Map();
     promotionUsageLimits.forEach((limit) => {
       promotionLimitsMap.set(limit.promotion_id, limit);
-      console.log(`  Limit for promotion ${limit.promotion_id}: ${limit.limit} (used: ${limit.used})`);
+      console.log(
+        `  Limit for promotion ${limit.promotion_id}: ${limit.limit} (used: ${limit.used})`,
+      );
     });
 
+    // Fetch campaign details
+    console.log(`Fetching campaign details for campaign ${id}`);
+    const [campaignDetail] =
+      await customCampaignModuleService.listCampaignDetails({
+        campaign_id: id,
+      });
+    console.log(
+      campaignDetail
+        ? `Found campaign detail with image: ${campaignDetail.image_url}`
+        : "No campaign detail found",
+    );
+
     // Process promotions to extract product information
     const products: CustomCampaign["products"] = [];
     for await (const promotion of campaign.promotions ?? []) {
@@ -87,7 +107,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
 
       const productRule = promotion.application_method.target_rules.find(
         (rule) =>
-          rule.attribute === "items.product.id" && rule.operator === "eq"
+          rule.attribute === "items.product.id" && rule.operator === "eq",
       );
       const promotionLimit = promotionLimitsMap.get(promotion.id);
 
@@ -97,13 +117,15 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
       }
 
       if (!promotionLimit.product_id) {
-        console.log(`  No product_id in usage limit for promotion ${promotion.id}`);
+        console.log(
+          `  No product_id in usage limit for promotion ${promotion.id}`,
+        );
         continue;
       }
 
       try {
         const product = await productService.retrieveProduct(
-          promotionLimit.product_id
+          promotionLimit.product_id,
         );
 
         if (productRule && promotion.application_method.value !== undefined) {
@@ -112,22 +134,31 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
               id: product.id,
               title: product.title,
             },
-            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,
+            maxQty: promotion.application_method?.max_quantity ?? 0,
+            limit: promotionLimit?.limit ?? 0,
           });
           console.log(`  Added product ${product.title} to response`);
         }
       } catch (productError) {
-        console.error(`  Error fetching product ${promotionLimit.product_id}:`, productError);
+        console.error(
+          `  Error fetching product ${promotionLimit.product_id}:`,
+          productError,
+        );
       }
     }
 
     res.status(200).json({
       ...campaign,
+      name: campaign.name!,
+      description: campaign.description!,
+      starts_at: campaign.starts_at!,
+      ends_at: campaign.ends_at!,
+      type: CampaignTypeEnum.FlashSale,
       products,
-    } satisfies CustomCampaign);
+      campaign_detail: campaignDetail || null,
+    } satisfies CustomCampaign & { campaign_detail: any });
   } catch (error) {
     if (error instanceof MedusaError) {
       throw error;
@@ -136,7 +167,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     console.error("Error fetching flash sale:", error);
     throw new MedusaError(
       MedusaError.Types.UNEXPECTED_STATE,
-      "An error occurred while fetching the flash sale"
+      "An error occurred while fetching the flash sale",
     );
   }
 };
@@ -146,7 +177,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
  */
 export const PUT = async (
   req: MedusaRequest<CustomCampaign>,
-  res: MedusaResponse
+  res: MedusaResponse,
 ) => {
   const { id } = req.params;
   const body = req.body;
@@ -154,7 +185,7 @@ export const PUT = async (
   if (!id) {
     throw new MedusaError(
       MedusaError.Types.INVALID_DATA,
-      "Campaign ID is required"
+      "Campaign ID is required",
     );
   }
 
@@ -163,7 +194,7 @@ export const PUT = async (
     if (new Date(body.ends_at) < new Date(body.starts_at)) {
       throw new MedusaError(
         MedusaError.Types.INVALID_DATA,
-        "End date must be after start date"
+        "End date must be after start date",
       );
     }
 
@@ -184,7 +215,7 @@ export const PUT = async (
     console.error("Error updating flash sale:", error);
     throw new MedusaError(
       MedusaError.Types.UNEXPECTED_STATE,
-      "An error occurred while updating the flash sale"
+      "An error occurred while updating the flash sale",
     );
   }
 };

package/src/api/middlewares.ts

@@ -7,6 +7,11 @@ import {
   createCustomCampaignSchema,
   GetFlashSalesSchema,
 } from "./admin/flash-sales/route";
+import multer from "multer";
+
+const upload = multer({
+  storage: multer.memoryStorage(),
+});
 
 export default defineMiddlewares([
   {
@@ -29,4 +34,20 @@ export default defineMiddlewares([
       }),
     ],
   },
+  {
+    methods: ["POST"],
+    matcher: "/admin/campaigns/:id/image",
+    middlewares: [
+      // @ts-ignore
+      upload.single("file"),
+    ],
+  },
+  {
+    methods: ["POST"],
+    matcher: "/admin/campaigns/:id/thumbnail",
+    middlewares: [
+      // @ts-ignore
+      upload.single("file"),
+    ],
+  },
 ]);

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

@@ -13,7 +13,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
   if (!id) {
     throw new MedusaError(
       MedusaError.Types.INVALID_DATA,
-      "Campaign ID is required"
+      "Campaign ID is required",
     );
   }
 
@@ -35,7 +35,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     if (customCampaignTypes.length === 0) {
       throw new MedusaError(
         MedusaError.Types.NOT_FOUND,
-        `Buy X Get Y campaign with ID ${id} not found`
+        `Buy X Get Y campaign with ID ${id} not found`,
       );
     }
 
@@ -45,19 +45,19 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     if (!campaign) {
       throw new MedusaError(
         MedusaError.Types.NOT_FOUND,
-        `Buy X Get Y campaign with ID ${id} 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 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",
       );
     }
 
@@ -69,13 +69,13 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
 
     // 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,
     );
 
     if (availableConfigs.length === 0) {
       throw new MedusaError(
         MedusaError.Types.NOT_ALLOWED,
-        "This campaign has no available promotions"
+        "This campaign has no available promotions",
       );
     }
 
@@ -119,7 +119,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
           rewardValue: config.reward_value,
           remaining: config.limit ? config.limit - config.used : null,
         };
-      })
+      }),
     );
 
     res.status(200).json({
@@ -140,7 +140,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     console.error("Error fetching Buy X Get Y 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/api/store/buy-x-get-y/products/[productId]/route.ts

@@ -2,7 +2,6 @@ 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
@@ -14,7 +13,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
   if (!productId) {
     throw new MedusaError(
       MedusaError.Types.INVALID_DATA,
-      "Product ID is required"
+      "Product ID is required",
     );
   }
 
@@ -46,7 +45,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
 
     // Get campaign details for each config
     const campaignIds = Array.from(
-      new Set(buyXGetYConfigs.map((config) => config.campaign_id))
+      new Set(buyXGetYConfigs.map((config) => config.campaign_id)),
     );
 
     const campaigns = await promotionService.listCampaigns({
@@ -61,14 +60,14 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
           const endsAt = new Date(campaign.ends_at);
           return startsAt <= now && endsAt >= now;
         })
-        .map((campaign: any) => campaign.id)
+        .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)
+        (!config.limit || config.used < config.limit),
     );
 
     if (activeConfigs.length === 0) {
@@ -82,19 +81,19 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     const promotions = await Promise.all(
       activeConfigs.map(async (config) => {
         const campaign = campaigns.find(
-          (c: any) => c.id === config.campaign_id
+          (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,
+          campaign_id: campaign!.id,
+          campaign_name: campaign!.name,
           trigger_quantity: config.trigger_quantity,
           reward_product: {
             id: rewardProduct.id,
@@ -106,9 +105,9 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
           reward_type: config.reward_type,
           reward_value: config.reward_value,
           remaining: config.limit ? config.limit - config.used : null,
-          ends_at: campaign.ends_at,
+          ends_at: campaign!.ends_at,
         };
-      })
+      }),
     );
 
     res.status(200).json({
@@ -123,7 +122,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     console.error("Error checking product BOGO promotions:", error);
     throw new MedusaError(
       MedusaError.Types.UNEXPECTED_STATE,
-      "An error occurred while checking promotions"
+      "An error occurred while checking promotions",
     );
   }
 };

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

@@ -15,6 +15,8 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
 
   try {
     const now = new Date();
+    const take = parseInt(req.query.limit as string) || 20;
+    const skip = parseInt(req.query.offset as string) || 0;
 
     // Get all Buy X Get Y campaign types
     const customCampaignTypes =
@@ -22,7 +24,9 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
         type: CampaignTypeEnum.BuyXGetY,
       });
 
-    console.log(`Found ${customCampaignTypes.length} Buy X Get Y campaign types`);
+    console.log(
+      `Found ${customCampaignTypes.length} Buy X Get Y campaign types`,
+    );
 
     if (customCampaignTypes.length === 0) {
       return res.status(200).json({
@@ -59,7 +63,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
 
         // 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,
         );
 
         if (availableConfigs.length === 0) {
@@ -98,7 +102,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
               rewardValue: config.reward_value,
               remaining: config.limit ? config.limit - config.used : null,
             };
-          })
+          }),
         );
 
         return {
@@ -109,7 +113,7 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
           ends_at: campaign.ends_at,
           rules,
         };
-      })
+      }),
     );
 
     // Filter out null campaigns (those with no available rules)
@@ -122,7 +126,10 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
       offset: skip,
     });
   } catch (error) {
-    console.error("Error fetching Buy X Get Y campaigns for storefront:", error);
+    console.error(
+      "Error fetching Buy X Get Y campaigns for storefront:",
+      error,
+    );
     res.status(500).json({
       campaigns: [],
       count: 0,