feat(plugins): Adds add-on plugin

Adds an add-on plugin, that supports adding add-ons to line items in the cart

packages/medusa-plugin-add-ons/src/api/index.js

@@ -0,0 +1,12 @@
+import { Router } from "express"
+import admin from "./routes/admin"
+import store from "./routes/store"
+
+export default (rootDirectory) => {
+  const app = Router()
+
+  store(app, rootDirectory)
+  admin(app)
+
+  return app
+}

packages/medusa-plugin-add-ons/src/api/middlewares/await-middleware.js

@@ -0,0 +1 @@
+export default (fn) => (...args) => fn(...args).catch(args[2])

packages/medusa-plugin-add-ons/src/api/middlewares/index.js

@@ -0,0 +1,5 @@
+import { default as wrap } from "./await-middleware"
+
+export default {
+  wrap,
+}

packages/medusa-plugin-add-ons/src/api/routes/admin/create-add-on.js

@@ -0,0 +1,29 @@
+import { Validator, MedusaError } from "medusa-core-utils"
+
+export default async (req, res) => {
+  const schema = Validator.object().keys({
+    name: Validator.string().required(),
+    prices: Validator.array()
+      .items({
+        currency_code: Validator.string().required(),
+        amount: Validator.number().required(),
+      })
+      .required(),
+    valid_for: Validator.array().items(Validator.string()).required(),
+    metadata: Validator.object().optional(),
+  })
+
+  const { value, error } = schema.validate(req.body)
+  if (error) {
+    throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
+  }
+  try {
+    const addOnService = req.scope.resolve("addOnService")
+
+    const addOn = await addOnService.create(value)
+
+    res.status(200).json({ addOn })
+  } catch (err) {
+    throw err
+  }
+}

packages/medusa-plugin-add-ons/src/api/routes/admin/delete-add-on.js

@@ -0,0 +1,16 @@
+export default async (req, res) => {
+  const { id } = req.params
+
+  const addOnService = req.scope.resolve("addOnService")
+  try {
+    await addOnService.delete(id)
+
+    res.status(200).send({
+      id,
+      object: "addOn",
+      deleted: true,
+    })
+  } catch (err) {
+    throw err
+  }
+}

packages/medusa-plugin-add-ons/src/api/routes/admin/get-add-on.js

@@ -0,0 +1,11 @@
+export default async (req, res) => {
+  const { id } = req.params
+
+  try {
+    const addOnService = req.scope.resolve("addOnService")
+    const addOn = await addOnService.retrieve(id)
+    res.json({ add_on: addOn })
+  } catch (err) {
+    throw err
+  }
+}

packages/medusa-plugin-add-ons/src/api/routes/admin/index.js

@@ -0,0 +1,23 @@
+import { Router } from "express"
+import bodyParser from "body-parser"
+import middlewares from "../../middlewares"
+
+const route = Router()
+
+export default (app) => {
+  app.use("/admin", route)
+
+  route.post(
+    "/add-ons",
+    bodyParser.json(),
+    middlewares.wrap(require("./create-add-on").default)
+  )
+
+  route.post(
+    "/add-ons/:id",
+    bodyParser.json(),
+    middlewares.wrap(require("./update-add-on").default)
+  )
+
+  return app
+}

packages/medusa-plugin-add-ons/src/api/routes/admin/list-add-ons.js

@@ -0,0 +1,10 @@
+export default async (req, res) => {
+  try {
+    const addOnService = req.scope.resolve("addOnService")
+    const addOns = await addOnService.list({})
+
+    res.status(200).json({ add_ons: addOns })
+  } catch (err) {
+    throw err
+  }
+}

packages/medusa-plugin-add-ons/src/api/routes/admin/update-add-on.js

@@ -0,0 +1,31 @@
+import { Validator, MedusaError } from "medusa-core-utils";
+
+export default async (req, res) => {
+  const { id } = req.params;
+
+  const schema = Validator.object().keys({
+    name: Validator.string().optional(),
+    prices: Validator.array()
+      .items({
+        currency_code: Validator.string().required(),
+        amount: Validator.number().required(),
+      })
+      .optional(),
+    valid_for: Validator.array().items(Validator.string()).optional(),
+    metadata: Validator.object().optional(),
+  });
+
+  const { value, error } = schema.validate(req.body);
+  if (error) {
+    throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details);
+  }
+  try {
+    const addOnService = req.scope.resolve("addOnService");
+
+    const addOn = await addOnService.update(id, value);
+
+    res.status(200).json({ addOn });
+  } catch (err) {
+    throw err;
+  }
+};

