Fix linting errors in routes admin product (#656)

.eslintignore

@@ -35,7 +35,6 @@
 /packages/medusa/src/api/routes/admin/notes
 /packages/medusa/src/api/routes/admin/notifications
 /packages/medusa/src/api/routes/admin/orders
-/packages/medusa/src/api/routes/admin/products
 /packages/medusa/src/api/routes/admin/regions
 /packages/medusa/src/api/routes/admin/return-reasons
 /packages/medusa/src/api/routes/admin/returns

packages/medusa/src/api/routes/admin/products/add-option.js

@@ -39,17 +39,13 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
 
-    await productService.addOption(id, value.title)
+  await productService.addOption(id, value.title)
-    const product = await productService.retrieve(id, {
+  const product = await productService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ product })
+  res.json({ product })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/products/create-product.js

@@ -188,9 +188,7 @@ export default async (req, res) => {
     description: Validator.string().allow(""),
     is_giftcard: Validator.boolean().default(false),
     discountable: Validator.boolean().default(true),
-    images: Validator.array()
+    images: Validator.array().items(Validator.string()).optional(),
-      .items(Validator.string())
-      .optional(),
     thumbnail: Validator.string().optional(),
     handle: Validator.string().optional(),
     status: Validator.string()
@@ -203,9 +201,7 @@ export default async (req, res) => {
       })
       .allow(null)
       .optional(),
-    collection_id: Validator.string()
+    collection_id: Validator.string().allow(null).optional(),
-      .allow(null)
-      .optional(),
     tags: Validator.array()
       .items({
         id: Validator.string().optional(),
@@ -225,30 +221,13 @@ export default async (req, res) => {
       inventory_quantity: Validator.number().default(0),
       allow_backorder: Validator.boolean().optional(),
       manage_inventory: Validator.boolean().optional(),
-      weight: Validator.number()
+      weight: Validator.number().allow(null).optional(),
-        .allow(null)
+      length: Validator.number().allow(null).optional(),
-        .optional(),
+      height: Validator.number().allow(null).optional(),
-      length: Validator.number()
+      width: Validator.number().allow(null).optional(),
-        .allow(null)
+      origin_country: Validator.string().optional().allow("").allow(null),
-        .optional(),
+      mid_code: Validator.string().optional().allow("").allow(null),
-      height: Validator.number()
+      material: Validator.string().optional().allow("").allow(null),
-        .allow(null)
-        .optional(),
-      width: Validator.number()
-        .allow(null)
-        .optional(),
-      origin_country: Validator.string()
-        .optional()
-        .allow("")
-        .allow(null),
-      mid_code: Validator.string()
-        .optional()
-        .allow("")
-        .allow(null),
-      material: Validator.string()
-        .optional()
-        .allow("")
-        .allow(null),
       metadata: Validator.object().optional(),
       prices: Validator.array()
         .items(
@@ -256,9 +235,7 @@ export default async (req, res) => {
             .keys({
               region_id: Validator.string(),
               currency_code: Validator.string(),
-              amount: Validator.number()
+              amount: Validator.number().integer().required(),
-                .integer()
-                .required(),
               sale_amount: Validator.number().optional(),
             })
             .xor("region_id", "currency_code")
@@ -270,30 +247,14 @@ export default async (req, res) => {
         })
         .default([]),
     }),
-    weight: Validator.number()
+    weight: Validator.number().allow(null).optional(),
-      .allow(null)
+    length: Validator.number().allow(null).optional(),
-      .optional(),
+    height: Validator.number().allow(null).optional(),
-    length: Validator.number()
+    width: Validator.number().allow(null).optional(),
-      .allow(null)
+    hs_code: Validator.string().optional().allow(""),
-      .optional(),
+    origin_country: Validator.string().optional().allow(""),
-    height: Validator.number()
+    mid_code: Validator.string().optional().allow(""),
-      .allow(null)
+    material: Validator.string().optional().allow(""),
-      .optional(),
-    width: Validator.number()
-      .allow(null)
-      .optional(),
-    hs_code: Validator.string()
-      .optional()
-      .allow(""),
-    origin_country: Validator.string()
-      .optional()
-      .allow(""),
-    mid_code: Validator.string()
-      .optional()
-      .allow(""),
-    material: Validator.string()
-      .optional()
-      .allow(""),
     metadata: Validator.object().optional(),
   })
 
@@ -302,66 +263,64 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
+  const productVariantService = req.scope.resolve("productVariantService")
-    const productVariantService = req.scope.resolve("productVariantService")
+  const shippingProfileService = req.scope.resolve("shippingProfileService")
-    const shippingProfileService = req.scope.resolve("shippingProfileService")
 
-    const entityManager = req.scope.resolve("manager")
+  const entityManager = req.scope.resolve("manager")
 
-    let newProduct
+  let newProduct
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      const { variants } = value
+    const { variants } = value
-      delete value.variants
+    delete value.variants
 
-      if (!value.thumbnail && value.images && value.images.length) {
+    if (!value.thumbnail && value.images && value.images.length) {
-        value.thumbnail = value.images[0]
+      value.thumbnail = value.images[0]
+    }
+
+    let shippingProfile
+    // Get default shipping profile
+    if (value.is_giftcard) {
+      shippingProfile = await shippingProfileService.retrieveGiftCardDefault()
+    } else {
+      shippingProfile = await shippingProfileService.retrieveDefault()
+    }
+
+    newProduct = await productService
+      .withTransaction(manager)
+      .create({ ...value, profile_id: shippingProfile.id })
+
+    if (variants) {
+      for (const [i, variant] of variants.entries()) {
+        variant.variant_rank = i
       }
 
-      let shippingProfile
+      const optionIds = value.options.map(
-      // Get default shipping profile
+        (o) => newProduct.options.find((newO) => newO.title === o.title).id
-      if (value.is_giftcard) {
+      )
-        shippingProfile = await shippingProfileService.retrieveGiftCardDefault()
-      } else {
-        shippingProfile = await shippingProfileService.retrieveDefault()
-      }
 
-      newProduct = await productService
+      await Promise.all(
-        .withTransaction(manager)
+        variants.map(async (v) => {
-        .create({ ...value, profile_id: shippingProfile.id })
+          const variant = {
+            ...v,
+            options: v.options.map((o, index) => ({
+              ...o,
+              option_id: optionIds[index],
+            })),
+          }
 
-      if (variants) {
+          await productVariantService
-        for (const [i, variant] of variants.entries()) variant.variant_rank = i
+            .withTransaction(manager)
+            .create(newProduct.id, variant)
+        })
+      )
+    }
+  })
 
-        const optionIds = value.options.map(
+  const product = await productService.retrieve(newProduct.id, {
-          o => newProduct.options.find(newO => newO.title === o.title).id
+    select: defaultFields,
-        )
+    relations: defaultRelations,
+  })
 
-        await Promise.all(
+  res.json({ product })
-          variants.map(async v => {
-            const variant = {
-              ...v,
-              options: v.options.map((o, index) => ({
-                ...o,
-                option_id: optionIds[index],
-              })),
-            }
-
-            await productVariantService
-              .withTransaction(manager)
-              .create(newProduct.id, variant)
-          })
-        )
-      }
-    })
-
-    const product = await productService.retrieve(newProduct.id, {
-      select: defaultFields,
-      relations: defaultRelations,
-    })
-
-    res.json({ product })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/products/create-variant.js

