@medusajs/product 0.4.0-snapshot-20240429113131 → 1.0.0-rc-20241001083650

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

@@ -12,21 +12,23 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("@medusajs/types");
+const types_1 = require("@medusajs/framework/types");
 const _models_1 = require("../models");
-const utils_1 = require("@medusajs/utils");
+const utils_1 = require("@medusajs/framework/utils");
 const types_2 = require("../types");
+const utils_2 = require("../utils");
 const joiner_config_1 = require("./../joiner-config");
-const generateMethodForModels = [
-    { model: _models_1.ProductCategory, singular: "Category", plural: "Categories" },
-    { model: _models_1.ProductCollection, singular: "Collection", plural: "Collections" },
-    { model: _models_1.ProductOption, singular: "Option", plural: "Options" },
-    { model: _models_1.ProductTag, singular: "Tag", plural: "Tags" },
-    { model: _models_1.ProductType, singular: "Type", plural: "Types" },
-    { model: _models_1.ProductVariant, singular: "Variant", plural: "Variants" },
-];
-class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.Product, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
-    constructor({ baseRepository, productService, productVariantService, productTagService, productCategoryService, productCollectionService, productImageService, productTypeService, productOptionService, productOptionValueService, eventBusModuleService, }, moduleDeclaration) {
+class ProductModuleService extends (0, utils_1.MedusaService)({
+    Product: _models_1.Product,
+    ProductCategory: _models_1.ProductCategory,
+    ProductCollection: _models_1.ProductCollection,
+    ProductOption: _models_1.ProductOption,
+    ProductOptionValue: _models_1.ProductOptionValue,
+    ProductTag: _models_1.ProductTag,
+    ProductType: _models_1.ProductType,
+    ProductVariant: _models_1.ProductVariant,
+}) {
+    constructor({ baseRepository, productService, productVariantService, productTagService, productCategoryService, productCollectionService, productImageService, productTypeService, productOptionService, productOptionValueService, [utils_1.Modules.EVENT_BUS]: eventBusModuleService, }, moduleDeclaration) {
         // @ts-ignore
         // eslint-disable-next-line prefer-rest-params
         super(...arguments);
@@ -46,7 +48,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
     }
-    async createVariants(data, sharedContext = {}) {
+    async createProductVariants(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const variants = await this.createVariants_(input, sharedContext);
         const createdVariants = await this.baseRepository_.serialize(variants);
@@ -54,18 +56,22 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     }
     async createVariants_(data, sharedContext = {}) {
         if (data.some((v) => !v.product_id)) {
-            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Tried to create variants without specifying a product_id");
+            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))],
         }, {
-            take: null,
             relations: ["values"],
         }, sharedContext);
         const productVariantsWithOptions = ProductModuleService.assignOptionsToVariants(data, productOptions);
-        return await this.productVariantService_.create(productVariantsWithOptions, sharedContext);
+        const createdVariants = await this.productVariantService_.create(productVariantsWithOptions, sharedContext);
+        utils_2.eventBuilders.createdProductVariant({
+            data: createdVariants,
+            sharedContext,
+        });
+        return createdVariants;
     }