packages/medusa-plugin-add-ons/src/api/routes/store/create-line-item.js

@@ -0,0 +1,37 @@
+import { Validator, MedusaError } from "medusa-core-utils"
+
+export default async (req, res) => {
+  const { id } = req.params
+
+  const schema = Validator.object().keys({
+    variant_id: Validator.string().required(),
+    quantity: Validator.number().required(),
+    add_ons: Validator.array().items(Validator.string()).optional(),
+  })
+
+  const { value, error } = schema.validate(req.body)
+  if (error) {
+    throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
+  }
+
+  try {
+    const lineItemService = req.scope.resolve("addOnLineItemService")
+    const cartService = req.scope.resolve("cartService")
+
+    let cart = await cartService.retrieve(id)
+
+    const lineItem = await lineItemService.generate(
+      value.variant_id,
+      cart.region_id,
+      value.quantity,
+      value.add_ons
+    )
+
+    cart = await cartService.addLineItem(cart._id, lineItem)
+    cart = await cartService.decorate(cart, [], ["region"])
+
+    res.status(200).json({ cart })
+  } catch (err) {
+    throw err
+  }
+}

packages/medusa-plugin-add-ons/src/api/routes/store/get-by-product.js

@@ -0,0 +1,21 @@
+import { Validator } from "medusa-core-utils"
+
+export default async (req, res) => {
+  const schema = Validator.object({
+    product_id: Validator.string().required(),
+  })
+
+  const { value, error } = schema.validate(region_id)
+
+  if (error) {
+    throw error
+  }
+
+  try {
+    const addOnService = req.scope.resolve("addOnService")
+    const addOn = await addOnService.retrieveByProduct(value.product_id)
+    res.json({ add_on: addOn })
+  } catch (err) {
+    throw err
+  }
+}

packages/medusa-plugin-add-ons/src/api/routes/store/index.js

@@ -0,0 +1,37 @@
+import { Router } from "express"
+import bodyParser from "body-parser"
+import cors from "cors"
+import middlewares from "../../middlewares"
+import { getConfigFile } from "medusa-core-utils"
+
+const route = Router()
+
+export default (app, rootDirectory) => {
+  const { configModule } = getConfigFile(rootDirectory, `medusa-config`)
+  const config = (configModule && configModule.projectConfig) || {}
+
+  const storeCors = config.store_cors || ""
+
+  route.use(
+    cors({
+      origin: storeCors.split(","),
+      credentials: true,
+    })
+  )
+
+  app.use("/store", route)
+
+  route.post(
+    "/carts/:id/line-items/add-on",
+    bodyParser.json(),
+    middlewares.wrap(require("./create-line-item").default)
+  )
+
+  route.post(
+    "/carts/:id/line-items/:line_id/add-on",
+    bodyParser.json(),
+    middlewares.wrap(require("./update-line-item").default)
+  )
+
+  return app
+}

packages/medusa-plugin-add-ons/src/api/routes/store/update-line-item.js

@@ -0,0 +1,50 @@
+import { Validator, MedusaError } from "medusa-core-utils"
+
+export default async (req, res) => {
+  const { id, line_id } = req.params
+
+  const schema = Validator.object().keys({
+    add_ons: Validator.array().items(Validator.string()).optional(),
+    quantity: Validator.number().optional(),
+  })
+
+  const { value, error } = schema.validate(req.body)
+  if (error) {
+    throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
+  }
+
+  try {
+    const lineItemService = req.scope.resolve("addOnLineItemService")
+    const cartService = req.scope.resolve("cartService")
+
+    let cart
+    if (value.quantity === 0) {
+      cart = await cartService.removeLineItem(id, line_id)
+    } else {
+      cart = await cartService.retrieve(id)
+
+      const existing = cart.items.find((i) => i._id.equals(line_id))
+      if (!existing) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          "Could not find the line item"
+        )
+      }
+
+      const lineItem = await lineItemService.generate(
+        existing.content.variant._id,
+        cart.region_id,
+        value.quantity,
+        value.add_ons
+      )
+
+      cart = await cartService.updateLineItem(cart._id, line_id, lineItem)
+    }
+
+    cart = await cartService.decorate(cart, [], ["region"])
+
+    res.status(200).json({ cart })
+  } catch (err) {
+    throw err
+  }
+}