@lodashventure/medusa-campaign 1.1.4 → 1.1.6

package/src/api/admin/campaigns/fix-dates/route.ts

@@ -0,0 +1,107 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import { Modules } from "@medusajs/framework/utils";
+import { updateCampaignsWorkflow } from "@medusajs/medusa/core-flows";
+
+/**
+ * POST handler to fix campaign dates - makes all campaigns active for testing
+ */
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  try {
+    // Get all campaigns
+    const allCampaigns = await promotionService.listCampaigns({});
+
+    console.log(`Found ${allCampaigns.length} campaigns to fix`);
+
+    const updatedCampaigns = [];
+
+    // Update each campaign to be active for the whole year
+    for (const campaign of allCampaigns) {
+      try {
+        const result = await updateCampaignsWorkflow.run({
+          input: {
+            campaignsData: [
+              {
+                id: campaign.id,
+                starts_at: new Date("2024-01-01T00:00:00Z"),
+                ends_at: new Date("2025-12-31T23:59:59Z"),
+              },
+            ],
+          },
+        });
+
+        updatedCampaigns.push({
+          id: campaign.id,
+          name: campaign.name,
+          old_starts_at: campaign.starts_at,
+          old_ends_at: campaign.ends_at,
+          new_starts_at: "2024-01-01T00:00:00Z",
+          new_ends_at: "2025-12-31T23:59:59Z",
+        });
+
+        console.log(`✅ Fixed dates for campaign: ${campaign.name}`);
+      } catch (error) {
+        console.error(`❌ Failed to update campaign ${campaign.id}:`, error);
+      }
+    }
+
+    res.status(200).json({
+      success: true,
+      message: `Updated ${updatedCampaigns.length} campaigns`,
+      campaigns: updatedCampaigns,
+    });
+  } catch (error) {
+    console.error("Error fixing campaign dates:", error);
+    res.status(500).json({
+      error: "Failed to fix campaign dates",
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
+};
+
+/**
+ * GET handler to show current campaign dates
+ */
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const promotionService = container.resolve(Modules.PROMOTION);
+  const now = new Date();
+
+  try {
+    const allCampaigns = await promotionService.listCampaigns({});
+
+    const campaignDates = allCampaigns.map((campaign: any) => {
+      const startsAt = new Date(campaign.starts_at);
+      const endsAt = new Date(campaign.ends_at);
+      const isActive = startsAt <= now && endsAt >= now;
+
+      return {
+        id: campaign.id,
+        name: campaign.name,
+        starts_at: campaign.starts_at,
+        ends_at: campaign.ends_at,
+        isActive,
+        reason: !isActive
+          ? (startsAt > now ? "Not started yet" : "Already ended")
+          : "Active",
+      };
+    });
+
+    res.status(200).json({
+      currentTime: now.toISOString(),
+      campaigns: campaignDates,
+      summary: {
+        total: campaignDates.length,
+        active: campaignDates.filter((c: any) => c.isActive).length,
+        notStarted: campaignDates.filter((c: any) => c.reason === "Not started yet").length,
+        ended: campaignDates.filter((c: any) => c.reason === "Already ended").length,
+      },
+    });
+  } catch (error) {
+    console.error("Error checking campaign dates:", error);
+    res.status(500).json({
+      error: "Failed to check campaign dates",
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
+};

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

@@ -0,0 +1,153 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import { 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";
+
+/**
+ * POST handler to sync existing campaigns with custom campaign types
+ * This creates the missing custom_campaign_type records for existing campaigns
+ */
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  try {
+    // Get all campaigns from promotion service
+    const allCampaigns = await promotionService.listCampaigns({});
+    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));
+    console.log(`Found ${existingTypes.length} existing custom campaign types`);
+
+    const created = [];
+    const skipped = [];
+
+    // Create custom campaign types for campaigns that don't have them
+    for (const campaign of allCampaigns) {
+      if (existingCampaignIds.has(campaign.id)) {
+        skipped.push({
+          id: campaign.id,
+          name: campaign.name,
+          reason: "Already has custom campaign type",
+        });
+        continue;
+      }
+
+      try {
+        // Determine type based on campaign name or identifier
+        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")) {
+          type = CampaignTypeEnum.BuyXGetY;
+        }
+
+        const result = await customCampaignModuleService.createCustomCampaignTypes({
+          campaign_id: campaign.id,
+          type: type,
+        });
+
+        created.push({
+          id: campaign.id,
+          name: campaign.name,
+          type: type,
+          custom_type_id: result.id,
+        });
+
+        console.log(`✅ Created custom type for campaign: ${campaign.name} (${type})`);
+      } catch (error) {
+        console.error(`❌ Failed to create custom type for campaign ${campaign.id}:`, error);
+        skipped.push({
+          id: campaign.id,
+          name: campaign.name,
+          reason: error instanceof Error ? error.message : "Unknown error",
+        });
+      }
+    }
+
+    res.status(200).json({
+      success: true,
+      message: `Synced ${created.length} campaigns`,
+      created,
+      skipped,
+      summary: {
+        totalCampaigns: allCampaigns.length,
+        existingTypes: existingTypes.length,
+        newlyCreated: created.length,
+        skipped: skipped.length,
+      },
+    });
+  } catch (error) {
+    console.error("Error syncing campaigns:", error);
+    res.status(500).json({
+      error: "Failed to sync campaigns",
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
+};
+
+/**
+ * GET handler to check sync status
+ */
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const promotionService = container.resolve(Modules.PROMOTION);
+
+  try {
+    // Get all campaigns and custom types
+    const allCampaigns = await promotionService.listCampaigns({});
+    const customTypes = await customCampaignModuleService.listCustomCampaignTypes({});
+
+    // Map custom types by campaign ID
+    const typeMap = new Map(
+      customTypes.map((ct) => [ct.campaign_id, ct])
+    );
+
+    // Check which campaigns have custom types
+    const campaignStatus = allCampaigns.map((campaign: any) => {
+      const customType = typeMap.get(campaign.id);
+
+      return {
+        id: campaign.id,
+        name: campaign.name,
+        campaign_identifier: campaign.campaign_identifier,
+        hasCustomType: !!customType,
+        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);
+
+    res.status(200).json({
+      summary: {
+        totalCampaigns: allCampaigns.length,
+        withCustomType: withCustomType.length,
+        withoutCustomType: withoutCustomType.length,
+      },
+      withCustomType,
+      withoutCustomType,
+      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);
+    res.status(500).json({
+      error: "Failed to check sync status",
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
+};

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

@@ -7,6 +7,8 @@ import {
 import { CampaignTypeEnum } from "../../../../modules/custom-campaigns/types/campaign-type.enum";
 import { CustomCampaign, createCustomCampaignSchema } from "../route";
 import { updateCustomFlashSaleWorkflow } from "../../../../workflows/custom-campaign/updateCustomFlashSaleWorkflow";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../../../modules/custom-campaigns/service";
 
 /**
  * GET handler for fetching a specific flash sale by ID
@@ -21,29 +23,34 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     );
   }
 
-  const query = container.resolve(ContainerRegistrationKeys.QUERY);
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
   const productService = container.resolve(Modules.PRODUCT);
+  const promotionService = container.resolve(Modules.PROMOTION);
 
   try {
+    console.log(`Fetching flash sale with ID: ${id}`);
+
     // First, find the custom campaign type by campaign ID
-    const {
-      data: [customCampaignTypes],
-    } = await query.graph({
-      entity: "custom_campaign_type",
-      fields: [
-        "id",
-        "campaign.*",
-        "campaign.promotions.*",
-        "campaign.promotions.application_method.*",
-        "campaign.promotions.application_method.target_rules.*",
-      ],
-      filters: {
+    const customCampaignTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({
         type: CampaignTypeEnum.FlashSale,
         campaign_id: id,
-      },
-    });
+      });
 
-    const campaign = customCampaignTypes.campaign;
+    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`
+      );
+    }
+
+    // Fetch the campaign from promotion service
+    const campaign = await promotionService.retrieveCampaign(id, {
+      relations: ["promotions", "promotions.application_method", "promotions.application_method.target_rules"],
+    });
 
     if (!campaign) {
       throw new MedusaError(
@@ -53,24 +60,28 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
     }
 
     // Fetch promotion usage limits for the campaign
-    const { data: promotionUsageLimits } = await query.graph({
-      entity: "promotion_usage_limit",
-      fields: ["id", "promotion_id", "product_id", "limit", "used"],
-      filters: {
+    console.log(`Fetching promotion usage limits for campaign ${id}`);
+    const promotionUsageLimits =
+      await customCampaignModuleService.listPromotionUsageLimits({
         campaign_id: id,
-      },
-    });
+      });
+
+    console.log(`Found ${promotionUsageLimits.length} promotion usage limits`);
 
     // Create a map of promotion usage limits by promotion ID
     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})`);
     });
 
     // Process promotions to extract product information
     const products: CustomCampaign["products"] = [];
     for await (const promotion of campaign.promotions ?? []) {
+      console.log(`Processing promotion ${promotion.id}`);
+
       if (!promotion.application_method?.target_rules?.length) {
+        console.log(`  No target rules for promotion ${promotion.id}`);
         continue;
       }
 
@@ -80,21 +91,36 @@ export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
       );
       const promotionLimit = promotionLimitsMap.get(promotion.id);
 
-      const product = await productService.retrieveProduct(
-        promotionLimit?.product_id
-      );
+      if (!promotionLimit) {
+        console.log(`  No usage limit found for promotion ${promotion.id}`);
+        continue;
+      }
+
+      if (!promotionLimit.product_id) {
+        console.log(`  No product_id in usage limit for promotion ${promotion.id}`);
+        continue;
+      }
 
-      if (productRule && promotion.application_method.value) {
-        products.push({
-          product: {
-            id: product.id,
-            title: product.title,
-          },
-          discountType: promotion.application_method?.type,
-          discountValue: promotion.application_method?.value,
-          maxQty: promotion.application_method?.max_quantity,
-          limit: promotionLimitsMap.get(promotion.id)?.limit,
-        });
+      try {
+        const product = await productService.retrieveProduct(
+          promotionLimit.product_id
+        );
+
+        if (productRule && promotion.application_method.value !== undefined) {
+          products.push({
+            product: {
+              id: product.id,
+              title: product.title,
+            },
+            discountType: promotion.application_method?.type,
+            discountValue: promotion.application_method?.value,
+            maxQty: promotion.application_method?.max_quantity,
+            limit: promotionLimit?.limit,
+          });
+          console.log(`  Added product ${product.title} to response`);
+        }
+      } catch (productError) {
+        console.error(`  Error fetching product ${promotionLimit.product_id}:`, productError);
       }
     }
 

package/src/api/admin/flash-sales/route.ts

@@ -2,11 +2,14 @@ import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
 import {
   ContainerRegistrationKeys,
   MedusaError,
+  Modules,
 } from "@medusajs/framework/utils";
 import { createFindParams } from "@medusajs/medusa/api/utils/validators";
 import z from "zod";
 import { CampaignTypeEnum } from "../../../modules/custom-campaigns/types/campaign-type.enum";
 import { createCustomCampaignWorkflow } from "../../../workflows/custom-campaign/createCustomCampaignWorkflow";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../../modules/custom-campaigns/service";
 
 export const createCustomCampaignSchema = z.object({
   name: z.string().min(1, "Name is required"),
@@ -61,27 +64,60 @@ export const POST = async (
 };
 
 export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
-  const query = container.resolve(ContainerRegistrationKeys.QUERY);
-  const {
-    data: customCampaigns,
-    metadata: { count, take, skip } = {
-      count: 0,
-      take: 20,
-      skip: 0,
-    },
-  } = await query.graph({
-    entity: "custom_campaign_type",
-    ...req.queryConfig,
-    fields: ["id", "campaign.*", "campaign.promotions.*"],
-    filters: { type: CampaignTypeEnum.FlashSale },
-  });
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+  const promotionService = container.resolve(Modules.PROMOTION);
 
-  const campaigns = customCampaigns.map((campaign) => campaign.campaign);
+  try {
+    console.log("Fetching flash sale campaigns...");
 
-  res.status(200).json({
-    campaigns,
-    count,
-    limit: take,
-    offset: skip,
-  });
+    // Get all flash sale campaign types
+    const customCampaignTypes =
+      await customCampaignModuleService.listCustomCampaignTypes({
+        type: CampaignTypeEnum.FlashSale,
+      });
+
+    console.log(`Found ${customCampaignTypes.length} flash sale campaign types`);
+
+    if (customCampaignTypes.length === 0) {
+      return res.status(200).json({
+        campaigns: [],
+        count: 0,
+        limit: 20,
+        offset: 0,
+      });
+    }
+
+    // Get campaign IDs
+    const campaignIds = customCampaignTypes.map((ct) => ct.campaign_id);
+
+    // Fetch campaigns from promotion service
+    const campaigns = await promotionService.listCampaigns(
+      {
+        id: campaignIds,
+      },
+      {
+        relations: ["promotions"],
+      }
+    );
+
+    console.log(`Found ${campaigns.length} campaigns from promotion service`);
+
+    res.status(200).json({
+      campaigns,
+      count: campaigns.length,
+      limit: 20,
+      offset: 0,
+    });
+  } catch (error) {
+    console.error("Error fetching flash sales:", error);
+    res.status(500).json({
+      campaigns: [],
+      count: 0,
+      limit: 20,
+      offset: 0,
+      error: "Failed to fetch flash sales",
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
 };

package/src/api/admin/force-fix/route.ts

@@ -0,0 +1,184 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import { Modules } from "@medusajs/framework/utils";
+import { updateCampaignsWorkflow } from "@medusajs/medusa/core-flows";
+import { CampaignTypeEnum } from "../../../modules/custom-campaigns/types/campaign-type.enum";
+
+/**
+ * POST handler to force fix all campaigns in one go
+ * This will sync types and fix dates
+ */
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const promotionService = container.resolve(Modules.PROMOTION);
+  const results: any = {
+    timestamp: new Date().toISOString(),
+    steps: []
+  };
+
+  try {
+    // Step 1: Get all campaigns
+    const allCampaigns = await promotionService.listCampaigns({});
+    results.steps.push({
+      step: "Get campaigns",
+      status: "✅",
+      count: allCampaigns.length
+    });
+
+    if (allCampaigns.length === 0) {
+      return res.status(200).json({
+        ...results,
+        message: "No campaigns found to fix"
+      });
+    }
+
+    // Step 2: Try to get custom campaign module
+    let customModule: any;
+    try {
+      customModule = container.resolve("customCampaign");
+      results.steps.push({
+        step: "Resolve custom module",
+        status: "✅"
+      });
+    } catch {
+      results.steps.push({
+        step: "Resolve custom module",
+        status: "❌",
+        message: "Module not available - creating types manually"
+      });
+    }
+
+    // Step 3: Fix dates for all campaigns
+    const dateFixResults = [];
+    for (const campaign of allCampaigns) {
+      try {
+        await updateCampaignsWorkflow.run({
+          input: {
+            campaignsData: [{
+              id: campaign.id,
+              starts_at: new Date("2024-01-01T00:00:00Z"),
+              ends_at: new Date("2025-12-31T23:59:59Z")
+            }]
+          }
+        });
+        dateFixResults.push({
+          id: campaign.id,
+          name: campaign.name,
+          status: "✅ Dates fixed"
+        });
+      } catch (e) {
+        dateFixResults.push({
+          id: campaign.id,
+          name: campaign.name,
+          status: "❌ Failed",
+          error: e instanceof Error ? e.message : String(e)
+        });
+      }
+    }
+
+    results.steps.push({
+      step: "Fix campaign dates",
+      status: "✅",
+      fixed: dateFixResults.filter(r => r.status.includes("✅")).length,
+      failed: dateFixResults.filter(r => r.status.includes("❌")).length,
+      details: dateFixResults
+    });
+
+    // Step 4: Create custom types if module is available
+    if (customModule) {
+      const existingTypes = await customModule.listCustomCampaignTypes({});
+      const existingCampaignIds = new Set(existingTypes.map((t: any) => t.campaign_id));
+
+      const typeCreationResults = [];
+      for (const campaign of allCampaigns) {
+        if (existingCampaignIds.has(campaign.id)) {
+          typeCreationResults.push({
+            id: campaign.id,
+            name: campaign.name,
+            status: "⏭️ Already has type"
+          });
+          continue;
+        }
+
+        try {
+          // Determine type based on name
+          const type = campaign.name?.toLowerCase().includes("bogo") ||
+                       campaign.name?.toLowerCase().includes("buy") && campaign.name?.toLowerCase().includes("get")
+                       ? CampaignTypeEnum.BuyXGetY
+                       : CampaignTypeEnum.FlashSale;
+
+          await customModule.createCustomCampaignTypes({
+            campaign_id: campaign.id,
+            type: type
+          });
+
+          typeCreationResults.push({
+            id: campaign.id,
+            name: campaign.name,
+            type: type,
+            status: "✅ Type created"
+          });
+        } catch (e) {
+          typeCreationResults.push({
+            id: campaign.id,
+            name: campaign.name,
+            status: "❌ Failed",
+            error: e instanceof Error ? e.message : String(e)
+          });
+        }
+      }
+
+      results.steps.push({
+        step: "Create custom types",
+        status: "✅",
+        created: typeCreationResults.filter(r => r.status.includes("✅")).length,
+        skipped: typeCreationResults.filter(r => r.status.includes("⏭️")).length,
+        failed: typeCreationResults.filter(r => r.status.includes("❌")).length,
+        details: typeCreationResults
+      });
+    }
+
+    // Step 5: Direct database update as fallback
+    if (!customModule) {
+      try {
+        const db = container.resolve("__pg_connection__");
+
+        for (const campaign of allCampaigns) {
+          const type = campaign.name?.toLowerCase().includes("bogo") ||
+                       campaign.name?.toLowerCase().includes("buy") && campaign.name?.toLowerCase().includes("get")
+                       ? "buy-x-get-y"
+                       : "flash-sale";
+
+          await db.raw(`
+            INSERT INTO custom_campaign_type (id, campaign_id, type, created_at, updated_at)
+            VALUES (?, ?, ?, NOW(), NOW())
+            ON CONFLICT (campaign_id) WHERE deleted_at IS NULL
+            DO UPDATE SET type = EXCLUDED.type, updated_at = NOW()
+          `, [`cct_${Date.now()}_${campaign.id}`, campaign.id, type]);
+        }
+
+        results.steps.push({
+          step: "Direct DB insert for custom types",
+          status: "✅"
+        });
+      } catch (e) {
+        results.steps.push({
+          step: "Direct DB insert for custom types",
+          status: "❌",
+          error: e instanceof Error ? e.message : String(e)
+        });
+      }
+    }
+
+    results.success = true;
+    results.message = "Force fix completed";
+
+    res.status(200).json(results);
+  } catch (error) {
+    res.status(500).json({
+      ...results,
+      success: false,
+      error: "Failed to force fix campaigns",
+      details: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined
+    });
+  }
+};