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

docs: revise commerce modules overview pages (#10738)

Browse Source 
* revise API Key Module overview

* revise auth module

* support ref sidebar items

* remove examples

* revise cart module

* revise currency

* revise customer module

* revise fulfillment module

* revise inventory module

* revise order module

* revise payment

* revise pricing module

* revise product module

* revise promotion module

* revise region module

* revise sales channel module

* revise stock location module

* revise store module

* revise tax module

* revise user module

* lint content + fix snippets
This commit is contained in:
Shahed Nasser authored and GitHub committed 2024-12-26 10:32:16 +02:00
1 parent c8f9938865
commit ebca8fed28
112 files changed
+9465 -7731
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

www/apps/resources/app/commerce-modules/store/examples/page.mdx
-272
View File
@@ -1,272 +0,0 @@
import { CodeTabs, CodeTab } from "docs-ui"
export const metadata = {
title: `Examples of the Store Module`,
}
# {metadata.title}
In this guide, you’ll find common examples of how you can use the Store Module in your application.
<Note>
You should only use the Store Module's main service when implementing complex customizations. For common cases, check out [available workflows instead](../../../medusa-workflows-reference/page.mdx).
</Note>
## Create a Store
<CodeTabs groupId="app-type">
<CodeTab label="Medusa API Router" value="medusa">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function POST(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const storeModuleService = request.scope.resolve(
Modules.STORE
)
const store = await storeModuleService.createStores({
name: "My Store",
supported_currencies: [
{
currency_code: "usd",
is_default: true,
},
],
})
res.json({
store,
})
}
```
</CodeTab>
<CodeTab label="Next.js App Router" value="nextjs">
```ts
import { NextResponse } from "next/server"
import { initialize as initializeStoreModule } from "@medusajs/medusa/store"
export async function POST(request: Request) {
const storeModuleService = await initializeStoreModule()
const store = await storeModuleService.createStores({
name: "My Store",
supported_currencies: [
{
currency_code: "usd",
is_default: true,
},
],
})
res.json({
store,
})
}
```
</CodeTab>
</CodeTabs>
---
## List Stores
<CodeTabs groupId="app-type">
<CodeTab label="Medusa API Router" value="medusa">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function GET(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const storeModuleService = request.scope.resolve(
Modules.STORE
)
res.json({
stores: await storeModuleService.listStores(),
})
}
```
</CodeTab>
<CodeTab label="Next.js App Router" value="nextjs">
```ts
import { NextResponse } from "next/server"
import { initialize as initializeStoreModule } from "@medusajs/medusa/store"
export async function GET(request: Request) {
const storeModuleService = await initializeStoreModule()
const salesChannels = await storeModuleService.listStores()
return NextResponse.json({
stores: await storeModuleService.list(),
})
}
```
</CodeTab>
</CodeTabs>
---
## Retrieve a Store by its ID
<CodeTabs groupId="app-type">
<CodeTab label="Medusa API Router" value="medusa">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function GET(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const storeModuleService = request.scope.resolve(
Modules.STORE
)
const store = await storeModuleService.retrieveStore("store_123")
res.json({
store,
})
}
```
</CodeTab>
<CodeTab label="Next.js App Router" value="nextjs">
```ts
import { NextResponse } from "next/server"
import { initialize as initializeStoreModule } from "@medusajs/medusa/store"
export async function GET(request: Request, { params }: ContextType) {
const storeModuleService = await initializeStoreModule()
const store = await storeModuleService.retrieveStore("store_123")
return NextResponse.json({ store })
}
```
</CodeTab>
</CodeTabs>
---
## Update a Store
<CodeTabs groupId="app-type">
<CodeTab label="Medusa API Router" value="medusa">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function POST(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const storeModuleService = request.scope.resolve(
Modules.STORE
)
const store = await storeModuleService.updateStores("store_123", {
name: "Change Store",
})
res.json({
store,
})
}
```
</CodeTab>
<CodeTab label="Next.js App Router" value="nextjs">
```ts
import { NextResponse } from "next/server"
import { initialize as initializeStoreModule } from "@medusajs/medusa/store"
export async function POST(request: Request, { params }: ContextType) {
const storeModuleService = await initializeStoreModule()
const store = await storeModuleService.updateStores("store_123", {
name: "Change Store",
})
return NextResponse.json({ store })
}
```
</CodeTab>
</CodeTabs>
---
## Delete a Store
<CodeTabs groupId="app-type">
<CodeTab label="Medusa API Router" value="medusa">
```ts
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
export async function DELETE(
request: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const storeModuleService = request.scope.resolve(
Modules.STORE
)
await storeModuleService.deleteStores("store_123")
res.status(200)
}
```
</CodeTab>
<CodeTab label="Next.js App Router" value="nextjs">
```ts
import { NextResponse } from "next/server"
import { initialize as initializeStoreModule } from "@medusajs/medusa/store"
export async function DELETE(request: Request, { params }: ContextType) {
const storeModuleService = await initializeStoreModule()
await storeModuleService.deleteStores("store_123")
}
```
</CodeTab>
</CodeTabs>
---
## More Examples
The [Store Module's main service reference](/references/store) provides a reference to all the methods available for use with examples for each.
www/apps/resources/app/commerce-modules/store/links-to-other-modules/page.mdx
+4 -4
View File
@@ -39,8 +39,8 @@ To retrieve the details of a store's currencies with [Query](!docs!/learn/fundam
const { data: stores } = await query.graph({
entity: "store",
fields: [
"supported_currencies.currency.*"
]
"supported_currencies.currency.*",
],
})
// stores.supported_currencies
@@ -57,8 +57,8 @@ import { useQueryGraphStep } from "@medusajs/medusa/core-flows"
const { data: stores } = useQueryGraphStep({
entity: "store",
fields: [
"supported_currencies.currency.*"
]
"supported_currencies.currency.*",
],
})
// stores.supported_currencies
www/apps/resources/app/commerce-modules/store/page.mdx
+119 -63
View File
@@ -6,98 +6,154 @@ export const metadata = {
# {metadata.title}
The Store Module provides store-related features in your Medusa and Node.js applications.
In this section of the documentation, you will find resources to learn more about the Store Module and how to use it in your application.
Medusa has store related features available out-of-the-box through the Store Module. A [module](!docs!/learn/fundamentals/modules) is a standalone package that provides features for a single domain. Each of Medusa's commerce features are placed in commerce modules, such as this Store Module.
<Note>
Learn more about why modules are isolated in [this documentation](!docs!/learn/fundamentals/modules/isolation).
</Note>
## Store Features
- [Store Management](/references/store/models/Store): Create and manage stores in your application.
- [Multi-Tenancy Support](/references/store/models/Store): Create multiple stores, each having its own configurations.
---
## How to Use Store Module's Service
You can use the Store Module's main service by resolving from the Medusa container the resource `Modules.STORE`.
In your Medusa application, you build flows around commerce modules. A flow is built as a [Workflow](!docs!/learn/fundamentals/workflows), which is a special function composed of a series of steps that guarantees data consistency and reliable roll-back mechanism.
You can build custom workflows and steps. You can also re-use Medusa's workflows and steps, which are provided by the `@medusajs/medusa/core-flows` package.
For example:
<CodeTabs groupId="resource-type">
<CodeTab label="Workflow Step" value="workflow-step">
export const highlights = [
["12", "Modules.STORE", "Resolve the module in a step."]
]
```ts title="src/workflows/hello-world/step1.ts"
import { createStep } from "@medusajs/framework/workflows-sdk"
```ts title="src/workflows/create-store.ts" highlights={highlights}
import {
createWorkflow,
WorkflowResponse,
createStep,
StepResponse,
} from "@medusajs/framework/workflows-sdk"
import { Modules } from "@medusajs/framework/utils"
const step1 = createStep("step-1", async (_, { container }) => {
const storeModuleService: IStoreModuleService = container.resolve(
Modules.STORE
)
const createStoreStep = createStep(
"create-store",
async ({}, { container }) => {
const storeModuleService = container.resolve(Modules.STORE)
const stores = await storeModuleService.listStores()
})
const store = await storeModuleService.createStores({
name: "My Store",
supported_currencies: [{
currency_code: "usd",
is_default: true,
}],
})
return new StepResponse({ store }, store.id)
},
async (storeId, { container }) => {
if(!storeId) {
return
}
const storeModuleService = container.resolve(Modules.STORE)
await storeModuleService.deleteStores([storeId])
}
)
export const createStoreWorkflow = createWorkflow(
"create-store",
() => {
const { store } = createStoreStep()
return new WorkflowResponse({ store })
}
)
```
</CodeTab>
<CodeTab label="API Route" value="api-route">
You can then execute the workflow in your custom API routes, scheduled jobs, or subscribers:
```ts title="src/api/store/custom/route.ts"
import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
import { Modules } from "@medusajs/framework/utils"
<CodeTabs group="resource-types">
<CodeTab label="API Route" value="api-route">
```ts title="src/api/workflow/route.ts" highlights={[["11"], ["12"]]} collapsibleLines="1-6" expandButtonLabel="Show Imports"
import type {
MedusaRequest,
MedusaResponse,
} from "@medusajs/framework/http"
import { createStoreWorkflow } from "../../workflows/create-store"
export async function GET(
request: MedusaRequest,
req: MedusaRequest,
res: MedusaResponse
): Promise<void> {
const storeModuleService: IStoreModuleService = request.scope.resolve(
Modules.STORE
)
) {
const { result } = await createStoreWorkflow(req.scope)
.run()
res.json({
stores: await storeModuleService.listStores(),
})
res.send(result)
}
```
</CodeTab>
<CodeTab label="Subscriber" value="subscribers">
<CodeTab label="Subscriber" value="subscriber">
```ts title="src/subscribers/user-created.ts" highlights={[["11"], ["12"]]} collapsibleLines="1-6" expandButtonLabel="Show Imports"
import {
type SubscriberConfig,
type SubscriberArgs,
} from "@medusajs/framework"
import { createStoreWorkflow } from "../workflows/create-store"
```ts title="src/subscribers/custom-handler.ts"
import { SubscriberArgs } from "@medusajs/framework"
import { Modules } from "@medusajs/framework/utils"
export default async function handleUserCreated({
event: { data },
container,
}: SubscriberArgs<{ id: string }>) {
const { result } = await createStoreWorkflow(container)
.run()
export default async function subscriberHandler({ container }: SubscriberArgs) {
const storeModuleService: IStoreModuleService = container.resolve(
Modules.STORE
)
console.log(result)
}
const stores = await storeModuleService.listStores()
export const config: SubscriberConfig = {
event: "user.created",
}
```
</CodeTab>
<CodeTab label="Scheduled Job" value="scheduled-job">
```ts title="src/jobs/run-daily.ts" highlights={[["7"], ["8"]]}
import { MedusaContainer } from "@medusajs/framework/types"
import { createStoreWorkflow } from "../workflows/create-store"
export default async function myCustomJob(
container: MedusaContainer
) {
const { result } = await createStoreWorkflow(container)
.run()
console.log(result)
}
export const config = {
name: "run-once-a-day",
schedule: `0 0 * * *`,
}
```
</CodeTab>
</CodeTabs>
Learn more about workflows in [this documentation](!docs!/learn/fundamentals/workflows).
---
## Features
### Store Management
A store holds the main configurations of your commerce store, such as supported currencies, default region and sales channel, and more.
```ts
const store = await storeModuleService.createStores({
name: "My Store",
supported_currency_codes: ["usd"],
})
```
### Multi-Tenancy Support
You can create multiple stores, each having its own configurations.
```ts
const stores = await storeModuleService.createStores([
{
name: "USA Store",
supported_currency_codes: ["usd"],
},
{
name: "Europe Store",
supported_currency_codes: ["eur"],
},
])
```
<CommerceModuleSections name="Store" />