@lodashventure/medusa-campaign 1.0.0 → 1.1.1

package/src/admin/lib/sdk.ts

@@ -0,0 +1,10 @@
+// src/admin/lib/sdk.ts
+import Medusa from "@medusajs/js-sdk";
+
+export const sdk = new Medusa({
+  baseUrl: import.meta.env.VITE_BACKEND_URL || "/",
+  debug: import.meta.env.DEV,
+  auth: {
+    type: "session",
+  },
+});

package/src/admin/routes/flash-sales/[id]/page.tsx

@@ -0,0 +1,105 @@
+import { defineRouteConfig } from "@medusajs/admin-sdk";
+import { Sparkles } from "@medusajs/icons";
+import { Button, Container, toast } from "@medusajs/ui";
+import { useQueryClient } from "@tanstack/react-query";
+import axios from "axios";
+import { FC, useState } from "react";
+import { useNavigate, useParams } from "react-router-dom";
+import {
+  CampaignData,
+  CustomCampaign,
+  FlashSaleForm,
+} from "../../../components/FlashSaleForm";
+import { useFlashSaleById } from "../../../hooks/useFlashSaleById";
+
+const FlashSaleDetail: FC = () => {
+  const { id } = useParams<{ id: string }>();
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+  const { data, isLoading } = useFlashSaleById(id || "");
+
+  const [isEditing, setIsEditing] = useState(false);
+
+  async function handleSubmit(campaignData: CampaignData) {
+    try {
+      await axios.put(`/admin/flash-sales/${id}`, {
+        ...campaignData,
+        starts_at: new Date(campaignData.starts_at).toUTCString(),
+        ends_at: new Date(campaignData.ends_at).toUTCString(),
+      });
+
+      toast.success("Flash sale updated successfully");
+      queryClient.invalidateQueries({
+        exact: false,
+        predicate(query) {
+          return ["flash-sales", "flash-sale"].includes(
+            query.queryKey[0] as string
+          );
+        },
+      });
+      navigate("/flash-sales");
+    } catch (error) {
+      let message: string;
+
+      if (axios.isAxiosError(error)) {
+        console.log(error);
+        message = error.response?.data.message;
+      } else if (error instanceof Error) {
+        message = error.message;
+      } else {
+        message = "Failed to update flash sale";
+      }
+
+      toast.error("Failed to update flash sale", {
+        description: message,
+      });
+    }
+  }
+
+  if (isLoading) {
+    return (
+      <Container className="flex items-center justify-center h-screen">
+        <div className="animate-spin h-10 w-10 border-4 border-primary rounded-full border-t-transparent"></div>
+      </Container>
+    );
+  }
+
+  if (!data) {
+    return (
+      <Container>
+        <p>Flash sale not found</p>
+      </Container>
+    );
+  }
+
+  // Convert campaign data to the format expected by the form
+  const campaignData: CustomCampaign = {
+    name: data.name || "",
+    description: data.description || "",
+    type: "flash-sale",
+    starts_at: data.starts_at,
+    ends_at: data.ends_at,
+  };
+
+  return (
+    <>
+      <FlashSaleForm
+        initialData={campaignData}
+        initialProducts={
+          new Map(data.products.map((product) => [product.product.id, product]))
+        }
+        onSubmit={handleSubmit}
+        onCancel={() => navigate("/flash-sales")}
+        disabled={!isEditing}
+      />
+      <Button onClick={() => setIsEditing((prev) => !prev)}>Toggle Edit</Button>
+    </>
+  );
+};
+
+export const config = defineRouteConfig({
+  label: "Flash Sale Detail",
+  icon: Sparkles,
+});
+
+export default FlashSaleDetail;

package/src/admin/routes/flash-sales/create/page.tsx

@@ -0,0 +1,51 @@
+import { toast } from "@medusajs/ui";
+import { useQueryClient } from "@tanstack/react-query";
+import axios from "axios";
+import { FC } from "react";
+import { useNavigate } from "react-router-dom";
+import { CampaignData, FlashSaleForm } from "../../../components/FlashSaleForm";
+
+const FlashSaleCreate: FC = () => {
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+
+  async function handleSubmit(campaignData: CampaignData) {
+    try {
+      await axios.post("/admin/flash-sales", {
+        ...campaignData,
+        starts_at: new Date(campaignData.starts_at).toUTCString(),
+        ends_at: new Date(campaignData.ends_at).toUTCString(),
+      });
+      toast.success("Flash sale created successfully");
+      queryClient.invalidateQueries({
+        exact: false,
+        queryKey: ["flash-sales"],
+      });
+      navigate("/flash-sales");
+    } catch (error) {
+      let message: string;
+
+      if (axios.isAxiosError(error)) {
+        console.log(error);
+        message = error.response?.data.message;
+      } else if (error instanceof Error) {
+        message = error.message;
+      } else {
+        message = "Failed to create flash sale";
+      }
+
+      toast.error("Failed to create flash sale", {
+        description: message,
+      });
+    }
+  }
+
+  return (
+    <FlashSaleForm
+      onSubmit={handleSubmit}
+      onCancel={() => navigate("/flash-sales")}
+    />
+  );
+};
+
+export default FlashSaleCreate;

