@medusajs/product 3.0.0-snapshot-20250410105645 → 3.0.0-snapshot-20251104004624

package/dist/services/product-module-service.js

@@ -11,13 +11,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var _a, _b;
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@medusajs/framework/types");
 const _models_1 = require("../models");
 const utils_1 = require("@medusajs/framework/utils");
-const utils_2 = require("../utils");
 const joiner_config_1 = require("./../joiner-config");
+const events_1 = require("../utils/events");
 class ProductModuleService extends (0, utils_1.MedusaService)({
     Product: _models_1.Product,
     ProductCategory: _models_1.ProductCategory,
@@ -27,13 +27,15 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     ProductTag: _models_1.ProductTag,
     ProductType: _models_1.ProductType,
     ProductVariant: _models_1.ProductVariant,
+    ProductImage: _models_1.ProductImage,
 }) {
-    constructor({ baseRepository, productService, productVariantService, productTagService, productCategoryService, productCollectionService, productImageService, productTypeService, productOptionService, productOptionValueService, [utils_1.Modules.EVENT_BUS]: eventBusModuleService, }, moduleDeclaration) {
+    constructor({ baseRepository, productRepository, productService, productVariantService, productTagService, productCategoryService, productCollectionService, productImageService, productTypeService, productOptionService, productOptionValueService, productVariantProductImageService, [utils_1.Modules.EVENT_BUS]: eventBusModuleService, }, moduleDeclaration) {
         // @ts-ignore
         // eslint-disable-next-line prefer-rest-params
         super(...arguments);
         this.moduleDeclaration = moduleDeclaration;
         this.baseRepository_ = baseRepository;
+        this.productRepository_ = productRepository;
         this.productService_ = productService;
         this.productVariantService_ = productVariantService;
         this.productTagService_ = productTagService;
@@ -43,6 +45,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         this.productTypeService_ = productTypeService;
         this.productOptionService_ = productOptionService;
         this.productOptionValueService_ = productOptionValueService;
+        this.productVariantProductImageService_ = productVariantProductImageService;
         this.eventBusModuleService_ = eventBusModuleService;
     }
     __joinerConfig() {
@@ -50,17 +53,63 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     }
     // @ts-ignore
     async retrieveProduct(productId, config, sharedContext) {
-        const product = await this.productService_.retrieve(productId, this.getProductFindConfig_(config), sharedContext);
+        const relationsSet = new Set(config?.relations ?? []);
+        const shouldLoadVariantImages = relationsSet.has("variants.images");
+        if (shouldLoadVariantImages) {
+            relationsSet.add("variants");
+            relationsSet.add("images");
+        }
+        const product = await this.productService_.retrieve(productId, this.getProductFindConfig_({
+            ...config,
+            relations: Array.from(relationsSet),
+        }), sharedContext);
+        if (shouldLoadVariantImages && product.variants && product.images) {
+            await this.buildVariantImagesFromProduct(product.variants, product.images, sharedContext);
+        }
         return this.baseRepository_.serialize(product);
     }
     // @ts-ignore
     async listProducts(filters, config, sharedContext) {
-        const products = await this.productService_.list(filters, this.getProductFindConfig_(config), sharedContext);
+        const relationsSet = new Set(config?.relations ?? []);
+        const shouldLoadVariantImages = relationsSet.has("variants.images");
+        if (shouldLoadVariantImages) {
+            relationsSet.add("variants");
+            relationsSet.add("images");
+        }
+        const products = await this.productService_.list(filters, this.getProductFindConfig_({
+            ...config,
+            relations: Array.from(relationsSet),
+        }), sharedContext);
+        if (shouldLoadVariantImages) {
+            for (const product of products) {
+                if (product.variants && product.images) {
+                    await this.buildVariantImagesFromProduct(product.variants, product.images, sharedContext);
+                }
+            }
+        }
         return this.baseRepository_.serialize(products);
     }
     // @ts-ignore
     async listAndCountProducts(filters, config, sharedContext) {
-        const [products, count] = await this.productService_.listAndCount(filters, this.getProductFindConfig_(config), sharedContext);
+        const shouldLoadVariantImages = config?.relations?.includes("variants.images");
+        // Ensure we load necessary relations
+        const relations = [...(config?.relations || [])];
+        if (shouldLoadVariantImages) {
+            if (!relations.includes("variants")) {
+                relations.push("variants");
+            }
+            if (!relations.includes("images")) {
+                relations.push("images");
+            }
+        }
+        const [products, count] = await this.productService_.listAndCount(filters, this.getProductFindConfig_({ ...config, relations }), sharedContext);
+        if (shouldLoadVariantImages) {
+            for (const product of products) {
+                if (product.variants && product.images) {
+                    await this.buildVariantImagesFromProduct(product.variants, product.images, sharedContext);
+                }
+            }
+        }
         const serializedProducts = await this.baseRepository_.serialize(products);
         return [serializedProducts, count];
     }
@@ -105,10 +154,6 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         const productVariantsWithOptions = ProductModuleService.assignOptionsToVariants(data, productOptions);
         ProductModuleService.checkIfVariantWithOptionsAlreadyExists(productVariantsWithOptions, variants);
         const createdVariants = await this.productVariantService_.create(productVariantsWithOptions, sharedContext);
-        utils_2.eventBuilders.createdProductVariant({
-            data: createdVariants,
-            sharedContext,
-        });
         return createdVariants;
     }
     async upsertProductVariants(data, sharedContext = {}) {
@@ -118,7 +163,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         let created = [];
         let updated = [];
         if (forCreate.length) {
-            created = await this.createVariants_(forCreate, sharedContext);
+            created = await this.createProductVariants(forCreate, sharedContext);
         }
         if (forUpdate.length) {
             updated = await this.updateVariants_(forUpdate, sharedContext);
@@ -165,21 +210,9 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         if (data.some((d) => !!d.options)) {
             ProductModuleService.checkIfVariantWithOptionsAlreadyExists(productVariantsWithOptions, allVariants);
         }
-        const { entities: productVariants, performedActions } = await this.productVariantService_.upsertWithReplace(productVariantsWithOptions, {
+        const { entities: productVariants } = await this.productVariantService_.upsertWithReplace(productVariantsWithOptions, {
             relations: ["options"],
         }, sharedContext);
-        utils_2.eventBuilders.createdProductVariant({
-            data: performedActions.created[_models_1.ProductVariant.name] ?? [],
-            sharedContext,
-        });
-        utils_2.eventBuilders.updatedProductVariant({
-            data: performedActions.updated[_models_1.ProductVariant.name] ?? [],
-            sharedContext,
-        });
-        utils_2.eventBuilders.deletedProductVariant({
-            data: performedActions.deleted[_models_1.ProductVariant.name] ?? [],
-            sharedContext,
-        });
         return productVariants;
     }
     // @ts-expect-error
@@ -187,13 +220,14 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         const input = Array.isArray(data) ? data : [data];
         const tags = await this.productTagService_.create(input, sharedContext);
         const createdTags = await this.baseRepository_.serialize(tags);
-        utils_2.eventBuilders.createdProductTag({
-            data: createdTags,
-            sharedContext,
-        });
         return Array.isArray(data) ? createdTags : createdTags[0];
     }
     async upsertProductTags(data, sharedContext = {}) {
+        const tags = await this.upsertProductTags_(data, sharedContext);
+        const allTags = await this.baseRepository_.serialize(Array.isArray(data) ? tags : tags[0]);
+        return allTags;
+    }
+    async upsertProductTags_(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((tag) => !!tag.id);
         const forCreate = input.filter((tag) => !tag.id);
@@ -201,21 +235,11 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         let updated = [];
         if (forCreate.length) {
             created = await this.productTagService_.create(forCreate, sharedContext);
-            utils_2.eventBuilders.createdProductTag({
-                data: created,
-                sharedContext,
-            });
         }
         if (forUpdate.length) {
             updated = await this.productTagService_.update(forUpdate, sharedContext);
-            utils_2.eventBuilders.updatedProductTag({
-                data: updated,
-                sharedContext,
-            });
         }
-        const result = [...created, ...updated];
-        const allTags = await this.baseRepository_.serialize(result);
-        return Array.isArray(data) ? allTags : allTags[0];
+        return [...created, ...updated];
     }
     // @ts-expect-error
     async updateProductTags(idOrSelector, data, sharedContext = {}) {
@@ -234,10 +258,6 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         const tags = await this.productTagService_.update(normalizedInput, sharedContext);
         const updatedTags = await this.baseRepository_.serialize(tags);
-        utils_2.eventBuilders.updatedProductTag({
-            data: updatedTags,
-            sharedContext,
-        });
         return (0, utils_1.isString)(idOrSelector) ? updatedTags[0] : updatedTags;
     }
     // @ts-expect-error
@@ -248,6 +268,11 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         return Array.isArray(data) ? createdTypes : createdTypes[0];
     }
     async upsertProductTypes(data, sharedContext = {}) {
+        const types = await this.upsertProductTypes_(data, sharedContext);
+        const result = await this.baseRepository_.serialize(types);
+        return Array.isArray(data) ? result : result[0];
+    }
+    async upsertProductTypes_(data, sharedContext) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((type) => !!type.id);
         const forCreate = input.filter((type) => !type.id);
@@ -259,9 +284,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         if (forUpdate.length) {
             updated = await this.productTypeService_.update(forUpdate, sharedContext);
         }
-        const result = [...created, ...updated];
-        const allTypes = await this.baseRepository_.serialize(result);
-        return Array.isArray(data) ? allTypes : allTypes[0];
+        return [...created, ...updated];
     }
     // @ts-expect-error
     async updateProductTypes(idOrSelector, data, sharedContext = {}) {
@@ -382,10 +405,6 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         const input = Array.isArray(data) ? data : [data];
         const collections = await this.createCollections_(input, sharedContext);
         const createdCollections = await this.baseRepository_.serialize(collections);
-        utils_2.eventBuilders.createdProductCollection({
-            data: collections,
-            sharedContext,
-        });
         return Array.isArray(data) ? createdCollections : createdCollections[0];
     }
     async createCollections_(data, sharedContext = {}) {
@@ -396,6 +415,13 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         return productCollections;
     }
     async upsertProductCollections(data, sharedContext = {}) {
+        const collections = await this.upsertCollections_(data, sharedContext);
+        const serializedCollections = await this.baseRepository_.serialize(collections);
+        return Array.isArray(data)
+            ? serializedCollections
+            : serializedCollections[0];
+    }
+    async upsertCollections_(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((collection) => !!collection.id);
         const forCreate = input.filter((collection) => !collection.id);
@@ -407,21 +433,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         if (forUpdate.length) {
             updated = await this.updateCollections_(forUpdate, sharedContext);
         }
-        const result = [...created, ...updated];
-        const allCollections = await this.baseRepository_.serialize(result);
-        if (created.length) {
-            utils_2.eventBuilders.createdProductCollection({
-                data: created,
-                sharedContext,
-            });
-        }
-        if (updated.length) {
-            utils_2.eventBuilders.updatedProductCollection({
-                data: updated,
-                sharedContext,
-            });
-        }
-        return Array.isArray(data) ? allCollections : allCollections[0];
+        return [...created, ...updated];
     }
     // @ts-expect-error
     async updateProductCollections(idOrSelector, data, sharedContext = {}) {
@@ -439,10 +451,6 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         const collections = await this.updateCollections_(normalizedInput, sharedContext);
         const updatedCollections = await this.baseRepository_.serialize(collections);
-        utils_2.eventBuilders.updatedProductCollection({
-            data: updatedCollections,
-            sharedContext,
-        });
         return (0, utils_1.isString)(idOrSelector) ? updatedCollections[0] : updatedCollections;
     }
     async updateCollections_(data, sharedContext = {}) {
@@ -451,31 +459,29 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         // Another alternative is to not allow passing product_ids to a collection, and instead set the collection_id through the product update call.
         const updatedCollections = await this.productCollectionService_.update(normalizedInput.map((c) => (0, utils_1.removeUndefined)({ ...c, products: undefined })), sharedContext);
         const collections = [];
-        const updateSelectorAndData = updatedCollections.flatMap((collectionData) => {
+        const toUpdate = [];
+        updatedCollections.forEach((collectionData) => {
             const input = normalizedInput.find((c) => c.id === collectionData.id);
             const productsToUpdate = input?.products;
             const dissociateSelector = {
                 collection_id: collectionData.id,
             };
             const associateSelector = {};
-            if (!!productsToUpdate?.length) {
+            if ((0, utils_1.isDefined)(productsToUpdate)) {
                 const productIds = productsToUpdate.map((p) => p.id);
                 dissociateSelector["id"] = { $nin: productIds };
                 associateSelector["id"] = { $in: productIds };
             }
-            else if (!(0, utils_1.isDefined)(productsToUpdate)) {
-                return [];
-            }
-            const result = [
-                {
+            if ((0, utils_1.isPresent)(dissociateSelector["id"])) {
+                toUpdate.push({
                     selector: dissociateSelector,
                     data: {
                         collection_id: null,
                     },
-                },
-            ];
-            if ((0, utils_1.isPresent)(associateSelector)) {
-                result.push({
+                });
+            }
+            if ((0, utils_1.isPresent)(associateSelector["id"])) {
+                toUpdate.push({
                     selector: associateSelector,
                     data: {
                         collection_id: collectionData.id,
@@ -486,10 +492,9 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 ...collectionData,
                 products: productsToUpdate ?? [],
             });
-            return result;
         });
-        if (updateSelectorAndData.length) {
-            await this.productService_.update(updateSelectorAndData, sharedContext);
+        if (toUpdate.length) {
+            await this.productService_.update(toUpdate, sharedContext);
         }
         return collections;
     }
@@ -501,39 +506,65 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         });
         const categories = await this.productCategoryService_.create(input, sharedContext);
         const createdCategories = await this.baseRepository_.serialize(categories);
-        utils_2.eventBuilders.createdProductCategory({
+        // TODO: Same as the update categories, for some reason I cant get the tree repository update
+        events_1.eventBuilders.createdProductCategory({
             data: createdCategories,
             sharedContext,
         });
         return Array.isArray(data) ? createdCategories : createdCategories[0];
     }
     async upsertProductCategories(data, sharedContext = {}) {
+        const categories = await this.upsertProductCategories_(data, sharedContext);
+        const serializedCategories = await this.baseRepository_.serialize(categories);
+        return Array.isArray(data) ? serializedCategories : serializedCategories[0];
+    }
+    async upsertProductCategories_(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((category) => !!category.id);
-        const forCreate = input.filter((category) => !category.id);
+        let forCreate = input.filter((category) => !category.id);
         let created = [];
         let updated = [];
         if (forCreate.length) {
+            forCreate = forCreate.map((productCategory) => {
+                productCategory.handle ??= (0, utils_1.kebabCase)(productCategory.name);
+                return productCategory;
+            });
             created = await this.productCategoryService_.create(forCreate, sharedContext);
         }
         if (forUpdate.length) {
             updated = await this.productCategoryService_.update(forUpdate, sharedContext);
         }
-        const createdCategories = await this.baseRepository_.serialize(created);
-        const updatedCategories = await this.baseRepository_.serialize(updated);
-        utils_2.eventBuilders.createdProductCategory({
-            data: createdCategories,
-            sharedContext,
-        });
-        utils_2.eventBuilders.updatedProductCategory({
-            data: updatedCategories,
-            sharedContext,
-        });
-        const result = [...createdCategories, ...updatedCategories];
-        return Array.isArray(data) ? result : result[0];
+        // TODO: Same as the update categories, for some reason I cant get the tree repository update
+        // event. I ll need to investigate this
+        if (created.length) {
+            events_1.eventBuilders.createdProductCategory({
+                data: created,
+                sharedContext,
+            });
+        }
+        if (updated.length) {
+            events_1.eventBuilders.updatedProductCategory({
+                data: updated,
+                sharedContext,
+            });
+        }
+        return [...created, ...updated];
     }
     // @ts-expect-error
     async updateProductCategories(idOrSelector, data, sharedContext = {}) {
+        const categories = await this.updateProductCategories_(idOrSelector, data, sharedContext);
+        const serializedCategories = await this.baseRepository_.serialize(categories);
+        // TODO: for some reason I cant get the tree repository update
+        // event. I ll need to investigate this
+        events_1.eventBuilders.updatedProductCategory({
+            data: serializedCategories,
+            sharedContext,
+        });
+        return (0, utils_1.isString)(idOrSelector)
+            ? serializedCategories[0]
+            : serializedCategories;
+    }
+    async updateProductCategories_(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             // Check if the type exists in the first place
@@ -548,22 +579,13 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             }));
         }
         const categories = await this.productCategoryService_.update(normalizedInput, sharedContext);
-        const updatedCategories = await this.baseRepository_.serialize(categories);
-        utils_2.eventBuilders.updatedProductCategory({
-            data: updatedCategories,
-            sharedContext,
-        });
-        return (0, utils_1.isString)(idOrSelector) ? updatedCategories[0] : updatedCategories;
+        return categories;
     }
     // @ts-expect-error
     async createProducts(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const products = await this.createProducts_(input, sharedContext);
         const createdProducts = await this.baseRepository_.serialize(products);
-        utils_2.eventBuilders.createdProduct({
-            data: createdProducts,
-            sharedContext,
-        });
         return Array.isArray(data) ? createdProducts : createdProducts[0];
     }
     async upsertProducts(data, sharedContext = {}) {
@@ -573,25 +595,13 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         let created = [];
         let updated = [];
         if (forCreate.length) {
-            created = await this.createProducts_(forCreate, sharedContext);
+            created = await this.createProducts(forCreate, sharedContext);
         }
         if (forUpdate.length) {
             updated = await this.updateProducts_(forUpdate, sharedContext);
         }
         const result = [...created, ...updated];
         const allProducts = await this.baseRepository_.serialize(result);
-        if (created.length) {
-            utils_2.eventBuilders.createdProduct({
-                data: created,
-                sharedContext,
-            });
-        }
-        if (updated.length) {
-            utils_2.eventBuilders.updatedProduct({
-                data: updated,
-                sharedContext,
-            });
-        }
         return Array.isArray(data) ? allProducts : allProducts[0];
     }
     // @ts-expect-error
@@ -611,10 +621,6 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         const products = await this.updateProducts_(normalizedInput, sharedContext);
         const updatedProducts = await this.baseRepository_.serialize(products);
-        utils_2.eventBuilders.updatedProduct({
-            data: updatedProducts,
-            sharedContext,
-        });
         return (0, utils_1.isString)(idOrSelector) ? updatedProducts[0] : updatedProducts;
     }
     async createProducts_(data, sharedContext = {}) {
@@ -670,79 +676,34 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         return createdProducts;
     }
     async updateProducts_(data, sharedContext = {}) {
-        const normalizedProducts = await this.normalizeUpdateProductInput(data, sharedContext);
+        // We have to do that manually because this method is bypassing the product service and goes
+        // directly to the custom product repository
+        const manager = (sharedContext.transactionManager ??
+            sharedContext.manager);
+        const subscriber = (0, utils_1.createMedusaMikroOrmEventSubscriber)(["updateProducts_"], this);
+        if (manager && subscriber) {
+            manager
+                .getEventManager()
+                .registerSubscriber(new subscriber(sharedContext));
+        }
+        const originalProducts = await this.productService_.list({
+            id: data.map((d) => d.id),
+        }, {
+            relations: ["options", "options.values", "variants", "images", "tags"],
+        }, sharedContext);
+        const normalizedProducts = await this.normalizeUpdateProductInput(data, originalProducts);
         for (const product of normalizedProducts) {
             this.validateProductUpdatePayload(product);
         }
-        const { entities: productData } = await this.productService_.upsertWithReplace(normalizedProducts, {
-            relations: ["tags", "categories"],
-        }, sharedContext);
-        // There is more than 1-level depth of relations here, so we need to handle the options and variants manually
-        await (0, utils_1.promiseAll)(
-        // Note: It's safe to rely on the order here as `upsertWithReplace` preserves the order of the input
-        normalizedProducts.map(async (product, i) => {
-            const upsertedProduct = productData[i];
-            let allOptions = [];
-            if (product.options?.length) {
-                const { entities: productOptions } = await this.productOptionService_.upsertWithReplace(product.options?.map((option) => ({
-                    ...option,
-                    product_id: upsertedProduct.id,
-                })) ?? [], { relations: ["values"] }, sharedContext);
-                upsertedProduct.options = productOptions;
-                // Since we handle the options and variants outside of the product upsert, we need to clean up manually
-                await this.productOptionService_.delete({
-                    product_id: upsertedProduct.id,
-                    id: {
-                        $nin: upsertedProduct.options.map(({ id }) => id),
-                    },
-                }, sharedContext);
-                allOptions = upsertedProduct.options;
-            }
-            else {
-                // If the options weren't affected, but the user is changing the variants, make sure we have all options available locally
-                if (product.variants?.length) {
-                    allOptions = await this.productOptionService_.list({ product_id: upsertedProduct.id }, { relations: ["values"] }, sharedContext);
-                }
-            }
-            if (product.variants?.length) {
-                const productVariantsWithOptions = ProductModuleService.assignOptionsToVariants(product.variants.map((v) => ({
-                    ...v,
-                    product_id: upsertedProduct.id,
-                })) ?? [], allOptions);
-                ProductModuleService.checkIfVariantsHaveUniqueOptionsCombinations(productVariantsWithOptions);
-                const { entities: productVariants } = await this.productVariantService_.upsertWithReplace(productVariantsWithOptions, { relations: ["options"] }, sharedContext);
-                upsertedProduct.variants = productVariants;
-                await this.productVariantService_.delete({
-                    product_id: upsertedProduct.id,
-                    id: {
-                        $nin: upsertedProduct.variants.map(({ id }) => id),
-                    },
-                }, sharedContext);
-            }
-            if (Array.isArray(product.images)) {
-                if (product.images.length) {
-                    const { entities: productImages } = await this.productImageService_.upsertWithReplace(product.images.map((image, rank) => ({
-                        ...image,
-                        product_id: upsertedProduct.id,
-                        rank,
-                    })), {}, sharedContext);
-                    upsertedProduct.images = productImages;
-                    await this.productImageService_.delete({
-                        product_id: upsertedProduct.id,
-                        id: {
-                            $nin: productImages.map(({ id }) => id),
-                        },
-                    }, sharedContext);
-                }
-                else {
-                    await this.productImageService_.delete({ product_id: upsertedProduct.id }, sharedContext);
-                }
-            }
-        }));
-        return productData;
+        const updatedProducts = await this.productRepository_.deepUpdate(normalizedProducts, ProductModuleService.validateVariantOptions, sharedContext);
+        return updatedProducts;
     }
     // @ts-expect-error
     async updateProductOptionValues(idOrSelector, data, sharedContext = {}) {
+        // TODO: There is a missmatch in the API which lead to function with different number of
+        // arguments. Therefore, applying the MedusaContext() decorator to the function will not work
+        // because the context arg index will differ from method to method.
+        sharedContext.messageAggregator ??= new utils_1.MessageAggregator();
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             // This will throw if the product option value does not exist
@@ -756,16 +717,29 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 ...data,
             }));
         }
-        const productOptionValues = await super.updateProductOptionValues(normalizedInput, sharedContext);
+        const productOptionValues = await this.updateProductOptionValues_(normalizedInput, sharedContext);
         const updatedProductOptionValues = await this.baseRepository_.serialize(productOptionValues);
-        utils_2.eventBuilders.updatedProductOptionValue({
-            data: updatedProductOptionValues,
-            sharedContext: sharedContext,
-        });
+        // TODO: Because of the wrong method override, we have to compensate to prevent breaking
+        // changes right now
+        const groupedEvents = sharedContext.messageAggregator.getMessages();
+        if (Object.values(groupedEvents).flat().length > 0 &&
+            this.eventBusModuleService_) {
+            const promises = [];
+            for (const group of Object.keys(groupedEvents)) {
+                promises.push(this.eventBusModuleService_.emit(groupedEvents[group], {
+                    internal: true,
+                }));
+            }
+            await Promise.all(promises);
+            sharedContext.messageAggregator.clearMessages();
+        }
         return (0, utils_1.isString)(idOrSelector)
             ? updatedProductOptionValues[0]
             : updatedProductOptionValues;
     }
