From cf3c9b13b5668bbf26d97d30636a345b9850600c Mon Sep 17 00:00:00 2001 From: Adrien de Peretti Date: Wed, 27 Mar 2024 18:51:17 +0100 Subject: [PATCH] Fix/pricing data manipulation (#6845) **What** - Fix returned data order - improve implentation - rm unnecessary promises and/or promise all - replace promise.all for promiseAll --- .changeset/cool-pigs-rush.md | 5 + .../src/services/__tests__/index.spec.ts | 7 +- .../pricing/src/services/pricing-module.ts | 660 +++++++++--------- 3 files changed, 330 insertions(+), 342 deletions(-) create mode 100644 .changeset/cool-pigs-rush.md diff --git a/.changeset/cool-pigs-rush.md b/.changeset/cool-pigs-rush.md new file mode 100644 index 0000000000..65766a7c76 --- /dev/null +++ b/.changeset/cool-pigs-rush.md @@ -0,0 +1,5 @@ +--- +"@medusajs/pricing": patch +--- + +Fix/pricing data manipulation diff --git a/packages/pricing/src/services/__tests__/index.spec.ts b/packages/pricing/src/services/__tests__/index.spec.ts index 1691dbec45..f2e589564e 100644 --- a/packages/pricing/src/services/__tests__/index.spec.ts +++ b/packages/pricing/src/services/__tests__/index.spec.ts @@ -1,6 +1 @@ -describe("Noop test", () => { - it("noop check", async () => { - expect(true).toBe(true) - }) - }) - \ No newline at end of file +it("noop", () => {}) diff --git a/packages/pricing/src/services/pricing-module.ts b/packages/pricing/src/services/pricing-module.ts index 3fcc4c9f2a..76720b96c1 100644 --- a/packages/pricing/src/services/pricing-module.ts +++ b/packages/pricing/src/services/pricing-module.ts @@ -21,10 +21,12 @@ import { groupBy, InjectManager, InjectTransactionManager, + isDefined, MedusaContext, MedusaError, ModulesSdkUtils, PriceListType, + promiseAll, removeNullish, } from "@medusajs/utils" @@ -39,11 +41,11 @@ import { RuleType, } from "@models" -import {PriceListService, RuleTypeService} from "@services" -import {validatePriceListDates} from "@utils" -import {entityNameToLinkableKeysMap, joinerConfig} from "../joiner-config" -import {PriceSetIdPrefix} from "../models/price-set"; -import {PriceListIdPrefix} from "../models/price-list"; +import { PriceListService, RuleTypeService } from "@services" +import { validatePriceListDates } from "@utils" +import { entityNameToLinkableKeysMap, joinerConfig } from "../joiner-config" +import { PriceSetIdPrefix } from "../models/price-set" +import { PriceListIdPrefix } from "../models/price-list" type InjectedDependencies = { baseRepository: DAL.RepositoryService @@ -247,6 +249,236 @@ export default class PricingModuleService< return Array.isArray(data) ? results : results[0] } + async addRules( + data: PricingTypes.AddRulesDTO, + sharedContext?: Context + ): Promise + + async addRules( + data: PricingTypes.AddRulesDTO[], + sharedContext?: Context + ): Promise + + @InjectManager("baseRepository_") + async addRules( + data: PricingTypes.AddRulesDTO | PricingTypes.AddRulesDTO[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + const inputs = Array.isArray(data) ? data : [data] + + const priceSets = await this.addRules_(inputs, sharedContext) + + const dbPriceSets = await this.list( + { id: priceSets.map(({ id }) => id) }, + { relations: ["rule_types"] } + ) + + const orderedPriceSets = priceSets.map((priceSet) => { + return dbPriceSets.find((p) => p.id === priceSet.id)! + }) + + return Array.isArray(data) ? orderedPriceSets : orderedPriceSets[0] + } + + async addPrices( + data: AddPricesDTO, + sharedContext?: Context + ): Promise + + async addPrices( + data: AddPricesDTO[], + sharedContext?: Context + ): Promise + + @InjectManager("baseRepository_") + async addPrices( + data: AddPricesDTO | AddPricesDTO[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + const input = Array.isArray(data) ? data : [data] + + await this.addPrices_(input, sharedContext) + + const dbPrices = await this.list( + { id: input.map((d) => d.priceSetId) }, + { relations: ["prices"] }, + sharedContext + ) + + const orderedPriceSets = input.map((inputItem) => { + return dbPrices.find((p) => p.id === inputItem.priceSetId)! + }) + + return Array.isArray(data) ? orderedPriceSets : orderedPriceSets[0] + } + + @InjectTransactionManager("baseRepository_") + async removeRules( + data: PricingTypes.RemovePriceSetRulesDTO[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + const priceSets = await this.priceSetService_.list( + { id: data.map((d) => d.id) }, + {}, + sharedContext + ) + + const priceSetIds = priceSets.map((ps) => ps.id) + const ruleTypes = await this.ruleTypeService_.list( + { + rule_attribute: data.map((d) => d.rules || []).flat(), + }, + { take: null }, + sharedContext + ) + + const ruleTypeIds = ruleTypes.map((rt) => rt.id) + const priceSetRuleTypes = await this.priceSetRuleTypeService_.list( + { 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"], take: null }, + sharedContext + ) + + await this.priceSetRuleTypeService_.delete( + priceSetRuleTypes.map((psrt) => psrt.id), + sharedContext + ) + + await this.priceService_.delete( + priceRules.map((pr) => pr.price.id), + sharedContext + ) + } + + @InjectTransactionManager("baseRepository_") + async update( + data: PricingTypes.UpdatePriceSetDTO[], + @MedusaContext() sharedContext: Context = {} + ) { + const priceSets = await this.priceSetService_.update(data, sharedContext) + + return await this.baseRepository_.serialize( + priceSets + ) + } + + @InjectManager("baseRepository_") + async createPriceLists( + data: PricingTypes.CreatePriceListDTO[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + const priceLists = await this.createPriceLists_(data, sharedContext) + + return await this.baseRepository_.serialize( + priceLists + ) + } + + @InjectTransactionManager("baseRepository_") + async updatePriceLists( + data: PricingTypes.UpdatePriceListDTO[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + const priceLists = await this.updatePriceLists_(data, sharedContext) + + return await this.baseRepository_.serialize( + priceLists + ) + } + + @InjectManager("baseRepository_") + async createPriceListRules( + data: PricingTypes.CreatePriceListRuleDTO[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + const priceLists = await this.createPriceListRules_(data, sharedContext) + + return await this.baseRepository_.serialize< + PricingTypes.PriceListRuleDTO[] + >(priceLists, { + populate: true, + }) + } + + @InjectTransactionManager("baseRepository_") + async createPriceListRules_( + data: PricingTypes.CreatePriceListRuleDTO[], + @MedusaContext() sharedContext: Context = {} + ) { + return await this.priceListRuleService_.create(data, sharedContext) + } + + @InjectTransactionManager("baseRepository_") + async updatePriceListRules( + data: PricingTypes.UpdatePriceListRuleDTO[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + const priceLists = await this.priceListRuleService_.update( + data, + sharedContext + ) + + return await this.baseRepository_.serialize< + PricingTypes.PriceListRuleDTO[] + >(priceLists, { + populate: true, + }) + } + + @InjectManager("baseRepository_") + async updatePriceListPrices( + data: PricingTypes.UpdatePriceListPricesDTO[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + return await this.updatePriceListPrices_(data, sharedContext) + } + + @InjectManager("baseRepository_") + async removePrices( + ids: string[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + await this.removePrices_(ids, sharedContext) + } + + @InjectManager("baseRepository_") + async addPriceListPrices( + data: PricingTypes.AddPriceListPricesDTO[], + @MedusaContext() sharedContext: Context = {} + ): Promise { + return await this.addPriceListPrices_(data, sharedContext) + } + + @InjectManager("baseRepository_") + async setPriceListRules( + data: PricingTypes.SetPriceListRulesDTO, + @MedusaContext() sharedContext: Context = {} + ): Promise { + const [priceList] = await this.setPriceListRules_([data], sharedContext) + + return await this.baseRepository_.serialize( + priceList + ) + } + + @InjectManager("baseRepository_") + async removePriceListRules( + data: PricingTypes.RemovePriceListRulesDTO, + @MedusaContext() sharedContext: Context = {} + ): Promise { + const [priceList] = await this.removePriceListRules_([data], sharedContext) + + return await this.baseRepository_.serialize( + priceList + ) + } + @InjectTransactionManager("baseRepository_") protected async create_( data: PricingTypes.CreatePriceSetDTO[], @@ -379,31 +611,6 @@ export default class PricingModuleService< return createdPriceSets } - async addRules( - data: PricingTypes.AddRulesDTO, - sharedContext?: Context - ): Promise - - async addRules( - data: PricingTypes.AddRulesDTO[], - sharedContext?: Context - ): Promise - - @InjectManager("baseRepository_") - async addRules( - data: PricingTypes.AddRulesDTO | PricingTypes.AddRulesDTO[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - const inputs = Array.isArray(data) ? data : [data] - - const priceSets = await this.addRules_(inputs, sharedContext) - - return await this.list( - { id: priceSets.map(({ id }) => id) }, - { relations: ["rule_types"] } - ) - } - @InjectTransactionManager("baseRepository_") protected async addRules_( inputs: PricingTypes.AddRulesDTO[], @@ -487,32 +694,6 @@ export default class PricingModuleService< return priceSets } - async addPrices( - data: AddPricesDTO, - sharedContext?: Context - ): Promise - - async addPrices( - data: AddPricesDTO[], - sharedContext?: Context - ): Promise - - @InjectManager("baseRepository_") - async addPrices( - data: AddPricesDTO | AddPricesDTO[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - const input = Array.isArray(data) ? data : [data] - - await this.addPrices_(input, sharedContext) - - return await this.list( - { id: input.map((d) => d.priceSetId) }, - { relations: ["prices"] }, - sharedContext - ) - } - @InjectTransactionManager("baseRepository_") protected async addPrices_( input: AddPricesDTO[], @@ -566,110 +747,25 @@ export default class PricingModuleService< prices.map((price) => { const numberOfRules = Object.entries(price?.rules ?? {}).length + const priceRules = Object.entries(price.rules ?? {}).map( + ([attribute, value]) => ({ + rule_type_id: ruleTypeMap.get(priceSetId)!.get(attribute)!.id, + price_set_id: priceSetId, + value, + }) + ) + return { ...price, price_set_id: priceSetId, title: "test", // TODO: accept title rules_count: numberOfRules, + priceRules, } }) ) - 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 price = createdPrices[rulesCursor] - rulesCursor++ - - return Object.entries(rules).map(([k, v]) => ({ - price_id: price.id, - rule_type_id: ruleTypeMap.get(priceSetId)!.get(k)!.id, - price_set_id: priceSetId, - value: v, - })) - }) - ) - - if (priceRulesBulkData.length > 0) { - await this.priceRuleService_.create(priceRulesBulkData, sharedContext) - } - } - - @InjectTransactionManager("baseRepository_") - async removeRules( - data: PricingTypes.RemovePriceSetRulesDTO[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - const priceSets = await this.priceSetService_.list( - { id: data.map((d) => d.id) }, - {}, - sharedContext - ) - - const priceSetIds = priceSets.map((ps) => ps.id) - const ruleTypes = await this.ruleTypeService_.list( - { - rule_attribute: data.map((d) => d.rules || []).flat(), - }, - { take: null }, - sharedContext - ) - - const ruleTypeIds = ruleTypes.map((rt) => rt.id) - const priceSetRuleTypes = await this.priceSetRuleTypeService_.list( - { 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"], take: null }, - sharedContext - ) - - await this.priceSetRuleTypeService_.delete( - priceSetRuleTypes.map((psrt) => psrt.id), - sharedContext - ) - - await this.priceService_.delete( - priceRules.map((pr) => pr.price.id), - sharedContext - ) - } - - @InjectTransactionManager("baseRepository_") - async update( - data: PricingTypes.UpdatePriceSetDTO[], - @MedusaContext() sharedContext: Context = {} - ) { - const priceSets = await this.priceSetService_.update(data, sharedContext) - - return await this.baseRepository_.serialize( - priceSets, - { populate: true } - ) - } - - @InjectManager("baseRepository_") - async createPriceLists( - data: PricingTypes.CreatePriceListDTO[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - const priceLists = await this.createPriceLists_(data, sharedContext) - - return await this.baseRepository_.serialize( - priceLists, - { populate: true } - ) + await this.priceService_.create(pricesToCreate, sharedContext) } @InjectTransactionManager("baseRepository_") @@ -732,7 +828,7 @@ export default class PricingModuleService< return { price_list_id: id, rule_type_id: ruleType.id, - price_list_rule_values: value.map((v) => ({ value: v })) + price_list_rule_values: value.map((v) => ({ value: v })), } } ) @@ -773,19 +869,6 @@ export default class PricingModuleService< ) } - @InjectTransactionManager("baseRepository_") - async updatePriceLists( - data: PricingTypes.UpdatePriceListDTO[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - const priceLists = await this.updatePriceLists_(data, sharedContext) - - return await this.baseRepository_.serialize( - priceLists, - { populate: true } - ) - } - @InjectTransactionManager("baseRepository_") protected async updatePriceLists_( data: PricingTypes.UpdatePriceListDTO[], @@ -891,53 +974,6 @@ export default class PricingModuleService< return updatedPriceLists } - @InjectManager("baseRepository_") - async createPriceListRules( - data: PricingTypes.CreatePriceListRuleDTO[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - const priceLists = await this.createPriceListRules_(data, sharedContext) - - return await this.baseRepository_.serialize< - PricingTypes.PriceListRuleDTO[] - >(priceLists, { - populate: true, - }) - } - - @InjectTransactionManager("baseRepository_") - async createPriceListRules_( - data: PricingTypes.CreatePriceListRuleDTO[], - @MedusaContext() sharedContext: Context = {} - ) { - return await this.priceListRuleService_.create(data, sharedContext) - } - - @InjectTransactionManager("baseRepository_") - async updatePriceListRules( - data: PricingTypes.UpdatePriceListRuleDTO[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - const priceLists = await this.priceListRuleService_.update( - data, - sharedContext - ) - - return await this.baseRepository_.serialize< - PricingTypes.PriceListRuleDTO[] - >(priceLists, { - populate: true, - }) - } - - @InjectManager("baseRepository_") - async updatePriceListPrices( - data: PricingTypes.UpdatePriceListPricesDTO[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - return await this.updatePriceListPrices_(data, sharedContext) - } - @InjectTransactionManager("baseRepository_") protected async updatePriceListPrices_( data: PricingTypes.UpdatePriceListPricesDTO[], @@ -1046,36 +1082,34 @@ export default class PricingModuleService< const priceRuleIdsToDelete: string[] = [] const priceRulesToCreate: PricingTypes.CreatePriceRuleDTO[] = [] - const pricesToUpdate: (PricingTypes.UpdatePriceDTO & { - rules_count: number - })[] = [] + const pricesToUpdate: Partial[] = [] 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") { + if (!isDefined(rules)) { continue } pricesToUpdate.push({ ...rest, rules_count: Object.keys(rules).length, - }) + price_rules: Object.entries(rules).map( + ([ruleAttribute, ruleValue]) => ({ + price_set_id, + rule_type_id: ruleTypeMap.get(ruleAttribute)!.id, + value: ruleValue, + price_id: price.id, + }) + ), + } as unknown as TPrice) priceRuleIdsToDelete.push(...priceRules.map((pr) => pr.id)) - priceRulesToCreate.push( - ...Object.entries(rules).map(([ruleAttribute, ruleValue]) => ({ - price_set_id, - rule_type_id: ruleTypeMap.get(ruleAttribute)!.id, - value: ruleValue, - price_id: price.id, - })) - ) } - await Promise.all([ + await promiseAll([ this.priceRuleService_.delete(priceRuleIdsToDelete), this.priceRuleService_.create(priceRulesToCreate), this.priceService_.update(pricesToUpdate), @@ -1085,14 +1119,6 @@ export default class PricingModuleService< return priceLists } - @InjectManager("baseRepository_") - async removePrices( - ids: string[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - await this.removePrices_(ids, sharedContext) - } - @InjectTransactionManager("baseRepository_") protected async removePrices_( ids: string[], @@ -1101,14 +1127,6 @@ export default class PricingModuleService< await this.priceService_.delete(ids, sharedContext) } - @InjectManager("baseRepository_") - async addPriceListPrices( - data: PricingTypes.AddPriceListPricesDTO[], - @MedusaContext() sharedContext: Context = {} - ): Promise { - return await this.addPriceListPrices_(data, sharedContext) - } - @InjectTransactionManager("baseRepository_") protected async addPriceListPrices_( data: PricingTypes.AddPriceListPricesDTO[], @@ -1191,6 +1209,8 @@ export default class PricingModuleService< const priceListMap = new Map(priceLists.map((p) => [p.id, p])) + const pricesToCreate: Partial[] = [] + for (const { price_list_id: priceListId, prices } of data) { const priceList = priceListMap.get(priceListId) @@ -1201,59 +1221,45 @@ export default class PricingModuleService< ) } - await Promise.all( - prices.map(async (priceData) => { - const priceRules = priceData.rules || {} - const noOfRules = Object.keys(priceRules).length + const priceListPricesToCreate = prices.map((priceData) => { + const priceRules = priceData.rules || {} + const noOfRules = Object.keys(priceRules).length - const [price] = await this.priceService_.create( - [ - { - ...priceData, - price_set_id: priceData.price_set_id, - title: "test", - price_list_id: priceList.id, - rules_count: noOfRules, - }, - ], - sharedContext - ) + const priceRulesToCreate = Object.entries(priceRules).map( + ([ruleAttribute, ruleValue]) => { + return { + price_set_id: priceData.price_set_id, + rule_type_id: ruleTypeMap.get(ruleAttribute)!?.id, + value: ruleValue, + } + } + ) - await this.priceRuleService_.create( - Object.entries(priceRules).map(([ruleAttribute, ruleValue]) => { - return { - price_set_id: priceData.price_set_id, - rule_type_id: ruleTypeMap.get(ruleAttribute)!?.id, - value: ruleValue, - price_id: price.id, - } - }), - sharedContext - ) + return { + ...priceData, + price_set_id: priceData.price_set_id, + title: "test", + price_list_id: priceList.id, + rules_count: noOfRules, + price_rules: priceRulesToCreate, + } as unknown as TPrice + }) - return price - }) - ) + pricesToCreate.push(...priceListPricesToCreate) } + await this.priceService_.create(pricesToCreate, sharedContext) + return priceLists } - @InjectManager("baseRepository_") - async setPriceListRules( - data: PricingTypes.SetPriceListRulesDTO, - @MedusaContext() sharedContext: Context = {} - ): Promise { - const [priceList] = await this.setPriceListRules_([data], sharedContext) - - return priceList - } - @InjectTransactionManager("baseRepository_") protected async setPriceListRules_( data: PricingTypes.SetPriceListRulesDTO[], sharedContext: Context = {} - ): Promise { + ): Promise { + // TODO: re think this method + const priceLists = await this.priceListService_.list( { id: data.map((d) => d.price_list_id) }, { relations: ["price_list_rules", "price_list_rules.rule_type"] }, @@ -1267,6 +1273,7 @@ export default class PricingModuleService< ) const ruleTypeMap = new Map(ruleTypes.map((rt) => [rt.rule_attribute, rt])) + const ruleIdsToUpdate: string[] = [] const rulesToCreate: CreatePriceListRuleDTO[] = [] const priceRuleValues = new Map>() @@ -1286,38 +1293,37 @@ export default class PricingModuleService< ) const priceListRuleValues = new Map() - await Promise.all( - Object.entries(rules).map(async ([key, value]) => { - const ruleType = ruleTypeMap.get(key) - if (!ruleType) { - throw new MedusaError( - MedusaError.Types.INVALID_DATA, - `Rule type with attribute: ${key} not found` - ) - } - const rule = priceListRulesMap.get(key) - - priceListRuleValues.set( - ruleType.id, - Array.isArray(value) ? value : [value] + Object.entries(rules).map(async ([key, value]) => { + const ruleType = ruleTypeMap.get(key) + if (!ruleType) { + throw new MedusaError( + MedusaError.Types.INVALID_DATA, + `Rule type with attribute: ${key} not found` ) + } - if (!rule) { - rulesToCreate.push({ - rule_type_id: ruleType.id, - price_list_id: priceListId, - }) - } else { - ruleIdsToUpdate.push(rule.id) - } - }) - ) + const rule = priceListRulesMap.get(key) + + priceListRuleValues.set( + ruleType.id, + Array.isArray(value) ? value : [value] + ) + + if (!rule) { + rulesToCreate.push({ + rule_type_id: ruleType.id, + price_list_id: priceListId, + }) + } else { + ruleIdsToUpdate.push(rule.id) + } + }) priceRuleValues.set(priceListId, priceListRuleValues) } - const [createdRules, priceListValuesToDelete] = await Promise.all([ + const [createdRules, priceListValuesToDelete] = await promiseAll([ this.priceListRuleService_.create(rulesToCreate), this.priceListRuleValueService_.list( { price_list_rule_id: ruleIdsToUpdate }, @@ -1348,7 +1354,7 @@ export default class PricingModuleService< }) } - await Promise.all([ + await promiseAll([ this.priceListRuleValueService_.delete( priceListValuesToDelete.map((p) => p.id), sharedContext @@ -1359,27 +1365,14 @@ export default class PricingModuleService< ), ]) - return await this.baseRepository_.serialize( - priceLists, - { populate: true } - ) - } - - @InjectManager("baseRepository_") - async removePriceListRules( - data: PricingTypes.RemovePriceListRulesDTO, - @MedusaContext() sharedContext: Context = {} - ): Promise { - const [priceList] = await this.removePriceListRules_([data], sharedContext) - - return priceList + return priceLists } @InjectTransactionManager("baseRepository_") protected async removePriceListRules_( data: PricingTypes.RemovePriceListRulesDTO[], sharedContext: Context = {} - ): Promise { + ): Promise { const priceLists = await this.priceListService_.list( { id: data.map((d) => d.price_list_id) }, { relations: ["price_list_rules", "price_list_rules.rule_type"] }, @@ -1403,22 +1396,17 @@ export default class PricingModuleService< 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) + rules.map(async (rule_attribute) => { + const rule = priceListRulesMap.get(rule_attribute) - if (rule) { - idsToDelete.push(rule.id) - } - }) - ) + if (rule) { + idsToDelete.push(rule.id) + } + }) } await this.priceListRuleService_.delete(idsToDelete) - return await this.baseRepository_.serialize( - priceLists, - { populate: true } - ) + return priceLists } }