fix: make packages/medusa/src/api/routes/admin/orders pass eslint (#649)

.eslintignore

@@ -27,7 +27,6 @@
 /packages/medusa/src/api/routes/admin/auth
 /packages/medusa/src/api/routes/admin/collections
 /packages/medusa/src/api/routes/admin/notes
-/packages/medusa/src/api/routes/admin/orders
 /packages/medusa/src/api/routes/admin/store
 /packages/medusa/src/api/routes/store/carts
 /packages/medusa/src/api/routes/store/return-reasons

packages/medusa/src/api/routes/admin/orders/add-shipping-method.js

@@ -1,4 +1,3 @@
-import _ from "lodash"
 import { Validator, MedusaError } from "medusa-core-utils"
 import { defaultFields, defaultRelations } from "./"
 
@@ -28,15 +27,9 @@ export default async (req, res) => {
   const { id } = req.params
 
   const schema = Validator.object().keys({
-    price: Validator.number()
+    price: Validator.number().integer().integer().allow(0).required(),
-      .integer()
-      .integer()
-      .allow(0)
-      .required(),
     option_id: Validator.string().required(),
-    data: Validator.object()
+    data: Validator.object().optional().default({}),
-      .optional()
-      .default({}),
   })
 
   const { value, error } = schema.validate(req.body)
@@ -44,20 +37,16 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    await orderService.addShippingMethod(id, value.option_id, value.data, {
+  await orderService.addShippingMethod(id, value.option_id, value.data, {
-      price: value.price,
+    price: value.price,
-    })
+  })
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.status(200).json({ order })
+  res.status(200).json({ order })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/orders/archive-order.js

@@ -1,17 +1,13 @@
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    await orderService.archive(id)
+  await orderService.archive(id)
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      relations: ["region", "customer", "swaps"],
+    relations: ["region", "customer", "swaps"],
-    })
+  })
 
-    res.json({ order })
+  res.json({ order })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/cancel-claim.js

