@medusajs/fulfillment 3.0.0-preview-20250410180148 → 3.0.0-preview-20251201152819

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

@@ -17,7 +17,6 @@ const utils_1 = require("@medusajs/framework/utils");
 const _models_1 = require("../models");
 const _utils_1 = require("../utils");
 const joiner_config_1 = require("../joiner-config");
-const events_1 = require("../utils/events");
 const generateMethodForModels = {
     FulfillmentSet: _models_1.FulfillmentSet,
     ServiceZone: _models_1.ServiceZone,
@@ -27,7 +26,7 @@ const generateMethodForModels = {
     ShippingOptionRule: _models_1.ShippingOptionRule,
     ShippingOptionType: _models_1.ShippingOptionType,
     FulfillmentProvider: _models_1.FulfillmentProvider,
-    // Not adding Fulfillment to not auto generate the methods under the hood and only provide the methods we want to expose8
+    // Not adding Fulfillment to not auto generate the methods under the hood and only provide the methods we want to expose
 };
 class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels) {
     constructor({ baseRepository, fulfillmentSetService, serviceZoneService, geoZoneService, shippingProfileService, shippingOptionService, shippingOptionRuleService, shippingOptionTypeService, fulfillmentProviderService, fulfillmentService, fulfillmentAddressService, }, moduleDeclaration) {
@@ -108,10 +107,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             }
         }
         const createdFulfillmentSets = await this.fulfillmentSetService_.create(data_, sharedContext);
-        (0, _utils_1.buildCreatedFulfillmentSetEvents)({
-            fulfillmentSets: createdFulfillmentSets,
-            sharedContext,
-        });
         return createdFulfillmentSets;
     }
     // @ts-expect-error
@@ -132,10 +127,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             }
         }
         const createdServiceZones = await this.serviceZoneService_.create(data_, sharedContext);
-        (0, _utils_1.buildCreatedServiceZoneEvents)({
-            serviceZones: createdServiceZones,
-            sharedContext,
-        });
         return createdServiceZones;
     }
     // @ts-expect-error
@@ -153,19 +144,11 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             (0, _utils_1.validateAndNormalizeRules)(rules);
         }
         const createdSO = await this.shippingOptionService_.create(data_, sharedContext);
-        (0, events_1.buildCreatedShippingOptionEvents)({
-            shippingOptions: createdSO,
-            sharedContext,
-        });
         return createdSO;
     }
     // @ts-expect-error
     async createShippingProfiles(data, sharedContext = {}) {
         const createdShippingProfiles = await this.createShippingProfiles_(data, sharedContext);
-        _utils_1.eventBuilders.createdShippingProfile({
-            data: createdShippingProfiles,
-            sharedContext,
-        });
         return await this.baseRepository_.serialize(Array.isArray(data) ? createdShippingProfiles : createdShippingProfiles[0]);
     }
     async createShippingProfiles_(data, sharedContext = {}) {
@@ -180,10 +163,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
         const data_ = Array.isArray(data) ? data : [data];
         FulfillmentModuleService.validateGeoZones(data_);
         const createdGeoZones = await this.geoZoneService_.create(data_, sharedContext);
-        _utils_1.eventBuilders.createdGeoZone({
-            data: createdGeoZones,
-            sharedContext,
-        });
         return await this.baseRepository_.serialize(Array.isArray(data) ? createdGeoZones : createdGeoZones[0]);
     }
     // @ts-expect-error
@@ -200,10 +179,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
         }
         (0, _utils_1.validateAndNormalizeRules)(data_);
         const createdSORules = await this.shippingOptionRuleService_.create(data_, sharedContext);
-        _utils_1.eventBuilders.createdShippingOptionRule({
-            data: createdSORules.map((sor) => ({ id: sor.id })),
-            sharedContext,
-        });
         return createdSORules;
     }
     async createFulfillment(data, sharedContext = {}) {
@@ -223,10 +198,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             await this.fulfillmentService_.delete(fulfillment.id, sharedContext);
             throw error;
         }
-        (0, _utils_1.buildCreatedFulfillmentEvents)({
-            fulfillments: [fulfillment],
-            sharedContext,
-        });
         return await this.baseRepository_.serialize(fulfillment);
     }
     async deleteFulfillment(id, sharedContext = {}) {
@@ -258,10 +229,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             await this.fulfillmentService_.delete(fulfillment.id, sharedContext);
             throw error;
         }