-    async upsertVariants(data, sharedContext = {}) {
+    async upsertProductVariants(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((variant) => !!variant.id);
         const forCreate = input.filter((variant) => !variant.id);
@@ -81,7 +87,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         const allVariants = await this.baseRepository_.serialize(result);
         return Array.isArray(data) ? allVariants : allVariants[0];
     }
-    async updateVariants(idOrSelector, data, sharedContext = {}) {
+    async updateProductVariants(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             normalizedInput = [{ id: idOrSelector, ...data }];
@@ -100,7 +106,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async updateVariants_(data, sharedContext = {}) {
         // Validation step
         const variantIdsToUpdate = data.map(({ id }) => id);
-        const variants = await this.productVariantService_.list({ id: variantIdsToUpdate }, { take: null }, sharedContext);
+        const variants = await this.productVariantService_.list({ id: variantIdsToUpdate }, {}, sharedContext);
         if (variants.length !== data.length) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot update non-existing variants with ids: ${(0, utils_1.arrayDifference)(variantIdsToUpdate, variants.map(({ id }) => id)).join(", ")}`);
         }
@@ -112,26 +118,87 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         }));
         const productOptions = await this.productOptionService_.list({
             product_id: Array.from(new Set(variantsWithProductId.map((v) => v.product_id))),
-        }, { take: null, relations: ["values"] }, sharedContext);
-        return this.productVariantService_.upsertWithReplace(ProductModuleService.assignOptionsToVariants(variantsWithProductId, productOptions), {
+        }, { relations: ["values"] }, sharedContext);
+        const { entities: productVariants, performedActions } = await this.productVariantService_.upsertWithReplace(ProductModuleService.assignOptionsToVariants(variantsWithProductId, productOptions), {
             relations: ["options"],
         }, sharedContext);
+        utils_2.eventBuilders.createdProductVariant({
+            data: performedActions.created[_models_1.ProductVariant.name] ?? [],
+            sharedContext,
+        });
+        utils_2.eventBuilders.updatedProductVariant({
+            data: performedActions.updated[_models_1.ProductVariant.name] ?? [],
+            sharedContext,
+        });
+        utils_2.eventBuilders.deletedProductVariant({
+            data: performedActions.deleted[_models_1.ProductVariant.name] ?? [],
+            sharedContext,
+        });
+        return productVariants;
     }
-    async createTags(data, sharedContext = {}) {
-        const productTags = await this.productTagService_.create(data, sharedContext);
-        return await this.baseRepository_.serialize(productTags);
+    async createProductTags(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const tags = await this.productTagService_.create(input, sharedContext);
+        const createdTags = await this.baseRepository_.serialize(tags);
+        utils_2.eventBuilders.createdProductTag({
+            data: createdTags,
+            sharedContext,
+        });
+        return Array.isArray(data) ? createdTags : createdTags[0];
     }
-    async updateTags(data, sharedContext = {}) {
-        const productTags = await this.productTagService_.update(data, sharedContext);
-        return await this.baseRepository_.serialize(productTags);
+    async upsertProductTags(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const forUpdate = input.filter((tag) => !!tag.id);
+        const forCreate = input.filter((tag) => !tag.id);
+        let created = [];
+        let updated = [];
+        if (forCreate.length) {
+            created = await this.productTagService_.create(forCreate, sharedContext);
+            utils_2.eventBuilders.createdProductTag({
+                data: created,
+                sharedContext,
+            });
+        }
+        if (forUpdate.length) {
+            updated = await this.productTagService_.update(forUpdate, sharedContext);
+            utils_2.eventBuilders.updatedProductTag({
+                data: updated,
+                sharedContext,
+            });
+        }
+        const result = [...created, ...updated];
+        const allTags = await this.baseRepository_.serialize(result);
+        return Array.isArray(data) ? allTags : allTags[0];
     }
-    async createTypes(data, sharedContext = {}) {
+    async updateProductTags(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = [];
+        if ((0, utils_1.isString)(idOrSelector)) {
+            // Check if the tag exists in the first place
+            await this.productTagService_.retrieve(idOrSelector, {}, sharedContext);
+            normalizedInput = [{ id: idOrSelector, ...data }];
+        }
+        else {
+            const tags = await this.productTagService_.list(idOrSelector, {}, sharedContext);
+            normalizedInput = tags.map((tag) => ({
+                id: tag.id,
+                ...data,
+            }));
+        }
+        const tags = await this.productTagService_.update(normalizedInput, sharedContext);
+        const updatedTags = await this.baseRepository_.serialize(tags);
+        utils_2.eventBuilders.updatedProductTag({
+            data: updatedTags,
+            sharedContext,
+        });
+        return (0, utils_1.isString)(idOrSelector) ? updatedTags[0] : updatedTags;
+    }
+    async createProductTypes(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const types = await this.productTypeService_.create(input, sharedContext);
         const createdTypes = await this.baseRepository_.serialize(types);
         return Array.isArray(data) ? createdTypes : createdTypes[0];
     }
-    async upsertTypes(data, sharedContext = {}) {
+    async upsertProductTypes(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((type) => !!type.id);
         const forCreate = input.filter((type) => !type.id);
@@ -147,7 +214,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         const allTypes = await this.baseRepository_.serialize(result);
         return Array.isArray(data) ? allTypes : allTypes[0];
     }
-    async updateTypes(idOrSelector, data, sharedContext = {}) {
+    async updateProductTypes(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             // Check if the type exists in the first place
@@ -165,7 +232,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         const updatedTypes = await this.baseRepository_.serialize(types);
         return (0, utils_1.isString)(idOrSelector) ? updatedTypes[0] : updatedTypes;
     }
-    async createOptions(data, sharedContext = {}) {
+    async createProductOptions(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const options = await this.createOptions_(input, sharedContext);
         const createdOptions = await this.baseRepository_.serialize(options);
@@ -185,7 +252,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         });
         return await this.productOptionService_.create(normalizedInput, sharedContext);
     }
-    async upsertOptions(data, sharedContext = {}) {
+    async upsertProductOptions(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((option) => !!option.id);
         const forCreate = input.filter((option) => !option.id);
@@ -201,7 +268,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         const allOptions = await this.baseRepository_.serialize(result);
         return Array.isArray(data) ? allOptions : allOptions[0];
     }
-    async updateOptions(idOrSelector, data, sharedContext = {}) {
+    async updateProductOptions(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             await this.productOptionService_.retrieve(idOrSelector, {}, sharedContext);
@@ -223,7 +290,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         if (data.some((option) => !option.id)) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Tried to update options without specifying an ID");
         }
-        const dbOptions = await this.productOptionService_.list({ id: data.map(({ id }) => id) }, { take: null, relations: ["values"] }, sharedContext);
+        const dbOptions = await this.productOptionService_.list({ id: data.map(({ id }) => id) }, { relations: ["values"] }, sharedContext);
         if (dbOptions.length !== data.length) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot update non-existing options with ids: ${(0, utils_1.arrayDifference)(data.map(({ id }) => id), dbOptions.map(({ id }) => id)).join(", ")}`);
         }
@@ -255,25 +322,29 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
                     : {}),
             };
         });
