fix(product, types, workflows): Update product variant workflow

integration-tests/plugins/__tests__/product/admin/update-product-variant.spec.ts

@@ -62,6 +62,9 @@ describe("[Product & Pricing Module] POST /admin/products/:id/variants/:id", ()
         {
           options: [{ option_id: "test-product-option-1", value: "test" }],
         },
+        {
+          options: [{ option_id: "test-product-option-1", value: "test 2" }],
+        },
       ],
       options: [
         {
@@ -250,4 +253,121 @@ describe("[Product & Pricing Module] POST /admin/products/:id/variants/:id", ()
       })
     )
   })
+
+  it("Should update variant option value", async () => {
+    const api = useApi()! as AxiosInstance
+
+    const data = {
+      options: [
+        {
+          option_id: "test-product-option-1",
+          value: "updated",
+        },
+      ],
+    }
+
+    await api.post(
+      `/admin/products/${product.id}/variants/${variant.id}`,
+      data,
+      adminHeaders
+    )
+
+    const response = await api.get(
+      `/admin/products/${product.id}`,
+      adminHeaders
+    )
+
+    expect(response.status).toEqual(200)
+    expect(response.data.product).toEqual(
+      expect.objectContaining({
+        id: expect.any(String),
+        variants: expect.arrayContaining([
+          expect.objectContaining({
+            id: variant.id,
+            options: [
+              expect.objectContaining({
+                option_id: "test-product-option-1",
+                value: "updated",
+              }),
+            ],
+          }),
+          expect.objectContaining({
+            id: product.variants[1].id,
+            options: [
+              expect.objectContaining({
+                option_id: "test-product-option-1",
+                value: "test 2",
+              }),
+            ],
+          }),
+        ]),
+      })
+    )
+  })
+
+  it("Should remove options not present in update", async () => {
+    const api = useApi()! as AxiosInstance
+
+    product = await simpleProductFactory(dbConnection, {
+      id: "test-product-with-multiple-options",
+      variants: [
+        {
+          options: [
+            { option_id: "test-product-multi-option-1", value: "test" },
+            { option_id: "test-product-multi-option-2", value: "test value" },
+          ],
+        },
+      ],
+      options: [
+        {
+          id: "test-product-multi-option-1",
+          title: "Test option 1",
+        },
+        {
+          id: "test-product-multi-option-2",
+          title: "Test option 2",
+        },
+      ],
+    })
+
+    variant = product.variants[0]
+
+    const data = {
+      options: [
+        {
+          option_id: "test-product-multi-option-1",
+          value: "updated",
+        },
+      ],
+    }
+
+    await api.post(
+      `/admin/products/${product.id}/variants/${variant.id}`,
+      data,
+      adminHeaders
+    )
+
+    const response = await api.get(
+      `/admin/products/${product.id}`,
+      adminHeaders
+    )
+
+    expect(response.status).toEqual(200)
+    expect(response.data.product).toEqual(
+      expect.objectContaining({
+        id: expect.any(String),
+        variants: [
+          expect.objectContaining({
+            id: variant.id,
+            options: [
+              expect.objectContaining({
+                option_id: "test-product-multi-option-1",
+                value: "updated",
+              }),
+            ],
+          }),
+        ],
+      })
+    )
+  })
 })

packages/product/src/loaders/container.ts