@@ -115,18 +115,10 @@ export default async (req, res) => {
     inventory_quantity: Validator.number().default(0),
     allow_backorder: Validator.boolean().optional(),
     manage_inventory: Validator.boolean().optional(),
-    weight: Validator.number()
+    weight: Validator.number().allow(null).optional(),
-      .allow(null)
+    length: Validator.number().allow(null).optional(),
-      .optional(),
+    height: Validator.number().allow(null).optional(),
-    length: Validator.number()
+    width: Validator.number().allow(null).optional(),
-      .allow(null)
-      .optional(),
-    height: Validator.number()
-      .allow(null)
-      .optional(),
-    width: Validator.number()
-      .allow(null)
-      .optional(),
     origin_country: Validator.string().allow(""),
     mid_code: Validator.string().allow(""),
     material: Validator.string().allow(""),
@@ -137,9 +129,7 @@ export default async (req, res) => {
           .keys({
             region_id: Validator.string().empty(null),
             currency_code: Validator.string().required(),
-            amount: Validator.number()
+            amount: Validator.number().integer().required(),
-              .integer()
-              .required(),
             sale_amount: Validator.number().optional(),
           })
           .xor("region_id", "currency_code")
@@ -158,19 +148,15 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const productVariantService = req.scope.resolve("productVariantService")
-    const productVariantService = req.scope.resolve("productVariantService")
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
 
-    await productVariantService.create(id, value)
+  await productVariantService.create(id, value)
 
-    const product = await productService.retrieve(id, {
+  const product = await productService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ product })
+  res.json({ product })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/products/delete-option.js

@@ -31,21 +31,17 @@ import { defaultRelations, defaultFields } from "."
 export default async (req, res) => {
   const { id, option_id } = req.params
 
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
+  await productService.deleteOption(id, option_id)
-    await productService.deleteOption(id, option_id)
+  const data = await productService.retrieve(id, {
-    const data = await productService.retrieve(id, {
+    select: defaultFields,
-      select: defaultFields,
+    relations: defaultRelations,
-      relations: defaultRelations,
+  })
-    })
 
-    res.json({
+  res.json({
-      option_id,
+    option_id,
-      object: "option",
+    object: "option",
-      deleted: true,
+    deleted: true,
-      product: data,
+    product: data,
-    })
+  })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/products/delete-product.js

@@ -26,15 +26,11 @@
 export default async (req, res) => {
   const { id } = req.params
 
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
+  await productService.delete(id)
-    await productService.delete(id)
+  res.json({
-    res.json({
+    id,
-      id,
+    object: "product",
-      object: "product",
+    deleted: true,
-      deleted: true,
+  })
-    })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/products/delete-variant.js

@@ -29,24 +29,20 @@ import { defaultRelations, defaultFields } from "."
 export default async (req, res) => {
   const { id, variant_id } = req.params
 
-  try {
+  const productVariantService = req.scope.resolve("productVariantService")
-    const productVariantService = req.scope.resolve("productVariantService")
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
 
-    await productVariantService.delete(variant_id)
+  await productVariantService.delete(variant_id)
 
-    const data = await productService.retrieve(id, {
+  const data = await productService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({
+  res.json({
-      variant_id,
+    variant_id,
-      object: "product-variant",
+    object: "product-variant",
-      deleted: true,
+    deleted: true,
-      product: data,
+    product: data,
-    })
+  })
-  } catch (err) {
-    throw err
-  }
 }

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

@@ -3,7 +3,7 @@ import middlewares from "../../../middlewares"
 
 const route = Router()
 
-export default app => {
+export default (app) => {
   app.use("/products", route)
 
   route.post("/", middlewares.wrap(require("./create-product").default))

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

@@ -1,4 +1,3 @@
-import _ from "lodash"
 import { MedusaError, Validator } from "medusa-core-utils"
 import { defaultFields, defaultRelations, filterableFields } from "./"
 
@@ -42,52 +41,48 @@ export default async (req, res) => {
     )
   }
 
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
 
-    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 = {}
 
-    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(",")
-    }
-
-    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]
-      }
-    }
-
-    if (selector.status?.indexOf("null") > -1) {
-      selector.status.splice(selector.status.indexOf("null"), 1)
-      if (selector.status.length === 0) {
-        delete selector.status
-      }
-    }
-
-    const listConfig = {
-      select: includeFields.length ? includeFields : defaultFields,
-      relations: expandFields.length ? expandFields : defaultRelations,
-      skip: offset,
-      take: limit,
-    }
-
-    let products = await productService.list(selector, listConfig)
-
-    res.json({ products, count: products.length, offset, limit })
-  } catch (error) {
-    throw error
   }
+
+  let includeFields = []
+  if ("fields" in req.query) {
+    includeFields = req.query.fields.split(",")
+  }
+
+  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]
+    }
+  }
+
+  if (selector.status?.indexOf("null") > -1) {
+    selector.status.splice(selector.status.indexOf("null"), 1)
+    if (selector.status.length === 0) {
+      delete selector.status
+    }
+  }
+
+  const listConfig = {
+    select: includeFields.length ? includeFields : defaultFields,
+    relations: expandFields.length ? expandFields : defaultRelations,
+    skip: offset,
+    take: limit,
+  }
+
+  const products = await productService.list(selector, listConfig)
+
+  res.json({ products, count: products.length, offset, limit })
 }

