feat(core-flows): calculate SO price on cart ops (#10563)

**What**
- calculate the shipping option price when creating a shipping method
- calculate the shipping option price when refreshing cart
- add testing for calculated SO flow
- fix validation on calculated SO creation
- add manual fulfillment provider for testing
- add `from_location` to calculation context

---

RESOLVES CMRC-778
RESOLVES CMRC-602
RESOLVES SUP-136
This commit is contained in:
Frane Polić
2024-12-16 22:28:30 +00:00
committed by GitHub
parent 95baacfd00
commit 0c49470066
21 changed files with 903 additions and 52 deletions
@@ -16,7 +16,7 @@ import { validateCartStep } from "../steps/validate-cart"
import { validateAndReturnShippingMethodsDataStep } from "../steps/validate-shipping-methods-data"
import { validateCartShippingOptionsPriceStep } from "../steps/validate-shipping-options-price"
import { cartFieldsForRefreshSteps } from "../utils/fields"
import { listShippingOptionsForCartWorkflow } from "./list-shipping-options-for-cart"
import { listShippingOptionsForCartWithPricingWorkflow } from "./list-shipping-options-for-cart-with-pricing"
import { updateCartPromotionsWorkflow } from "./update-cart-promotions"
import { updateTaxLinesWorkflow } from "./update-tax-lines"
@@ -56,13 +56,14 @@ export const addShippingMethodToCartWorkflow = createWorkflow(
shippingOptionsContext: { is_return: "false", enabled_in_store: "true" },
})
const shippingOptions = listShippingOptionsForCartWorkflow.runAsStep({
input: {
option_ids: optionIds,
cart_id: cart.id,
is_return: false,
},
})
const shippingOptions =
listShippingOptionsForCartWithPricingWorkflow.runAsStep({
input: {
options: input.options,
cart_id: cart.id,
is_return: false,
},
})
validateCartShippingOptionsPriceStep({ shippingOptions })
@@ -5,6 +5,7 @@ export * from "./confirm-variant-inventory"
export * from "./create-carts"
export * from "./create-payment-collection-for-cart"
export * from "./list-shipping-options-for-cart"
export * from "./list-shipping-options-for-cart-with-pricing"
export * from "./refresh-payment-collection"
export * from "./transfer-cart-customer"
export * from "./update-cart"
@@ -0,0 +1,275 @@
import { ShippingOptionPriceType } from "@medusajs/framework/utils"
import {
createWorkflow,
parallelize,
transform,
WorkflowData,
WorkflowResponse,
} from "@medusajs/framework/workflows-sdk"
import { useQueryGraphStep, validatePresenceOfStep } from "../../common"
import { useRemoteQueryStep } from "../../common/steps/use-remote-query"
import { calculateShippingOptionsPricesStep } from "../../fulfillment"
import { CalculateShippingOptionPriceDTO } from "@medusajs/types"
const COMMON_OPTIONS_FIELDS = [
"id",
"name",
"price_type",
"service_zone_id",
"service_zone.fulfillment_set_id",
"shipping_profile_id",
"provider_id",
"data",
"type.id",
"type.label",
"type.description",
"type.code",
"provider.id",
"provider.is_enabled",
"rules.attribute",
"rules.value",
"rules.operator",
]
export const listShippingOptionsForCartWithPricingWorkflowId =
"list-shipping-options-for-cart-with-pricing"
/**
* This workflow lists the shipping options of a cart.
*/
export const listShippingOptionsForCartWithPricingWorkflow = createWorkflow(
listShippingOptionsForCartWithPricingWorkflowId,
(
input: WorkflowData<{
cart_id: string
options?: { id: string; data?: Record<string, unknown> }[]
is_return?: boolean
enabled_in_store?: boolean
}>
) => {
const optionIds = transform({ input }, ({ input }) =>
(input.options ?? []).map(({ id }) => id)
)
const cartQuery = useQueryGraphStep({
entity: "cart",
filters: { id: input.cart_id },
fields: [
"id",
"sales_channel_id",
"currency_code",
"region_id",
"shipping_address.city",
"shipping_address.country_code",
"shipping_address.province",
"shipping_address.postal_code",
"items.*",
"item_total",
"total",
],
options: { throwIfKeyNotFound: true },
}).config({ name: "get-cart" })
const cart = transform({ cartQuery }, ({ cartQuery }) => cartQuery.data[0])
validatePresenceOfStep({
entity: cart,
fields: ["sales_channel_id", "region_id", "currency_code"],
})
const scFulfillmentSetQuery = useQueryGraphStep({
entity: "sales_channels",
filters: { id: cart.sales_channel_id },
fields: [
"stock_locations.id",
"stock_locations.name",
"stock_locations.address.*",
"stock_locations.fulfillment_sets.id",
],
}).config({ name: "sales_channels-fulfillment-query" })
const scFulfillmentSets = transform(
{ scFulfillmentSetQuery },
({ scFulfillmentSetQuery }) => scFulfillmentSetQuery.data[0]
)
const { fulfillmentSetIds, fulfillmentSetLocationMap } = transform(
{ scFulfillmentSets },
({ scFulfillmentSets }) => {
const fulfillmentSetIds = new Set<string>()
const fulfillmentSetLocationMap = {}
scFulfillmentSets.stock_locations.forEach((stockLocation) => {
stockLocation.fulfillment_sets.forEach((fulfillmentSet) => {
fulfillmentSetLocationMap[fulfillmentSet.id] = stockLocation
fulfillmentSetIds.add(fulfillmentSet.id)
})
})
return {
fulfillmentSetIds: Array.from(fulfillmentSetIds),
fulfillmentSetLocationMap,
}
}
)
const commonOptions = transform(
{ input, cart, fulfillmentSetIds },
({ input, cart, fulfillmentSetIds }) => ({
context: {
is_return: input.is_return ?? false,
enabled_in_store: input.enabled_in_store ?? true,
},
filters: {
fulfillment_set_id: fulfillmentSetIds,
address: {
country_code: cart.shipping_address?.country_code,
province_code: cart.shipping_address?.province,
city: cart.shipping_address?.city,
postal_expression: cart.shipping_address?.postal_code,
},
},
})
)
const typeQueryFilters = transform(
{ optionIds, commonOptions },
({ optionIds, commonOptions }) => ({
id: optionIds.length ? optionIds : undefined,
...commonOptions,
})
)
/**
* We need to prefetch exact same SO as in the final result but only to determine pricing calculations first.
*/
const initialOptions = useRemoteQueryStep({
entry_point: "shipping_options",
variables: typeQueryFilters,
fields: ["id", "price_type"],
}).config({ name: "shipping-options-price-type-query" })
/**
* Prepare queries for flat rate and calculated shipping options since price calculations are different for each.
*/
const { flatRateOptionsQuery, calculatedShippingOptionsQuery } = transform(
{
cart,
initialOptions,
commonOptions,
},
({ cart, initialOptions, commonOptions }) => {
const flatRateShippingOptionIds: string[] = []
const calculatedShippingOptionIds: string[] = []
initialOptions.forEach((option) => {
if (option.price_type === ShippingOptionPriceType.FLAT) {
flatRateShippingOptionIds.push(option.id)
} else {
calculatedShippingOptionIds.push(option.id)
}
})
return {
flatRateOptionsQuery: {
...commonOptions,
id: flatRateShippingOptionIds,
calculated_price: { context: cart },
},
calculatedShippingOptionsQuery: {
...commonOptions,
id: calculatedShippingOptionIds,
},
}
}
)
const [shippingOptionsFlatRate, shippingOptionsCalculated] = parallelize(
useRemoteQueryStep({
entry_point: "shipping_options",
fields: [
...COMMON_OPTIONS_FIELDS,
"calculated_price.*",
"prices.*",
"prices.price_rules.*",
],
variables: flatRateOptionsQuery,
}).config({ name: "shipping-options-query-flat-rate" }),
useRemoteQueryStep({
entry_point: "shipping_options",
fields: [...COMMON_OPTIONS_FIELDS],
variables: calculatedShippingOptionsQuery,
}).config({ name: "shipping-options-query-calculated" })
)
const calculateShippingOptionsPricesData = transform(
{
shippingOptionsCalculated,
cart,
input,
fulfillmentSetLocationMap,
},
({
shippingOptionsCalculated,
cart,
input,
fulfillmentSetLocationMap,
}) => {
const optionDataMap = new Map(
(input.options ?? []).map(({ id, data }) => [id, data])
)
return shippingOptionsCalculated.map(
(so) =>
({
id: so.id as string,
optionData: so.data,
context: {
...cart,
from_location:
fulfillmentSetLocationMap[so.service_zone.fulfillment_set_id],
},
data: optionDataMap.get(so.id),
provider_id: so.provider_id,
} as CalculateShippingOptionPriceDTO)
)
}
)
const prices = calculateShippingOptionsPricesStep(
calculateShippingOptionsPricesData
)
const shippingOptionsWithPrice = transform(
{ shippingOptionsFlatRate, shippingOptionsCalculated, prices },
({ shippingOptionsFlatRate, shippingOptionsCalculated, prices }) => {
return [
...shippingOptionsFlatRate.map((shippingOption) => {
const price = shippingOption.calculated_price
return {
...shippingOption,
amount: price?.calculated_amount,
is_tax_inclusive: !!price?.is_calculated_price_tax_inclusive,
}
}),
...shippingOptionsCalculated.map((shippingOption, index) => {
return {
...shippingOption,
amount: prices[index]?.calculated_amount,
is_tax_inclusive:
prices[index]?.is_calculated_price_tax_inclusive,
calculated_price: prices[index],
}
}),
]
}
)
return new WorkflowResponse(shippingOptionsWithPrice)
}
)
@@ -9,7 +9,7 @@ import {
import { useQueryGraphStep } from "../../common"
import { removeShippingMethodFromCartStep } from "../steps"
import { updateShippingMethodsStep } from "../steps/update-shipping-methods"
import { listShippingOptionsForCartWorkflow } from "./list-shipping-options-for-cart"
import { listShippingOptionsForCartWithPricingWorkflow } from "./list-shipping-options-for-cart-with-pricing"
export const refreshCartShippingMethodsWorkflowId =
"refresh-cart-shipping-methods"
@@ -32,28 +32,33 @@ export const refreshCartShippingMethodsWorkflow = createWorkflow(
"shipping_address.country_code",
"shipping_address.province",
"shipping_methods.shipping_option_id",
"shipping_methods.data",
"total",
],
options: { throwIfKeyNotFound: true },
}).config({ name: "get-cart" })
const cart = transform({ cartQuery }, ({ cartQuery }) => cartQuery.data[0])
const shippingOptionIds: string[] = transform({ cart }, ({ cart }) =>
const listShippingOptionsInput = transform({ cart }, ({ cart }) =>
(cart.shipping_methods || [])
.map((shippingMethod) => shippingMethod.shipping_option_id)
.map((shippingMethod) => ({
id: shippingMethod.shipping_option_id,
data: shippingMethod.data,
}))
.filter(Boolean)
)
when({ shippingOptionIds }, ({ shippingOptionIds }) => {
return !!shippingOptionIds?.length
when({ listShippingOptionsInput }, ({ listShippingOptionsInput }) => {
return !!listShippingOptionsInput?.length
}).then(() => {
const shippingOptions = listShippingOptionsForCartWorkflow.runAsStep({
input: {
option_ids: shippingOptionIds,
cart_id: cart.id,
is_return: false,
},
})
const shippingOptions =
listShippingOptionsForCartWithPricingWorkflow.runAsStep({
input: {
options: listShippingOptionsInput,
cart_id: cart.id,
is_return: false,
},
})
// Creates an object on which shipping methods to remove or update depending
// on the validity of the shipping options for the cart
@@ -73,9 +73,20 @@ export const validateShippingOptionPricesStep = createStep(
}
})
await fulfillmentModuleService.validateShippingOptionsForPriceCalculation(
calculatedOptions as FulfillmentWorkflow.CreateShippingOptionsWorkflowInput[]
)
const validation =
await fulfillmentModuleService.validateShippingOptionsForPriceCalculation(
calculatedOptions as FulfillmentWorkflow.CreateShippingOptionsWorkflowInput[]
)
if (validation.some((v) => !v)) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Cannot calcuate pricing for: [${calculatedOptions
.filter((o, i) => !validation[i])
.map((o) => o.name)
.join(", ")}] shipping option(s).`
)
}
const regionIdSet = new Set<string>()
@@ -25,7 +25,7 @@ export const calculateShippingOptionsPricesWorkflow = createWorkflow(
const shippingOptionsQuery = useQueryGraphStep({
entity: "shipping_option",
filters: { id: ids },
fields: ["id", "provider_id", "data"],
fields: ["id", "provider_id", "data", "service_zone.fulfillment_set_id"],
}).config({ name: "shipping-options-query" })
const cartQuery = useQueryGraphStep({
@@ -34,12 +34,58 @@ export const calculateShippingOptionsPricesWorkflow = createWorkflow(
fields: ["id", "items.*", "shipping_address.*"],
}).config({ name: "cart-query" })
const fulfillmentSetId = transform(
{ shippingOptionsQuery },
({ shippingOptionsQuery }) =>
shippingOptionsQuery.data.map(
(so) => so.service_zone.fulfillment_set_id
)
)
const locationFulfillmentSetQuery = useQueryGraphStep({
entity: "location_fulfillment_set",
filters: { fulfillment_set_id: fulfillmentSetId },
fields: ["id", "stock_location_id", "fulfillment_set_id"],
}).config({ name: "location-fulfillment-set-query" })
const locationIds = transform(
{ locationFulfillmentSetQuery },
({ locationFulfillmentSetQuery }) =>
locationFulfillmentSetQuery.data.map((lfs) => lfs.stock_location_id)
)
const locationQuery = useQueryGraphStep({
entity: "stock_location",
filters: { id: locationIds },
fields: ["id", "name", "address.*"],
}).config({ name: "location-query" })
const data = transform(
{ shippingOptionsQuery, cartQuery, input },
({ shippingOptionsQuery, cartQuery, input }) => {
{
shippingOptionsQuery,
cartQuery,
input,
locationFulfillmentSetQuery,
locationQuery,
},
({
shippingOptionsQuery,
cartQuery,
input,
locationFulfillmentSetQuery,
locationQuery,
}) => {
const shippingOptions = shippingOptionsQuery.data
const cart = cartQuery.data[0]
const locations = locationQuery.data
const locationFulfillmentSetMap = new Map(
locationFulfillmentSetQuery.data.map((lfs) => [
lfs.fulfillment_set_id,
lfs.stock_location_id,
])
)
const shippingOptionDataMap = new Map(
input.shipping_options.map((so) => [so.id, so.data])
)
@@ -50,7 +96,14 @@ export const calculateShippingOptionsPricesWorkflow = createWorkflow(
optionData: shippingOption.data,
data: shippingOptionDataMap.get(shippingOption.id) ?? {},
context: {
cart,
...cart,
from_location: locations.find(
(l) =>
l.id ===
locationFulfillmentSetMap.get(
shippingOption.service_zone.fulfillment_set_id
)
),
},
}))
}