implement events to the pricing module (#7584)

packages/modules/pricing/src/services/pricing-module.ts

@@ -21,6 +21,7 @@ import {
 import {
   arrayDifference,
   deduplicate,
+  EmitEvents,
   generateEntityId,
   groupBy,
   InjectManager,
@@ -47,11 +48,11 @@ import {
 } from "@models"
 
 import { PriceListService, RuleTypeService } from "@services"
-import { validatePriceListDates } from "@utils"
-import { UpdatePriceSetInput } from "src/types/services"
+import { validatePriceListDates, eventBuilders } from "@utils"
 import { entityNameToLinkableKeysMap, joinerConfig } from "../joiner-config"
 import { PriceListIdPrefix } from "../models/price-list"
 import { PriceSetIdPrefix } from "../models/price-set"
+import { ServiceTypes } from "@types"
 
 type InjectedDependencies = {
   baseRepository: DAL.RepositoryService
@@ -326,6 +327,7 @@ export default class PricingModuleService<
   ): Promise<PriceSetDTO[]>
 
   @InjectManager("baseRepository_")
+  @EmitEvents()
   async create(
     data: PricingTypes.CreatePriceSetDTO | PricingTypes.CreatePriceSetDTO[],
     @MedusaContext() sharedContext: Context = {}
@@ -336,7 +338,14 @@ export default class PricingModuleService<
     // TODO: Remove the need to refetch the data here
     const dbPriceSets = await this.list(
       { id: priceSets.map((p) => p.id) },
-      { relations: ["rule_types", "prices", "price_rules"] },
+      {
+        relations: [
+          "rule_types",
+          "prices",
+          "price_rules",
+          "prices.price_rules",
+        ],
+      },
       sharedContext
     )
 
@@ -366,7 +375,7 @@ export default class PricingModuleService<
   ): Promise<PriceSetDTO | PriceSetDTO[]> {
     const input = Array.isArray(data) ? data : [data]
     const forUpdate = input.filter(
-      (priceSet): priceSet is UpdatePriceSetInput => !!priceSet.id
+      (priceSet): priceSet is ServiceTypes.UpdatePriceSetInput => !!priceSet.id
     )
     const forCreate = input.filter(
       (priceSet): priceSet is CreatePriceSetDTO => !priceSet.id
@@ -404,7 +413,7 @@ export default class PricingModuleService<
     data: PricingTypes.UpdatePriceSetDTO,
     @MedusaContext() sharedContext: Context = {}
   ): Promise<PriceSetDTO | PriceSetDTO[]> {
-    let normalizedInput: UpdatePriceSetInput[] = []
+    let normalizedInput: ServiceTypes.UpdatePriceSetInput[] = []
     if (isString(idOrSelector)) {
       // Check if the ID exists, it will throw if not.
       await this.priceSetService_.retrieve(idOrSelector, {}, sharedContext)
@@ -431,7 +440,7 @@ export default class PricingModuleService<
   }
 
   private async normalizeUpdateData(
-    data: UpdatePriceSetInput[],
+    data: ServiceTypes.UpdatePriceSetInput[],
     sharedContext
   ) {
     const ruleAttributes = data
@@ -480,7 +489,7 @@ export default class PricingModuleService<
 
   @InjectTransactionManager("baseRepository_")
   protected async update_(
-    data: UpdatePriceSetInput[],
+    data: ServiceTypes.UpdatePriceSetInput[],
     @MedusaContext() sharedContext: Context = {}
   ): Promise<PriceSet[]> {
     // TODO: We are not handling rule types, rules, etc. here, add support after data models are finalized
@@ -560,6 +569,7 @@ export default class PricingModuleService<
   ): Promise<PricingTypes.PriceSetDTO[]>
 
   @InjectManager("baseRepository_")
+  @EmitEvents()
   async addPrices(
     data: AddPricesDTO | AddPricesDTO[],
     @MedusaContext() sharedContext: Context = {}
@@ -626,6 +636,7 @@ export default class PricingModuleService<
   }
 
   @InjectManager("baseRepository_")
+  @EmitEvents()
   async createPriceLists(
     data: PricingTypes.CreatePriceListDTO[],
     @MedusaContext() sharedContext: Context = {}
@@ -668,6 +679,7 @@ export default class PricingModuleService<
   }
 
   @InjectManager("baseRepository_")
+  @EmitEvents()
   async addPriceListPrices(
     data: PricingTypes.AddPriceListPricesDTO[],
     @MedusaContext() sharedContext: Context = {}
@@ -823,6 +835,49 @@ export default class PricingModuleService<
       sharedContext
     )
 
+    const eventsData = createdPriceSets.reduce(
+      (eventsData, priceSet) => {
+        eventsData.priceSets.push({
+          id: priceSet.id,
+        })
+
+        priceSet.prices.map((price) => {
+          eventsData.prices.push({
+            id: price.id,
+          })
+          price.price_rules.map((priceRule) => {
+            eventsData.priceRules.push({
+              id: priceRule.id,
+            })
+          })
+        })
+
+        return eventsData
+      },
+      {
+        priceSets: [],
+        priceRules: [],
+        prices: [],
+      } as {
+        priceSets: { id: string }[]
+        priceRules: { id: string }[]
+        prices: { id: string }[]
+      }
+    )
+
+    eventBuilders.createdPriceSet({
+      data: eventsData.priceSets,
+      sharedContext,
+    })
+    eventBuilders.createdPrice({
+      data: eventsData.prices,
+      sharedContext,
+    })
+    eventBuilders.createdPriceRule({
+      data: eventsData.priceRules,
+      sharedContext,
+    })
+
     if (ruleSetRuleTypeToCreateMap.size) {
       await this.priceSetRuleTypeService_.create(
         Array.from(ruleSetRuleTypeToCreateMap.values()),
@@ -982,12 +1037,53 @@ export default class PricingModuleService<
             price_set_id: priceSetId,
             title: "test", // TODO: accept title
             rules_count: numberOfRules,
-            priceRules,
+            price_rules: priceRules,
           }
         })
     )
 
-    await this.priceService_.create(pricesToCreate, sharedContext)
+    const prices = await this.priceService_.create(
+      pricesToCreate,
+      sharedContext
+    )
+
+    /**
+     * Preparing data for emitting events
+     */
+    const eventsData = prices.reduce(
+      (eventsData, price) => {
+        eventsData.prices.push({
+          id: price.id,
+        })
+        price.price_rules.map((priceRule) => {
+          eventsData.priceRules.push({
+            id: priceRule.id,
+          })
+        })
+        return eventsData
+      },
+      {
+        priceRules: [],
+        prices: [],
+      } as {
+        priceRules: { id: string }[]
+        prices: { id: string }[]
+      }
+    )
+
+    /**
+     * Emitting events for all created entities
+     */
+    eventBuilders.createdPrice({
+      data: eventsData.prices,
+      sharedContext,
+    })
+    eventBuilders.createdPriceRule({
+      data: eventsData.priceRules,
+      sharedContext,
+    })
+
+    return prices
   }
 
   @InjectTransactionManager("baseRepository_")
@@ -1085,10 +1181,73 @@ export default class PricingModuleService<
       }
     )
 
-    return await this.priceListService_.create(
+    const priceLists = await this.priceListService_.create(
       priceListsToCreate,
       sharedContext
     )
+
+    /**
+     * Preparing data for emitting events
+     */
+    const eventsData = priceLists.reduce(
+      (eventsData, priceList) => {
+        eventsData.priceList.push({
+          id: priceList.id,
+        })
+
+        priceList.price_list_rules.map((listRule) => {
+          eventsData.priceListRules.push({
+            id: listRule.id,
+          })
+        })
+
+        priceList.prices.map((price) => {
+          eventsData.prices.push({
+            id: price.id,
+          })
+          price.price_rules.map((priceRule) => {
+            eventsData.priceRules.push({
+              id: priceRule.id,
+            })
+          })
+        })
+
+        return eventsData
+      },
+      {
+        priceList: [],
+        priceListRules: [],
+        priceRules: [],
+        prices: [],
+      } as {
+        priceList: { id: string }[]
+        priceListRules: { id: string }[]
+        priceRules: { id: string }[]
+        prices: { id: string }[]
+      }
+    )
+
+    /**
+     * Emitting events for all created entities
+     */
+    eventBuilders.createdPriceList({
+      data: eventsData.priceList,
+      sharedContext,
+    })
+    eventBuilders.createdPriceListRule({
+      data: eventsData.priceListRules,
+      sharedContext,
+    })
+    eventBuilders.createdPrice({
+      data: eventsData.prices,
+      sharedContext,
+    })
+    eventBuilders.createdPriceRule({
+      data: eventsData.priceRules,
+      sharedContext,
+    })
+
+    return priceLists
   }
 
   @InjectTransactionManager("baseRepository_")
@@ -1468,7 +1627,44 @@ export default class PricingModuleService<
       pricesToCreate.push(...priceListPricesToCreate)
     }
 
