feat: Add order endpoints for store (#7266)

packages/medusa/src/api-v2/middlewares.ts

@@ -43,6 +43,7 @@ import { storeRegionRoutesMiddlewares } from "./store/regions/middlewares"
 import { storePaymentProvidersMiddlewares } from "./store/payment-providers/middlewares"
 import { storePaymentCollectionsMiddlewares } from "./store/payment-collections/middlewares"
 import { storeShippingOptionRoutesMiddlewares } from "./store/shipping-options/middlewares"
+import { storeOrderRoutesMiddlewares } from "./store/orders/middlewares"
 
 export const config: MiddlewaresConfig = {
   routes: [
@@ -58,6 +59,7 @@ export const config: MiddlewaresConfig = {
     ...storePaymentProvidersMiddlewares,
     ...storeShippingOptionRoutesMiddlewares,
     ...storePaymentCollectionsMiddlewares,
+    ...storeOrderRoutesMiddlewares,
     ...authRoutesMiddlewares,
     ...adminWorkflowsExecutionsMiddlewares,
     ...storeRegionRoutesMiddlewares,

packages/medusa/src/api-v2/store/carts/middlewares.ts

@@ -3,7 +3,7 @@ import { authenticate } from "../../../utils/authenticate-middleware"
 import { validateAndTransformBody } from "../../utils/validate-body"
 import { validateAndTransformQuery } from "../../utils/validate-query"
 import * as OrderQueryConfig from "../orders/query-config"
-import { StoreGetOrder } from "../orders/validators"
+import { StoreGetOrderParams } from "../orders/validators"
 import * as QueryConfig from "./query-config"
 import {
   StoreAddCartLineItem,
@@ -142,7 +142,7 @@ export const storeCartRoutesMiddlewares: MiddlewareRoute[] = [
     middlewares: [
       validateAndTransformBody(StoreCompleteCart),
       validateAndTransformQuery(
-        StoreGetOrder,
+        StoreGetOrderParams,
         OrderQueryConfig.retrieveTransformQueryConfig
       ),
     ],

packages/medusa/src/api-v2/store/orders/[id]/route.ts

@@ -0,0 +1,13 @@
+import { MedusaRequest, MedusaResponse } from "../../../../types/routing"
+import { refetchOrder } from "../helpers"
+
+// TODO: Do we want to apply some sort of authentication here? My suggestion is that we do
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const order = await refetchOrder(
+    req.params.id,
+    req.scope,
+    req.remoteQueryConfig.fields
+  )
+
+  res.json({ order })
+}

packages/medusa/src/api-v2/store/orders/middlewares.ts

@@ -0,0 +1,32 @@
+import { MiddlewareRoute } from "../../../loaders/helpers/routing/types"
+import { authenticate } from "../../../utils/authenticate-middleware"
+import { validateAndTransformQuery } from "../../utils/validate-query"
+import * as QueryConfig from "./query-config"
+import { StoreGetOrderParams, StoreGetOrdersParams } from "./validators"
+
+export const storeOrderRoutesMiddlewares: MiddlewareRoute[] = [
+  {
+    method: ["GET"],
+    matcher: "/store/orders",
+    middlewares: [
+      authenticate("store", ["session", "bearer"]),
+      validateAndTransformQuery(
+        StoreGetOrdersParams,
+        QueryConfig.listTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["GET"],
+    matcher: "/store/orders/:id",
+    middlewares: [
+      authenticate("store", ["session", "bearer"], {
+        allowUnauthenticated: true,
+      }),
+      validateAndTransformQuery(
+        StoreGetOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+]

packages/medusa/src/api-v2/store/orders/query-config.ts

@@ -15,6 +15,7 @@ export const defaultStoreRetrieveOrderFields = [
   "status",
   "version",
   "summary",
+  "currency_code",
   "total",
   "subtotal",
   "tax_total",
@@ -53,3 +54,8 @@ export const retrieveTransformQueryConfig = {
   defaults: defaultStoreRetrieveOrderFields,
   isList: false,
 }
+
+export const listTransformQueryConfig = {
+  defaults: defaultStoreOrderFields,
+  isList: false,
+}

packages/medusa/src/api-v2/store/orders/route.ts

@@ -0,0 +1,34 @@
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../types/routing"
+import { AdminGetOrdersParamsType } from "../../admin/draft-orders/validators"
+
+export const GET = async (
+  req: AuthenticatedMedusaRequest<AdminGetOrdersParamsType>,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order",
+    variables: {
+      filters: { ...req.filterableFields, customer_id: req.auth.actor_id },
+      ...req.remoteQueryConfig.pagination,
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const { rows: orders, metadata } = await remoteQuery(queryObject)
+
+  res.json({
+    orders,
+    count: metadata.count,
+    offset: metadata.skip,
+    limit: metadata.take,
+  })
+}

packages/medusa/src/api-v2/store/orders/validators.ts

@@ -1,5 +1,18 @@
 import { z } from "zod"
-import { createSelectParams } from "../../utils/validators"
+import { createFindParams, createSelectParams } from "../../utils/validators"
 
-export const StoreGetOrder = createSelectParams()
-export type StoreGetOrderType = z.infer<typeof StoreGetOrder>
+export const StoreGetOrderParams = createSelectParams()
+export type StoreGetOrderParamsType = z.infer<typeof StoreGetOrderParams>
+
+export const StoreGetOrdersParams = createFindParams({
+  offset: 0,
+  limit: 50,
+}).merge(
+  z.object({
+    id: z.union([z.string(), z.array(z.string())]).optional(),
+    status: z.union([z.string(), z.array(z.string())]).optional(),
+    $and: z.lazy(() => StoreGetOrdersParams.array()).optional(),
+    $or: z.lazy(() => StoreGetOrdersParams.array()).optional(),
+  })
+)
+export type StoreGetOrdersParamsType = z.infer<typeof StoreGetOrdersParams>