fix: make packages/medusa/src/api/routes/admin/returns pass eslint (#653)

.eslintignore

@@ -28,7 +28,6 @@
 /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/returns
 /packages/medusa/src/api/routes/admin/shipping-profiles
 /packages/medusa/src/api/routes/admin/store
 /packages/medusa/src/api/routes/store/carts

packages/medusa/src/api/routes/admin/returns/cancel-return.js

@@ -1,5 +1,3 @@
-import { result } from "lodash"
-import { MedusaError, Validator } from "medusa-core-utils"
 import { defaultFields, defaultRelations } from "../orders"
 
 /**
@@ -24,27 +22,23 @@ import { defaultFields, defaultRelations } from "../orders"
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const returnService = req.scope.resolve("returnService")
-    const returnService = req.scope.resolve("returnService")
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
 
-    let result = await returnService.cancel(id)
+  let result = await returnService.cancel(id)
 
-    if (result.swap_id) {
+  if (result.swap_id) {
-      const swapService = req.scope.resolve("swapService")
+    const swapService = req.scope.resolve("swapService")
-      result = await swapService.retrieve(result.swap_id)
+    result = await swapService.retrieve(result.swap_id)
-    } else if (result.claim_order_id) {
+  } else if (result.claim_order_id) {
-      const claimService = req.scope.resolve("claimService")
+    const claimService = req.scope.resolve("claimService")
-      result = await claimService.retrieve(result.claim_order_id)
+    result = await claimService.retrieve(result.claim_order_id)
-    }
-
-    const order = await orderService.retrieve(result.order_id, {
-      select: defaultFields,
-      relations: defaultRelations,
-    })
-
-    res.status(200).json({ order })
-  } catch (err) {
-    throw err
   }
+
+  const order = await orderService.retrieve(result.order_id, {
+    select: defaultFields,
+    relations: defaultRelations,
+  })
+
+  res.status(200).json({ order })
 }

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

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

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

@@ -1,5 +1,3 @@
-import _ from "lodash"
-
 /**
  * @oas [get] /returns
  * operationId: "GetReturns"
@@ -20,25 +18,21 @@ import _ from "lodash"
  *                 $ref: "#/components/schemas/return"
  */
 export default async (req, res) => {
-  try {
+  const returnService = req.scope.resolve("returnService")
-    const returnService = req.scope.resolve("returnService")
 
-    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
 
-    const selector = {}
+  const selector = {}
 
-    const listConfig = {
+  const listConfig = {
-      relations: ["swap", "order"],
+    relations: ["swap", "order"],
-      skip: offset,
+    skip: offset,
-      take: limit,
+    take: limit,
-      order: { created_at: "DESC" },
+    order: { created_at: "DESC" },
-    }
-
-    const returns = await returnService.list(selector, { ...listConfig })
-
-    res.json({ returns, count: returns.length, offset, limit })
-  } catch (error) {
-    throw error
   }
+
+  const returns = await returnService.list(selector, { ...listConfig })
+
+  res.json({ returns, count: returns.length, offset, limit })
 }

packages/medusa/src/api/routes/admin/returns/receive-return.js

@@ -48,9 +48,7 @@ export default async (req, res) => {
         quantity: Validator.number().required(),
       })
       .required(),
-    refund: Validator.number()
+    refund: Validator.number().integer().optional(),
-      .integer()
-      .optional(),
   })
 
   const { value, error } = schema.validate(req.body)
@@ -59,45 +57,41 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const returnService = req.scope.resolve("returnService")
-    const returnService = req.scope.resolve("returnService")
+  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")
 
-    let receivedReturn
+  let receivedReturn
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      let refundAmount = value.refund
+    let refundAmount = value.refund
 
-      if (typeof value.refund !== "undefined" && value.refund < 0) {
+    if (typeof value.refund !== "undefined" && value.refund < 0) {
-        refundAmount = 0
+      refundAmount = 0
-      }
+    }
 
-      receivedReturn = await returnService
+    receivedReturn = await returnService
+      .withTransaction(manager)
+      .receive(id, value.items, refundAmount, true)
+
+    if (receivedReturn.order_id) {
+      await orderService
         .withTransaction(manager)
-        .receive(id, value.items, refundAmount, true)
+        .registerReturnReceived(
+          receivedReturn.order_id,
+          receivedReturn,
+          refundAmount
+        )
+    }
 
-      if (receivedReturn.order_id) {
+    if (receivedReturn.swap_id) {
-        await orderService
+      await swapService
-          .withTransaction(manager)
+        .withTransaction(manager)
-          .registerReturnReceived(
+        .registerReceived(receivedReturn.swap_id)
-            receivedReturn.order_id,
+    }
-            receivedReturn,
+  })
-            refundAmount
-          )
-      }
 
-      if (receivedReturn.swap_id) {
+  receivedReturn = await returnService.retrieve(id, { relations: ["swap"] })
-        await swapService
-          .withTransaction(manager)
-          .registerReceived(receivedReturn.swap_id)
-      }
-    })
 
-    receivedReturn = await returnService.retrieve(id, { relations: ["swap"] })
+  res.status(200).json({ return: receivedReturn })
-
-    res.status(200).json({ return: receivedReturn })
-  } catch (err) {
-    throw err
-  }
 }