@medusajs/medusa 1.7.13 → 1.7.14

package/dist/services/product-variant.js

@@ -206,28 +206,27 @@ var ProductVariantService = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                            var productRepo, variantRepo, prices, rest, product, variantExists, toCreate, productVariant, result, prices_1, prices_1_1, price, region, e_1_1;
-                            var e_1, _a;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
+                            var productRepo, variantRepo, prices, rest, product, variantExists, toCreate, productVariant, result;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
                                     case 0:
                                         productRepo = manager.getCustomRepository(this.productRepository_);
                                         variantRepo = manager.getCustomRepository(this.productVariantRepository_);
                                         prices = variant.prices, rest = __rest(variant, ["prices"]);
                                         product = productOrProductId;
-                                        if (!(typeof product === "string")) return [3 /*break*/, 2];
+                                        if (!(0, utils_1.isString)(product)) return [3 /*break*/, 2];
                                         return [4 /*yield*/, productRepo.findOne({
                                                 where: { id: productOrProductId },
                                                 relations: ["variants", "variants.options", "options"],
                                             })];
                                     case 1:
-                                        product = (_b.sent());
+                                        product = (_a.sent());
                                         return [3 /*break*/, 3];
                                     case 2:
                                         if (!product.id) {
                                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Product id missing");
                                         }
-                                        _b.label = 3;
+                                        _a.label = 3;
                                     case 3:
                                         if (product.options.length !== variant.options.length) {
                                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Product options length does not match variant options length. Product has ".concat(product.options.length, " and variant has ").concat(variant.options.length, "."));
@@ -253,54 +252,25 @@ var ProductVariantService = /** @class */ (function (_super) {
                                         productVariant = variantRepo.create(toCreate);
                                         return [4 /*yield*/, variantRepo.save(productVariant)];
                                     case 4:
-                                        result = _b.sent();
-                                        if (!prices) return [3 /*break*/, 15];
-                                        _b.label = 5;
+                                        result = _a.sent();
+                                        if (!prices) return [3 /*break*/, 6];
+                                        return [4 /*yield*/, this.updateVariantPrices([
+                                                {
+                                                    variantId: result.id,
+                                                    prices: prices,
+                                                },
+                                            ])];
                                     case 5:
-                                        _b.trys.push([5, 13, 14, 15]);
-                                        prices_1 = __values(prices), prices_1_1 = prices_1.next();
-                                        _b.label = 6;
-                                    case 6:
-                                        if (!!prices_1_1.done) return [3 /*break*/, 12];
-                                        price = prices_1_1.value;
-                                        if (!price.region_id) return [3 /*break*/, 9];
-                                        return [4 /*yield*/, this.regionService_.retrieve(price.region_id)];
-                                    case 7:
-                                        region = _b.sent();
-                                        return [4 /*yield*/, this.setRegionPrice(result.id, {
-                                                amount: price.amount,
-                                                region_id: price.region_id,
-                                                currency_code: region.currency_code,
-                                            })];
-                                    case 8:
-                                        _b.sent();
-                                        return [3 /*break*/, 11];
-                                    case 9: return [4 /*yield*/, this.setCurrencyPrice(result.id, price)];
-                                    case 10:
-                                        _b.sent();
-                                        _b.label = 11;
-                                    case 11:
-                                        prices_1_1 = prices_1.next();
-                                        return [3 /*break*/, 6];
-                                    case 12: return [3 /*break*/, 15];
-                                    case 13:
-                                        e_1_1 = _b.sent();
-                                        e_1 = { error: e_1_1 };
-                                        return [3 /*break*/, 15];
-                                    case 14:
-                                        try {
-                                            if (prices_1_1 && !prices_1_1.done && (_a = prices_1.return)) _a.call(prices_1);
-                                        }
-                                        finally { if (e_1) throw e_1.error; }
-                                        return [7 /*endfinally*/];
-                                    case 15: return [4 /*yield*/, this.eventBus_
+                                        _a.sent();
+                                        _a.label = 6;
+                                    case 6: return [4 /*yield*/, this.eventBus_
                                             .withTransaction(manager)
                                             .emit(ProductVariantService.Events.CREATED, {
                                             id: result.id,
                                             product_id: result.product_id,
                                         })];
-                                    case 16:
-                                        _b.sent();
+                                    case 7:
+                                        _a.sent();
                                         return [2 /*return*/, result];
                                 }
                             });
@@ -310,114 +280,174 @@ var ProductVariantService = /** @class */ (function (_super) {
             });
         });
     };
