Fix linting errors in admin/draft-orders (#676)

.eslintignore

@@ -26,7 +26,6 @@
 /packages/medusa/src/api/routes/admin/apps
 /packages/medusa/src/api/routes/admin/auth
 /packages/medusa/src/api/routes/admin/collections
-/packages/medusa/src/api/routes/admin/draft-orders
 /packages/medusa/src/api/routes/admin/notes
 /packages/medusa/src/api/routes/admin/orders
 /packages/medusa/src/api/routes/admin/return-reasons

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

@@ -98,23 +98,15 @@ import { defaultFields, defaultRelations } from "."
 
 export default async (req, res) => {
   const schema = Validator.object().keys({
-    status: Validator.string()
+    status: Validator.string().valid("open", "completed").optional(),
-      .valid("open", "completed")
+    email: Validator.string().email().required(),
-      .optional(),
-    email: Validator.string()
-      .email()
-      .required(),
     billing_address: Validator.address().optional(),
     shipping_address: Validator.address().optional(),
     items: Validator.array()
       .items({
-        variant_id: Validator.string()
+        variant_id: Validator.string().optional().allow(""),
-          .optional()
-          .allow(""),
         unit_price: Validator.number().optional(),
-        title: Validator.string()
+        title: Validator.string().optional().allow(""),
-          .optional()
-          .allow(""),
         quantity: Validator.number().required(),
         metadata: Validator.object().default({}),
       })
@@ -131,11 +123,7 @@ export default async (req, res) => {
       .items({
         option_id: Validator.string().required(),
         data: Validator.object().optional(),
-        price: Validator.number()
+        price: Validator.number().integer().integer().allow(0).optional(),
-          .integer()
-          .integer()
-          .allow(0)
-          .optional(),
       })
       .required(),
     metadata: Validator.object().optional(),
@@ -148,17 +136,13 @@ export default async (req, res) => {
 
   value = transformIdableFields(value, ["shipping_address", "billing_address"])
 
-  try {
+  const draftOrderService = req.scope.resolve("draftOrderService")
-    const draftOrderService = req.scope.resolve("draftOrderService")
+  let draftOrder = await draftOrderService.create(value)
-    let draftOrder = await draftOrderService.create(value)
 
-    draftOrder = await draftOrderService.retrieve(draftOrder.id, {
+  draftOrder = await draftOrderService.retrieve(draftOrder.id, {
-      relations: defaultRelations,
+    relations: defaultRelations,
-      select: defaultFields,
+    select: defaultFields,
-    })
+  })
 
-    res.status(200).json({ draft_order: draftOrder })
+  res.status(200).json({ draft_order: draftOrder })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/draft-orders/create-line-item.js

@@ -55,57 +55,53 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const draftOrderService = req.scope.resolve("draftOrderService")
-    const draftOrderService = req.scope.resolve("draftOrderService")
+  const cartService = req.scope.resolve("cartService")
-    const cartService = req.scope.resolve("cartService")
+  const lineItemService = req.scope.resolve("lineItemService")
-    const lineItemService = req.scope.resolve("lineItemService")
+  const entityManager = req.scope.resolve("manager")
-    const entityManager = req.scope.resolve("manager")
 
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      const draftOrder = await draftOrderService
+    const draftOrder = await draftOrderService
+      .withTransaction(manager)
+      .retrieve(id, { select: defaultFields, relations: ["cart"] })
+
+    if (draftOrder.status === "completed") {
+      throw new MedusaError(
+        MedusaError.Types.NOT_ALLOWED,
+        "You are only allowed to update open draft orders"
+      )
+    }
+
+    if (value.variant_id) {
+      const line = await lineItemService.generate(
+        value.variant_id,
+        draftOrder.cart.region_id,
+        value.quantity,
+        { metadata: value.metadata, unit_price: value.unit_price }
+      )
+
+      await cartService
         .withTransaction(manager)
-        .retrieve(id, { select: defaultFields, relations: ["cart"] })
+        .addLineItem(draftOrder.cart_id, line)
+    } else {
+      // custom line items can be added to a draft order
+      await lineItemService.withTransaction(manager).create({
+        cart_id: draftOrder.cart_id,
+        has_shipping: true,
+        title: value.title || "Custom item",
+        allow_discounts: false,
+        unit_price: value.unit_price || 0,
+        quantity: value.quantity,
+      })
+    }
 
-      if (draftOrder.status === "completed") {
+    draftOrder.cart = await cartService
-        throw new MedusaError(
+      .withTransaction(manager)
-          MedusaError.Types.NOT_ALLOWED,
+      .retrieve(draftOrder.cart_id, {
-          "You are only allowed to update open draft orders"
+        relations: defaultCartRelations,
-        )
+        select: defaultCartFields,
-      }
+      })
 
-      if (value.variant_id) {
+    res.status(200).json({ draft_order: draftOrder })
-        const line = await lineItemService.generate(
+  })
-          value.variant_id,
-          draftOrder.cart.region_id,
-          value.quantity,
-          { metadata: value.metadata, unit_price: value.unit_price }
-        )
-
-        await cartService
-          .withTransaction(manager)
-          .addLineItem(draftOrder.cart_id, line)
-      } else {
-        // custom line items can be added to a draft order
-        await lineItemService.withTransaction(manager).create({
-          cart_id: draftOrder.cart_id,
-          has_shipping: true,
-          title: value.title || "Custom item",
-          allow_discounts: false,
-          unit_price: value.unit_price || 0,
-          quantity: value.quantity,
-        })
-      }
-
-      draftOrder.cart = await cartService
-        .withTransaction(manager)
-        .retrieve(draftOrder.cart_id, {
-          relations: defaultCartRelations,
-          select: defaultCartFields,
-        })
-
-      res.status(200).json({ draft_order: draftOrder })
-    })
-  } catch (err) {
-    throw err
-  }
 }

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

@@ -27,15 +27,12 @@
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const draftOrderService = req.scope.resolve("draftOrderService")
-    const draftOrderService = req.scope.resolve("draftOrderService")
+  await draftOrderService.delete(id)
-    await draftOrderService.delete(id)
+
-    res.json({
+  res.json({
-      id,
+    id,
-      object: "draft-order",
+    object: "draft-order",
-      deleted: true,
+    deleted: true,
-    })
+  })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/draft-orders/delete-line-item.js

@@ -1,4 +1,4 @@
-import { MedusaError, Validator } from "medusa-core-utils"
+import { MedusaError } from "medusa-core-utils"
 import { defaultCartFields, defaultCartRelations, defaultFields } from "."
 
 /**
@@ -25,37 +25,33 @@ import { defaultCartFields, defaultCartRelations, defaultFields } from "."
 export default async (req, res) => {
   const { id, line_id } = req.params
 
-  try {
+  const draftOrderService = req.scope.resolve("draftOrderService")
-    const draftOrderService = req.scope.resolve("draftOrderService")
+  const cartService = req.scope.resolve("cartService")
-    const cartService = req.scope.resolve("cartService")
+  const entityManager = req.scope.resolve("manager")
-    const entityManager = req.scope.resolve("manager")
 
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      const draftOrder = await draftOrderService
+    const draftOrder = await draftOrderService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .retrieve(id, { select: defaultFields })
+      .retrieve(id, { select: defaultFields })
 
-      if (draftOrder.status === "completed") {
+    if (draftOrder.status === "completed") {
-        throw new MedusaError(
+      throw new MedusaError(
-          MedusaError.Types.NOT_ALLOWED,
+        MedusaError.Types.NOT_ALLOWED,
-          "You are only allowed to update open draft orders"
+        "You are only allowed to update open draft orders"
-        )
+      )
-      }
+    }
 
-      await cartService
+    await cartService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .removeLineItem(draftOrder.cart_id, line_id)
+      .removeLineItem(draftOrder.cart_id, line_id)
 
-      draftOrder.cart = await cartService
+    draftOrder.cart = await cartService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .retrieve(draftOrder.cart_id, {
+      .retrieve(draftOrder.cart_id, {
-          relations: defaultCartRelations,
+        relations: defaultCartRelations,
-          select: defaultCartFields,
+        select: defaultCartFields,
-        })
+      })
 
-      res.status(200).json({ draft_order: draftOrder })
+    res.status(200).json({ draft_order: draftOrder })
-    })
+  })
-  } catch (err) {
-    throw err
-  }
 }

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

@@ -28,22 +28,18 @@ import {
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const draftOrderService = req.scope.resolve("draftOrderService")
-    const draftOrderService = req.scope.resolve("draftOrderService")
+  const cartService = req.scope.resolve("cartService")
-    const cartService = req.scope.resolve("cartService")
 
-    const draftOrder = await draftOrderService.retrieve(id, {
+  const draftOrder = await draftOrderService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    draftOrder.cart = await cartService.retrieve(draftOrder.cart_id, {
+  draftOrder.cart = await cartService.retrieve(draftOrder.cart_id, {
-      relations: defaultCartRelations,
+    relations: defaultCartRelations,
-      select: defaultCartFields,
+    select: defaultCartFields,
-    })
+  })
 
-    res.json({ draft_order: draftOrder })
+  res.json({ draft_order: draftOrder })
-  } catch (error) {
-    throw error
-  }
 }

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

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

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

@@ -1,4 +1,3 @@
-import _ from "lodash"
 import { defaultFields, defaultRelations } from "./"
 
 /**
@@ -20,33 +19,29 @@ import { defaultFields, defaultRelations } from "./"
  */
 
 export default async (req, res) => {
-  try {
+  const draftOrderService = req.scope.resolve("draftOrderService")
-    const draftOrderService = req.scope.resolve("draftOrderService")
 
-    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
-    }
-
-    const listConfig = {
-      select: defaultFields,
-      relations: defaultRelations,
-      skip: offset,
-      take: limit,
-      order: { created_at: "DESC" },
-    }
-
-    const [draftOrders, count] = await draftOrderService.listAndCount(
-      selector,
-      listConfig
-    )
-
-    res.json({ draft_orders: draftOrders, count, offset, limit })
-  } catch (error) {
-    throw error
   }
+
+  const listConfig = {
+    select: defaultFields,
+    relations: defaultRelations,
+    skip: offset,
+    take: limit,
+    order: { created_at: "DESC" },
+  }
+
+  const [draftOrders, count] = await draftOrderService.listAndCount(
+    selector,
+    listConfig
+  )
+
+  res.json({ draft_orders: draftOrders, count, offset, limit })
 }

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