@@ -24,28 +24,24 @@ import { defaultRelations, defaultFields } from "."
 export default async (req, res) => {
   const { id, claim_id } = req.params
 
-  try {
+  const claimService = req.scope.resolve("claimService")
-    const claimService = req.scope.resolve("claimService")
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    const claim = await claimService.retrieve(claim_id)
+  const claim = await claimService.retrieve(claim_id)
 
-    if (claim.order_id !== id) {
+  if (claim.order_id !== id) {
-      throw new MedusaError(
+    throw new MedusaError(
-        MedusaError.Types.NOT_FOUND,
+      MedusaError.Types.NOT_FOUND,
-        `no claim was found with the id: ${claim_id} related to order: ${id}`
+      `no claim was found with the id: ${claim_id} related to order: ${id}`
-      )
+    )
-    }
-
-    await claimService.cancel(claim_id)
-
-    const order = await orderService.retrieve(id, {
-      select: defaultFields,
-      relations: defaultRelations,
-    })
-
-    res.json({ order })
-  } catch (error) {
-    throw error
   }
+
+  await claimService.cancel(claim_id)
+
+  const order = await orderService.retrieve(id, {
+    select: defaultFields,
+    relations: defaultRelations,
+  })
+
+  res.json({ order })
 }

packages/medusa/src/api/routes/admin/orders/cancel-fulfillment-claim.js

@@ -25,37 +25,33 @@ import { defaultRelations, defaultFields } from "."
 export default async (req, res) => {
   const { id, claim_id, fulfillment_id } = req.params
 
-  try {
+  const fulfillmentService = req.scope.resolve("fulfillmentService")
-    const fulfillmentService = req.scope.resolve("fulfillmentService")
+  const claimService = req.scope.resolve("claimService")
-    const claimService = req.scope.resolve("claimService")
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
+  const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
 
-    if (fulfillment.claim_order_id !== claim_id) {
+  if (fulfillment.claim_order_id !== claim_id) {
-      throw new MedusaError(
+    throw new MedusaError(
-        MedusaError.Types.NOT_FOUND,
+      MedusaError.Types.NOT_FOUND,
-        `no fulfillment was found with the id: ${fulfillment_id} related to claim: ${claim_id}`
+      `no fulfillment was found with the id: ${fulfillment_id} related to claim: ${claim_id}`
-      )
+    )
-    }
-
-    const claim = await claimService.retrieve(claim_id)
-
-    if (claim.order_id !== id) {
-      throw new MedusaError(
-        MedusaError.Types.NOT_FOUND,
-        `no claim was found with the id: ${claim_id} related to order: ${id}`
-      )
-    }
-
-    await claimService.cancelFulfillment(fulfillment_id)
-
-    const order = await orderService.retrieve(id, {
-      select: defaultFields,
-      relations: defaultRelations,
-    })
-    res.json({ order })
-  } catch (error) {
-    throw error
   }
+
+  const claim = await claimService.retrieve(claim_id)
+
+  if (claim.order_id !== id) {
+    throw new MedusaError(
+      MedusaError.Types.NOT_FOUND,
+      `no claim was found with the id: ${claim_id} related to order: ${id}`
+    )
+  }
+
+  await claimService.cancelFulfillment(fulfillment_id)
+
+  const order = await orderService.retrieve(id, {
+    select: defaultFields,
+    relations: defaultRelations,
+  })
+  res.json({ order })
 }

packages/medusa/src/api/routes/admin/orders/cancel-fulfillment-swap.js

@@ -25,38 +25,34 @@ import { defaultRelations, defaultFields } from "."
 export default async (req, res) => {
   const { id, swap_id, fulfillment_id } = req.params
 
-  try {
+  const fulfillmentService = req.scope.resolve("fulfillmentService")
-    const fulfillmentService = req.scope.resolve("fulfillmentService")
+  const swapService = req.scope.resolve("swapService")
-    const swapService = req.scope.resolve("swapService")
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
+  const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
 
-    if (fulfillment.swap_id !== swap_id) {
+  if (fulfillment.swap_id !== swap_id) {
-      throw new MedusaError(
+    throw new MedusaError(
-        MedusaError.Types.NOT_FOUND,
+      MedusaError.Types.NOT_FOUND,
-        `no fulfillment was found with the id: ${fulfillment_id} related to swap: ${id}`
+      `no fulfillment was found with the id: ${fulfillment_id} related to swap: ${id}`
-      )
+    )
-    }
-
-    const swap = await swapService.retrieve(swap_id)
-
-    if (swap.order_id !== id) {
-      throw new MedusaError(
-        MedusaError.Types.NOT_FOUND,
-        `no swap was found with the id: ${swap_id} related to order: ${id}`
-      )
-    }
-
-    await swapService.cancelFulfillment(fulfillment_id)
-
-    const order = await orderService.retrieve(id, {
-      select: defaultFields,
-      relations: defaultRelations,
-    })
-
-    res.json({ order })
-  } catch (error) {
-    throw error
   }
+
+  const swap = await swapService.retrieve(swap_id)
+
+  if (swap.order_id !== id) {
+    throw new MedusaError(
+      MedusaError.Types.NOT_FOUND,
+      `no swap was found with the id: ${swap_id} related to order: ${id}`
+    )
+  }
+
+  await swapService.cancelFulfillment(fulfillment_id)
+
+  const order = await orderService.retrieve(id, {
+    select: defaultFields,
+    relations: defaultRelations,
+  })
+
+  res.json({ order })
 }

packages/medusa/src/api/routes/admin/orders/cancel-fulfillment.js

@@ -24,28 +24,24 @@ import { defaultRelations, defaultFields } from "."
 export default async (req, res) => {
   const { id, fulfillment_id } = req.params
 
-  try {
+  const fulfillmentService = req.scope.resolve("fulfillmentService")
-    const fulfillmentService = req.scope.resolve("fulfillmentService")
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
+  const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
 
-    if (fulfillment.order_id !== id) {
+  if (fulfillment.order_id !== id) {
-      throw new MedusaError(
+    throw new MedusaError(
-        MedusaError.Types.NOT_FOUND,
+      MedusaError.Types.NOT_FOUND,
-        `no fulfillment was found with the id: ${fulfillment_id} related to order: ${id}`
+      `no fulfillment was found with the id: ${fulfillment_id} related to order: ${id}`
-      )
+    )
-    }
-
-    await orderService.cancelFulfillment(fulfillment_id)
-
-    const order = await orderService.retrieve(id, {
-      select: defaultFields,
-      relations: defaultRelations,
-    })
-
-    res.json({ order })
-  } catch (error) {
-    throw error
   }
+
+  await orderService.cancelFulfillment(fulfillment_id)
+
+  const order = await orderService.retrieve(id, {
+    select: defaultFields,
+    relations: defaultRelations,
+  })
+
+  res.json({ order })
 }

packages/medusa/src/api/routes/admin/orders/cancel-order.js

@@ -22,17 +22,13 @@ import { defaultFields, defaultRelations } from "."
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  await orderService.cancel(id)
-    await orderService.cancel(id)
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ order })
+  res.json({ order })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/cancel-swap.js

@@ -24,28 +24,24 @@ import { defaultRelations, defaultFields } from "."
 export default async (req, res) => {
   const { id, swap_id } = req.params
 
-  try {
+  const swapService = req.scope.resolve("swapService")
-    const swapService = req.scope.resolve("swapService")
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    const swap = await swapService.retrieve(swap_id)
+  const swap = await swapService.retrieve(swap_id)
 
-    if (swap.order_id !== id) {
+  if (swap.order_id !== id) {
-      throw new MedusaError(
+    throw new MedusaError(
-        MedusaError.Types.NOT_FOUND,
+      MedusaError.Types.NOT_FOUND,
-        `no swap was found with the id: ${swap_id} related to order: ${id}`
+      `no swap was found with the id: ${swap_id} related to order: ${id}`
-      )
+    )
-    }
-
-    await swapService.cancel(swap_id)
-
-    const order = await orderService.retrieve(id, {
-      select: defaultFields,
-      relations: defaultRelations,
-    })
-
-    res.json({ order })
-  } catch (error) {
-    throw error
   }
+
+  await swapService.cancel(swap_id)
+
+  const order = await orderService.retrieve(id, {
+    select: defaultFields,
+    relations: defaultRelations,
+  })
+
+  res.json({ order })
 }

packages/medusa/src/api/routes/admin/orders/capture-payment.js

@@ -22,18 +22,14 @@ import { defaultRelations, defaultFields } from "./"
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    await orderService.capturePayment(id)
+  await orderService.capturePayment(id)
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ order })
+  res.json({ order })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/complete-order.js

@@ -1,17 +1,13 @@
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    await orderService.completeOrder(id)
+  await orderService.completeOrder(id)
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      relations: ["region", "customer", "swaps"],
+    relations: ["region", "customer", "swaps"],
-    })
+  })
 
