@lodashventure/medusa-campaign 1.0.0 → 1.1.1

package/src/modules/custom-campaigns/models/promotion-usage-limit.ts

@@ -0,0 +1,14 @@
+import { model } from "@medusajs/framework/utils";
+
+const PromotionUsageLimit = model
+  .define("promotion_usage_limit", {
+    id: model.id().primaryKey(),
+    campaign_id: model.text(),
+    promotion_id: model.text(),
+    product_id: model.text(),
+    limit: model.number(),
+    used: model.number(),
+  })
+  .indexes([{ on: ["campaign_id", "promotion_id"], unique: true }]);
+
+export default PromotionUsageLimit;

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

@@ -0,0 +1,10 @@
+import { MedusaService } from "@medusajs/framework/utils";
+import CustomCampaignType from "./models/custom-campaign-type";
+import PromotionUsageLimit from "./models/promotion-usage-limit";
+
+class CustomCampaignModuleService extends MedusaService({
+  CustomCampaignType,
+  PromotionUsageLimit,
+}) {}
+
+export default CustomCampaignModuleService;

package/src/modules/custom-campaigns/types/campaign-type.enum.ts

@@ -0,0 +1,3 @@
+export enum CampaignTypeEnum {
+  FlashSale = "flash-sale",
+}

package/src/providers/README.md

