@medusajs/product 3.0.0-snapshot-20251106181920 → 3.0.0-snapshot-20251126221441

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

@@ -11,7 +11,7 @@ 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");
@@ -29,7 +29,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     ProductVariant: _models_1.ProductVariant,
     ProductImage: _models_1.ProductImage,
 }) {
-    constructor({ baseRepository, productRepository, productService, productVariantService, productTagService, productCategoryService, productCollectionService, productImageService, productTypeService, productOptionService, productProductOptionService, productOptionValueService, productVariantProductImageService, [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);
@@ -44,7 +44,6 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         this.productImageService_ = productImageService;
         this.productTypeService_ = productTypeService;
         this.productOptionService_ = productOptionService;
-        this.productProductOptionService_ = productProductOptionService;
         this.productOptionValueService_ = productOptionValueService;
         this.productVariantProductImageService_ = productVariantProductImageService;
         this.eventBusModuleService_ = eventBusModuleService;
@@ -143,11 +142,9 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Unable to create variants without specifying a product_id");
         }
         const productOptions = await this.productOptionService_.list({
-            products: {
-                id: [...new Set(data.map((v) => v.product_id))],
-            },
+            product_id: [...new Set(data.map((v) => v.product_id))],
         }, {
-            relations: ["values", "products"],
+            relations: ["values"],
         }, sharedContext);
         const variants = await this.productVariantService_.list({
             product_id: [...new Set(data.map((v) => v.product_id))],
@@ -207,10 +204,8 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             product_id: v.product_id,
         }));
         const productOptions = await this.productOptionService_.list({
-            products: {
-                id: Array.from(new Set(variantsWithProductId.map((v) => v.product_id))),
-            },
-        }, { relations: ["values", "products"] }, sharedContext);
+            product_id: Array.from(new Set(variantsWithProductId.map((v) => v.product_id))),
+        }, { relations: ["values"] }, sharedContext);
         const productVariantsWithOptions = ProductModuleService.assignOptionsToVariants(variantsWithProductId, productOptions);
         if (data.some((d) => !!d.options)) {
             ProductModuleService.checkIfVariantWithOptionsAlreadyExists(productVariantsWithOptions, allVariants);
@@ -318,25 +313,18 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         return Array.isArray(data) ? createdOptions : createdOptions[0];
     }
     async createOptions_(data, sharedContext = {}) {
+        if (data.some((v) => !v.product_id)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Tried to create options without specifying a product_id");
+        }
         const normalizedInput = data.map((opt) => {
-            Object.keys(opt.ranks ?? []).forEach((value) => {
-                if (!opt.values.includes(value)) {
-                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Value "${value}" is assigned a rank but is not defined in the list of values.`);
-                }
-            });
             return {
                 ...opt,
                 values: opt.values?.map((v) => {
-                    // Normalize each value into an object and attach rank if available
-                    const valueObj = (0, utils_1.isString)(v) ? { value: v } : v;
-                    const rank = opt.ranks && (0, utils_1.isString)(v)
-                        ? opt.ranks[v]
-                        : opt.ranks?.[valueObj.value];
-                    return rank !== undefined ? { ...valueObj, rank } : valueObj;
+                    return typeof v === "string" ? { value: v } : v;
                 }),
             };
         });
-        return this.productOptionService_.create(normalizedInput, sharedContext);
+        return await this.productOptionService_.create(normalizedInput, sharedContext);
     }
     async upsertProductOptions(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
@@ -383,77 +371,35 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         // Data normalization
         const normalizedInput = data.map((opt) => {
-            const dbOption = dbOptions.find(({ id }) => id === opt.id);
-            const dbValues = dbOption?.values || [];
-            if (opt.ranks) {
-                const validValues = opt.values ?? dbValues.map((v) => v.value);
-                Object.keys(opt.ranks).forEach((value) => {
-                    if (!validValues.includes(value)) {
-                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Value "${value}" is assigned a rank but is not defined in the list of values.`);
-                    }
-                });
-            }
-            let normalizedValues;
-            if (opt.values) {
-                // If new values are provided → normalize and apply ranks
-                normalizedValues = opt.values.map((v) => {
-                    const valueObj = (0, utils_1.isString)(v) ? { value: v } : v;
-                    const rank = opt.ranks && (0, utils_1.isString)(v)
-                        ? opt.ranks[v]
-                        : opt.ranks?.[valueObj.value];
-                    const rankedValue = rank !== undefined ? { ...valueObj, rank } : valueObj;
-                    if ("id" in rankedValue) {
-                        return rankedValue;
-                    }
-                    const dbVal = dbValues.find((dbVal) => dbVal.value === rankedValue.value);
-                    if (!dbVal) {
-                        return rankedValue;
-                    }
-                    return {
-                        id: dbVal.id,
-                        ...rankedValue,
-                    };
-                });
-            }
-            else if (opt.ranks) {
-                // If only ranks were provided → update existing DB values with ranks
-                normalizedValues = dbValues.map((dbVal) => {
-                    const rank = opt.ranks[dbVal.value];
-                    return rank !== undefined
-                        ? { id: dbVal.id, value: dbVal.value, rank }
-                        : { id: dbVal.id, value: dbVal.value };
-                });
-            }
-            const { ranks, ...cleanOpt } = opt;
+            const dbValues = dbOptions.find(({ id }) => id === opt.id)?.values || [];
+            const normalizedValues = opt.values?.map((v) => {
+                return typeof v === "string" ? { value: v } : v;
+            });
             return {
-                ...cleanOpt,
-                ...(normalizedValues ? { values: normalizedValues } : {}),
+                ...opt,
+                ...(normalizedValues
+                    ? {
+                        // Oftentimes the options are only passed by value without an id, even if they exist in the DB
+                        values: normalizedValues.map((normVal) => {
+                            if ("id" in normVal) {
+                                return normVal;
+                            }
+                            const dbVal = dbValues.find((dbVal) => dbVal.value === normVal.value);
+                            if (!dbVal) {
+                                return normVal;
+                            }
+                            return {
+                                id: dbVal.id,
+                                value: normVal.value,
+                            };
+                        }),
+                    }
+                    : {}),
             };
         });
         const { entities: productOptions } = await this.productOptionService_.upsertWithReplace(normalizedInput, { relations: ["values"] }, sharedContext);
         return productOptions;
     }