-    /**
-     * Updates a variant.
-     * Price updates should use dedicated methods.
-     * The function will throw, if price updates are attempted.
-     * @param variantOrVariantId - variant or id of a variant.
-     * @param update - an object with the update values.
-     * @param config - an object with the config values for returning the variant.
-     * @return resolves to the update result.
-     */
-    ProductVariantService.prototype.update = function (variantOrVariantId, update) {
+    ProductVariantService.prototype.update = function (variantOrVariantIdOrData, updateData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = Array.isArray(variantOrVariantIdOrData)
+                            ? variantOrVariantIdOrData
+                            : [];
+                        return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                                var variantRepo, variant, result;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            variantRepo = manager.getCustomRepository(this.productVariantRepository_);
+                                            if (!updateData) return [3 /*break*/, 3];
+                                            variant = variantOrVariantIdOrData;
+                                            if (!(0, utils_1.isString)(variantOrVariantIdOrData)) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, this.retrieve(variantOrVariantIdOrData, {
+                                                    select: variantRepo.metadata.columns.map(function (c) { return c.propertyName; }),
+                                                })];
+                                        case 1:
+                                            variant = _a.sent();
+                                            _a.label = 2;
+                                        case 2:
+                                            if (!(variant === null || variant === void 0 ? void 0 : variant.id)) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Variant id missing");
+                                            }
+                                            data = [{ variant: variant, updateData: updateData }];
+                                            _a.label = 3;
+                                        case 3: return [4 /*yield*/, this.updateBatch(data)];
+                                        case 4:
+                                            result = _a.sent();
+                                            return [2 /*return*/, (Array.isArray(variantOrVariantIdOrData)
+                                                    ? result
+                                                    : result[0])];
+                                    }
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ProductVariantService.prototype.updateBatch = function (variantData) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                            var variantRepo, variant, variantRes, prices, options, metadata, inventory_quantity, rest, options_1, options_1_1, option, e_2_1, _a, _b, _c, key, value, result;
-                            var e_2, _d, e_3, _e;
-                            return __generator(this, function (_f) {
-                                switch (_f.label) {
+                            var variantRepo, variantPriceUpdateData, results, events;
+                            var _this = this;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
                                     case 0:
                                         variantRepo = manager.getCustomRepository(this.productVariantRepository_);
-                                        variant = variantOrVariantId;
-                                        if (!(typeof variant === "string")) return [3 /*break*/, 2];
-                                        return [4 /*yield*/, variantRepo.findOne({
-                                                where: { id: variantOrVariantId },
-                                            })];
+                                        variantPriceUpdateData = variantData
+                                            .filter(function (data) { return (0, medusa_core_utils_1.isDefined)(data.updateData.prices); })
+                                            .map(function (data) { return ({
+                                            variantId: data.variant.id,
+                                            prices: data.updateData.prices,
+                                        }); });
+                                        if (!variantPriceUpdateData.length) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this.updateVariantPrices(variantPriceUpdateData)];
                                     case 1:
-                                        variantRes = _f.sent();
-                                        if (!(0, medusa_core_utils_1.isDefined)(variantRes)) {
-                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Variant with id ".concat(variantOrVariantId, " was not found"));
-                                        }
-                                        else {
-                                            variant = variantRes;
-                                        }
-                                        return [3 /*break*/, 3];
-                                    case 2:
-                                        if (!variant.id) {
-                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Variant id missing");
-                                        }
-                                        _f.label = 3;
+                                        _a.sent();
+                                        _a.label = 2;
+                                    case 2: return [4 /*yield*/, Promise.all(variantData.map(function (_a) {
+                                            var variant = _a.variant, updateData = _a.updateData;
+                                            return __awaiter(_this, void 0, void 0, function () {
+                                                var prices, options, rest, shouldUpdate, shouldEmitUpdateEvent, _b, _c, option, e_1_1, toUpdate, _d, _e, _f, key, value, result, id, rawResult;
+                                                var e_1, _g, e_2, _h;
+                                                return __generator(this, function (_j) {
+                                                    switch (_j.label) {
+                                                        case 0:
+                                                            prices = updateData.prices, options = updateData.options, rest = __rest(updateData, ["prices", "options"]);
+                                                            shouldUpdate = (0, utils_1.hasChanges)(variant, rest);
+                                                            shouldEmitUpdateEvent = shouldUpdate || !!(options === null || options === void 0 ? void 0 : options.length) || !!(prices === null || prices === void 0 ? void 0 : prices.length);
+                                                            _j.label = 1;
+                                                        case 1:
+                                                            _j.trys.push([1, 6, 7, 8]);
+                                                            _b = __values(options !== null && options !== void 0 ? options : []), _c = _b.next();
+                                                            _j.label = 2;
+                                                        case 2:
+                                                            if (!!_c.done) return [3 /*break*/, 5];
+                                                            option = _c.value;
+                                                            return [4 /*yield*/, this.updateOptionValue(variant.id, option.option_id, option.value)];
+                                                        case 3:
+                                                            _j.sent();
+                                                            _j.label = 4;
+                                                        case 4:
+                                                            _c = _b.next();
+                                                            return [3 /*break*/, 2];
+                                                        case 5: return [3 /*break*/, 8];
+                                                        case 6:
+                                                            e_1_1 = _j.sent();
+                                                            e_1 = { error: e_1_1 };
+                                                            return [3 /*break*/, 8];
+                                                        case 7:
+                                                            try {
+                                                                if (_c && !_c.done && (_g = _b.return)) _g.call(_b);
+                                                            }
+                                                            finally { if (e_1) throw e_1.error; }
+                                                            return [7 /*endfinally*/];
+                                                        case 8:
+                                                            toUpdate = {};
+                                                            if ((0, utils_1.isObject)(rest.metadata)) {
+                                                                toUpdate["metadata"] = (0, utils_1.setMetadata)(variant, rest.metadata);
+                                                                delete rest.metadata;
+                                                            }
+                                                            if (Object.keys(rest).length) {
+                                                                try {
+                                                                    for (_d = __values(Object.entries(rest)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                                                        _f = __read(_e.value, 2), key = _f[0], value = _f[1];
+                                                                        if (variant[key] !== value) {
+                                                                            toUpdate[key] = value;
+                                                                        }
+                                                                    }
+                                                                }
+                                                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                                                finally {
+                                                                    try {
+                                                                        if (_e && !_e.done && (_h = _d.return)) _h.call(_d);
+                                                                    }
+                                                                    finally { if (e_2) throw e_2.error; }
+                                                                }
+                                                            }
+                                                            result = variant;
+                                                            if (!shouldUpdate) return [3 /*break*/, 10];
+                                                            id = variant.id;
+                                                            return [4 /*yield*/, variantRepo.update({ id: id }, toUpdate)];
+                                                        case 9:
+                                                            rawResult = _j.sent();
+                                                            result = variantRepo.create(__assign(__assign({}, variant), rawResult.generatedMaps[0]));
+                                                            _j.label = 10;
+                                                        case 10: return [2 /*return*/, [result, updateData, shouldEmitUpdateEvent]];
+                                                    }
+                                                });
+                                            });
+                                        }))];
                                     case 3:
-                                        prices = update.prices, options = update.options, metadata = update.metadata, inventory_quantity = update.inventory_quantity, rest = __rest(update, ["prices", "options", "metadata", "inventory_quantity"]);
-                                        if (!prices) return [3 /*break*/, 5];
-                                        return [4 /*yield*/, this.updateVariantPrices(variant.id, prices)];
+                                        results = _a.sent();
+                                        events = results
+                                            .filter(function (_a) {
+                                            var _b = __read(_a, 3), shouldEmitUpdateEvent = _b[2];
+                                            return shouldEmitUpdateEvent;
+                                        })
+                                            .map(function (_a) {
+                                            var _b = __read(_a, 2), result = _b[0], updatedData = _b[1];
+                                            return {
+                                                eventName: ProductVariantService.Events.UPDATED,
+                                                data: {
+                                                    id: result.id,
+                                                    product_id: result.product_id,
+                                                    fields: Object.keys(updatedData),
+                                                },
+                                            };
+                                        });
+                                        if (!events.length) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, this.eventBus_.withTransaction(manager).emit(events)];
                                     case 4:
-                                        _f.sent();
-                                        _f.label = 5;
-                                    case 5:
-                                        if (!options) return [3 /*break*/, 13];
-                                        _f.label = 6;
-                                    case 6:
-                                        _f.trys.push([6, 11, 12, 13]);
-                                        options_1 = __values(options), options_1_1 = options_1.next();
-                                        _f.label = 7;
-                                    case 7:
-                                        if (!!options_1_1.done) return [3 /*break*/, 10];
-                                        option = options_1_1.value;
-                                        return [4 /*yield*/, this.updateOptionValue(variant.id, option.option_id, option.value)];
-                                    case 8:
-                                        _f.sent();
-                                        _f.label = 9;
-                                    case 9:
-                                        options_1_1 = options_1.next();
-                                        return [3 /*break*/, 7];
-                                    case 10: return [3 /*break*/, 13];
-                                    case 11:
-                                        e_2_1 = _f.sent();
-                                        e_2 = { error: e_2_1 };
-                                        return [3 /*break*/, 13];
-                                    case 12:
-                                        try {
-                                            if (options_1_1 && !options_1_1.done && (_d = options_1.return)) _d.call(options_1);
-                                        }
-                                        finally { if (e_2) throw e_2.error; }
-                                        return [7 /*endfinally*/];
-                                    case 13:
-                                        if (typeof metadata === "object") {
-                                            variant.metadata = (0, utils_1.setMetadata)(variant, metadata);
-                                        }
-                                        if (typeof inventory_quantity === "number") {
-                                            variant.inventory_quantity = inventory_quantity;
-                                        }
-                                        try {
-                                            for (_a = __values(Object.entries(rest)), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                                _c = __read(_b.value, 2), key = _c[0], value = _c[1];
-                                                variant[key] = value;
-                                            }
-                                        }
-                                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                                        finally {
-                                            try {
-                                                if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
-                                            }
-                                            finally { if (e_3) throw e_3.error; }
-                                        }
-                                        return [4 /*yield*/, variantRepo.save(variant)];
-                                    case 14:
-                                        result = _f.sent();
-                                        return [4 /*yield*/, this.eventBus_
-                                                .withTransaction(manager)
-                                                .emit(ProductVariantService.Events.UPDATED, {
-                                                id: result.id,
-                                                product_id: result.product_id,
-                                                fields: Object.keys(update),
-                                            })];
-                                    case 15:
-                                        _f.sent();
-                                        return [2 /*return*/, result];
+                                        _a.sent();
+                                        _a.label = 5;
+                                    case 5: return [2 /*return*/, results.map(function (_a) {
+                                            var _b = __read(_a, 1), variant = _b[0];
+                                            return variant;
+                                        })];
                                 }
                             });
                         }); })];