+    async updateProductOptionValues_(normalizedInput, sharedContext = {}) {
+        return await this.productOptionValueService_.update(normalizedInput, sharedContext);
+    }
     /**
      * Validates the manually provided handle value of the product
      * to be URL-safe
@@ -800,7 +774,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     }
     async normalizeCreateProductInput(products, sharedContext = {}) {
         const products_ = Array.isArray(products) ? products : [products];
-        const normalizedProducts = (await this.normalizeUpdateProductInput(products_, sharedContext));
+        const normalizedProducts = (await this.normalizeUpdateProductInput(products_));
         for (const productData of normalizedProducts) {
             if (!productData.handle && productData.title) {
                 productData.handle = (0, utils_1.toHandle)(productData.title);
@@ -811,6 +785,20 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             if (!productData.thumbnail && productData.images?.length) {
                 productData.thumbnail = productData.images[0].url;
             }
+            // TODO: these props are typed as number, the model expect a string, the API expect number etc
+            // There is some inconsistency here, we should fix it
+            if ("weight" in productData) {
+                productData.weight = productData.weight?.toString();
+            }
+            if ("length" in productData) {
+                productData.length = productData.length?.toString();
+            }
+            if ("height" in productData) {
+                productData.height = productData.height?.toString();
+            }
+            if ("width" in productData) {
+                productData.width = productData.width?.toString();
+            }
             if (productData.images?.length) {
                 productData.images = productData.images.map((image, index) => image.rank != null
                     ? image
@@ -822,12 +810,23 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         return (Array.isArray(products) ? normalizedProducts : normalizedProducts[0]);
     }
-    async normalizeUpdateProductInput(products, sharedContext = {}) {
+    /**
+     * Normalizes the input for the update product input
+     * @param products - The products to normalize
+     * @param originalProducts - The original products to use for the normalization (must include options and option values relations)
+     * @returns The normalized products
+     */
+    async normalizeUpdateProductInput(products, originalProducts) {
         const products_ = Array.isArray(products) ? products : [products];
         const productsIds = products_.map((p) => p.id).filter(Boolean);
         let dbOptions = [];
         if (productsIds.length) {
-            dbOptions = await this.productOptionService_.list({ product_id: productsIds }, { relations: ["values"] }, sharedContext);
+            // Re map options to handle non serialized data as well
+            dbOptions =
+                originalProducts
+                    ?.map((originalProduct) => originalProduct.options.map((option) => option))
+                    .flat()
+                    .filter(Boolean) ?? [];
         }
         const normalizedProducts = [];
         for (const product of products_) {
@@ -838,7 +837,8 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             if (productData.options?.length) {
                 ;
                 productData.options = productData.options?.map((option) => {
-                    const dbOption = dbOptions.find((o) => o.title === option.title && o.product_id === productData.id);
+                    const dbOption = dbOptions.find((o) => (o.title === option.title || o.id === option.id) &&
+                        o.product_id === productData.id);
                     return {
                         title: option.title,
                         values: option.values?.map((value) => {
@@ -886,6 +886,14 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         return collectionData;
     }
+    static validateVariantOptions(variants, options) {
+        const variantsWithOptions = ProductModuleService.assignOptionsToVariants(variants.map((v) => ({
+            ...v,
+            // adding product_id to the variant to make it valid for the assignOptionsToVariants function
+            ...(options.length ? { product_id: options[0].product_id } : {}),
+        })), options);
+        ProductModuleService.checkIfVariantsHaveUniqueOptionsCombinations(variantsWithOptions);
+    }
     static assignOptionsToVariants(variants, options) {
         if (!variants.length) {
             return variants;
@@ -895,7 +903,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             const productsOptions = options.filter((o) => o.product_id === variant.product_id);
             if (numOfProvidedVariantOptionValues &&
                 productsOptions.length !== numOfProvidedVariantOptionValues) {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Product has ${productsOptions.length} but there were ${numOfProvidedVariantOptionValues} provided option values for the variant: ${variant.title}.`);
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Product has ${productsOptions.length} option values but there were ${numOfProvidedVariantOptionValues} provided option values for the variant: ${variant.title}.`);
             }
             const variantOptions = Object.entries(variant.options || {}).map(([key, val]) => {
                 const option = productsOptions.find((o) => o.title === key);
@@ -961,6 +969,169 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             }
         }
     }
+    // @ts-ignore
+    async listProductVariants(filters, config, sharedContext = {}) {
+        const shouldLoadImages = config?.relations?.includes("images");
+        const relations = [...(config?.relations || [])];
+        if (shouldLoadImages) {
+            relations.push("product.images");
+        }
+        const variants = await this.productVariantService_.list(filters, {
+            ...config,
+            relations,
+        }, sharedContext);
+        if (shouldLoadImages) {
+            // Get variant images for all variants
+            const variantImagesMap = await this.getVariantImages(variants, sharedContext);
+            for (const variant of variants) {
+                variant.images = variantImagesMap.get(variant.id) || [];
+            }
+        }
+        return this.baseRepository_.serialize(variants);
+    }
+    // @ts-ignore
+    async listAndCountProductVariants(filters, config, sharedContext = {}) {
+        const shouldLoadImages = config?.relations?.includes("images");
+        const relations = [...(config?.relations || [])];
+        if (shouldLoadImages) {
+            relations.push("product.images");
+        }
+        const [variants, count] = await this.productVariantService_.listAndCount(filters, {
+            ...config,
+            relations,
+        }, sharedContext);
+        if (shouldLoadImages) {
+            // Get variant images for all variants
+            const variantImagesMap = await this.getVariantImages(variants, sharedContext);
+            for (const variant of variants) {
+                variant.images = variantImagesMap.get(variant.id) || [];
+            }
+        }
+        const serializedVariants = await this.baseRepository_.serialize(variants);
+        return [serializedVariants, count];
+    }
+    // @ts-ignore
+    async retrieveProductVariant(id, config, sharedContext = {}) {
+        const shouldLoadImages = config?.relations?.includes("images");
+        const relations = [...(config?.relations || [])];
+        if (shouldLoadImages) {
+            relations.push("images", "product", "product.images");
+        }
+        const variant = await this.productVariantService_.retrieve(id, {
+            ...config,
+            relations,
+        }, sharedContext);
+        if (shouldLoadImages) {
+            const variantImages = await this.getVariantImages([variant], sharedContext);
+            variant.images = variantImages.get(id) || [];
+        }
+        return this.baseRepository_.serialize(variant);
+    }
+    async addImageToVariant(data, sharedContext = {}) {
+        const productVariantProductImage = await this.addImageToVariant_(data, sharedContext);
+        return productVariantProductImage;
+    }
+    async addImageToVariant_(data, sharedContext = {}) {
+        // TODO: consider validation that image and variant are on the same product
+        const productVariantProductImage = await this.productVariantProductImageService_.create(data, sharedContext);
+        return productVariantProductImage.map((vi) => ({ id: vi.id }));
+    }
+    async removeImageFromVariant(data, sharedContext = {}) {
+        await this.removeImageFromVariant_(data, sharedContext);
+    }
+    async removeImageFromVariant_(data, sharedContext = {}) {
+        const pairs = Array.isArray(data) ? data : [data];
+        const productVariantProductImages = await this.productVariantProductImageService_.list({
+            $or: pairs,
+        });
+        await this.productVariantProductImageService_.delete(productVariantProductImages.map((p) => p.id), sharedContext);
+    }
+    async getVariantImages(variants, context = {}) {
+        if (variants.length === 0) {
+            return new Map();
+        }
+        // Create lookup maps for efficient processing
+        const uniqueProductIds = new Set();
+        // Build lookup maps
+        for (const variant of variants) {
+            if (variant.product_id) {
+                uniqueProductIds.add(variant.product_id);
+            }
+        }
+        const allProductImages = (await this.listProductImages({ product_id: Array.from(uniqueProductIds) }, {
+            relations: ["variants"],
+        }, context));
+        // all product images
+        const imagesByProductId = new Map();
+        // variant specific images
+        const variantSpecificImageIds = new Map();
+        // Single pass to build both lookup maps
+        for (const img of allProductImages) {
+            // Group by product_id
+            if (!imagesByProductId.has(img.product_id)) {
+                imagesByProductId.set(img.product_id, []);
+            }
+            imagesByProductId.get(img.product_id).push(img);
+            // Track variant-specific images
+            if (img.variants.length > 0) {
+                for (const variant of img.variants) {
+                    if (!variantSpecificImageIds.has(variant.id)) {
+                        variantSpecificImageIds.set(variant.id, new Set());
+                    }
+                    variantSpecificImageIds.get(variant.id).add(img.id || "");
+                }
+            }
+        }
+        const result = new Map();
+        for (const variant of variants) {
+            const productId = variant.product_id;
+            const productImages = imagesByProductId.get(productId) || [];
+            const specificImageIds = variantSpecificImageIds.get(variant.id) || new Set();
+            const variantImages = productImages.filter((img) => {
+                // general product image
+                if (!img.variants.length) {
+                    return true;
+                }
+                // Check if this image is specifically associated with this variant
+                return specificImageIds.has(img.id || "");
+            });
+            result.set(variant.id, variantImages);
+        }
+        return result;
+    }
+    async buildVariantImagesFromProduct(variants, productImages, sharedContext = {}) {
+        // Create a clean map of images without problematic collections
+        const imagesMap = new Map();
+        for (const img of productImages) {
+            imagesMap.set(img.id, img);
+        }
+        const variantIds = variants.map((v) => v.id);
+        const variantImageRelations = await this.productVariantProductImageService_.list({ variant_id: variantIds }, { select: ["variant_id", "image_id"] }, sharedContext);
+        const variantIdImageIdsMap = new Map();
+        const imageIdVariantIdsMap = new Map();
+        // build both lookup
+        for (const relation of variantImageRelations) {
+            if (!variantIdImageIdsMap.has(relation.variant_id)) {
+                variantIdImageIdsMap.set(relation.variant_id, []);
+            }
+            variantIdImageIdsMap.get(relation.variant_id).push(relation.image_id);
+            if (!imageIdVariantIdsMap.has(relation.image_id)) {
+                imageIdVariantIdsMap.set(relation.image_id, []);
+            }
+            imageIdVariantIdsMap.get(relation.image_id).push(relation.variant_id);
+        }
+        const [generalImages, variantImages] = (0, utils_1.partitionArray)(productImages, (img) => !imageIdVariantIdsMap.has(img.id) // if image doesn't have any variants, it is a general image
+        );
+        for (const variant of variants) {
+            const variantImageIds = variantIdImageIdsMap.get(variant.id) || [];
+            variant.images = [...generalImages];
+            for (const image of variantImages) {
+                if (variantImageIds.includes(image.id)) {
+                    variant.images.push(image);
+                }
+            }
+        }
+    }
 }
 exports.default = ProductModuleService;
 __decorate([
@@ -1041,13 +1212,20 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "createProductTags", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "upsertProductTags", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "upsertProductTags_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)()
@@ -1059,7 +1237,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateProductTags", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -1068,14 +1247,22 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "createProductTypes", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "upsertProductTypes", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "upsertProductTypes_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1084,7 +1271,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateProductTypes", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -1101,13 +1289,15 @@ __decorate([
 ], ProductModuleService.prototype, "createOptions_", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "upsertProductOptions", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1140,13 +1330,20 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "createCollections_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "upsertProductCollections", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "upsertCollections_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)()
@@ -1175,13 +1372,20 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "createProductCategories", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "upsertProductCategories", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "upsertProductCategories_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)()
@@ -1192,6 +1396,13 @@ __decorate([
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateProductCategories", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "updateProductCategories_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)()
@@ -1234,6 +1445,13 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateProducts_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "updateProductOptionValues_", null);
 __decorate([
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
@@ -1241,9 +1459,64 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "normalizeCreateProductInput", null);
 __decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "listProductVariants", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "listAndCountProductVariants", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-ignore
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "retrieveProductVariant", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "addImageToVariant", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "addImageToVariant_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [typeof (_b = typeof T !== "undefined" && T) === "function" ? _b : Object, Object]),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "removeImageFromVariant", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "removeImageFromVariant_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "normalizeUpdateProductInput", null);
+], ProductModuleService.prototype, "getVariantImages", null);
 //# sourceMappingURL=product-module-service.js.map