-        (0, _utils_1.buildCreatedFulfillmentEvents)({
-            fulfillments: [fulfillment],
-            sharedContext,
-        });
         return await this.baseRepository_.serialize(fulfillment);
     }
     // @ts-expect-error
@@ -349,14 +316,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             }
         });
         if (serviceZoneIdsToDelete.length) {
-            _utils_1.eventBuilders.deletedServiceZone({
-                data: serviceZoneIdsToDelete.map((id) => ({ id })),
-                sharedContext,
-            });
-            _utils_1.eventBuilders.deletedGeoZone({
-                data: geoZoneIdsToDelete.map((id) => ({ id })),
-                sharedContext,
-            });
             await (0, utils_1.promiseAll)([
                 this.geoZoneService_.delete({
                     id: geoZoneIdsToDelete,
@@ -367,27 +326,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             ]);
         }
         const updatedFulfillmentSets = await this.fulfillmentSetService_.update(data_, sharedContext);
-        _utils_1.eventBuilders.updatedFulfillmentSet({
-            data: updatedFulfillmentSets,
-            sharedContext,
-        });
-        const createdServiceZoneIds = [];
-        const createdGeoZoneIds = updatedFulfillmentSets
-            .flatMap((f) => [...f.service_zones].flatMap((serviceZone) => {
-            if (!existingServiceZoneIds.includes(serviceZone.id)) {
-                createdServiceZoneIds.push(serviceZone.id);
-            }
-            return serviceZone.geo_zones.map((g) => g.id);
-        }))
-            .filter((id) => !existingGeoZoneIds.includes(id));
-        _utils_1.eventBuilders.createdServiceZone({
-            data: createdServiceZoneIds.map((id) => ({ id })),
-            sharedContext,
-        });
-        _utils_1.eventBuilders.createdGeoZone({
-            data: createdGeoZoneIds.map((id) => ({ id })),
-            sharedContext,
-        });
         return Array.isArray(data)
             ? updatedFulfillmentSets
             : updatedFulfillmentSets[0];
@@ -478,32 +416,11 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             }
         });
         if (geoZoneIdsToDelete.length) {
-            _utils_1.eventBuilders.deletedGeoZone({
-                data: geoZoneIdsToDelete.map((id) => ({ id })),
-                sharedContext,
-            });
             await this.geoZoneService_.delete({
                 id: geoZoneIdsToDelete,
             }, sharedContext);
         }
         const updatedServiceZones = await this.serviceZoneService_.update(data_, sharedContext);
-        _utils_1.eventBuilders.updatedServiceZone({
-            data: updatedServiceZones,
-            sharedContext,
-        });
-        const createdGeoZoneIds = updatedServiceZones
-            .flatMap((serviceZone) => {
-            return serviceZone.geo_zones.map((g) => g.id);
-        })
-            .filter((id) => !existingGeoZoneIds.includes(id));
-        _utils_1.eventBuilders.createdGeoZone({
-            data: createdGeoZoneIds.map((id) => ({ id })),
-            sharedContext,
-        });
-        _utils_1.eventBuilders.updatedGeoZone({
-            data: updatedGeoZoneIds.map((id) => ({ id })),
-            sharedContext,
-        });
         return Array.isArray(data) ? updatedServiceZones : updatedServiceZones[0];
     }
     async upsertServiceZones(data, sharedContext = {}) {
@@ -571,11 +488,12 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
         const ruleIdsToDelete = [];
         const updatedRuleIds = [];
         const existingRuleIds = [];
-        const optionTypeDeletedIds = [];
         dataArray.forEach((shippingOption) => {
-            const existingShippingOption = existingShippingOptions.get(shippingOption.id); // Garuantueed to exist since the validation above have been performed
-            if (shippingOption.type && !("id" in shippingOption.type)) {
-                optionTypeDeletedIds.push(existingShippingOption.type.id);
+            const existingShippingOption = existingShippingOptions.get(shippingOption.id); // Guaranteed to exist since the validation above have been performed
+            // `type_id` doesn't exist on the entity/table, `type_id` argument is mapped to `shipping_option_type_id`
+            if (shippingOption.type_id) {
+                shippingOption.shipping_option_type_id = shippingOption.type_id;
+                delete shippingOption.type_id;
             }
             if (!shippingOption.rules) {
                 return;
@@ -622,61 +540,13 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             });
         });
         if (ruleIdsToDelete.length) {
-            _utils_1.eventBuilders.deletedShippingOptionRule({
-                data: ruleIdsToDelete.map((id) => ({ id })),
-                sharedContext,
-            });
             await this.shippingOptionRuleService_.delete(ruleIdsToDelete, sharedContext);
         }
         const updatedShippingOptions = await this.shippingOptionService_.update(dataArray, sharedContext);
-        this.handleShippingOptionUpdateEvents({
-            shippingOptionsData: dataArray,
-            updatedShippingOptions,
-            optionTypeDeletedIds,
-            updatedRuleIds,
-            existingRuleIds,
-            sharedContext,
-        });
         return Array.isArray(data)
             ? updatedShippingOptions
             : updatedShippingOptions[0];
     }
