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

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 joiner_config_1 = require("./../joiner-config");
 const events_1 = require("../utils/events");
+const joiner_config_1 = require("./../joiner-config");
 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, productProductOptionService, productProductOptionValueService, 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,8 +44,6 @@ 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;
@@ -57,16 +55,10 @@ 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),
@@ -74,9 +66,6 @@ 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
@@ -87,11 +76,6 @@ 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),
@@ -103,15 +87,11 @@ 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) {
@@ -122,14 +102,6 @@ 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) {
@@ -138,9 +110,6 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
                 }
             }
         }
-        if (shouldFilterOptionValues) {
-            this.filterOptionValuesByProducts(products);
-        }
         const serializedProducts = await this.baseRepository_.serialize(products);
         return [serializedProducts, count];
     }
@@ -173,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))],
@@ -237,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);
@@ -348,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];
@@ -413,255 +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 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];
@@ -886,41 +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 })),
-                        value_ids: option.value_ids,
-                    };
-                }
-                return option;
-            });
-            return { ...product, options: hydratedOptions };
-        });
-        const normalizedProducts = (await this.normalizeCreateProductInput(hydratedData, sharedContext));
+        const normalizedProducts = await this.normalizeCreateProductInput(data, sharedContext);
         for (const product of normalizedProducts) {
             this.validateProductCreatePayload(product);
         }
@@ -934,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;
@@ -942,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");
@@ -973,79 +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 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;
+        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
@@ -1058,73 +686,23 @@ 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", "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));
+        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);
         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 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();
@@ -1199,22 +777,7 @@ class ProductModuleService extends (0, utils_1.MedusaService)({
     async normalizeCreateProductInput(products, sharedContext = {}) {
         const products_ = Array.isArray(products) ? products : [products];
         const normalizedProducts = (await this.normalizeUpdateProductInput(products_));
-        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 } : {}),
-                    };
-                });
-            }
+        for (const productData of normalizedProducts) {
             if (!productData.handle && productData.title) {
                 productData.handle = (0, utils_1.toHandle)(productData.title);
             }
@@ -1257,12 +820,39 @@ 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) => ({
@@ -1301,10 +891,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);
     }
@@ -1314,13 +901,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}.`);
@@ -1519,134 +1100,6 @@ 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();
@@ -1860,36 +1313,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)()
@@ -2107,11 +1530,4 @@ __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