-    res.json({ order })
+  res.json({ order })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/create-claim-shipment.js

@@ -39,9 +39,7 @@ export default async (req, res) => {
 
   const schema = Validator.object().keys({
     fulfillment_id: Validator.string().required(),
-    tracking_numbers: Validator.array()
+    tracking_numbers: Validator.array().items(Validator.string()).optional(),
-      .items(Validator.string())
-      .optional(),
   })
 
   const { value, error } = schema.validate(req.body)
@@ -49,23 +47,19 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const claimService = req.scope.resolve("claimService")
-    const claimService = req.scope.resolve("claimService")
 
-    await claimService.createShipment(
+  await claimService.createShipment(
-      claim_id,
+    claim_id,
-      value.fulfillment_id,
+    value.fulfillment_id,
-      value.tracking_numbers.map(n => ({ tracking_number: n }))
+    value.tracking_numbers.map((n) => ({ tracking_number: n }))
-    )
+  )
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ order })
+  res.json({ order })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/create-claim.js

@@ -112,9 +112,7 @@ import { defaultRelations, defaultFields } from "./"
 export default async (req, res) => {
   const { id } = req.params
   const schema = Validator.object().keys({
-    type: Validator.string()
+    type: Validator.string().valid("replace", "refund").required(),
-      .valid("replace", "refund")
-      .required(),
     claim_items: Validator.array()
       .items({
         item_id: Validator.string().required(),
@@ -133,9 +131,7 @@ export default async (req, res) => {
     return_shipping: Validator.object()
       .keys({
         option_id: Validator.string().optional(),
-        price: Validator.number()
+        price: Validator.number().integer().optional(),
-          .integer()
-          .optional(),
       })
       .optional(),
     additional_items: Validator.array()
@@ -148,14 +144,10 @@ export default async (req, res) => {
       .items({
         id: Validator.string().optional(),
         option_id: Validator.string().optional(),
-        price: Validator.number()
+        price: Validator.number().integer().optional(),
-          .integer()
-          .optional(),
       })
       .optional(),
-    refund_amount: Validator.number()
+    refund_amount: Validator.number().integer().optional(),
-      .integer()
-      .optional(),
     shipping_address: Validator.object().optional(),
     no_notification: Validator.boolean().optional(),
     metadata: Validator.object().optional(),
@@ -185,176 +177,172 @@ export default async (req, res) => {
   res.setHeader("Access-Control-Expose-Headers", "Idempotency-Key")
   res.setHeader("Idempotency-Key", idempotencyKey.idempotency_key)
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const claimService = req.scope.resolve("claimService")
-    const claimService = req.scope.resolve("claimService")
+  const returnService = req.scope.resolve("returnService")
-    const returnService = req.scope.resolve("returnService")
 
-    let inProgress = true
+  let inProgress = true
-    let err = false
+  let err = false
 
-    while (inProgress) {
+  while (inProgress) {
-      switch (idempotencyKey.recovery_point) {
+    switch (idempotencyKey.recovery_point) {
-        case "started": {
+      case "started": {
-          const { key, error } = await idempotencyKeyService.workStage(
+        const { key, error } = await idempotencyKeyService.workStage(
-            idempotencyKey.idempotency_key,
+          idempotencyKey.idempotency_key,
-            async manager => {
+          async (manager) => {
-              const order = await orderService
+            const order = await orderService
-                .withTransaction(manager)
+              .withTransaction(manager)
-                .retrieve(id, {
+              .retrieve(id, {
-                  relations: [
+                relations: [
-                    "items",
+                  "items",
-                    "cart",
+                  "cart",
-                    "cart.discounts",
+                  "cart.discounts",
-                    "cart.discounts.rule",
+                  "cart.discounts.rule",
-                  ],
+                ],
-                })
-
-              await claimService.withTransaction(manager).create({
-                idempotency_key: idempotencyKey.idempotency_key,
-                order,
-                type: value.type,
-                shipping_address: value.shipping_address,
-                claim_items: value.claim_items,
-                return_shipping: value.return_shipping,
-                additional_items: value.additional_items,
-                shipping_methods: value.shipping_methods,
-                no_notification: value.no_notification,
-                metadata: value.metadata,
               })
 
-              return {
+            await claimService.withTransaction(manager).create({
-                recovery_point: "claim_created",
+              idempotency_key: idempotencyKey.idempotency_key,
-              }
+              order,
+              type: value.type,
+              shipping_address: value.shipping_address,
+              claim_items: value.claim_items,
+              return_shipping: value.return_shipping,
+              additional_items: value.additional_items,
+              shipping_methods: value.shipping_methods,
+              no_notification: value.no_notification,
+              metadata: value.metadata,
+            })
+
+            return {
+              recovery_point: "claim_created",
             }
-          )
-
-          if (error) {
-            inProgress = false
-            err = error
-          } else {
-            idempotencyKey = key
           }
-          break
+        )
-        }
 
-        case "claim_created": {
+        if (error) {
-          const { key, error } = await idempotencyKeyService.workStage(
-            idempotencyKey.idempotency_key,
-            async manager => {
-              let claim = await claimService.withTransaction(manager).list({
-                idempotency_key: idempotencyKey.idempotency_key,
-              })
-
-              if (!claim.length) {
-                throw new MedusaError(
-                  MedusaError.Types.INVALID_DATA,
-                  `Claim not found`
-                )
-              }
-
-              claim = claim[0]
-
-              if (claim.type === "refund") {
-                await claimService
-                  .withTransaction(manager)
-                  .processRefund(claim.id)
-              }
-
-              return {
-                recovery_point: "refund_handled",
-              }
-            }
-          )
-
-          if (error) {
-            inProgress = false
-            err = error
-          } else {
-            idempotencyKey = key
-          }
-          break
-        }
-
-        case "refund_handled": {
-          const { key, error } = await idempotencyKeyService.workStage(
-            idempotencyKey.idempotency_key,
-            async manager => {
-              let order = await orderService
-                .withTransaction(manager)
-                .retrieve(id, {
-                  relations: ["items", "discounts"],
-                })
-
-              let claim = await claimService.withTransaction(manager).list(
-                {
-                  idempotency_key: idempotencyKey.idempotency_key,
-                },
-                {
-                  relations: ["return_order"],
-                }
-              )
-
-              if (!claim.length) {
-                throw new MedusaError(
-                  MedusaError.Types.INVALID_DATA,
-                  `Claim not found`
-                )
-              }
-
-              claim = claim[0]
-
-              if (claim.return_order) {
-                await returnService
-                  .withTransaction(manager)
-                  .fulfill(claim.return_order.id)
-              }
-
-              order = await orderService.withTransaction(manager).retrieve(id, {
-                select: defaultFields,
-                relations: defaultRelations,
-              })
-
-              return {
-                response_code: 200,
-                response_body: { order },
-              }
-            }
-          )
-
-          if (error) {
-            inProgress = false
-            err = error
-          } else {
-            idempotencyKey = key
-          }
-          break
-        }
-
-        case "finished": {
           inProgress = false
-          break
+          err = error
+        } else {
+          idempotencyKey = key
         }
-
+        break
-        default:
-          idempotencyKey = await idempotencyKeyService.update(
-            idempotencyKey.idempotency_key,
-            {
-              recovery_point: "finished",
-              response_code: 500,
-              response_body: { message: "Unknown recovery point" },
-            }
-          )
-          break
       }
-    }
 
-    if (err) {
+      case "claim_created": {
-      throw err
+        const { key, error } = await idempotencyKeyService.workStage(
-    }
+          idempotencyKey.idempotency_key,
+          async (manager) => {
+            let claim = await claimService.withTransaction(manager).list({
+              idempotency_key: idempotencyKey.idempotency_key,
+            })
 
-    res.status(idempotencyKey.response_code).json(idempotencyKey.response_body)
+            if (!claim.length) {
-  } catch (error) {
+              throw new MedusaError(
-    throw error
+                MedusaError.Types.INVALID_DATA,
+                `Claim not found`
+              )
+            }
+
+            claim = claim[0]
+
+            if (claim.type === "refund") {
+              await claimService
+                .withTransaction(manager)
+                .processRefund(claim.id)
+            }
+
+            return {
+              recovery_point: "refund_handled",
+            }
+          }
+        )
+
+        if (error) {
+          inProgress = false
+          err = error
+        } else {
+          idempotencyKey = key
+        }
+        break
+      }
+
+      case "refund_handled": {
+        const { key, error } = await idempotencyKeyService.workStage(
+          idempotencyKey.idempotency_key,
+          async (manager) => {
+            let order = await orderService
+              .withTransaction(manager)
+              .retrieve(id, {
+                relations: ["items", "discounts"],
+              })
+
+            let claim = await claimService.withTransaction(manager).list(
+              {
+                idempotency_key: idempotencyKey.idempotency_key,
+              },
+              {
+                relations: ["return_order"],
+              }
+            )
+
+            if (!claim.length) {
+              throw new MedusaError(
+                MedusaError.Types.INVALID_DATA,
+                `Claim not found`
+              )
+            }
+
+            claim = claim[0]
+
+            if (claim.return_order) {
+              await returnService
+                .withTransaction(manager)
+                .fulfill(claim.return_order.id)
+            }
+
+            order = await orderService.withTransaction(manager).retrieve(id, {
+              select: defaultFields,
+              relations: defaultRelations,
+            })
+
+            return {
+              response_code: 200,
+              response_body: { order },
+            }
+          }
+        )
+
+        if (error) {
+          inProgress = false
+          err = error
+        } else {
+          idempotencyKey = key
+        }
+        break
+      }
+
+      case "finished": {
+        inProgress = false
+        break
+      }
+
+      default:
+        idempotencyKey = await idempotencyKeyService.update(
+          idempotencyKey.idempotency_key,
+          {
+            recovery_point: "finished",
+            response_code: 500,
+            response_body: { message: "Unknown recovery point" },
+          }
+        )
+        break
+    }
   }
+
+  if (err) {
+    throw err
+  }
+
+  res.status(idempotencyKey.response_code).json(idempotencyKey.response_body)
 }

packages/medusa/src/api/routes/admin/orders/create-fulfillment.js

@@ -61,21 +61,17 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    await orderService.createFulfillment(id, value.items, {
+  await orderService.createFulfillment(id, value.items, {
-      metadata: value.metadata,
+    metadata: value.metadata,
-      no_notification: value.no_notification,
+    no_notification: value.no_notification,
-    })
+  })
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ order })
+  res.json({ order })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/create-order.js

@@ -3,9 +3,7 @@ import { MedusaError, Validator } from "medusa-core-utils"
 export default async (req, res) => {
   const schema = Validator.object().keys({
     status: Validator.string().optional(),
-    email: Validator.string()
+    email: Validator.string().email().required(),
-      .email()
-      .required(),
     billing_address: Validator.address().required(),
     shipping_address: Validator.address().required(),
     items: Validator.array().required(),
@@ -36,13 +34,9 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  let order = await orderService.create(value)
-    let order = await orderService.create(value)
+  order = await orderService.decorate(order, [], ["region"])
-    order = await orderService.decorate(order, [], ["region"])
 
-    res.status(200).json({ order })
+  res.status(200).json({ order })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/orders/create-shipment.js

@@ -41,9 +41,7 @@ export default async (req, res) => {
 
   const schema = Validator.object().keys({
     fulfillment_id: Validator.string().required(),
-    tracking_numbers: Validator.array()
+    tracking_numbers: Validator.array().items(Validator.string()).optional(),
-      .items(Validator.string())
-      .optional(),
     no_notification: Validator.boolean().optional(),
   })
 
@@ -52,23 +50,19 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    await orderService.createShipment(
+  await orderService.createShipment(
-      id,
+    id,
-      value.fulfillment_id,
+    value.fulfillment_id,
-      value.tracking_numbers.map(n => ({ tracking_number: n })),
+    value.tracking_numbers.map((n) => ({ tracking_number: n })),
-      { no_notification: value.no_notification }
+    { no_notification: value.no_notification }
-    )
+  )
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ order })
+  res.json({ order })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/create-swap-shipment.js

@@ -42,9 +42,7 @@ export default async (req, res) => {
 
   const schema = Validator.object().keys({
     fulfillment_id: Validator.string().required(),
-    tracking_numbers: Validator.array()
+    tracking_numbers: Validator.array().items(Validator.string()).optional(),
-      .items(Validator.string())
-      .optional(),
     no_notification: Validator.boolean().optional(),
   })
 
@@ -53,24 +51,20 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const swapService = req.scope.resolve("swapService")
-    const swapService = req.scope.resolve("swapService")
 
-    await swapService.createShipment(
+  await swapService.createShipment(
-      swap_id,
+    swap_id,
-      value.fulfillment_id,
+    value.fulfillment_id,
-      value.tracking_numbers.map(n => ({ tracking_number: n })),
+    value.tracking_numbers.map((n) => ({ tracking_number: n })),
-      { no_notification: value.no_notification }
+    { no_notification: value.no_notification }
-    )
+  )
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ order })
+  res.json({ order })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/create-swap.js

@@ -87,9 +87,7 @@ export default async (req, res) => {
     return_shipping: Validator.object()
       .keys({
         option_id: Validator.string().optional(),
-        price: Validator.number()
+        price: Validator.number().integer().optional(),
-          .integer()
-          .optional(),
       })
       .optional(),
     additional_items: Validator.array().items({
@@ -131,127 +129,121 @@ export default async (req, res) => {
   res.setHeader("Access-Control-Expose-Headers", "Idempotency-Key")
   res.setHeader("Idempotency-Key", idempotencyKey.idempotency_key)
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const swapService = req.scope.resolve("swapService")
-    const swapService = req.scope.resolve("swapService")
+  const returnService = req.scope.resolve("returnService")
-    const returnService = req.scope.resolve("returnService")
 
-    let inProgress = true
+  let inProgress = true
-    let err = false
+  let err = false
 
-    while (inProgress) {
+  while (inProgress) {
-      switch (idempotencyKey.recovery_point) {
+    switch (idempotencyKey.recovery_point) {
-        case "started": {
+      case "started": {
-          const { key, error } = await idempotencyKeyService.workStage(
+        const { key, error } = await idempotencyKeyService.workStage(
-            idempotencyKey.idempotency_key,
+          idempotencyKey.idempotency_key,
-            async manager => {
+          async (manager) => {
-              const order = await orderService
+            const order = await orderService
-                .withTransaction(manager)
+              .withTransaction(manager)
-                .retrieve(id, {
+              .retrieve(id, {
-                  select: ["refunded_total", "total"],
+                select: ["refunded_total", "total"],
-                  relations: ["items", "swaps", "swaps.additional_items"],
+                relations: ["items", "swaps", "swaps.additional_items"],
-                })
-
-              const swap = await swapService
-                .withTransaction(manager)
-                .create(
-                  order,
-                  value.return_items,
-                  value.additional_items,
-                  value.return_shipping,
-                  {
-                    idempotency_key: idempotencyKey.idempotency_key,
-                    no_notification: value.no_notification,
-                    allow_backorder: value.allow_backorder,
-                  }
-                )
-
-              await swapService
-                .withTransaction(manager)
-                .createCart(swap.id, value.custom_shipping_options)
-              const returnOrder = await returnService
-                .withTransaction(manager)
-                .retrieveBySwap(swap.id)
-
-              await returnService
-                .withTransaction(manager)
-                .fulfill(returnOrder.id)
-
-              return {
-                recovery_point: "swap_created",
-              }
-            }
-          )
-
-          if (error) {
-            inProgress = false
-            err = error
-          } else {
-            idempotencyKey = key
-          }
-          break
-        }
-
-        case "swap_created": {
-          const { key, error } = await idempotencyKeyService.workStage(
-            idempotencyKey.idempotency_key,
-            async manager => {
-              const swaps = await swapService.list({
-                idempotency_key: idempotencyKey.idempotency_key,
               })
 
-              if (!swaps.length) {
+            const swap = await swapService
-                throw new MedusaError(
+              .withTransaction(manager)
-                  MedusaError.Types.INVALID_DATA,
+              .create(
-                  "Swap not found"
+                order,
-                )
+                value.return_items,
-              }
+                value.additional_items,
+                value.return_shipping,
+                {
+                  idempotency_key: idempotencyKey.idempotency_key,
+                  no_notification: value.no_notification,
+                  allow_backorder: value.allow_backorder,
+                }
+              )
 
-              const order = await orderService.retrieve(id, {
+            await swapService
-                select: defaultFields,
+              .withTransaction(manager)
-                relations: defaultRelations,
+              .createCart(swap.id, value.custom_shipping_options)
-              })
+            const returnOrder = await returnService
+              .withTransaction(manager)
+              .retrieveBySwap(swap.id)
 
-              return {
+            await returnService.withTransaction(manager).fulfill(returnOrder.id)
-                response_code: 200,
+
-                response_body: { order },
+            return {
-              }
+              recovery_point: "swap_created",
             }
-          )
-
-          if (error) {
-            inProgress = false
-            err = error
-          } else {
-            idempotencyKey = key
           }
-          break
+        )
-        }
 
-        case "finished": {
+        if (error) {
           inProgress = false
-          break
+          err = error
+        } else {
+          idempotencyKey = key
         }
-
+        break
-        default:
-          idempotencyKey = await idempotencyKeyService.update(
-            idempotencyKey.idempotency_key,
-            {
-              recovery_point: "finished",
-              response_code: 500,
-              response_body: { message: "Unknown recovery point" },
-            }
-          )
-          break
       }
-    }
 
-    if (err) {
+      case "swap_created": {
-      throw err
+        const { key, error } = await idempotencyKeyService.workStage(
-    }
+          idempotencyKey.idempotency_key,
+          async (manager) => {
+            const swaps = await swapService.list({
+              idempotency_key: idempotencyKey.idempotency_key,
+            })
 
-    res.status(idempotencyKey.response_code).json(idempotencyKey.response_body)
+            if (!swaps.length) {
-  } catch (error) {
+              throw new MedusaError(
-    throw error
+                MedusaError.Types.INVALID_DATA,
+                "Swap not found"
+              )
+            }
+
+            const order = await orderService.retrieve(id, {
+              select: defaultFields,
+              relations: defaultRelations,
+            })
+
+            return {
+              response_code: 200,
+              response_body: { order },
+            }
+          }
+        )
+
+        if (error) {
+          inProgress = false
+          err = error
+        } else {
+          idempotencyKey = key
+        }
+        break
+      }
+
+      case "finished": {
+        inProgress = false
+        break
+      }
+
+      default:
+        idempotencyKey = await idempotencyKeyService.update(
+          idempotencyKey.idempotency_key,
+          {
+            recovery_point: "finished",
+            response_code: 500,
+            response_body: { message: "Unknown recovery point" },
+          }
+        )
+        break
+    }
   }
+
+  if (err) {
+    throw err
+  }
+
+  res.status(idempotencyKey.response_code).json(idempotencyKey.response_body)
 }

packages/medusa/src/api/routes/admin/orders/delete-metadata.js

@@ -21,17 +21,13 @@
 export default async (req, res) => {
   const { id, key } = req.params
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    await orderService.deleteMetadata(id, key)
+  await orderService.deleteMetadata(id, key)
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      relations: ["region", "customer", "swaps"],
+    relations: ["region", "customer", "swaps"],
-    })
+  })
 
-    res.status(200).json({ order })
+  res.status(200).json({ order })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/orders/fulfill-claim.js

@@ -45,25 +45,21 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const claimService = req.scope.resolve("claimService")
-    const claimService = req.scope.resolve("claimService")
+  const entityManager = req.scope.resolve("manager")
-    const entityManager = req.scope.resolve("manager")
 
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      await claimService.withTransaction(manager).createFulfillment(claim_id, {
+    await claimService.withTransaction(manager).createFulfillment(claim_id, {
-        metadata: value.metadata,
+      metadata: value.metadata,
-        no_notification: value.no_notification,
+      no_notification: value.no_notification,
-      })
     })
+  })
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.status(200).json({ order })
+  res.status(200).json({ order })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/orders/fulfill-swap.js

@@ -45,25 +45,21 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const swapService = req.scope.resolve("swapService")
-    const swapService = req.scope.resolve("swapService")
+  const entityManager = req.scope.resolve("manager")
-    const entityManager = req.scope.resolve("manager")
 
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      await swapService.withTransaction(manager).createFulfillment(swap_id, {
+    await swapService.withTransaction(manager).createFulfillment(swap_id, {
-        metadata: value.metadata,
+      metadata: value.metadata,
-        no_notification: value.no_notification,
+      no_notification: value.no_notification,
-      })
-
-      const order = await orderService.withTransaction(manager).retrieve(id, {
-        select: defaultFields,
-        relations: defaultRelations,
-      })
-
-      res.status(200).json({ order })
     })
-  } catch (err) {
+
-    throw err
+    const order = await orderService.withTransaction(manager).retrieve(id, {
-  }
+      select: defaultFields,
+      relations: defaultRelations,
+    })
+
+    res.status(200).json({ order })
+  })
 }

packages/medusa/src/api/routes/admin/orders/get-order.js

@@ -22,16 +22,12 @@ import { defaultRelations, defaultFields } from "./"
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ order })
+  res.json({ order })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/index.js

@@ -3,7 +3,7 @@ import middlewares from "../../../middlewares"
 
 const route = Router()
 
-export default app => {
+export default (app) => {
   app.use("/orders", route)
 
   /**

packages/medusa/src/api/routes/admin/orders/list-orders.js

@@ -30,58 +30,51 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    const limit = parseInt(req.query.limit) || 50
+  const limit = parseInt(req.query.limit) || 50
-    const offset = parseInt(req.query.offset) || 0
+  const offset = parseInt(req.query.offset) || 0
 
-    let selector = {}
+  const selector = {}
 
-    if ("q" in req.query) {
+  if ("q" in req.query) {
-      selector.q = req.query.q
+    selector.q = req.query.q
-    }
-
-    let includeFields = []
-    if ("fields" in req.query) {
-      includeFields = req.query.fields.split(",")
-      // Ensure created_at is included, since we are sorting on this
-      includeFields.push("created_at")
-    }
-
-    let expandFields = []
-    if ("expand" in req.query) {
-      expandFields = req.query.expand.split(",")
-    }
-
-    for (const k of filterableFields) {
-      if (k in value) {
-        selector[k] = value[k]
-      }
-    }
-
-    const listConfig = {
-      select: includeFields.length ? includeFields : defaultFields,
-      relations: expandFields.length ? expandFields : defaultRelations,
-      skip: offset,
-      take: limit,
-      order: { created_at: "DESC" },
-    }
-
-    const [orders, count] = await orderService.listAndCount(
-      selector,
-      listConfig
-    )
-
-    let data = orders
-
-    const fields = [...includeFields, ...expandFields]
-    if (fields.length) {
-      data = orders.map(o => _.pick(o, fields))
-    }
-
-    res.json({ orders: data, count, offset, limit })
-  } catch (error) {
-    throw error
   }
+
+  let includeFields = []
+  if ("fields" in req.query) {
+    includeFields = req.query.fields.split(",")
+    // Ensure created_at is included, since we are sorting on this
+    includeFields.push("created_at")
+  }
+
+  let expandFields = []
+  if ("expand" in req.query) {
+    expandFields = req.query.expand.split(",")
+  }
+
+  for (const k of filterableFields) {
+    if (k in value) {
+      selector[k] = value[k]
+    }
+  }
+
+  const listConfig = {
+    select: includeFields.length ? includeFields : defaultFields,
+    relations: expandFields.length ? expandFields : defaultRelations,
+    skip: offset,
+    take: limit,
+    order: { created_at: "DESC" },
+  }
+
+  const [orders, count] = await orderService.listAndCount(selector, listConfig)
+
+  let data = orders
+
+  const fields = [...includeFields, ...expandFields]
+  if (fields.length) {
+    data = orders.map((o) => _.pick(o, fields))
+  }
+
+  res.json({ orders: data, count, offset, limit })
 }

packages/medusa/src/api/routes/admin/orders/process-swap-payment.js

@@ -23,22 +23,18 @@ import { defaultFields, defaultRelations } from "./"
 export default async (req, res) => {
   const { id, swap_id } = req.params
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const swapService = req.scope.resolve("swapService")
-    const swapService = req.scope.resolve("swapService")
+  const entityManager = req.scope.resolve("manager")
-    const entityManager = req.scope.resolve("manager")
 
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      await swapService.withTransaction(manager).processDifference(swap_id)
+    await swapService.withTransaction(manager).processDifference(swap_id)
 
-      const order = await orderService.withTransaction(manager).retrieve(id, {
+    const order = await orderService.withTransaction(manager).retrieve(id, {
-        select: defaultFields,
+      select: defaultFields,
-        relations: defaultRelations,
+      relations: defaultRelations,
-      })
-
-      res.json({ order })
     })
-  } catch (error) {
+
-    throw error
+    res.json({ order })
-  }
+  })
 }

packages/medusa/src/api/routes/admin/orders/receive-swap.js

@@ -54,28 +54,24 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const swapService = req.scope.resolve("swapService")
-    const swapService = req.scope.resolve("swapService")
+  const entityManager = req.scope.resolve("manager")
-    const entityManager = req.scope.resolve("manager")
 
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      await swapService
+    await swapService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .receiveReturn(swap_id, value.items)
+      .receiveReturn(swap_id, value.items)
 
-      await orderService
+    await orderService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .registerSwapReceived(id, swap_id)
+      .registerSwapReceived(id, swap_id)
-    })
+  })
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.status(200).json({ order })
+  res.status(200).json({ order })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/orders/refund-payment.js

@@ -43,13 +43,9 @@ import { defaultRelations, defaultFields } from "./"
 export default async (req, res) => {
   const { id } = req.params
   const schema = Validator.object().keys({
-    amount: Validator.number()
+    amount: Validator.number().integer().required(),
-      .integer()
-      .required(),
     reason: Validator.string().required(),
-    note: Validator.string()
+    note: Validator.string().allow("").optional(),
-      .allow("")
-      .optional(),
     no_notification: Validator.boolean().optional(),
   })
 
@@ -59,24 +55,16 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    await orderService.createRefund(
+  await orderService.createRefund(id, value.amount, value.reason, value.note, {
-      id,
+    no_notification: value.no_notification,
-      value.amount,
+  })
-      value.reason,
-      value.note,
-      { no_notification: value.no_notification }
-    )
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.status(200).json({ order })
+  res.status(200).json({ order })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/orders/request-return.js

@@ -76,16 +76,12 @@ export default async (req, res) => {
     return_shipping: Validator.object()
       .keys({
         option_id: Validator.string().optional(),
-        price: Validator.number()
+        price: Validator.number().integer().optional(),
-          .integer()
-          .optional(),
       })
       .optional(),
     receive_now: Validator.boolean().default(false),
     no_notification: Validator.boolean().optional(),
-    refund: Validator.number()
+    refund: Validator.number().integer().optional(),
-      .integer()
-      .optional(),
   })
 
   const { value, error } = schema.validate(req.body)
@@ -126,7 +122,7 @@ export default async (req, res) => {
         case "started": {
           const { key, error } = await idempotencyKeyService.workStage(
             idempotencyKey.idempotency_key,
-            async manager => {
+            async (manager) => {
               const returnObj = {
                 order_id: id,
                 idempotency_key: idempotencyKey.idempotency_key,
@@ -145,7 +141,7 @@ export default async (req, res) => {
                 }
               }
 
-              let order = await orderService
+              const order = await orderService
                 .withTransaction(manager)
                 .retrieve(id)
 
@@ -191,7 +187,7 @@ export default async (req, res) => {
         case "return_requested": {
           const { key, error } = await idempotencyKeyService.workStage(
             idempotencyKey.idempotency_key,
-            async manager => {
+            async (manager) => {
               let order = await orderService
                 .withTransaction(manager)
                 .retrieve(id, { relations: ["returns"] })

packages/medusa/src/api/routes/admin/orders/update-claim.js

@@ -104,9 +104,7 @@ export default async (req, res) => {
       .items({
         id: Validator.string().optional(),
         option_id: Validator.string().optional(),
-        price: Validator.number()
+        price: Validator.number().integer().optional(),
-          .integer()
-          .optional(),
       })
       .optional(),
     no_notification: Validator.boolean().optional(),
@@ -118,19 +116,15 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const claimService = req.scope.resolve("claimService")
-    const claimService = req.scope.resolve("claimService")
 
-    await claimService.update(claim_id, value)
+  await claimService.update(claim_id, value)
 
-    const data = await orderService.retrieve(id, {
+  const data = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ order: data })
+  res.json({ order: data })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/orders/update-order.js

@@ -31,18 +31,14 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    await orderService.update(id, value)
+  await orderService.update(id, value)
 
-    const order = await orderService.retrieve(id, {
+  const order = await orderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.status(200).json({ order })
+  res.status(200).json({ order })
-  } catch (err) {
-    throw err
-  }
 }