@lodashventure/medusa-campaign 1.1.0 → 1.1.1

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,
+      }),
+    ],
+  },
+]);

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

@@ -0,0 +1,133 @@
+import { MedusaRequest, MedusaResponse, container } from "@medusajs/framework";
+import {
+  MedusaError,
+  ContainerRegistrationKeys,
+  Modules,
+} from "@medusajs/framework/utils";
+import { CampaignTypeEnum } from "../../../../modules/custom-campaigns/types/campaign-type.enum";
+import { CustomCampaign } from "../../../admin/flash-sales/route";
+
+export const GET = async (
+  req: MedusaRequest<{ id: string }>,
+  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,
+        });
+      }
+    }
+
+    const campaignData = {
+      id: campaign.id,
+      name: campaign.name,
+      description: campaign.description,
+      type: campaign.type,
+      startsAt: campaign.starts_at,
+      endsAt: campaign.ends_at,
+    };
+
+    const productData = products.map((product) => ({
+      id: product.product.id,
+      title: product.product.title,
+      discountType: product.discountType,
+      discountValue: product.discountValue,
+      maxQty: product.maxQty,
+      limit: product.limit,
+    }));
+
+    res.status(200).json({
+      ...campaignData,
+      products: productData,
+    });
+  } 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"
+    );
+  }
+};

package/src/api/store/campaigns/route.ts

@@ -0,0 +1,36 @@
+import { container, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { CampaignTypeEnum } from "../../../modules/custom-campaigns/types/campaign-type.enum";
+
+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.name",
+      "campaign.description",
+      "campaign.type",
+      "campaign.starts_at",
+      "campaign.ends_at",
+    ],
+    filters: { type: CampaignTypeEnum.FlashSale },
+  });
+
+  const campaigns = customCampaigns.map((campaign) => campaign.campaign);
+
+  res.status(200).json({
+    campaigns,
+    count,
+    limit: take,
+    offset: skip,
+  });
+};

package/src/jobs/README.md