@@ -426,70 +456,231 @@ var ProductVariantService = /** @class */ (function (_super) {
             });
         });
     };
-    /**
-     * Updates a variant's prices.
-     * Deletes any prices that are not in the update object, and is not associated with a price list.
-     * @param variantId - the id of variant
-     * @param prices - the update prices
-     * @returns empty promise
-     */
-    ProductVariantService.prototype.updateVariantPrices = function (variantId, prices) {
+    ProductVariantService.prototype.updateVariantPrices = function (variantIdOrData, prices) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = !(0, utils_1.isString)(variantIdOrData)
+                            ? variantIdOrData
+                            : [];
+                        if (prices && (0, utils_1.isString)(variantIdOrData)) {
+                            data = [{ variantId: variantIdOrData, prices: prices }];
+                        }
+                        return [4 /*yield*/, this.updateVariantPricesBatch(data)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ProductVariantService.prototype.updateVariantPricesBatch = function (data) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                            var moneyAmountRepo, regionsServiceTx, prices_2, prices_2_1, price, region, e_4_1;
-                            var e_4, _a;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
+                            var moneyAmountRepo, regionIdsSet, regions, regionsMap, dataRegionPrices, dataCurrencyPrices, promises;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
                                     case 0:
                                         moneyAmountRepo = manager.getCustomRepository(this.moneyAmountRepository_);
                                         // Delete obsolete prices
-                                        return [4 /*yield*/, moneyAmountRepo.deleteVariantPricesNotIn(variantId, prices)];
+                                        return [4 /*yield*/, moneyAmountRepo.deleteVariantPricesNotIn(data)];
                                     case 1:
                                         // Delete obsolete prices
-                                        _b.sent();
-                                        regionsServiceTx = this.regionService_.withTransaction(manager);
-                                        _b.label = 2;
+                                        _a.sent();
+                                        regionIdsSet = new Set(data
+                                            .map(function (data_) {
+                                            return data_.prices
+                                                .filter(function (price) { return price.region_id; })
+                                                .map(function (price) { return price.region_id; });
+                                        })
+                                            .flat());
+                                        return [4 /*yield*/, this.regionService_.withTransaction(manager).list({
+                                                id: __spreadArray([], __read(regionIdsSet), false),
+                                            }, {
+                                                select: ["id", "currency_code"],
+                                            })];
                                     case 2:
-                                        _b.trys.push([2, 10, 11, 12]);
-                                        prices_2 = __values(prices), prices_2_1 = prices_2.next();
-                                        _b.label = 3;
+                                        regions = _a.sent();
+                                        regionsMap = new Map(regions.map(function (r) { return [r.id, r]; }));
+                                        dataRegionPrices = [];
+                                        dataCurrencyPrices = [];
+                                        data.forEach(function (_a) {
+                                            var prices = _a.prices, variantId = _a.variantId;
+                                            prices.forEach(function (price) {
+                                                if (price.region_id) {
+                                                    var region = regionsMap.get(price.region_id);
+                                                    dataRegionPrices.push({
+                                                        variantId: variantId,
+                                                        price: {
+                                                            currency_code: region.currency_code,
+                                                            region_id: price.region_id,
+                                                            amount: price.amount,
+                                                        },
+                                                    });
+                                                }
+                                                else {
+                                                    dataCurrencyPrices.push({
+                                                        variantId: variantId,
+                                                        price: __assign(__assign({}, price), { currency_code: price.currency_code }),
+                                                    });
+                                                }
+                                            });
+                                        });
+                                        promises = [];
+                                        if (dataRegionPrices.length) {
+                                            promises.push(this.addOrUpdateRegionPrices(dataRegionPrices));
+                                        }
+                                        if (dataCurrencyPrices.length) {
+                                            promises.push(this.addOrUpdateCurrencyPrices(dataCurrencyPrices));
+                                        }
+                                        return [4 /*yield*/, Promise.all(promises)];
                                     case 3:
-                                        if (!!prices_2_1.done) return [3 /*break*/, 9];
-                                        price = prices_2_1.value;
-                                        if (!price.region_id) return [3 /*break*/, 6];
-                                        return [4 /*yield*/, regionsServiceTx.retrieve(price.region_id)];
-                                    case 4:
-                                        region = _b.sent();
-                                        return [4 /*yield*/, this.setRegionPrice(variantId, {
-                                                currency_code: region.currency_code,
-                                                region_id: price.region_id,
-                                                amount: price.amount,
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ProductVariantService.prototype.addOrUpdateRegionPrices = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var moneyAmountRepo, where, moneyAmounts, moneyAmountsMapToVariantId, dataToCreate, dataToUpdate, promises;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        moneyAmountRepo = manager.getCustomRepository(this.moneyAmountRepository_);
+                                        where = data.map(function (data_) { return ({
+                                            variant_id: data_.variantId,
+                                            region_id: data_.price.region_id,
+                                            price_list_id: (0, typeorm_1.IsNull)(),
+                                        }); });
+                                        return [4 /*yield*/, moneyAmountRepo.find({
+                                                where: where,
                                             })];
-                                    case 5:
-                                        _b.sent();
-                                        return [3 /*break*/, 8];
-                                    case 6: return [4 /*yield*/, this.setCurrencyPrice(variantId, price)];
-                                    case 7:
-                                        _b.sent();
-                                        _b.label = 8;
-                                    case 8:
-                                        prices_2_1 = prices_2.next();
-                                        return [3 /*break*/, 3];
-                                    case 9: return [3 /*break*/, 12];
-                                    case 10:
-                                        e_4_1 = _b.sent();
-                                        e_4 = { error: e_4_1 };
-                                        return [3 /*break*/, 12];
-                                    case 11:
-                                        try {
-                                            if (prices_2_1 && !prices_2_1.done && (_a = prices_2.return)) _a.call(prices_2);
+                                    case 1:
+                                        moneyAmounts = _a.sent();
+                                        moneyAmountsMapToVariantId = new Map();
+                                        moneyAmounts.map(function (d) {
+                                            var _a;
+                                            var moneyAmounts = (_a = moneyAmountsMapToVariantId.get(d.variant_id)) !== null && _a !== void 0 ? _a : [];
+                                            moneyAmounts.push(d);
+                                            moneyAmountsMapToVariantId.set(d.variant_id, moneyAmounts);
+                                        });
+                                        dataToCreate = [];
+                                        dataToUpdate = [];
+                                        data.forEach(function (_a) {
+                                            var _b;
+                                            var price = _a.price, variantId = _a.variantId;
+                                            var variantMoneyAmounts = (_b = moneyAmountsMapToVariantId.get(variantId)) !== null && _b !== void 0 ? _b : [];
+                                            var moneyAmount = variantMoneyAmounts.find(function (ma) { return ma.region_id === price.region_id; });
+                                            if (moneyAmount) {
+                                                // No need to update if the amount is the same
+                                                if (moneyAmount.amount !== price.amount) {
+                                                    dataToUpdate.push({
+                                                        id: moneyAmount.id,
+                                                        amount: price.amount,
+                                                    });
+                                                }
+                                            }
+                                            else {
+                                                dataToCreate.push(moneyAmountRepo.create(__assign(__assign({}, price), { variant_id: variantId })));
+                                            }
+                                        });
+                                        promises = [];
+                                        if (dataToCreate.length) {
+                                            promises.push(moneyAmountRepo.insertBulk(dataToCreate));
+                                        }
+                                        if (dataToUpdate.length) {
+                                            dataToUpdate.forEach(function (data) {
+                                                var id = data.id, rest = __rest(data, ["id"]);
+                                                promises.push(moneyAmountRepo.update({ id: data.id }, rest));
+                                            });
                                         }
-                                        finally { if (e_4) throw e_4.error; }
-                                        return [7 /*endfinally*/];
-                                    case 12: return [2 /*return*/];
+                                        return [4 /*yield*/, Promise.all(promises)];
+                                    case 2:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ProductVariantService.prototype.addOrUpdateCurrencyPrices = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var moneyAmountRepo, where, moneyAmounts, moneyAmountsMapToVariantId, dataToCreate, dataToUpdate, promises;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        moneyAmountRepo = manager.getCustomRepository(this.moneyAmountRepository_);
+                                        where = data.map(function (data_) { return ({
+                                            variant_id: data_.variantId,
+                                            currency_code: data_.price.currency_code,
+                                            region_id: (0, typeorm_1.IsNull)(),
+                                            price_list_id: (0, typeorm_1.IsNull)(),
+                                        }); });
+                                        return [4 /*yield*/, moneyAmountRepo.find({
+                                                where: where,
+                                            })];
+                                    case 1:
+                                        moneyAmounts = _a.sent();
+                                        moneyAmountsMapToVariantId = new Map();
+                                        moneyAmounts.map(function (d) {
+                                            var _a;
+                                            var moneyAmounts = (_a = moneyAmountsMapToVariantId.get(d.variant_id)) !== null && _a !== void 0 ? _a : [];
+                                            moneyAmounts.push(d);
+                                            moneyAmountsMapToVariantId.set(d.variant_id, moneyAmounts);
+                                        });
+                                        dataToCreate = [];
+                                        dataToUpdate = [];
+                                        data.forEach(function (_a) {
+                                            var _b;
+                                            var price = _a.price, variantId = _a.variantId;
+                                            var variantMoneyAmounts = (_b = moneyAmountsMapToVariantId.get(variantId)) !== null && _b !== void 0 ? _b : [];
+                                            var moneyAmount = variantMoneyAmounts.find(function (ma) { return ma.currency_code === price.currency_code; });
+                                            if (moneyAmount) {
+                                                // No need to update if the amount is the same
+                                                if (moneyAmount.amount !== price.amount) {
+                                                    dataToUpdate.push({
+                                                        id: moneyAmount.id,
+                                                        amount: price.amount,
+                                                    });
+                                                }
+                                            }
+                                            else {
+                                                dataToCreate.push(moneyAmountRepo.create(__assign(__assign({}, price), { variant_id: variantId, currency_code: price.currency_code.toLowerCase() })));
+                                            }
+                                        });
+                                        promises = [];
+                                        if (dataToCreate.length) {
+                                            promises.push(moneyAmountRepo.insertBulk(dataToCreate));
+                                        }
+                                        if (dataToUpdate.length) {
+                                            dataToUpdate.forEach(function (data) {
+                                                var id = data.id, rest = __rest(data, ["id"]);
+                                                promises.push(moneyAmountRepo.update({ id: data.id }, rest));
+                                            });
+                                        }
+                                        return [4 /*yield*/, Promise.all(promises)];
+                                    case 2:
+                                        _a.sent();
+                                        return [2 /*return*/];
                                 }
                             });
                         }); })];