@@ -5,6 +5,7 @@ import {
   ProductCollectionRepository,
   ProductImageRepository,
   ProductOptionRepository,
+  ProductOptionValueRepository,
   ProductRepository,
   ProductTagRepository,
   ProductTypeRepository,
@@ -17,6 +18,7 @@ import {
   ProductImageService,
   ProductModuleService,
   ProductOptionService,
+  ProductOptionValueService,
   ProductService,
   ProductTagService,
   ProductTypeService,
@@ -48,6 +50,7 @@ export default async ({
     productImageService: asClass(ProductImageService).singleton(),
     productTypeService: asClass(ProductTypeService).singleton(),
     productOptionService: asClass(ProductOptionService).singleton(),
+    productOptionValueService: asClass(ProductOptionValueService).singleton(),
   })
 
   if (customRepositories) {
@@ -69,6 +72,9 @@ function loadDefaultRepositories({ container }) {
     productTagRepository: asClass(ProductTagRepository).singleton(),
     productTypeRepository: asClass(ProductTypeRepository).singleton(),
     productOptionRepository: asClass(ProductOptionRepository).singleton(),
+    productOptionValueRepository: asClass(
+      ProductOptionValueRepository
+    ).singleton(),
     productVariantRepository: asClass(ProductVariantRepository).singleton(),
   })
 }

packages/product/src/models/index.ts

@@ -5,4 +5,5 @@ export { default as ProductTag } from "./product-tag"
 export { default as ProductType } from "./product-type"
 export { default as ProductVariant } from "./product-variant"
 export { default as ProductOption } from "./product-option"
+export { default as ProductOptionValue } from "./product-option-value"
 export { default as Image } from "./product-image"

packages/product/src/repositories/index.ts

@@ -7,3 +7,4 @@ export { ProductCategoryRepository } from "./product-category"
 export { ProductImageRepository } from "./product-image"
 export { ProductTypeRepository } from "./product-type"
 export { ProductOptionRepository } from "./product-option"
+export { ProductOptionValueRepository } from "./product-option-value"

packages/product/src/repositories/product-option-value.ts

@@ -0,0 +1,109 @@
+import { ProductOptionValue } from "@models"
+import { Context, DAL } from "@medusajs/types"
+import { SqlEntityManager } from "@mikro-orm/postgresql"
+import { DALUtils } from "@medusajs/utils"
+import {
+  CreateProductOptionValueDTO,
+  UpdateProductOptionValueDTO,
+} from "../types/services/product-option-value"
+import { LoadStrategy } from "@mikro-orm/core"
+import { FilterQuery as MikroFilterQuery } from "@mikro-orm/core/typings"
+import { FindOptions as MikroOptions } from "@mikro-orm/core/drivers/IDatabaseDriver"
+
+export class ProductOptionValueRepository extends DALUtils.MikroOrmBaseRepository {
+  protected readonly manager_: SqlEntityManager
+
+  constructor({ manager }: { manager: SqlEntityManager }) {
+    // @ts-ignore
+    // eslint-disable-next-line prefer-rest-params
+    super(...arguments)
+    this.manager_ = manager
+  }
+
+  async find(
+    findOptions: DAL.FindOptions<ProductOptionValue> = { where: {} },
+    context: Context = {}
+  ): Promise<ProductOptionValue[]> {
+    const manager = this.getActiveManager<SqlEntityManager>(context)
+    const findOptions_ = { ...findOptions }
+
+    findOptions_.options ??= {}
+
+    Object.assign(findOptions_.options, {
+      strategy: LoadStrategy.SELECT_IN,
+    })
+
+    return await manager.find(
+      ProductOptionValue,
+      findOptions_.where as MikroFilterQuery<ProductOptionValue>,
+      findOptions_.options as MikroOptions<ProductOptionValue>
+    )
+  }
+
+  async upsert(
+    optionValues: (UpdateProductOptionValueDTO | CreateProductOptionValueDTO)[],
+    context: Context = {}
+  ): Promise<ProductOptionValue[]> {
+    const manager = this.getActiveManager<SqlEntityManager>(context)
+
+    const optionValueIds = optionValues
+      .filter((option) => !!option.id)
+      .map(({ id }) => id!)
+
+    const existingOptionValues = await this.find(
+      {
+        where: {
+          id: {
+            $in: optionValueIds,
+          },
+        },
+      },
+      context
+    )
+
+    const existingOptionValuesMap = new Map(
+      existingOptionValues.map<[string, ProductOptionValue]>((optionValue) => [
+        optionValue.id,
+        optionValue,
+      ])
+    )
+
+    const upsertedOptionValues: ProductOptionValue[] = []
+    const optionValuesToCreate: ProductOptionValue[] = []
+    const optionValuesToUpdate: ProductOptionValue[] = []
+
+    optionValues.forEach((optionValue) => {
+      if (optionValue.id && existingOptionValuesMap.has(optionValue.id)) {
+        const existingOptionValue = existingOptionValuesMap.get(optionValue.id)!
+        const updatedOptionValue = manager.assign(
+          existingOptionValue,
+          optionValue as UpdateProductOptionValueDTO
+        )
+        optionValuesToUpdate.push(updatedOptionValue)
+      } else {
+        const newOptionValue = manager.create(
+          ProductOptionValue,
+          optionValue as CreateProductOptionValueDTO
+        )
+        optionValuesToCreate.push(newOptionValue)
+      }
+    })
+
+    if (optionValuesToCreate.length) {
+      manager.persist(optionValuesToCreate)
+      upsertedOptionValues.push(...optionValuesToCreate)
+    }
+
+    if (optionValuesToUpdate.length) {
+      manager.persist(optionValuesToUpdate)
+      upsertedOptionValues.push(...optionValuesToUpdate)
+    }
+
+    return upsertedOptionValues
+  }
+
+  async delete(ids: string[], context: Context = {}): Promise<void> {
+    const manager = this.getActiveManager<SqlEntityManager>(context)
+    await manager.nativeDelete(ProductOptionValue, { id: { $in: ids } }, {})
+  }
+}

packages/product/src/services/index.ts

@@ -7,3 +7,4 @@ export { default as ProductVariantService } from "./product-variant"
 export { default as ProductTypeService } from "./product-type"
 export { default as ProductOptionService } from "./product-option"
 export { default as ProductImageService } from "./product-image"
+export { default as ProductOptionValueService } from "./product-option-value"