docs: revise commerce modules overview pages (#10738)

* revise API Key Module overview

* revise auth module

* support ref sidebar items

* remove examples

* revise cart module

* revise currency

* revise customer module

* revise fulfillment module

* revise inventory module

* revise order module

* revise payment

* revise pricing module

* revise product module

* revise promotion module

* revise region module

* revise sales channel module

* revise stock location module

* revise store module

* revise tax module

* revise user module

* lint content + fix snippets
This commit is contained in:
Shahed Nasser
2024-12-26 10:32:16 +02:00
committed by GitHub
parent c8f9938865
commit ebca8fed28
112 changed files with 9465 additions and 7731 deletions
@@ -1,395 +0,0 @@
import { CodeTabs, CodeTab } from "docs-ui"
export const metadata = {
title: `Examples of the Pricing Module`,
}
# {metadata.title}
In this document, youll find common examples of how you can use the Pricing Module in your application.
<Note>
You should only use the Pricing Module's main service when implementing complex customizations. For common cases, check out [available workflows instead](../../../medusa-workflows-reference/page.mdx).
</Note>
## Create a Price Set
<CodeTabs groupId="app-type">
<CodeTab value="medusa" label="Medusa API Router">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function POST(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const pricingModuleService = request.scope.resolve(
Modules.PRICING
)
const priceSet = await pricingModuleService.createPriceSets([
{
prices: [
{
currency_code: "eur",
amount: 10,
rules: {
region_id: "reg_123",
},
},
],
},
])
res.json({ price_set: priceSet })
}
```
</CodeTab>
<CodeTab value="nextjs" label="Next.js App Router">
```ts
import { NextResponse } from "next/server"
import { initialize as initializePricingModule } from "@medusajs/medusa/pricing"
export async function POST(request: Request) {
const pricingModuleService = await initializePricingModule()
const body = await request.json()
const priceSet = await pricingModuleService.createPriceSets([
{
prices: [
{
currency_code: "eur",
amount: 10,
rules: {
region_id: "reg_123",
},
},
],
},
])
return NextResponse.json({ price_set: priceSet })
}
```
</CodeTab>
</CodeTabs>
---
## List Price Sets
<CodeTabs groupId="app-type">
<CodeTab value="medusa" label="Medusa API Router">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function GET(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const pricingModuleService = request.scope.resolve(
Modules.PRICING
)
const priceSets = await pricingModuleService.listPriceSets()
res.json({ price_sets: priceSets })
}
```
</CodeTab>
<CodeTab value="nextjs" label="Next.js App Router">
```ts
import { NextResponse } from "next/server"
import { initialize as initializePricingModule } from "@medusajs/medusa/pricing"
export async function GET(request: Request) {
const pricingModuleService = await initializePricingModule()
const priceSets = await pricingModuleService.listPriceSets()
return NextResponse.json({ price_sets: priceSets })
}
```
</CodeTab>
</CodeTabs>
---
## Retrieve a Price Set by its ID
<CodeTabs groupId="app-type">
<CodeTab value="medusa" label="Medusa API Router">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function GET(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const pricingModuleService = request.scope.resolve(
Modules.PRICING
)
const priceSet = await pricingModuleService.retrievePriceSet("pset_123")
res.json({ price_set: priceSet })
}
```
</CodeTab>
<CodeTab value="nextjs" label="Next.js App Router">
```ts
import { NextResponse } from "next/server"
import { initialize as initializePricingModule } from "@medusajs/medusa/pricing"
export async function GET(request: Request) {
const pricingModuleService = await initializePricingModule()
const priceSet = await pricingModuleService.retrievePriceSet("pset_123")
return NextResponse.json({ price_set: priceSet })
}
```
</CodeTab>
</CodeTabs>
---
## Add Prices with Rules
<CodeTabs groupId="app-type">
<CodeTab value="medusa" label="Medusa API Router">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function POST(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const pricingModuleService = request.scope.resolve(
Modules.PRICING
)
const priceSet = await pricingModuleService.addPrices({
priceSetId: "pset_123",
prices: [
{
amount: 500,
currency_code: "USD",
rules: {
region_id: "reg_123",
},
},
],
})
res.json({ price_set: priceSet })
}
```
</CodeTab>
<CodeTab value="nextjs" label="Next.js App Router">
```ts
import { NextResponse } from "next/server"
import { initialize as initializePricingModule } from "@medusajs/medusa/pricing"
export async function POST(request: Request) {
const pricingModuleService = await initializePricingModule()
const body = await request.json()
const priceSet = await pricingModuleService.addPrices({
priceSetId: "pset_123",
prices: [
{
amount: 500,
currency_code: "USD",
rules: {
region_id: "reg_123",
},
},
],
})
return NextResponse.json({ price_set: priceSet })
}
```
</CodeTab>
</CodeTabs>
---
## Create Price List
<CodeTabs groupId="app-type">
<CodeTab value="medusa" label="Medusa API Router">
```ts collapsibleLines="1-8" expandButtonLabel="Show Imports"
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { IPricingModuleService } from "@medusajs/framework/types"
import { PriceListType } from "@medusajs/framework/utils"
import { Modules } from "@medusajs/framework/utils"
export async function POST(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const pricingModuleService = request.scope.resolve(
Modules.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: ["reg_123", "reg_321"],
},
prices: [
{
amount: 400,
currency_code: "EUR",
price_set_id: "pset_124",
},
],
},
])
res.json({ price_lists: priceLists })
}
```
</CodeTab>
<CodeTab value="nextjs" label="Next.js App Router">
```ts
import { NextResponse } from "next/server"
import { PriceListType } from "@medusajs/framework/utils"
import { initialize as initializePricingModule } from "@medusajs/medusa/pricing"
import { PriceListType } from "@medusajs/framework/utils"
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: ["reg_123", "reg_321"],
},
prices: [
{
amount: 400,
currency_code: "EUR",
price_set_id: "pset_124",
},
],
},
])
return NextResponse.json({ price_lists: priceLists })
}
```
</CodeTab>
</CodeTabs>
---
## Calculate Prices For a Currency
<CodeTabs groupId="app-type">
<CodeTab value="medusa" label="Medusa API Router">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function POST(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const pricingModuleService = request.scope.resolve(
Modules.PRICING
)
const price = await pricingModuleService.calculatePrices(
{
id: ["pset_123"],
},
{
context: {
currency_code: "eur",
},
}
)
res.json({ price })
}
```
</CodeTab>
<CodeTab value="nextjs" label="Next.js App Router">
```ts
import { NextResponse } from "next/server"
import { initialize as initializePricingModule } from "@medusajs/medusa/pricing"
export async function GET(request: Request) {
const pricingModuleService = await initializePricingModule()
const price = await pricingModuleService.calculatePrices(
{
id: ["pset_123"],
},
{
context: {
currency_code: "eur",
},
}
)
return NextResponse.json({ price })
}
```
</CodeTab>
</CodeTabs>
---
## More Examples
The [Pricing Module's main service reference](/references/pricing) provides a reference to all the methods available for use with examples for each.
@@ -36,8 +36,8 @@ To retrieve the shipping option of a price set with [Query](!docs!/learn/fundame
const { data: priceSets } = await query.graph({
entity: "price_set",
fields: [
"shipping_option.*"
]
"shipping_option.*",
],
})
// priceSets.shipping_option
@@ -54,8 +54,8 @@ import { useQueryGraphStep } from "@medusajs/medusa/core-flows"
const { data: priceSets } = useQueryGraphStep({
entity: "price_set",
fields: [
"shipping_option.*"
]
"shipping_option.*",
],
})
// priceSets.shipping_option
@@ -133,8 +133,8 @@ To retrieve the variant of a price set with [Query](!docs!/learn/fundamentals/mo
const { data: priceSets } = await query.graph({
entity: "price_set",
fields: [
"variant.*"
]
"variant.*",
],
})
// priceSets.variant
@@ -151,8 +151,8 @@ import { useQueryGraphStep } from "@medusajs/medusa/core-flows"
const { data: priceSets } = useQueryGraphStep({
entity: "price_set",
fields: [
"variant.*"
]
"variant.*",
],
})
// priceSets.variant
@@ -6,157 +6,167 @@ export const metadata = {
# {metadata.title}
The Pricing Module provides pricing-related features in your Medusa and Node.js applications.
In this section of the documentation, you will find resources to learn more about the Pricing Module and how to use it in your application.
## How to Use Pricing Module's Service
Medusa has pricing related features available out-of-the-box through the Pricing Module. A [module](!docs!/learn/fundamentals/modules) is a standalone package that provides features for a single domain. Each of Medusa's commerce features are placed in commerce modules, such as this Pricing Module.
You can use the Pricing Module's main service by resolving from the Medusa container the resource `Modules.PRICING`.
<Note>
Learn more about why modules are isolated in [this documentation](!docs!/learn/fundamentals/modules/isolation).
</Note>
## Pricing Features
- [Price Management](./concepts/page.mdx): Store and manage prices of a resource, such as a product or a variant.
- [Advanced Rule Engine](./price-rules/page.mdx): Create prices with custom rules to condition prices based on different contexts.
- [Price Lists](./concepts/page.mdx#price-list): Group prices and apply them only in specific conditions with price lists.
- [Price Calculation Strategy](./price-calculation/page.mdx): Retrieve the best price in a given context and for the specified rule values.
- [Tax-Inclusive Pricing](./tax-inclusive-pricing/page.mdx): Calculate prices with taxes included in the price, and Medusa will handle calculating the taxes automatically.
---
## How to Use the Pricing Module
In your Medusa application, you build flows around commerce modules. A flow is built as a [Workflow](!docs!/learn/fundamentals/workflows), which is a special function composed of a series of steps that guarantees data consistency and reliable roll-back mechanism.
You can build custom workflows and steps. You can also re-use Medusa's workflows and steps, which are provided by the `@medusajs/medusa/core-flows` package.
For example:
<CodeTabs groupId="resource-type">
<CodeTab label="Workflow Step" value="workflow-step">
export const highlights = [
["12", "Modules.PRICING", "Resolve the module in a step."]
]
```ts title="src/workflows/hello-world/step1.ts"
import { createStep } from "@medusajs/framework/workflows-sdk"
```ts title="src/workflows/create-price-set.ts" highlights={highlights}
import {
createWorkflow,
WorkflowResponse,
createStep,
StepResponse,
} from "@medusajs/framework/workflows-sdk"
import { Modules } from "@medusajs/framework/utils"
const step1 = createStep("step-1", async (_, { container }) => {
const pricingModuleService = container.resolve(
Modules.PRICING
)
const createPriceSetStep = createStep(
"create-price-set",
async ({}, { container }) => {
const pricingModuleService = container.resolve(Modules.PRICING)
const priceSets = await pricingModuleService.listPriceSets()
})
const priceSet = await pricingModuleService.createPriceSets({
prices: [
{
amount: 500,
currency_code: "USD",
},
{
amount: 400,
currency_code: "EUR",
min_quantity: 0,
max_quantity: 4,
rules: {},
},
],
})
return new StepResponse({ priceSet }, priceSet.id)
},
async (priceSetId, { container }) => {
if (!priceSetId) {
return
}
const pricingModuleService = container.resolve(Modules.PRICING)
await pricingModuleService.deletePriceSets([priceSetId])
}
)
export const createPriceSetWorkflow = createWorkflow(
"create-price-set",
() => {
const { priceSet } = createPriceSetStep()
return new WorkflowResponse({
priceSet,
})
}
)
```
</CodeTab>
<CodeTab label="API Route" value="api-route">
You can then execute the workflow in your custom API routes, scheduled jobs, or subscribers:
```ts title="src/api/store/custom/route.ts"
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
<CodeTabs group="resource-types">
<CodeTab label="API Route" value="api-route">
```ts title="src/api/workflow/route.ts" highlights={[["11"], ["12"]]} collapsibleLines="1-6" expandButtonLabel="Show Imports"
import type {
MedusaRequest,
MedusaResponse,
} from "@medusajs/framework/http"
import { createPriceSetWorkflow } from "../../workflows/create-price-set"
export async function GET(
request: MedusaRequest,
req: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const pricingModuleService = request.scope.resolve(
Modules.PRICING
)
) {
const { result } = await createPriceSetWorkflow(req.scope)
.run()
res.json({
price_sets: await pricingModuleService.listPriceSets(),
})
res.send(result)
}
```
</CodeTab>
<CodeTab label="Subscriber" value="subscribers">
<CodeTab label="Subscriber" value="subscriber">
```ts title="src/subscribers/user-created.ts" highlights={[["11"], ["12"]]} collapsibleLines="1-6" expandButtonLabel="Show Imports"
import {
type SubscriberConfig,
type SubscriberArgs,
} from "@medusajs/framework"
import { createPriceSetWorkflow } from "../workflows/create-price-set"
```ts title="src/subscribers/custom-handler.ts"
import { SubscriberArgs } from "@medusajs/framework"
import { Modules } from "@medusajs/framework/utils"
export default async function handleUserCreated({
event: { data },
container,
}: SubscriberArgs<{ id: string }>) {
const { result } = await createPriceSetWorkflow(container)
.run()
export default async function subscriberHandler({ container }: SubscriberArgs) {
const pricingModuleService = container.resolve(
Modules.PRICING
)
console.log(result)
}
const priceSets = await pricingModuleService.listPriceSets()
export const config: SubscriberConfig = {
event: "user.created",
}
```
</CodeTab>
<CodeTab label="Scheduled Job" value="scheduled-job">
```ts title="src/jobs/run-daily.ts" highlights={[["7"], ["8"]]}
import { MedusaContainer } from "@medusajs/framework/types"
import { createPriceSetWorkflow } from "../workflows/create-price-set"
export default async function myCustomJob(
container: MedusaContainer
) {
const { result } = await createPriceSetWorkflow(container)
.run()
console.log(result)
}
export const config = {
name: "run-once-a-day",
schedule: `0 0 * * *`,
}
```
</CodeTab>
</CodeTabs>
Learn more about workflows in [this documentation](!docs!/learn/fundamentals/workflows).
---
## Features
### Price Management
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.createPriceSets({
prices: [
{
amount: 500,
currency_code: "USD",
},
{
amount: 400,
currency_code: "EUR",
min_quantity: 0,
max_quantity: 4,
rules: {},
},
],
})
```
### Advanced Rule Engine
Create prices with custom rules. This gives you more flexibility in how you condition prices, filter them, and ensure the best prices are retrieved for custom contexts.
```ts highlights={[["8"]]}
const priceSet = await pricingModuleService.addPrices({
priceSetId: "pset_123",
prices: [
{
amount: 500,
currency_code: "EUR",
rules: {
region_id: "reg_123",
},
},
],
})
```
### Price Lists
Group prices and apply them only in specific conditions with price lists.
You can also use them to override existing prices for specified conditions, or create a sale.
```ts
const priceList = await pricingModuleService.createPriceLists([
{
title: "My Sale",
description: "Sale on selected items.",
type: "sale",
starts_at: Date.parse("01/10/2023").toString(),
ends_at: Date.parse("31/10/2023").toString(),
rules: {
region_id: ["reg_123", "reg_321"],
},
prices: [
{
amount: 400,
currency_code: "EUR",
price_set_id: "pset_123",
},
],
},
])
```
### Price Calculation Strategy
Retrieve the best price in a given context and for the specified rule values.
```ts
const price = await pricingModuleService.calculatePrices(
{ id: ["pset_123"] },
{
context: {
currency_code: "EUR",
region_id: "reg_123",
},
}
)
```
<CommerceModuleSections name="Pricing" />