@medusajs/product 3.0.0-snapshot-20251202221811 → 3.0.0-snapshot-20251208164410

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

@@ -16,8 +16,8 @@ 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 events_1 = require("../utils/events");
 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,
@@ -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, productProductOptionValueService, productOptionValueService, productVariantProductImageService, [utils_1.Modules.EVENT_BUS]: eventBusModuleService, }, moduleDeclaration) {
         // @ts-ignore
         // eslint-disable-next-line prefer-rest-params
         super(...arguments);
@@ -44,6 +44,8 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         this.productImageService_ = productImageService;
         this.productTypeService_ = productTypeService;
         this.productOptionService_ = productOptionService;
+        this.productProductOptionService_ = productProductOptionService;
+        this.productProductOptionValueService_ = productProductOptionValueService;
         this.productOptionValueService_ = productOptionValueService;
         this.productVariantProductImageService_ = productVariantProductImageService;
         this.eventBusModuleService_ = eventBusModuleService;
@@ -55,10 +57,16 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     async retrieveProduct(productId, config, sharedContext) {
         const relationsSet = new Set(config?.relations ?? []);
         const shouldLoadVariantImages = relationsSet.has("variants.images");
+        const shouldFilterOptionValues = relationsSet.has("options.values");
         if (shouldLoadVariantImages) {
             relationsSet.add("variants");
             relationsSet.add("images");
         }
+        if (shouldFilterOptionValues) {
+            relationsSet.add("options");
+            relationsSet.add("product_options");
+            relationsSet.add("product_options.values");
+        }
         const product = await this.productService_.retrieve(productId, this.getProductFindConfig_({
             ...config,
             relations: Array.from(relationsSet),
@@ -66,6 +74,9 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         if (shouldLoadVariantImages && product.variants && product.images) {
             await this.buildVariantImagesFromProduct(product.variants, product.images, sharedContext);
         }
+        if (shouldFilterOptionValues) {
+            this.filterOptionValuesByProduct(product);
+        }
         return this.baseRepository_.serialize(product);
     }
     // @ts-ignore
@@ -76,6 +87,11 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
             relationsSet.add("variants");
             relationsSet.add("images");
         }
+        const shouldFilterOptionValues = relationsSet.has("options.values");
+        if (shouldFilterOptionValues) {
+            relationsSet.add("product_options");
+            relationsSet.add("product_options.values");
+        }
         const products = await this.productService_.list(filters, this.getProductFindConfig_({
             ...config,
             relations: Array.from(relationsSet),
@@ -87,11 +103,15 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 }
             }
         }
+        if (shouldFilterOptionValues) {
+            this.filterOptionValuesByProducts(products);
+        }
         return this.baseRepository_.serialize(products);
     }
     // @ts-ignore
     async listAndCountProducts(filters, config, sharedContext) {
         const shouldLoadVariantImages = config?.relations?.includes("variants.images");
+        const shouldFilterOptionValues = config?.relations?.includes("options.values");
         // Ensure we load necessary relations
         const relations = [...(config?.relations || [])];
         if (shouldLoadVariantImages) {
@@ -102,6 +122,14 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 relations.push("images");
             }
         }
+        if (shouldFilterOptionValues) {
+            if (!relations.includes("product_options")) {
+                relations.push("product_options");
+            }
+            if (!relations.includes("product_options.values")) {
+                relations.push("product_options.values");
+            }
+        }
         const [products, count] = await this.productService_.listAndCount(filters, this.getProductFindConfig_({ ...config, relations }), sharedContext);
         if (shouldLoadVariantImages) {
             for (const product of products) {
@@ -110,6 +138,9 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 }
             }
         }
+        if (shouldFilterOptionValues) {
+            this.filterOptionValuesByProducts(products);
+        }
         const serializedProducts = await this.baseRepository_.serialize(products);
         return [serializedProducts, count];
     }