@@ -541,6 +732,7 @@ var ProductVariantService = /** @class */ (function (_super) {
         });
     };
     /**
+     * @deprecated use addOrUpdateRegionPrices instead
      * Sets the default price of a specific region
      * @param variantId - the id of the variant to update
      * @param price - the price for the variant.
@@ -583,6 +775,7 @@ var ProductVariantService = /** @class */ (function (_super) {
         });
     };
     /**
+     * @deprecated use addOrUpdateCurrencyPrices instead
      * Sets the default price for the given currency.
      * @param variantId - the id of the variant to set prices for
      * @param price - the price for the variant
@@ -815,48 +1008,55 @@ var ProductVariantService = /** @class */ (function (_super) {
         });
     };
     /**
-     * Deletes variant.
+     * Deletes variant or variants.
      * Will never fail due to delete being idempotent.
-     * @param variantId - the id of the variant to delete. Must be
+     * @param variantIds - the id of the variant to delete. Must be
      *   castable as an ObjectId
      * @return empty promise
      */
-    ProductVariantService.prototype.delete = function (variantId) {
+    ProductVariantService.prototype.delete = function (variantIds) {
         return __awaiter(this, void 0, void 0, function () {
+            var variantIds_;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                            var variantRepo, variant;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        variantRepo = manager.getCustomRepository(this.productVariantRepository_);
-                                        return [4 /*yield*/, variantRepo.findOne({
-                                                where: { id: variantId },
-                                                relations: ["prices", "options", "inventory_items"],
-                                            })];
-                                    case 1:
-                                        variant = _a.sent();
-                                        if (!variant) {
-                                            return [2 /*return*/, Promise.resolve()];
-                                        }
-                                        return [4 /*yield*/, variantRepo.softRemove(variant)];
-                                    case 2:
-                                        _a.sent();
-                                        return [4 /*yield*/, this.eventBus_
-                                                .withTransaction(manager)
-                                                .emit(ProductVariantService.Events.DELETED, {
-                                                id: variant.id,
-                                                product_id: variant.product_id,
-                                                metadata: variant.metadata,
-                                            })];
-                                    case 3:
-                                        _a.sent();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
+                    case 0:
+                        variantIds_ = (0, utils_1.isString)(variantIds) ? [variantIds] : variantIds;
+                        return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                                var variantRepo, variants, events;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            variantRepo = manager.getCustomRepository(this.productVariantRepository_);
+                                            return [4 /*yield*/, variantRepo.find({
+                                                    where: { id: (0, typeorm_1.In)(variantIds_) },
+                                                    relations: ["prices", "options", "inventory_items"],
+                                                })];
+                                        case 1:
+                                            variants = _a.sent();
+                                            if (!variants.length) {
+                                                return [2 /*return*/, Promise.resolve()];
+                                            }
+                                            return [4 /*yield*/, variantRepo.softRemove(variants)];
+                                        case 2:
+                                            _a.sent();
+                                            events = variants.map(function (variant) {
+                                                return {
+                                                    eventName: ProductVariantService.Events.DELETED,
+                                                    data: {
+                                                        id: variant.id,
+                                                        product_id: variant.product_id,
+                                                        metadata: variant.metadata,
+                                                    },
+                                                };
+                                            });
+                                            return [4 /*yield*/, this.eventBus_.withTransaction(manager).emit(events)];
+                                        case 3:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });