import { CodeTabs, CodeTab } from "docs-ui"

export const metadata = {
  title: `Pricing Module`,
}

# {metadata.title}

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 service'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.

```ts
const priceSet = await pricingModuleService.create({
  rules: [],
  prices: [
   {
      amount: 500,
      currency_code: "USD",
    },
    {
        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.

```ts
const ruleTypes = await pricingModuleService.createRuleTypes([
  {
    name: "Region",
    rule_field: "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.

```ts
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

Retrieve the best price in a given context and for the specified rule values.

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

---

## Configure Pricing Module

To use the Pricing Module, enable it in the `modules` object in `medusa-config.js`:

```js title="medusa-config.js"
const { Modules } = require("@medusajs/modules-sdk")

// ...

const modules = {
  // ...
  [Modules.PRICING]: true,
}
```

---

## How to Use Pricing Module's Service

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

For example:

<CodeTabs groupId="resource-type">
  <CodeTab label="API Route" value="api-route">

  ```ts title="src/api/store/custom/route.ts"
  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(),
    })
  }
  ```

  </CodeTab>
  <CodeTab label="Subscriber" value="subscribers">

  ```ts title="src/subscribers/custom-handler.ts"
  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()
  }
  ```

  </CodeTab>
  <CodeTab label="Workflow Step" value="workflow-step">

  ```ts title="src/workflows/hello-world/step1.ts"
  import { createStep } from "@medusajs/workflows-sdk"
  import { IPricingModuleService } from "@medusajs/types"
  import { ModuleRegistrationName } from "@medusajs/modules-sdk"

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

    const priceSets = await pricingModuleService.list()
  })
  ```

  </CodeTab>
</CodeTabs>