-    async addProductOptionToProduct(data, sharedContext = {}) {
-        const productOptionProducts = await this.addProductOptionToProduct_(data, sharedContext);
-        return productOptionProducts;
-    }
-    async addProductOptionToProduct_(data, sharedContext = {}) {
-        const productOptionProducts = await this.productProductOptionService_.create(data, sharedContext);
-        if (Array.isArray(data)) {
-            return productOptionProducts.map((ppo) => ({ id: ppo.id }));
-        }
-        return { id: productOptionProducts.id };
-    }
-    async removeProductOptionFromProduct(data, sharedContext = {}) {
-        await this.removeProductOptionFromProduct_(data, sharedContext);
-    }
-    async removeProductOptionFromProduct_(data, sharedContext = {}) {
-        const pairs = Array.isArray(data) ? data : [data];
-        const productOptionsProducts = await this.productProductOptionService_.list({
-            $or: pairs,
-        });
-        await this.productProductOptionService_.delete(productOptionsProducts.map(({ id }) => id), sharedContext);
-    }
     // @ts-expect-error
     async createProductCollections(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
@@ -678,40 +624,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         return (0, utils_1.isString)(idOrSelector) ? updatedProducts[0] : updatedProducts;
     }
     async createProducts_(data, sharedContext = {}) {
-        const existingOptionIds = data
-            .flatMap((p) => p.options ?? [])
-            .filter((o) => "id" in o)
-            .map((o) => o.id);
-        let existingOptions = [];
-        if (existingOptionIds.length > 0) {
-            existingOptions = await this.productOptionService_.list({ id: existingOptionIds }, { relations: ["values"] }, sharedContext);
-            const fetchedIds = new Set(existingOptions.map((opt) => opt.id));
-            const missingIds = existingOptionIds.filter((id) => !fetchedIds.has(id));
-            if (missingIds.length) {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Some product options were not found: [${missingIds.join(", ")}]`);
-            }
-        }
-        const existingOptionsMap = new Map(existingOptions.map((opt) => [opt.id, opt]));
-        const hydratedData = data.map((product) => {
-            if (!product.options?.length)
-                return product;
-            const hydratedOptions = product.options.map((option) => {
-                if ("id" in option) {
-                    const dbOption = existingOptionsMap.get(option.id);
-                    if (!dbOption) {
-                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Product option with id ${option.id} not found.`);
-                    }
-                    return {
-                        id: dbOption.id,
-                        title: dbOption.title,
-                        values: dbOption.values?.map((v) => ({ value: v.value })),
-                    };
-                }
-                return option;
-            });
-            return { ...product, options: hydratedOptions };
-        });
-        const normalizedProducts = this.normalizeCreateProductInput(hydratedData, sharedContext);
+        const normalizedProducts = await this.normalizeCreateProductInput(data, sharedContext);
         for (const product of normalizedProducts) {
             this.validateProductCreatePayload(product);
         }
@@ -725,7 +638,6 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             }, {}, sharedContext);
         }
         const existingTagsMap = new Map(existingTags.map((tag) => [tag.id, tag]));