-        return await this.productOptionService_.upsertWithReplace(normalizedInput, { relations: ["values"] }, sharedContext);
+        const { entities: productOptions } = await this.productOptionService_.upsertWithReplace(normalizedInput, { relations: ["values"] }, sharedContext);
+        return productOptions;
     }
-    async createCollections(data, sharedContext = {}) {
+    async createProductCollections(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const collections = await this.createCollections_(input, sharedContext);
         const createdCollections = await this.baseRepository_.serialize(collections);
         await this.eventBusModuleService_?.emit(collections.map(({ id }) => ({
-            eventName: types_2.ProductCollectionEvents.COLLECTION_CREATED,
+            name: types_2.ProductCollectionEvents.COLLECTION_CREATED,
             data: { id },
-        })));
+        })), {
+            internal: true,
+        });
         return Array.isArray(data) ? createdCollections : createdCollections[0];
     }
     async createCollections_(data, sharedContext = {}) {
         const normalizedInput = data.map(ProductModuleService.normalizeCreateProductCollectionInput);
         // It's safe to use upsertWithReplace here since we only have product IDs and the only operation to do is update the product
         // with the collection ID
-        return await this.productCollectionService_.upsertWithReplace(normalizedInput, { relations: ["products"] }, sharedContext);
+        const { entities: productCollections } = await this.productCollectionService_.upsertWithReplace(normalizedInput, { relations: ["products"] }, sharedContext);
+        return productCollections;
     }