@@ -0,0 +1,30 @@
+## Module Providers
+
+You can create module providers, such as Notification or File Module Providers under a sub-directory of this directory. For example, `src/providers/my-notification`.
+
+Then, you register them in the Medusa application as `plugin-name/providers/my-notification`:
+
+```ts
+module.exports = defineConfig({
+  // ...
+  modules: [
+    {
+      resolve: "@medusajs/medusa/notification",
+      options: {
+        providers: [
+          {
+            resolve: "@myorg/plugin-name/providers/my-notification",
+            id: "my-notification",
+            options: {
+              channels: ["email"],
+              // provider options...
+            },
+          },
+        ],
+      },
+    },
+  ],
+})
+```
+
+Learn more in [this documentation](https://docs.medusajs.com/learn/fundamentals/plugins/create).

package/src/subscribers/README.md

@@ -0,0 +1,59 @@
+# Custom subscribers
+
+Subscribers handle events emitted in the Medusa application.
+
+The subscriber is created in a TypeScript or JavaScript file under the `src/subscribers` directory.
+
+For example, create the file `src/subscribers/product-created.ts` with the following content:
+
+```ts
+import {
+  type SubscriberConfig,
+} from "@medusajs/framework"
+
+// subscriber function
+export default async function productCreateHandler() {
+  console.log("A product was created")
+}
+
+// subscriber config
+export const config: SubscriberConfig = {
+  event: "product.created",
+}
+```
+
+A subscriber file must export:
+
+- The subscriber function that is an asynchronous function executed whenever the associated event is triggered.
+- A configuration object defining the event this subscriber is listening to.
+
+## Subscriber Parameters
+
+A subscriber receives an object having the following properties:
+
+- `event`: An object holding the event's details. It has a `data` property, which is the event's data payload.
+- `container`: The Medusa container. Use it to resolve modules' main services and other registered resources.
+
+```ts
+import type {
+  SubscriberArgs,
+  SubscriberConfig,
+} from "@medusajs/framework"
+
+export default async function productCreateHandler({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const productId = data.id
+
+  const productModuleService = container.resolve("product")
+
+  const product = await productModuleService.retrieveProduct(productId)
+
+  console.log(`The product ${product.title} was created`)
+}
+
+export const config: SubscriberConfig = {
+  event: "product.created",
+}
+```

package/src/subscribers/order-placed.ts

@@ -0,0 +1,17 @@
+import { SubscriberArgs, type SubscriberConfig } from "@medusajs/framework";
+import { updatePromotionUsageWorkflow } from "../workflows/custom-campaign/updatePromotionUsageWorkflow";
+
+export default async function updatePromotionUsage({
+  event: { data },
+}: SubscriberArgs<{ id: string }>) {
+  // update promotion usage
+  await updatePromotionUsageWorkflow.run({
+    input: {
+      order_id: data.id,
+    },
+  });
+}
+
+export const config: SubscriberConfig = {
+  event: `order.placed`,
+};

package/src/workflows/README.md

@@ -0,0 +1,79 @@
+# Custom Workflows
+
+A workflow is a series of queries and actions that complete a task.
+
+The workflow is created in a TypeScript or JavaScript file under the `src/workflows` directory.
+
+For example:
+
+```ts
+import {
+  createStep,
+  createWorkflow,
+  WorkflowResponse,
+  StepResponse,
+} from "@medusajs/framework/workflows-sdk"
+
+const step1 = createStep("step-1", async () => {
+  return new StepResponse(`Hello from step one!`)
+})
+
+type WorkflowInput = {
+  name: string
+}
+
+const step2 = createStep(
+  "step-2",
+  async ({ name }: WorkflowInput) => {
+    return new StepResponse(`Hello ${name} from step two!`)
+  }
+)
+
+type WorkflowOutput = {
+  message1: string
+  message2: string
+}
+
+const helloWorldWorkflow = createWorkflow(
+  "hello-world",
+  (input: WorkflowInput) => {
+    const greeting1 = step1()
+    const greeting2 = step2(input)
+    
+    return new WorkflowResponse({
+      message1: greeting1,
+      message2: greeting2
+    })
+  }
+)
+
+export default helloWorldWorkflow
+```
+
+## Execute Workflow
+
+You can execute the workflow from other resources, such as API routes, scheduled jobs, or subscribers.
+
+For example, to execute the workflow in an API route:
+
+```ts
+import type {
+  MedusaRequest,
+  MedusaResponse,
+} from "@medusajs/framework"
+import myWorkflow from "../../../workflows/hello-world"
+
+export async function GET(
+  req: MedusaRequest,
+  res: MedusaResponse
+) {
+  const { result } = await myWorkflow(req.scope)
+    .run({
+      input: {
+        name: req.query.name as string,
+      },
+    })
+
+  res.send(result)
+}
+```

package/src/workflows/custom-campaign/createCustomCampaignWorkflow.ts

@@ -0,0 +1,181 @@
+import { container } from "@medusajs/framework";
+import {
+  CampaignDTO,
+  CreateApplicationMethodDTO,
+  CreatePromotionDTO,
+  PromotionDTO,
+} from "@medusajs/framework/types";
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+  Modules,
+} from "@medusajs/framework/utils";
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import {
+  createCampaignsWorkflow,
+  createPromotionsWorkflow,
+  deleteCampaignsWorkflow,
+  deletePromotionsWorkflow,
+} from "@medusajs/medusa/core-flows";
+import { CustomCampaign } from "../../api/admin/flash-sales/route";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../modules/custom-campaigns/service";
+
+const createCustomCampaignStep = createStep(
+  "create-custom-campaign-step",
+  async (data: CustomCampaign) => {
+    const link = container.resolve(ContainerRegistrationKeys.LINK);
+    const customCampaignModuleService =
+      container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+    const campaignIdentifier = `${data.type}-${Date.now()}`;
+
+    let campaign: CampaignDTO | undefined;
+    let promotions: PromotionDTO[] | undefined;
+    let customCampaignType:
+      | Awaited<
+          ReturnType<CustomCampaignModuleService["createCustomCampaignTypes"]>
+        >[number]
+      | undefined;
+    let promotionUsageLimit:
+      | Awaited<
+          ReturnType<CustomCampaignModuleService["createPromotionUsageLimits"]>
+        >
+      | undefined;
+
+    const {
+      result: [_campaign],
+    } = await createCampaignsWorkflow.run({
+      input: {
+        campaignsData: [
+          {
+            name: data.name,
+            campaign_identifier: campaignIdentifier,
+            description: data.description,
+            starts_at: new Date(data.starts_at),
+            ends_at: new Date(data.ends_at),
+          },
+        ],
+      },
+    });
+    campaign = _campaign;
+
+    try {
+      const { result: _promotions } = await createPromotionsWorkflow.run({
+        input: {
+          promotionsData: data.products.map(
+            (product) =>
+              ({
+                code: `${campaignIdentifier}-${product.product.id}`,
+                type: "standard",
+                status: "active",
+                is_automatic: true,
+                campaign_id: campaign.id,
+                application_method: {
+                  target_type: "items",
+                  allocation: "each",
+                  type: product.discountType,
+                  value: product.discountValue,
+                  max_quantity: product.maxQty,
+                  target_rules: [
+                    {
+                      attribute: "items.product.id",
+                      operator: "eq",
+                      values: [product.product.id],
+                    },
+                  ],
+                } satisfies CreateApplicationMethodDTO,
+              } satisfies CreatePromotionDTO)
+          ),
+        },
+      });
+      promotions = _promotions;
+
+      const productPromotionMap = new Map<string, string>();
+      promotions.forEach((promotion) => {
+        const productId = promotion.code?.split("-").at(-1);
+        if (!productId) {
+          throw new MedusaError(
+            MedusaError.Types.INVALID_DATA,
+            "Invalid product id"
+          );
+        }
+        productPromotionMap.set(productId, promotion.id);
+      });
+
+      customCampaignType =
+        await customCampaignModuleService.createCustomCampaignTypes({
+          campaign_id: campaign.id,
+          type: data.type,
+        });
+
+      promotionUsageLimit =
+        await customCampaignModuleService.createPromotionUsageLimits(
+          data.products.map((product) => ({
+            campaign_id: campaign.id,
+            promotion_id: productPromotionMap.get(product.product.id),
+            product_id: product.product.id,
+            limit: product.limit,
+            used: 0,
+          }))
+        );
+
+      // link campaign type
+      await link.create([
+        {
+          [Modules.PROMOTION]: {
+            campaign_id: campaign.id,
+          },
+          [CUSTOM_CAMPAIGN_MODULE]: {
+            custom_campaign_type_id: customCampaignType.id,
+          },
+        },
+      ]);
+
+      return new StepResponse({
+        campaign,
+        promotions,
+      });
+    } catch (error) {
+      console.log({ error });
+      await deleteCampaignsWorkflow.run({
+        input: {
+          ids: campaign.id,
+        },
+      });
+
+      if (promotions) {
+        await deletePromotionsWorkflow.run({
+          input: {
+            ids: promotions.map((promotion) => promotion.id),
+          },
+        });
+      }
+
+      if (customCampaignType) {
+        await customCampaignModuleService.deleteCustomCampaignTypes(
+          customCampaignType.id
+        );
+      }
+
+      if (promotionUsageLimit) {
+        await customCampaignModuleService.deletePromotionUsageLimits(
+          promotionUsageLimit.map((limit) => limit.id)
+        );
+      }
+    }
+  }
+);
+
+export const createCustomCampaignWorkflow = createWorkflow(
+  "create-custom-campaign",
+  (data: CustomCampaign) => {
+    const customCampaign = createCustomCampaignStep(data);
+
+    return new WorkflowResponse(customCampaign);
+  }
+);