-        const productOptionsToCreate = new Map();
         const productsToCreate = normalizedProducts.map((product) => {
             const productId = (0, utils_1.generateEntityId)(product.id, "prod");
             product.id = productId;
@@ -733,12 +645,6 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 ;
                 product.categories = product.categories.map((category) => category.id);
             }
-            if (product.options?.length) {
-                const newOptions = product.options.filter((o) => !("id" in o));
-                if (newOptions.length) {
-                    productOptionsToCreate.set(productId, newOptions);
-                }
-            }
             if (product.variants?.length) {
                 const normalizedVariants = product.variants.map((variant) => {
                     const variantId = (0, utils_1.generateEntityId)(variant.id, "variant");
@@ -764,66 +670,10 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                     throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Tag with id ${tag.id} not found. Please create the tag before associating it with the product.`);
                 });
             }
-            delete product.options;
             return product;
         });
-        const productToOptionIdsMap = new Map();
-        const allOptionsWithIds = [];
-        for (const [productId, options] of productOptionsToCreate.entries()) {
-            const optionIds = [];
-            for (const option of options) {
-                const optionId = (0, utils_1.generateEntityId)(undefined, "opt");
-                optionIds.push(optionId);
-                allOptionsWithIds.push({
-                    ...option,
-                    id: optionId,
-                });
-            }
-            productToOptionIdsMap.set(productId, optionIds);
-        }
-        const [createdProducts] = await Promise.all([
-            this.productService_.create(productsToCreate, sharedContext),
-            allOptionsWithIds.length > 0
-                ? this.createOptions_(allOptionsWithIds, sharedContext)
-                : Promise.resolve([]),
-        ]);
-        const linkPairs = [];
-        for (const product of createdProducts) {
-            const hydratedProduct = hydratedData.find((p) => p.title === product.title);
-            const allOptionIds = [];
-            if (hydratedProduct?.options?.length) {
-                for (const option of hydratedProduct.options) {
-                    if ("id" in option) {
-                        allOptionIds.push(option.id);
-                    }
-                }
-            }
-            const newOptionIds = productToOptionIdsMap.get(product.id) ?? [];
-            const optionIds = [...new Set([...allOptionIds, ...newOptionIds])];
-            for (const optionId of optionIds) {
-                linkPairs.push({
-                    product_id: product.id,
-                    product_option_id: optionId,
-                });
-            }
-        }
-        if (linkPairs.length > 0) {
-            await this.addProductOptionToProduct_(linkPairs, sharedContext);
-        }
-        const productIds = createdProducts.map((p) => p.id);
-        const productsWithOptions = await this.productService_.list({ id: productIds }, {
-            relations: [
-                "options",
-                "options.values",
-                "options.products",
-                "variants",
-                "images",
-                "tags",
-            ],
-        }, sharedContext);
-        const productIdOrder = new Map(productIds.map((id, index) => [id, index]));
-        const orderedProductsWithOptions = [...productsWithOptions].sort((a, b) => (productIdOrder.get(a.id) ?? 0) - (productIdOrder.get(b.id) ?? 0));
-        return orderedProductsWithOptions;
+        const createdProducts = await this.productService_.create(productsToCreate, sharedContext);
+        return createdProducts;
     }
     async updateProducts_(data, sharedContext = {}) {
         // We have to do that manually because this method is bypassing the product service and goes
@@ -836,69 +686,12 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 .getEventManager()
                 .registerSubscriber(new subscriber(sharedContext));
         }
-        const allOptionIds = data
-            .flatMap((p) => p.option_ids ?? [])
-            .filter((id) => !!id);
-        const [originalProducts, existingOptions] = await Promise.all([
-            this.productService_.list({ id: data.map((d) => d.id) }, {
-                relations: [
-                    "options",
-                    "options.values",
-                    "options.products",
-                    "variants",
-                    "images",
-                    "tags",
-                ],
-            }, sharedContext),
-            allOptionIds.length
-                ? this.productOptionService_.list({ id: allOptionIds }, {
-                    relations: ["values", "products"],
-                }, sharedContext)
-                : Promise.resolve([]),
-        ]);
-        if (allOptionIds.length && existingOptions.length !== allOptionIds.length) {
-            const found = new Set(existingOptions.map((opt) => opt.id));
-            const missing = allOptionIds.filter((id) => !found.has(id));
-            if (missing.length) {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Some product options were not found: [${missing.join(", ")}]`);
-            }
-        }
-        const linkPairs = [];
-        const unlinkPairs = [];
-        for (const product of data) {
-            if (!product.option_ids) {
-                continue;
-            }
-            const newOptionIds = new Set(product.option_ids);
-            const existingOptionIds = new Set(originalProducts
-                .find((p) => p.id === product.id)
-                ?.options?.map((o) => o.id) ?? []);
-            for (const optionId of newOptionIds) {
-                if (!existingOptionIds.has(optionId)) {
-                    linkPairs.push({
-                        product_id: product.id,
-                        product_option_id: optionId,
-                    });
-                }
-            }
-            for (const optionId of existingOptionIds) {
-                if (!newOptionIds.has(optionId)) {
-                    unlinkPairs.push({
-                        product_id: product.id,
-                        product_option_id: optionId,
-                    });
-                }
-            }
-            delete product.option_ids;
-        }
-        await Promise.all([
-            linkPairs.length &&
-                this.addProductOptionToProduct_(linkPairs, sharedContext),
-            unlinkPairs.length &&
-                this.removeProductOptionFromProduct_(unlinkPairs, sharedContext),
-        ]);
-        await sharedContext.transactionManager.flush();
-        const normalizedProducts = this.normalizeUpdateProductInput(data);
+        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);
         }