package/src/admin/routes/flash-sales/page.tsx

@@ -0,0 +1,15 @@
+import { defineRouteConfig } from "@medusajs/admin-sdk";
+import { Sparkles } from "@medusajs/icons";
+import { FC } from "react";
+import { FlashSalePage } from "../../components/FlashSalePage";
+
+const FlashSale: FC = () => {
+  return <FlashSalePage />;
+};
+
+export const config = defineRouteConfig({
+  label: "Flash Sale",
+  icon: Sparkles,
+});
+
+export default FlashSale;

package/src/admin/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["."]
+}

package/src/admin/types/campaign.ts

@@ -0,0 +1,25 @@
+export interface Campaign {
+  id: string;
+  name: string;
+  description: string;
+  start_date: string;
+  end_date: string;
+  status: "draft" | "active" | "completed" | "cancelled";
+  created_at: string;
+  updated_at: string;
+}
+
+export interface CampaignFilters {
+  status?: string[];
+  q?: string;
+  start_date?: string;
+  end_date?: string;
+}
+
+export interface CampaignFormValues {
+  name: string;
+  description: string;
+  start_date: string;
+  end_date: string;
+  status: string;
+}

package/src/admin/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/src/api/README.md

@@ -0,0 +1,133 @@
+# Custom API Routes
+
+An API Route is a REST API endpoint.
+
+An API Route is created in a TypeScript or JavaScript file under the `/src/api` directory of your Medusa application. The file’s name must be `route.ts` or `route.js`.
+
+For example, to create a `GET` API Route at `/store/hello-world`, create the file `src/api/store/hello-world/route.ts` with the following content:
+
+```ts
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  res.json({
+    message: "Hello world!",
+  });
+}
+```
+
+## Supported HTTP methods
+
+The file based routing supports the following HTTP methods:
+
+- GET
+- POST
+- PUT
+- PATCH
+- DELETE
+- OPTIONS
+- HEAD
+
+You can define a handler for each of these methods by exporting a function with the name of the method in the paths `route.ts` file.
+
+For example:
+
+```ts
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  // Handle GET requests
+}
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  // Handle POST requests
+}
+
+export async function PUT(req: MedusaRequest, res: MedusaResponse) {
+  // Handle PUT requests
+}
+```
+
+## Parameters
+
+To create an API route that accepts a path parameter, create a directory within the route's path whose name is of the format `[param]`.
+
+For example, if you want to define a route that takes a `productId` parameter, you can do so by creating a file called `/api/products/[productId]/route.ts`:
+
+```ts
+import type {
+  MedusaRequest,
+  MedusaResponse,
+} from "@medusajs/framework/http"
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  const { productId } = req.params;
+
+  res.json({
+    message: `You're looking for product ${productId}`
+  })
+}
+```
+
+To create an API route that accepts multiple path parameters, create within the file's path multiple directories whose names are of the format `[param]`.
+
+For example, if you want to define a route that takes both a `productId` and a `variantId` parameter, you can do so by creating a file called `/api/products/[productId]/variants/[variantId]/route.ts`.
+
+## Using the container
+
+The Medusa container is available on `req.scope`. Use it to access modules' main services and other registered resources:
+
+```ts
+import type {
+  MedusaRequest,
+  MedusaResponse,
+} from "@medusajs/framework/http"
+
+export const GET = async (
+  req: MedusaRequest,
+  res: MedusaResponse
+) => {
+  const productModuleService = req.scope.resolve("product")
+
+  const [, count] = await productModuleService.listAndCount()
+
+  res.json({
+    count,
+  })
+}
+```
+
+## Middleware
+
+You can apply middleware to your routes by creating a file called `/api/middlewares.ts`. This file must export a configuration object with what middleware you want to apply to which routes.
+
+For example, if you want to apply a custom middleware function to the `/store/custom` route, you can do so by adding the following to your `/api/middlewares.ts` file:
+
+```ts
+import { defineMiddlewares } from "@medusajs/framework/http"
+import type {
+  MedusaRequest,
+  MedusaResponse,
+  MedusaNextFunction,
+} from "@medusajs/framework/http";
+
+async function logger(
+  req: MedusaRequest,
+  res: MedusaResponse,
+  next: MedusaNextFunction
+) {
+  console.log("Request received");
+  next();
+}
+
+export default defineMiddlewares({
+  routes: [
+    {
+      matcher: "/store/custom",
+      middlewares: [logger],
+    },
+  ],
+})
+```
+
+The `matcher` property can be either a string or a regular expression. The `middlewares` property accepts an array of middleware functions.

package/src/api/admin/flash-sales/[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 { CustomCampaign, createCustomCampaignSchema } from "../route";
+import { updateCustomFlashSaleWorkflow } from "../../../../workflows/custom-campaign/updateCustomFlashSaleWorkflow";
+
+/**
+ * GET handler for fetching a specific flash sale 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);
+
+  try {
+    // 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: {
+        type: CampaignTypeEnum.FlashSale,
+        campaign_id: id,
+      },
+    });
+
+    const campaign = customCampaignTypes.campaign;
+
+    if (!campaign) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        `Flash sale with ID ${id} not found`
+      );
+    }
+
+    // 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: {
+        campaign_id: id,
+      },
+    });
+
+    // Create a map of promotion usage limits by promotion ID
+    const promotionLimitsMap = new Map();
+    promotionUsageLimits.forEach((limit) => {
+      promotionLimitsMap.set(limit.promotion_id, limit);
+    });
+
+    // Process promotions to extract product information
+    const products: CustomCampaign["products"] = [];
+    for await (const promotion of campaign.promotions ?? []) {
+      if (!promotion.application_method?.target_rules?.length) {
+        continue;
+      }
+
+      const productRule = promotion.application_method.target_rules.find(
+        (rule) =>
+          rule.attribute === "items.product.id" && rule.operator === "eq"
+      );
+      const promotionLimit = promotionLimitsMap.get(promotion.id);
+
+      const product = await productService.retrieveProduct(
+        promotionLimit?.product_id
+      );
+
+      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,
+        });
+      }
+    }
+
+    res.status(200).json({
+      ...campaign,
+      products,
+    } satisfies CustomCampaign);
+  } catch (error) {
+    if (error instanceof MedusaError) {
+      throw error;
+    }
+
+    console.error("Error fetching flash sale:", error);
+    throw new MedusaError(
+      MedusaError.Types.UNEXPECTED_STATE,
+      "An error occurred while fetching the flash sale"
+    );
+  }
+};
+
+/**
+ * PUT handler for updating a specific flash sale by ID
+ */
+export const PUT = async (
+  req: MedusaRequest<CustomCampaign>,
+  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"
+      );
+    }
+
+    // Update the flash sale
+    const result = await updateCustomFlashSaleWorkflow.run({
+      input: {
+        ...body,
+        id,
+      },
+    });
+
+    res.status(200).json(result.result);
+  } catch (error) {
+    if (error instanceof MedusaError) {
+      throw error;
+    }
+
+    console.error("Error updating flash sale:", error);
+    throw new MedusaError(
+      MedusaError.Types.UNEXPECTED_STATE,
+      "An error occurred while updating the flash sale"
+    );
+  }
+};

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

@@ -0,0 +1,87 @@
+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 { createCustomCampaignWorkflow } from "../../../workflows/custom-campaign/createCustomCampaignWorkflow";
+
+export const createCustomCampaignSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  description: z.string().min(1, "Description is required"),
+  type: z.nativeEnum(CampaignTypeEnum),
+  starts_at: z.coerce.date(),
+  ends_at: z.coerce.date(),
+  products: z
+    .array(
+      z.object({
+        product: z.object({
+          id: z.string(),
+          title: z.string(),
+        }),
+        discountType: z.enum([
+          "percentage",
+          // need to handle fixed discount and currency
+          // "fixed",
+        ]),
+        discountValue: z.number().min(1),
+        limit: z.number().min(1),
+        maxQty: z.number().min(1),
+      })
+    )
+    .min(1, "At least one product is required"),
+});
+
+export type CustomCampaign = z.infer<typeof createCustomCampaignSchema>;
+
+export const GetFlashSalesSchema = createFindParams({
+  order: "-created_at",
+});
+
+export const POST = async (
+  req: MedusaRequest<CustomCampaign>,
+  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"
+    );
+  }
+
+  const customCampaign = await createCustomCampaignWorkflow.run({
+    input: body,
+  });
+
+  res.status(200).json(customCampaign);
+};
+
+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 campaigns = customCampaigns.map((campaign) => campaign.campaign);
+
+  res.status(200).json({
+    campaigns,
+    count,
+    limit: take,
+    offset: skip,
+  });
+};

package/src/api/middlewares.ts

@@ -0,0 +1,32 @@
+import {
+  defineMiddlewares,
+  validateAndTransformBody,
+  validateAndTransformQuery,
+} from "@medusajs/framework";
+import {
+  createCustomCampaignSchema,
+  GetFlashSalesSchema,
+} from "./admin/flash-sales/route";
+
+export default defineMiddlewares([
+  {
+    methods: ["POST"],
+    matcher: "/admin/flash-sales",
+    middlewares: [validateAndTransformBody(createCustomCampaignSchema as any)],
+  },
+  {
+    methods: ["PUT"],
+    matcher: "/admin/flash-sales/:id",
+    middlewares: [validateAndTransformBody(createCustomCampaignSchema as any)],
+  },
+  {
+    methods: ["GET"],
+    matcher: "/admin/flash-sales",
+    middlewares: [
+      validateAndTransformQuery(GetFlashSalesSchema as any, {
+        defaults: ["*", "campaign.*"],
+        isList: true,
+      }),
+    ],
+  },
+]);