@@ -142,9 +173,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 +237,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 +348,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 +413,255 @@ 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 pairs = Array.isArray(data) ? data : [data];
+        const existingProductOptions = await this.productProductOptionService_.list({
+            $or: pairs.map((pair) => ({
+                product_id: pair.product_id,
+                product_option_id: pair.product_option_id,
+            })),
+        }, { relations: ["values"] }, sharedContext);
+        // Validate value removals when product_option_value_ids are provided - this sets new values for the product <> options meaning some values may be removed thus we need removal here as well
+        const validationPairs = [];
+        for (const pair of pairs) {
+            if (pair.product_option_value_ids) {
+                const existingProductOption = existingProductOptions.find((epo) => epo.product_id === pair.product_id &&
+                    epo.product_option_id === pair.product_option_id);
+                if (existingProductOption) {
+                    const currentValues = Array.isArray(existingProductOption.values)
+                        ? existingProductOption.values
+                        : existingProductOption.values?.toArray?.() ?? [];
+                    const currentValueIds = new Set(currentValues.map((v) => v.id));
+                    const newValueIds = new Set(pair.product_option_value_ids);
+                    // Find values being removed
+                    const removedValueIds = Array.from(currentValueIds).filter((id) => !newValueIds.has(id));
+                    if (removedValueIds.length > 0) {
+                        validationPairs.push({
+                            productId: pair.product_id,
+                            optionId: pair.product_option_id,
+                            valueIdsToCheck: removedValueIds,
+                        });
+                    }
+                }
+            }
+        }
+        if (validationPairs.length > 0) {
+            await this.validateOptionRemoval_(validationPairs, sharedContext);
+        }
+        // Separate pairs: those that need PPO creation vs those that just need value updates
+        const pairsNeedingPPOCreation = [];
+        for (const pair of pairs) {
+            const hasExistingPPO = existingProductOptions.some((epo) => epo.product_id === pair.product_id &&
+                epo.product_option_id === pair.product_option_id);
+            // Only create PPO if it doesn't exist
+            if (!hasExistingPPO) {
+                pairsNeedingPPOCreation.push(pair);
+            }
+        }
+        let createdPPOs = [];
+        if (pairsNeedingPPOCreation.length > 0) {
+            const productProductOptions = await this.productProductOptionService_.create(pairsNeedingPPOCreation, sharedContext);
+            createdPPOs = (Array.isArray(productProductOptions)
+                ? productProductOptions
+                : [productProductOptions]);
+        }
+        // Map all PPOs (existing and newly created) to their pairs
+        const ppoMap = new Map();
+        // First, add existing PPOs (these take precedence for value updates)
+        for (const existingPPO of existingProductOptions) {
+            const key = `${existingPPO.product_id}_${existingPPO.product_option_id}`;
+            ppoMap.set(key, existingPPO);
+        }
+        // Then add newly created PPOs (only if they don't already exist in the map)
+        for (const ppo of createdPPOs) {
+            const key = `${ppo.product_id}_${ppo.product_option_id}`;
+            if (!ppoMap.has(key)) {
+                ppoMap.set(key, ppo);
+            }
+        }
+        const uniqueOptionIds = [...new Set(pairs.map((p) => p.product_option_id))];
+        const options = await this.productOptionService_.list({ id: uniqueOptionIds }, { relations: ["values"] }, sharedContext);
+        const optionValuesMap = new Map(options.map((opt) => [opt.id, opt.values || []]));
+        const valuePairsToCreate = [];
+        for (const pair of pairs) {
+            const key = `${pair.product_id}_${pair.product_option_id}`;
+            const ppo = ppoMap.get(key);
+            if (!ppo)
+                continue;
+            const originalPair = pair;
+            if (originalPair) {
+                const allValues = optionValuesMap.get(originalPair.product_option_id) || [];
+                // If specific value IDs were provided, use only those; otherwise use all values
+                const valuesToLink = originalPair.product_option_value_ids
+                    ? allValues.filter((v) => originalPair.product_option_value_ids.includes(v.id))
+                    : allValues;
+                // If updating with specific value_ids, remove old values that aren't in the new list
+                if (originalPair.product_option_value_ids) {
+                    const existingProductOption = existingProductOptions.find((epo) => epo.product_id === originalPair.product_id &&
+                        epo.product_option_id === originalPair.product_option_id);
+                    if (existingProductOption) {
+                        const currentValues = Array.isArray(existingProductOption.values)
+                            ? existingProductOption.values
+                            : existingProductOption.values?.toArray?.() ?? [];
+                        const currentValueIds = new Set(currentValues.map((v) => v.id));
+                        const newValueIds = new Set(originalPair.product_option_value_ids);
+                        // Find values to remove
+                        const valuesToRemove = Array.from(currentValueIds).filter((id) => !newValueIds.has(id));
+                        // Delete removed value links
+                        if (valuesToRemove.length > 0) {
+                            await this.productProductOptionValueService_.delete({
+                                product_product_option_id: existingProductOption.id,
+                                product_option_value_id: valuesToRemove,
+                            }, sharedContext);
+                            // Flush to ensure deletion is persisted
+                            await sharedContext.transactionManager?.flush?.();
+                        }
+                        // refetch PPOs after deletion
+                        const [reloadedPPO] = await this.productProductOptionService_.list({
+                            id: existingProductOption.id,
+                        }, { relations: ["values"] }, sharedContext);
+                        const reloadedValues = reloadedPPO
+                            ? Array.isArray(reloadedPPO.values)
+                                ? reloadedPPO.values
+                                : reloadedPPO.values?.toArray?.() ?? []
+                            : [];
+                        const reloadedValueIds = new Set(reloadedValues.map((v) => v.id));
+                        // Only create links for values that don't already exist (check against reloaded values)
+                        const existingValueIdsSet = reloadedValueIds;
+                        for (const value of valuesToLink) {
+                            if (!existingValueIdsSet.has(value.id)) {
+                                valuePairsToCreate.push({
+                                    product_product_option_id: existingProductOption.id,
+                                    product_option_value_id: value.id,
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        // No existing link, create all value links
+                        for (const value of valuesToLink) {
+                            valuePairsToCreate.push({
+                                product_product_option_id: ppo.id,
+                                product_option_value_id: value.id,
+                            });
+                        }
+                    }
+                }
+                else {
+                    // No specific value_ids, create all value links (only if PPO is newly created)
+                    if (!existingProductOptions.find((epo) => epo.product_id === pair.product_id &&
+                        epo.product_option_id === pair.product_option_id)) {
+                        for (const value of valuesToLink) {
+                            valuePairsToCreate.push({
+                                product_product_option_id: ppo.id,
+                                product_option_value_id: value.id,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        if (valuePairsToCreate.length > 0) {
+            await this.productProductOptionValueService_.create(valuePairsToCreate, sharedContext);
+        }
+        // Get all PPOs (existing + created) for return value
+        const allPPOsForReturn = [];
+        for (const pair of pairs) {
+            const key = `${pair.product_id}_${pair.product_option_id}`;
+            const ppo = ppoMap.get(key);
+            if (ppo) {
+                allPPOsForReturn.push(ppo);
+            }
+        }
+        if (Array.isArray(data)) {
+            return allPPOsForReturn.map((ppo) => ({ id: ppo.id }));
+        }
+        return { id: allPPOsForReturn[0]?.id || createdPPOs[0]?.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,
+        }, { relations: [] }, sharedContext);
+        // Validate that no variants are using the options before removal
+        const validationPairs = productOptionsProducts
+            .map((productOptionProduct) => {
+            const productId = productOptionProduct.product_id;
+            const optionId = productOptionProduct.product_option_id;
+            if (productId && optionId) {
+                return {
+                    productId,
+                    optionId,
+                    // Check all values of the option
+                };
+            }
+            return null;
+        })
+            .filter((p) => p !== null);
+        if (validationPairs.length > 0) {
+            await this.validateOptionRemoval_(validationPairs, sharedContext);
+        }
+        const productOptionsProductIds = productOptionsProducts.map(({ id }) => id);
+        await this.productProductOptionValueService_.delete(productOptionsProductIds.map((id) => ({ product_product_option_id: id })), sharedContext);
+        await this.productProductOptionService_.delete(productOptionsProductIds, sharedContext);
+    }
     // @ts-expect-error
     async createProductCollections(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
@@ -624,7 +886,41 @@ 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 })),
+                        value_ids: option.value_ids,
+                    };
+                }
+                return option;
+            });
+            return { ...product, options: hydratedOptions };
+        });
+        const normalizedProducts = (await this.normalizeCreateProductInput(hydratedData, sharedContext));
         for (const product of normalizedProducts) {
             this.validateProductCreatePayload(product);
         }
@@ -638,6 +934,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 +942,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 +973,79 @@ 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 existingOptions = [];
+            if (hydratedProduct?.options?.length) {
+                for (const option of hydratedProduct.options) {
+                    if ("id" in option) {
+                        existingOptions.push({
+                            id: option.id,
+                            value_ids: option.value_ids,
+                        });
+                    }
+                }
+            }
+            const newOptionIds = productToOptionIdsMap.get(product.id) ?? [];
+            const newOptions = newOptionIds.map((id) => ({ id }));
+            const allOptions = [...existingOptions, ...newOptions];
+            for (const option of allOptions) {
+                const pair = {
+                    product_id: product.id,
+                    product_option_id: option.id,
+                    product_option_value_ids: option.value_ids
+                        ? option.value_ids
+                        : undefined,
+                };
+                linkPairs.push(pair);
+            }
+        }
+        if (linkPairs.length > 0) {
+            await this.addProductOptionToProduct_(linkPairs, sharedContext);
+        }
+        await sharedContext.transactionManager.flush();
+        const productIds = createdProducts.map((p) => p.id);
+        const productsWithOptions = await this.productService_.list({ id: productIds }, {
+            relations: [
+                "options",
+                "options.values",
+                "options.products",
+                "product_options",
+                "product_options.values",
+                "variants",
+                "images",
+                "tags",
+            ],
+        }, sharedContext);
+        // Filter option values to only include those associated with each product
+        this.filterOptionValuesByProducts(productsWithOptions);
+        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,23 +1058,73 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 .getEventManager()
                 .registerSubscriber(new subscriber(sharedContext));
         }