@@ -26,59 +26,53 @@ import {
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const draftOrderService = req.scope.resolve("draftOrderService")
-    const draftOrderService = req.scope.resolve("draftOrderService")
+  const paymentProviderService = req.scope.resolve("paymentProviderService")
-    const paymentProviderService = req.scope.resolve("paymentProviderService")
+  const orderService = req.scope.resolve("orderService")
-    const orderService = req.scope.resolve("orderService")
+  const cartService = req.scope.resolve("cartService")
-    const cartService = req.scope.resolve("cartService")
+  const entityManager = req.scope.resolve("manager")
-    const entityManager = req.scope.resolve("manager")
 
-    let result
+  let result
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      const draftOrder = await draftOrderService
+    const draftOrder = await draftOrderService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .retrieve(id)
+      .retrieve(id)
 
-      const cart = await cartService
+    const cart = await cartService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .retrieve(draftOrder.cart_id, {
+      .retrieve(draftOrder.cart_id, {
-          select: ["total"],
+        select: ["total"],
-          relations: [
+        relations: [
-            "discounts",
+          "discounts",
-            "discounts.rule",
+          "discounts.rule",
-            "discounts.rule.valid_for",
+          "discounts.rule.valid_for",
-            "shipping_methods",
+          "shipping_methods",
-            "region",
+          "region",
-            "items",
+          "items",
-          ],
+        ],
-        })
+      })
 
-      await paymentProviderService
+    await paymentProviderService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .createSession("system", cart)
+      .createSession("system", cart)
 
-      await cartService
+    await cartService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .setPaymentSession(cart.id, "system")
+      .setPaymentSession(cart.id, "system")
 
-      await cartService.withTransaction(manager).authorizePayment(cart.id)
+    await cartService.withTransaction(manager).authorizePayment(cart.id)
 
-      result = await orderService
+    result = await orderService.withTransaction(manager).createFromCart(cart.id)
-        .withTransaction(manager)
-        .createFromCart(cart.id)
 
-      await draftOrderService
+    await draftOrderService
-        .withTransaction(manager)
+      .withTransaction(manager)
-        .registerCartCompletion(draftOrder.id, result.id)
+      .registerCartCompletion(draftOrder.id, result.id)
-    })
+  })
 
-    const order = await orderService.retrieve(result.id, {
+  const order = await orderService.retrieve(result.id, {
-      relations: defaultOrderRelations,
+    relations: defaultOrderRelations,
-      select: defaultOrderFields,
+    select: defaultOrderFields,
-    })
+  })
 
-    res.status(200).json({ order })
+  res.status(200).json({ order })
-  } catch (err) {
-    throw err
-  }
 }

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

@@ -1,5 +1,5 @@
 import { MedusaError, Validator } from "medusa-core-utils"
-import { defaultCartFields, defaultCartRelations, defaultFields } from "."
+import { defaultCartFields, defaultCartRelations } from "."
 
 /**
  * @oas [post] /admin/draft-orders/{id}
@@ -60,9 +60,7 @@ export default async (req, res) => {
   const schema = Validator.object().keys({
     region_id: Validator.string().optional(),
     country_code: Validator.string().optional(),
-    email: Validator.string()
+    email: Validator.string().email().optional(),
-      .email()
-      .optional(),
     billing_address: Validator.object().optional(),
     shipping_address: Validator.object().optional(),
     discounts: Validator.array()
@@ -79,35 +77,31 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const draftOrderService = req.scope.resolve("draftOrderService")
-    const draftOrderService = req.scope.resolve("draftOrderService")
+  const cartService = req.scope.resolve("cartService")
-    const cartService = req.scope.resolve("cartService")
 
-    const draftOrder = await draftOrderService.retrieve(id)
+  const draftOrder = await draftOrderService.retrieve(id)
 
-    if (draftOrder.status === "completed") {
+  if (draftOrder.status === "completed") {
-      throw new MedusaError(
+    throw new MedusaError(
-        MedusaError.Types.NOT_ALLOWED,
+      MedusaError.Types.NOT_ALLOWED,
-        "You are only allowed to update open draft orders"
+      "You are only allowed to update open draft orders"
-      )
+    )
-    }
-
-    if ("no_notification_order" in value) {
-      await draftOrderService.update(draftOrder.id, {
-        no_notification_order: value.no_notification_order,
-      })
-      delete value.no_notification_order
-    }
-
-    await cartService.update(draftOrder.cart_id, value)
-
-    draftOrder.cart = await cartService.retrieve(draftOrder.cart_id, {
-      relations: defaultCartRelations,
-      select: defaultCartFields,
-    })
-
-    res.status(200).json({ draft_order: draftOrder })
-  } catch (err) {
-    throw err
   }
+
+  if ("no_notification_order" in value) {
+    await draftOrderService.update(draftOrder.id, {
+      no_notification_order: value.no_notification_order,
+    })
+    delete value.no_notification_order
+  }
+
+  await cartService.update(draftOrder.cart_id, value)
+
+  draftOrder.cart = await cartService.retrieve(draftOrder.cart_id, {
+    relations: defaultCartRelations,
+    select: defaultCartFields,
+  })
+
+  res.status(200).json({ draft_order: draftOrder })
 }

packages/medusa/src/api/routes/admin/draft-orders/update-line-item.js

@@ -51,64 +51,60 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const draftOrderService = req.scope.resolve("draftOrderService")
-    const draftOrderService = req.scope.resolve("draftOrderService")
+  const cartService = req.scope.resolve("cartService")
-    const cartService = req.scope.resolve("cartService")
+  const entityManager = req.scope.resolve("manager")
-    const entityManager = req.scope.resolve("manager")
 
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      const draftOrder = await draftOrderService
+    const draftOrder = await draftOrderService
+      .withTransaction(manager)
+      .retrieve(id, {
+        select: defaultFields,
+        relations: ["cart", "cart.items"],
+      })
+
+    if (draftOrder.status === "completed") {
+      throw new MedusaError(
+        MedusaError.Types.NOT_ALLOWED,
+        "You are only allowed to update open draft orders"
+      )
+    }
+
+    if (value.quantity === 0) {
+      await cartService
         .withTransaction(manager)
-        .retrieve(id, {
+        .removeLineItem(draftOrder.cart.id, line_id)
-          select: defaultFields,
+    } else {
-          relations: ["cart", "cart.items"],
+      const existing = draftOrder.cart.items.find((i) => i.id === line_id)
-        })
 
-      if (draftOrder.status === "completed") {
+      if (!existing) {
         throw new MedusaError(
-          MedusaError.Types.NOT_ALLOWED,
+          MedusaError.Types.INVALID_DATA,
-          "You are only allowed to update open draft orders"
+          "Could not find the line item"
         )
       }
 
-      if (value.quantity === 0) {
+      const lineItemUpdate = {
-        await cartService
+        ...value,
-          .withTransaction(manager)
+        region_id: draftOrder.cart.region_id,
-          .removeLineItem(draftOrder.cart.id, line_id)
-      } else {
-        const existing = draftOrder.cart.items.find(i => i.id === line_id)
-
-        if (!existing) {
-          throw new MedusaError(
-            MedusaError.Types.INVALID_DATA,
-            "Could not find the line item"
-          )
-        }
-
-        const lineItemUpdate = {
-          ...value,
-          region_id: draftOrder.cart.region_id,
-        }
-
-        if (existing.variant_id) {
-          lineItemUpdate.variant_id = existing.variant_id
-        }
-
-        await cartService
-          .withTransaction(manager)
-          .updateLineItem(draftOrder.cart_id, line_id, lineItemUpdate)
       }
 
-      draftOrder.cart = await cartService
+      if (existing.variant_id) {
-        .withTransaction(manager)
+        lineItemUpdate.variant_id = existing.variant_id
-        .retrieve(draftOrder.cart_id, {
+      }
-          relations: defaultCartRelations,
-          select: defaultCartFields,
-        })
 
-      res.status(200).json({ draft_order: draftOrder })
+      await cartService
-    })
+        .withTransaction(manager)
-  } catch (err) {
+        .updateLineItem(draftOrder.cart_id, line_id, lineItemUpdate)
-    throw err
+    }
-  }
+
+    draftOrder.cart = await cartService
+      .withTransaction(manager)
+      .retrieve(draftOrder.cart_id, {
+        relations: defaultCartRelations,
+        select: defaultCartFields,
+      })
+
+    res.status(200).json({ draft_order: draftOrder })
+  })
 }