@medusajs/product 3.0.0-snapshot-20251104011621 → 3.0.0-snapshot-20251106143524

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;
+var _a, _b;
 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, productOptionValueService, productVariantProductImageService, [utils_1.Modules.EVENT_BUS]: eventBusModuleService, }, moduleDeclaration) {
+    constructor({ baseRepository, productRepository, productService, productVariantService, productTagService, productCategoryService, productCollectionService, productImageService, productTypeService, productOptionService, productProductOptionService, productOptionValueService, productVariantProductImageService, [utils_1.Modules.EVENT_BUS]: eventBusModuleService, }, moduleDeclaration) {
         // @ts-ignore
         // eslint-disable-next-line prefer-rest-params
         super(...arguments);
@@ -44,6 +44,7 @@ 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;
@@ -142,9 +143,11 @@ 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({
-            product_id: [...new Set(data.map((v) => v.product_id))],
+            products: {
+                id: [...new Set(data.map((v) => v.product_id))],
+            },
         }, {
-            relations: ["values"],
+            relations: ["values", "products"],
         }, sharedContext);
         const variants = await this.productVariantService_.list({
             product_id: [...new Set(data.map((v) => v.product_id))],
@@ -204,8 +207,10 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             product_id: v.product_id,
         }));
         const productOptions = await this.productOptionService_.list({
-            product_id: Array.from(new Set(variantsWithProductId.map((v) => v.product_id))),
-        }, { relations: ["values"] }, sharedContext);
+            products: {
+                id: Array.from(new Set(variantsWithProductId.map((v) => v.product_id))),
+            },
+        }, { relations: ["values", "products"] }, sharedContext);
         const productVariantsWithOptions = ProductModuleService.assignOptionsToVariants(variantsWithProductId, productOptions);
         if (data.some((d) => !!d.options)) {
             ProductModuleService.checkIfVariantWithOptionsAlreadyExists(productVariantsWithOptions, allVariants);
@@ -313,18 +318,25 @@ 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) => {
-                    return typeof v === "string" ? { value: v } : 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 await this.productOptionService_.create(normalizedInput, sharedContext);
+        return this.productOptionService_.create(normalizedInput, sharedContext);
     }
     async upsertProductOptions(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
@@ -371,35 +383,77 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         // Data normalization
         const normalizedInput = data.map((opt) => {
-            const dbValues = dbOptions.find(({ id }) => id === opt.id)?.values || [];
-            const normalizedValues = opt.values?.map((v) => {
-                return typeof v === "string" ? { value: v } : v;
-            });
-            return {
-                ...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 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;
+            return {
+                ...cleanOpt,
+                ...(normalizedValues ? { values: normalizedValues } : {}),
             };
         });
         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];
@@ -624,7 +678,40 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         return (0, utils_1.isString)(idOrSelector) ? updatedProducts[0] : updatedProducts;
     }
     async createProducts_(data, sharedContext = {}) {
-        const normalizedProducts = await this.normalizeCreateProductInput(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);
         for (const product of normalizedProducts) {
             this.validateProductCreatePayload(product);
         }
@@ -638,6 +725,7 @@ 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;
@@ -645,6 +733,12 @@ 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");
@@ -670,10 +764,66 @@ 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 createdProducts = await this.productService_.create(productsToCreate, sharedContext);
-        return createdProducts;
+        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;
     }
     async updateProducts_(data, sharedContext = {}) {
         // We have to do that manually because this method is bypassing the product service and goes
@@ -686,12 +836,69 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 .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);
+        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);
         for (const product of normalizedProducts) {
             this.validateProductUpdatePayload(product);
         }
@@ -700,7 +907,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     }
     // @ts-expect-error
     async updateProductOptionValues(idOrSelector, data, sharedContext = {}) {
-        // TODO: There is a missmatch in the API which lead to function with different number of
+        // TODO: There is a mismatch 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();
@@ -772,10 +979,24 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     validateProductUpdatePayload(productData) {
         this.validateProductPayload(productData);
     }
-    async normalizeCreateProductInput(products, sharedContext = {}) {
+    normalizeCreateProductInput(products, sharedContext = {}) {
         const products_ = Array.isArray(products) ? products : [products];
-        const normalizedProducts = (await this.normalizeUpdateProductInput(products_));
+        const normalizedProducts = 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);
             }
@@ -816,46 +1037,18 @@ 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
      */
-    async normalizeUpdateProductInput(products, originalProducts) {
+    normalizeUpdateProductInput(products) {
         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((cid) => ({
-                    id: cid,
+                productData.tags = productData.tag_ids.map((tid) => ({
+                    id: tid,
                 }));
                 delete productData.tag_ids;
             }
@@ -890,7 +1083,10 @@ 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
-            ...(options.length ? { product_id: options[0].product_id } : {}),
+            // 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);
         ProductModuleService.checkIfVariantsHaveUniqueOptionsCombinations(variantsWithOptions);
     }
@@ -900,7 +1096,13 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         const variantsWithOptions = variants.map((variant) => {
             const numOfProvidedVariantOptionValues = Object.keys(variant.options || {}).length;
-            const productsOptions = options.filter((o) => o.product_id === variant.product_id);
+            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);
+            });
             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}.`);
@@ -1312,6 +1514,36 @@ __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)()
@@ -1456,7 +1688,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", Promise)
+    __metadata("design:returntype", typeof (_b = typeof TOutput !== "undefined" && TOutput) === "function" ? _b : Object)
 ], ProductModuleService.prototype, "normalizeCreateProductInput", null);
 __decorate([
     (0, utils_1.InjectManager)()