-        const productIds = data.map((d) => d.id).filter(Boolean);
-        const originalProducts = await this.productService_.list({
-            id: productIds,
-        }, {
-            relations: ["options", "options.values", "tags"],
-            take: productIds.length,
-        }, 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", "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 = (await this.normalizeUpdateProductInput(data));
         for (const product of normalizedProducts) {
             this.validateProductUpdatePayload(product);
         }
         const updatedProducts = await this.productRepository_.deepUpdate(normalizedProducts, ProductModuleService.validateVariantOptions, sharedContext);
+        // Filter option values to only include those associated with each product
+        this.filterOptionValuesByProducts(updatedProducts);
         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
+        // 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();
@@ -777,7 +1199,22 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     async normalizeCreateProductInput(products, sharedContext = {}) {
         const products_ = Array.isArray(products) ? products : [products];
         const normalizedProducts = (await this.normalizeUpdateProductInput(products_));
-        for (const productData of normalizedProducts) {
+        for await (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,
+                            };
+                        }),
+                        is_exclusive: option.is_exclusive ?? true, // Always default to true for options created from product creation
+                        ...(option.id ? { id: option.id } : {}),
+                    };
+                });
+            }
             if (!productData.handle && productData.title) {
                 productData.handle = (0, utils_1.toHandle)(productData.title);
             }