package/src/workflows/custom-campaign/updateCustomFlashSaleWorkflow.ts

@@ -0,0 +1,185 @@
+import { container } from "@medusajs/framework";
+import {
+  CreateApplicationMethodDTO,
+  CreatePromotionDTO,
+  UpdateCampaignDTO,
+  UpdatePromotionDTO,
+} from "@medusajs/framework/types";
+import { MedusaError, Modules } from "@medusajs/framework/utils";
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import {
+  createPromotionsWorkflow,
+  deletePromotionsWorkflow,
+  updateCampaignsWorkflow,
+  updatePromotionsWorkflow,
+} from "@medusajs/medusa/core-flows";
+import { CustomCampaign } from "../../api/admin/flash-sales/route";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../modules/custom-campaigns/service";
+
+interface UpdateFlashSaleInput extends CustomCampaign {
+  id: string;
+}
+
+const updateCustomFlashSaleStep = createStep(
+  "update-custom-flash-sale-step",
+  async (data: UpdateFlashSaleInput) => {
+    const campaign_id = data.id;
+
+    const customCampaignModuleService =
+      container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+    const promotionService = container.resolve(Modules.PROMOTION);
+
+    if (!campaign_id) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Campaign ID is required"
+      );
+    }
+
+    // Fetch the existing campaign
+    const campaign = await promotionService.retrieveCampaign(campaign_id);
+
+    // Fetch existing promotion usage limits
+    const promotionUsageLimits =
+      await customCampaignModuleService.listPromotionUsageLimits({
+        campaign_id: campaign_id,
+      });
+
+    // Create maps for existing promotions and usage limits
+    const existingPromotionUsageMapByProductId = new Map(
+      promotionUsageLimits.map((limit) => [limit.product_id, limit])
+    );
+    const promotionsToBeCreate = data.products.filter(
+      (product) => !existingPromotionUsageMapByProductId.has(product.product.id)
+    );
+    const productPromotionsToBeUpdate = data.products.filter((product) =>
+      existingPromotionUsageMapByProductId.has(product.product.id)
+    );
+
+    const inputProductIdSet = new Set(
+      data.products.map((product) => product.product.id)
+    );
+    const promotionsToBeDelete = promotionUsageLimits.filter(
+      (limit) => !inputProductIdSet.has(limit.product_id)
+    );
+
+    console.log("update campaign");
+    // 1. Update the campaign details
+    await updateCampaignsWorkflow.run({
+      input: {
+        campaignsData: [
+          {
+            id: campaign_id,
+            name: data.name,
+            description: data.description,
+            starts_at: new Date(data.starts_at),
+            ends_at: new Date(data.ends_at),
+          } satisfies UpdateCampaignDTO,
+        ],
+      },
+    });
+
+    // 2.1 Update promotions to be updated
+    await promotionService.updatePromotions(
+      productPromotionsToBeUpdate.map((product) => {
+        const promotion_id =
+          existingPromotionUsageMapByProductId.get(product.product.id)
+            ?.promotion_id ?? "";
+
+        return {
+          id: promotion_id,
+          application_method: {
+            value: product.discountValue,
+            max_quantity: product.maxQty,
+          },
+        } satisfies UpdatePromotionDTO;
+      })
+    );
+
+    // 2.2 Update promotion usage limits to be updated
+    await customCampaignModuleService.updatePromotionUsageLimits(
+      productPromotionsToBeUpdate.map((product) => ({
+        id:
+          existingPromotionUsageMapByProductId.get(product.product.id)?.id ??
+          "",
+        limit: product.limit,
+      }))
+    );
+
+    // 3. Delete promotions to be deleted
+    await deletePromotionsWorkflow.run({
+      input: {
+        ids: promotionsToBeDelete.map((limit) => limit.promotion_id),
+      },
+    });
+    await customCampaignModuleService.softDeletePromotionUsageLimits(
+      promotionsToBeDelete.map((limit) => limit.id)
+    );
+
+    // 4. Create promotions to be created
+    const { result: createdPromotions } = await createPromotionsWorkflow.run({
+      input: {
+        promotionsData: promotionsToBeCreate.map(
+          (product) =>
+            ({
+              code: `${campaign.campaign_identifier}-${product.product.id}`,
+              type: "standard",
+              status: "active",
+              is_automatic: true,
+              campaign_id: campaign_id,
+              application_method: {
+                target_type: "items",
+                allocation: "each",
+                type: product.discountType,
+                value: product.discountValue,
+                max_quantity: product.maxQty,
+                target_rules: [
+                  {
+                    attribute: "items.product.id",
+                    operator: "eq",
+                    values: [product.product.id],
+                  },
+                ],
+              } satisfies CreateApplicationMethodDTO,
+            } satisfies CreatePromotionDTO)
+        ),
+      },
+    });
+    const productPromotionMap = new Map<string, string>();
+    createdPromotions.forEach((promotion) => {
+      const productId = promotion.code?.split("-").at(-1);
+      if (!productId) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          "Invalid product id"
+        );
+      }
+      productPromotionMap.set(productId, promotion.id);
+    });
+    await customCampaignModuleService.createPromotionUsageLimits(
+      promotionsToBeCreate.map((product) => ({
+        campaign_id: campaign.id,
+        promotion_id: productPromotionMap.get(product.product.id) ?? "",
+        product_id: product.product.id,
+        limit: product.limit,
+        used: 0,
+      }))
+    );
+    return new StepResponse();
+  }
+);
+
+export const updateCustomFlashSaleWorkflow = createWorkflow(
+  "update-custom-flash-sale",
+  (data: UpdateFlashSaleInput) => {
+    const updatedFlashSale = updateCustomFlashSaleStep(data);
+
+    return new WorkflowResponse(updatedFlashSale);
+  }
+);

