@lodashventure/medusa-campaign 1.1.4 → 1.1.6

package/src/admin/components/BuyXGetYForm.tsx

@@ -0,0 +1,422 @@
+import { Trash } from "@medusajs/icons";
+import {
+  Button,
+  Container,
+  Input,
+  Label,
+  Select,
+  Table,
+  Textarea,
+  toast,
+} from "@medusajs/ui";
+import dayjs from "dayjs";
+import { FC, useState } from "react";
+import { Controller, useFieldArray, useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import z from "zod";
+import { ProductSelector } from "./ProductSelector";
+
+const buyXGetYCampaignSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  description: z.string().min(1, "Description is required"),
+  type: z.literal("buy-x-get-y"),
+  starts_at: z.string().min(1, "Start date is required"),
+  ends_at: z.string().min(1, "End date is required"),
+});
+
+const buyXGetYRuleSchema = z.object({
+  triggerProduct: z.object({
+    id: z.string(),
+    title: z.string(),
+  }),
+  triggerQuantity: z.number().min(1, "Trigger quantity must be at least 1"),
+  rewardProduct: z.object({
+    id: z.string(),
+    title: z.string(),
+  }),
+  rewardQuantity: z.number().min(1, "Reward quantity must be at least 1"),
+  rewardType: z.enum(["free", "percentage", "fixed"]),
+  rewardValue: z.number().optional(),
+  limit: z.number().min(1).optional(),
+});
+
+export type BuyXGetYRule = z.infer<typeof buyXGetYRuleSchema>;
+
+export const buyXGetYDataSchema = buyXGetYCampaignSchema
+  .extend({
+    rules: z
+      .array(buyXGetYRuleSchema)
+      .min(1, "At least one rule is required"),
+  })
+  .refine(
+    (data) => new Date(data.starts_at) < new Date(data.ends_at),
+    "End date must be after start date"
+  );
+
+export type BuyXGetYData = z.infer<typeof buyXGetYDataSchema>;
+
+interface BuyXGetYFormProps {
+  initialData?: z.infer<typeof buyXGetYCampaignSchema>;
+  initialRules?: BuyXGetYRule[];
+  onSubmit: (data: BuyXGetYData) => void;
+  onCancel: () => void;
+  disabled?: boolean;
+}
+
+export const BuyXGetYForm: FC<BuyXGetYFormProps> = ({
+  initialData,
+  initialRules,
+  onSubmit,
+  onCancel,
+  disabled = false,
+}) => {
+  const {
+    control,
+    register,
+    handleSubmit,
+    watch,
+    setValue,
+    formState: { errors },
+  } = useForm<BuyXGetYData>({
+    resolver: zodResolver(buyXGetYDataSchema),
+    defaultValues: {
+      name: initialData?.name || "",
+      description: initialData?.description || "",
+      type: "buy-x-get-y",
+      starts_at: initialData?.starts_at || "",
+      ends_at: initialData?.ends_at || "",
+      rules: initialRules || [],
+    },
+  });
+
+  const { fields, append, remove } = useFieldArray({
+    control,
+    name: "rules",
+  });
+
+  const [openTriggerProductModal, setOpenTriggerProductModal] = useState<number | null>(null);
+  const [openRewardProductModal, setOpenRewardProductModal] = useState<number | null>(null);
+
+  const startsAt = watch("starts_at");
+  const endsAt = watch("ends_at");
+
+  const handleDateTimeChange = (
+    field: "starts_at" | "ends_at",
+    type: "date" | "time",
+    value: string
+  ) => {
+    const currentValue = watch(field);
+
+    if (type === "date") {
+      const time = currentValue
+        ? dayjs(currentValue).format("HH:mm")
+        : field === "starts_at"
+        ? "00:00"
+        : "23:59";
+      setValue(field, `${value}T${time}`);
+    } else {
+      const date = currentValue
+        ? dayjs(currentValue).format("YYYY-MM-DD")
+        : dayjs().format("YYYY-MM-DD");
+      setValue(field, `${date}T${value}`);
+    }
+  };
+
+  const onFormSubmit = (data: BuyXGetYData) => {
+    onSubmit(data);
+  };
+
+  const onFormError = () => {
+    const errorMessages = Object.entries(errors)
+      .map(([key, value]) => {
+        if (key === "rules" && Array.isArray(value)) {
+          return value
+            .map((item, index) =>
+              item
+                ? `Rule ${index + 1}: ${Object.values(item).map(v => v?.message).filter(Boolean).join(", ")}`
+                : ""
+            )
+            .filter(Boolean)
+            .join(", ");
+        }
+        return value?.message;
+      })
+      .filter(Boolean)
+      .join(", ");
+
+    toast.error("Invalid data", {
+      description: errorMessages,
+    });
+  };
+
+  const addNewRule = () => {
+    append({
+      triggerProduct: { id: "", title: "" },
+      triggerQuantity: 1,
+      rewardProduct: { id: "", title: "" },
+      rewardQuantity: 1,
+      rewardType: "free",
+      rewardValue: undefined,
+      limit: undefined,
+    });
+  };
+
+  return (
+    <Container>
+      <div className="flex items-center justify-between">
+        <h1 className="text-xl font-semibold">Buy X Get Y Campaign</h1>
+        <Button variant="transparent" onClick={onCancel}>
+          Cancel
+        </Button>
+      </div>
+      <form
+        onSubmit={handleSubmit(onFormSubmit, onFormError)}
+        className="space-y-4 my-8"
+      >
+        <div>
+          <Label>Name</Label>
+          <Input {...register("name")} disabled={disabled} />
+          {errors.name && (
+            <p className="text-red-500 text-sm mt-1">{errors.name.message}</p>
+          )}
+        </div>
+
+        <div>
+          <Label>Description</Label>
+          <Textarea {...register("description")} disabled={disabled} />
+          {errors.description && (
+            <p className="text-red-500 text-sm mt-1">
+              {errors.description.message}
+            </p>
+          )}
+        </div>
+
+        <div className="grid grid-cols-2 gap-4">
+          <div>
+            <Label>Start Date</Label>
+            <div className="flex gap-2">
+              <Input
+                type="date"
+                value={startsAt ? dayjs(startsAt).format("YYYY-MM-DD") : ""}
+                onChange={(e) =>
+                  handleDateTimeChange("starts_at", "date", e.target.value)
+                }
+                disabled={disabled}
+                className="flex-1"
+              />
+              <Input
+                type="time"
+                value={startsAt ? dayjs(startsAt).format("HH:mm") : ""}
+                onChange={(e) =>
+                  handleDateTimeChange("starts_at", "time", e.target.value)
+                }
+                disabled={disabled}
+                className="w-32"
+              />
+            </div>
+            {errors.starts_at && (
+              <p className="text-red-500 text-sm mt-1">
+                {errors.starts_at.message}
+              </p>
+            )}
+          </div>
+          <div>
+            <Label>End Date</Label>
+            <div className="flex gap-2">
+              <Input
+                type="date"
+                value={endsAt ? dayjs(endsAt).format("YYYY-MM-DD") : ""}
+                onChange={(e) =>
+                  handleDateTimeChange("ends_at", "date", e.target.value)
+                }
+                disabled={disabled}
+                className="flex-1"
+              />
+              <Input
+                type="time"
+                value={endsAt ? dayjs(endsAt).format("HH:mm") : ""}
+                onChange={(e) =>
+                  handleDateTimeChange("ends_at", "time", e.target.value)
+                }
+                disabled={disabled}
+                className="w-32"
+              />
+            </div>
+            {errors.ends_at && (
+              <p className="text-red-500 text-sm mt-1">
+                {errors.ends_at.message}
+              </p>
+            )}
+          </div>
+        </div>
+
+        <div className="flex justify-between items-center">
+          <Label>Rules (Buy X Get Y)</Label>
+          <Button
+            type="button"
+            variant="secondary"
+            onClick={addNewRule}
+            disabled={disabled}
+          >
+            Add Rule
+          </Button>
+        </div>
+
+        {fields.length > 0 && (
+          <Table>
+            <Table.Header>
+              <Table.Row>
+                <Table.HeaderCell>Trigger Product</Table.HeaderCell>
+                <Table.HeaderCell>Qty</Table.HeaderCell>
+                <Table.HeaderCell>Reward Product</Table.HeaderCell>
+                <Table.HeaderCell>Qty</Table.HeaderCell>
+                <Table.HeaderCell>Reward Type</Table.HeaderCell>
+                <Table.HeaderCell>Value</Table.HeaderCell>
+                <Table.HeaderCell>Limit</Table.HeaderCell>
+                <Table.HeaderCell></Table.HeaderCell>
+              </Table.Row>
+            </Table.Header>
+            <Table.Body>
+              {fields.map((field, index) => {
+                const rewardType = watch(`rules.${index}.rewardType`);
+
+                return (
+                  <Table.Row key={field.id}>
+                    <Table.Cell>
+                      <div className="flex flex-col">
+                        <Input
+                          value={watch(`rules.${index}.triggerProduct.title`) || "Select product"}
+                          onClick={() => setOpenTriggerProductModal(index)}
+                          readOnly
+                          disabled={disabled}
+                        />
+                        {openTriggerProductModal === index && (
+                          <ProductSelector
+                            onSelect={(product) => {
+                              setValue(`rules.${index}.triggerProduct`, {
+                                id: product.id,
+                                title: product.title,
+                              });
+                              setOpenTriggerProductModal(null);
+                            }}
+                            onClose={() => setOpenTriggerProductModal(null)}
+                          />
+                        )}
+                      </div>
+                    </Table.Cell>
+                    <Table.Cell>
+                      <Input
+                        type="number"
+                        {...register(`rules.${index}.triggerQuantity`, {
+                          valueAsNumber: true,
+                        })}
+                        disabled={disabled}
+                        className="w-20"
+                      />
+                    </Table.Cell>
+                    <Table.Cell>
+                      <div className="flex flex-col">
+                        <Input
+                          value={watch(`rules.${index}.rewardProduct.title`) || "Select product"}
+                          onClick={() => setOpenRewardProductModal(index)}
+                          readOnly
+                          disabled={disabled}
+                        />
+                        {openRewardProductModal === index && (
+                          <ProductSelector
+                            onSelect={(product) => {
+                              setValue(`rules.${index}.rewardProduct`, {
+                                id: product.id,
+                                title: product.title,
+                              });
+                              setOpenRewardProductModal(null);
+                            }}
+                            onClose={() => setOpenRewardProductModal(null)}
+                          />
+                        )}
+                      </div>
+                    </Table.Cell>
+                    <Table.Cell>
+                      <Input
+                        type="number"
+                        {...register(`rules.${index}.rewardQuantity`, {
+                          valueAsNumber: true,
+                        })}
+                        disabled={disabled}
+                        className="w-20"
+                      />
+                    </Table.Cell>
+                    <Table.Cell>
+                      <Controller
+                        control={control}
+                        name={`rules.${index}.rewardType`}
+                        render={({ field }) => (
+                          <Select {...field} disabled={disabled}>
+                            <option value="free">Free</option>
+                            <option value="percentage">Percentage Off</option>
+                            <option value="fixed">Fixed Discount</option>
+                          </Select>
+                        )}
+                      />
+                    </Table.Cell>
+                    <Table.Cell>
+                      {rewardType !== "free" && (
+                        <Input
+                          type="number"
+                          {...register(`rules.${index}.rewardValue`, {
+                            valueAsNumber: true,
+                          })}
+                          disabled={disabled}
+                          placeholder={rewardType === "percentage" ? "%" : "$"}
+                          className="w-24"
+                        />
+                      )}
+                    </Table.Cell>
+                    <Table.Cell>
+                      <Input
+                        type="number"
+                        {...register(`rules.${index}.limit`, {
+                          valueAsNumber: true,
+                        })}
+                        disabled={disabled}
+                        placeholder="Unlimited"
+                        className="w-24"
+                      />
+                    </Table.Cell>
+                    <Table.Cell>
+                      <Button
+                        type="button"
+                        variant="transparent"
+                        onClick={() => remove(index)}
+                        disabled={disabled}
+                      >
+                        <Trash />
+                      </Button>
+                    </Table.Cell>
+                  </Table.Row>
+                );
+              })}
+            </Table.Body>
+          </Table>
+        )}
+
+        {errors.rules && (
+          <p className="text-red-500 text-sm mt-1">
+            {typeof errors.rules === "object" && "message" in errors.rules
+              ? errors.rules.message
+              : "Please check your rules configuration"}
+          </p>
+        )}
+
+        <div className="flex justify-end gap-2 mt-6">
+          <Button type="button" variant="secondary" onClick={onCancel}>
+            Cancel
+          </Button>
+          <Button type="submit" disabled={disabled}>
+            {initialData ? "Update Campaign" : "Create Campaign"}
+          </Button>
+        </div>
+      </form>
+    </Container>
+  );
+};

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