-    handleShippingOptionUpdateEvents({ shippingOptionsData, updatedShippingOptions, optionTypeDeletedIds, updatedRuleIds, existingRuleIds, sharedContext, }) {
-        _utils_1.eventBuilders.updatedShippingOption({
-            data: updatedShippingOptions,
-            sharedContext,
-        });
-        _utils_1.eventBuilders.deletedShippingOptionType({
-            data: optionTypeDeletedIds.map((id) => ({ id })),
-            sharedContext,
-        });
-        const createdOptionTypeIds = updatedShippingOptions
-            .filter((so) => {
-            const updateData = shippingOptionsData.find((sod) => sod.id === so.id);
-            return updateData?.type && !("id" in updateData.type);
-        })
-            .map((so) => so.type.id);
-        _utils_1.eventBuilders.createdShippingOptionType({
-            data: createdOptionTypeIds.map((id) => ({ id })),
-            sharedContext,
-        });
-        const createdRuleIds = updatedShippingOptions
-            .flatMap((so) => [...so.rules].map((rule) => {
-            if (existingRuleIds.includes(rule.id)) {
-                return;
-            }
-            return rule.id;
-        }))
-            .filter((id) => !!id);
-        _utils_1.eventBuilders.createdShippingOptionRule({
-            data: createdRuleIds.map((id) => ({ id })),
-            sharedContext,
-        });
-        _utils_1.eventBuilders.updatedShippingOptionRule({
-            data: updatedRuleIds.map((id) => ({ id })),
-            sharedContext,
-        });
-    }
     async upsertShippingOptions(data, sharedContext = {}) {
         const upsertedShippingOptions = await this.upsertShippingOptions_(data, sharedContext);
         const allShippingOptions = await this.baseRepository_.serialize(upsertedShippingOptions);
@@ -704,8 +574,42 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
         }
         return [...created, ...updated];
     }
+    async upsertShippingOptionTypes(data, sharedContext = {}) {
+        const results = await this.updateShippingOptionTypes_(data, sharedContext);
+        const allTypes = await this.baseRepository_.serialize(results);
+        return Array.isArray(data) ? allTypes : allTypes[0];
+    }
+    async updateShippingOptionTypes_(data, sharedContext) {
+        const input = Array.isArray(data) ? data : [data];
+        const results = await this.shippingOptionTypeService_.upsert(input, sharedContext);
+        return results;
+    }
+    // @ts-expect-error
+    async updateShippingOptionTypes(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = [];
+        if ((0, utils_1.isString)(idOrSelector)) {
+            // Check if the type exists in the first place
+            await this.shippingOptionTypeService_.retrieve(idOrSelector, {}, sharedContext);
+            normalizedInput = [{ id: idOrSelector, ...data }];
+        }
+        else {
+            const types = await this.shippingOptionTypeService_.list(idOrSelector, {}, sharedContext);
+            normalizedInput = types.map((type) => ({
+                id: type.id,
+                ...data,
+            }));
+        }
+        const types = await this.shippingOptionTypeService_.update(normalizedInput, sharedContext);
+        const updatedTypes = await this.baseRepository_.serialize(types);
+        return (0, utils_1.isString)(idOrSelector) ? updatedTypes[0] : updatedTypes;
+    }
     // @ts-expect-error
     async updateShippingProfiles(idOrSelector, data, sharedContext = {}) {
+        const profiles = await this.updateShippingProfiles_(idOrSelector, data, sharedContext);
+        const updatedProfiles = await this.baseRepository_.serialize(profiles);
+        return (0, utils_1.isString)(idOrSelector) ? updatedProfiles[0] : updatedProfiles;
+    }
+    async updateShippingProfiles_(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             await this.shippingProfileService_.retrieve(idOrSelector, {}, sharedContext);
@@ -719,10 +623,13 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             }));
         }
         const profiles = await this.shippingProfileService_.update(normalizedInput, sharedContext);
