0f79f22ebc
* update package * fix(pricing): update price list prices perf issues * Create lemon-clocks-sing.md * fix(pricing): update price list prices perf issues * fix(pricing): update price list prices perf issues * update package * update package * improvements * remove unnecessary comments --------- Co-authored-by: Oli Juhl <59018053+olivermrbl@users.noreply.github.com>
1923 lines
55 KiB
TypeScript
1923 lines
55 KiB
TypeScript
import {
|
|
AddPricesDTO,
|
|
Context,
|
|
CreatePricePreferenceDTO,
|
|
CreatePriceRuleDTO,
|
|
CreatePricesDTO,
|
|
CreatePriceSetDTO,
|
|
DAL,
|
|
FindConfig,
|
|
InferEntityType,
|
|
InternalModuleDeclaration,
|
|
MedusaContainer,
|
|
ModuleJoinerConfig,
|
|
ModulesSdkTypes,
|
|
PricePreferenceDTO,
|
|
PriceSetDTO,
|
|
PricingContext,
|
|
PricingFilters,
|
|
PricingRepositoryService,
|
|
PricingRuleOperatorValues,
|
|
PricingTypes,
|
|
UpsertPricePreferenceDTO,
|
|
UpsertPriceSetDTO,
|
|
} from "@medusajs/framework/types"
|
|
import {
|
|
arrayDifference,
|
|
deduplicate,
|
|
EmitEvents,
|
|
GetIsoStringFromDate,
|
|
groupBy,
|
|
InjectManager,
|
|
InjectTransactionManager,
|
|
isDefined,
|
|
isPresent,
|
|
isString,
|
|
MathBN,
|
|
MedusaContext,
|
|
MedusaError,
|
|
ModulesSdkUtils,
|
|
PriceListType,
|
|
PricingRuleOperator,
|
|
promiseAll,
|
|
removeNullish,
|
|
} from "@medusajs/framework/utils"
|
|
|
|
import {
|
|
Price,
|
|
PriceList,
|
|
PriceListRule,
|
|
PricePreference,
|
|
PriceRule,
|
|
PriceSet,
|
|
} from "@models"
|
|
|
|
import { Collection } from "@medusajs/framework/mikro-orm/core"
|
|
import { ServiceTypes } from "@types"
|
|
import { validatePriceListDates } from "@utils"
|
|
import { joinerConfig } from "../joiner-config"
|
|
|
|
type InjectedDependencies = {
|
|
baseRepository: DAL.RepositoryService
|
|
pricingRepository: PricingRepositoryService
|
|
priceSetService: ModulesSdkTypes.IMedusaInternalService<any>
|
|
priceRuleService: ModulesSdkTypes.IMedusaInternalService<any>
|
|
priceService: ModulesSdkTypes.IMedusaInternalService<any>
|
|
priceListService: ModulesSdkTypes.IMedusaInternalService<any>
|
|
pricePreferenceService: ModulesSdkTypes.IMedusaInternalService<any>
|
|
priceListRuleService: ModulesSdkTypes.IMedusaInternalService<any>
|
|
}
|
|
|
|
const generateMethodForModels = {
|
|
PriceSet,
|
|
PriceList,
|
|
PriceListRule,
|
|
PriceRule,
|
|
Price,
|
|
PricePreference,
|
|
}
|
|
|
|
const BaseClass = ModulesSdkUtils.MedusaService<{
|
|
PriceSet: { dto: PricingTypes.PriceSetDTO }
|
|
Price: { dto: PricingTypes.PriceDTO }
|
|
PriceRule: {
|
|
dto: PricingTypes.PriceRuleDTO
|
|
create: PricingTypes.CreatePriceRuleDTO
|
|
update: PricingTypes.UpdatePriceRuleDTO
|
|
}
|
|
PriceList: { dto: PricingTypes.PriceListDTO }
|
|
PriceListRule: { dto: PricingTypes.PriceListRuleDTO }
|
|
// PricePreference: { dto: PricingTypes.PricePreferenceDTO }
|
|
PricePreference: { dto: any }
|
|
}>(generateMethodForModels)
|
|
|
|
export default class PricingModuleService
|
|
extends BaseClass
|
|
implements PricingTypes.IPricingModuleService
|
|
{
|
|
protected readonly container_: MedusaContainer
|
|
protected baseRepository_: DAL.RepositoryService
|
|
protected readonly pricingRepository_: PricingRepositoryService & {
|
|
clearAvailableAttributes?: () => Promise<void>
|
|
}
|
|
protected readonly priceSetService_: ModulesSdkTypes.IMedusaInternalService<
|
|
InferEntityType<typeof PriceSet>
|
|
>
|
|
protected readonly priceRuleService_: ModulesSdkTypes.IMedusaInternalService<
|
|
InferEntityType<typeof PriceRule>
|
|
>
|
|
protected readonly priceService_: ModulesSdkTypes.IMedusaInternalService<
|
|
InferEntityType<typeof Price>
|
|
>
|
|
protected readonly priceListService_: ModulesSdkTypes.IMedusaInternalService<
|
|
InferEntityType<typeof PriceList>
|
|
>
|
|
protected readonly priceListRuleService_: ModulesSdkTypes.IMedusaInternalService<
|
|
InferEntityType<typeof PriceListRule>
|
|
>
|
|
protected readonly pricePreferenceService_: ModulesSdkTypes.IMedusaInternalService<
|
|
InferEntityType<typeof PricePreference>
|
|
>
|
|
|
|
constructor(
|
|
{
|
|
baseRepository,
|
|
pricingRepository,
|
|
priceSetService,
|
|
priceRuleService,
|
|
priceService,
|
|
pricePreferenceService,
|
|
priceListService,
|
|
priceListRuleService,
|
|
}: InjectedDependencies,
|
|
protected readonly moduleDeclaration: InternalModuleDeclaration
|
|
) {
|
|
// @ts-ignore
|
|
super(...arguments)
|
|
|
|
this.container_ = arguments[0]
|
|
this.baseRepository_ = baseRepository
|
|
this.pricingRepository_ = pricingRepository
|
|
this.priceSetService_ = priceSetService
|
|
this.priceRuleService_ = priceRuleService
|
|
this.priceService_ = priceService
|
|
this.pricePreferenceService_ = pricePreferenceService
|
|
this.priceListService_ = priceListService
|
|
this.priceListRuleService_ = priceListRuleService
|
|
}
|
|
|
|
__joinerConfig(): ModuleJoinerConfig {
|
|
return joinerConfig
|
|
}
|
|
|
|
private setupCalculatedPriceConfig_(
|
|
filters,
|
|
config
|
|
): PricingContext["context"] | undefined {
|
|
const fieldIdx = config.relations?.indexOf("calculated_price")
|
|
const shouldCalculatePrice = fieldIdx > -1
|
|
|
|
const pricingContext = filters.context ?? {}
|
|
|
|
delete filters.context
|
|
if (!shouldCalculatePrice) {
|
|
return
|
|
}
|
|
|
|
// cleanup virtual field "calculated_price"
|
|
config.relations?.splice(fieldIdx, 1)
|
|
|
|
return pricingContext
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
@EmitEvents()
|
|
// @ts-expect-error
|
|
async createPriceRules(
|
|
...args: Parameters<PricingTypes.IPricingModuleService["createPriceRules"]>
|
|
): Promise<PricingTypes.PriceRuleDTO | PricingTypes.PriceRuleDTO[]> {
|
|
try {
|
|
return await super.createPriceRules(...args)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
@EmitEvents()
|
|
// @ts-expect-error
|
|
async updatePriceRules(
|
|
...args: Parameters<PricingTypes.IPricingModuleService["updatePriceRules"]>
|
|
): Promise<PricingTypes.PriceRuleDTO | PricingTypes.PriceRuleDTO[]> {
|
|
try {
|
|
return await super.updatePriceRules(...args)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
@EmitEvents()
|
|
// @ts-expect-error
|
|
async createPriceListRules(
|
|
...args: any[]
|
|
): Promise<PricingTypes.PriceListRuleDTO | PricingTypes.PriceListRuleDTO[]> {
|
|
try {
|
|
// @ts-ignore
|
|
return await super.createPriceListRules(...args)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
@EmitEvents()
|
|
// @ts-expect-error
|
|
async updatePriceListRules(
|
|
...args: any[]
|
|
): Promise<PricingTypes.PriceListRuleDTO | PricingTypes.PriceListRuleDTO[]> {
|
|
try {
|
|
// @ts-ignore
|
|
return await super.updatePriceListRules(...args)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectManager()
|
|
// @ts-expect-error
|
|
async retrievePriceSet(
|
|
id: string,
|
|
config?: FindConfig<PriceSetDTO> | undefined,
|
|
sharedContext?: Context | undefined
|
|
): Promise<PriceSetDTO> {
|
|
const priceSet = await this.priceSetService_.retrieve(
|
|
id,
|
|
this.normalizePriceSetConfig(config),
|
|
sharedContext
|
|
)
|
|
|
|
return await this.baseRepository_.serialize<PriceSetDTO>(priceSet)
|
|
}
|
|
|
|
@InjectManager()
|
|
// @ts-expect-error
|
|
async listPriceSets(
|
|
filters: PricingTypes.FilterablePriceSetProps = {},
|
|
config: FindConfig<PricingTypes.PriceSetDTO> = {},
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PriceSetDTO[]> {
|
|
const normalizedConfig = this.normalizePriceSetConfig(config)
|
|
const pricingContext = this.setupCalculatedPriceConfig_(
|
|
filters,
|
|
normalizedConfig
|
|
)
|
|
|
|
const priceSets = await super.listPriceSets(
|
|
filters,
|
|
normalizedConfig,
|
|
sharedContext
|
|
)
|
|
if (!pricingContext || !priceSets.length) {
|
|
return priceSets
|
|
}
|
|
|
|
const calculatedPrices = await this.calculatePrices(
|
|
{ id: priceSets.map((p) => p.id) },
|
|
{ context: pricingContext },
|
|
sharedContext
|
|
)
|
|
|
|
const calculatedPricesMap = new Map()
|
|
for (const calculatedPrice of calculatedPrices) {
|
|
calculatedPricesMap.set(calculatedPrice.id, calculatedPrice)
|
|
}
|
|
|
|
for (const priceSet of priceSets) {
|
|
const calculatedPrice = calculatedPricesMap.get(priceSet.id)
|
|
priceSet.calculated_price = calculatedPrice ?? null
|
|
}
|
|
|
|
return await this.baseRepository_.serialize<PriceSetDTO[]>(priceSets)
|
|
}
|
|
|
|
@InjectManager()
|
|
// @ts-expect-error
|
|
async listAndCountPriceSets(
|
|
filters: PricingTypes.FilterablePriceSetProps = {},
|
|
config: FindConfig<PricingTypes.PriceSetDTO> = {},
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<[PriceSetDTO[], number]> {
|
|
const normalizedConfig = this.normalizePriceSetConfig(config)
|
|
const pricingContext = this.setupCalculatedPriceConfig_(
|
|
filters,
|
|
normalizedConfig
|
|
)
|
|
|
|
const [priceSets, count] = await super.listAndCountPriceSets(
|
|
filters,
|
|
normalizedConfig,
|
|
sharedContext
|
|
)
|
|
if (!pricingContext || !priceSets.length) {
|
|
const serializedPriceSets = await this.baseRepository_.serialize<
|
|
PriceSetDTO[]
|
|
>(priceSets)
|
|
return [serializedPriceSets, count]
|
|
}
|
|
|
|
const calculatedPrices = await this.calculatePrices(
|
|
{ id: priceSets.map((p) => p.id) },
|
|
{ context: pricingContext },
|
|
sharedContext
|
|
)
|
|
|
|
const calculatedPricesMap = new Map()
|
|
for (const calculatedPrice of calculatedPrices) {
|
|
calculatedPricesMap.set(calculatedPrice.id, calculatedPrice)
|
|
}
|
|
|
|
for (const priceSet of priceSets) {
|
|
const calculatedPrice = calculatedPricesMap.get(priceSet.id)
|
|
priceSet.calculated_price = calculatedPrice ?? null
|
|
}
|
|
|
|
const serializedPriceSets = await this.baseRepository_.serialize<
|
|
PriceSetDTO[]
|
|
>(priceSets)
|
|
|
|
return [serializedPriceSets, count]
|
|
}
|
|
|
|
@InjectManager()
|
|
// @ts-expect-error
|
|
async listPriceRules(
|
|
filters: PricingTypes.FilterablePriceRuleProps,
|
|
config: FindConfig<PricingTypes.PriceRuleDTO> = {},
|
|
sharedContext?: Context
|
|
): Promise<PricingTypes.PriceRuleDTO[]> {
|
|
const priceRules = await this.listPriceRules_(
|
|
filters,
|
|
config,
|
|
sharedContext
|
|
)
|
|
|
|
return await this.baseRepository_.serialize<PricingTypes.PriceRuleDTO[]>(
|
|
priceRules
|
|
)
|
|
}
|
|
|
|
protected async listPriceRules_(
|
|
filters: PricingTypes.FilterablePriceRuleProps,
|
|
config: FindConfig<PricingTypes.PriceRuleDTO> = {},
|
|
sharedContext?: Context
|
|
): Promise<InferEntityType<typeof PriceRule>[]> {
|
|
return await this.priceRuleService_.list(filters, config, sharedContext)
|
|
}
|
|
|
|
@InjectManager()
|
|
// @ts-expect-error
|
|
async listPricePreferences(
|
|
filters: PricingTypes.FilterablePricePreferenceProps,
|
|
config: FindConfig<PricingTypes.PricePreferenceDTO> = {},
|
|
sharedContext?: Context
|
|
): Promise<PricingTypes.PricePreferenceDTO[]> {
|
|
const pricePreferences = await this.listPricePreferences_(
|
|
filters,
|
|
config,
|
|
sharedContext
|
|
)
|
|
|
|
return await this.baseRepository_.serialize<
|
|
PricingTypes.PricePreferenceDTO[]
|
|
>(pricePreferences)
|
|
}
|
|
|
|
protected async listPricePreferences_(
|
|
filters: PricingTypes.FilterablePricePreferenceProps,
|
|
config: FindConfig<PricingTypes.PricePreferenceDTO> = {},
|
|
sharedContext?: Context
|
|
): Promise<InferEntityType<typeof PricePreference>[]> {
|
|
return await this.pricePreferenceService_.list(
|
|
filters,
|
|
config,
|
|
sharedContext
|
|
)
|
|
}
|
|
|
|
@InjectManager()
|
|
async calculatePrices(
|
|
pricingFilters: PricingFilters,
|
|
pricingContext: PricingContext = { context: {} },
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricingTypes.CalculatedPriceSet[]> {
|
|
const results = await this.pricingRepository_.calculatePrices(
|
|
pricingFilters,
|
|
pricingContext,
|
|
sharedContext
|
|
)
|
|
|
|
const pricesSetPricesMap = groupBy(results, "price_set_id")
|
|
const priceIds: string[] = []
|
|
pricesSetPricesMap.forEach(
|
|
(prices: PricingTypes.CalculatedPriceSetDTO[], key) => {
|
|
const priceListPrice = prices.find((p) => p.price_list_id)
|
|
const defaultPrice = prices?.find((p) => !p.price_list_id)
|
|
if (!prices.length || (!priceListPrice && !defaultPrice)) {
|
|
pricesSetPricesMap.delete(key)
|
|
return
|
|
}
|
|
|
|
let calculatedPrice: PricingTypes.CalculatedPriceSetDTO | undefined =
|
|
defaultPrice
|
|
let originalPrice: PricingTypes.CalculatedPriceSetDTO | undefined =
|
|
defaultPrice
|
|
|
|
/**
|
|
* When deciding which price to use we follow the following logic:
|
|
* - If the price list is of type OVERRIDE, we always use the price list price.
|
|
* - If there are multiple price list prices of type OVERRIDE, we use the one with the lowest amount.
|
|
* - If the price list is of type SALE, we use the lowest price between the price list price and the default price
|
|
*/
|
|
if (priceListPrice) {
|
|
switch (priceListPrice.price_list_type) {
|
|
case PriceListType.OVERRIDE:
|
|
calculatedPrice = priceListPrice
|
|
originalPrice = priceListPrice
|
|
break
|
|
case PriceListType.SALE: {
|
|
let lowestPrice = priceListPrice
|
|
|
|
if (defaultPrice?.amount && priceListPrice.amount) {
|
|
lowestPrice = MathBN.lte(
|
|
priceListPrice.amount,
|
|
defaultPrice.amount
|
|
)
|
|
? priceListPrice
|
|
: defaultPrice
|
|
}
|
|
|
|
calculatedPrice = lowestPrice
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
pricesSetPricesMap.set(key, { calculatedPrice, originalPrice })
|
|
priceIds.push(
|
|
...(deduplicate(
|
|
[calculatedPrice?.id, originalPrice?.id].filter(Boolean)
|
|
) as string[])
|
|
)
|
|
}
|
|
)
|
|
|
|
// We use the price rules to get the right preferences for the price
|
|
const priceRulesForPrices = await this.listPriceRules(
|
|
{ price_id: priceIds },
|
|
{},
|
|
sharedContext
|
|
)
|
|
|
|
const priceRulesPriceMap = groupBy(priceRulesForPrices, "price_id")
|
|
|
|
// Note: For now the preferences are intentionally kept very simple and explicit - they use either the region or currency,
|
|
// so we hard-code those as the possible filters here. This can be made more flexible if needed later on.
|
|
const preferenceContext = Object.entries(
|
|
pricingContext.context ?? {}
|
|
).filter(([key, val]) => {
|
|
return key === "region_id" || key === "currency_code"
|
|
})
|
|
let pricingPreferences: InferEntityType<typeof PricePreference>[] = []
|
|
if (preferenceContext.length) {
|
|
const preferenceFilters = preferenceContext.length
|
|
? {
|
|
$or: preferenceContext.map(([key, val]) => ({
|
|
attribute: key,
|
|
value: val,
|
|
})),
|
|
}
|
|
: {}
|
|
pricingPreferences = await this.listPricePreferences_(
|
|
preferenceFilters as PricingTypes.FilterablePricePreferenceProps,
|
|
{},
|
|
sharedContext
|
|
)
|
|
}
|
|
|
|
const calculatedPrices: PricingTypes.CalculatedPriceSet[] = []
|
|
|
|
for (const priceSetId of pricingFilters.id) {
|
|
const prices = pricesSetPricesMap.get(priceSetId)
|
|
if (!prices) {
|
|
continue
|
|
}
|
|
|
|
const {
|
|
calculatedPrice,
|
|
originalPrice,
|
|
}: {
|
|
calculatedPrice: PricingTypes.CalculatedPriceSetDTO
|
|
originalPrice: PricingTypes.CalculatedPriceSetDTO | undefined
|
|
} = prices
|
|
|
|
const calculatedPrice_: PricingTypes.CalculatedPriceSet = {
|
|
id: priceSetId,
|
|
is_calculated_price_price_list: !!calculatedPrice?.price_list_id,
|
|
is_calculated_price_tax_inclusive: isTaxInclusive(
|
|
priceRulesPriceMap.get(calculatedPrice.id),
|
|
pricingPreferences,
|
|
calculatedPrice.currency_code!,
|
|
pricingContext.context?.region_id as string
|
|
),
|
|
calculated_amount: isPresent(calculatedPrice?.amount)
|
|
? parseFloat(calculatedPrice?.amount as string)
|
|
: null,
|
|
raw_calculated_amount: calculatedPrice?.raw_amount || null,
|
|
|
|
is_original_price_price_list: !!originalPrice?.price_list_id,
|
|
is_original_price_tax_inclusive: originalPrice?.id
|
|
? isTaxInclusive(
|
|
priceRulesPriceMap.get(originalPrice.id),
|
|
pricingPreferences,
|
|
originalPrice.currency_code || calculatedPrice.currency_code!,
|
|
pricingContext.context?.region_id as string
|
|
)
|
|
: false,
|
|
original_amount: isPresent(originalPrice?.amount)
|
|
? parseFloat(originalPrice?.amount as string)
|
|
: null,
|
|
raw_original_amount: originalPrice?.raw_amount || null,
|
|
|
|
currency_code: calculatedPrice?.currency_code || null,
|
|
|
|
calculated_price: {
|
|
id: calculatedPrice?.id || null,
|
|
price_list_id: calculatedPrice?.price_list_id || null,
|
|
price_list_type: calculatedPrice?.price_list_type || null,
|
|
min_quantity: parseInt(calculatedPrice?.min_quantity || "") || null,
|
|
max_quantity: parseInt(calculatedPrice?.max_quantity || "") || null,
|
|
},
|
|
|
|
original_price: {
|
|
id: originalPrice?.id || null,
|
|
price_list_id: originalPrice?.price_list_id || null,
|
|
price_list_type: originalPrice?.price_list_type || null,
|
|
min_quantity: parseInt(originalPrice?.min_quantity || "") || null,
|
|
max_quantity: parseInt(originalPrice?.max_quantity || "") || null,
|
|
},
|
|
}
|
|
|
|
calculatedPrices.push(calculatedPrice_)
|
|
}
|
|
|
|
return calculatedPrices
|
|
}
|
|
|
|
// @ts-expect-error
|
|
async createPriceSets(
|
|
data: PricingTypes.CreatePriceSetDTO,
|
|
sharedContext?: Context
|
|
): Promise<PriceSetDTO>
|
|
|
|
// @ts-expect-error
|
|
async createPriceSets(
|
|
data: PricingTypes.CreatePriceSetDTO[],
|
|
sharedContext?: Context
|
|
): Promise<PriceSetDTO[]>
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
// @ts-expect-error
|
|
async createPriceSets(
|
|
data: PricingTypes.CreatePriceSetDTO | PricingTypes.CreatePriceSetDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PriceSetDTO | PriceSetDTO[]> {
|
|
const input = Array.isArray(data) ? data : [data]
|
|
const priceSets = await this.createPriceSets_(input, sharedContext)
|
|
|
|
// TODO: Remove the need to refetch the data here
|
|
const dbPriceSets = await this.listPriceSets(
|
|
{ id: priceSets.map((p) => p.id) },
|
|
this.normalizePriceSetConfig({
|
|
relations: ["prices", "prices.price_rules"],
|
|
}),
|
|
sharedContext
|
|
)
|
|
|
|
// 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)!
|
|
})
|
|
|
|
try {
|
|
return await this.baseRepository_.serialize<PriceSetDTO[] | PriceSetDTO>(
|
|
Array.isArray(data) ? results : results[0]
|
|
)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
async upsertPriceSets(
|
|
data: UpsertPriceSetDTO[],
|
|
sharedContext?: Context
|
|
): Promise<PriceSetDTO[]>
|
|
async upsertPriceSets(
|
|
data: UpsertPriceSetDTO,
|
|
sharedContext?: Context
|
|
): Promise<PriceSetDTO>
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
async upsertPriceSets(
|
|
data: UpsertPriceSetDTO | UpsertPriceSetDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PriceSetDTO | PriceSetDTO[]> {
|
|
const result = await this.upsertPriceSets_(data, sharedContext)
|
|
|
|
try {
|
|
return await this.baseRepository_.serialize<PriceSetDTO[] | PriceSetDTO>(
|
|
Array.isArray(data) ? result : result[0]
|
|
)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async upsertPriceSets_(
|
|
data: UpsertPriceSetDTO | UpsertPriceSetDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<InferEntityType<typeof PriceSet>[]> {
|
|
const input = Array.isArray(data) ? data : [data]
|
|
|
|
const forUpdate = input.filter(
|
|
(priceSet): priceSet is ServiceTypes.UpdatePriceSetInput => !!priceSet.id
|
|
)
|
|
const forCreate = input.filter(
|
|
(priceSet): priceSet is CreatePriceSetDTO => !priceSet.id
|
|
)
|
|
|
|
const operations: Promise<InferEntityType<typeof PriceSet>[]>[] = []
|
|
|
|
if (forCreate.length) {
|
|
operations.push(this.createPriceSets_(forCreate, sharedContext))
|
|
}
|
|
if (forUpdate.length) {
|
|
operations.push(this.updatePriceSets_(forUpdate, sharedContext))
|
|
}
|
|
|
|
const result = (await promiseAll(operations)).flat()
|
|
|
|
return result
|
|
}
|
|
|
|
// @ts-expect-error
|
|
async updatePriceSets(
|
|
id: string,
|
|
data: PricingTypes.UpdatePriceSetDTO,
|
|
sharedContext?: Context
|
|
): Promise<PriceSetDTO>
|
|
// @ts-expect-error
|
|
async updatePriceSets(
|
|
selector: PricingTypes.FilterablePriceSetProps,
|
|
data: PricingTypes.UpdatePriceSetDTO,
|
|
sharedContext?: Context
|
|
): Promise<PriceSetDTO[]>
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
// @ts-expect-error
|
|
async updatePriceSets(
|
|
idOrSelector: string | PricingTypes.FilterablePriceSetProps,
|
|
data: PricingTypes.UpdatePriceSetDTO,
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PriceSetDTO | PriceSetDTO[]> {
|
|
let normalizedInput: ServiceTypes.UpdatePriceSetInput[] = []
|
|
if (isString(idOrSelector)) {
|
|
// Check if the ID exists, it will throw if not.
|
|
await this.priceSetService_.retrieve(idOrSelector, {}, sharedContext)
|
|
normalizedInput = [{ id: idOrSelector, ...data }]
|
|
} else {
|
|
const priceSets = await this.priceSetService_.list(
|
|
idOrSelector,
|
|
{},
|
|
sharedContext
|
|
)
|
|
|
|
normalizedInput = priceSets.map((priceSet) => ({
|
|
id: priceSet.id,
|
|
...data,
|
|
}))
|
|
}
|
|
|
|
const updateResult = await this.updatePriceSets_(
|
|
normalizedInput,
|
|
sharedContext
|
|
)
|
|
|
|
const serializedUpdateResult = await this.baseRepository_.serialize<
|
|
PriceSetDTO[] | PriceSetDTO
|
|
>(isString(idOrSelector) ? updateResult[0] : updateResult)
|
|
|
|
try {
|
|
return serializedUpdateResult
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async updatePriceSets_(
|
|
data: ServiceTypes.UpdatePriceSetInput[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<InferEntityType<typeof PriceSet>[]> {
|
|
const normalizedData = await this.normalizeUpdateData(data)
|
|
|
|
const priceSetIds = normalizedData.map(({ id }) => id)
|
|
const existingPrices = await this.priceService_.list(
|
|
{
|
|
price_set_id: priceSetIds,
|
|
price_list_id: null,
|
|
},
|
|
{
|
|
relations: ["price_rules"],
|
|
take: null,
|
|
},
|
|
sharedContext
|
|
)
|
|
|
|
const existingPricesMap = new Map<string, InferEntityType<typeof Price>>(
|
|
existingPrices.map((p) => [p.id, p])
|
|
)
|
|
|
|
const prices = normalizedData.flatMap((priceSet) => priceSet.prices || [])
|
|
|
|
const pricesToCreate = prices.filter(
|
|
(price) => !price.id || !existingPricesMap.has(price.id)
|
|
)
|
|
const pricesToUpdate = prices.filter(
|
|
(price) => price.id && existingPricesMap.has(price.id)
|
|
)
|
|
|
|
const incomingPriceIds = new Set(prices.map((p) => p.id).filter(Boolean))
|
|
const pricesToDelete = existingPrices
|
|
.filter((existingPrice) => !incomingPriceIds.has(existingPrice.id))
|
|
.map((p) => p.id)
|
|
|
|
let createdPrices: InferEntityType<typeof Price>[] = []
|
|
let updatedPrices: InferEntityType<typeof Price>[] = []
|
|
|
|
if (pricesToCreate.length > 0) {
|
|
createdPrices = await this.priceService_.create(
|
|
pricesToCreate.map((price) => {
|
|
price.price_rules ??= []
|
|
return price
|
|
}),
|
|
sharedContext
|
|
)
|
|
}
|
|
|
|
if (pricesToUpdate.length > 0) {
|
|
// Handle price rules for updated prices
|
|
for (const priceToUpdate of pricesToUpdate) {
|
|
const existingPrice = existingPricesMap.get(priceToUpdate.id!)
|
|
|
|
if (priceToUpdate.price_rules?.length) {
|
|
const existingPriceRules = existingPrice?.price_rules || []
|
|
|
|
// Separate price rules for create, update, delete
|
|
const priceRulesToCreate = priceToUpdate.price_rules.filter(
|
|
(rule) => !("id" in rule)
|
|
)
|
|
const priceRulesToUpdate = priceToUpdate.price_rules.filter(
|
|
(rule) => "id" in rule
|
|
)
|
|
|
|
const incomingPriceRuleIds = new Set(
|
|
priceToUpdate.price_rules
|
|
.map((r) => "id" in r && r.id)
|
|
.filter(Boolean)
|
|
)
|
|
const priceRulesToDelete = existingPriceRules
|
|
.filter(
|
|
(existingRule) => !incomingPriceRuleIds.has(existingRule.id)
|
|
)
|
|
.map((r) => r.id)
|
|
|
|
let createdPriceRules: InferEntityType<typeof PriceRule>[] = []
|
|
let updatedPriceRules: InferEntityType<typeof PriceRule>[] = []
|
|
|
|
// Bulk operations for price rules
|
|
if (priceRulesToCreate.length > 0) {
|
|
createdPriceRules = await this.priceRuleService_.create(
|
|
priceRulesToCreate.map((rule) => ({
|
|
...rule,
|
|
price_id: priceToUpdate.id,
|
|
})),
|
|
sharedContext
|
|
)
|
|
}
|
|
|
|
if (priceRulesToUpdate.length > 0) {
|
|
updatedPriceRules = await this.priceRuleService_.update(
|
|
priceRulesToUpdate,
|
|
sharedContext
|
|
)
|
|
}
|
|
|
|
if (priceRulesToDelete.length > 0) {
|
|
await this.priceRuleService_.delete(
|
|
priceRulesToDelete,
|
|
sharedContext
|
|
)
|
|
}
|
|
|
|
const upsertedPriceRules = [
|
|
...createdPriceRules,
|
|
...updatedPriceRules,
|
|
]
|
|
|
|
priceToUpdate.price_rules = upsertedPriceRules
|
|
;(priceToUpdate as InferEntityType<typeof Price>).rules_count =
|
|
upsertedPriceRules.length
|
|
} else if (
|
|
// In the case price_rules is provided but without any rules, we delete the existing rules
|
|
isDefined(priceToUpdate.price_rules) &&
|
|
priceToUpdate.price_rules.length === 0
|
|
) {
|
|
const priceRuleToDelete = existingPrice?.price_rules?.map((r) => r.id)
|
|
|
|
if (priceRuleToDelete?.length) {
|
|
await this.priceRuleService_.delete(
|
|
priceRuleToDelete,
|
|
sharedContext
|
|
)
|
|
}
|
|
|
|
;(priceToUpdate as InferEntityType<typeof Price>).rules_count = 0
|
|
} else {
|
|
// @ts-expect-error - we want to delete the rules_count property in any case even if provided by mistake
|
|
delete (priceToUpdate as InferEntityType<typeof Price>).rules_count
|
|
}
|
|
// We don't want to persist the price_rules in the database through the price service as it would not work
|
|
delete priceToUpdate.price_rules
|
|
}
|
|
|
|
updatedPrices = await this.priceService_.update(
|
|
pricesToUpdate,
|
|
sharedContext
|
|
)
|
|
}
|
|
|
|
if (pricesToDelete.length > 0) {
|
|
await this.priceService_.delete(pricesToDelete, sharedContext)
|
|
}
|
|
|
|
const priceSets = await this.priceSetService_.list(
|
|
{ id: normalizedData.map(({ id }) => id) },
|
|
{
|
|
relations: ["prices", "prices.price_rules"],
|
|
},
|
|
sharedContext
|
|
)
|
|
|
|
const upsertedPricesMap = new Map<string, InferEntityType<typeof Price>[]>()
|
|
|
|
const upsertedPrices = [...createdPrices, ...updatedPrices]
|
|
upsertedPrices.forEach((price) => {
|
|
upsertedPricesMap.set(price.price_set_id, [
|
|
...(upsertedPricesMap.get(price.price_set_id) || []),
|
|
price,
|
|
])
|
|
})
|
|
|
|
// re assign the prices to the price sets to not have to refetch after the transaction and keep the bahaviour the same as expected. If the user needs more data, he can still re list the price set with the expected fields and relations that he needs
|
|
|
|
priceSets.forEach((ps) => {
|
|
ps.prices = upsertedPricesMap.get(ps.id) || []
|
|
})
|
|
|
|
return priceSets
|
|
}
|
|
|
|
private async normalizeUpdateData(data: ServiceTypes.UpdatePriceSetInput[]) {
|
|
return data.map((priceSet) => {
|
|
return {
|
|
...priceSet,
|
|
prices: this.normalizePrices(
|
|
priceSet.prices?.map((p) => ({ ...p, price_set_id: priceSet.id })),
|
|
[]
|
|
),
|
|
}
|
|
})
|
|
}
|
|
|
|
private normalizePrices(
|
|
data: CreatePricesDTO[] | undefined,
|
|
existingPrices: PricingTypes.PriceDTO[],
|
|
priceListId?: string | undefined
|
|
) {
|
|
const pricesToUpsert = new Map<
|
|
string,
|
|
CreatePricesDTO & { price_rules?: CreatePriceRuleDTO[] }
|
|
>()
|
|
const existingPricesMap = new Map<string, PricingTypes.PriceDTO>()
|
|
Array.from(existingPrices ?? []).forEach((price) => {
|
|
existingPricesMap.set(hashPrice(price), price)
|
|
})
|
|
|
|
const ruleOperatorsSet = new Set<PricingRuleOperatorValues>(
|
|
Object.values(PricingRuleOperator)
|
|
)
|
|
const validOperatorsList = Array.from(ruleOperatorsSet).join(", ")
|
|
const invalidOperatorError = `operator should be one of ${validOperatorsList}`
|
|
|
|
data?.forEach((price) => {
|
|
const cleanRules = price.rules ? removeNullish(price.rules) : {}
|
|
|
|
const rules = Object.entries(cleanRules).flatMap(([attribute, value]) => {
|
|
if (Array.isArray(value)) {
|
|
return value.map((customRule) => {
|
|
if (!ruleOperatorsSet.has(customRule.operator)) {
|
|
throw new MedusaError(
|
|
MedusaError.Types.INVALID_DATA,
|
|
invalidOperatorError
|
|
)
|
|
}
|
|
|
|
if (typeof customRule.value !== "number") {
|
|
throw new MedusaError(
|
|
MedusaError.Types.INVALID_DATA,
|
|
`value should be a number`
|
|
)
|
|
}
|
|
|
|
return {
|
|
attribute,
|
|
operator: customRule.operator,
|
|
// TODO: we throw above if value is not a number, but the model expect the value to be a string
|
|
value: customRule.value.toString(),
|
|
}
|
|
})
|
|
}
|
|
|
|
return {
|
|
attribute,
|
|
value,
|
|
}
|
|
})
|
|
|
|
const entry = price as ServiceTypes.UpsertPriceDTO
|
|
|
|
const hasRulesInput = isPresent(price.rules)
|
|
entry.price_list_id = priceListId
|
|
if (hasRulesInput) {
|
|
entry.price_rules = rules
|
|
entry.rules_count = rules.length
|
|
delete (entry as CreatePricesDTO).rules
|
|
}
|
|
|
|
const entryHash = hashPrice(entry)
|
|
|
|
// We want to keep the existing rules as they might already have ids, but any other data should come from the updated input
|
|
const existing = existingPricesMap.get(entryHash)
|
|
|
|
if (existing) {
|
|
entry.id = existing.id ?? entry.id
|
|
entry.price_rules = existing.price_rules ?? entry.price_rules
|
|
}
|
|
|
|
pricesToUpsert.set(entryHash, entry)
|
|
})
|
|
|
|
return Array.from(pricesToUpsert.values())
|
|
}
|
|
|
|
async addPrices(
|
|
data: AddPricesDTO,
|
|
sharedContext?: Context
|
|
): Promise<PricingTypes.PriceSetDTO>
|
|
|
|
async addPrices(
|
|
data: AddPricesDTO[],
|
|
sharedContext?: Context
|
|
): Promise<PricingTypes.PriceSetDTO[]>
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
async addPrices(
|
|
data: AddPricesDTO | AddPricesDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricingTypes.PriceSetDTO[] | PricingTypes.PriceSetDTO> {
|
|
const input = Array.isArray(data) ? data : [data]
|
|
|
|
await this.addPrices_(input, sharedContext)
|
|
|
|
const dbPrices = await this.listPriceSets(
|
|
{ id: input.map((d) => d.priceSetId) },
|
|
{ relations: ["prices"] },
|
|
sharedContext
|
|
)
|
|
|
|
const orderedPriceSets = input.map((inputItem) => {
|
|
return dbPrices.find((p) => p.id === inputItem.priceSetId)!
|
|
})
|
|
|
|
const serializedOrderedPriceSets = await this.baseRepository_.serialize<
|
|
PricingTypes.PriceSetDTO[]
|
|
>(Array.isArray(data) ? orderedPriceSets : orderedPriceSets[0])
|
|
|
|
try {
|
|
return serializedOrderedPriceSets
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
// @ts-ignore
|
|
async createPriceLists(
|
|
data: PricingTypes.CreatePriceListDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricingTypes.PriceListDTO[]> {
|
|
const priceLists = await this.createPriceLists_(data, sharedContext)
|
|
|
|
try {
|
|
return await this.baseRepository_.serialize<PricingTypes.PriceListDTO[]>(
|
|
priceLists
|
|
)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
// @ts-ignore
|
|
async updatePriceLists(
|
|
data: PricingTypes.UpdatePriceListDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricingTypes.PriceListDTO[]> {
|
|
const priceLists = await this.updatePriceLists_(data, sharedContext)
|
|
|
|
try {
|
|
return await this.baseRepository_.serialize<PricingTypes.PriceListDTO[]>(
|
|
priceLists
|
|
)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
async updatePriceListPrices(
|
|
data: PricingTypes.UpdatePriceListPricesDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricingTypes.PriceDTO[]> {
|
|
const prices = await this.updatePriceListPrices_(data, sharedContext)
|
|
|
|
try {
|
|
return await this.baseRepository_.serialize<PricingTypes.PriceDTO[]>(
|
|
prices
|
|
)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
async removePrices(
|
|
ids: string[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<void> {
|
|
try {
|
|
await this.removePrices_(ids, sharedContext)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
async addPriceListPrices(
|
|
data: PricingTypes.AddPriceListPricesDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricingTypes.PriceDTO[]> {
|
|
const prices = await this.addPriceListPrices_(data, sharedContext)
|
|
|
|
try {
|
|
return await this.baseRepository_.serialize<PricingTypes.PriceDTO[]>(
|
|
prices
|
|
)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
async setPriceListRules(
|
|
data: PricingTypes.SetPriceListRulesDTO,
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricingTypes.PriceListDTO> {
|
|
const [priceList] = await this.setPriceListRules_([data], sharedContext)
|
|
|
|
try {
|
|
return await this.baseRepository_.serialize<PricingTypes.PriceListDTO>(
|
|
priceList
|
|
)
|
|
} finally {
|
|
this.pricingRepository_.clearAvailableAttributes?.()
|
|
}
|
|
}
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
async removePriceListRules(
|
|
data: PricingTypes.RemovePriceListRulesDTO,
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricingTypes.PriceListDTO> {
|
|
const [priceList] = await this.removePriceListRules_([data], sharedContext)
|
|
|
|
return await this.baseRepository_.serialize<PricingTypes.PriceListDTO>(
|
|
priceList
|
|
)
|
|
}
|
|
|
|
// @ts-expect-error
|
|
async createPricePreferences(
|
|
data: PricingTypes.CreatePricePreferenceDTO,
|
|
sharedContext?: Context
|
|
): Promise<PricePreferenceDTO>
|
|
async createPricePreferences(
|
|
data: PricingTypes.CreatePricePreferenceDTO[],
|
|
sharedContext?: Context
|
|
): Promise<PricePreferenceDTO[]>
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
async createPricePreferences(
|
|
data:
|
|
| PricingTypes.CreatePricePreferenceDTO
|
|
| PricingTypes.CreatePricePreferenceDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricePreferenceDTO | PricePreferenceDTO[]> {
|
|
const normalized = Array.isArray(data) ? data : [data]
|
|
const preferences = await this.createPricePreferences_(
|
|
normalized,
|
|
sharedContext
|
|
)
|
|
|
|
const serialized = await this.baseRepository_.serialize<
|
|
PricePreferenceDTO[]
|
|
>(preferences)
|
|
return Array.isArray(data) ? serialized : serialized[0]
|
|
}
|
|
|
|
async upsertPricePreferences(
|
|
data: UpsertPricePreferenceDTO[],
|
|
sharedContext?: Context
|
|
): Promise<PricePreferenceDTO[]>
|
|
async upsertPricePreferences(
|
|
data: UpsertPricePreferenceDTO,
|
|
sharedContext?: Context
|
|
): Promise<PricePreferenceDTO>
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
async upsertPricePreferences(
|
|
data: UpsertPricePreferenceDTO | UpsertPricePreferenceDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricePreferenceDTO | PricePreferenceDTO[]> {
|
|
const result = await this.upsertPricePreferences_(data, sharedContext)
|
|
|
|
return await this.baseRepository_.serialize<
|
|
PricePreferenceDTO[] | PricePreferenceDTO
|
|
>(Array.isArray(data) ? result : result[0])
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async upsertPricePreferences_(
|
|
data: UpsertPricePreferenceDTO | UpsertPricePreferenceDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<InferEntityType<typeof PricePreference>[]> {
|
|
const input = Array.isArray(data) ? data : [data]
|
|
const forUpdate = input.filter(
|
|
(
|
|
pricePreference
|
|
): pricePreference is ServiceTypes.UpdatePricePreferenceInput =>
|
|
!!pricePreference.id
|
|
)
|
|
const forCreate = input.filter(
|
|
(pricePreference): pricePreference is CreatePricePreferenceDTO =>
|
|
!pricePreference.id
|
|
)
|
|
|
|
const operations: Promise<InferEntityType<typeof PricePreference>[]>[] = []
|
|
|
|
if (forCreate.length) {
|
|
operations.push(this.createPricePreferences_(forCreate, sharedContext))
|
|
}
|
|
if (forUpdate.length) {
|
|
operations.push(this.updatePricePreferences_(forUpdate, sharedContext))
|
|
}
|
|
|
|
const result = (await promiseAll(operations)).flat()
|
|
|
|
return result
|
|
}
|
|
|
|
// @ts-expect-error
|
|
async updatePricePreferences(
|
|
id: string,
|
|
data: PricingTypes.UpdatePricePreferenceDTO,
|
|
sharedContext?: Context
|
|
): Promise<PricePreferenceDTO>
|
|
// @ts-expect-error
|
|
async updatePricePreferences(
|
|
selector: PricingTypes.FilterablePricePreferenceProps,
|
|
data: PricingTypes.UpdatePricePreferenceDTO,
|
|
sharedContext?: Context
|
|
): Promise<PricePreferenceDTO[]>
|
|
|
|
@InjectManager()
|
|
@EmitEvents()
|
|
// @ts-expect-error
|
|
async updatePricePreferences(
|
|
idOrSelector: string | PricingTypes.FilterablePricePreferenceProps,
|
|
data: PricingTypes.UpdatePricePreferenceDTO,
|
|
@MedusaContext() sharedContext: Context = {}
|
|
): Promise<PricePreferenceDTO | PricePreferenceDTO[]> {
|
|
let normalizedInput: ServiceTypes.UpdatePricePreferenceInput[] = []
|
|
if (isString(idOrSelector)) {
|
|
// Check if the ID exists, it will throw if not.
|
|
await this.pricePreferenceService_.retrieve(
|
|
idOrSelector,
|
|
{},
|
|
sharedContext
|
|
)
|
|
normalizedInput = [{ id: idOrSelector, ...data }]
|
|
} else {
|
|
const pricePreferences = await this.pricePreferenceService_.list(
|
|
idOrSelector,
|
|
{},
|
|
sharedContext
|
|
)
|
|
|
|
normalizedInput = pricePreferences.map((pricePreference) => ({
|
|
id: pricePreference.id,
|
|
...data,
|
|
}))
|
|
}
|
|
|
|
const updateResult = await this.updatePricePreferences_(
|
|
normalizedInput,
|
|
sharedContext
|
|
)
|
|
|
|
const pricePreferences = await this.baseRepository_.serialize<
|
|
PricePreferenceDTO[] | PricePreferenceDTO
|
|
>(updateResult)
|
|
|
|
return isString(idOrSelector) ? pricePreferences[0] : pricePreferences
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async createPricePreferences_(
|
|
data: PricingTypes.CreatePricePreferenceDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
) {
|
|
const preferences = await this.pricePreferenceService_.create(
|
|
data.map((d) => ({
|
|
...d,
|
|
is_tax_inclusive: d.is_tax_inclusive ?? false,
|
|
})),
|
|
sharedContext
|
|
)
|
|
|
|
return preferences
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async updatePricePreferences_(
|
|
data: PricingTypes.UpdatePricePreferenceDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
) {
|
|
const preferences = await this.pricePreferenceService_.update(
|
|
data,
|
|
sharedContext
|
|
)
|
|
|
|
return preferences
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async createPriceSets_(
|
|
data: PricingTypes.CreatePriceSetDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
) {
|
|
const input = Array.isArray(data) ? data : [data]
|
|
|
|
const toCreate = input.map((inputData) => {
|
|
const entry = {
|
|
...inputData,
|
|
prices: this.normalizePrices(inputData.prices, []),
|
|
}
|
|
return entry
|
|
})
|
|
|
|
// Bulk create price sets
|
|
const priceSets = await this.priceSetService_.create(
|
|
toCreate,
|
|
sharedContext
|
|
)
|
|
|
|
return priceSets
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async addPrices_(
|
|
input: AddPricesDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
) {
|
|
const prices = input.flatMap((data) => {
|
|
return data.prices.map((price) => {
|
|
;(price as PricingTypes.PriceDTO).price_set_id = data.priceSetId
|
|
return price
|
|
})
|
|
})
|
|
|
|
const priceConstraints =
|
|
buildPreNormalizationPriceConstraintsFromData(prices)
|
|
|
|
const [priceSets, priceSetPrices] = await promiseAll([
|
|
this.listPriceSets(
|
|
{ id: input.map((d) => d.priceSetId) },
|
|
{},
|
|
sharedContext
|
|
),
|
|
this.priceService_.list(
|
|
priceConstraints,
|
|
{ relations: ["price_rules"] },
|
|
sharedContext
|
|
),
|
|
])
|
|
|
|
const existingPrices = priceSetPrices as unknown as PricingTypes.PriceDTO[]
|
|
|
|
const pricesToUpsert = input
|
|
.flatMap((addPrice) =>
|
|
this.normalizePrices(addPrice.prices, existingPrices)
|
|
)
|
|
.filter(Boolean) as ServiceTypes.UpsertPriceDTO[]
|
|
|
|
const priceSetMap = new Map<string, PriceSetDTO>(
|
|
priceSets.map((p) => [p.id, p])
|
|
)
|
|
pricesToUpsert.forEach((price) => {
|
|
const priceSet = priceSetMap.get(price.price_set_id)
|
|
|
|
if (!priceSet) {
|
|
throw new MedusaError(
|
|
MedusaError.Types.INVALID_DATA,
|
|
`Price set with id: ${price.price_set_id} not found`
|
|
)
|
|
}
|
|
})
|
|
|
|
const { entities } = await this.priceService_.upsertWithReplace(
|
|
pricesToUpsert,
|
|
{ relations: ["price_rules"] },
|
|
sharedContext
|
|
)
|
|
|
|
return entities
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async createPriceLists_(
|
|
data: PricingTypes.CreatePriceListDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
) {
|
|
const normalized = this.normalizePriceListDate(data)
|
|
|
|
const priceListsToCreate: ServiceTypes.CreatePriceListDTO[] =
|
|
normalized.map((priceListData) => {
|
|
const entry = {
|
|
...priceListData,
|
|
rules: undefined,
|
|
} as ServiceTypes.CreatePriceListDTO
|
|
|
|
if (priceListData.prices) {
|
|
entry.prices = this.normalizePrices(
|
|
priceListData.prices,
|
|
[]
|
|
) as ServiceTypes.UpsertPriceDTO[]
|
|
}
|
|
|
|
if (priceListData.rules) {
|
|
const cleanRules = priceListData.rules
|
|
? removeNullish(priceListData.rules)
|
|
: {}
|
|
const rules = Object.entries(cleanRules)
|
|
const numberOfRules = rules.length
|
|
|
|
const rulesDataMap = new Map()
|
|
rules.map(([attribute, value]) => {
|
|
const rule = {
|
|
attribute,
|
|
value,
|
|
}
|
|
rulesDataMap.set(JSON.stringify(rule), rule)
|
|
})
|
|
|
|
entry.price_list_rules = Array.from(rulesDataMap.values())
|
|
entry.rules_count = numberOfRules
|
|
}
|
|
|
|
return entry
|
|
})
|
|
|
|
const priceLists = await this.priceListService_.create(
|
|
priceListsToCreate,
|
|
sharedContext
|
|
)
|
|
|
|
return priceLists
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async updatePriceLists_(
|
|
data: PricingTypes.UpdatePriceListDTO[],
|
|
@MedusaContext() sharedContext: Context = {}
|
|
) {
|
|
const existingPriceLists = await this.priceListService_.list(
|
|
{ id: data.map((d) => d.id) },
|
|
{},
|
|
sharedContext
|
|
)
|
|
|
|
if (existingPriceLists.length !== data.length) {
|
|
const diff = arrayDifference(
|
|
data.map((d) => d.id),
|
|
existingPriceLists.map((p) => p.id)
|
|
)
|
|
throw new MedusaError(
|
|
MedusaError.Types.INVALID_DATA,
|
|
`Price lists with ids: '${diff.join(", ")}' not found`
|
|
)
|
|
}
|
|
|
|
const normalizedData = this.normalizePriceListDate(data).map(
|
|
(priceList) => {
|
|
const entry: Partial<ServiceTypes.CreatePriceListDTO> = {
|
|
...priceList,
|
|
rules: undefined,
|
|
price_list_rules: undefined,
|
|
}
|
|
|
|
if (typeof priceList.rules === "object") {
|
|
const cleanRules = priceList.rules
|
|
? removeNullish(priceList.rules)
|
|
: {}
|
|
const rules = Object.entries(cleanRules)
|
|
const numberOfRules = rules.length
|
|
|
|
const rulesDataMap = new Map()
|
|
rules.map(([attribute, value]) => {
|
|
const rule = {
|
|
attribute,
|
|
value,
|
|
}
|
|
rulesDataMap.set(JSON.stringify(rule), rule)
|
|
})
|
|
|
|
entry.price_list_rules = Array.from(rulesDataMap.values())
|
|
entry.rules_count = numberOfRules
|
|
}
|
|
|
|
return entry
|
|
}
|
|
)
|
|
|
|
const { entities } = await this.priceListService_.upsertWithReplace(
|
|
normalizedData,
|
|
{
|
|
relations: ["price_list_rules"],
|
|
}
|
|
)
|
|
|
|
return entities
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async updatePriceListPrices_(
|
|
data: PricingTypes.UpdatePriceListPricesDTO[],
|
|
sharedContext: Context = {}
|
|
): Promise<InferEntityType<typeof Price>[]> {
|
|
const priceListIds = data.map((p) => p.price_list_id)
|
|
const prices = data.flatMap((p) => p.prices)
|
|
|
|
const priceConstraints = buildPreNormalizationPriceConstraintsFromData(
|
|
prices,
|
|
priceListIds
|
|
)
|
|
|
|
const [priceLists, priceListPrices] = await promiseAll([
|
|
this.priceListService_.list({ id: priceListIds }, {}, sharedContext),
|
|
this.priceService_.list(
|
|
priceConstraints,
|
|
{ relations: ["price_rules"] },
|
|
sharedContext
|
|
),
|
|
])
|
|
|
|
const existingPrices = priceListPrices as unknown as PricingTypes.PriceDTO[]
|
|
|
|
const pricesToUpsert = data
|
|
.flatMap((addPrice) =>
|
|
this.normalizePrices(
|
|
addPrice.prices as ServiceTypes.UpsertPriceDTO[],
|
|
existingPrices,
|
|
addPrice.price_list_id
|
|
)
|
|
)
|
|
.filter(Boolean) as ServiceTypes.UpsertPriceDTO[]
|
|
|
|
const priceListMap = new Map(priceLists.map((p) => [p.id, p]))
|
|
|
|
for (const { price_list_id: priceListId } of data) {
|
|
const priceList = priceListMap.get(priceListId)
|
|
|
|
if (!priceList) {
|
|
throw new MedusaError(
|
|
MedusaError.Types.INVALID_DATA,
|
|
`Price list with id: ${priceListId} not found`
|
|
)
|
|
}
|
|
}
|
|
|
|
const { entities } = await this.priceService_.upsertWithReplace(
|
|
pricesToUpsert,
|
|
{ relations: ["price_rules"] },
|
|
sharedContext
|
|
)
|
|
|
|
return entities
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async removePrices_(
|
|
ids: string[],
|
|
sharedContext: Context = {}
|
|
): Promise<void> {
|
|
await this.priceService_.delete(ids, sharedContext)
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async addPriceListPrices_(
|
|
data: PricingTypes.AddPriceListPricesDTO[],
|
|
sharedContext: Context = {}
|
|
): Promise<InferEntityType<typeof Price>[]> {
|
|
const priceListIds = data.map((p) => p.price_list_id)
|
|
const prices = data.flatMap((p) => p.prices)
|
|
|
|
const priceConstraints = buildPreNormalizationPriceConstraintsFromData(
|
|
prices,
|
|
priceListIds
|
|
)
|
|
const [priceLists, priceListPrices] = await promiseAll([
|
|
this.priceListService_.list({ id: priceListIds }, {}, sharedContext),
|
|
this.priceService_.list(
|
|
priceConstraints,
|
|
{ relations: ["price_rules"] },
|
|
sharedContext
|
|
),
|
|
])
|
|
|
|
const existingPrices = priceListPrices as unknown as PricingTypes.PriceDTO[]
|
|
|
|
const pricesToUpsert = data
|
|
.flatMap((addPrice) =>
|
|
this.normalizePrices(
|
|
addPrice.prices,
|
|
existingPrices,
|
|
addPrice.price_list_id
|
|
)
|
|
)
|
|
.filter(Boolean) as ServiceTypes.UpsertPriceDTO[]
|
|
|
|
const priceListMap = new Map(priceLists.map((p) => [p.id, p]))
|
|
pricesToUpsert.forEach((price) => {
|
|
const priceList = priceListMap.get(price.price_list_id!)
|
|
|
|
if (!priceList) {
|
|
throw new MedusaError(
|
|
MedusaError.Types.INVALID_DATA,
|
|
`Price list with id: ${price.price_list_id} not found`
|
|
)
|
|
}
|
|
})
|
|
|
|
const { entities } = await this.priceService_.upsertWithReplace(
|
|
pricesToUpsert,
|
|
{ relations: ["price_rules"] },
|
|
sharedContext
|
|
)
|
|
|
|
return entities
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async setPriceListRules_(
|
|
data: PricingTypes.SetPriceListRulesDTO[],
|
|
sharedContext: Context = {}
|
|
): Promise<InferEntityType<typeof PriceList>[]> {
|
|
// TODO: re think this method
|
|
const priceLists = await this.priceListService_.list(
|
|
{ id: data.map((d) => d.price_list_id) },
|
|
{
|
|
relations: ["price_list_rules"],
|
|
},
|
|
sharedContext
|
|
)
|
|
|
|
const rulesMap = new Map()
|
|
data.forEach((rule) => {
|
|
if (!rulesMap.has(rule.price_list_id)) {
|
|
rulesMap.set(rule.price_list_id, [])
|
|
}
|
|
|
|
Object.entries(rule.rules).forEach(([key, value]) => {
|
|
rulesMap.get(rule.price_list_id).push([key, value])
|
|
})
|
|
})
|
|
|
|
const priceListsUpsert = priceLists
|
|
.map((priceList) => {
|
|
const priceListRules =
|
|
priceList.price_list_rules as unknown as Collection<
|
|
InferEntityType<typeof PriceListRule>
|
|
>
|
|
const allRules = new Map(
|
|
priceListRules.toArray().map((r) => [r.attribute, r.value])
|
|
)
|
|
|
|
const rules = rulesMap.get(priceList.id)
|
|
if (!rules?.length) {
|
|
return
|
|
}
|
|
|
|
rules.forEach(([key, value]) => {
|
|
allRules.set(key, value)
|
|
})
|
|
|
|
return {
|
|
...priceList,
|
|
rules_count: allRules.size,
|
|
price_list_rules: Array.from(allRules).map(([attribute, value]) => ({
|
|
attribute,
|
|
value,
|
|
})),
|
|
}
|
|
})
|
|
.filter(Boolean)
|
|
|
|
const { entities } = await this.priceListService_.upsertWithReplace(
|
|
priceListsUpsert,
|
|
{ relations: ["price_list_rules"] },
|
|
sharedContext
|
|
)
|
|
|
|
return entities
|
|
}
|
|
|
|
@InjectTransactionManager()
|
|
protected async removePriceListRules_(
|
|
data: PricingTypes.RemovePriceListRulesDTO[],
|
|
sharedContext: Context = {}
|
|
): Promise<InferEntityType<typeof PriceList>[]> {
|
|
// TODO: re think this method
|
|
const priceLists = await this.priceListService_.list(
|
|
{ id: data.map((d) => d.price_list_id) },
|
|
{
|
|
relations: ["price_list_rules"],
|
|
},
|
|
sharedContext
|
|
)
|
|
|
|
const rulesMap = new Map()
|
|
data.forEach((rule) => {
|
|
if (!rulesMap.has(rule.price_list_id)) {
|
|
rulesMap.set(rule.price_list_id, [])
|
|
}
|
|
|
|
rule.rules.forEach((key) => {
|
|
rulesMap.get(rule.price_list_id).push([key, undefined])
|
|
})
|
|
})
|
|
|
|
const priceListsUpsert = priceLists
|
|
.map((priceList) => {
|
|
const priceListRules =
|
|
priceList.price_list_rules as unknown as Collection<
|
|
InferEntityType<typeof PriceListRule>
|
|
>
|
|
|
|
const allRules = new Map(
|
|
priceListRules.toArray().map((r) => [r.attribute, r.value])
|
|
)
|
|
|
|
const rules = rulesMap.get(priceList.id)
|
|
if (!rules?.length) {
|
|
return
|
|
}
|
|
|
|
rules.forEach(([key, value]) => {
|
|
allRules.set(key, value)
|
|
})
|
|
|
|
return {
|
|
...priceList,
|
|
rules_count: allRules.size,
|
|
price_list_rules: Array.from(allRules)
|
|
.map(([attribute, value]) => ({
|
|
attribute,
|
|
value,
|
|
}))
|
|
.filter((r) => !!r.value),
|
|
}
|
|
})
|
|
.filter(Boolean)
|
|
|
|
const { entities } = await this.priceListService_.upsertWithReplace(
|
|
priceListsUpsert,
|
|
{ relations: ["price_list_rules"] },
|
|
sharedContext
|
|
)
|
|
|
|
return entities
|
|
}
|
|
|
|
protected normalizePriceListDate(
|
|
data: (
|
|
| ServiceTypes.UpdatePriceListDTO
|
|
| ServiceTypes.CreatePriceListDTO
|
|
| ServiceTypes.CreatePriceListDTO
|
|
)[]
|
|
) {
|
|
return data.map((priceListData: any) => {
|
|
validatePriceListDates(priceListData)
|
|
|
|
if (!!priceListData.starts_at) {
|
|
priceListData.starts_at = GetIsoStringFromDate(priceListData.starts_at)
|
|
}
|
|
|
|
if (!!priceListData.ends_at) {
|
|
priceListData.ends_at = GetIsoStringFromDate(priceListData.ends_at)
|
|
}
|
|
|
|
return priceListData
|
|
})
|
|
}
|
|
|
|
protected normalizePriceSetConfig(
|
|
config: FindConfig<PricingTypes.PriceSetDTO> | undefined
|
|
) {
|
|
return {
|
|
options: {
|
|
populateWhere: { prices: { price_list_id: null } },
|
|
},
|
|
...config,
|
|
}
|
|
}
|
|
}
|
|
|
|
const isTaxInclusive = (
|
|
priceRules: InferEntityType<typeof PriceRule>[],
|
|
preferences: InferEntityType<typeof PricePreference>[],
|
|
currencyCode: string,
|
|
regionId?: string
|
|
) => {
|
|
const regionRule = priceRules?.find(
|
|
(rule) => rule.attribute === "region_id" && rule.value === regionId
|
|
)
|
|
|
|
const regionPreference = preferences.find(
|
|
(p) => p.attribute === "region_id" && p.value === regionId
|
|
)
|
|
|
|
const currencyPreference = preferences.find(
|
|
(p) => p.attribute === "currency_code" && p.value === currencyCode
|
|
)
|
|
|
|
if (regionRule && regionPreference) {
|
|
return regionPreference.is_tax_inclusive
|
|
}
|
|
|
|
if (currencyPreference) {
|
|
return currencyPreference.is_tax_inclusive
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
const hashPrice = (
|
|
price: PricingTypes.PriceDTO | PricingTypes.CreatePricesDTO
|
|
): string => {
|
|
// Build hash using deterministic property order to avoid expensive sort operation
|
|
// Using a direct string concatenation approach for better performance
|
|
const parts: string[] = []
|
|
|
|
if ("currency_code" in price) {
|
|
parts.push(`cc:${price.currency_code ?? ""}`)
|
|
}
|
|
if ("price_set_id" in price) {
|
|
parts.push(`ps:${price.price_set_id ?? ""}`)
|
|
}
|
|
if ("price_list_id" in price) {
|
|
parts.push(`pl:${price.price_list_id ?? ""}`)
|
|
}
|
|
if ("min_quantity" in price) {
|
|
parts.push(`min:${price.min_quantity ?? ""}`)
|
|
}
|
|
if ("max_quantity" in price) {
|
|
parts.push(`max:${price.max_quantity ?? ""}`)
|
|
}
|
|
|
|
// Add price rules in a deterministic way if present
|
|
if ("price_rules" in price && price.price_rules) {
|
|
const sortedRules = price.price_rules.map(
|
|
(pr) => `${pr.attribute}=${pr.value}`
|
|
)
|
|
if (sortedRules.length) {
|
|
parts.push(`rules:${sortedRules.join(",")}`)
|
|
}
|
|
}
|
|
|
|
return parts.sort().join("|")
|
|
}
|
|
|
|
/**
|
|
* Build targeted database constraints to fetch only prices that could match the incoming data.
|
|
* Uses the same properties as hashPrice to ensure consistency.
|
|
*/
|
|
const buildPreNormalizationPriceConstraintsFromData = (
|
|
prices: (
|
|
| PricingTypes.CreatePricesDTO
|
|
| ServiceTypes.UpsertPriceDTO
|
|
| PricingTypes.UpdatePriceListPriceDTO
|
|
)[],
|
|
priceListIds?: string | string[]
|
|
): any => {
|
|
// Separate prices with explicit IDs from those without
|
|
const pricesWithIds = prices.filter((p) => p.id).map((p) => p.id)
|
|
|
|
// Build unique constraints based on hash properties
|
|
const constraintSet = new Set<string>()
|
|
const constraints: any[] = []
|
|
|
|
for (const price of prices) {
|
|
// Skip if price has explicit ID (will be queried separately)
|
|
if (price.id) continue
|
|
|
|
const constraint: any = {}
|
|
|
|
if (price.currency_code !== undefined) {
|
|
constraint.currency_code = price.currency_code
|
|
}
|
|
if ("price_set_id" in price && price.price_set_id !== undefined) {
|
|
constraint.price_set_id = price.price_set_id
|
|
}
|
|
if ("price_list_id" in price && price.price_list_id !== undefined) {
|
|
constraint.price_list_id = price.price_list_id
|
|
}
|
|
if (price.min_quantity !== undefined) {
|
|
constraint.min_quantity = price.min_quantity
|
|
}
|
|
if (price.max_quantity !== undefined) {
|
|
constraint.max_quantity = price.max_quantity
|
|
}
|
|
|
|
// Use hash to deduplicate constraints
|
|
const constraintHash = JSON.stringify(constraint)
|
|
if (!constraintSet.has(constraintHash)) {
|
|
constraintSet.add(constraintHash)
|
|
constraints.push(constraint)
|
|
}
|
|
}
|
|
|
|
// Build final query
|
|
const query: any = {}
|
|
|
|
if (priceListIds) {
|
|
if (Array.isArray(priceListIds) && priceListIds.length > 0) {
|
|
query.price_list_id = {
|
|
$in: priceListIds,
|
|
}
|
|
} else {
|
|
query.price_list_id = priceListIds
|
|
}
|
|
}
|
|
|
|
// Combine ID-based and property-based constraints
|
|
if (pricesWithIds.length && constraints.length) {
|
|
query.$or = [{ id: pricesWithIds }, ...constraints]
|
|
} else if (pricesWithIds.length) {
|
|
query.id = pricesWithIds
|
|
} else if (constraints.length) {
|
|
if (constraints.length === 1) {
|
|
Object.assign(query, constraints[0])
|
|
} else {
|
|
query.$or = constraints
|
|
}
|
|
}
|
|
|
|
return query
|
|
}
|