feat(core-flows,medusa,types,utils): rename psma to prices (#6796)

What: Renames pricesetmoneyamount to prices Co-authored-by: Adrien de Peretti <25098370+adrien2p@users.noreply.github.com>
2024-03-25 13:15:25 +00:00
parent fbc369705d
commit 9073d7aba3
80 changed files with 1056 additions and 2276 deletions
@@ -2,6 +2,7 @@ import {
  AddPricesDTO,
  Context,
  CreatePriceListRuleDTO,
+  CreatePricesDTO,
  DAL,
  InternalModuleDeclaration,
  ModuleJoinerConfig,
@@ -14,33 +15,33 @@ import {
  RuleTypeDTO,
 } from "@medusajs/types"
 import {
+  arrayDifference,
+  deduplicate,
+  generateEntityId,
+  groupBy,
  InjectManager,
  InjectTransactionManager,
  MedusaContext,
  MedusaError,
  ModulesSdkUtils,
  PriceListType,
-  arrayDifference,
-  deduplicate,
-  groupBy,
  removeNullish,
 } from "@medusajs/utils"

 import {
+  Price,
  PriceList,
  PriceListRule,
  PriceListRuleValue,
  PriceRule,
  PriceSet,
-  PriceSetMoneyAmount,
  PriceSetRuleType,
  RuleType,
 } from "@models"

-import { PriceListService, RuleTypeService } from "@services"
-import { ServiceTypes } from "@types"
-import { validatePriceListDates } from "@utils"
-import { entityNameToLinkableKeysMap, joinerConfig } from "../joiner-config"
+import {PriceListService, RuleTypeService} from "@services"
+import {validatePriceListDates} from "@utils"
+import {entityNameToLinkableKeysMap, joinerConfig} from "../joiner-config"

 type InjectedDependencies = {
  baseRepository: DAL.RepositoryService
@@ -49,7 +50,7 @@ type InjectedDependencies = {
  ruleTypeService: RuleTypeService<any>
  priceRuleService: ModulesSdkTypes.InternalModuleService<any>
  priceSetRuleTypeService: ModulesSdkTypes.InternalModuleService<any>
-  priceSetMoneyAmountService: ModulesSdkTypes.InternalModuleService<any>
+  priceService: ModulesSdkTypes.InternalModuleService<any>
  priceListService: PriceListService<any>
  priceListRuleService: ModulesSdkTypes.InternalModuleService<any>
  priceListRuleValueService: ModulesSdkTypes.InternalModuleService<any>
@@ -60,7 +61,7 @@ const generateMethodForModels = [
  PriceListRule,
  PriceListRuleValue,
  PriceRule,
-  PriceSetMoneyAmount,
+  Price,
  PriceSetRuleType,
  RuleType,
 ]
@@ -70,7 +71,7 @@ export default class PricingModuleService<
    TRuleType extends RuleType = RuleType,
    TPriceRule extends PriceRule = PriceRule,
    TPriceSetRuleType extends PriceSetRuleType = PriceSetRuleType,
-    TPriceSetMoneyAmount extends PriceSetMoneyAmount = PriceSetMoneyAmount,
+    TPrice extends Price = Price,
    TPriceList extends PriceList = PriceList,
    TPriceListRule extends PriceListRule = PriceListRule,
    TPriceListRuleValue extends PriceListRuleValue = PriceListRuleValue
@@ -79,7 +80,7 @@ export default class PricingModuleService<
    InjectedDependencies,
    PricingTypes.PriceSetDTO,
    {
-      PriceSetMoneyAmount: { dto: PricingTypes.PriceSetMoneyAmountDTO }
+      Price: { dto: PricingTypes.PriceDTO }
      PriceRule: {
        dto: PricingTypes.PriceRuleDTO
        create: PricingTypes.CreatePriceRuleDTO
@@ -102,7 +103,7 @@ export default class PricingModuleService<
  protected readonly priceSetService_: ModulesSdkTypes.InternalModuleService<TPriceSet>
  protected readonly priceRuleService_: ModulesSdkTypes.InternalModuleService<TPriceRule>
  protected readonly priceSetRuleTypeService_: ModulesSdkTypes.InternalModuleService<TPriceSetRuleType>
-  protected readonly priceSetMoneyAmountService_: ModulesSdkTypes.InternalModuleService<TPriceSetMoneyAmount>
+  protected readonly priceService_: ModulesSdkTypes.InternalModuleService<TPrice>
  protected readonly priceListService_: PriceListService<TPriceList>
  protected readonly priceListRuleService_: ModulesSdkTypes.InternalModuleService<TPriceListRule>
  protected readonly priceListRuleValueService_: ModulesSdkTypes.InternalModuleService<TPriceListRuleValue>
@@ -115,7 +116,7 @@ export default class PricingModuleService<
      priceSetService,
      priceRuleService,
      priceSetRuleTypeService,
-      priceSetMoneyAmountService,
+      priceService,
      priceListService,
      priceListRuleService,
      priceListRuleValueService,
@@ -132,7 +133,7 @@ export default class PricingModuleService<
    this.ruleTypeService_ = ruleTypeService
    this.priceRuleService_ = priceRuleService
    this.priceSetRuleTypeService_ = priceSetRuleTypeService
-    this.priceSetMoneyAmountService_ = priceSetMoneyAmountService
+    this.priceService_ = priceService
    this.priceListService_ = priceListService
    this.priceListRuleService_ = priceListRuleService
    this.priceListRuleValueService_ = priceListRuleValueService
@@ -228,20 +229,20 @@ export default class PricingModuleService<
    @MedusaContext() sharedContext: Context = {}
  ): Promise<PriceSetDTO | PriceSetDTO[]> {
    const input = Array.isArray(data) ? data : [data]
-
    const priceSets = await this.create_(input, sharedContext)

    const dbPriceSets = await this.list(
-      { id: priceSets.filter((p) => !!p).map((p) => p!.id) },
-      {
-        relations: ["rule_types", "price_set_money_amounts", "price_rules"],
-      },
+      { id: priceSets.map((p) => p.id) },
+      { relations: ["rule_types", "prices", "price_rules"] },
      sharedContext
    )

-    return (Array.isArray(data) ? dbPriceSets : dbPriceSets[0]) as unknown as
-      | PriceSetDTO
-      | PriceSetDTO[]
+    // Ensure the output to be in the same order as the input
+    const results = priceSets.map((priceSet) => {
+      return dbPriceSets.find((p) => p.id === priceSet.id)!
+    })
+
+    return Array.isArray(data) ? results : results[0]
  }

  @InjectTransactionManager("baseRepository_")
@@ -249,14 +250,14 @@ export default class PricingModuleService<
    data: PricingTypes.CreatePriceSetDTO[],
    @MedusaContext() sharedContext: Context = {}
  ) {
+    const input = Array.isArray(data) ? data : [data]
+
    const ruleAttributes = data
      .map((d) => d.rules?.map((r) => r.rule_attribute) ?? [])
      .flat()

    const ruleTypes = await this.ruleTypeService_.list(
-      {
-        rule_attribute: ruleAttributes,
-      },
+      { rule_attribute: ruleAttributes },
      { take: null },
      sharedContext
    )
@@ -293,77 +294,82 @@ export default class PricingModuleService<
      )
    }

+    const ruleSetRuleTypeToCreateMap: Map<string, TPriceSetRuleType> = new Map()
+
+    const toCreate = input.map((inputData) => {
+      const id = generateEntityId(
+        (inputData as unknown as TPriceSet).id,
+        "pset"
+      )
+
+      const { prices, rules = [], ...rest } = inputData
+
+      let pricesData: CreatePricesDTO[] = []
+
+      rules.forEach((rule) => {
+        const priceSetRuleType = {
+          rule_type_id: ruleTypeMap.get(rule.rule_attribute).id,
+          price_set_id: id,
+        } as TPriceSetRuleType
+
+        ruleSetRuleTypeToCreateMap.set(
+          JSON.stringify(priceSetRuleType),
+          priceSetRuleType
+        )
+      })
+
+      if (inputData.prices) {
+        pricesData = inputData.prices.map((price) => {
+          let { rules: priceRules = {}, ...rest } = price
+          const cleanRules = priceRules ? removeNullish(priceRules) : {}
+          const numberOfRules = Object.keys(cleanRules).length
+
+          const rulesDataMap = new Map()
+
+          Object.entries(priceRules).map(([attribute, value]) => {
+            const rule = {
+              price_set_id: id,
+              rule_type_id: ruleTypeMap.get(attribute).id,
+              value,
+            }
+            rulesDataMap.set(JSON.stringify(rule), rule)
+
+            const priceSetRuleType = {
+              rule_type_id: ruleTypeMap.get(attribute).id,
+              price_set_id: id,
+            } as TPriceSetRuleType
+
+            ruleSetRuleTypeToCreateMap.set(
+              JSON.stringify(priceSetRuleType),
+              priceSetRuleType
+            )
+          })
+
+          return {
+            ...rest,
+            title: "test", // TODO: accept title
+            rules_count: numberOfRules,
+            price_rules: Array.from(rulesDataMap.values()),
+          }
+        })
+      }
+
+      return {
+        ...rest,
+        id,
+        prices: pricesData,
+      }
+    })
+
    // Bulk create price sets
-    const priceSetData = data.map(({ rules, prices, ...rest }) => rest)
    const createdPriceSets = await this.priceSetService_.create(
-      priceSetData,
+      toCreate,
      sharedContext
    )

-    // Price set rule types
-    const ruleTypeData = data.flatMap(
-      (item, index) =>
-        item.rules?.map((rule) => ({
-          rule_type: ruleTypeMap.get(rule.rule_attribute),
-          price_set: createdPriceSets[index],
-        })) || []
-    )
-
-    if (ruleTypeData.length > 0) {
+    if (ruleSetRuleTypeToCreateMap.size) {
      await this.priceSetRuleTypeService_.create(
-        ruleTypeData as unknown as PricingTypes.CreatePriceSetRuleTypeDTO[],
-        sharedContext
-      )
-    }
-
-    const priceSetMoneyAmountData: unknown[] = []
-    const priceRulesData: unknown[] = []
-
-    for (const [index, item] of data.entries()) {
-      for (const price of item.prices || []) {
-        const cleanRules = price.rules ? removeNullish(price.rules) : {}
-        const numberOfRules = Object.entries(cleanRules).length
-
-        const priceSetMoneyAmount = {
-          ...price,
-          price_set_id: createdPriceSets[index].id,
-          title: "test", // TODO: accept title
-          rules_count: numberOfRules,
-        }
-        priceSetMoneyAmountData.push(priceSetMoneyAmount)
-
-        for (const [k, v] of Object.entries(cleanRules)) {
-          priceRulesData.push({
-            price_set_money_amount_id: null, // Updated later
-            rule_type_id: ruleTypeMap.get(k).id,
-            price_set_id: createdPriceSets[index].id,
-            value: v,
-            price_list_id: "test",
-          })
-        }
-      }
-    }
-
-    // Bulk create price set money amounts
-    const createdPriceSetMoneyAmounts =
-      await this.priceSetMoneyAmountService_.create(
-        priceSetMoneyAmountData as PricingTypes.CreatePriceSetMoneyAmountDTO[],
-        sharedContext
-      )
-
-    // Update price set money amount references
-    for (let i = 0, j = 0; i < priceSetMoneyAmountData.length; i++) {
-      const rulesCount = (priceSetMoneyAmountData[i] as any).rules_count
-      for (let k = 0; k < rulesCount; k++, j++) {
-        ;(priceRulesData[j] as any).price_set_money_amount_id =
-          createdPriceSetMoneyAmounts[i].id
-      }
-    }
-
-    // Price rules
-    if (priceRulesData.length > 0) {
-      await this.priceRuleService_.create(
-        priceRulesData as ServiceTypes.CreatePriceRuleDTO[],
+        Array.from(ruleSetRuleTypeToCreateMap.values()),
        sharedContext
      )
    }
@@ -392,9 +398,7 @@ export default class PricingModuleService<

    return await this.list(
      { id: priceSets.map(({ id }) => id) },
-      {
-        relations: ["rule_types"],
-      }
+      { relations: ["rule_types"] }
    )
  }

@@ -417,7 +421,6 @@ export default class PricingModuleService<
    )

    const priceSetMap = new Map(priceSets.map((p) => [p.id, p]))
-
    const invalidPriceSetInputs = inputs.filter(
      (d) => !priceSetMap.has(d.priceSetId)
    )
@@ -434,7 +437,7 @@ export default class PricingModuleService<
    const ruleTypes = await this.ruleTypeService_.list(
      {
        rule_attribute: inputs
-          .map((d) => d.rules.map((r) => r.attribute))
+          .map((data) => data.rules.map((r) => r.attribute))
          .flat(),
      },
      { take: null },
@@ -461,23 +464,21 @@ export default class PricingModuleService<

    const priceSetRuleTypesCreate: PricingTypes.CreatePriceSetRuleTypeDTO[] = []

-    inputs.forEach((d) => {
-      const priceSet = priceSetMap.get(d.priceSetId)
-
-      for (const r of d.rules) {
-        if (priceSetRuleTypeMap.get(d.priceSetId)!.has(r.attribute)) {
+    inputs.forEach((data) => {
+      for (const rule of data.rules) {
+        if (priceSetRuleTypeMap.get(data.priceSetId)!.has(rule.attribute)) {
          continue
        }

        priceSetRuleTypesCreate.push({
-          rule_type: ruleTypeMap.get(r.attribute) as RuleTypeDTO,
-          price_set: priceSet as unknown as PriceSetDTO,
+          rule_type_id: ruleTypeMap.get(rule.attribute)!.id,
+          price_set_id: priceSetMap.get(data.priceSetId)!.id,
        })
      }
    })

    await this.priceSetRuleTypeService_.create(
-      priceSetRuleTypesCreate as unknown as PricingTypes.CreatePriceSetRuleTypeDTO[],
+      priceSetRuleTypesCreate,
      sharedContext
    )

@@ -503,11 +504,11 @@ export default class PricingModuleService<

    await this.addPrices_(input, sharedContext)

-    return (await this.list(
+    return await this.list(
      { id: input.map((d) => d.priceSetId) },
-      { relations: ["price_set_money_amounts"] },
+      { relations: ["prices"] },
      sharedContext
-    )) as unknown as PricingTypes.PriceSetDTO[] | PricingTypes.PriceSetDTO
+    )
  }

  @InjectTransactionManager("baseRepository_")
@@ -558,7 +559,7 @@ export default class PricingModuleService<
      }
    })

-    const priceSetMoneyAmountsBulkData: unknown[] = input.flatMap(
+    const pricesToCreate: PricingTypes.CreatePriceDTO[] = input.flatMap(
      ({ priceSetId, prices }) =>
        prices.map((price) => {
          const numberOfRules = Object.entries(price?.rules ?? {}).length
@@ -572,21 +573,21 @@ export default class PricingModuleService<
        })
    )

-    const createdPriceSetMoneyAmounts =
-      await this.priceSetMoneyAmountService_.create(
-        priceSetMoneyAmountsBulkData as ServiceTypes.CreatePriceSetMoneyAmountDTO[],
-        sharedContext
-      )
+    const createdPrices = await this.priceService_.create(
+      pricesToCreate,
+      sharedContext
+    )

    // Price rules
    let rulesCursor = 0
    const priceRulesBulkData = input.flatMap(({ priceSetId, prices }) =>
      prices.flatMap((ma) => {
        const rules = ma.rules ?? {}
-        const priceSetMoneyAmount = createdPriceSetMoneyAmounts[rulesCursor]
+        const price = createdPrices[rulesCursor]
        rulesCursor++
+
        return Object.entries(rules).map(([k, v]) => ({
-          price_set_money_amount_id: priceSetMoneyAmount.id,
+          price_id: price.id,
          rule_type_id: ruleTypeMap.get(priceSetId)!.get(k)!.id,
          price_set_id: priceSetId,
          value: v,
@@ -605,14 +606,12 @@ export default class PricingModuleService<
    @MedusaContext() sharedContext: Context = {}
  ): Promise<void> {
    const priceSets = await this.priceSetService_.list(
-      {
-        id: data.map((d) => d.id),
-      },
+      { id: data.map((d) => d.id) },
      {},
      sharedContext
    )
-    const priceSetIds = priceSets.map((ps) => ps.id)

+    const priceSetIds = priceSets.map((ps) => ps.id)
    const ruleTypes = await this.ruleTypeService_.list(
      {
        rule_attribute: data.map((d) => d.rules || []).flat(),
@@ -620,26 +619,17 @@ export default class PricingModuleService<
      { take: null },
      sharedContext
    )
-    const ruleTypeIds = ruleTypes.map((rt) => rt.id)

+    const ruleTypeIds = ruleTypes.map((rt) => rt.id)
    const priceSetRuleTypes = await this.priceSetRuleTypeService_.list(
-      {
-        price_set_id: priceSetIds,
-        rule_type_id: ruleTypeIds,
-      },
+      { price_set_id: priceSetIds, rule_type_id: ruleTypeIds },
      { take: null },
      sharedContext
    )

    const priceRules = await this.priceRuleService_.list(
-      {
-        price_set_id: priceSetIds,
-        rule_type_id: ruleTypeIds,
-      },
-      {
-        select: ["price_set_money_amount"],
-        take: null,
-      },
+      { price_set_id: priceSetIds, rule_type_id: ruleTypeIds },
+      { select: ["price"], take: null },
      sharedContext
    )

@@ -648,8 +638,8 @@ export default class PricingModuleService<
      sharedContext
    )

-    await this.priceSetMoneyAmountService_.delete(
-      priceRules.map((pr) => pr.price_set_money_amount.id),
+    await this.priceService_.delete(
+      priceRules.map((pr) => pr.price.id),
      sharedContext
    )
  }
@@ -663,9 +653,7 @@ export default class PricingModuleService<

    return await this.baseRepository_.serialize<PricingTypes.PriceSetDTO[]>(
      priceSets,
-      {
-        populate: true,
-      }
+      { populate: true }
    )
  }

@@ -678,9 +666,7 @@ export default class PricingModuleService<

    return await this.baseRepository_.serialize<PricingTypes.PriceListDTO[]>(
      priceLists,
-      {
-        populate: true,
-      }
+      { populate: true }
    )
  }

@@ -759,7 +745,7 @@ export default class PricingModuleService<
        )

        // Create the values for the rule
-        for (const ruleValue of ruleValues as string[]) {
+        for (const ruleValue of ruleValues) {
          await this.priceListRuleValueService_.create(
            [{ price_list_rule_id: priceListRule.id, value: ruleValue }],
            sharedContext
@@ -767,26 +753,23 @@ export default class PricingModuleService<
        }
      }

-      for (const price of prices) {
+      for (const priceData of prices) {
        const {
          price_set_id: priceSetId,
          rules: priceRules = {},
-          ...psmaData
-        } = price
+          ...rest
+        } = priceData

-        const [priceSetMoneyAmount] =
-          await this.priceSetMoneyAmountService_.create(
-            [
-              {
-                price_set_id: priceSetId,
-                price_list_id: priceList.id,
-                title: "test",
-                rules_count: Object.keys(priceRules).length,
-                ...psmaData,
-              },
-            ],
-            sharedContext
-          )
+        const createdPrice = await this.priceService_.create(
+          {
+            price_set_id: priceSetId,
+            price_list_id: priceList.id,
+            title: "test",
+            rules_count: Object.keys(priceRules).length,
+            ...rest,
+          },
+          sharedContext
+        )

        await this.priceRuleService_.create(
          Object.entries(priceRules).map(([ruleAttribute, ruleValue]) => {
@@ -794,7 +777,7 @@ export default class PricingModuleService<
              price_set_id: priceSetId,
              rule_type_id: ruleTypeMap.get(ruleAttribute)!?.id,
              value: ruleValue,
-              price_set_money_amount_id: priceSetMoneyAmount.id,
+              price_id: createdPrice.id,
            }
          }),
          sharedContext
@@ -814,9 +797,7 @@ export default class PricingModuleService<

    return await this.baseRepository_.serialize<PricingTypes.PriceListDTO[]>(
      priceLists,
-      {
-        populate: true,
-      }
+      { populate: true }
    )
  }

@@ -913,7 +894,7 @@ export default class PricingModuleService<
          sharedContext
        )

-        for (const ruleValue of ruleValues as string[]) {
+        for (const ruleValue of ruleValues) {
          await this.priceListRuleValueService_.create(
            [{ price_list_rule_id: priceListRule.id, value: ruleValue }],
            sharedContext
@@ -979,7 +960,7 @@ export default class PricingModuleService<
  ): Promise<PricingTypes.PriceListDTO[]> {
    const ruleTypeAttributes: string[] = []
    const priceListIds: string[] = []
-    const psmaIds: string[] = []
+    const priceIds: string[] = []
    const priceSetIds = data
      .map((d) => d.prices.map((price) => price.price_set_id))
      .flat()
@@ -988,22 +969,19 @@ export default class PricingModuleService<
      priceListIds.push(priceListData.price_list_id)

      for (const price of priceListData.prices) {
-        psmaIds.push(price.id)
+        priceIds.push(price.id)
        ruleTypeAttributes.push(...Object.keys(price.rules || {}))
      }
    }

-    const psmas = await this.listPriceSetMoneyAmounts(
-      { id: psmaIds },
-      {
-        take: null,
-        relations: ["price_rules"],
-      },
+    const prices = await this.listPrices(
+      { id: priceIds },
+      { take: null, relations: ["price_rules"] },
      sharedContext
    )

-    const psmaMap: Map<string, PricingTypes.PriceSetMoneyAmountDTO> = new Map(
-      psmas.map((psma) => [psma.id, psma])
+    const priceMap: Map<string, PricingTypes.PriceDTO> = new Map(
+      prices.map((price) => [price.id, price])
    )

    const ruleTypes = await this.listRuleTypes(
@@ -1032,6 +1010,7 @@ export default class PricingModuleService<
        }

        acc.set(curr.id, priceSetRuleAttributeSet)
+
        return acc
      },
      new Map()
@@ -1080,40 +1059,41 @@ export default class PricingModuleService<
        )
      }

-      const moneyAmountsToUpdate: PricingTypes.UpdateMoneyAmountDTO[] = []
-      const priceRulesToDelete: string[] = []
+      const priceRuleIdsToDelete: string[] = []
      const priceRulesToCreate: PricingTypes.CreatePriceRuleDTO[] = []
-      const psmaToUpdate: ServiceTypes.UpdatePriceSetMoneyAmountDTO[] = []
+      const pricesToUpdate: (PricingTypes.UpdatePriceDTO & {
+        rules_count: number
+      })[] = []

-      for (const price of prices) {
-        const { rules, price_set_id, ...priceData } = price
-        const priceSetMoneyAmount = psmaMap.get(price.id)!
-        const priceRules = priceSetMoneyAmount.price_rules!
+      for (const priceData of prices) {
+        const { rules, price_set_id, ...rest } = priceData
+        const price = priceMap.get(rest.id)!
+        const priceRules = price.price_rules!

        if (typeof rules === "undefined") {
          continue
        }

-        psmaToUpdate.push({
-          ...priceData,
+        pricesToUpdate.push({
+          ...rest,
          rules_count: Object.keys(rules).length,
        })

-        priceRulesToDelete.push(...priceRules.map((pr) => pr.id))
+        priceRuleIdsToDelete.push(...priceRules.map((pr) => pr.id))
        priceRulesToCreate.push(
          ...Object.entries(rules).map(([ruleAttribute, ruleValue]) => ({
-            price_set_id: price.price_set_id,
+            price_set_id,
            rule_type_id: ruleTypeMap.get(ruleAttribute)!.id,
            value: ruleValue,
-            price_set_money_amount_id: priceSetMoneyAmount.id,
+            price_id: price.id,
          }))
        )
      }

      await Promise.all([
-        this.priceRuleService_.delete(priceRulesToDelete),
+        this.priceRuleService_.delete(priceRuleIdsToDelete),
        this.priceRuleService_.create(priceRulesToCreate),
-        this.priceSetMoneyAmountService_.update(psmaToUpdate),
+        this.priceService_.update(pricesToUpdate),
      ])
    }

@@ -1133,7 +1113,7 @@ export default class PricingModuleService<
    ids: string[],
    sharedContext: Context = {}
  ): Promise<void> {
-    await this.priceSetMoneyAmountService_.delete(ids, sharedContext)
+    await this.priceService_.delete(ids, sharedContext)
  }

  @InjectManager("baseRepository_")
@@ -1237,15 +1217,15 @@ export default class PricingModuleService<
      }

      await Promise.all(
-        prices.map(async (price) => {
-          const priceRules = price.rules || {}
+        prices.map(async (priceData) => {
+          const priceRules = priceData.rules || {}
          const noOfRules = Object.keys(priceRules).length

-          const [psma] = await this.priceSetMoneyAmountService_.create(
+          const [price] = await this.priceService_.create(
            [
              {
-                ...price,
-                price_set_id: price.price_set_id,
+                ...priceData,
+                price_set_id: priceData.price_set_id,
                title: "test",
                price_list_id: priceList.id,
                rules_count: noOfRules,
@@ -1257,16 +1237,16 @@ export default class PricingModuleService<
          await this.priceRuleService_.create(
            Object.entries(priceRules).map(([ruleAttribute, ruleValue]) => {
              return {
-                price_set_id: price.price_set_id,
+                price_set_id: priceData.price_set_id,
                rule_type_id: ruleTypeMap.get(ruleAttribute)!?.id,
                value: ruleValue,
-                price_set_money_amount_id: psma.id,
+                price_id: price.id,
              }
            }),
            sharedContext
          )

-          return psma
+          return price
        })
      )
    }
@@ -1291,27 +1271,19 @@ export default class PricingModuleService<
  ): Promise<PricingTypes.PriceListDTO[]> {
    const priceLists = await this.priceListService_.list(
      { id: data.map((d) => d.price_list_id) },
-      {
-        relations: ["price_list_rules", "price_list_rules.rule_type"],
-      },
+      { relations: ["price_list_rules", "price_list_rules.rule_type"] },
      sharedContext
    )

    const priceListMap = new Map(priceLists.map((p) => [p.id, p]))
    const ruleTypes = await this.listRuleTypes(
-      {
-        rule_attribute: data.map((d) => Object.keys(d.rules)).flat(),
-      },
-      {
-        take: null,
-      }
+      { rule_attribute: data.map((d) => Object.keys(d.rules)).flat() },
+      { take: null }
    )

    const ruleTypeMap = new Map(ruleTypes.map((rt) => [rt.rule_attribute, rt]))
-
    const ruleIdsToUpdate: string[] = []
    const rulesToCreate: CreatePriceListRuleDTO[] = []
-
    const priceRuleValues = new Map<string, Map<string, string[]>>()

    for (const { price_list_id: priceListId, rules } of data) {
@@ -1325,9 +1297,7 @@ export default class PricingModuleService<
      }

      const priceListRulesMap: Map<string, PriceListRule> = new Map(
-        priceList.price_list_rules
-          .getItems()
-          .map((p) => [p.rule_type.rule_attribute, p])
+        priceList.price_list_rules.map((p) => [p.rule_type.rule_attribute, p])
      )

      const priceListRuleValues = new Map<string, string[]>()
@@ -1365,9 +1335,7 @@ export default class PricingModuleService<
    const [createdRules, priceListValuesToDelete] = await Promise.all([
      this.priceListRuleService_.create(rulesToCreate),
      this.priceListRuleValueService_.list(
-        {
-          price_list_rule_id: ruleIdsToUpdate,
-        },
+        { price_list_rule_id: ruleIdsToUpdate },
        { take: null }
      ),
    ])
@@ -1382,6 +1350,7 @@ export default class PricingModuleService<
      }

      const values = ruleValues.get(rule_type_id)
+
      if (!values) {
        continue
      }
@@ -1400,16 +1369,14 @@ export default class PricingModuleService<
        sharedContext
      ),
      this.priceListRuleValueService_.create(
-        priceListRuleValuesToCreate as ServiceTypes.CreatePriceListRuleValueDTO[],
+        priceListRuleValuesToCreate,
        sharedContext
      ),
    ])

    return await this.baseRepository_.serialize<PricingTypes.PriceListDTO[]>(
      priceLists,
-      {
-        populate: true,
-      }
+      { populate: true }
    )
  }

@@ -1430,15 +1397,13 @@ export default class PricingModuleService<
  ): Promise<PricingTypes.PriceListDTO[]> {
    const priceLists = await this.priceListService_.list(
      { id: data.map((d) => d.price_list_id) },
-      {
-        relations: ["price_list_rules", "price_list_rules.rule_type"],
-      },
+      { relations: ["price_list_rules", "price_list_rules.rule_type"] },
      sharedContext
    )

    const priceListMap = new Map(priceLists.map((p) => [p.id, p]))
-
    const idsToDelete: string[] = []
+
    for (const { price_list_id: priceListId, rules } of data) {
      const priceList = priceListMap.get(priceListId)

@@ -1450,14 +1415,13 @@ export default class PricingModuleService<
      }

      const priceListRulesMap: Map<string, PriceListRule> = new Map(
-        priceList.price_list_rules
-          .getItems()
-          .map((p) => [p.rule_type.rule_attribute, p])
+        priceList.price_list_rules.map((p) => [p.rule_type.rule_attribute, p])
      )

      await Promise.all(
        rules.map(async (rule_attribute) => {
          const rule = priceListRulesMap.get(rule_attribute)
+
          if (rule) {
            idsToDelete.push(rule.id)
          }
@@ -1469,9 +1433,7 @@ export default class PricingModuleService<

    return await this.baseRepository_.serialize<PricingTypes.PriceListDTO[]>(
      priceLists,
-      {
-        populate: true,
-      }
+      { populate: true }
    )
  }
 }
@@ -1,4 +1,4 @@
-import { Context, DAL } from "@medusajs/types"
+import { Context, DAL, PricingTypes } from "@medusajs/types"
 import {
  InjectTransactionManager,
  MedusaContext,
@@ -6,7 +6,6 @@ import {
  validateRuleAttributes,
 } from "@medusajs/utils"
 import { RuleType } from "@models"
-import { ServiceTypes } from "@types"

 type InjectedDependencies = {
  ruleTypeRepository: DAL.RepositoryService
@@ -26,17 +25,17 @@ export default class RuleTypeService<
  }

  create(
-    data: ServiceTypes.CreateRuleTypeDTO,
+    data: PricingTypes.CreateRuleTypeDTO,
    sharedContext: Context
  ): Promise<TEntity>
  create(
-    data: ServiceTypes.CreateRuleTypeDTO[],
+    data: PricingTypes.CreateRuleTypeDTO[],
    sharedContext: Context
  ): Promise<TEntity[]>

  @InjectTransactionManager("ruleTypeRepository_")
  async create(
-    data: ServiceTypes.CreateRuleTypeDTO | ServiceTypes.CreateRuleTypeDTO[],
+    data: PricingTypes.CreateRuleTypeDTO | PricingTypes.CreateRuleTypeDTO[],
    @MedusaContext() sharedContext: Context = {}
  ): Promise<TEntity | TEntity[]> {
    const data_ = Array.isArray(data) ? data : [data]
@@ -46,12 +45,12 @@ export default class RuleTypeService<

  // @ts-ignore
  update(
-    data: ServiceTypes.UpdateRuleTypeDTO[],
+    data: PricingTypes.UpdateRuleTypeDTO[],
    sharedContext: Context
  ): Promise<TEntity[]>
  // @ts-ignore
  update(
-    data: ServiceTypes.UpdateRuleTypeDTO,
+    data: PricingTypes.UpdateRuleTypeDTO,
    sharedContext: Context
  ): Promise<TEntity>

@@ -59,7 +58,7 @@ export default class RuleTypeService<
  // TODO: add support for selector? and then rm ts ignore
  // @ts-ignore
  async update(
-    data: ServiceTypes.UpdateRuleTypeDTO | ServiceTypes.UpdateRuleTypeDTO[],
+    data: PricingTypes.UpdateRuleTypeDTO | PricingTypes.UpdateRuleTypeDTO[],
    @MedusaContext() sharedContext: Context = {}
  ): Promise<TEntity | TEntity[]> {
    const data_ = Array.isArray(data) ? data : [data]