-    async upsertCollections(data, sharedContext = {}) {
+    async upsertProductCollections(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((collection) => !!collection.id);
         const forCreate = input.filter((collection) => !collection.id);
@@ -289,19 +360,23 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         const allCollections = await this.baseRepository_.serialize(result);
         if (created.length) {
             await this.eventBusModuleService_?.emit(created.map(({ id }) => ({
-                eventName: types_2.ProductCollectionEvents.COLLECTION_CREATED,
+                name: types_2.ProductCollectionEvents.COLLECTION_CREATED,
                 data: { id },
-            })));
+            })), {
+                internal: true,
+            });
         }
         if (updated.length) {
             await this.eventBusModuleService_?.emit(updated.map(({ id }) => ({
-                eventName: types_2.ProductCollectionEvents.COLLECTION_UPDATED,
+                name: types_2.ProductCollectionEvents.COLLECTION_UPDATED,
                 data: { id },
-            })));
+            })), {
+                internal: true,
+            });
         }
         return Array.isArray(data) ? allCollections : allCollections[0];
     }
-    async updateCollections(idOrSelector, data, sharedContext = {}) {
+    async updateProductCollections(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             await this.productCollectionService_.retrieve(idOrSelector, {}, sharedContext);
@@ -317,9 +392,11 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         const collections = await this.updateCollections_(normalizedInput, sharedContext);
         const updatedCollections = await this.baseRepository_.serialize(collections);
         await this.eventBusModuleService_?.emit(updatedCollections.map(({ id }) => ({
-            eventName: types_2.ProductCollectionEvents.COLLECTION_UPDATED,
+            name: types_2.ProductCollectionEvents.COLLECTION_UPDATED,
             data: { id },
-        })));
+        })), {
+            internal: true,
+        });
         return (0, utils_1.isString)(idOrSelector) ? updatedCollections[0] : updatedCollections;
     }
     async updateCollections_(data, sharedContext = {}) {
@@ -327,85 +404,146 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         // TODO: Maybe we can update upsertWithReplace to not remove oneToMany entities, but just disassociate them? With that we can remove the code below.
         // Another alternative is to not allow passing product_ids to a collection, and instead set the collection_id through the product update call.
         const updatedCollections = await this.productCollectionService_.update(normalizedInput.map((c) => (0, utils_1.removeUndefined)({ ...c, products: undefined })), sharedContext);
-        const collectionWithProducts = await (0, utils_1.promiseAll)(updatedCollections.map(async (collection, i) => {
-            const input = normalizedInput.find((c) => c.id === collection.id);
+        const collections = [];
+        const updateSelectorAndData = updatedCollections.flatMap((collectionData) => {
+            const input = normalizedInput.find((c) => c.id === collectionData.id);
             const productsToUpdate = input?.products;
-            if (!productsToUpdate) {
-                return { ...collection, products: [] };
+            const dissociateSelector = {
+                collection_id: collectionData.id,
+            };
+            const associateSelector = {};
+            if (!!productsToUpdate?.length) {
+                const productIds = productsToUpdate.map((p) => p.id);
+                dissociateSelector["id"] = { $nin: productIds };
+                associateSelector["id"] = { $in: productIds };
             }
-            await this.productService_.update({
-                selector: { collection_id: collection.id },
-                data: { collection_id: null },
-            }, sharedContext);
-            if (productsToUpdate.length > 0) {
-                await this.productService_.update(productsToUpdate.map((p) => ({
-                    id: p.id,
-                    collection_id: collection.id,
-                })), sharedContext);
+            const result = [
+                {
+                    selector: dissociateSelector,
+                    data: {
+                        collection_id: null,
+                    },
+                },
+            ];
+            if ((0, utils_1.isPresent)(associateSelector)) {
+                result.push({
+                    selector: associateSelector,
+                    data: {
+                        collection_id: collectionData.id,
+                    },
+                });
             }
-            return { ...collection, products: productsToUpdate };
-        }));
-        return collectionWithProducts;
-    }
-    async createCategory(data, sharedContext = {}) {
-        const result = await this.createCategory_(data, sharedContext);
-        return await this.baseRepository_.serialize(result);
-    }
-    async createCategory_(data, sharedContext = {}) {
-        const productCategory = await this.productCategoryService_.create(data, sharedContext);
-        await this.eventBusModuleService_?.emit(types_2.ProductCategoryEvents.CATEGORY_CREATED, { id: productCategory.id });
-        return productCategory;
-    }
-    async updateCategory(categoryId, data, sharedContext = {}) {
-        const productCategory = await this.productCategoryService_.update(categoryId, data, sharedContext);
-        await this.eventBusModuleService_?.emit(types_2.ProductCategoryEvents.CATEGORY_UPDATED, { id: productCategory.id });
-        return await this.baseRepository_.serialize(productCategory, {
-            populate: true,
+            collections.push({
+                ...collectionData,
+                products: productsToUpdate ?? [],
+            });
+            return result;
+        });
+        await this.productService_.update(updateSelectorAndData, sharedContext);
+        return collections;
+    }
+    async createProductCategories(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const categories = await this.productCategoryService_.create(input, sharedContext);
+        const createdCategories = await this.baseRepository_.serialize(categories);
+        utils_2.eventBuilders.createdProductCategory({
+            data: createdCategories,
+            sharedContext,
+        });
+        return Array.isArray(data) ? createdCategories : createdCategories[0];
+    }
+    async upsertProductCategories(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const forUpdate = input.filter((category) => !!category.id);
+        const forCreate = input.filter((category) => !category.id);
+        let created = [];
+        let updated = [];
+        if (forCreate.length) {
+            created = await this.productCategoryService_.create(forCreate, sharedContext);
+        }
+        if (forUpdate.length) {
+            updated = await this.productCategoryService_.update(forUpdate, sharedContext);
+        }
+        const createdCategories = await this.baseRepository_.serialize(created);
+        const updatedCategories = await this.baseRepository_.serialize(updated);
+        utils_2.eventBuilders.createdProductCategory({
+            data: createdCategories,
+            sharedContext,
         });
+        utils_2.eventBuilders.updatedProductCategory({
+            data: updatedCategories,
+            sharedContext,
+        });
+        const result = [...createdCategories, ...updatedCategories];
+        return Array.isArray(data) ? result : result[0];
     }
-    async deleteCategory(categoryId, sharedContext = {}) {
-        await this.productCategoryService_.delete(categoryId, sharedContext);
-        await this.eventBusModuleService_?.emit(types_2.ProductCategoryEvents.CATEGORY_DELETED, { id: categoryId });
+    async updateProductCategories(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = [];
+        if ((0, utils_1.isString)(idOrSelector)) {
+            // Check if the type exists in the first place
+            await this.productCategoryService_.retrieve(idOrSelector, {}, sharedContext);
+            normalizedInput = [{ id: idOrSelector, ...data }];
+        }
+        else {
+            const categories = await this.productCategoryService_.list(idOrSelector, {}, sharedContext);
+            normalizedInput = categories.map((type) => ({
+                id: type.id,
+                ...data,
+            }));
+        }
+        const categories = await this.productCategoryService_.update(normalizedInput, sharedContext);
+        const updatedCategories = await this.baseRepository_.serialize(categories);
+        utils_2.eventBuilders.updatedProductCategory({
+            data: updatedCategories,
+            sharedContext,
+        });
+        return (0, utils_1.isString)(idOrSelector) ? updatedCategories[0] : updatedCategories;
     }
-    async create(data, sharedContext = {}) {
+    async createProducts(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const products = await this.create_(input, sharedContext);
+        const products = await this.createProducts_(input, sharedContext);
         const createdProducts = await this.baseRepository_.serialize(products);
         await this.eventBusModuleService_?.emit(createdProducts.map(({ id }) => ({
-            eventName: types_2.ProductEvents.PRODUCT_CREATED,
+            name: types_2.ProductEvents.PRODUCT_CREATED,
             data: { id },
-        })));
+        })), {
+            internal: true,
+        });
         return Array.isArray(data) ? createdProducts : createdProducts[0];
     }
-    async upsert(data, sharedContext = {}) {
+    async upsertProducts(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((product) => !!product.id);
         const forCreate = input.filter((product) => !product.id);
         let created = [];
         let updated = [];
         if (forCreate.length) {
-            created = await this.create_(forCreate, sharedContext);
+            created = await this.createProducts_(forCreate, sharedContext);
         }
         if (forUpdate.length) {
-            updated = await this.update_(forUpdate, sharedContext);
+            updated = await this.updateProducts_(forUpdate, sharedContext);
         }
         const result = [...created, ...updated];
         const allProducts = await this.baseRepository_.serialize(result);
         if (created.length) {
             await this.eventBusModuleService_?.emit(created.map(({ id }) => ({
-                eventName: types_2.ProductEvents.PRODUCT_CREATED,
+                name: types_2.ProductEvents.PRODUCT_CREATED,
                 data: { id },
-            })));
+            })), {
+                internal: true,
+            });
         }
         if (updated.length) {
             await this.eventBusModuleService_?.emit(updated.map(({ id }) => ({
-                eventName: types_2.ProductEvents.PRODUCT_UPDATED,
+                name: types_2.ProductEvents.PRODUCT_UPDATED,
                 data: { id },
-            })));
+            })), {
+                internal: true,
+            });
         }
         return Array.isArray(data) ? allProducts : allProducts[0];
     }
