feat(core-flows,medusa,order,types): update orders (#10373)

**What**
- add order update endpoint
- add workflows and steps for updating orders
- add `registerChanges` method to Order module + workflow step

---

CLOSES CMRC-633

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

@@ -1,10 +1,17 @@
-import { getOrderDetailWorkflow } from "@medusajs/core-flows"
+import {
+  getOrderDetailWorkflow,
+  updateOrderWorkflow,
+} from "@medusajs/core-flows"
 import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "@medusajs/framework/http"
-import { HttpTypes } from "@medusajs/framework/types"
-import { AdminGetOrdersOrderParamsType } from "../validators"
+import { AdminOrder, HttpTypes } from "@medusajs/framework/types"
+import {
+  AdminGetOrdersOrderParamsType,
+  AdminUpdateOrderType,
+} from "../validators"
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
 
 export const GET = async (
   req: AuthenticatedMedusaRequest<AdminGetOrdersOrderParamsType>,
@@ -21,3 +28,25 @@ export const GET = async (
 
   res.status(200).json({ order: result as HttpTypes.AdminOrder })
 }
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest<AdminUpdateOrderType>,
+  res: MedusaResponse<HttpTypes.AdminOrderResponse>
+) => {
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+
+  await updateOrderWorkflow(req.scope).run({
+    input: {
+      ...req.validatedBody,
+      id: req.params.id,
+    },
+  })
+
+  const result = await query.graph({
+    entity: "order",
+    filters: { id: req.params.id },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  res.status(200).json({ order: result.data[0] as AdminOrder })
+}

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

@@ -16,6 +16,7 @@ import {
   AdminOrderCreateFulfillment,
   AdminOrderCreateShipment,
   AdminTransferOrder,
+  AdminUpdateOrder,
 } from "./validators"
 
 export const adminOrderRoutesMiddlewares: MiddlewareRoute[] = [
@@ -39,6 +40,17 @@ export const adminOrderRoutesMiddlewares: MiddlewareRoute[] = [
       ),
     ],
   },
+  {
+    method: ["POST"],
+    matcher: "/admin/orders/:id",
+    middlewares: [
+      validateAndTransformBody(AdminUpdateOrder),
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
   {
     method: ["GET"],
     matcher: "/admin/orders/:id/line-items",

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

@@ -5,6 +5,7 @@ import {
   createSelectParams,
   WithAdditionalData,
 } from "../../utils/validators"
+import { AddressPayload } from "../../utils/common-validators"
 
 export const AdminGetOrdersOrderParams = createSelectParams().merge(
   z.object({
@@ -136,3 +137,10 @@ export type AdminCancelOrderTransferRequestType = z.infer<
   typeof AdminCancelOrderTransferRequest
 >
 export const AdminCancelOrderTransferRequest = z.object({})
+
+export type AdminUpdateOrderType = z.infer<typeof AdminUpdateOrder>
+export const AdminUpdateOrder = z.object({
+  email: z.string().optional(),
+  shipping_address: AddressPayload.optional(),
+  billing_address: AddressPayload.optional(),
+})

packages/medusa/src/api/utils/common-validators/common.ts

@@ -2,17 +2,17 @@ import { z } from "zod"
 
 export const AddressPayload = z
   .object({
-    first_name: z.string().nullish(),
-    last_name: z.string().nullish(),
-    phone: z.string().nullish(),
-    company: z.string().nullish(),
-    address_1: z.string().nullish(),
-    address_2: z.string().nullish(),
-    city: z.string().nullish(),
-    country_code: z.string().nullish(),
-    province: z.string().nullish(),
-    postal_code: z.string().nullish(),
-    metadata: z.record(z.unknown()).nullish(),
+    first_name: z.string().optional(),
+    last_name: z.string().optional(),
+    phone: z.string().optional(),
+    company: z.string().optional(),
+    address_1: z.string().optional(),
+    address_2: z.string().optional(),
+    city: z.string().optional(),
+    country_code: z.string().optional(),
+    province: z.string().optional(),
+    postal_code: z.string().optional(),
+    metadata: z.record(z.unknown()).optional(),
   })
   .strict()