@@ -0,0 +1,164 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+  Modules,
+} from "@medusajs/framework/utils";
+import { CampaignTypeEnum } from "../../../../modules/custom-campaigns/types/campaign-type.enum";
+import { BuyXGetYCampaign } from "../../../../workflows/custom-campaign/createBuyXGetYCampaignWorkflow";
+import { updateBuyXGetYCampaignWorkflow } from "../../../../workflows/custom-campaign/updateBuyXGetYCampaignWorkflow";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../../../modules/custom-campaigns/service";
+
+/**
+ * GET handler for fetching a specific Buy X Get Y campaign by ID
+ */
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const { id } = req.params;
+
+  if (!id) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Campaign ID is required"
+    );
+  }
+
+  const query = container.resolve(ContainerRegistrationKeys.QUERY);
+  const productService = container.resolve(Modules.PRODUCT);
+  const customCampaignModuleService =
+    container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+
+  try {
+    // Find the custom campaign type by campaign ID
+    const {
+      data: [customCampaignTypes],
+    } = await query.graph({
+      entity: "custom_campaign_type",
+      fields: [
+        "id",
+        "campaign.*",
+        "campaign.promotions.*",
+      ],
+      filters: {
+        type: CampaignTypeEnum.BuyXGetY,
+        campaign_id: id,
+      },
+    });
+
+    const campaign = customCampaignTypes?.campaign;
+
+    if (!campaign) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        `Buy X Get Y campaign with ID ${id} not found`
+      );
+    }
+
+    // Fetch Buy X Get Y configurations for the campaign
+    const buyXGetYConfigs =
+      await customCampaignModuleService.listBuyXGetYConfigs({
+        campaign_id: id,
+      });
+
+    // Process configurations to extract product information
+    const rules: BuyXGetYCampaign["rules"] = [];
+    for (const config of buyXGetYConfigs) {
+      const triggerProduct = await productService.retrieveProduct(
+        config.trigger_product_id
+      );
+      const rewardProduct = await productService.retrieveProduct(
+        config.reward_product_id
+      );
+
+      rules.push({
+        triggerProduct: {
+          id: triggerProduct.id,
+          title: triggerProduct.title,
+        },
+        triggerQuantity: config.trigger_quantity,
+        rewardProduct: {
+          id: rewardProduct.id,
+          title: rewardProduct.title,
+        },
+        rewardQuantity: config.reward_quantity,
+        rewardType: config.reward_type as "free" | "percentage" | "fixed",
+        rewardValue: config.reward_value ?? undefined,
+        limit: config.limit ?? undefined,
+      });
+    }
+
+    res.status(200).json({
+      ...campaign,
+      type: CampaignTypeEnum.BuyXGetY,
+      rules,
+    } satisfies BuyXGetYCampaign);
+  } catch (error) {
+    if (error instanceof MedusaError) {
+      throw error;
+    }
+
+    console.error("Error fetching Buy X Get Y campaign:", error);
+    throw new MedusaError(
+      MedusaError.Types.UNEXPECTED_STATE,
+      "An error occurred while fetching the Buy X Get Y campaign"
+    );
+  }
+};
+
+/**
+ * PUT handler for updating a specific Buy X Get Y campaign by ID
+ */
+export const PUT = async (
+  req: MedusaRequest<BuyXGetYCampaign>,
+  res: MedusaResponse
+) => {
+  const { id } = req.params;
+  const body = req.body;
+
+  if (!id) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Campaign ID is required"
+    );
+  }
+
+  try {
+    // Check if start date is before end date
+    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"
+      );
+    }
+
+    // Validate reward types
+    for (const rule of body.rules) {
+      if (rule.rewardType !== "free" && !rule.rewardValue) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          "Reward value is required for percentage and fixed reward types"
+        );
+      }
+    }
+
+    // Update the Buy X Get Y campaign
+    const result = await updateBuyXGetYCampaignWorkflow.run({
+      input: {
+        ...body,
+        id,
+      },
+    });
+
+    res.status(200).json(result.result);
+  } catch (error) {
+    if (error instanceof MedusaError) {
+      throw error;
+    }
+
+    console.error("Error updating Buy X Get Y campaign:", error);
+    throw new MedusaError(
+      MedusaError.Types.UNEXPECTED_STATE,
+      "An error occurred while updating the Buy X Get Y campaign"
+    );
+  }
+};

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

