@medusajs/product 2.10.2-snapshot-20250903082430 → 2.10.2-snapshot-20250903100537

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,
@@ -107,10 +107,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 = {}) {
@@ -120,7 +116,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);
@@ -167,21 +163,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
@@ -189,13 +173,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);
@@ -203,21 +188,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 = {}) {
@@ -236,10 +211,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
@@ -250,6 +221,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);
@@ -261,9 +237,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 = {}) {
@@ -384,10 +358,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 = {}) {
@@ -398,6 +368,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);
@@ -409,21 +386,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 = {}) {
@@ -441,10 +404,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 = {}) {
@@ -500,39 +459,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
@@ -547,22 +532,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 = {}) {
@@ -572,25 +548,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
@@ -610,10 +574,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 = {}) {
@@ -669,14 +629,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);
         }
-        return this.productRepository_.deepUpdate(normalizedProducts, ProductModuleService.validateVariantOptions, sharedContext);
+        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
@@ -690,16 +670,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
@@ -734,7 +727,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);
@@ -756,12 +749,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_) {
@@ -772,7 +776,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) => {
@@ -983,13 +988,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)()
@@ -1001,7 +1013,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)()),
@@ -1010,14 +1023,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)()),
@@ -1026,7 +1047,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)()),
@@ -1043,13 +1065,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)()),
@@ -1082,13 +1106,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)()
@@ -1117,13 +1148,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)()
@@ -1134,6 +1172,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)()
@@ -1177,15 +1222,16 @@ __decorate([
     __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", [typeof (_a = typeof T !== "undefined" && T) === "function" ? _a : Object, Object]),
+    __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "normalizeCreateProductInput", null);
+], ProductModuleService.prototype, "updateProductOptionValues_", null);
 __decorate([
     __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", [typeof (_a = typeof T !== "undefined" && T) === "function" ? _a : Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "normalizeUpdateProductInput", null);
+], ProductModuleService.prototype, "normalizeCreateProductInput", null);
 //# sourceMappingURL=product-module-service.js.map