@@ -907,7 +700,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     }
     // @ts-expect-error
     async updateProductOptionValues(idOrSelector, data, sharedContext = {}) {
-        // TODO: There is a mismatch in the API which lead to function with different number of
+        // 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();
@@ -979,24 +772,10 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     validateProductUpdatePayload(productData) {
         this.validateProductPayload(productData);
     }
-    normalizeCreateProductInput(products, sharedContext = {}) {
+    async normalizeCreateProductInput(products, sharedContext = {}) {
         const products_ = Array.isArray(products) ? products : [products];
-        const normalizedProducts = this.normalizeUpdateProductInput(products_);
+        const normalizedProducts = (await this.normalizeUpdateProductInput(products_));
         for (const productData of normalizedProducts) {
-            if (productData.options?.length) {
-                ;
-                productData.options = productData.options?.map((option) => {
-                    return {
-                        title: option.title,
-                        values: option.values?.map((value) => {
-                            return {
-                                value: value,
-                            };
-                        }),
-                        ...(option.id ? { id: option.id } : {}),
-                    };
-                });
-            }
             if (!productData.handle && productData.title) {
                 productData.handle = (0, utils_1.toHandle)(productData.title);
             }
@@ -1037,18 +816,46 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
      * @param originalProducts - The original products to use for the normalization (must include options and option values relations)
      * @returns The normalized products
      */
-    normalizeUpdateProductInput(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) {
+            // 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_) {
             const productData = { ...product };
             if (productData.is_giftcard) {
                 productData.discountable = false;
             }
+            if (productData.options?.length) {
+                ;
+                productData.options = productData.options?.map((option) => {
+                    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) => {
+                            const dbValue = dbOption?.values?.find((val) => val.value === value);
+                            return {
+                                value: value,
+                                ...(dbValue ? { id: dbValue.id } : {}),
+                            };
+                        }),
+                        ...(dbOption ? { id: dbOption.id } : {}),
+                    };
+                });
+            }
             if (productData.tag_ids) {
                 ;
-                productData.tags = productData.tag_ids.map((tid) => ({
-                    id: tid,
+                productData.tags = productData.tag_ids.map((cid) => ({
+                    id: cid,
                 }));
                 delete productData.tag_ids;
             }
@@ -1083,10 +890,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         const variantsWithOptions = ProductModuleService.assignOptionsToVariants(variants.map((v) => ({
             ...v,
             // adding product_id to the variant to make it valid for the assignOptionsToVariants function
-            // get product_id from the first product in the products array of the first option
-            ...(options.length && options[0].products?.length
-                ? { product_id: options[0].products[0].id }
-                : {}),
+            ...(options.length ? { product_id: options[0].product_id } : {}),
         })), options);
         ProductModuleService.checkIfVariantsHaveUniqueOptionsCombinations(variantsWithOptions);
     }
@@ -1096,13 +900,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         const variantsWithOptions = variants.map((variant) => {
             const numOfProvidedVariantOptionValues = Object.keys(variant.options || {}).length;
-            const productsOptions = options.filter((o) => {
-                // products could be a Collection object or array, normalize to array
-                const productsArray = Array.isArray(o.products)
-                    ? o.products
-                    : o.products?.toArray?.() ?? [];
-                return productsArray.some((p) => p.id === variant.product_id);
-            });
+            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} option values but there were ${numOfProvidedVariantOptionValues} provided option values for the variant: ${variant.title}.`);
@@ -1514,36 +1312,6 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateOptions_", null);
-__decorate([
-    (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, "addProductOptionToProduct", 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, "addProductOptionToProduct_", null);
-__decorate([
-    (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, "removeProductOptionFromProduct", 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, "removeProductOptionFromProduct_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)()
@@ -1677,6 +1445,16 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "updateProducts_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
+    // @ts-expect-error
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "updateProductOptionValues", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
@@ -1688,7 +1466,7 @@ __decorate([
     __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:returntype", typeof (_b = typeof TOutput !== "undefined" && TOutput) === "function" ? _b : Object)
+    __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "normalizeCreateProductInput", null);
 __decorate([
     (0, utils_1.InjectManager)()