asyavee/medusa-store
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

docs: update docusaurus to v3 (#5625)

Browse Source 
* update dependencies

* update onboarding mdx

* fixes for mdx issues

* fixes for mdx compatibility

* resolve mdx errors

* fixes in reference

* fix check errors

* revert change in vale action

* fix node version in action

* fix summary in markdown
This commit is contained in:
Shahed Nasser
2023-11-13 20:11:50 +02:00
committed by GitHub
parent cedab58339
commit c6dff873de
2265 changed files with 46163 additions and 47195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

911
www/apps/docs/content/modules/orders/admin/edit-order.mdx
View File

File diff suppressed because it is too large Load Diff

770
www/apps/docs/content/modules/orders/admin/manage-claims.mdx
View File

@@ -61,72 +61,72 @@ You can learn more about [authenticating as an admin user in the API reference](
To view an order’s claims, you can retrieve the order using the [Get Order API Route](https://docs.medusajs.com/api/admin#orders_getordersorder) and access the order’s claims:
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.retrieve(orderId)
.then(({ order }) => {
console.log(order.claims)
})
```
```ts
medusa.admin.orders.retrieve(orderId)
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminOrder } from "medusa-react"
```tsx
import { useAdminOrder } from "medusa-react"
const Order = () => {
const {
order,
isLoading,
} = useAdminOrder(orderId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && (
<>
<span>{order.display_id}</span>
{order.claims?.length > 0 && (
<ul>
{order.claims.map((claim) => (
<li key={claim.id}>{claim.id}</li>
))}
</ul>
const Order = () => {
const {
order,
isLoading,
} = useAdminOrder(orderId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && (
<>
<span>{order.display_id}</span>
{order.claims?.length > 0 && (
<ul>
{order.claims.map((claim) => (
<li key={claim.id}>{claim.id}</li>
))}
</ul>
)}
</>
)}
</>
)}
</div>
)
}
</div>
)
}
export default Order
```
export default Order
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X GET '<BACKEND_URL>/admin/orders/<ORDER_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X GET '<BACKEND_URL>/admin/orders/<ORDER_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This request requires the order’s ID as a path parameter.
@@ -140,35 +140,10 @@ The request returns the order as an object. In that object, you can access an ar
You can create a claim by sending a request to the [Create Claim API Route](https://docs.medusajs.com/api/admin#orders_postordersorderclaims):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.createClaim(orderId, {
type: "refund",
claim_items: [
{
item_id,
quantity: 1,
},
],
})
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminCreateClaim } from "medusa-react"
const CreateClaim = () => {
const createClaim = useAdminCreateClaim(orderId)
// ...
const handleCreate = () => {
createClaim.mutate({
```ts
medusa.admin.orders.createClaim(orderId, {
type: "refund",
claim_items: [
{
@@ -177,59 +152,84 @@ const CreateClaim = () => {
},
],
})
}
.then(({ order }) => {
console.log(order.claims)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default CreateClaim
```
```tsx
import { useAdminCreateClaim } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const CreateClaim = () => {
const createClaim = useAdminCreateClaim(orderId)
// ...
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
type: "refund",
claim_items: [
{
item_id,
quantity: 1,
},
],
}),
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"type": "refund",
"claim_items": [
{
"item_id": "<ITEM_ID>",
"quantity": 1
const handleCreate = () => {
createClaim.mutate({
type: "refund",
claim_items: [
{
item_id,
quantity: 1,
},
],
})
}
]
}'
```
</TabItem>
// ...
}
export default CreateClaim
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
type: "refund",
claim_items: [
{
item_id,
quantity: 1,
},
],
}),
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"type": "refund",
"claim_items": [
{
"item_id": "<ITEM_ID>",
"quantity": 1
}
]
}'
```
</TabItem>
</Tabs>
This API Route requires the order ID to be passed as a path parameter.
@@ -258,76 +258,76 @@ The request returns the updated order as an object. You can access the order’s
You can update a claim by sending a request to the [Update Claim API Route](https://docs.medusajs.com/api/admin#orders_postordersorderclaimsclaim):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.updateClaim(orderId, claimId, {
no_notification: true,
})
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminUpdateClaim } from "medusa-react"
const UpdateClaim = () => {
const updateClaim = useAdminUpdateClaim(orderId)
// ...
const handleUpdate = () => {
updateClaim.mutate({
claim_id,
```ts
medusa.admin.orders.updateClaim(orderId, claimId, {
no_notification: true,
})
}
.then(({ order }) => {
console.log(order.claims)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default UpdateClaim
```
```tsx
import { useAdminUpdateClaim } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const UpdateClaim = () => {
const updateClaim = useAdminUpdateClaim(orderId)
// ...
```ts
fetch(
`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}`,
{
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
no_notification: true,
}),
}
)
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
const handleUpdate = () => {
updateClaim.mutate({
claim_id,
no_notification: true,
})
}
</TabItem>
<TabItem value="curl" label="cURL">
// ...
}
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"no_notification": true
}'
```
export default UpdateClaim
```
</TabItem>
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(
`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}`,
{
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
no_notification: true,
}),
}
)
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"no_notification": true
}'
```
</TabItem>
</Tabs>
This API Route requires the ID of the order and the claim to be passed as path parameters.
@@ -349,63 +349,63 @@ Fulfillments are available on a claim object under the `fulfillments` property,
You can create a fulfillment for a claim by sending a request to the [Create Claim Fulfillment API Route](https://docs.medusajs.com/api/admin#orders_postordersorderclaimsclaimfulfillments):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.fulfillClaim(orderId, claimId, {
})
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminFulfillClaim } from "medusa-react"
const FulfillClaim = () => {
const fulfillClaim = useAdminFulfillClaim(orderId)
// ...
const handleFulfill = () => {
fulfillClaim.mutate({
claim_id,
```ts
medusa.admin.orders.fulfillClaim(orderId, claimId, {
})
}
.then(({ order }) => {
console.log(order.claims)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default FulfillClaim
```
```tsx
import { useAdminFulfillClaim } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const FulfillClaim = () => {
const fulfillClaim = useAdminFulfillClaim(orderId)
// ...
const handleFulfill = () => {
fulfillClaim.mutate({
claim_id,
})
}
// ...
}
export default FulfillClaim
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}/fulfillments`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}/fulfillments`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>/fulfillments' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>/fulfillments' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order and claim IDs as path parameters.
@@ -419,75 +419,75 @@ The request returns the updated order as an object. You can access the order’s
You can create a shipment for a claim by sending a request to the [Create Claim Shipment API Route](https://docs.medusajs.com/api/admin#orders_postordersorderclaimsclaimshipments):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.createClaimShipment(orderId, claimId, {
fulfillment_id,
})
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminCreateClaimShipment } from "medusa-react"
const CreateShipment = () => {
const createShipment = useAdminCreateClaimShipment(orderId)
// ...
const handleCreate = () => {
createShipment.mutate({
claim_id,
```ts
medusa.admin.orders.createClaimShipment(orderId, claimId, {
fulfillment_id,
})
}
.then(({ order }) => {
console.log(order.claims)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default CreateShipment
```
```tsx
import { useAdminCreateClaimShipment } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const CreateShipment = () => {
const createShipment = useAdminCreateClaimShipment(orderId)
// ...
const handleCreate = () => {
createShipment.mutate({
claim_id,
fulfillment_id,
})
}
// ...
}
export default CreateShipment
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}/shipments`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
fulfillment_id,
}),
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}/shipments`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
fulfillment_id,
}),
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>/shipments' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"fulfillment_id": "<FUL_ID>"
}'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>/shipments' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"fulfillment_id": "<FUL_ID>"
}'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order and claim IDs as path parameters.
@@ -511,69 +511,69 @@ You can’t cancel a fulfillment that has a shipment
You can cancel a fulfillment by sending a request to the [Cancel Fulfillment API Route](https://docs.medusajs.com/api/admin#orders_postordersclaimfulfillmentscancel):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.cancelClaimFulfillment(
orderId,
claimId,
fulfillmentId
)
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminCancelClaimFulfillment } from "medusa-react"
const CancelFulfillment = () => {
const cancelFulfillment = useAdminCancelClaimFulfillment(
orderId
)
// ...
const handleCancel = () => {
cancelFulfillment.mutate({
claim_id,
fulfillment_id,
```ts
medusa.admin.orders.cancelClaimFulfillment(
orderId,
claimId,
fulfillmentId
)
.then(({ order }) => {
console.log(order.claims)
})
}
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default CancelFulfillment
```
```tsx
import { useAdminCancelClaimFulfillment } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const CancelFulfillment = () => {
const cancelFulfillment = useAdminCancelClaimFulfillment(
orderId
)
// ...
const handleCancel = () => {
cancelFulfillment.mutate({
claim_id,
fulfillment_id,
})
}
// ...
}
export default CancelFulfillment
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}/fulfillments/${fulfillmentId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}/fulfillments/${fulfillmentId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>/fulfillments/<FUL_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>/fulfillments/<FUL_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order, claim, and fulfillment IDs to be passed as path parameters.
@@ -595,60 +595,60 @@ You can’t cancel a claim that has been refunded. You must also cancel the clai
You can cancel a claim by sending a request to the [Cancel Claim API Route](https://docs.medusajs.com/api/admin#orders_postordersclaimcancel):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.cancelClaim(orderId, claimId)
.then(({ order }) => {
console.log(order.claims)
})
```
```ts
medusa.admin.orders.cancelClaim(orderId, claimId)
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminCancelClaim } from "medusa-react"
```tsx
import { useAdminCancelClaim } from "medusa-react"
const CancelClaim = () => {
const cancelClaim = useAdminCancelClaim(orderId)
// ...
const CancelClaim = () => {
const cancelClaim = useAdminCancelClaim(orderId)
// ...
const handleCancel = () => {
cancelClaim.mutate(claimId)
}
const handleCancel = () => {
cancelClaim.mutate(claimId)
}
// ...
}
// ...
}
export default CancelClaim
```
export default CancelClaim
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/claims/${claimId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.claims)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/claims/<CLAIM_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order and claim IDs as path parameters.

1022
www/apps/docs/content/modules/orders/admin/manage-draft-orders.mdx
View File

File diff suppressed because it is too large Load Diff

1481
www/apps/docs/content/modules/orders/admin/manage-orders.mdx
View File

File diff suppressed because it is too large Load Diff

764
www/apps/docs/content/modules/orders/admin/manage-returns.mdx
View File

@@ -60,68 +60,68 @@ Return reasons allow you to specify why an item is returned. They are especially
You can list available return reasons using the [List Return Reasons API Route](https://docs.medusajs.com/api/admin#return-reasons_getreturnreasons):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.returnReasons.list()
.then(({ return_reasons }) => {
console.log(return_reasons.length)
})
```
```ts
medusa.admin.returnReasons.list()
.then(({ return_reasons }) => {
console.log(return_reasons.length)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminReturnReasons } from "medusa-react"
```tsx
import { useAdminReturnReasons } from "medusa-react"
const ReturnReasons = () => {
const { return_reasons, isLoading } = useAdminReturnReasons()
const ReturnReasons = () => {
const { return_reasons, isLoading } = useAdminReturnReasons()
return (
<div>
{isLoading && <span>Loading...</span>}
{return_reasons && !return_reasons.length && (
<span>No Return Reasons</span>
)}
{return_reasons && return_reasons.length > 0 && (
<ul>
{return_reasons.map((reason) => (
<li key={reason.id}>
{reason.label}: {reason.value}
</li>
))}
</ul>
)}
</div>
)
}
return (
<div>
{isLoading && <span>Loading...</span>}
{return_reasons && !return_reasons.length && (
<span>No Return Reasons</span>
)}
{return_reasons && return_reasons.length > 0 && (
<ul>
{return_reasons.map((reason) => (
<li key={reason.id}>
{reason.label}: {reason.value}
</li>
))}
</ul>
)}
</div>
)
}
export default ReturnReasons
```
export default ReturnReasons
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/return-reasons`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ return_reasons }) => {
console.log(return_reasons.length)
})
```
```ts
fetch(`<BACKEND_URL>/admin/return-reasons`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ return_reasons }) => {
console.log(return_reasons.length)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X GET '<BACKEND_URL>/admin/return-reasons' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X GET '<BACKEND_URL>/admin/return-reasons' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route doesn't require or accept any path or query parameters.
@@ -133,76 +133,76 @@ The request returns an array of return reason objects.
You can create a return reason using the [Create Return Reason API Route](https://docs.medusajs.com/api/admin#return-reasons_postreturnreasons):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.returnReasons.create({
label: "Damaged",
value: "damaged",
})
.then(({ return_reason }) => {
console.log(return_reason.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminCreateReturnReason } from "medusa-react"
const CreateReturnReason = () => {
const createReturnReason = useAdminCreateReturnReason()
// ...
const handleCreate = () => {
createReturnReason.mutate({
```ts
medusa.admin.returnReasons.create({
label: "Damaged",
value: "damaged",
})
}
.then(({ return_reason }) => {
console.log(return_reason.id)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default CreateReturnReason
```
```tsx
import { useAdminCreateReturnReason } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const CreateReturnReason = () => {
const createReturnReason = useAdminCreateReturnReason()
// ...
```ts
fetch(`<BACKEND_URL>/admin/return-reasons`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
label: "Damaged",
value: "damaged",
}),
})
.then((response) => response.json())
.then(({ return_reason }) => {
console.log(return_reason.id)
})
```
const handleCreate = () => {
createReturnReason.mutate({
label: "Damaged",
value: "damaged",
})
}
</TabItem>
<TabItem value="curl" label="cURL">
// ...
}
```bash
curl -L -X POST '<BACKEND_URL>/admin/return-reasons' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"label": "Damaged",
"value": "damaged"
}'
```
export default CreateReturnReason
```
</TabItem>
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/return-reasons`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
label: "Damaged",
value: "damaged",
}),
})
.then((response) => response.json())
.then(({ return_reason }) => {
console.log(return_reason.id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/return-reasons' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"label": "Damaged",
"value": "damaged"
}'
```
</TabItem>
</Tabs>
This API Route requires the following request body parameters:
@@ -219,74 +219,74 @@ This request returns the created return reason as an object.
You can update a return reason by sending a request to the [Update Return Reason API Route](https://docs.medusajs.com/api/admin#return-reasons_postreturnreasonsreason):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.returnReasons.update(returnReasonId, {
label: "Damaged",
})
.then(({ return_reason }) => {
console.log(return_reason.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminUpdateReturnReason } from "medusa-react"
const UpdateReturnReason = () => {
const updateReturnReason = useAdminUpdateReturnReason(
returnReasonId
)
// ...
const handleUpdate = () => {
updateReturnReason.mutate({
```ts
medusa.admin.returnReasons.update(returnReasonId, {
label: "Damaged",
})
}
.then(({ return_reason }) => {
console.log(return_reason.id)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default UpdateReturnReason
```
```tsx
import { useAdminUpdateReturnReason } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const UpdateReturnReason = () => {
const updateReturnReason = useAdminUpdateReturnReason(
returnReasonId
)
// ...
```ts
fetch(`<BACKEND_URL>/admin/return-reasons/${returnReasonId}`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
label: "Damaged",
}),
})
.then((response) => response.json())
.then(({ return_reason }) => {
console.log(return_reason.id)
})
```
const handleUpdate = () => {
updateReturnReason.mutate({
label: "Damaged",
})
}
</TabItem>
<TabItem value="curl" label="cURL">
// ...
}
```bash
curl -L -X POST '<BACKEND_URL>/admin/return-reasons/<REASON_ID>' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"label": "Damaged"
}'
```
export default UpdateReturnReason
```
</TabItem>
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/return-reasons/${returnReasonId}`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
label: "Damaged",
}),
})
.then((response) => response.json())
.then(({ return_reason }) => {
console.log(return_reason.id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/return-reasons/<REASON_ID>' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"label": "Damaged"
}'
```
</TabItem>
</Tabs>
This API Route requires the return reason ID to be passed as a path parameter.
@@ -300,60 +300,60 @@ The request returns the updated return reason as an object.
You can delete a return reason by sending a request to the [Delete Return Reason API Route](https://docs.medusajs.com/api/admin#return-reasons_deletereturnreason):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.returnReasons.delete(returnReasonId)
.then(({ id, object, deleted }) => {
console.log(id)
})
```
```ts
medusa.admin.returnReasons.delete(returnReasonId)
.then(({ id, object, deleted }) => {
console.log(id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminDeleteReturnReason } from "medusa-react"
```tsx
import { useAdminDeleteReturnReason } from "medusa-react"
const DeleteReturnReason = () => {
const deleteReturnReason = useAdminDeleteReturnReason(
returnReasonId
)
// ...
const DeleteReturnReason = () => {
const deleteReturnReason = useAdminDeleteReturnReason(
returnReasonId
)
// ...
const handleDelete = () => {
deleteReturnReason.mutate()
}
const handleDelete = () => {
deleteReturnReason.mutate()
}
// ...
}
// ...
}
export default DeleteReturnReason
```
export default DeleteReturnReason
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/return-reasons/${returnReasonId}`, {
credentials: "include",
method: "DELETE",
})
.then((response) => response.json())
.then(({ id, object, deleted }) => {
console.log(id)
})
```
```ts
fetch(`<BACKEND_URL>/admin/return-reasons/${returnReasonId}`, {
credentials: "include",
method: "DELETE",
})
.then((response) => response.json())
.then(({ id, object, deleted }) => {
console.log(id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X DELETE '<BACKEND_URL>/admin/return-reasons/<REASON_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X DELETE '<BACKEND_URL>/admin/return-reasons/<REASON_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the return reason ID as a path parameter.
@@ -377,72 +377,72 @@ You can view all returns in your commerce system, regardless of which order they
When you retrieve an order using the [Get Order API Route](https://docs.medusajs.com/api/admin#orders_getordersorder), you can access the returns within the order object:
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.retrieve(orderId)
.then(({ order }) => {
console.log(order.returns)
})
```
```ts
medusa.admin.orders.retrieve(orderId)
.then(({ order }) => {
console.log(order.returns)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminOrder } from "medusa-react"
```tsx
import { useAdminOrder } from "medusa-react"
const Order = () => {
const {
order,
isLoading,
} = useAdminOrder(orderId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && (
<>
<span>{order.display_id}</span>
{order.returns?.length > 0 && (
<ul>
{order.returns.map((orderReturn) => (
<li key={orderReturn.id}>{orderReturn.id}</li>
))}
</ul>
const Order = () => {
const {
order,
isLoading,
} = useAdminOrder(orderId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && (
<>
<span>{order.display_id}</span>
{order.returns?.length > 0 && (
<ul>
{order.returns.map((orderReturn) => (
<li key={orderReturn.id}>{orderReturn.id}</li>
))}
</ul>
)}
</>
)}
</>
)}
</div>
)
}
</div>
)
}
export default Order
```
export default Order
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.returns)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.returns)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X GET '<BACKEND_URL>/admin/orders/<ORDER_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X GET '<BACKEND_URL>/admin/orders/<ORDER_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order ID as a path parameter.
@@ -470,89 +470,89 @@ You can retrieve a claim using the Get Order API Route as explained [here](./man
You can mark a return as received by sending a request to the [Receive a Return API Route](https://docs.medusajs.com/api/admin#returns_postreturnsreturnreceive):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.returns.receive(return_id, {
items: [
{
item_id,
quantity: 1,
},
],
})
.then((data) => {
console.log(data.return.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminReceiveReturn } from "medusa-react"
const ReceiveReturn = () => {
const receiveReturn = useAdminReceiveReturn(
returnId
)
// ...
const handleReceive = () => {
receiveReturn.mutate({
email,
```ts
medusa.admin.returns.receive(return_id, {
items: [
{
item_id,
quantity: 1,
},
],
})
}
.then((data) => {
console.log(data.return.id)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default ReceiveReturn
```
```tsx
import { useAdminReceiveReturn } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const ReceiveReturn = () => {
const receiveReturn = useAdminReceiveReturn(
returnId
)
// ...
```ts
fetch(`<BACKEND_URL>/admin/returns/${returnId}/receive`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
items: [
{
item_id,
quantity: 1,
},
],
}),
})
.then((response) => response.json())
.then((data) => {
console.log(data.return.id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/returns/<RETURN_ID>/receive' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"items": [
{
"item_id": "<ITEM_ID>",
"quantity": 1
const handleReceive = () => {
receiveReturn.mutate({
email,
})
}
]
}'
```
</TabItem>
// ...
}
export default ReceiveReturn
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/returns/${returnId}/receive`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
items: [
{
item_id,
quantity: 1,
},
],
}),
})
.then((response) => response.json())
.then((data) => {
console.log(data.return.id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/returns/<RETURN_ID>/receive' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"items": [
{
"item_id": "<ITEM_ID>",
"quantity": 1
}
]
}'
```
</TabItem>
</Tabs>
This API Route requires the ID of the return as a path parameter.
@@ -579,60 +579,60 @@ A received return can’t be canceled.
You can cancel a return by sending a request to the [Cancel Return API Route](https://docs.medusajs.com/api/admin#returns_postreturnsreturncancel):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.returns.cancel(returnId)
.then(({ order }) => {
console.log(order.returns)
})
```
```ts
medusa.admin.returns.cancel(returnId)
.then(({ order }) => {
console.log(order.returns)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminCancelReturn } from "medusa-react"
```tsx
import { useAdminCancelReturn } from "medusa-react"
const CancelReturn = () => {
const cancelReturn = useAdminCancelReturn(
returnId
)
// ...
const CancelReturn = () => {
const cancelReturn = useAdminCancelReturn(
returnId
)
// ...
const handleCancel = () => {
cancelReturn.mutate()
}
const handleCancel = () => {
cancelReturn.mutate()
}
// ...
}
// ...
}
export default CancelReturn
```
export default CancelReturn
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/returns/${returnId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.returns)
})
```
```ts
fetch(`<BACKEND_URL>/admin/returns/${returnId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.returns)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/returns/<RETURN_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/returns/<RETURN_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the return ID to be passed as a path parameter.

594
www/apps/docs/content/modules/orders/admin/manage-swaps.mdx
View File

@@ -68,71 +68,71 @@ If you want to view all swaps in your system, and not swaps specific to an order
You can view an order’s swaps by retrieving the order using the [Get Order API Route](https://docs.medusajs.com/api/admin#orders_getordersorder):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.retrieve(orderId)
.then(({ order }) => {
console.log(order.swaps)
})
```
```ts
medusa.admin.orders.retrieve(orderId)
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminOrder } from "medusa-react"
```tsx
import { useAdminOrder } from "medusa-react"
const Order = () => {
const {
order,
isLoading,
} = useAdminOrder(orderId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && (
<>
<span>{order.display_id}</span>
{order.swaps?.length > 0 && (
<ul>
{order.swaps.map((swap) => (
<li key={swap.id}>{swap.difference_due}</li>
))}
</ul>
const Order = () => {
const {
order,
isLoading,
} = useAdminOrder(orderId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && (
<>
<span>{order.display_id}</span>
{order.swaps?.length > 0 && (
<ul>
{order.swaps.map((swap) => (
<li key={swap.id}>{swap.difference_due}</li>
))}
</ul>
)}
</>
)}
</>
)}
</div>
)
}
</div>
)
}
export default Order
```
export default Order
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X GET '<BACKEND_URL>/admin/orders/<ORDER_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X GET '<BACKEND_URL>/admin/orders/<ORDER_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order ID to be passed as a path parameter.
@@ -148,62 +148,62 @@ Processing a swap’s payment can mean either refunding or capturing payment, de
Regardless of whether you need to refund or capture the payment, you can process the swap’s payment by sending a request to the [Process Swap Payment API Route](https://docs.medusajs.com/api/admin#orders_postordersorderswapsswapprocesspayment):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.processSwapPayment(orderId, swapId)
.then(({ order }) => {
console.log(order.swaps)
})
```
```ts
medusa.admin.orders.processSwapPayment(orderId, swapId)
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminProcessSwapPayment } from "medusa-react"
```tsx
import { useAdminProcessSwapPayment } from "medusa-react"
const ProcessPayment = () => {
const processPayment = useAdminProcessSwapPayment(
orderId
)
// ...
const ProcessPayment = () => {
const processPayment = useAdminProcessSwapPayment(
orderId
)
// ...
const handleProcess = () => {
processPayment.mutate(swapId)
}
const handleProcess = () => {
processPayment.mutate(swapId)
}
// ...
}
// ...
}
export default ProcessPayment
```
export default ProcessPayment
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/process-payment`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/process-payment`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/process-payment' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/process-payment' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order ID and the swap ID as path parameters.
@@ -223,65 +223,65 @@ Fulfillments are available on a swap object under the `fulfillments` property, w
You can create a fulfillment for a swap by sending a request to the [Create Swap Fulfillment API Route](https://docs.medusajs.com/api/admin#orders_postordersorderswapsswapfulfillments):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.fulfillSwap(orderId, swapId, {
})
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminFulfillSwap } from "medusa-react"
const FulfillSwap = () => {
const fulfillSwap = useAdminFulfillSwap(
orderId
)
// ...
const handleFulfill = () => {
fulfillSwap.mutate({
swap_id: swapId,
```ts
medusa.admin.orders.fulfillSwap(orderId, swapId, {
})
}
.then(({ order }) => {
console.log(order.swaps)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default FulfillSwap
```
```tsx
import { useAdminFulfillSwap } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const FulfillSwap = () => {
const fulfillSwap = useAdminFulfillSwap(
orderId
)
// ...
const handleFulfill = () => {
fulfillSwap.mutate({
swap_id: swapId,
})
}
// ...
}
export default FulfillSwap
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/fulfillments`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/fulfillments`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/fulfillments' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/fulfillments' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order ID and swap ID as path parameters.
@@ -295,77 +295,77 @@ The request returns the updated order as an object. You can access the order’s
You can create a shipment for a swap’s fulfillment using the [Create Swap Shipment API Route](https://docs.medusajs.com/api/admin#orders_postordersorderswapsswapshipments):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.createSwapShipment(orderId, swapId, {
fulfillment_id,
})
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminCreateSwapShipment } from "medusa-react"
const CreateShipment = () => {
const createShipment = useAdminCreateSwapShipment(
orderId
)
// ...
const handleCreate = () => {
createShipment.mutate({
swap_id,
```ts
medusa.admin.orders.createSwapShipment(orderId, swapId, {
fulfillment_id,
})
}
.then(({ order }) => {
console.log(order.swaps)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default CreateShipment
```
```tsx
import { useAdminCreateSwapShipment } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const CreateShipment = () => {
const createShipment = useAdminCreateSwapShipment(
orderId
)
// ...
const handleCreate = () => {
createShipment.mutate({
swap_id,
fulfillment_id,
})
}
// ...
}
export default CreateShipment
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/shipments`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
fulfillment_id,
}),
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/shipments`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
fulfillment_id,
}),
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/shipments' \
-H 'Authorization: Bearer <API_TOKEN>'\
-H 'Content-Type: application/json' \
--data-raw '{
"fulfillment_id": "<FUL_ID>"
}'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/shipments' \
-H 'Authorization: Bearer <API_TOKEN>'\
-H 'Content-Type: application/json' \
--data-raw '{
"fulfillment_id": "<FUL_ID>"
}'
```
</TabItem>
</TabItem>
</Tabs>
This API Route expects the order and swap IDs to be passed as path parameters.
@@ -389,69 +389,69 @@ You can’t cancel a fulfillment that has a shipment
You can cancel a fulfillment by sending a request to the [Cancel Swap Fulfillment API Route](https://docs.medusajs.com/api/admin#orders_postordersswapfulfillmentscancel):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.cancelSwapFulfillment(
orderId,
swapId,
fulfillmentId
)
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminCancelSwapFulfillment } from "medusa-react"
const CancelFulfillment = () => {
const cancelFulfillment = useAdminCancelSwapFulfillment(
orderId
)
// ...
const handleCancel = () => {
cancelFulfillment.mutate({
swap_id,
fulfillment_id,
```ts
medusa.admin.orders.cancelSwapFulfillment(
orderId,
swapId,
fulfillmentId
)
.then(({ order }) => {
console.log(order.swaps)
})
}
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default CancelFulfillment
```
```tsx
import { useAdminCancelSwapFulfillment } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const CancelFulfillment = () => {
const cancelFulfillment = useAdminCancelSwapFulfillment(
orderId
)
// ...
const handleCancel = () => {
cancelFulfillment.mutate({
swap_id,
fulfillment_id,
})
}
// ...
}
export default CancelFulfillment
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/shipments/${fulfillmentId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/shipments/${fulfillmentId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/fulfillments/<FUL_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/fulfillments/<FUL_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order, swap, and fulfillment IDs to be passed as path parameters.
@@ -473,62 +473,62 @@ You can’t cancel a swap that has been refunded. You must also cancel all swap
You can cancel a swap by sending a request to the [Cancel Swap API Route](https://docs.medusajs.com/api/admin#orders_postordersswapcancel):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.orders.cancelSwap(orderId, swapId)
.then(({ order }) => {
console.log(order.swaps)
})
```
```ts
medusa.admin.orders.cancelSwap(orderId, swapId)
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminCancelSwap } from "medusa-react"
```tsx
import { useAdminCancelSwap } from "medusa-react"
const CancelSwap = () => {
const cancelSwap = useAdminCancelSwap(
orderId
)
// ...
const CancelSwap = () => {
const cancelSwap = useAdminCancelSwap(
orderId
)
// ...
const handleCancel = () => {
cancelSwap.mutate(swapId)
}
const handleCancel = () => {
cancelSwap.mutate(swapId)
}
// ...
}
// ...
}
export default CancelSwap
```
export default CancelSwap
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
```ts
fetch(`<BACKEND_URL>/admin/orders/${orderId}/swaps/${swapId}/cancel`, {
credentials: "include",
method: "POST",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.swaps)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
```bash
curl -L -X POST '<BACKEND_URL>/admin/orders/<ORDER_ID>/swaps/<SWAP_ID>/cancel' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order and swap IDs as path parameters.

228
www/apps/docs/content/modules/orders/storefront/create-return.mdx
View File

@@ -60,65 +60,65 @@ When a customer wants to create a return, they must choose the items they want t
You can optionally allow customers to choose a return shipping option that they’ll use to return the items. To show the customers the available return shipping options, send a request to the Get [Shipping Options API Route](https://docs.medusajs.com/api/store#shipping-options_getshippingoptions):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.shippingOptions.list({
is_return: "true",
})
.then(({ shipping_options }) => {
console.log(shipping_options.length)
})
```
```ts
medusa.shippingOptions.list({
is_return: "true",
})
.then(({ shipping_options }) => {
console.log(shipping_options.length)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useShippingOptions } from "medusa-react"
```tsx
import { useShippingOptions } from "medusa-react"
const ReturnShippingOptions = () => {
const {
shipping_options,
isLoading,
} = useShippingOptions({
is_return: "true",
})
return (
<div>
{isLoading && <span>Loading...</span>}
{shipping_options?.length &&
shipping_options?.length > 0 && (
<ul>
{shipping_options?.map((shipping_option) => (
<li key={shipping_option.id}>
{shipping_option.id}
</li>
))}
</ul>
)}
</div>
)
}
const ReturnShippingOptions = () => {
const {
shipping_options,
isLoading,
} = useShippingOptions({
is_return: "true",
})
return (
<div>
{isLoading && <span>Loading...</span>}
{shipping_options?.length &&
shipping_options?.length > 0 && (
<ul>
{shipping_options?.map((shipping_option) => (
<li key={shipping_option.id}>
{shipping_option.id}
</li>
))}
</ul>
)}
</div>
)
}
export default ReturnShippingOptions
```
export default ReturnShippingOptions
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/shipping-options?is_return=true`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ shipping_options }) => {
console.log(shipping_options.length)
})
```
```ts
fetch(`<BACKEND_URL>/store/shipping-options?is_return=true`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ shipping_options }) => {
console.log(shipping_options.length)
})
```
</TabItem>
</TabItem>
</Tabs>
This API Route allows you to pass the `is_return` query parameter to indicate whether the shipping options should be return shipping options. You can learn about other available filters in the [API reference](https://docs.medusajs.com/api/store#shipping-options_getshippingoptions).
@@ -132,38 +132,10 @@ The request returns an array of shipping option objects.
You can create the return by sending a request to the [Create Return API Route](https://docs.medusajs.com/api/store#returns_postreturns):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.returns.create({
order_id,
items: [
{
item_id,
quantity: 1,
},
],
return_shipping: {
option_id,
},
})
.then((data) => {
console.log(data.return.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useCreateReturn } from "medusa-react"
const CreateReturn = () => {
const createReturn = useCreateReturn()
// ...
const handleCreate = () => {
createReturn.mutate({
```ts
medusa.returns.create({
order_id,
items: [
{
@@ -175,44 +147,72 @@ const CreateReturn = () => {
option_id,
},
})
}
.then((data) => {
console.log(data.return.id)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default CreateReturn
```
```tsx
import { useCreateReturn } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const CreateReturn = () => {
const createReturn = useCreateReturn()
// ...
```ts
fetch(`<BACKEND_URL>/store/returns`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
order_id,
items: [
{
item_id,
quantity: 1,
const handleCreate = () => {
createReturn.mutate({
order_id,
items: [
{
item_id,
quantity: 1,
},
],
return_shipping: {
option_id,
},
})
}
// ...
}
export default CreateReturn
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/returns`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
],
return_shipping: {
option_id,
},
}),
})
.then((response) => response.json())
.then((data) => {
console.log(data.return.id)
})
```
body: JSON.stringify({
order_id,
items: [
{
item_id,
quantity: 1,
},
],
return_shipping: {
option_id,
},
}),
})
.then((response) => response.json())
.then((data) => {
console.log(data.return.id)
})
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the following request body parameters:

220
www/apps/docs/content/modules/orders/storefront/create-swap.mdx
View File

@@ -63,42 +63,10 @@ You can optionally allow customers to choose a return shipping option that they
After collecting the swap details in step 1, you can create a swap in the Medusa backend by sending a request to the [Create Swap API Route](https://docs.medusajs.com/api/store#swaps_postswaps):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.swaps.create({
order_id,
return_items: [
{
item_id,
quantity: 1,
},
],
additional_items: [
{
variant_id,
quantity: 1,
},
],
return_shipping_option,
})
.then(({ swap }) => {
console.log(swap.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useCreateSwap } from "medusa-react"
const CreateSwap = () => {
const createSwap = useCreateSwap()
// ...
const handleCreate = () => {
createSwap.mutate({
```ts
medusa.swaps.create({
order_id,
return_items: [
{
@@ -114,48 +82,80 @@ const CreateSwap = () => {
],
return_shipping_option,
})
}
.then(({ swap }) => {
console.log(swap.id)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default CreateSwap
```
```tsx
import { useCreateSwap } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const CreateSwap = () => {
const createSwap = useCreateSwap()
// ...
```ts
fetch(`<BACKEND_URL>/store/swaps`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
order_id,
return_items: [
{
item_id,
quantity: 1,
const handleCreate = () => {
createSwap.mutate({
order_id,
return_items: [
{
item_id,
quantity: 1,
},
],
additional_items: [
{
variant_id,
quantity: 1,
},
],
return_shipping_option,
})
}
// ...
}
export default CreateSwap
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/swaps`, {
credentials: "include",
method: "POST",
headers: {
"Content-Type": "application/json",
},
],
additional_items: [
{
variant_id,
quantity: 1,
},
],
return_shipping_option,
}),
})
.then((response) => response.json())
.then(({ swap }) => {
console.log(swap.id)
})
```
body: JSON.stringify({
order_id,
return_items: [
{
item_id,
quantity: 1,
},
],
additional_items: [
{
variant_id,
quantity: 1,
},
],
return_shipping_option,
}),
})
.then((response) => response.json())
.then(({ swap }) => {
console.log(swap.id)
})
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the following request body parameters:
@@ -191,53 +191,53 @@ When you complete the cart, the returned `type` field can be used to indicate th
During your checkout flow, you might need to retrieve the swap using the cart’s ID. For example, if you want to display the swap’s details after the cart is successfully completed. You can do that using the [Get by Cart ID API Route](https://docs.medusajs.com/api/store#swaps_getswapsswapcartid):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.swaps.retrieveByCartId(cartId)
.then(({ swap }) => {
console.log(swap.id)
})
```
```ts
medusa.swaps.retrieveByCartId(cartId)
.then(({ swap }) => {
console.log(swap.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useCartSwap } from "medusa-react"
```tsx
import { useCartSwap } from "medusa-react"
const Swap = () => {
const {
swap,
isLoading,
} = useCartSwap(cartId)
return (
<div>
{isLoading && <span>Loading...</span>}
{swap && <span>{swap.id}</span>}
</div>
)
}
const Swap = () => {
const {
swap,
isLoading,
} = useCartSwap(cartId)
return (
<div>
{isLoading && <span>Loading...</span>}
{swap && <span>{swap.id}</span>}
</div>
)
}
export default Swap
```
export default Swap
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/swaps/${cartId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ swap }) => {
console.log(swap.id)
})
```
```ts
fetch(`<BACKEND_URL>/store/swaps/${cartId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ swap }) => {
console.log(swap.id)
})
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the ID of the cart as a path parameter.

426
www/apps/docs/content/modules/orders/storefront/handle-order-edits.mdx
View File

@@ -73,44 +73,44 @@ You must have an existing order edit in the “request” state.
You can retrieve a single order edit by its ID by sending a request to the [Get Order Edit API Route](https://docs.medusajs.com/api/store#order-edits_getordereditsorderedit):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.orderEdits.retrieve(orderEditId)
.then(({ order_edit }) => {
console.log(order_edit.changes)
// show changed items to the customer
})
```
```ts
medusa.orderEdits.retrieve(orderEditId)
.then(({ order_edit }) => {
console.log(order_edit.changes)
// show changed items to the customer
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useOrderEdit } from "medusa-react"
```tsx
import { useOrderEdit } from "medusa-react"
const OrderEdit = () => {
const { order_edit, isLoading } = useOrderEdit(orderEditId)
const OrderEdit = () => {
const { order_edit, isLoading } = useOrderEdit(orderEditId)
// ...
}
// ...
}
export default OrderEdit
```
export default OrderEdit
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/order-edits/${orderEditId}`)
.then((response) => response.json())
.then(({ order_edit }) => {
console.log(order_edit.changes)
// show changed items to the customer
})
```
```ts
fetch(`<BACKEND_URL>/store/order-edits/${orderEditId}`)
.then((response) => response.json())
.then(({ order_edit }) => {
console.log(order_edit.changes)
// show changed items to the customer
})
```
</TabItem>
</TabItem>
</Tabs>
The request requires the order edit’s ID as a path parameter.
@@ -201,132 +201,132 @@ If `difference_due` is greater than 0, then additional payment from the customer
2. When the customer selects the payment processor, initialize the payment session of that provider in the payment collection. You can do that by sending a request to the [Manage Payment Sessions API Route](https://docs.medusajs.com/api/store#payment-collections_postpaymentcollectionspaymentcollectionsessionsbatch), passing it the payment collection’s ID as a path parameter, and the payment processor's ID as a request body parameter:
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
<!-- eslint-disable max-len -->
```ts
medusa.paymentCollections.managePaymentSession(paymentCollectionId, {
provider_id,
})
.then(({ payment_collection }) => {
console.log(payment_collection.payment_sessions)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useManagePaymentSession } from "medusa-react"
const OrderEditPayment = () => {
const managePaymentSession = useManagePaymentSession(
paymentCollectionId
)
// ...
const handleAdditionalPayment = (provider_id: string) => {
managePaymentSession.mutate({
```ts
medusa.paymentCollections.managePaymentSession(paymentCollectionId, {
provider_id,
})
}
.then(({ payment_collection }) => {
console.log(payment_collection.payment_sessions)
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default OrderEditPayment
```
```tsx
import { useManagePaymentSession } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const OrderEditPayment = () => {
const managePaymentSession = useManagePaymentSession(
paymentCollectionId
)
// ...
const handleAdditionalPayment = (provider_id: string) => {
managePaymentSession.mutate({
provider_id,
})
}
// ...
}
export default OrderEditPayment
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(
`<BACKEND_URL>/store/payment-collections/${paymentCollectionId}/sessions`,
{
method: "POST",
credentials: "include",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
provider_id,
}),
}
)
.then((response) => response.json())
.then(({ payment_collection }) => {
console.log(payment_collection.payment_sessions)
})
```
```ts
fetch(
`<BACKEND_URL>/store/payment-collections/${paymentCollectionId}/sessions`,
{
method: "POST",
credentials: "include",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
provider_id,
}),
}
)
.then((response) => response.json())
.then(({ payment_collection }) => {
console.log(payment_collection.payment_sessions)
})
```
</TabItem>
</TabItem>
</Tabs>
1. Show the customer the payment details form based on the payment session’s provider. For example, if the provider ID of a payment session is `stripe`, you must show Stripe’s card component to enter the customer’s card details.
2. Authorize the payment using the payment processor. The [Authorize Payment Session API Route](https://docs.medusajs.com/api/store#payment-collections_postpaymentcollectionssessionssessionauthorize) accepts the payment collection’s ID and the ID of the payment session as path parameters:
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa
.paymentCollection
.authorizePaymentSession(
paymentCollectionId,
paymentSessionId
)
.then(({ payment_session }) => {
console.log(payment_session.id)
})
```
```ts
medusa
.paymentCollection
.authorizePaymentSession(
paymentCollectionId,
paymentSessionId
)
.then(({ payment_session }) => {
console.log(payment_session.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAuthorizePaymentSession } from "medusa-react"
```tsx
import { useAuthorizePaymentSession } from "medusa-react"
const OrderEditPayment = () => {
const authorizePaymentSession = useAuthorizePaymentSession(
paymentCollectionId
)
// ...
const OrderEditPayment = () => {
const authorizePaymentSession = useAuthorizePaymentSession(
paymentCollectionId
)
// ...
const handleAuthorizePayment = (paymentSessionId: string) => {
authorizePaymentSession.mutate(paymentSessionId)
}
const handleAuthorizePayment = (paymentSessionId: string) => {
authorizePaymentSession.mutate(paymentSessionId)
}
// ...
}
// ...
}
export default OrderEditPayment
```
export default OrderEditPayment
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(
`<BACKEND_URL>/store/payment-collection/${paymentCollectionId}` +
`/sessions/${paymentSessionId}/authorize`,
{
method: "POST",
credentials: "include",
}
)
.then((response) => response.json())
.then(({ payment_session }) => {
console.log(payment_session.id)
})
```
```ts
fetch(
`<BACKEND_URL>/store/payment-collection/${paymentCollectionId}` +
`/sessions/${paymentSessionId}/authorize`,
{
method: "POST",
credentials: "include",
}
)
.then((response) => response.json())
.then(({ payment_session }) => {
console.log(payment_session.id)
})
```
</TabItem>
</TabItem>
</Tabs>
After performing the above steps, you can [complete the Order Edit](#complete-the-order-edit).
@@ -338,52 +338,52 @@ After performing the above steps, you can [complete the Order Edit](#complete-th
To confirm and complete the order edit, send a request to the [Complete Order Edit API Route](https://docs.medusajs.com/api/store#order-edits_postordereditsordereditcomplete):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.orderEdits.complete(orderEditId)
.then(({ order_edit }) => {
console.log(order_edit.confirmed_at)
})
```
```ts
medusa.orderEdits.complete(orderEditId)
.then(({ order_edit }) => {
console.log(order_edit.confirmed_at)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useCompleteOrderEdit } from "medusa-react"
```tsx
import { useCompleteOrderEdit } from "medusa-react"
const OrderEdit = () => {
const completeOrderEdit = useCompleteOrderEdit(orderEditId)
// ...
const OrderEdit = () => {
const completeOrderEdit = useCompleteOrderEdit(orderEditId)
// ...
const handleCompleteOrderEdit = () => {
completeOrderEdit.mutate()
}
const handleCompleteOrderEdit = () => {
completeOrderEdit.mutate()
}
// ...
}
// ...
}
export default OrderEdit
```
export default OrderEdit
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/store/order-edits/${orderEditId}/complete`, {
method: "POST",
credentials: "include",
})
.then((response) => response.json())
.then(({ order_edit }) => {
console.log(order_edit.confirmed_at)
})
```
```ts
fetch(`<BACKEND_URL>/store/order-edits/${orderEditId}/complete`, {
method: "POST",
credentials: "include",
})
.then((response) => response.json())
.then(({ order_edit }) => {
console.log(order_edit.confirmed_at)
})
```
</TabItem>
</TabItem>
</Tabs>
This request accepts the order edit’s ID as a path parameter.
@@ -405,63 +405,63 @@ If the payment isn’t authorized first, the order edit completion will fail.
If the customer wants to decline the Order Edit, you can do that by sending a request to the Decline Order Edit API Route:
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.orderEdits.decline(orderEditId, {
decline_reason: "I am not satisfied",
})
.then(({ order_edit }) => {
console.log(order_edit.declined_at)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useDeclineOrderEdit } from "medusa-react"
const OrderEdit = () => {
const declineOrderEdit = useDeclineOrderEdit(orderEditId)
// ...
const handleDeclineOrderEdit = () => {
declineOrderEdit.mutate({
declined_reason: "I am not satisfied",
})
}
// ...
}
export default OrderEdit
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(
`<BACKEND_URL>/store/order-edits/${orderEditId}/decline`,
{
method: "POST",
credentials: "include",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
```ts
medusa.orderEdits.decline(orderEditId, {
decline_reason: "I am not satisfied",
}),
}
)
.then((response) => response.json())
.then(({ order_edit }) => {
console.log(order_edit.declined_at)
})
```
})
.then(({ order_edit }) => {
console.log(order_edit.declined_at)
})
```
</TabItem>
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useDeclineOrderEdit } from "medusa-react"
const OrderEdit = () => {
const declineOrderEdit = useDeclineOrderEdit(orderEditId)
// ...
const handleDeclineOrderEdit = () => {
declineOrderEdit.mutate({
declined_reason: "I am not satisfied",
})
}
// ...
}
export default OrderEdit
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(
`<BACKEND_URL>/store/order-edits/${orderEditId}/decline`,
{
method: "POST",
credentials: "include",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
decline_reason: "I am not satisfied",
}),
}
)
.then((response) => response.json())
.then(({ order_edit }) => {
console.log(order_edit.declined_at)
})
```
</TabItem>
</Tabs>
The request requires passing the order edit’s ID as a path parameter.

178
www/apps/docs/content/modules/orders/storefront/implement-claim-order.mdx
View File

@@ -80,47 +80,47 @@ When the customer wants to claim an order, they must supply its ID.
To allow the customer to claim an order, send a request to the Claim an Order API Route:
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.orders.requestCustomerOrders({
order_ids: [
order_id,
],
})
.then(() => {
// successful
})
.catch(() => {
// an error occurred
})
```
```ts
medusa.orders.requestCustomerOrders({
order_ids: [
order_id,
],
})
.then(() => {
// successful
})
.catch(() => {
// an error occurred
})
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/orders/batch/customer/token`, {
method: "POST",
credentials: "include",
body: JSON.stringify({
order_ids: [
order_id,
],
}),
headers: {
"Content-Type": "application/json",
},
})
.then(() => {
// successful
})
.catch(() => {
// display an error to the customer
})
```
```ts
fetch(`<BACKEND_URL>/store/orders/batch/customer/token`, {
method: "POST",
credentials: "include",
body: JSON.stringify({
order_ids: [
order_id,
],
}),
headers: {
"Content-Type": "application/json",
},
})
.then(() => {
// successful
})
.catch(() => {
// display an error to the customer
})
```
</TabItem>
</TabItem>
</Tabs>
This request accepts as a body parameter the array `order_ids`. Each item in the array is the ID of an order that the customer wants to claim. You can pass more than one ID.
@@ -138,65 +138,65 @@ The link in the email that the customer receives should be a page in your storef
Then, you send a request to the Verify Claim Order API Route:
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.orders.confirmRequest({
token,
})
.then(() => {
// successful
})
.catch(() => {
// an error occurred
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useGrantOrderAccess } from "medusa-react"
const ClaimOrder = () => {
const grantOrderAccess = useGrantOrderAccess()
// ...
const handleVerifyOrderClaim = (token: string) => {
grantOrderAccess.mutate(({
```ts
medusa.orders.confirmRequest({
token,
}))
}
})
.then(() => {
// successful
})
.catch(() => {
// an error occurred
})
```
// ...
}
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
export default ClaimOrder
```
```tsx
import { useGrantOrderAccess } from "medusa-react"
</TabItem>
<TabItem value="fetch" label="Fetch API">
const ClaimOrder = () => {
const grantOrderAccess = useGrantOrderAccess()
// ...
```ts
fetch(`<BACKEND_URL>/store/orders/customer/confirm`, {
method: "POST",
credentials: "include",
body: JSON.stringify({
token,
}),
headers: {
"Content-Type": "application/json",
},
})
.then(() => {
// successful
})
.catch(() => {
// display an error to the customer
})
```
const handleVerifyOrderClaim = (token: string) => {
grantOrderAccess.mutate(({
token,
}))
}
</TabItem>
// ...
}
export default ClaimOrder
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/orders/customer/confirm`, {
method: "POST",
credentials: "include",
body: JSON.stringify({
token,
}),
headers: {
"Content-Type": "application/json",
},
})
.then(() => {
// successful
})
.catch(() => {
// display an error to the customer
})
```
</TabItem>
</Tabs>
This request accepts as a body parameter the string `token`. This would be the token passed as a parameter to your storefront page through the link in the email.

246
www/apps/docs/content/modules/orders/storefront/retrieve-order-details.mdx
View File

@@ -39,53 +39,53 @@ Retrieving an order by its ID is useful for different scenarios, such as using a
You can retrieve an order by its ID using the [Get Order API Route](https://docs.medusajs.com/api/store#orders_getordersorder):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.orders.retrieve(orderId)
.then(({ order }) => {
console.log(order.id)
})
```
```ts
medusa.orders.retrieve(orderId)
.then(({ order }) => {
console.log(order.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useOrder } from "medusa-react"
```tsx
import { useOrder } from "medusa-react"
const Order = () => {
const {
order,
isLoading,
} = useOrder(orderId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && <span>{order.display_id}</span>}
</div>
)
}
const Order = () => {
const {
order,
isLoading,
} = useOrder(orderId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && <span>{order.display_id}</span>}
</div>
)
}
export default Order
```
export default Order
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/orders/${orderId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.id)
})
```
```ts
fetch(`<BACKEND_URL>/store/orders/${orderId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.id)
})
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the order’s ID to be passed as a path parameter. You can utilize the [expand](https://docs.medusajs.com/api/store#expanding-fields) and [fields](https://docs.medusajs.com/api/store#selecting-fields) query parameters to select parameters and relations to return.
@@ -101,61 +101,61 @@ Display IDs allow you to show human-readable IDs to your customers. Retrieving a
You can retrieve an order by its display ID using the [Look Up Order API Route](https://docs.medusajs.com/api/store#orders_getorders):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.orders.lookupOrder({
display_id: 1,
email: "user@example.com",
})
.then(({ order }) => {
console.log(order.id)
})
```
```ts
medusa.orders.lookupOrder({
display_id: 1,
email: "user@example.com",
})
.then(({ order }) => {
console.log(order.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useOrders } from "medusa-react"
```tsx
import { useOrders } from "medusa-react"
const Order = () => {
const {
order,
isLoading,
} = useOrders({
display_id: 1,
email: "user@example.com",
})
return (
<div>
{isLoading && <span>Loading...</span>}
{order && <span>{order.display_id}</span>}
</div>
)
}
const Order = () => {
const {
order,
isLoading,
} = useOrders({
display_id: 1,
email: "user@example.com",
})
return (
<div>
{isLoading && <span>Loading...</span>}
{order && <span>{order.display_id}</span>}
</div>
)
}
export default Order
```
export default Order
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(`<BACKEND_URL>/store/orders?display_id=1&email=user@example.com`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.id)
})
```
```ts
fetch(`<BACKEND_URL>/store/orders?display_id=1&email=user@example.com`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.id)
})
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires two query parameters:
@@ -176,53 +176,53 @@ In certain scenarios, you may need to retrieve an order’s details using the ID
You can retrieve an order by the cart ID using the [Get by Cart ID API Route](https://docs.medusajs.com/api/store#orders_getordersordercartid):
<Tabs groupId="request-type" isCodeTabs={true}>
<TabItem value="client" label="Medusa JS Client" default>
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.orders.retrieveByCartId(cartId)
.then(({ order }) => {
console.log(order.id)
})
```
```ts
medusa.orders.retrieveByCartId(cartId)
.then(({ order }) => {
console.log(order.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useCartOrder } from "medusa-react"
```tsx
import { useCartOrder } from "medusa-react"
const Order = () => {
const {
order,
isLoading,
} = useCartOrder(cartId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && <span>{order.display_id}</span>}
</div>
)
}
const Order = () => {
const {
order,
isLoading,
} = useCartOrder(cartId)
return (
<div>
{isLoading && <span>Loading...</span>}
{order && <span>{order.display_id}</span>}
</div>
)
}
export default Order
```
export default Order
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/orders/cart/${cartId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.id)
})
```
```ts
fetch(`<BACKEND_URL>/store/orders/cart/${cartId}`, {
credentials: "include",
})
.then((response) => response.json())
.then(({ order }) => {
console.log(order.id)
})
```
</TabItem>
</TabItem>
</Tabs>
This API Route requires the ID of the cart as a path parameter.