-        const updatedProfiles = await this.baseRepository_.serialize(profiles);
-        return (0, utils_1.isString)(idOrSelector) ? updatedProfiles[0] : updatedProfiles;
+        return profiles;
     }
     async upsertShippingProfiles(data, sharedContext = {}) {
+        const profiles = await this.upsertShippingProfiles_(data, sharedContext);
+        return await this.baseRepository_.serialize(Array.isArray(data) ? profiles : profiles[0]);
+    }
+    async upsertShippingProfiles_(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((prof) => !!prof.id);
         const forCreate = input.filter((prof) => !prof.id);
@@ -734,9 +641,7 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
         if (forUpdate.length) {
             updated = await this.shippingProfileService_.update(forUpdate, sharedContext);
         }
-        const result = [...created, ...updated];
-        const allProfiles = await this.baseRepository_.serialize(result);
-        return Array.isArray(data) ? allProfiles : allProfiles[0];
+        return [...created, ...updated];
     }
     // @ts-expect-error
     async updateGeoZones(data, sharedContext = {}) {
@@ -746,10 +651,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
         }
         FulfillmentModuleService.validateGeoZones(data_);
         const updatedGeoZones = await this.geoZoneService_.update(data_, sharedContext);
-        _utils_1.eventBuilders.updatedGeoZone({
-            data: updatedGeoZones,
-            sharedContext,
-        });
         const serialized = await this.baseRepository_.serialize(updatedGeoZones);
         return Array.isArray(data) ? serialized : serialized[0];
     }
@@ -765,10 +666,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
         }
         (0, _utils_1.validateAndNormalizeRules)(data_);
         const updatedShippingOptionRules = await this.shippingOptionRuleService_.update(data_, sharedContext);
-        _utils_1.eventBuilders.updatedShippingOptionRule({
-            data: updatedShippingOptionRules.map((rule) => ({ id: rule.id })),
-            sharedContext,
-        });
         return Array.isArray(data)
             ? updatedShippingOptionRules
             : updatedShippingOptionRules[0];
@@ -782,8 +679,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             relations: ["items", "labels"],
         }, sharedContext);
         const updatedLabelIds = [];
-        let deletedLabelIds = [];
-        const existingLabelIds = existingFulfillment.labels.map((label) => label.id);
         /**
          * @note
          * Since the relation is a one to many, the deletion, update and creation of labels
@@ -795,10 +690,6 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
          * and we also need to emit the events later on.
          */
         if ((0, utils_1.isDefined)(data.labels) && (0, utils_1.isPresent)(data.labels)) {
-            const dataLabelIds = data.labels
-                .filter((label) => "id" in label)
-                .map((label) => label.id);
-            deletedLabelIds = (0, utils_1.arrayDifference)(existingLabelIds, dataLabelIds);
             for (let label of data.labels) {
                 if (!("id" in label)) {
                     continue;
@@ -815,30 +706,8 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
             }
         }
         const [fulfillment] = await this.fulfillmentService_.update([{ id, ...data }], sharedContext);
-        this.handleFulfillmentUpdateEvents(fulfillment, existingLabelIds, updatedLabelIds, deletedLabelIds, sharedContext);
         return fulfillment;
     }