@@ -0,0 +1,104 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+} 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 {
+  BuyXGetYCampaign,
+  createBuyXGetYCampaignWorkflow,
+} from "../../../workflows/custom-campaign/createBuyXGetYCampaignWorkflow";
+
+export const createBuyXGetYCampaignSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  description: z.string().min(1, "Description is required"),
+  type: z.literal(CampaignTypeEnum.BuyXGetY),
+  starts_at: z.coerce.date(),
+  ends_at: z.coerce.date(),
+  rules: z
+    .array(
+      z.object({
+        triggerProduct: z.object({
+          id: z.string(),
+          title: z.string(),
+        }),
+        triggerQuantity: z.number().min(1, "Trigger quantity must be at least 1"),
+        rewardProduct: z.object({
+          id: z.string(),
+          title: z.string(),
+        }),
+        rewardQuantity: z.number().min(1, "Reward quantity must be at least 1"),
+        rewardType: z.enum(["free", "percentage", "fixed"]),
+        rewardValue: z.number().optional(),
+        limit: z.number().min(1).optional(),
+      })
+    )
+    .min(1, "At least one rule is required"),
+});
+
+export const GetBuyXGetYCampaignsSchema = createFindParams({
+  order: "-created_at",
+});
+
+export const POST = async (
+  req: MedusaRequest<BuyXGetYCampaign>,
+  res: MedusaResponse
+) => {
+  const body = req.body;
+
+  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"
+    );
+  }
+
+  // Validate reward types
+  for (const rule of body.rules) {
+    if (rule.rewardType !== "free" && !rule.rewardValue) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Reward value is required for percentage and fixed reward types"
+      );
+    }
+  }
+
+  const campaign = await createBuyXGetYCampaignWorkflow.run({
+    input: body,
+  });
+
+  res.status(200).json(campaign);
+};
+
+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.*",
+      "campaign.promotions.application_method.*",
+    ],
+    filters: { type: CampaignTypeEnum.BuyXGetY },
+  });
+
+  const campaigns = customCampaigns.map((campaign) => campaign.campaign);
+
+  res.status(200).json({
+    campaigns,
+    count,
+    limit: take,
+    offset: skip,
+  });
+};