@@ -820,39 +1257,12 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
      */
     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
-                    ?.flatMap((originalProduct) => originalProduct.options.map((option) => option))
-                    .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) => ({
@@ -891,7 +1301,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);
     }
@@ -901,7 +1314,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}.`);
@@ -1100,6 +1519,134 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
         }
         return result;
     }
+    /**
+     * Validates that no variants are using the specified option or option values
+     * before they are removed from a product.
+     *
+     * @param pairs - Array of validation pairs: { productId, optionId, valueIdsToCheck? }
+     * @param sharedContext - The shared context
+     * @throws MedusaError if any variants are using the option/values
+     */
+    async validateOptionRemoval_(pairs, sharedContext = {}) {
+        if (pairs.length === 0) {
+            return;
+        }
+        // Filter pairs that need validation (for option removal, check if option is linked)
+        const pairsToValidate = [];
+        // For option removals (no valueIdsToCheck), check if options are linked to products
+        const optionRemovalPairs = pairs.filter((p) => !p.valueIdsToCheck);
+        if (optionRemovalPairs.length > 0) {
+            const existingProductOptions = await this.productProductOptionService_.list({
+                $or: optionRemovalPairs.map((p) => ({
+                    product_id: p.productId,
+                    product_option_id: p.optionId,
+                })),
+            }, {}, sharedContext);
+            const existingPairsSet = new Set(existingProductOptions.map((epo) => `${epo.product_id}_${epo.product_option_id}`));
+            // Only validate pairs that are actually linked
+            for (const pair of optionRemovalPairs) {
+                const key = `${pair.productId}_${pair.optionId}`;
+                if (existingPairsSet.has(key)) {
+                    pairsToValidate.push(pair);
+                }
+            }
+        }
+        // For value removals (with valueIdsToCheck), always validate
+        const valueRemovalPairs = pairs.filter((p) => p.valueIdsToCheck);
+        pairsToValidate.push(...valueRemovalPairs);
+        if (pairsToValidate.length === 0) {
+            return; // Nothing to validate
+        }
+        // Get all unique option IDs to fetch options with their values
+        const uniqueOptionIds = [...new Set(pairsToValidate.map((p) => p.optionId))];
+        const options = await this.productOptionService_.list({ id: uniqueOptionIds }, { relations: ["values"] }, sharedContext);
+        const optionsMap = new Map(options.map((opt) => [opt.id, opt]));
+        const bulkValidationPairs = [];
+        for (const pair of pairsToValidate) {
+            const option = optionsMap.get(pair.optionId);
+            if (!option) {
+                continue; // Option doesn't exist, skip
+            }
+            // if no subset is provided we check the whole option values
+            const valueIdsToValidate = pair.valueIdsToCheck
+                ? pair.valueIdsToCheck
+                : (option.values || []).map((v) => v.id);
+            if (valueIdsToValidate.length === 0) {
+                continue; // No values to check
+            }
+            bulkValidationPairs.push({
+                productId: pair.productId,
+                optionValueIds: valueIdsToValidate,
+                pair,
+                option,
+            });
+        }
+        if (bulkValidationPairs.length > 0) {
+            const conflictingVariantsMap = await this.productRepository_.checkVariantsUsingOptionValues(bulkValidationPairs.map((p) => ({
+                productId: p.productId,
+                optionValueIds: p.optionValueIds,
+            })), sharedContext);
+            for (const bulkPair of bulkValidationPairs) {
+                const allConflictingVariants = [];
+                for (const valueId of bulkPair.optionValueIds) {
+                    const key = `${bulkPair.productId}_${valueId}`;
+                    const variants = conflictingVariantsMap.get(key) || [];
+                    // Deduplicate variants by variant_id
+                    for (const variant of variants) {
+                        if (!allConflictingVariants.some((v) => v.variant_id === variant.variant_id)) {
+                            allConflictingVariants.push({
+                                variant_id: variant.variant_id,
+                                title: variant.title,
+                            });
+                        }
+                    }
+                }
+                if (allConflictingVariants.length > 0) {
+                    const variantNames = allConflictingVariants.map((v) => v.title || v.variant_id);
+                    if (bulkPair.pair.valueIdsToCheck) {
+                        // Specific values being removed
+                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot unassign option values from product because the following variant(s) are using it: ${variantNames.join(", ")}`);
+                    }
+                    else {
+                        // Entire option being removed
+                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot unassign product option from product which has variants for that option`);
+                    }
+                }
+            }
+        }
+    }
+    filterOptionValuesByProducts(products) {
+        for (const product of products) {
+            this.filterOptionValuesByProduct(product);
+        }
+    }
+    filterOptionValuesByProduct(product) {
+        if (!product.options || !product.product_options) {
+            return;
+        }
+        const productOptions = Array.isArray(product.product_options)
+            ? product.product_options
+            : product.product_options?.toArray?.() ?? [];
+        // Build a Set of value IDs that are actually associated with this product
+        const allowedValueIds = new Set();
+        for (const productOption of productOptions) {
+            const values = Array.isArray(productOption.values)
+                ? productOption.values
+                : productOption.values?.toArray?.() ?? [];
+            for (const value of values) {
+                allowedValueIds.add(value.id);
+            }
+        }
+        // Filter the values in each option to only include allowed ones
+        if (product.options) {
+            for (const option of product.options) {
+                if (option.values) {
+                    option.values = option.values.filter((value) => allowedValueIds.has(value.id));
+                }
+            }
+        }
+        delete product.product_options;
+    }
     async buildVariantImagesFromProduct(variants, productImages, sharedContext = {}) {
         // Create a clean map of images without problematic collections
         const imagesMap = new Map();
@@ -1313,6 +1860,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)()
@@ -1530,4 +2107,11 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "getVariantImages", 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, "validateOptionRemoval_", null);
 //# sourceMappingURL=product-module-service.js.map