chore: reorganize docs apps (#7228)

* reorganize docs apps

* add README

* fix directory

* add condition for old docs

www/apps/resources/app/commerce-modules/user/examples/page.mdx

@@ -0,0 +1,411 @@
+import { CodeTabs, CodeTab } from "docs-ui"
+
+export const metadata = {
+  title: `Examples of the User Module`,
+}
+
+# {metadata.title}
+
+In this guide, you’ll find common examples of how you can use the User Module in your application.
+
+## Create a User
+
+<CodeTabs groupId="app-type">
+  <CodeTab label="Medusa API Router" value="medusa">
+
+  ```ts
+  import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  export async function POST(
+    req: MedusaRequest,
+    res: MedusaResponse
+  ): Promise<void> {
+    const userModuleService: IUserModuleService =
+      req.scope.resolve(ModuleRegistrationName.USER)
+
+    const user = await userModuleService.create({
+      email: "user@example.com",
+      first_name: "John",
+      last_name: "Smith",
+    })
+
+    res.json({ user })
+  }
+  ```
+
+  </CodeTab>
+  <CodeTab label="Next.js App Router" value="nextjs">
+
+  ```ts
+  import { NextResponse } from "next/server"
+
+  import {
+    initialize as initializeUserModule,
+  } from "@medusajs/user"
+
+  export async function POST(request: Request) {
+    const userModuleService = await initializeUserModule()
+
+    const user = await userModuleService.create({
+      email: "user@example.com",
+      first_name: "John",
+      last_name: "Smith",
+    })
+
+    return NextResponse.json({
+      user,
+    })
+  }
+  ```
+
+  </CodeTab>
+</CodeTabs>
+
+---
+
+## List Users
+
+<CodeTabs groupId="app-type">
+  <CodeTab label="Medusa API Router" value="medusa">
+
+  ```ts
+  import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  export async function GET(
+    req: MedusaRequest,
+    res: MedusaResponse
+  ): Promise<void> {
+    const userModuleService: IUserModuleService =
+      req.scope.resolve(ModuleRegistrationName.USER)
+
+    res.json({
+      users: await userModuleService.list(),
+    })
+  }
+  ```
+
+  </CodeTab>
+  <CodeTab label="Next.js App Router" value="nextjs">
+
+  ```ts
+  import { NextResponse } from "next/server"
+
+  import {
+    initialize as initializeUserModule,
+  } from "@medusajs/user"
+
+  export async function GET(request: Request) {
+    const userModuleService = await initializeUserModule()
+
+    return NextResponse.json({
+      users: await userModuleService.list(),
+    })
+  }
+  ```
+
+  </CodeTab>
+</CodeTabs>
+
+---
+
+## Update a User
+
+<CodeTabs groupId="app-type">
+  <CodeTab label="Medusa API Router" value="medusa">
+
+  ```ts
+  import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  export async function POST(
+    req: MedusaRequest,
+    res: MedusaResponse
+  ): Promise<void> {
+    const userModuleService: IUserModuleService =
+      req.scope.resolve(ModuleRegistrationName.USER)
+
+    const user = await userModuleService.update({
+      id: "user_123",
+      last_name: "Smith",
+    })
+
+    res.json({ user })
+  }
+  ```
+
+  </CodeTab>
+  <CodeTab label="Next.js App Router" value="nextjs">
+
+  ```ts
+  import { NextResponse } from "next/server"
+
+  import {
+    initialize as initializeUserModule,
+  } from "@medusajs/user"
+
+  export async function POST(
+    request: Request
+  ) {
+    const userModuleService = await initializeUserModule()
+
+    const user = await userModuleService.update({
+      id: "user_123",
+      last_name: "Smith",
+    })
+
+    return NextResponse.json({
+      user,
+    })
+  }
+  ```
+
+  </CodeTab>
+</CodeTabs>
+
+---
+
+## Delete a User
+
+<CodeTabs groupId="app-type">
+  <CodeTab label="Medusa API Router" value="medusa">
+
+  ```ts
+  import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  export async function DELETE(
+    req: MedusaRequest,
+    res: MedusaResponse
+  ): Promise<void> {
+    const userModuleService: IUserModuleService =
+      req.scope.resolve(ModuleRegistrationName.USER)
+
+    await userModuleService.delete(["user_123"])
+  }
+  ```
+
+  </CodeTab>
+  <CodeTab label="Next.js App Router" value="nextjs">
+
+  ```ts
+  import { NextResponse } from "next/server"
+
+  import {
+    initialize as initializeUserModule,
+  } from "@medusajs/user"
+
+  export async function DELETE(
+    request: Request
+  ) {
+    const userModuleService = await initializeUserModule()
+
+    await userModuleService.delete(["user_123"])
+  }
+  ```
+
+  </CodeTab>
+</CodeTabs>
+
+---
+
+## Invite User
+
+<CodeTabs groupId="app-type">
+  <CodeTab label="Medusa API Router" value="medusa">
+
+  ```ts
+  import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  export async function POST(
+    req: MedusaRequest,
+    res: MedusaResponse
+  ): Promise<void> {
+    const userModuleService: IUserModuleService =
+      req.scope.resolve(ModuleRegistrationName.USER)
+
+    const invite = await userModuleService.createInvites({
+      email: "user2@example.com",
+    })
+
+    res.json({
+      invite,
+    })
+  }
+  ```
+
+  </CodeTab>
+  <CodeTab label="Next.js App Router" value="nextjs">
+
+  ```ts
+  import { NextResponse } from "next/server"
+
+  import {
+    initialize as initializeUserModule,
+  } from "@medusajs/user"
+
+  export async function POST(
+    request: Request,
+    { params }: ContextType
+  ) {
+    const userModuleService = await initializeUserModule()
+
+    const invite = await userModuleService.createInvites({
+      email: "user2@example.com",
+    })
+
+    return NextResponse.json({
+      invite,
+    })
+  }
+  ```
+
+  </CodeTab>
+</CodeTabs>
+
+---
+
+## Accept Invite
+
+<CodeTabs groupId="app-type">
+  <CodeTab label="Medusa API Router" value="medusa">
+
+  ```ts
+  import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  export async function POST(
+    req: MedusaRequest,
+    res: MedusaResponse
+  ): Promise<void> {
+    const userModuleService: IUserModuleService =
+      req.scope.resolve(ModuleRegistrationName.USER)
+
+    const invite =
+      await userModuleService.validateInviteToken("secret_123")
+
+    const user = await userModuleService.create({
+      email: invite.email,
+      metadata: invite.metadata,
+    })
+
+    await userModuleService.updateInvites({
+      id: invite.id,
+      accepted: true,
+    })
+
+    res.json({
+      user,
+    })
+  }
+  ```
+
+  </CodeTab>
+  <CodeTab label="Next.js App Router" value="nextjs">
+
+  ```ts
+  import { NextResponse } from "next/server"
+
+  import {
+    initialize as initializeUserModule,
+  } from "@medusajs/user"
+
+  export async function POST(
+    request: Request,
+    { params }: ContextType
+  ) {
+    const userModuleService = await initializeUserModule()
+
+    const invite =
+      await userModuleService.validateInviteToken("secret_123")
+
+    const user = await userModuleService.create({
+      email: invite.email,
+      metadata: invite.metadata,
+    })
+
+    await userModuleService.updateInvites({
+      id: invite.id,
+      accepted: true,
+    })
+
+    return NextResponse.json({
+      user,
+    })
+  }
+  ```
+
+  </CodeTab>
+</CodeTabs>
+
+---
+
+## Refresh Invite
+
+<CodeTabs groupId="app-type">
+  <CodeTab label="Medusa API Router" value="medusa">
+
+  ```ts
+  import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  export async function POST(
+    req: MedusaRequest,
+    res: MedusaResponse
+  ): Promise<void> {
+    const userModuleService: IUserModuleService =
+      req.scope.resolve(ModuleRegistrationName.USER)
+
+    const invites = await userModuleService.refreshInviteTokens([
+      "invite_123",
+    ])
+
+    res.json({
+      invite: invites[0],
+    })
+  }
+  ```
+
+  </CodeTab>
+  <CodeTab label="Next.js App Router" value="nextjs">
+
+  ```ts
+  import { NextResponse } from "next/server"
+
+  import {
+    initialize as initializeUserModule,
+  } from "@medusajs/user"
+
+  export async function POST(
+    request: Request,
+    { params }: ContextType
+  ) {
+    const userModuleService = await initializeUserModule()
+
+    const invites = await userModuleService.refreshInviteTokens([
+      "invite_123",
+    ])
+
+    return NextResponse.json({
+      invite: invites[0],
+    })
+  }
+  ```
+
+  </CodeTab>
+</CodeTabs>
+
+---
+
+## More Examples
+
+The [module interface reference](/references/user) provides a reference to all the methods available for use with examples for each.

www/apps/resources/app/commerce-modules/user/module-options/page.mdx

@@ -0,0 +1,64 @@
+---
+sidebar_label: "Module Options"
+---
+
+import { Table } from "docs-ui"
+
+export const metadata = {
+  title: `User Module Options`,
+}
+
+# {metadata.title}
+
+In this document, you'll learn about the options of the User Module.
+
+## Module Options
+
+```js title="medusa-config.js"
+const modules = {
+  // ...
+  user: {
+    resolve: "@medusajs/user",
+    options: {
+      jwt_secret: process.env.JWT_SECRET,
+    },
+  },
+}
+```
+
+<Table>
+  <Table.Header>
+    <Table.Row>
+      <Table.HeaderCell>Option</Table.HeaderCell>
+      <Table.HeaderCell>Description</Table.HeaderCell>
+      <Table.HeaderCell>Required</Table.HeaderCell>
+    </Table.Row>
+  </Table.Header>
+  <Table.Body>
+    <Table.Row>
+      <Table.Cell>
+      
+      `jwt_secret`
+      
+      </Table.Cell>
+      <Table.Cell>
+      
+      A string indicating the secret used to sign the invite tokens.
+      
+      </Table.Cell>
+      <Table.Cell>
+      
+      Yes
+      
+      </Table.Cell>
+    </Table.Row>
+  </Table.Body>
+</Table>
+
+### Environment Variables
+
+Make sure to add the necessary environment variables for the above options in `.env`:
+
+```bash
+JWT_SECRET=supersecret
+```

www/apps/resources/app/commerce-modules/user/page.mdx

@@ -0,0 +1,127 @@
+import { CodeTabs, CodeTab } from "docs-ui"
+
+export const metadata = {
+  title: `User Module`,
+}
+
+# {metadata.title}
+
+The User Module is the `@medusajs/user` NPM package that provides user-related features in your Medusa and Node.js applications.
+
+---
+
+## Features
+
+### User Management
+
+Manage and store your users through Create, Read, Update, and Delete (CRUD) operations:
+
+```ts
+const user = await userModuleService.create({
+  email: "user@example.com",
+  first_name: "John",
+  last_name: "Smith",
+})
+```
+
+### Invite Users
+
+Invite users to join your store and manage those invites, with expiry and revalidation features.
+
+```ts
+const invite = await userModuleService.createInvites({
+  email: "user2@example.com",
+})
+
+// refresh token later
+await userModuleService.refreshInviteTokens([invite.id])
+```
+
+---
+
+## Configure User Module
+
+After installing the `@medusajs/user` package in your Medusa application, add it to the `modules` object in `medusa-config.js`:
+
+```js title="medusa-config.js"
+const modules = {
+  // ...
+  user: {
+    resolve: "@medusajs/user",
+    options: {
+      jwt_secret: process.env.JWT_SECRET,
+    },
+  },
+}
+```
+
+### Module Options
+
+Refer to [this documentation](./module-options/page.mdx) for details on the module's options.
+
+---
+
+## How to Use User Module's Service
+
+You can use the User Module's main service by resolving from the Medusa container the resource `ModuleRegistrationName.USER` imported from `@medusajs/modules-sdk`.
+
+For example:
+
+<CodeTabs groupId="resource-type">
+  <CodeTab label="API Route" value="api-route">
+
+  ```ts title="src/api/store/custom/route.ts"
+  import { MedusaRequest, MedusaResponse } from "@medusajs/medusa"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  export async function GET(
+    req: MedusaRequest,
+    res: MedusaResponse
+  ): Promise<void> {
+    const userModuleService: IUserModuleService =
+      req.scope.resolve(ModuleRegistrationName.USER)
+
+    res.json({
+      users: await userModuleService.list(),
+    })
+  }
+  ```
+
+  </CodeTab>
+  <CodeTab label="Subscriber" value="subscribers">
+
+  ```ts title="src/subscribers/custom-handler.ts"
+  import { SubscriberArgs } from "@medusajs/medusa"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  export default async function subscriberHandler({
+    container,
+  }: SubscriberArgs) {
+    const userModuleService: IUserModuleService =
+      container.resolve(ModuleRegistrationName.USER)
+
+    const users = await userModuleService.list()
+  }
+  ```
+
+  </CodeTab>
+  <CodeTab label="Workflow Step" value="workflow-step">
+
+  ```ts title="src/workflows/hello-world/step1.ts"
+  import { createStep } from "@medusajs/workflows-sdk"
+  import { IUserModuleService } from "@medusajs/types"
+  import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+
+  const step1 = createStep("step-1", async (_, context) => {
+    const userModuleService: IUserModuleService =
+      context.container.resolve(
+        ModuleRegistrationName.USER
+      )
+    const users = await userModuleService.list()
+  })
+  ```
+
+  </CodeTab>
+</CodeTabs>

www/apps/resources/app/commerce-modules/user/user-creation-flows/page.mdx

@@ -0,0 +1,61 @@
+export const metadata = {
+  title: `User Creation Flows`,
+}
+
+# {metadata.title}
+
+This document provides some possible flows to create a user.
+
+## Using the Auth Module
+
+The Auth Module allows you to create a user with different providers, such as creating a user with an email and password or creating a user using their Google account.
+
+Learn more about this creation flow in [this Auth Module guide](../../auth/user-creation/page.mdx).
+
+---
+
+## Invite Users
+
+Another possible flow to create a user is by sending them an invite. Then, once they accept it, you create a new user for them:
+
+```ts
+// create invite
+const invite = await userModuleService.createInvites({
+  email: "user@example.com",
+})
+
+// later, accept invite and create user
+const invite =
+  await userModuleService.validateInviteToken("secret123")
+
+await userModuleService.updateInvites({
+  id: invite.id,
+  accepted: true,
+})
+
+const user = await userModuleService.create({
+  email: invite.email,
+})
+```
+
+### Invite Expiry
+
+An invite has an expiry date. You can renew the expiry date and refresh the token using the `refreshInviteTokens` method:
+
+```ts
+await userModuleService.refreshInviteTokens(["invite_123"])
+```
+
+---
+
+## Straightforward Creation
+
+Finally, you can create a user using the `create` method of the User Module’s main service (`IUserModuleService`):
+
+```ts
+const user = await userModuleService.create({
+  email: "user@example.com",
+})
+```
+
+However, the User Module doesn’t handle authentication methods or store a user’s password. For that, you’d need to use the [Auth Module](../../auth/page.mdx).