-    return await this.priceService_.create(pricesToCreate, sharedContext)
+    const createdPrices = await this.priceService_.create(
+      pricesToCreate,
+      sharedContext
+    )
+
+    const eventsData = createdPrices.reduce(
+      (eventsData, price) => {
+        eventsData.prices.push({
+          id: price.id,
+        })
+
+        price.price_rules.map((priceRule) => {
+          eventsData.priceRules.push({
+            id: priceRule.id,
+          })
+        })
+
+        return eventsData
+      },
+      {
+        priceRules: [],
+        prices: [],
+      } as {
+        priceRules: { id: string }[]
+        prices: { id: string }[]
+      }
+    )
+
+    eventBuilders.createdPrice({
+      data: eventsData.prices,
+      sharedContext,
+    })
+    eventBuilders.createdPriceRule({
+      data: eventsData.priceRules,
+      sharedContext,
+    })
+
+    return createdPrices
   }
 
   @InjectTransactionManager("baseRepository_")

packages/modules/pricing/src/utils/events.ts

@@ -0,0 +1,52 @@
+import {} from "@models"
+import {
+  Modules,
+  CommonEvents,
+  PricingEvents,
+  eventBuilderFactory,
+} from "@medusajs/utils"
+
+export const eventBuilders = {
+  createdPriceSet: eventBuilderFactory({
+    service: Modules.PRICING,
+    action: CommonEvents.CREATED,
+    object: "price_set",
+    eventsEnum: PricingEvents,
+  }),
+  createdPriceSetRuleType: eventBuilderFactory({
+    service: Modules.PRICING,
+    action: CommonEvents.CREATED,
+    object: "price_set_rule_type",
+    eventsEnum: PricingEvents,
+  }),
+  createdPrice: eventBuilderFactory({
+    service: Modules.PRICING,
+    action: CommonEvents.CREATED,
+    object: "price",
+    eventsEnum: PricingEvents,
+  }),
+  createdPriceRule: eventBuilderFactory({
+    service: Modules.PRICING,
+    action: CommonEvents.CREATED,
+    object: "price_rule",
+    eventsEnum: PricingEvents,
+  }),
+  createdPriceList: eventBuilderFactory({
+    service: Modules.PRICING,
+    action: CommonEvents.CREATED,
+    object: "price_list",
+    eventsEnum: PricingEvents,
+  }),
+  createdPriceListRule: eventBuilderFactory({
+    service: Modules.PRICING,
+    action: CommonEvents.CREATED,
+    object: "price_list_rule",
+    eventsEnum: PricingEvents,
+  }),
+  attachedPriceListRule: eventBuilderFactory({
+    service: Modules.PRICING,
+    action: CommonEvents.ATTACHED,
+    object: "price_list_rule",
+    eventsEnum: PricingEvents,
+  }),
+}

packages/modules/pricing/src/utils/index.ts

@@ -1 +1,2 @@
 export * from "./validate-price-list-dates"
+export * from "./events"