@@ -0,0 +1,36 @@
+# Custom scheduled jobs
+
+A scheduled job is a function executed at a specified interval of time in the background of your Medusa application.
+
+A scheduled job is created in a TypeScript or JavaScript file under the `src/jobs` directory.
+
+For example, create the file `src/jobs/hello-world.ts` with the following content:
+
+```ts
+import {
+  MedusaContainer
+} from "@medusajs/framework/types";
+
+export default async function myCustomJob(container: MedusaContainer) {
+  const productService = container.resolve("product")
+
+  const products = await productService.listAndCountProducts();
+
+  // Do something with the products
+}
+
+export const config = {
+  name: "daily-product-report",
+  schedule: "0 0 * * *", // Every day at midnight
+};
+```
+
+A scheduled job file must export:
+
+- The function to be executed whenever it’s time to run the scheduled job.
+- A configuration object defining the job. It has three properties:
+  - `name`: a unique name for the job.
+  - `schedule`: a [cron expression](https://crontab.guru/).
+  - `numberOfExecutions`: an optional integer, specifying how many times the job will execute before being removed
+
+The `handler` is a function that accepts one parameter, `container`, which is a `MedusaContainer` instance used to resolve services.

package/src/links/README.md

@@ -0,0 +1,26 @@
+# Module Links
+
+A module link forms an association between two data models of different modules, while maintaining module isolation.
+
+Learn more about links in [this documentation](https://docs.medusajs.com/learn/fundamentals/module-links)
+
+For example:
+
+```ts
+import BlogModule from "../modules/blog"
+import ProductModule from "@medusajs/medusa/product"
+import { defineLink } from "@medusajs/framework/utils"
+
+export default defineLink(
+  ProductModule.linkable.product,
+  BlogModule.linkable.post
+)
+```
+
+This defines a link between the Product Module's `product` data model and the Blog Module (custom module)'s `post` data model.
+
+Then, in the Medusa application using this plugin, run the following command to sync the links to the database:
+
+```bash
+npx medusa db:migrate
+```

package/src/links/campaign-type.ts

@@ -0,0 +1,8 @@
+import { defineLink } from "@medusajs/framework/utils";
+import PromotionModule from "@medusajs/medusa/promotion";
+import CustomCampaignModule from "../modules/custom-campaigns";
+
+export default defineLink(PromotionModule.linkable.campaign, {
+  linkable: CustomCampaignModule.linkable.customCampaignType,
+  deleteCascade: true,
+});

package/src/modules/README.md

@@ -0,0 +1,116 @@
+# Custom Module
+
+A module is a package of reusable functionalities. It can be integrated into your Medusa application without affecting the overall system. You can create a module as part of a plugin.
+
+Learn more about modules in [this documentation](https://docs.medusajs.com/learn/fundamentals/modules).
+
+To create a module:
+
+## 1. Create a Data Model
+
+A data model represents a table in the database. You create a data model in a TypeScript or JavaScript file under the `models` directory of a module.
+
+For example, create the file `src/modules/blog/models/post.ts` with the following content:
+
+```ts
+import { model } from "@medusajs/framework/utils"
+
+const Post = model.define("post", {
+  id: model.id().primaryKey(),
+  title: model.text(),
+})
+
+export default Post
+```
+
+## 2. Create a Service
+
+A module must define a service. A service is a TypeScript or JavaScript class holding methods related to a business logic or commerce functionality.
+
+For example, create the file `src/modules/blog/service.ts` with the following content:
+
+```ts
+import { MedusaService } from "@medusajs/framework/utils"
+import Post from "./models/post"
+
+class BlogModuleService extends MedusaService({
+  Post,
+}){
+}
+
+export default BlogModuleService
+```
+
+## 3. Export Module Definition
+
+A module must have an `index.ts` file in its root directory that exports its definition. The definition specifies the main service of the module.
+
+For example, create the file `src/modules/blog/index.ts` with the following content:
+
+```ts
+import BlogModuleService from "./service"
+import { Module } from "@medusajs/framework/utils"
+
+export const BLOG_MODULE = "blog"
+
+export default Module(BLOG_MODULE, {
+  service: BlogModuleService,
+})
+```
+
+## 4. Generate Migrations
+
+To generate migrations for your module, run the following command in the plugin's directory:
+
+```bash
+npx medusa plugin:db:genreate
+```
+
+## Use Module
+
+You can use the module in customizations within the plugin or within the Medusa application using this plugin. When the plugin is added to a Medusa application, all its modules are registered as well.
+
+For example, to use the module in an API route:
+
+```ts
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework"
+import BlogModuleService from "../../../modules/blog/service"
+import { BLOG_MODULE } from "../../../modules/blog"
+
+export async function GET(
+  req: MedusaRequest,
+  res: MedusaResponse
+): Promise<void> {
+  const blogModuleService: BlogModuleService = req.scope.resolve(
+    BLOG_MODULE
+  )
+
+  const posts = await blogModuleService.listPosts()
+
+  res.json({
+    posts
+  })
+}
+```
+
+## Module Options
+
+When you register the plugin in the Medusa application, it can accept options. These options are passed to the modules within the plugin:
+
+```ts
+import { defineConfig } from "@medusajs/framework/utils"
+
+module.exports = defineConfig({
+  // ...
+  plugins: [
+    {
+      resolve: "@myorg/plugin-name",
+      options: {
+        apiKey: process.env.API_KEY,
+      },
+    },
+  ],
+})
+```
+
+Learn more about module options in [this documentation](https://docs.medusajs.com/learn/fundamentals/modules/options).

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

@@ -0,0 +1,8 @@
+import { Module } from "@medusajs/framework/utils";
+import CustomCampaignModuleService from "./service";
+
+export const CUSTOM_CAMPAIGN_MODULE = "customCampaign";
+
+export default Module(CUSTOM_CAMPAIGN_MODULE, {
+  service: CustomCampaignModuleService,
+});