package/src/workflows/custom-campaign/updatePromotionUsageWorkflow.ts

@@ -0,0 +1,70 @@
+import { Modules } from "@medusajs/framework/utils";
+import {
+  createStep,
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { CUSTOM_CAMPAIGN_MODULE } from "../../modules/custom-campaigns";
+import CustomCampaignModuleService from "../../modules/custom-campaigns/service";
+
+interface UpdatePromotionUsageInput {
+  order_id: string;
+}
+
+const updatePromotionUsageStep = createStep(
+  "update-promotion-usage-step",
+  async ({ order_id }: UpdatePromotionUsageInput, { container }) => {
+    const orderService = await container.resolve(Modules.ORDER);
+
+    const promotionService = await container.resolve(Modules.PROMOTION);
+    const customCampaignTypeService =
+      container.resolve<CustomCampaignModuleService>(CUSTOM_CAMPAIGN_MODULE);
+
+    const order = await orderService.retrieveOrder(order_id, {
+      relations: ["items.adjustments"],
+    });
+
+    const promotionSet = new Set(
+      order.items
+        ?.map((item) =>
+          item.adjustments?.map((adjustment) => adjustment.promotion_id)
+        )
+        .flat()
+    );
+    const promotionIds = Array.from(promotionSet);
+    const promotionUsageLimits =
+      await customCampaignTypeService.listPromotionUsageLimits({
+        promotion_id: promotionIds,
+      });
+
+    const updatePromotionUsagePayload = promotionUsageLimits.map((limit) => ({
+      ...limit,
+      used: limit.used + 1,
+    }));
+
+    const limitReachedPromotions = updatePromotionUsagePayload.filter(
+      (limit) => limit.used >= limit.limit
+    );
+
+    if (limitReachedPromotions.length > 0) {
+      await promotionService.updatePromotions(
+        limitReachedPromotions.map((limit) => ({
+          id: limit.promotion_id,
+          status: "inactive",
+        }))
+      );
+    }
+
+    await customCampaignTypeService.updatePromotionUsageLimits(
+      updatePromotionUsagePayload
+    );
+  }
+);
+
+export const updatePromotionUsageWorkflow = createWorkflow(
+  "update-promotion-usage",
+  (data: UpdatePromotionUsageInput) => {
+    updatePromotionUsageStep(data);
+    return new WorkflowResponse({ success: true });
+  }
+);