c51dce164d
* fixed typedoc plugin's escape strategy * move props comments to the associated property * regenerate references
5930 lines
141 KiB
Plaintext
5930 lines
141 KiB
Plaintext
---
|
|
displayed_sidebar: servicesSidebar
|
|
---
|
|
|
|
import ParameterTypes from "@site/src/components/ParameterTypes"
|
|
|
|
# IPricingModuleService
|
|
|
|
## Methods
|
|
|
|
### addPriceListPrices
|
|
|
|
`**addPriceListPrices**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)[]>`
|
|
|
|
This method is used to add prices to price lists.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function addPriceListPrices (items: {
|
|
priceListId: string,
|
|
prices: {
|
|
currency_code: string,
|
|
amount: number,
|
|
price_set_id: string
|
|
}[]
|
|
}[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceLists = await pricingService.addPriceListPrices(items)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[AddPriceListPricesDTO](AddPriceListPricesDTO.mdx)[]",
|
|
"description": "The prices to add for each price list.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListDTO](PriceListDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListDTO](PriceListDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The updated price lists.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### addPrices
|
|
|
|
`**addPrices**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)>`
|
|
|
|
This method adds prices to a price set.
|
|
|
|
#### Example
|
|
|
|
To add a default price to a price set, don't pass it any rules and make sure to pass it the `currency_code`:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function addPricesToPriceSet (priceSetId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSet = await pricingService.addPrices({
|
|
priceSetId,
|
|
prices: [
|
|
{
|
|
amount: 500,
|
|
currency_code: "USD",
|
|
rules: {},
|
|
},
|
|
],
|
|
})
|
|
|
|
// do something with the price set or return it
|
|
}
|
|
```
|
|
|
|
To add prices with rules:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function addPricesToPriceSet (priceSetId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSet = await pricingService.addPrices({
|
|
priceSetId,
|
|
prices: [
|
|
{
|
|
amount: 300,
|
|
currency_code: "EUR",
|
|
rules: {
|
|
region_id: "PL",
|
|
city: "krakow"
|
|
},
|
|
},
|
|
{
|
|
amount: 400,
|
|
currency_code: "EUR",
|
|
min_quantity: 0,
|
|
max_quantity: 4,
|
|
rules: {
|
|
region_id: "PL"
|
|
},
|
|
},
|
|
{
|
|
amount: 450,
|
|
currency_code: "EUR",
|
|
rules: {
|
|
city: "krakow"
|
|
},
|
|
}
|
|
],
|
|
})
|
|
|
|
// do something with the price set or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[AddPricesDTO](AddPricesDTO.mdx)",
|
|
"description": "The data defining the price set to add the prices to, along with the prices to add.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetDTO](PriceSetDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetDTO](PriceSetDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The price set that the prices were added to.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
`**addPrices**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>`
|
|
|
|
This method adds prices to multiple price sets.
|
|
|
|
#### Example
|
|
|
|
To add a default price to a price set, don't pass it any rules and make sure to pass it the `currency_code`:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function addPricesToPriceSet (priceSetId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSets = await pricingService.addPrices([{
|
|
priceSetId,
|
|
prices: [
|
|
{
|
|
amount: 500,
|
|
currency_code: "USD",
|
|
rules: {},
|
|
},
|
|
],
|
|
}])
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
To add prices with rules:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function addPricesToPriceSet (priceSetId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSets = await pricingService.addPrices([{
|
|
priceSetId,
|
|
prices: [
|
|
{
|
|
amount: 300,
|
|
currency_code: "EUR",
|
|
rules: {
|
|
region_id: "PL",
|
|
city: "krakow"
|
|
},
|
|
},
|
|
{
|
|
amount: 400,
|
|
currency_code: "EUR",
|
|
min_quantity: 0,
|
|
max_quantity: 4,
|
|
rules: {
|
|
region_id: "PL"
|
|
},
|
|
},
|
|
{
|
|
amount: 450,
|
|
currency_code: "EUR",
|
|
rules: {
|
|
city: "krakow"
|
|
},
|
|
}
|
|
],
|
|
}])
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[AddPricesDTO](AddPricesDTO.mdx)[]",
|
|
"description": "The data defining the prices to add per price set.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of the price sets that prices were added to.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### addRules
|
|
|
|
`**addRules**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)>`
|
|
|
|
This method adds rules to a price set.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function addRulesToPriceSet (priceSetId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSet = await pricingService.addRules({
|
|
priceSetId,
|
|
rules: [{
|
|
attribute: "region_id"
|
|
}]
|
|
})
|
|
|
|
// do something with the price set or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[AddRulesDTO](AddRulesDTO.mdx)",
|
|
"description": "The data defining the price set to add the rules to, along with the rules to add.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetDTO](PriceSetDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetDTO](PriceSetDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The price set that the rules were added to.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
`**addRules**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>`
|
|
|
|
This method adds rules to multiple price sets.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function addRulesToPriceSet (priceSetId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSets = await pricingService.addRules([{
|
|
priceSetId,
|
|
rules: [{
|
|
attribute: "region_id"
|
|
}]
|
|
}])
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[AddRulesDTO](AddRulesDTO.mdx)[]",
|
|
"description": "The data defining the rules to add per price set.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of the price sets that the rules were added to.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### calculatePrices
|
|
|
|
`**calculatePrices**(filters, context?, sharedContext?): Promise<[CalculatedPriceSetDTO](CalculatedPriceSetDTO.mdx)>`
|
|
|
|
This method is used to calculate prices based on the provided filters and context.
|
|
|
|
#### Example
|
|
|
|
When you calculate prices, you must at least specify the currency code:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
async function calculatePrice (priceSetId: string, currencyCode: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const price = await pricingService.calculatePrices(
|
|
{ id: [priceSetId] },
|
|
{
|
|
context: {
|
|
currency_code: currencyCode
|
|
}
|
|
}
|
|
)
|
|
|
|
// do something with the price or return it
|
|
}
|
|
```
|
|
|
|
To calculate prices for specific minimum and/or maximum quantity:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
async function calculatePrice (priceSetId: string, currencyCode: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const price = await pricingService.calculatePrices(
|
|
{ id: [priceSetId] },
|
|
{
|
|
context: {
|
|
currency_code: currencyCode,
|
|
min_quantity: 4
|
|
}
|
|
}
|
|
)
|
|
|
|
// do something with the price or return it
|
|
}
|
|
```
|
|
|
|
To calculate prices for custom rule types:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
async function calculatePrice (priceSetId: string, currencyCode: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const price = await pricingService.calculatePrices(
|
|
{ id: [priceSetId] },
|
|
{
|
|
context: {
|
|
currency_code: currencyCode,
|
|
region_id: "US"
|
|
}
|
|
}
|
|
)
|
|
|
|
// do something with the price or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[PricingFilters](PricingFilters.mdx)",
|
|
"description": "The filters to apply on prices.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "context",
|
|
"type": "[PricingContext](PricingContext.mdx)",
|
|
"description": "The context used to select the prices. For example, you can specify the region ID in this context, and only prices having the same value will be retrieved.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[CalculatedPriceSetDTO](CalculatedPriceSetDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[CalculatedPriceSetDTO](CalculatedPriceSetDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The calculated price matching the context and filters provided.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### create
|
|
|
|
`**create**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)>`
|
|
|
|
This method is used to create a new price set.
|
|
|
|
#### Example
|
|
|
|
To create a default price set, don't pass any rules. For example:
|
|
|
|
```ts
|
|
import { initialize as initializePricingModule } from "@medusajs/pricing"
|
|
|
|
async function createPriceSet() {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSet = await pricingService.create({
|
|
rules: [],
|
|
prices: [
|
|
{
|
|
amount: 500,
|
|
currency_code: "USD",
|
|
min_quantity: 0,
|
|
max_quantity: 4,
|
|
rules: {},
|
|
},
|
|
{
|
|
amount: 400,
|
|
currency_code: "USD",
|
|
min_quantity: 5,
|
|
max_quantity: 10,
|
|
rules: {},
|
|
},
|
|
],
|
|
})
|
|
|
|
// do something with the price set or return it
|
|
}
|
|
```
|
|
|
|
To create a price set and associate it with rule types:
|
|
|
|
```ts
|
|
import { initialize as initializePricingModule } from "@medusajs/pricing"
|
|
|
|
async function createPriceSet() {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSet = await pricingService.create({
|
|
rules: [{ rule_attribute: "region_id" }, { rule_attribute: "city" }],
|
|
prices: [
|
|
{
|
|
amount: 300,
|
|
currency_code: "EUR",
|
|
rules: {
|
|
region_id: "PL",
|
|
city: "krakow",
|
|
},
|
|
},
|
|
{
|
|
amount: 400,
|
|
currency_code: "EUR",
|
|
rules: {
|
|
region_id: "PL",
|
|
},
|
|
},
|
|
{
|
|
amount: 450,
|
|
currency_code: "EUR",
|
|
rules: {
|
|
city: "krakow",
|
|
},
|
|
},
|
|
],
|
|
})
|
|
|
|
// do something with the price set or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[CreatePriceSetDTO](CreatePriceSetDTO.mdx)",
|
|
"description": "The attributes of the price set to create.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetDTO](PriceSetDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetDTO](PriceSetDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The created price set.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
`**create**(data, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>`
|
|
|
|
This method is used to create multiple price sets.
|
|
|
|
#### Example
|
|
|
|
To create price sets with a default price, don't pass any rules and make sure to pass the `currency_code` of the price. For example:
|
|
|
|
```ts
|
|
import { initialize as initializePricingModule } from "@medusajs/pricing"
|
|
|
|
async function createPriceSets() {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSets = await pricingService.create([
|
|
{
|
|
rules: [],
|
|
prices: [
|
|
{
|
|
amount: 500,
|
|
currency_code: "USD",
|
|
rules: {},
|
|
},
|
|
],
|
|
},
|
|
])
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
To create price sets and associate them with rule types:
|
|
|
|
```ts
|
|
import { initialize as initializePricingModule } from "@medusajs/pricing"
|
|
|
|
async function createPriceSets() {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSets = await pricingService.create([
|
|
{
|
|
rules: [{ rule_attribute: "region_id" }, { rule_attribute: "city" }],
|
|
prices: [
|
|
{
|
|
amount: 300,
|
|
currency_code: "EUR",
|
|
rules: {
|
|
region_id: "PL",
|
|
city: "krakow",
|
|
},
|
|
},
|
|
{
|
|
amount: 400,
|
|
currency_code: "EUR",
|
|
min_quantity: 0,
|
|
max_quantity: 4,
|
|
rules: {
|
|
region_id: "PL",
|
|
},
|
|
},
|
|
{
|
|
amount: 450,
|
|
currency_code: "EUR",
|
|
rules: {
|
|
city: "krakow",
|
|
},
|
|
},
|
|
],
|
|
},
|
|
])
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[CreatePriceSetDTO](CreatePriceSetDTO.mdx)[]",
|
|
"description": "The price sets to create.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of created price sets.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### createCurrencies
|
|
|
|
`**createCurrencies**(data, sharedContext?): Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>`
|
|
|
|
This method is used to create new currencies.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import { initialize as initializePricingModule } from "@medusajs/pricing"
|
|
|
|
async function createCurrencies() {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const currencies = await pricingService.createCurrencies([
|
|
{
|
|
code: "USD",
|
|
symbol: "$",
|
|
symbol_native: "$",
|
|
name: "US Dollar",
|
|
},
|
|
])
|
|
|
|
// do something with the currencies or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[CreateCurrencyDTO](CreateCurrencyDTO.mdx)[]",
|
|
"description": "The currencies to create.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of created currencies.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### createMoneyAmounts
|
|
|
|
`**createMoneyAmounts**(data, sharedContext?): Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>`
|
|
|
|
This method creates money amounts.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import { initialize as initializePricingModule } from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmounts() {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const moneyAmounts = await pricingService.createMoneyAmounts([
|
|
{
|
|
amount: 500,
|
|
currency_code: "USD",
|
|
},
|
|
{
|
|
amount: 400,
|
|
currency_code: "USD",
|
|
min_quantity: 0,
|
|
max_quantity: 4,
|
|
},
|
|
])
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[CreateMoneyAmountDTO](CreateMoneyAmountDTO.mdx)[]",
|
|
"description": "The money amounts to create.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of created money amounts.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### createPriceListRules
|
|
|
|
`**createPriceListRules**(data, sharedContext?): Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>`
|
|
|
|
This method is used to create price list rules.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function createPriceListRules (items: {
|
|
rule_type_id: string
|
|
price_list_id: string
|
|
}[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceListRules = await pricingService.createPriceListRules(items)
|
|
|
|
// do something with the price list rule or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[CreatePriceListRuleDTO](CreatePriceListRuleDTO.mdx)[]",
|
|
"description": "The price list rules to create.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The created price list rules.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### createPriceLists
|
|
|
|
`**createPriceLists**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)[]>`
|
|
|
|
This method is used to create price lists.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function createPriceList (items: {
|
|
title: string
|
|
description: string
|
|
starts_at?: string
|
|
ends_at?: string
|
|
}[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceList = await pricingService.createPriceLists(items)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[CreatePriceListDTO](CreatePriceListDTO.mdx)[]",
|
|
"description": "The details of each price list to be created.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListDTO](PriceListDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListDTO](PriceListDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The created price lists.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### createPriceRules
|
|
|
|
`**createPriceRules**(data, sharedContext?): Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>`
|
|
|
|
This method is used to create new price rules based on the provided data.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function createPriceRules (
|
|
id: string,
|
|
priceSetId: string,
|
|
ruleTypeId: string,
|
|
value: string,
|
|
priceSetMoneyAmountId: string,
|
|
priceListId: string
|
|
) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceRules = await pricingService.createPriceRules([
|
|
{
|
|
id,
|
|
price_set_id: priceSetId,
|
|
rule_type_id: ruleTypeId,
|
|
value,
|
|
price_set_money_amount_id: priceSetMoneyAmountId,
|
|
price_list_id: priceListId
|
|
}
|
|
])
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[CreatePriceRuleDTO](CreatePriceRuleDTO.mdx)[]",
|
|
"description": "The price rules to create.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of created price rules.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### createPriceSetMoneyAmountRules
|
|
|
|
`**createPriceSetMoneyAmountRules**(data, sharedContext?): Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>`
|
|
|
|
This method is used to create new price set money amount rules. A price set money amount rule creates an association between a price set money amount and
|
|
a rule type.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function createPriceSetMoneyAmountRules (priceSetMoneyAmountId: string, ruleTypeId: string, value: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmountRules = await pricingService.createPriceSetMoneyAmountRules([
|
|
{
|
|
price_set_money_amount: priceSetMoneyAmountId,
|
|
rule_type: ruleTypeId,
|
|
value
|
|
}
|
|
])
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[CreatePriceSetMoneyAmountRulesDTO](CreatePriceSetMoneyAmountRulesDTO.mdx)[]",
|
|
"description": "The price set money amount rules to create.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of created price set money amount rules.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### createRuleTypes
|
|
|
|
`**createRuleTypes**(data, sharedContext?): Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>`
|
|
|
|
This method is used to create new rule types.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import { initialize as initializePricingModule } from "@medusajs/pricing"
|
|
|
|
async function createRuleTypes() {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const ruleTypes = await pricingService.createRuleTypes([
|
|
{
|
|
name: "Region",
|
|
rule_attribute: "region_id",
|
|
},
|
|
])
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[CreateRuleTypeDTO](CreateRuleTypeDTO.mdx)[]",
|
|
"description": "The rule types to create.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of created rule types.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### delete
|
|
|
|
`**delete**(ids, sharedContext?): Promise<void>`
|
|
|
|
This method deletes price sets by their IDs.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function removePriceSetRule (priceSetIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
await pricingService.delete(priceSetIds)
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "ids",
|
|
"type": "`string`[]",
|
|
"description": "The IDs of the price sets to delete.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<void>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<void>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "Resolves when the price sets are successfully deleted.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### deleteCurrencies
|
|
|
|
`**deleteCurrencies**(currencyCodes, sharedContext?): Promise<void>`
|
|
|
|
This method is used to delete currencies based on their currency code.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import { initialize as initializePricingModule } from "@medusajs/pricing"
|
|
|
|
async function deleteCurrencies() {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
await pricingService.deleteCurrencies(["USD"])
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "currencyCodes",
|
|
"type": "`string`[]",
|
|
"description": "Currency codes of the currencies to delete.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<void>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<void>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "Resolves once the currencies are deleted.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### deleteMoneyAmounts
|
|
|
|
`**deleteMoneyAmounts**(ids, sharedContext?): Promise<void>`
|
|
|
|
This method deletes money amounts by their IDs.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function deleteMoneyAmounts (moneyAmountIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
await pricingService.deleteMoneyAmounts(
|
|
moneyAmountIds
|
|
)
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "ids",
|
|
"type": "`string`[]",
|
|
"description": "The IDs of the money amounts to delete.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<void>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<void>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "Resolves when the money amounts are successfully deleted.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### deletePriceListRules
|
|
|
|
`**deletePriceListRules**(priceListRuleIds, sharedContext?): Promise<void>`
|
|
|
|
This method is used to delete price list rules.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function deletePriceListRules (priceListRuleIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
await pricingService.deletePriceListRules(priceListRuleIds)
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "priceListRuleIds",
|
|
"type": "`string`[]",
|
|
"description": "The IDs of the price list rules to delete.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<void>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<void>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "Resolves successfully when the price list rules are deleted.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### deletePriceLists
|
|
|
|
`**deletePriceLists**(priceListIds, sharedContext?): Promise<void>`
|
|
|
|
This method is used to delete price lists.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function deletePriceLists (ids: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
await pricingService.deletePriceLists(ids)
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "priceListIds",
|
|
"type": "`string`[]",
|
|
"description": "The IDs of the price lists to delete.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<void>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<void>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "Resolves when the price lists are deleted successfully.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### deletePriceRules
|
|
|
|
`**deletePriceRules**(priceRuleIds, sharedContext?): Promise<void>`
|
|
|
|
This method is used to delete price rules based on the specified IDs.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function deletePriceRules (
|
|
id: string,
|
|
) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
await pricingService.deletePriceRules([id])
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "priceRuleIds",
|
|
"type": "`string`[]",
|
|
"description": "The IDs of the price rules to delete.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<void>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<void>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "Resolves once the price rules are deleted.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### deletePriceSetMoneyAmountRules
|
|
|
|
`**deletePriceSetMoneyAmountRules**(ids, sharedContext?): Promise<void>`
|
|
|
|
This method is used to delete price set money amount rules based on the specified IDs.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function deletePriceSetMoneyAmountRule (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
await pricingService.deletePriceSetMoneyAmountRules([id])
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "ids",
|
|
"type": "`string`[]",
|
|
"description": "The IDs of the price set money amount rules to delete.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<void>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<void>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "Resolves once the price set money amount rules are deleted.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### deleteRuleTypes
|
|
|
|
`**deleteRuleTypes**(ruleTypeIds, sharedContext?): Promise<void>`
|
|
|
|
This method is used to delete rule types based on the provided IDs.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function deleteRuleTypes (ruleTypeId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
await pricingService.deleteRuleTypes([ruleTypeId])
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "ruleTypeIds",
|
|
"type": "`string`[]",
|
|
"description": "The IDs of the rule types to delete.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<void>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<void>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "Resolves once the rule types are deleted.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### list
|
|
|
|
`**list**(filters?, config?, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>`
|
|
|
|
This method is used to retrieve a paginated list of price sets based on optional filters and configuration.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price sets using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSets (priceSetIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSets = await pricingService.list(
|
|
{
|
|
id: priceSetIds
|
|
},
|
|
)
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price sets:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSets (priceSetIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSets = await pricingService.list(
|
|
{
|
|
id: priceSetIds
|
|
},
|
|
{
|
|
relations: ["money_amounts"]
|
|
}
|
|
)
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSets (priceSetIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSets = await pricingService.list(
|
|
{
|
|
id: priceSetIds
|
|
},
|
|
{
|
|
relations: ["money_amounts"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSets (priceSetIds: string[], moneyAmountIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSets = await pricingService.list(
|
|
{
|
|
$and: [
|
|
{
|
|
id: priceSetIds
|
|
},
|
|
{
|
|
money_amounts: {
|
|
id: moneyAmountIds
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
relations: ["money_amounts"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceSetProps](FilterablePriceSetProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price lists.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceSetDTO](PriceSetDTO.mdx)>",
|
|
"description": "The configurations determining how the price sets are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price set.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetDTO](PriceSetDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price sets.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listAndCount
|
|
|
|
`**listAndCount**(filters?, config?, sharedContext?): Promise<[[PriceSetDTO](PriceSetDTO.mdx)[], number]>`
|
|
|
|
This method is used to retrieve a paginated list of price sets along with the total count of available price sets satisfying the provided filters.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of prices sets using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSets (priceSetIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSets, count] = await pricingService.listAndCount(
|
|
{
|
|
id: priceSetIds
|
|
},
|
|
)
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price sets:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSets (priceSetIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSets, count] = await pricingService.listAndCount(
|
|
{
|
|
id: priceSetIds
|
|
},
|
|
{
|
|
relations: ["money_amounts"]
|
|
}
|
|
)
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSets (priceSetIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSets, count] = await pricingService.listAndCount(
|
|
{
|
|
id: priceSetIds
|
|
},
|
|
{
|
|
relations: ["money_amounts"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSets (priceSetIds: string[], moneyAmountIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSets, count] = await pricingService.listAndCount(
|
|
{
|
|
$and: [
|
|
{
|
|
id: priceSetIds
|
|
},
|
|
{
|
|
money_amounts: {
|
|
id: moneyAmountIds
|
|
}
|
|
}
|
|
]
|
|
},
|
|
{
|
|
relations: ["money_amounts"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price sets or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceSetProps](FilterablePriceSetProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price lists.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceSetDTO](PriceSetDTO.mdx)>",
|
|
"description": "The configurations determining how the price sets are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price set.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[[PriceSetDTO](PriceSetDTO.mdx)[], number]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[[PriceSetDTO](PriceSetDTO.mdx)[], number]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price sets along with their total count.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listAndCountCurrencies
|
|
|
|
`**listAndCountCurrencies**(filters?, config?, sharedContext?): Promise<[[CurrencyDTO](CurrencyDTO.mdx)[], number]>`
|
|
|
|
This method is used to retrieve a paginated list of currencies along with the total count of available currencies satisfying the provided filters.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of currencies using their codes:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveCurrencies (codes: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [currencies, count] = await pricingService.listAndCountCurrencies(
|
|
{
|
|
code: codes
|
|
},
|
|
)
|
|
|
|
// do something with the currencies or return them
|
|
}
|
|
```
|
|
|
|
To specify attributes that should be retrieved within the money amounts:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveCurrencies (codes: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [currencies, count] = await pricingService.listAndCountCurrencies(
|
|
{
|
|
code: codes
|
|
},
|
|
{
|
|
select: ["symbol_native"]
|
|
}
|
|
)
|
|
|
|
// do something with the currencies or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveCurrencies (codes: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [currencies, count] = await pricingService.listAndCountCurrencies(
|
|
{
|
|
code: codes
|
|
},
|
|
{
|
|
select: ["symbol_native"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the currencies or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterableCurrencyProps](FilterableCurrencyProps.mdx)",
|
|
"description": "The filters to apply on the retrieved currencies.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[CurrencyDTO](CurrencyDTO.mdx)>",
|
|
"description": "The configurations determining how the currencies are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a currency.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[[CurrencyDTO](CurrencyDTO.mdx)[], number]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[[CurrencyDTO](CurrencyDTO.mdx)[], number]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of currencies along with the total count.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listAndCountMoneyAmounts
|
|
|
|
`**listAndCountMoneyAmounts**(filters?, config?, sharedContext?): Promise<[[MoneyAmountDTO](MoneyAmountDTO.mdx)[], number]>`
|
|
|
|
This method is used to retrieve a paginated list of money amounts along with the total count of available money amounts satisfying the provided filters.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of money amounts using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmounts (moneyAmountIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [moneyAmounts, count] = await pricingService.listAndCountMoneyAmounts(
|
|
{
|
|
id: moneyAmountIds
|
|
}
|
|
)
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the money amounts:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmounts (moneyAmountIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [moneyAmounts, count] = await pricingService.listAndCountMoneyAmounts(
|
|
{
|
|
id: moneyAmountIds
|
|
},
|
|
{
|
|
relations: ["currency"]
|
|
}
|
|
)
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmounts (moneyAmountIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [moneyAmounts, count] = await pricingService.listAndCountMoneyAmounts(
|
|
{
|
|
id: moneyAmountIds
|
|
},
|
|
{
|
|
relations: ["currency"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmounts (moneyAmountIds: string[], currencyCode: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [moneyAmounts, count] = await pricingService.listAndCountMoneyAmounts(
|
|
{
|
|
$and: [
|
|
{
|
|
id: moneyAmountIds
|
|
},
|
|
{
|
|
currency_code: currencyCode
|
|
}
|
|
]
|
|
},
|
|
{
|
|
relations: ["currency"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterableMoneyAmountProps](FilterableMoneyAmountProps.mdx)",
|
|
"description": "The filters to apply on the retrieved money amounts.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[MoneyAmountDTO](MoneyAmountDTO.mdx)>",
|
|
"description": "The configurations determining how the money amounts are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a money amount.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[[MoneyAmountDTO](MoneyAmountDTO.mdx)[], number]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[[MoneyAmountDTO](MoneyAmountDTO.mdx)[], number]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of money amounts along with their total count.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listAndCountPriceListRules
|
|
|
|
`**listAndCountPriceListRules**(filters?, config?, sharedContext?): Promise<[[PriceListRuleDTO](PriceListRuleDTO.mdx)[], number]>`
|
|
|
|
This method is used to retrieve a paginated list of price list ruless along with the total count of available price list ruless satisfying the provided filters.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price list vs using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listAndCountPriceListRules (priceListRuleIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceListRules, count] = await pricingService.listAndCountPriceListRules(
|
|
{
|
|
id: priceListRuleIds
|
|
},
|
|
)
|
|
|
|
// do something with the price list rules or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price list rules:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listAndCountPriceListRules (priceListRuleIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceListRules, count] = await pricingService.listAndCountPriceListRules(
|
|
{
|
|
id: priceListRuleIds
|
|
},
|
|
{
|
|
relations: ["price_list_rule_values"]
|
|
}
|
|
)
|
|
|
|
// do something with the price list rules or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listAndCountPriceListRules (priceListRuleIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceListRules, count] = await pricingService.listAndCountPriceListRules(
|
|
{
|
|
id: priceListRuleIds
|
|
},
|
|
{
|
|
relations: ["price_list_rule_values"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price list rules or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listAndCountPriceListRules (priceListRuleIds: string[], ruleTypeIDs: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceListRules, count] = await pricingService.listAndCountPriceListRules(
|
|
{
|
|
$and: [
|
|
{
|
|
id: priceListRuleIds
|
|
},
|
|
{
|
|
rule_types: ruleTypeIDs
|
|
}
|
|
]
|
|
},
|
|
{
|
|
relations: ["price_list_rule_values"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price list rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceListRuleProps](FilterablePriceListRuleProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price list rules.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceListRuleDTO](PriceListRuleDTO.mdx)>",
|
|
"description": "The configurations determining how the price list rules are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price list rule.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[[PriceListRuleDTO](PriceListRuleDTO.mdx)[], number]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[[PriceListRuleDTO](PriceListRuleDTO.mdx)[], number]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price list rules along with their total count.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listAndCountPriceLists
|
|
|
|
`**listAndCountPriceLists**(filters?, config?, sharedContext?): Promise<[[PriceListDTO](PriceListDTO.mdx)[], number]>`
|
|
|
|
This method is used to retrieve a paginated list of price lists along with the total count of available price lists satisfying the provided filters.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price lists using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceLists (priceListIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceLists, count] = await pricingService.listPriceLists(
|
|
{
|
|
id: priceListIds
|
|
},
|
|
)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price lists:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceLists (priceListIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceLists, count] = await pricingService.listPriceLists(
|
|
{
|
|
id: priceListIds
|
|
},
|
|
{
|
|
relations: ["price_set_money_amounts"]
|
|
}
|
|
)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceLists (priceListIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceLists, count] = await pricingService.listPriceLists(
|
|
{
|
|
id: priceListIds
|
|
},
|
|
{
|
|
relations: ["price_set_money_amounts"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceLists (priceListIds: string[], titles: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceLists, count] = await pricingService.listPriceLists(
|
|
{
|
|
$and: [
|
|
{
|
|
id: priceListIds
|
|
},
|
|
{
|
|
title: titles
|
|
}
|
|
]
|
|
},
|
|
{
|
|
relations: ["price_set_money_amounts"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceListProps](FilterablePriceListProps-1.mdx)",
|
|
"description": "The filters to apply on the retrieved price lists.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceListDTO](PriceListDTO.mdx)>",
|
|
"description": "The configurations determining how the price lists are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price list.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[[PriceListDTO](PriceListDTO.mdx)[], number]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[[PriceListDTO](PriceListDTO.mdx)[], number]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price lists along with their total count.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listAndCountPriceRules
|
|
|
|
`**listAndCountPriceRules**(filters?, config?, sharedContext?): Promise<[[PriceRuleDTO](PriceRuleDTO.mdx)[], number]>`
|
|
|
|
This method is used to retrieve a paginated list of price rules along with the total count of available price rules satisfying the provided filters.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price rules using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRules (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceRules, count] = await pricingService.listAndCountPriceRules({
|
|
id: [id]
|
|
})
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price rules:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRules (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceRules, count] = await pricingService.listAndCountPriceRules({
|
|
id: [id],
|
|
}, {
|
|
relations: ["price_set"]
|
|
})
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRules (id: string, skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceRules, count] = await pricingService.listAndCountPriceRules({
|
|
id: [id],
|
|
}, {
|
|
relations: ["price_set"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRules (ids: string[], name: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceRules, count] = await pricingService.listAndCountPriceRules({
|
|
$and: [
|
|
{
|
|
id: ids
|
|
},
|
|
{
|
|
name
|
|
}
|
|
]
|
|
}, {
|
|
relations: ["price_set"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceRuleProps](FilterablePriceRuleProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price rules.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceRuleDTO](PriceRuleDTO.mdx)>",
|
|
"description": "The configurations determining how the price rule is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price rule.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[[PriceRuleDTO](PriceRuleDTO.mdx)[], number]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[[PriceRuleDTO](PriceRuleDTO.mdx)[], number]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price rules along with their total count.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listAndCountPriceSetMoneyAmountRules
|
|
|
|
`**listAndCountPriceSetMoneyAmountRules**(filters?, config?, sharedContext?): Promise<[[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[], number]>`
|
|
|
|
This method is used to retrieve a paginated list of price set money amount rules along with the total count of
|
|
available price set money amount rules satisfying the provided filters.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price set money amounts using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRules (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSetMoneyAmountRules, count] = await pricingService.listAndCountPriceSetMoneyAmountRules({
|
|
id: [id]
|
|
})
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price set money amount rules:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRules (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSetMoneyAmountRules, count] = await pricingService.listAndCountPriceSetMoneyAmountRules({
|
|
id: [id]
|
|
}, {
|
|
relations: ["price_set_money_amount"],
|
|
})
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRules (id: string, skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSetMoneyAmountRules, count] = await pricingService.listAndCountPriceSetMoneyAmountRules({
|
|
id: [id]
|
|
}, {
|
|
relations: ["price_set_money_amount"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRules (ids: string[], ruleTypeId: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSetMoneyAmountRules, count] = await pricingService.listAndCountPriceSetMoneyAmountRules({
|
|
$and: [
|
|
{
|
|
id: ids
|
|
},
|
|
{
|
|
rule_type_id: ruleTypeId
|
|
}
|
|
]
|
|
}, {
|
|
relations: ["price_set_money_amount"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceSetMoneyAmountRulesProps](FilterablePriceSetMoneyAmountRulesProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price set money amount rules.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)>",
|
|
"description": "The configurations determining how the price set money amount rules are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price set money amount rule.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[], number]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[], number]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price set money amount rules and their total count.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listAndCountPriceSetMoneyAmounts
|
|
|
|
`**listAndCountPriceSetMoneyAmounts**(filters?, config?, sharedContext?): Promise<[[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[], number]>`
|
|
|
|
This method is used to retrieve a paginated list of price set money amounts along with the total count of
|
|
available price set money amounts satisfying the provided filters.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price set money amounts using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmounts (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSetMoneyAmounts, count] = await pricingService.listAndCountPriceSetMoneyAmounts({
|
|
id: [id]
|
|
})
|
|
|
|
// do something with the price set money amounts or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price set money amounts:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmounts (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSetMoneyAmounts, count] = await pricingService.listAndCountPriceSetMoneyAmounts({
|
|
id: [id]
|
|
}, {
|
|
relations: ["price_rules"],
|
|
})
|
|
|
|
// do something with the price set money amounts or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmounts (id: string, skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSetMoneyAmounts, count] = await pricingService.listAndCountPriceSetMoneyAmounts({
|
|
id: [id]
|
|
}, {
|
|
relations: ["price_rules"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price set money amounts or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmounts (ids: string[], titles: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [priceSetMoneyAmounts, count] = await pricingService.listAndCountPriceSetMoneyAmounts({
|
|
$and: [
|
|
{
|
|
id: ids
|
|
},
|
|
{
|
|
title: titles
|
|
}
|
|
]
|
|
}, {
|
|
relations: ["price_rules"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price set money amounts or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceSetMoneyAmountProps](FilterablePriceSetMoneyAmountProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price set money amounts.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)>",
|
|
"description": "The configurations determining how the price set money amounts are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price set money amount.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[], number]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[], number]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price set money amounts and their total count.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listAndCountRuleTypes
|
|
|
|
`**listAndCountRuleTypes**(filters?, config?, sharedContext?): Promise<[[RuleTypeDTO](RuleTypeDTO.mdx)[], number]>`
|
|
|
|
This method is used to retrieve a paginated list of rule types along with the total count of available rule types satisfying the provided filters.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of rule types using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleTypes (ruleTypeId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [ruleTypes, count] = await pricingService.listAndCountRuleTypes({
|
|
id: [
|
|
ruleTypeId
|
|
]
|
|
})
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
To specify attributes that should be retrieved within the rule types:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleTypes (ruleTypeId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [ruleTypes, count] = await pricingService.listAndCountRuleTypes({
|
|
id: [
|
|
ruleTypeId
|
|
]
|
|
}, {
|
|
select: ["name"]
|
|
})
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleTypes (ruleTypeId: string, skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [ruleTypes, count] = await pricingService.listAndCountRuleTypes({
|
|
id: [
|
|
ruleTypeId
|
|
]
|
|
}, {
|
|
select: ["name"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleTypes (ruleTypeId: string[], name: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const [ruleTypes, count] = await pricingService.listAndCountRuleTypes({
|
|
$and: [
|
|
{
|
|
id: ruleTypeId
|
|
},
|
|
{
|
|
name
|
|
}
|
|
]
|
|
}, {
|
|
select: ["name"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterableRuleTypeProps](FilterableRuleTypeProps.mdx)",
|
|
"description": "The filters to apply on the retrieved rule types.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[RuleTypeDTO](RuleTypeDTO.mdx)>",
|
|
"description": "The configurations determining how the rule types are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a rule type.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[[RuleTypeDTO](RuleTypeDTO.mdx)[], number]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[[RuleTypeDTO](RuleTypeDTO.mdx)[], number]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of rule types along with their total count.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listCurrencies
|
|
|
|
`**listCurrencies**(filters?, config?, sharedContext?): Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>`
|
|
|
|
This method is used to retrieve a paginated list of currencies based on optional filters and configuration.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of currencies using their codes:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveCurrencies (codes: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const currencies = await pricingService.listCurrencies(
|
|
{
|
|
code: codes
|
|
},
|
|
)
|
|
|
|
// do something with the currencies or return them
|
|
}
|
|
```
|
|
|
|
To specify attributes that should be retrieved within the money amounts:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveCurrencies (codes: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const currencies = await pricingService.listCurrencies(
|
|
{
|
|
code: codes
|
|
},
|
|
{
|
|
select: ["symbol_native"]
|
|
}
|
|
)
|
|
|
|
// do something with the currencies or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveCurrencies (codes: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const currencies = await pricingService.listCurrencies(
|
|
{
|
|
code: codes
|
|
},
|
|
{
|
|
select: ["symbol_native"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the currencies or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterableCurrencyProps](FilterableCurrencyProps.mdx)",
|
|
"description": "The filters to apply on the retrieved currencies.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[CurrencyDTO](CurrencyDTO.mdx)>",
|
|
"description": "The configurations determining how the currencies are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a currency.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of currencies.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listMoneyAmounts
|
|
|
|
`**listMoneyAmounts**(filters?, config?, sharedContext?): Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>`
|
|
|
|
This method is used to retrieve a paginated list of money amounts based on optional filters and configuration.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of money amounts using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmounts (moneyAmountIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const moneyAmounts = await pricingService.listMoneyAmounts(
|
|
{
|
|
id: moneyAmountIds
|
|
}
|
|
)
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the money amounts:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmounts (moneyAmountIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const moneyAmounts = await pricingService.listMoneyAmounts(
|
|
{
|
|
id: moneyAmountIds
|
|
},
|
|
{
|
|
relations: ["currency"]
|
|
}
|
|
)
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmounts (moneyAmountIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const moneyAmounts = await pricingService.listMoneyAmounts(
|
|
{
|
|
id: moneyAmountIds
|
|
},
|
|
{
|
|
relations: ["currency"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmounts (moneyAmountIds: string[], currencyCode: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const moneyAmounts = await pricingService.listMoneyAmounts(
|
|
{
|
|
$and: [
|
|
{
|
|
id: moneyAmountIds
|
|
},
|
|
{
|
|
currency_code: currencyCode
|
|
}
|
|
]
|
|
},
|
|
{
|
|
relations: ["currency"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterableMoneyAmountProps](FilterableMoneyAmountProps.mdx)",
|
|
"description": "The filtes to apply on the retrieved money amounts.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[MoneyAmountDTO](MoneyAmountDTO.mdx)>",
|
|
"description": "The configurations determining how the money amounts are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a money amount.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of money amounts.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listPriceListRules
|
|
|
|
`**listPriceListRules**(filters?, config?, sharedContext?): Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>`
|
|
|
|
This method is used to retrieve a paginated list of price list rules based on optional filters and configuration.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price list vs using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listPriceListRules (priceListRuleIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceListRules = await pricingService.listPriceListRules(
|
|
{
|
|
id: priceListRuleIds
|
|
},
|
|
)
|
|
|
|
// do something with the price list rules or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price list rules:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listPriceListRules (priceListRuleIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceListRules = await pricingService.listPriceListRules(
|
|
{
|
|
id: priceListRuleIds
|
|
},
|
|
{
|
|
relations: ["price_list_rule_values"]
|
|
}
|
|
)
|
|
|
|
// do something with the price list rules or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listPriceListRules (priceListRuleIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceListRules = await pricingService.listPriceListRules(
|
|
{
|
|
id: priceListRuleIds
|
|
},
|
|
{
|
|
relations: ["price_list_rule_values"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price list rules or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listPriceListRules (priceListRuleIds: string[], ruleTypeIDs: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceListRules = await pricingService.listPriceListRules(
|
|
{
|
|
$and: [
|
|
{
|
|
id: priceListRuleIds
|
|
},
|
|
{
|
|
rule_types: ruleTypeIDs
|
|
}
|
|
]
|
|
},
|
|
{
|
|
relations: ["price_list_rule_values"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price list rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceListRuleProps](FilterablePriceListRuleProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price list rules.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceListRuleDTO](PriceListRuleDTO.mdx)>",
|
|
"description": "The configurations determining how the price list rules are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price list rule.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price list rules.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listPriceLists
|
|
|
|
`**listPriceLists**(filters?, config?, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)[]>`
|
|
|
|
This method is used to retrieve a paginated list of price lists based on optional filters and configuration.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price lists using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listPriceLists (priceListIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceLists = await pricingService.listPriceLists(
|
|
{
|
|
id: priceListIds
|
|
},
|
|
)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price lists:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listPriceLists (priceListIds: string[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceLists = await pricingService.listPriceLists(
|
|
{
|
|
id: priceListIds
|
|
},
|
|
{
|
|
relations: ["price_set_money_amounts"]
|
|
}
|
|
)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listPriceLists (priceListIds: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceLists = await pricingService.listPriceLists(
|
|
{
|
|
id: priceListIds
|
|
},
|
|
{
|
|
relations: ["price_set_money_amounts"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function listPriceLists (priceListIds: string[], titles: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceLists = await pricingService.listPriceLists(
|
|
{
|
|
$and: [
|
|
{
|
|
id: priceListIds
|
|
},
|
|
{
|
|
title: titles
|
|
}
|
|
]
|
|
},
|
|
{
|
|
relations: ["price_set_money_amounts"],
|
|
skip,
|
|
take
|
|
}
|
|
)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceListProps](FilterablePriceListProps-1.mdx)",
|
|
"description": "The filters to apply on the retrieved price lists.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceListDTO](PriceListDTO.mdx)>",
|
|
"description": "The configurations determining how the price lists are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price list.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListDTO](PriceListDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListDTO](PriceListDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price lists.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listPriceRules
|
|
|
|
`**listPriceRules**(filters?, config?, sharedContext?): Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>`
|
|
|
|
This method is used to retrieve a paginated list of price rules based on optional filters and configuration.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price rules using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRules (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceRules = await pricingService.listPriceRules({
|
|
id: [id]
|
|
})
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price rules:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRules (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceRules = await pricingService.listPriceRules({
|
|
id: [id],
|
|
}, {
|
|
relations: ["price_set"]
|
|
})
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRules (id: string, skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceRules = await pricingService.listPriceRules({
|
|
id: [id],
|
|
}, {
|
|
relations: ["price_set"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRules (ids: string[], name: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceRules = await pricingService.listPriceRules({
|
|
$and: [
|
|
{
|
|
id: ids
|
|
},
|
|
{
|
|
name
|
|
}
|
|
]
|
|
}, {
|
|
relations: ["price_set"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceRuleProps](FilterablePriceRuleProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price rules.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceRuleDTO](PriceRuleDTO.mdx)>",
|
|
"description": "The configurations determining how the price rule is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price rule.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price rules.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listPriceSetMoneyAmountRules
|
|
|
|
`**listPriceSetMoneyAmountRules**(filters?, config?, sharedContext?): Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>`
|
|
|
|
This method is used to retrieve a paginated list of price set money amount rules based on optional filters and configuration.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price set money amount rules using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRules (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmountRules = await pricingService.listPriceSetMoneyAmountRules({
|
|
id: [id]
|
|
})
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price set money amount rules:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRules (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmountRules = await pricingService.listPriceSetMoneyAmountRules({
|
|
id: [id]
|
|
}, {
|
|
relations: ["price_set_money_amount"]
|
|
})
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRules (id: string, skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmountRules = await pricingService.listPriceSetMoneyAmountRules({
|
|
id: [id]
|
|
}, {
|
|
relations: ["price_set_money_amount"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRules (ids: string[], ruleTypeId: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmountRules = await pricingService.listPriceSetMoneyAmountRules({
|
|
$and: [
|
|
{
|
|
id: ids
|
|
},
|
|
{
|
|
rule_type_id: ruleTypeId
|
|
}
|
|
]
|
|
}, {
|
|
relations: ["price_set_money_amount"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceSetMoneyAmountRulesProps](FilterablePriceSetMoneyAmountRulesProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price set money amount rules.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)>",
|
|
"description": "The configurations determining how the price set money amount rules are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price set money amount rule.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price set money amount rules.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listPriceSetMoneyAmounts
|
|
|
|
`**listPriceSetMoneyAmounts**(filters?, config?, sharedContext?): Promise<[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[]>`
|
|
|
|
This method is used to retrieve a paginated list of price set money amounts based on optional filters and configuration.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of price set money amounts using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmounts (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmounts = await pricingService.listPriceSetMoneyAmounts({
|
|
id: [id]
|
|
})
|
|
|
|
// do something with the price set money amounts or return them
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved within the price set money amounts:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmounts (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmounts = await pricingService.listPriceSetMoneyAmounts({
|
|
id: [id]
|
|
}, {
|
|
relations: ["price_rules"]
|
|
})
|
|
|
|
// do something with the price set money amounts or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmounts (id: string, skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmounts = await pricingService.listPriceSetMoneyAmounts({
|
|
id: [id]
|
|
}, {
|
|
relations: ["price_rules"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price set money amounts or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmounts (ids: string[], titles: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmounts = await pricingService.listPriceSetMoneyAmounts({
|
|
$and: [
|
|
{
|
|
id: ids
|
|
},
|
|
{
|
|
title: titles
|
|
}
|
|
]
|
|
}, {
|
|
relations: ["price_rules"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the price set money amounts or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterablePriceSetMoneyAmountProps](FilterablePriceSetMoneyAmountProps.mdx)",
|
|
"description": "The filters to apply on the retrieved price set money amounts.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)>",
|
|
"description": "The configurations determining how the price set money amounts are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price set money amount.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetMoneyAmountDTO](PriceSetMoneyAmountDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of price set money amounts.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### listRuleTypes
|
|
|
|
`**listRuleTypes**(filters?, config?, sharedContext?): Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>`
|
|
|
|
This method is used to retrieve a paginated list of rule types based on optional filters and configuration.
|
|
|
|
#### Example
|
|
|
|
To retrieve a list of rule types using their IDs:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleTypes (ruleTypeId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const ruleTypes = await pricingService.listRuleTypes({
|
|
id: [
|
|
ruleTypeId
|
|
]
|
|
})
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
To specify attributes that should be retrieved within the rule types:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleTypes (ruleTypeId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const ruleTypes = await pricingService.listRuleTypes({
|
|
id: [
|
|
ruleTypeId
|
|
]
|
|
}, {
|
|
select: ["name"]
|
|
})
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
By default, only the first `15` records are retrieved. You can control pagination by specifying the `skip` and `take` properties of the `config` parameter:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleTypes (ruleTypeId: string, skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const ruleTypes = await pricingService.listRuleTypes({
|
|
id: [
|
|
ruleTypeId
|
|
]
|
|
}, {
|
|
select: ["name"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
You can also use the `$and` or `$or` properties of the `filter` parameter to use and/or conditions in your filters. For example:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleTypes (ruleTypeId: string[], name: string[], skip: number, take: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const ruleTypes = await pricingService.listRuleTypes({
|
|
$and: [
|
|
{
|
|
id: ruleTypeId
|
|
},
|
|
{
|
|
name
|
|
}
|
|
]
|
|
}, {
|
|
select: ["name"],
|
|
skip,
|
|
take
|
|
})
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "filters",
|
|
"type": "[FilterableRuleTypeProps](FilterableRuleTypeProps.mdx)",
|
|
"description": "The filters to apply on the retrieved rule types.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[RuleTypeDTO](RuleTypeDTO.mdx)>",
|
|
"description": "The configurations determining how the rule types are retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a rule type.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of rule types.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### removePriceListRules
|
|
|
|
`**removePriceListRules**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)>`
|
|
|
|
This method is used to remove rules from a price list.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function setPriceListRules (priceListId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceList = await pricingService.removePriceListRules({
|
|
priceListId,
|
|
rules: ["region_id"]
|
|
})
|
|
|
|
// do something with the price list or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[RemovePriceListRulesDTO](RemovePriceListRulesDTO.mdx)",
|
|
"description": "The rules to remove from a price list.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListDTO](PriceListDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListDTO](PriceListDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The updated price lists.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### removeRules
|
|
|
|
`**removeRules**(data, sharedContext?): Promise<void>`
|
|
|
|
This method remove rules from a price set.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function removePriceSetRule (priceSetId: string, ruleAttributes: []) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
await pricingService.removeRules([
|
|
{
|
|
id: priceSetId,
|
|
rules: ruleAttributes
|
|
},
|
|
])
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[RemovePriceSetRulesDTO](RemovePriceSetRulesDTO.mdx)[]",
|
|
"description": "The rules to remove per price set.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<void>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<void>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "Resolves when rules are successfully removed.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### retrieve
|
|
|
|
`**retrieve**(id, config?, sharedContext?): Promise<[PriceSetDTO](PriceSetDTO.mdx)>`
|
|
|
|
This method is used to retrieve a price set by its ID.
|
|
|
|
#### Example
|
|
|
|
A simple example that retrieves a price set by its ID:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSet (priceSetId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSet = await pricingService.retrieve(
|
|
priceSetId
|
|
)
|
|
|
|
// do something with the price set or return it
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSet (priceSetId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSet = await pricingService.retrieve(
|
|
priceSetId,
|
|
{
|
|
relations: ["money_amounts"]
|
|
}
|
|
)
|
|
|
|
// do something with the price set or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "id",
|
|
"type": "`string`",
|
|
"description": "The ID of the price set to retrieve.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceSetDTO](PriceSetDTO.mdx)>",
|
|
"description": "The configurations determining how the price set is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price set.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetDTO](PriceSetDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetDTO](PriceSetDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The retrieved price set.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### retrieveCurrency
|
|
|
|
`**retrieveCurrency**(code, config?, sharedContext?): Promise<[CurrencyDTO](CurrencyDTO.mdx)>`
|
|
|
|
This method retrieves a currency by its code and and optionally based on the provided configurations.
|
|
|
|
#### Example
|
|
|
|
A simple example that retrieves a currency by its code:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveCurrency (code: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const currency = await pricingService.retrieveCurrency(
|
|
code
|
|
)
|
|
|
|
// do something with the currency or return it
|
|
}
|
|
```
|
|
|
|
To specify attributes that should be retrieved:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveCurrency (code: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const currency = await pricingService.retrieveCurrency(
|
|
code,
|
|
{
|
|
select: ["symbol_native"]
|
|
}
|
|
)
|
|
|
|
// do something with the currency or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "code",
|
|
"type": "`string`",
|
|
"description": "The code of the currency to retrieve.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[CurrencyDTO](CurrencyDTO.mdx)>",
|
|
"description": "The configurations determining how the currency is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a currency.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[CurrencyDTO](CurrencyDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[CurrencyDTO](CurrencyDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The retrieved currency.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### retrieveMoneyAmount
|
|
|
|
`**retrieveMoneyAmount**(id, config?, sharedContext?): Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)>`
|
|
|
|
This method retrieves a money amount by its ID.
|
|
|
|
#### Example
|
|
|
|
To retrieve a money amount by its ID:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmount (moneyAmountId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const moneyAmount = await pricingService.retrieveMoneyAmount(
|
|
moneyAmountId,
|
|
)
|
|
|
|
// do something with the money amount or return it
|
|
}
|
|
```
|
|
|
|
To retrieve relations along with the money amount:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveMoneyAmount (moneyAmountId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const moneyAmount = await pricingService.retrieveMoneyAmount(
|
|
moneyAmountId,
|
|
{
|
|
relations: ["currency"]
|
|
}
|
|
)
|
|
|
|
// do something with the money amount or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "id",
|
|
"type": "`string`",
|
|
"description": "The ID of the money amount to retrieve.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[MoneyAmountDTO](MoneyAmountDTO.mdx)>",
|
|
"description": "The configurations determining how a money amount is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a money amount.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The retrieved money amount.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### retrievePriceList
|
|
|
|
`**retrievePriceList**(id, config?, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)>`
|
|
|
|
This method is used to retrieve a price list by its ID.
|
|
|
|
#### Example
|
|
|
|
A simple example that retrieves a price list by its ID:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceList (priceListId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceList = await pricingService.retrievePriceList(
|
|
priceListId
|
|
)
|
|
|
|
// do something with the price list or return it
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceList (priceListId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceList = await pricingService.retrievePriceList(
|
|
priceListId,
|
|
{
|
|
relations: ["price_set_money_amounts"]
|
|
}
|
|
)
|
|
|
|
// do something with the price list or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "id",
|
|
"type": "`string`",
|
|
"description": "The ID of the price list to retrieve.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceListDTO](PriceListDTO.mdx)>",
|
|
"description": "The configurations determining how the price list is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price list.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListDTO](PriceListDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListDTO](PriceListDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The retrieved price list.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### retrievePriceListRule
|
|
|
|
`**retrievePriceListRule**(id, config?, sharedContext?): Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)>`
|
|
|
|
This method is used to retrieve a price list rule by its ID.
|
|
|
|
#### Example
|
|
|
|
A simple example that retrieves a price list rule by its ID:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceListRule (priceListRuleId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceListRule = await pricingService.retrievePriceListRule(
|
|
priceListRuleId
|
|
)
|
|
|
|
// do something with the price list rule or return it
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceListRule (priceListRuleId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceListRule = await pricingService.retrievePriceListRule(
|
|
priceListRuleId,
|
|
{
|
|
relations: ["price_list"]
|
|
}
|
|
)
|
|
|
|
// do something with the price list rule or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "id",
|
|
"type": "`string`",
|
|
"description": "The ID of the price list rule to retrieve.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceListRuleDTO](PriceListRuleDTO.mdx)>",
|
|
"description": "The configurations determining how the price list rule is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price list rule.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The retrieved price list rule.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### retrievePriceRule
|
|
|
|
`**retrievePriceRule**(id, config?, sharedContext?): Promise<[PriceRuleDTO](PriceRuleDTO.mdx)>`
|
|
|
|
This method is used to retrieve a price rule by its ID.
|
|
|
|
#### Example
|
|
|
|
A simple example that retrieves a price rule by its ID:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRule (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceRule = await pricingService.retrievePriceRule(id)
|
|
|
|
// do something with the price rule or return it
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceRule (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceRule = await pricingService.retrievePriceRule(id, {
|
|
relations: ["price_set"]
|
|
})
|
|
|
|
// do something with the price rule or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "id",
|
|
"type": "`string`",
|
|
"description": "The ID of the price rule to retrieve.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceRuleDTO](PriceRuleDTO.mdx)>",
|
|
"description": "The configurations determining how the price rule is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price rule.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceRuleDTO](PriceRuleDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceRuleDTO](PriceRuleDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The retrieved price rule.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### retrievePriceSetMoneyAmountRules
|
|
|
|
`**retrievePriceSetMoneyAmountRules**(id, config?, sharedContext?): Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)>`
|
|
|
|
This method is used to a price set money amount rule by its ID based on the provided configuration.
|
|
|
|
#### Example
|
|
|
|
A simple example that retrieves a price set money amount rule by its ID:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRule (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmountRule = await pricingService.retrievePriceSetMoneyAmountRules(id)
|
|
|
|
// do something with the price set money amount rule or return it
|
|
}
|
|
```
|
|
|
|
To specify relations that should be retrieved:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrievePriceSetMoneyAmountRule (id: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmountRule = await pricingService.retrievePriceSetMoneyAmountRules(id, {
|
|
relations: ["price_set_money_amount"]
|
|
})
|
|
|
|
// do something with the price set money amount rule or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "id",
|
|
"type": "`string`",
|
|
"description": "The ID of the price set money amount rule to retrieve.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)>",
|
|
"description": "The configurations determining how the price set money amount rule is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a price set money amount rule.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The retrieved price set money amount rule.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### retrieveRuleType
|
|
|
|
`**retrieveRuleType**(id, config?, sharedContext?): Promise<[RuleTypeDTO](RuleTypeDTO.mdx)>`
|
|
|
|
This method is used to retrieve a rule type by its ID and and optionally based on the provided configurations.
|
|
|
|
#### Example
|
|
|
|
A simple example that retrieves a rule type by its code:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleType (ruleTypeId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const ruleType = await pricingService.retrieveRuleType(ruleTypeId)
|
|
|
|
// do something with the rule type or return it
|
|
}
|
|
```
|
|
|
|
To specify attributes that should be retrieved:
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function retrieveRuleType (ruleTypeId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const ruleType = await pricingService.retrieveRuleType(ruleTypeId, {
|
|
select: ["name"]
|
|
})
|
|
|
|
// do something with the rule type or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "id",
|
|
"type": "`string`",
|
|
"description": "The ID of the rule type to retrieve.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "config",
|
|
"type": "[FindConfig](FindConfig-1.mdx)<[RuleTypeDTO](RuleTypeDTO.mdx)>",
|
|
"description": "The configurations determining how the rule type is retrieved. Its properties, such as `select` or `relations`, accept the attributes or relations associated with a rule type.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[RuleTypeDTO](RuleTypeDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[RuleTypeDTO](RuleTypeDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The retrieved rule type.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### setPriceListRules
|
|
|
|
`**setPriceListRules**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)>`
|
|
|
|
This method is used to set the rules of a price list.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function setPriceListRules (priceListId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceList = await pricingService.setPriceListRules({
|
|
priceListId,
|
|
rules: {
|
|
region_id: "US"
|
|
}
|
|
})
|
|
|
|
// do something with the price list or return it
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[SetPriceListRulesDTO](SetPriceListRulesDTO.mdx)",
|
|
"description": "The rules to set for a price list.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListDTO](PriceListDTO.mdx)>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListDTO](PriceListDTO.mdx)>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The updated price lists.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### updateCurrencies
|
|
|
|
`**updateCurrencies**(data, sharedContext?): Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>`
|
|
|
|
This method is used to update existing currencies with the provided data. In each currency object, the currency code must be provided to identify which currency to update.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import { initialize as initializePricingModule } from "@medusajs/pricing"
|
|
|
|
async function updateCurrencies() {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const currencies = await pricingService.updateCurrencies([
|
|
{
|
|
code: "USD",
|
|
symbol: "$",
|
|
},
|
|
])
|
|
|
|
// do something with the currencies or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[UpdateCurrencyDTO](UpdateCurrencyDTO.mdx)[]",
|
|
"description": "The currencies to update, each having the attributes that should be updated in a currency.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[CurrencyDTO](CurrencyDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of updated currencies.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### updateMoneyAmounts
|
|
|
|
`**updateMoneyAmounts**(data, sharedContext?): Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>`
|
|
|
|
This method updates existing money amounts.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function updateMoneyAmounts (moneyAmountId: string, amount: number) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const moneyAmounts = await pricingService.updateMoneyAmounts([
|
|
{
|
|
id: moneyAmountId,
|
|
amount
|
|
}
|
|
])
|
|
|
|
// do something with the money amounts or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[UpdateMoneyAmountDTO](UpdateMoneyAmountDTO.mdx)[]",
|
|
"description": "The money amounts to update, each having the attributes that should be updated in a money amount.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[MoneyAmountDTO](MoneyAmountDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of updated money amounts.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### updatePriceListRules
|
|
|
|
`**updatePriceListRules**(data, sharedContext?): Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>`
|
|
|
|
This method is used to update price list rules.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function updatePriceListRules (items: {
|
|
id: string
|
|
rule_type_id?: string
|
|
price_list_id?: string
|
|
}[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceListRules = await pricingService.updatePriceListRules(items)
|
|
|
|
// do something with the price list rule or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[UpdatePriceListRuleDTO](UpdatePriceListRuleDTO.mdx)[]",
|
|
"description": "The attributes to update for each price list rule.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListRuleDTO](PriceListRuleDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The updated price list rules.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### updatePriceLists
|
|
|
|
`**updatePriceLists**(data, sharedContext?): Promise<[PriceListDTO](PriceListDTO.mdx)[]>`
|
|
|
|
This method is used to update price lists.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function updatePriceLists (items: {
|
|
id: string
|
|
title: string
|
|
description: string
|
|
starts_at?: string
|
|
ends_at?: string
|
|
}[]) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceList = await pricingService.updatePriceLists(items)
|
|
|
|
// do something with the price lists or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[UpdatePriceListDTO](UpdatePriceListDTO.mdx)[]",
|
|
"description": "The attributes to update in each price list.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceListDTO](PriceListDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceListDTO](PriceListDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The updated price lists.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### updatePriceRules
|
|
|
|
`**updatePriceRules**(data, sharedContext?): Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>`
|
|
|
|
This method is used to update price rules, each with their provided data.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function updatePriceRules (
|
|
id: string,
|
|
priceSetId: string,
|
|
) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceRules = await pricingService.updatePriceRules([
|
|
{
|
|
id,
|
|
price_set_id: priceSetId,
|
|
}
|
|
])
|
|
|
|
// do something with the price rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[UpdatePriceRuleDTO](UpdatePriceRuleDTO.mdx)[]",
|
|
"description": "The price rules to update, each having attributes that should be updated in a price rule.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceRuleDTO](PriceRuleDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of updated price rules.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### updatePriceSetMoneyAmountRules
|
|
|
|
`**updatePriceSetMoneyAmountRules**(data, sharedContext?): Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>`
|
|
|
|
This method is used to update price set money amount rules, each with their provided data.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function updatePriceSetMoneyAmountRules (id: string, value: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const priceSetMoneyAmountRules = await pricingService.updatePriceSetMoneyAmountRules([
|
|
{
|
|
id,
|
|
value
|
|
}
|
|
])
|
|
|
|
// do something with the price set money amount rules or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[UpdatePriceSetMoneyAmountRulesDTO](UpdatePriceSetMoneyAmountRulesDTO.mdx)[]",
|
|
"description": "The price set money amounts to update, each having the attributes to update in a price set money amount.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[PriceSetMoneyAmountRulesDTO](PriceSetMoneyAmountRulesDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of updated price set money amount rules.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
___
|
|
|
|
### updateRuleTypes
|
|
|
|
`**updateRuleTypes**(data, sharedContext?): Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>`
|
|
|
|
This method is used to update existing rule types with the provided data.
|
|
|
|
#### Example
|
|
|
|
```ts
|
|
import {
|
|
initialize as initializePricingModule,
|
|
} from "@medusajs/pricing"
|
|
|
|
async function updateRuleTypes (ruleTypeId: string) {
|
|
const pricingService = await initializePricingModule()
|
|
|
|
const ruleTypes = await pricingService.updateRuleTypes([
|
|
{
|
|
id: ruleTypeId,
|
|
name: "Region",
|
|
}
|
|
])
|
|
|
|
// do something with the rule types or return them
|
|
}
|
|
```
|
|
|
|
#### Parameters
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "data",
|
|
"type": "[UpdateRuleTypeDTO](UpdateRuleTypeDTO.mdx)[]",
|
|
"description": "The rule types to update, each having the attributes that should be updated in a rule type.",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
},
|
|
{
|
|
"name": "sharedContext",
|
|
"type": "[Context](Context.mdx)",
|
|
"description": "A context used to share resources, such as transaction manager, between the application and the module.",
|
|
"optional": true,
|
|
"defaultValue": "",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|
|
|
|
#### Returns
|
|
|
|
Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>
|
|
|
|
<ParameterTypes parameters={[
|
|
{
|
|
"name": "Promise",
|
|
"type": "Promise<[RuleTypeDTO](RuleTypeDTO.mdx)[]>",
|
|
"optional": false,
|
|
"defaultValue": "",
|
|
"description": "The list of updated rule types.",
|
|
"expandable": false,
|
|
"children": []
|
|
}
|
|
]} />
|