fix: make api/routes/store/swaps pass eslint (#678)

.eslintignore

@@ -27,7 +27,7 @@
 /packages/medusa/src/api/routes/store/carts
 /packages/medusa/src/api/routes/store/return-reasons
 /packages/medusa/src/api/routes/store/returns
-/packages/medusa/src/api/routes/store/swaps
+
 
 # END OF FILES TODO
 

packages/medusa/src/api/routes/store/swaps/create-swap.js

@@ -95,131 +95,125 @@ 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 swapService = req.scope.resolve("swapService")
-    const returnService = req.scope.resolve("returnService")
+  const orderService = req.scope.resolve("orderService")
+  const swapService = req.scope.resolve("swapService")
+  const returnService = req.scope.resolve("returnService")
 
-    let inProgress = true
-    let err = false
+  let inProgress = true
+  let err = false
 
-    while (inProgress) {
-      switch (idempotencyKey.recovery_point) {
-        case "started": {
-          const { key, error } = await idempotencyKeyService.workStage(
-            idempotencyKey.idempotency_key,
-            async (manager) => {
-              const order = await orderService
-                .withTransaction(manager)
-                .retrieve(value.order_id, {
-                  select: ["refunded_total", "total"],
-                  relations: ["items", "swaps", "swaps.additional_items"],
-                })
+  while (inProgress) {
+    switch (idempotencyKey.recovery_point) {
+      case "started": {
+        const { key, error } = await idempotencyKeyService.workStage(
+          idempotencyKey.idempotency_key,
+          async (manager) => {
+            const order = await orderService
+              .withTransaction(manager)
+              .retrieve(value.order_id, {
+                select: ["refunded_total", "total"],
+                relations: ["items", "swaps", "swaps.additional_items"],
+              })
 
-              let returnShipping
-              if (value.return_shipping_option) {
-                returnShipping = {
-                  option_id: value.return_shipping_option,
+            let returnShipping
+            if (value.return_shipping_option) {
+              returnShipping = {
+                option_id: value.return_shipping_option,
+              }
+            }
+
+            const swap = await swapService
+              .withTransaction(manager)
+              .create(
+                order,
+                value.return_items,
+                value.additional_items,
+                returnShipping,
+                {
+                  idempotency_key: idempotencyKey.idempotency_key,
+                  no_notification: true,
                 }
-              }
+              )
 
-              const swap = await swapService
-                .withTransaction(manager)
-                .create(
-                  order,
-                  value.return_items,
-                  value.additional_items,
-                  returnShipping,
-                  {
-                    idempotency_key: idempotencyKey.idempotency_key,
-                    no_notification: true,
-                  }
-                )
+            await swapService.withTransaction(manager).createCart(swap.id)
+            const returnOrder = await returnService
+              .withTransaction(manager)
+              .retrieveBySwap(swap.id)
 
-              await swapService.withTransaction(manager).createCart(swap.id)
-              const returnOrder = await returnService
-                .withTransaction(manager)
-                .retrieveBySwap(swap.id)
+            await returnService.withTransaction(manager).fulfill(returnOrder.id)
 
-              await returnService
-                .withTransaction(manager)
-                .fulfill(returnOrder.id)
-
-              return {
-                recovery_point: "swap_created",
-              }
+            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) {
-                throw new MedusaError(
-                  MedusaError.Types.INVALID_DATA,
-                  "Swap not found"
-                )
-              }
-
-              const swap = await swapService.retrieve(swaps[0].id, {
-                select: defaultFields,
-                relations: defaultRelations,
-              })
-
-              return {
-                response_code: 200,
-                response_body: { swap },
-              }
-            }
-          )
-
-          if (error) {
-            inProgress = false
-            err = error
-          } else {
-            idempotencyKey = key
-          }
-          break
-        }
-
-        case "finished": {
+        if (error) {
           inProgress = false
-          break
+          err = error
+        } else {
+          idempotencyKey = key
         }
-
-        default:
-          idempotencyKey = await idempotencyKeyService.update(
-            idempotencyKey.idempotency_key,
-            {
-              recovery_point: "finished",
-              response_code: 500,
-              response_body: { message: "Unknown recovery point" },
-            }
-          )
-          break
+        break
       }
-    }
 
-    if (err) {
-      throw err
-    }
+      case "swap_created": {
+        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)
-  } catch (error) {
-    throw error
+            if (!swaps.length) {
+              throw new MedusaError(
+                MedusaError.Types.INVALID_DATA,
+                "Swap not found"
+              )
+            }
+
+            const swap = await swapService.retrieve(swaps[0].id, {
+              select: defaultFields,
+              relations: defaultRelations,
+            })
+
+            return {
+              response_code: 200,
+              response_body: { swap },
+            }
+          }
+        )
+
+        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/store/swaps/get-swap-by-cart.js

@@ -20,11 +20,7 @@
 export default async (req, res) => {
   const { cart_id } = req.params
 
-  try {
-    const swapService = req.scope.resolve("swapService")
-    const swap = await swapService.retrieveByCartId(cart_id)
-    res.json({ swap })
-  } catch (error) {
-    throw error
-  }
+  const swapService = req.scope.resolve("swapService")
+  const swap = await swapService.retrieveByCartId(cart_id)
+  res.json({ swap })
 }