Examples of the Pricing Module

In this document, you’ll find common examples of how you can use the Pricing Module in your application.

Create a Price Set

• medusa
• nextjs

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

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

  // A rule type with \`rule_attribute=region_id\` should
  // already be present in the database
  const priceSet = await pricingModuleService.create([
    {
      rules: [{ rule_attribute: "region_id" }],
      prices: [
        {
          currency_code: request.body.currency_code,
          amount: request.body.amount,
          rules: {
            region_id: request.body.region_id,
          },
        },
      ],
    },
  ])

  res.json({ price_set: priceSet })
}

import { NextResponse } from "next/server"

import {
  initialize as initializePricingModule,
} from "@medusajs/pricing"

export async function POST(request: Request) {
  const pricingModuleService = await initializePricingModule()
  const body = await request.json()

  // A rule type with \`rule_attribute=region_i\` should 
  // already be present in the database
  const priceSet = await pricingModuleService.create([
    {
      rules: [{ rule_attribute: "region_id" }],
      prices: [
        {
          currency_code: body.currency_code,
          amount: body.amount,
          rules: {
            region_id: body.region_id,
          },
        },
      ],
    },
  ])

  return NextResponse.json({ price_set: priceSet })
}

---

List Price Sets

• medusa
• nextjs

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)

  const priceSets = await pricingModuleService.list()

  res.json({ price_sets: priceSets })
}

import { NextResponse } from "next/server"

import { 
  initialize as initializePricingModule,
} from "@medusajs/pricing"

export async function GET(request: Request) {
  const pricingModuleService = await initializePricingModule()

  const priceSets = await pricingModuleService.list()

  return NextResponse.json({ price_sets: priceSets })
}

---

Retrieve a Price Set by its ID

• medusa
• nextjs

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)

  const priceSet = await pricingModuleService.retrieve(
    request.params.id
  )

  res.json({ price_set: priceSet })
}

import { NextResponse } from "next/server"

import {
  initialize as initializePricingModule,
} from "@medusajs/pricing"

type ContextType = {
  params: {
    id: string
  }
}

export async function GET(
  request: Request,
  { params }: ContextType
) {
  const pricingModuleService = await initializePricingModule()

  const priceSet = await pricingModuleService.retrieve(
    params.id
  )

  return NextResponse.json({ price_set: priceSet })
}

---

Create a Rule Type

• medusa
• nextjs

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

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

  const priceSet = await pricingModuleService.retrieve(
    request.params.id
  )

  res.json({ price_set: priceSet })
}

import { NextResponse } from "next/server"

import {
  initialize as initializePricingModule,
} from "@medusajs/pricing"

type ContextType = {
  params: {
    id: string
  }
}

export async function GET(
  request: Request,
  { params }: ContextType
) {
  const pricingModuleService = await initializePricingModule()

  const priceSet = await pricingModuleService.retrieve(
    params.id
  )

  return NextResponse.json({ price_set: priceSet })
}

---

Add Prices with Rules

• medusa
• nextjs

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

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

  const priceSet = await pricingModuleService.addPrices({
    priceSetId: request.body.price_set_id,
    prices: [
      {
        amount: 500,
        currency_code: "USD",
        rules: {
          region_id: request.body.region_id,
        },
      },
    ],
  })

  res.json({ price_set: priceSet })
}

import { NextResponse } from "next/server"

import {
  initialize as initializePricingModule,
} from "@medusajs/pricing"

export async function POST(request: Request) {
  const pricingModuleService = await initializePricingModule()
  const body = await request.json()

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

  return NextResponse.json({ price_set: priceSet })
}

---

Create Price List

• medusa
• nextjs

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

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

  const priceLists =
    await pricingModuleService.createPriceLists([
      {
        title: "My Sale",
        description: "This is my sale",
        type: PriceListType.SALE,
        starts_at: Date.parse("01/10/2023").toString(),
        ends_at: Date.parse("31/10/2023").toString(),
        rules: {
          region_id: ["DE", "DK"],
        },
        prices: [
          {
            amount: 400,
            currency_code: "EUR",
            price_set_id: "pset_124",
          },
        ],
      },
    ])

  res.json({ price_lists: priceLists })
}

import { NextResponse } from "next/server"
import { PriceListType } from "@medusajs/medusa"

import {
  initialize as initializePricingModule,
} from "@medusajs/pricing"

export async function POST(request: Request) {
  const pricingModuleService = await initializePricingModule()

  const priceLists = 
    await pricingModuleService.createPriceLists([
      {
        title: "My Sale",
        description: "This is my sale",
        type: PriceListType.SALE,
        starts_at: Date.parse("01/10/2023").toString(),
        ends_at: Date.parse("31/10/2023").toString(),
        rules: {
          region_id: ["DE", "DK"],
        },
        prices: [
          {
            amount: 400,
            currency_code: "EUR",
            price_set_id: "pset_124",
          },
        ],
      },
    ])

  return NextResponse.json({ price_lists: priceLists })
}

---

Calculate Prices For a Currency

• medusa
• nextjs

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

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

  const price = await pricingModuleService.calculatePrices(
    {
      id: [request.params.id],
    },
    {
      context: {
        currency_code: request.params.currency_code,
      },
    }
  )

  res.json({ price })
}

import { NextResponse } from "next/server"

import {
  initialize as initializePricingModule,
} from "@medusajs/pricing"

type ContextType = {
  params: {
    id: string
    currency_code: string
  }
}

export async function GET(
  request: Request,
  { params }: ContextType
) {
  const pricingModuleService = await initializePricingModule()

  const price = await pricingModuleService.calculatePrices({
    id: [params.id],
  }, {
    context: {
      currency_code: params.currency_code,
    },
  })

  return NextResponse.json({ price })
}

---

More Examples

The module interface reference provides a reference to all the methods available for use with examples for each.