-    handleFulfillmentUpdateEvents(fulfillment, existingLabelIds, updatedLabelIds, deletedLabelIds, sharedContext) {
-        _utils_1.eventBuilders.updatedFulfillment({
-            data: [{ id: fulfillment.id }],
-            sharedContext,
-        });
-        _utils_1.eventBuilders.deletedFulfillmentLabel({
-            data: deletedLabelIds.map((id) => ({ id })),
-            sharedContext,
-        });
-        _utils_1.eventBuilders.updatedFulfillmentLabel({
-            data: updatedLabelIds.map((id) => ({ id })),
-            sharedContext,
-        });
-        const createdLabels = fulfillment.labels.filter((label) => {
-            return !existingLabelIds.includes(label.id);
-        });
-        _utils_1.eventBuilders.createdFulfillmentLabel({
-            data: createdLabels.map((label) => ({ id: label.id })),
-            sharedContext,
-        });
-    }
     async cancelFulfillment(id, sharedContext = {}) {
         const canceledAt = new Date();
         let fulfillment = await this.fulfillmentService_.retrieve(id, {}, sharedContext);
@@ -856,13 +725,9 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
                 id,
                 canceled_at: canceledAt,
             }, sharedContext);
-            _utils_1.eventBuilders.updatedFulfillment({
-                data: [{ id }],
-                sharedContext,
-            });
         }
         const result = await this.baseRepository_.serialize(fulfillment);
-        return Array.isArray(result) ? result[0] : result;
+        return result;
     }
     async retrieveFulfillmentOptions(providerId) {
         return await this.fulfillmentProviderService_.getFulfillmentOptions(providerId);
@@ -1064,15 +929,22 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
          * Define the hierarchy of required properties for the geo zones.
          */
         const geoZoneRequirePropertyHierarchy = {
-            postal_expression: [
-                "country_code",
-                "province_code",
-                "city",
-                "postal_expression",
-            ],
-            city: ["country_code", "province_code", "city"],
-            province_code: ["country_code", "province_code"],
-            country_code: ["country_code"],
+            postal_expression: {
+                props: ["country_code", "province_code", "city", "postal_expression"],
+                type: "zip",
+            },
+            city: {
+                props: ["country_code", "province_code", "city"],
+                type: "city",
+            },
+            province_code: {
+                props: ["country_code", "province_code"],
+                type: "province",
+            },
+            country_code: {
+                props: ["country_code"],
+                type: "country",
+            },
         };
         /**
          * The following changes assume that the lowest level check (e.g postal expression) can't exist multiple times in the higher level (e.g country)
@@ -1080,14 +952,17 @@ class FulfillmentModuleService extends utils_1.ModulesSdkUtils.MedusaService(gen
          * to this pr https://github.com/medusajs/medusa/pull/8066
          */
         const geoZoneConstraints = Object.entries(geoZoneRequirePropertyHierarchy)
-            .map(([prop, requiredProps]) => {
+            .map(([prop, { props, type }]) => {
             if (address[prop]) {
-                return requiredProps.reduce((geoZoneConstraint, prop) => {
-                    if ((0, utils_1.isPresent)(address[prop])) {
-                        geoZoneConstraint[prop] = address[prop];
-                    }
-                    return geoZoneConstraint;
-                }, {});
+                return {
+                    type,
+                    ...props.reduce((geoZoneConstraint, prop) => {
+                        if ((0, utils_1.isPresent)(address[prop])) {
+                            geoZoneConstraint[prop] = address[prop];
+                        }
+                        return geoZoneConstraint;
+                    }, {}),
+                };
             }
             return null;
         })
@@ -1185,7 +1060,7 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], FulfillmentModuleService.prototype, "createShippingOptions_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
@@ -1334,7 +1209,32 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], FulfillmentModuleService.prototype, "upsertShippingOptions_", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (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)
+], FulfillmentModuleService.prototype, "upsertShippingOptionTypes", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], FulfillmentModuleService.prototype, "updateShippingOptionTypes_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
+    // @ts-expect-error
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], FulfillmentModuleService.prototype, "updateShippingOptionTypes", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1344,11 +1244,26 @@ __decorate([
 ], FulfillmentModuleService.prototype, "updateShippingProfiles", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], FulfillmentModuleService.prototype, "updateShippingProfiles_", 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)
 ], FulfillmentModuleService.prototype, "upsertShippingProfiles", 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)
+], FulfillmentModuleService.prototype, "upsertShippingProfiles_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)()
@@ -1414,7 +1329,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], FulfillmentModuleService.prototype, "validateShippingOptionsForPriceCalculation", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -1423,7 +1339,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], FulfillmentModuleService.prototype, "deleteShippingProfiles", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)()
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),