chore(medusa,core-flows): begin and cancel receive return (#8171)

What:
* `POST /admin/returns/:id/receive` 
* `DELETE /admin/returns/:id/receive`

CLOSES: CC-189

packages/medusa/src/api/admin/returns/[id]/cancel/route.ts

@@ -6,14 +6,17 @@ import {
 import { AdminPostCancelReturnReqSchemaType } from "../../validators"
 
 export const POST = async (
-  req: AuthenticatedMedusaRequest,
+  req: AuthenticatedMedusaRequest<AdminPostCancelReturnReqSchemaType>,
   res: MedusaResponse
 ) => {
-  const input = req.validatedBody as AdminPostCancelReturnReqSchemaType
+  const { id } = req.params
 
   const workflow = cancelReturnWorkflow(req.scope)
   const { result } = await workflow.run({
-    input,
+    input: {
+      ...req.validatedBody,
+      return_id: id,
+    },
   })
 
   res.status(200).json({ return: result })

packages/medusa/src/api/admin/returns/[id]/receive/route.ts

@@ -1,4 +1,13 @@
-import { receiveReturnOrderWorkflow } from "@medusajs/core-flows"
+import {
+  beginReceiveReturnWorkflow,
+  cancelReturnReceiveWorkflow,
+} from "@medusajs/core-flows"
+import {
+  ContainerRegistrationKeys,
+  ModuleRegistrationName,
+  promiseAll,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
 import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
@@ -9,12 +18,56 @@ export const POST = async (
   req: AuthenticatedMedusaRequest<AdminPostReceiveReturnsReqSchemaType>,
   res: MedusaResponse
 ) => {
-  const input = req.validatedBody as AdminPostReceiveReturnsReqSchemaType
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+  const orderModuleService = req.scope.resolve(ModuleRegistrationName.ORDER)
 
-  const workflow = receiveReturnOrderWorkflow(req.scope)
+  const { id } = req.params
+
+  const workflow = beginReceiveReturnWorkflow(req.scope)
   const { result } = await workflow.run({
-    input,
+    input: {
+      ...req.validatedBody,
+      return_id: id,
+    },
   })
 
-  res.status(200).json({ return: result })
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "return",
+    variables: {
+      id: result.return_id,
+      filters: {
+        ...req.filterableFields,
+      },
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [order, orderReturn] = await promiseAll([
+    orderModuleService.retrieveOrder(result.order_id),
+    remoteQuery(queryObject),
+  ])
+
+  res.json({
+    order,
+    return: orderReturn[0],
+  })
+}
+
+export const DELETE = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const { id } = req.params
+
+  await cancelReturnReceiveWorkflow(req.scope).run({
+    input: {
+      return_id: id,
+    },
+  })
+
+  res.status(200).json({
+    id,
+    object: "return",
+    deleted: true,
+  })
 }

packages/medusa/src/api/admin/returns/middlewares.ts

@@ -5,6 +5,7 @@ import * as QueryConfig from "./query-config"
 import {
   AdminGetOrdersOrderParams,
   AdminGetOrdersParams,
+  AdminPostReceiveReturnsReqSchema,
   AdminPostReturnsConfirmRequestReqSchema,
   AdminPostReturnsReqSchema,
   AdminPostReturnsRequestItemsActionReqSchema,
@@ -125,4 +126,20 @@ export const adminReturnRoutesMiddlewares: MiddlewareRoute[] = [
     matcher: "/admin/returns/:id/request",
     middlewares: [],
   },
+  {
+    method: ["POST"],
+    matcher: "/admin/returns/:id/receive",
+    middlewares: [
+      validateAndTransformBody(AdminPostReceiveReturnsReqSchema),
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
+  {
+    method: ["DELETE"],
+    matcher: "/admin/returns/:id/receive",
+    middlewares: [],
+  },
 ]

packages/medusa/src/api/admin/returns/route.ts

@@ -1,6 +1,8 @@
 import { beginReturnOrderWorkflow } from "@medusajs/core-flows"
 import {
   ContainerRegistrationKeys,
+  ModuleRegistrationName,
+  promiseAll,
   remoteQueryObjectFromString,
 } from "@medusajs/utils"
 import {
@@ -42,6 +44,7 @@ export const POST = async (
 ) => {
   const input = req.validatedBody as AdminPostReturnsReqSchemaType
   const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+  const orderModuleService = req.scope.resolve(ModuleRegistrationName.ORDER)
 
   const workflow = beginReturnOrderWorkflow(req.scope)
   const { result } = await workflow.run({
@@ -59,10 +62,13 @@ export const POST = async (
     fields: req.remoteQueryConfig.fields,
   })
 
-  const [orderReturn] = await remoteQuery(queryObject)
+  const [order, orderReturn] = await promiseAll([
+    orderModuleService.retrieveOrder(result.order_id),
+    remoteQuery(queryObject),
+  ])
 
   res.json({
-    order_preview: result,
-    return: orderReturn,
+    order,
+    return: orderReturn[0],
   })
 }

packages/medusa/src/api/admin/returns/validators.ts

@@ -38,13 +38,6 @@ export const AdminGetOrdersParams = createFindParams({
 
 export type AdminGetOrdersParamsType = z.infer<typeof AdminGetOrdersParams>
 
-const ItemSchema = z.object({
-  id: z.string(),
-  quantity: z.number().min(1),
-  reason_id: z.string().nullish(),
-  note: z.string().optional(),
-})
-
 export const AdminPostReturnsReqSchema = z.object({
   order_id: z.string(),
   location_id: z.string().optional(),
@@ -79,21 +72,33 @@ export type AdminPostOrderExchangesReqSchemaType = z.infer<
 >
 
 export const AdminPostReceiveReturnsReqSchema = z.object({
-  return_id: z.string(),
-  items: z.array(ItemSchema),
-  internal_note: z.string().nullish(),
+  internal_note: z.string().optional(),
+  description: z.string().optional(),
+  metadata: z.record(z.unknown()).nullish(),
 })
 export type AdminPostReceiveReturnsReqSchemaType = z.infer<
   typeof AdminPostReceiveReturnsReqSchema
 >
 
+const ReceiveItemSchema = z.object({
+  id: z.string(),
+  quantity: z.number().min(1),
+  internal_note: z.string().optional(),
+})
+export const AdminPostReceiveReturnItemsReqSchema = z.object({
+  items: z.array(ReceiveItemSchema),
+})
+export type AdminPostReceiveReturnItemsReqSchemaType = z.infer<
+  typeof AdminPostReceiveReturnItemsReqSchema
+>
+
 export const AdminPostCancelReturnReqSchema = z.object({
   return_id: z.string(),
   no_notification: z.boolean().optional(),
   internal_note: z.string().nullish(),
 })
 export type AdminPostCancelReturnReqSchemaType = z.infer<
-  typeof AdminPostReceiveReturnsReqSchema
+  typeof AdminPostCancelReturnReqSchema
 >
 
 export const AdminPostReturnsShippingReqSchema = z.object({