Pricing Module

The Pricing Module is the @medusajs/pricing NPM package that provides pricing-related features in your Medusa and Node.js applications.

Features

Price Management

With the Pricing Module, store the prices of a resource and manage them through the main interface's methods.

Prices are grouped in a price set, allowing you to add more than one price for a resource based on different conditions, such as currency code.

const priceSet = await pricingModuleService.create({
  rules: [],
  prices: [
   {
      amount: 500,
      currency_code: "USD",
      rules: {},
    },
    {
        amount: 400,
        currency_code: "EUR",
        min_quantity: 0,
        max_quantity: 4,
        rules: {},
      },
  ],
})

Advanced Rule Engine

Create custom rules and apply them to prices. This gives you more flexibility in how you condition prices, filter them, and ensure the best prices are retrieved for custom contexts.

const ruleTypes = await pricingModuleService.createRuleTypes([
  {
    name: "Region",
    rule_attribute: "region_id",
  },
])

const priceSet = await pricingModuleService.addPrices({
  priceSetId,
  prices: [
   {
      amount: 500,
      currency_code: "EUR",
      rules: {
        region_id: "PL",
      },
    },
  ],
})

Price Lists

Price lists allow you to group prices and apply them only in specific conditions. You can also use them to override existing prices for the specified conditions.

const priceList = await pricingModuleService.createPriceLists({
  title: "My Sale",
  type: "sale",
  starts_at: Date.parse("01/10/2023"),
  ends_at: Date.parse("31/10/2023"),
  rules: {
    region_id: ["DE", "DK"],
  },
  prices: [
    {
      amount: 400,
      currency_code: "EUR",
      price_set_id: priceSet.id,
    },
  ],
})

Price Calculation Strategy

The module’s main service provides a calculatePrices method to retrieve the best price for a given context.

You can use your custom rules here to find the best price for the specified rule values.

const price = await pricingModuleService.calculatePrices(
  { id: [priceSetId] },
  {
    context: {
      currency_code: "EUR",
      region_id: "PL",
    },
  }
)

---

Configure Pricing Module

After installing the @medusajs/pricing package in your Medusa application, add it to the modules object in medusa-config.js:

medusa-config.js

const modules = {
  // ...
  pricingService: {
    resolve: "@medusajs/pricing",
  },
}

---

How to Use Pricing Module's Service

You can use the Pricing Module's main service by resolving from the dependency container the resource ModuleRegistrationName.PRICING imported from @medusajs/modules-sdk.

For example:

• API Route
• Subscriber
• Workflow Step

import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
import { IPricingModuleService } from "@medusajs/types"
import { ModuleRegistrationName } from "@medusajs/modules-sdk"

export async function GET(
  request: MedusaRequest,
  res: MedusaResponse
): Promise<void> {
  const pricingModuleService: IPricingModuleService =
    request.scope.resolve(ModuleRegistrationName.PRICING)

  res.json({
    price_sets: await pricingModuleService.list(),
  })
}

import { SubscriberArgs } from "@medusajs/medusa"
import { IPricingModuleService } from "@medusajs/types"
import { ModuleRegistrationName } from "@medusajs/modules-sdk"

export default async function subscriberHandler({
  container,
}: SubscriberArgs) {
  const pricingModuleService: IPricingModuleService =
    container.resolve(ModuleRegistrationName.PRICING)

  const priceSets = await pricingModuleService.list()
}

import { createStep } from "@medusajs/workflows-sdk"
import { IPricingModuleService } from "@medusajs/types"
import { ModuleRegistrationName } from "@medusajs/modules-sdk"

const step1 = createStep("step-1", async (_, context) => {
  const pricingModuleService: IPricingModuleService =
    context.container.resolve(ModuleRegistrationName.PRICING)

  const priceSets = await pricingModuleService.list()
})