-    async update(idOrSelector, data, sharedContext = {}) {
+    async updateProducts(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             // This will throw if the product does not exist
@@ -419,17 +557,23 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
                 ...data,
             }));
         }
-        const products = await this.update_(normalizedInput, sharedContext);
+        const products = await this.updateProducts_(normalizedInput, sharedContext);
         const updatedProducts = await this.baseRepository_.serialize(products);
         await this.eventBusModuleService_?.emit(updatedProducts.map(({ id }) => ({
-            eventName: types_2.ProductEvents.PRODUCT_UPDATED,
+            name: types_2.ProductEvents.PRODUCT_UPDATED,
             data: { id },
-        })));
+        })), {
+            internal: true,
+        });
         return (0, utils_1.isString)(idOrSelector) ? updatedProducts[0] : updatedProducts;
     }
-    async create_(data, sharedContext = {}) {
-        const normalizedInput = await (0, utils_1.promiseAll)(data.map(async (d) => await this.normalizeCreateProductInput(d, sharedContext)));
-        const productData = await this.productService_.upsertWithReplace(normalizedInput, {
+    async createProducts_(data, sharedContext = {}) {
+        const normalizedInput = await (0, utils_1.promiseAll)(data.map(async (d) => {
+            const normalized = await this.normalizeCreateProductInput(d, sharedContext);
+            this.validateProductPayload(normalized);
+            return normalized;
+        }));
+        const { entities: productData } = await this.productService_.upsertWithReplace(normalizedInput, {
             relations: ["images", "tags", "categories"],
         }, sharedContext);
         await (0, utils_1.promiseAll)(
@@ -439,25 +583,29 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             upsertedProduct.options = [];
             upsertedProduct.variants = [];
             if (product.options?.length) {
-                upsertedProduct.options =
-                    await this.productOptionService_.upsertWithReplace(product.options?.map((option) => ({
-                        ...option,
-                        product_id: upsertedProduct.id,
-                    })) ?? [], { relations: ["values"] }, sharedContext);
+                const { entities: productOptions } = await this.productOptionService_.upsertWithReplace(product.options?.map((option) => ({
+                    ...option,
+                    product_id: upsertedProduct.id,
+                })) ?? [], { relations: ["values"] }, sharedContext);
+                upsertedProduct.options = productOptions;
             }
             if (product.variants?.length) {
-                upsertedProduct.variants =
-                    await this.productVariantService_.upsertWithReplace(ProductModuleService.assignOptionsToVariants(product.variants?.map((v) => ({
-                        ...v,
-                        product_id: upsertedProduct.id,
-                    })) ?? [], upsertedProduct.options), { relations: ["options"] }, sharedContext);
+                const { entities: productVariants } = await this.productVariantService_.upsertWithReplace(ProductModuleService.assignOptionsToVariants(product.variants?.map((v) => ({
+                    ...v,
+                    product_id: upsertedProduct.id,
+                })) ?? [], upsertedProduct.options), { relations: ["options"] }, sharedContext);
+                upsertedProduct.variants = productVariants;
             }
         }));
         return productData;
     }
-    async update_(data, sharedContext = {}) {
-        const normalizedInput = await (0, utils_1.promiseAll)(data.map(async (d) => await this.normalizeUpdateProductInput(d, sharedContext)));
-        const productData = await this.productService_.upsertWithReplace(normalizedInput, {
+    async updateProducts_(data, sharedContext = {}) {
+        const normalizedInput = await (0, utils_1.promiseAll)(data.map(async (d) => {
+            const normalized = await this.normalizeUpdateProductInput(d, sharedContext);
+            this.validateProductPayload(normalized);
+            return normalized;
+        }));
+        const { entities: productData } = await this.productService_.upsertWithReplace(normalizedInput, {
             relations: ["images", "tags", "categories"],
         }, sharedContext);
         // There is more than 1-level depth of relations here, so we need to handle the options and variants manually
@@ -467,11 +615,11 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             const upsertedProduct = productData[i];
             let allOptions = [];
             if (product.options?.length) {
-                upsertedProduct.options =
-                    await this.productOptionService_.upsertWithReplace(product.options?.map((option) => ({
-                        ...option,
-                        product_id: upsertedProduct.id,
-                    })) ?? [], { relations: ["values"] }, sharedContext);
+                const { entities: productOptions } = await this.productOptionService_.upsertWithReplace(product.options?.map((option) => ({
+                    ...option,
+                    product_id: upsertedProduct.id,
+                })) ?? [], { relations: ["values"] }, sharedContext);
+                upsertedProduct.options = productOptions;
                 // Since we handle the options and variants outside of the product upsert, we need to clean up manually
                 await this.productOptionService_.delete({
                     product_id: upsertedProduct.id,
@@ -484,15 +632,15 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             else {
                 // If the options weren't affected, but the user is changing the variants, make sure we have all options available locally
                 if (product.variants?.length) {
-                    allOptions = await this.productOptionService_.list({ product_id: upsertedProduct.id }, { take: null, relations: ["values"] }, sharedContext);
+                    allOptions = await this.productOptionService_.list({ product_id: upsertedProduct.id }, { relations: ["values"] }, sharedContext);
                 }
             }
             if (product.variants?.length) {
-                upsertedProduct.variants =
-                    await this.productVariantService_.upsertWithReplace(ProductModuleService.assignOptionsToVariants(product.variants?.map((v) => ({
-                        ...v,
-                        product_id: upsertedProduct.id,
-                    })) ?? [], allOptions), { relations: ["options"] }, sharedContext);
+                const { entities: productVariants } = await this.productVariantService_.upsertWithReplace(ProductModuleService.assignOptionsToVariants(product.variants?.map((v) => ({
+                    ...v,
+                    product_id: upsertedProduct.id,
+                })) ?? [], allOptions), { relations: ["options"] }, sharedContext);
+                upsertedProduct.variants = productVariants;
                 await this.productVariantService_.delete({
                     product_id: upsertedProduct.id,
                     id: {
@@ -503,10 +651,19 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         }));
         return productData;
     }
+    /**
+     * Validates the manually provided handle value of the product
+     * to be URL-safe
+     */
+    validateProductPayload(productData) {
+        if (productData.handle && !(0, utils_1.isValidHandle)(productData.handle)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid product handle '${productData.handle}'. It must contain URL safe characters`);
+        }
+    }
     async normalizeCreateProductInput(product, sharedContext = {}) {
         const productData = (await this.normalizeUpdateProductInput(product, sharedContext));
         if (!productData.handle && productData.title) {
-            productData.handle = (0, utils_1.kebabCase)(productData.title);
+            productData.handle = (0, utils_1.toHandle)(productData.title);
         }
         if (!productData.status) {
             productData.status = utils_1.ProductStatus.DRAFT;
@@ -521,33 +678,30 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         if (productData.is_giftcard) {
             productData.discountable = false;
         }
-        if (productData.tags?.length && productData.tags.some((t) => !t.id)) {
-            const dbTags = await this.productTagService_.list({
-                value: productData.tags
-                    .map((t) => t.value)
-                    .filter((v) => !!v),
-            }, { take: null }, sharedContext);
-            productData.tags = productData.tags.map((tag) => {
-                const dbTag = dbTags.find((t) => t.value === tag.value);
-                return {
-                    ...tag,
-                    ...(dbTag ? { id: dbTag.id } : {}),
-                };
-            });
-        }
         if (productData.options?.length) {
-            ;
+            const dbOptions = await this.productOptionService_.list({ product_id: productData.id }, { relations: ["values"] }, sharedContext);
             productData.options = productData.options?.map((option) => {
+                const dbOption = dbOptions.find((o) => o.title === option.title);
                 return {
                     title: option.title,
                     values: option.values?.map((value) => {
+                        const dbValue = dbOption?.values?.find((val) => val.value === value);
                         return {
                             value: value,
+                            ...(dbValue ? { id: dbValue.id } : {}),
                         };
                     }),
+                    ...(dbOption ? { id: dbOption.id } : {}),
                 };
             });
         }
+        if (productData.tag_ids) {
+            ;
+            productData.tags = productData.tag_ids.map((cid) => ({
+                id: cid,
+            }));
+            delete productData.tag_ids;
+        }
         if (productData.category_ids) {
             ;
             productData.categories = productData.category_ids.map((cid) => ({
@@ -581,7 +735,7 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         }
         const variantsWithOptions = variants.map((variant) => {
             const variantOptions = Object.entries(variant.options ?? {}).map(([key, val]) => {
-                const option = options.find((o) => o.title === key);
+                const option = options.find((o) => o.title === key && o.product_id === variant.product_id);
                 const optionValue = option?.values?.find((v) => (v.value?.value ?? v.value) === val);
                 if (!optionValue) {
                     throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Option value ${val} does not exist for option ${key}`);
@@ -603,208 +757,217 @@ class ProductModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
 }
 exports.default = ProductModuleService;
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (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, "createVariants", null);
+], ProductModuleService.prototype, "createProductVariants", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "createVariants_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "upsertVariants", null);
+], ProductModuleService.prototype, "upsertProductVariants", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "updateVariants", null);
+], ProductModuleService.prototype, "updateProductVariants", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "updateVariants_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "createTags", null);
+], ProductModuleService.prototype, "createProductTags", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "upsertProductTags", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "updateTags", null);
+], ProductModuleService.prototype, "updateProductTags", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "createTypes", null);
+], ProductModuleService.prototype, "createProductTypes", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "upsertTypes", null);
+], ProductModuleService.prototype, "upsertProductTypes", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "updateTypes", null);
+], ProductModuleService.prototype, "updateProductTypes", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "createOptions", null);
+], ProductModuleService.prototype, "createProductOptions", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "createOptions_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "upsertOptions", null);
+], ProductModuleService.prototype, "upsertProductOptions", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "updateOptions", null);
+], ProductModuleService.prototype, "updateProductOptions", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "updateOptions_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "createCollections", null);
+], ProductModuleService.prototype, "createProductCollections", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "createCollections_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "upsertCollections", null);
+], ProductModuleService.prototype, "upsertProductCollections", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "updateCollections", null);
+], ProductModuleService.prototype, "updateProductCollections", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "updateCollections_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (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, "createCategory", null);
+], ProductModuleService.prototype, "createProductCategories", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "createCategory_", null);
+], ProductModuleService.prototype, "upsertProductCategories", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "updateCategory", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "deleteCategory", null);
+], ProductModuleService.prototype, "updateProductCategories", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "create", null);
+], ProductModuleService.prototype, "createProducts", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "upsert", null);
+], ProductModuleService.prototype, "upsertProducts", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], ProductModuleService.prototype, "update", null);
+], ProductModuleService.prototype, "updateProducts", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "create_", null);
+], ProductModuleService.prototype, "createProducts_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (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, "update_", null);
+], ProductModuleService.prototype, "updateProducts_", null);
 __decorate([
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
@@ -817,3 +980,4 @@ __decorate([
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], ProductModuleService.prototype, "normalizeUpdateProductInput", null);
+//# sourceMappingURL=product-module-service.js.map