feat(medusa,product,core-flows,types): product options redesign (server-side)

.changeset/forty-tables-fetch.md

@@ -0,0 +1,8 @@
+---
+"@medusajs/medusa": minor
+"@medusajs/product": minor
+"@medusajs/core-flows": minor
+"@medusajs/types": minor
+---
+
+feat(medusa,product,core-flows,types): product options redesign (server-side)

integration-tests/.env.test

@@ -2,4 +2,4 @@
 DB_HOST=localhost
 DB_USERNAME=postgres
 DB_PASSWORD=''
-LOG_LEVEL=error
+LOG_LEVEL=error

integration-tests/http/__tests__/product-option/product-option.spec.ts

@@ -0,0 +1,274 @@
+import { medusaIntegrationTestRunner } from "@medusajs/test-utils"
+import {
+  adminHeaders,
+  createAdminUser,
+} from "../../../helpers/create-admin-user"
+
+jest.setTimeout(30000)
+
+medusaIntegrationTestRunner({
+  env: {},
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    let option1
+    let option2
+
+    beforeEach(async () => {
+      const container = getContainer()
+      await createAdminUser(dbConnection, adminHeaders, container)
+
+      option1 = (
+        await api.post(
+          "/admin/product-options",
+          {
+            title: "option1",
+            values: ["A", "B", "C"],
+          },
+          adminHeaders
+        )
+      ).data.product_option
+
+      option2 = (
+        await api.post(
+          "/admin/product-options",
+          {
+            title: "option2",
+            values: ["D", "E"],
+            is_exclusive: true,
+          },
+          adminHeaders
+        )
+      ).data.product_option
+    })
+
+    describe("GET /admin/product-options", () => {
+      it("should return a list of product options", async () => {
+        const res = await api.get("/admin/product-options", adminHeaders)
+
+        expect(res.status).toEqual(200)
+        expect(res.data.product_options).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              title: "option1",
+              is_exclusive: false,
+              values: expect.arrayContaining([
+                expect.objectContaining({ value: "A" }),
+                expect.objectContaining({ value: "B" }),
+                expect.objectContaining({ value: "C" }),
+              ]),
+            }),
+            expect.objectContaining({
+              title: "option2",
+              is_exclusive: true,
+              values: expect.arrayContaining([
+                expect.objectContaining({ value: "D" }),
+                expect.objectContaining({ value: "E" }),
+              ]),
+            }),
+          ])
+        )
+      })
+
+      it("should return a list of product options matching free text search param", async () => {
+        const res = await api.get("/admin/product-options?q=1", adminHeaders)
+
+        expect(res.status).toEqual(200)
+        expect(res.data.product_options.length).toEqual(1)
+        expect(res.data.product_options).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({ title: "option1" }),
+          ])
+        )
+      })
+
+      it("should return a list of exclusive product options", async () => {
+        const res = await api.get(
+          "/admin/product-options?is_exclusive=false",
+          adminHeaders
+        )
+
+        expect(res.status).toEqual(200)
+        expect(res.data.product_options.length).toEqual(1)
+        expect(res.data.product_options).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({ title: "option1" }),
+          ])
+        )
+      })
+    })
+
+    describe("POST /admin/product-options", () => {
+      it("should create a product option with value ranks", async () => {
+        const option = (
+          await api.post(
+            `/admin/product-options`,
+            {
+              title: "option3",
+              values: ["D", "E"],
+              ranks: {
+                E: 1,
+                D: 2,
+              },
+            },
+            adminHeaders
+          )
+        ).data.product_option
+
+        expect(option).toEqual(
+          expect.objectContaining({
+            title: "option3",
+            is_exclusive: false,
+            values: expect.arrayContaining([
+              expect.objectContaining({
+                value: "D",
+                rank: 2,
+              }),
+              expect.objectContaining({
+                value: "E",
+                rank: 1,
+              }),
+            ]),
+          })
+        )
+      })
+
+      it("should throw if a rank is specified for invalid value", async () => {
+        const error = await api
+          .post(
+            `/admin/product-options`,
+            {
+              title: "option3",
+              values: ["D", "E"],
+              ranks: {
+                E: 1,
+                invalid: 2,
+              },
+            },
+            adminHeaders
+          )
+          .catch((err) => err)
+
+        expect(error.response.status).toEqual(400)
+        expect(error.response.data.message).toEqual(
+          'Value "invalid" is assigned a rank but is not defined in the list of values.'
+        )
+      })
+    })
+
+    describe("GET /admin/product-options/[id]", () => {
+      it("should return a product option", async () => {
+        const res = await api.get(
+          `/admin/product-options/${option1.id}`,
+          adminHeaders
+        )
+
+        expect(res.status).toEqual(200)
+        expect(res.data.product_option.values.length).toEqual(3)
+        expect(res.data.product_option).toEqual(
+          expect.objectContaining({
+            title: "option1",
+            is_exclusive: false,
+            values: expect.arrayContaining([
+              expect.objectContaining({ value: "A" }),
+              expect.objectContaining({ value: "B" }),
+              expect.objectContaining({ value: "C" }),
+            ]),
+          })
+        )
+      })
+    })
+
+    describe("POST /admin/product-options/[id]", () => {
+      it("should update a product option", async () => {
+        const option = (
+          await api.post(
+            `/admin/product-options/${option2.id}`,
+            {
+              is_exclusive: false,
+            },
+            adminHeaders
+          )
+        ).data.product_option
+
+        expect(option.values.length).toEqual(2)
+        expect(option).toEqual(
+          expect.objectContaining({
+            title: "option2",
+            is_exclusive: false,
+            values: expect.arrayContaining([
+              expect.objectContaining({ value: "D" }),
+              expect.objectContaining({ value: "E" }),
+            ]),
+          })
+        )
+
+        const res = await api.get(
+          "/admin/product-options?is_exclusive=true",
+          adminHeaders
+        )
+
+        expect(res.status).toEqual(200)
+        expect(res.data.product_options.length).toEqual(0)
+      })
+
+      it("should update a product value ranks", async () => {
+        const option = (
+          await api.post(
+            `/admin/product-options/${option2.id}`,
+            {
+              ranks: {
+                D: 2,
+                E: 1,
+              },
+            },
+            adminHeaders
+          )
+        ).data.product_option
+
+        expect(option.values.length).toEqual(2)
+        expect(option).toEqual(
+          expect.objectContaining({
+            title: "option2",
+            is_exclusive: true,
+            values: expect.arrayContaining([
+              expect.objectContaining({
+                value: "D",
+                rank: 2,
+              }),
+              expect.objectContaining({
+                value: "E",
+                rank: 1,
+              }),
+            ]),
+          })
+        )
+      })
+
+      it("should throw when trying to update an option that does not exist", async () => {
+        const error = await api.post(
+          `/admin/product-options/iDontExist`,
+          {
+            is_exclusive: false,
+          },
+          adminHeaders
+        ).catch((e) => e)
+
+        expect(error.response.status).toEqual(404)
+        expect(error.response.data).toEqual({
+          message:  "Product option with id \"iDontExist\" not found",
+          type: "not_found"
+        })
+      })
+    })
+
+    describe("DELETE /admin/product-options/[id]", () => {
+      it("should delete a product option", async () => {
+        await api.delete(`/admin/product-options/${option2.id}`, adminHeaders)
+
+        const res = await api.get("/admin/product-options", adminHeaders)
+
+        expect(res.status).toEqual(200)
+        expect(res.data.product_options.length).toEqual(1)
+      })
+    })
+  },
+})

integration-tests/http/__tests__/product/admin/product-imports.spec.ts

@@ -4,8 +4,8 @@ import { csv2json, json2csv } from "json-2-csv"
 import { CommonEvents, Modules } from "@medusajs/utils"
 import { IEventBusModuleService, IFileModuleService } from "@medusajs/types"
 import {
-  TestEventUtils,
   medusaIntegrationTestRunner,
+  TestEventUtils,
 } from "@medusajs/test-utils"
 import {
   adminHeaders,