packages/medusa/src/api/routes/admin/products/list-tag-usage-count.js

@@ -1,11 +1,7 @@
 export default async (req, res) => {
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
 
-    const tags = await productService.listTagsByUsage()
+  const tags = await productService.listTagsByUsage()
 
-    res.json({ tags })
+  res.json({ tags })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/products/list-types.js

@@ -18,13 +18,9 @@
  *                 $ref: "#/components/schemas/product_type"
  */
 export default async (req, res) => {
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
 
-    const types = await productService.listTypes()
+  const types = await productService.listTypes()
 
-    res.json({ types })
+  res.json({ types })
-  } catch (error) {
-    throw error
-  }
 }

packages/medusa/src/api/routes/admin/products/set-metadata.js

@@ -14,19 +14,15 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
+  await productService.update(id, {
-    await productService.update(id, {
+    metadata: { [value.key]: value.value },
-      metadata: { [value.key]: value.value },
+  })
-    })
 
-    const product = await productService.retrieve(id, {
+  const product = await productService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.status(200).json({ product })
+  res.status(200).json({ product })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/products/update-option.js

@@ -41,18 +41,14 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
 
-    await productService.updateOption(id, option_id, value)
+  await productService.updateOption(id, option_id, value)
 
-    const product = await productService.retrieve(id, {
+  const product = await productService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ product })
+  res.json({ product })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/products/update-product.js

@@ -188,9 +188,7 @@ export default async (req, res) => {
 
   const schema = Validator.object().keys({
     title: Validator.string().optional(),
-    subtitle: Validator.string()
+    subtitle: Validator.string().optional().allow(null, ""),
-      .optional()
-      .allow(null, ""),
     description: Validator.string().optional(),
     discountable: Validator.boolean().optional(),
     status: Validator.string().valid(
@@ -206,9 +204,7 @@ export default async (req, res) => {
       })
       .allow(null)
       .optional(),
-    collection_id: Validator.string()
+    collection_id: Validator.string().allow(null).optional(),
-      .allow(null)
-      .optional(),
     tags: Validator.array()
       .items({
         id: Validator.string().optional(),
@@ -216,26 +212,15 @@ export default async (req, res) => {
       })
       .optional(),
     handle: Validator.string().optional(),
-    weight: Validator.number()
+    weight: Validator.number().allow(null).optional(),
-      .allow(null)
+    length: Validator.number().allow(null).optional(),
-      .optional(),
+    height: Validator.number().allow(null).optional(),
-    length: Validator.number()
+    width: Validator.number().allow(null).optional(),
-      .allow(null)
-      .optional(),
-    height: Validator.number()
-      .allow(null)
-      .optional(),
-    width: Validator.number()
-      .allow(null)
-      .optional(),
     origin_country: Validator.string().allow(null, ""),
     hs_code: Validator.string().allow(null, ""),
     mid_code: Validator.string().allow(null, ""),
     material: Validator.string().allow(null, ""),
-    images: Validator.array()
+    images: Validator.array().items(Validator.string()).optional().optional(),
-      .items(Validator.string())
-      .optional()
-      .optional(),
     thumbnail: Validator.string().optional(),
     variants: Validator.array()
       .items({
@@ -249,9 +234,7 @@ export default async (req, res) => {
             .keys({
               region_id: Validator.string(),
               currency_code: Validator.string(),
-              amount: Validator.number()
+              amount: Validator.number().integer().required(),
-                .integer()
-                .required(),
               sale_amount: Validator.number().optional(),
             })
             .xor("region_id", "currency_code")
@@ -266,21 +249,11 @@ export default async (req, res) => {
         inventory_quantity: Validator.number().allow(null),
         allow_backorder: Validator.boolean().allow(null),
         manage_inventory: Validator.boolean().allow(null),
-        weight: Validator.number()
+        weight: Validator.number().allow(null).optional(),
-          .allow(null)
+        length: Validator.number().allow(null).optional(),
-          .optional(),
+        height: Validator.number().allow(null).optional(),
-        length: Validator.number()
+        width: Validator.number().allow(null).optional(),
-          .allow(null)
+        hs_code: Validator.string().optional().allow(null, ""),
-          .optional(),
-        height: Validator.number()
-          .allow(null)
-          .optional(),
-        width: Validator.number()
-          .allow(null)
-          .optional(),
-        hs_code: Validator.string()
-          .optional()
-          .allow(null, ""),
         origin_country: Validator.string().allow(null, ""),
         mid_code: Validator.string().allow(null, ""),
         material: Validator.string().allow(null, ""),
@@ -295,21 +268,17 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
+  const entityManager = req.scope.resolve("manager")
-    const entityManager = req.scope.resolve("manager")
 
-    await entityManager.transaction(async manager => {
+  await entityManager.transaction(async (manager) => {
-      await productService.withTransaction(manager).update(id, value)
+    await productService.withTransaction(manager).update(id, value)
-    })
+  })
 
-    const product = await productService.retrieve(id, {
+  const product = await productService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
 
-    res.json({ product })
+  res.json({ product })
-  } catch (err) {
-    throw err
-  }
 }

packages/medusa/src/api/routes/admin/products/update-variant.js

@@ -1,4 +1,3 @@
-import _ from "lodash"
 import { MedusaError, Validator } from "medusa-core-utils"
 import { defaultFields, defaultRelations } from "./"
 
@@ -116,9 +115,7 @@ export default async (req, res) => {
         .keys({
           region_id: Validator.string().empty(null),
           currency_code: Validator.string(),
-          amount: Validator.number()
+          amount: Validator.number().integer().required(),
-            .integer()
-            .required(),
           sale_amount: Validator.number().optional(),
         })
         .xor("region_id", "currency_code")
@@ -133,30 +130,14 @@ export default async (req, res) => {
     inventory_quantity: Validator.number().optional(),
     allow_backorder: Validator.boolean().optional(),
     manage_inventory: Validator.boolean().optional(),
-    weight: Validator.number()
+    weight: Validator.number().allow(null).optional(),
-      .allow(null)
+    length: Validator.number().allow(null).optional(),
-      .optional(),
+    height: Validator.number().allow(null).optional(),
-    length: Validator.number()
+    width: Validator.number().allow(null).optional(),
-      .allow(null)
+    hs_code: Validator.string().optional().allow(null, ""),
-      .optional(),
+    origin_country: Validator.string().optional().allow(null, ""),
-    height: Validator.number()
+    mid_code: Validator.string().optional().allow(null, ""),
-      .allow(null)
+    material: Validator.string().optional().allow(null, ""),
-      .optional(),
-    width: Validator.number()
-      .allow(null)
-      .optional(),
-    hs_code: Validator.string()
-      .optional()
-      .allow(null, ""),
-    origin_country: Validator.string()
-      .optional()
-      .allow(null, ""),
-    mid_code: Validator.string()
-      .optional()
-      .allow(null, ""),
-    material: Validator.string()
-      .optional()
-      .allow(null, ""),
     metadata: Validator.object().optional(),
   })
 
@@ -165,18 +146,15 @@ export default async (req, res) => {
     throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
   }
 
-  try {
+  const productService = req.scope.resolve("productService")
-    const productService = req.scope.resolve("productService")
+  const productVariantService = req.scope.resolve("productVariantService")
-    const productVariantService = req.scope.resolve("productVariantService")
 
-    await productVariantService.update(variant_id, value)
+  await productVariantService.update(variant_id, value)
 
-    const product = await productService.retrieve(id, {
+  const product = await productService.retrieve(id, {
-      select: defaultFields,
+    select: defaultFields,
-      relations: defaultRelations,
+    relations: defaultRelations,
-    })
+  })
-    res.json({ product })
+
-  } catch (err) {
+  res.json({ product })
-    throw err
-  }
 }