@medusajs/medusa 1.2.2-dev.47 → 1.3.0

package/dist/services/discount.js

@@ -109,10 +109,14 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var medusa_interfaces_1 = require("medusa-interfaces");
-var medusa_core_utils_1 = require("medusa-core-utils");
 var iso8601_duration_1 = require("iso8601-duration");
+var lodash_1 = require("lodash");
+var medusa_core_utils_1 = require("medusa-core-utils");
+var medusa_interfaces_1 = require("medusa-interfaces");
 var typeorm_1 = require("typeorm");
+var discount_condition_1 = require("../models/discount-condition");
+var discount_rule_1 = require("../models/discount-rule");
+var date_helpers_1 = require("../utils/date-helpers");
 var exception_formatter_1 = require("../utils/exception-formatter");
 /**
  * Provides layer to manipulate discounts.
@@ -121,7 +125,7 @@ var exception_formatter_1 = require("../utils/exception-formatter");
 var DiscountService = /** @class */ (function (_super) {
     __extends(DiscountService, _super);
     function DiscountService(_a) {
-        var manager = _a.manager, discountRepository = _a.discountRepository, discountRuleRepository = _a.discountRuleRepository, giftCardRepository = _a.giftCardRepository, totalsService = _a.totalsService, productService = _a.productService, regionService = _a.regionService, eventBusService = _a.eventBusService;
+        var manager = _a.manager, discountRepository = _a.discountRepository, discountRuleRepository = _a.discountRuleRepository, giftCardRepository = _a.giftCardRepository, discountConditionRepository = _a.discountConditionRepository, totalsService = _a.totalsService, productService = _a.productService, regionService = _a.regionService, customerService = _a.customerService, eventBusService = _a.eventBusService;
         var _this = _super.call(this) || this;
         /** @private @const {EntityManager} */
         _this.manager_ = manager;
@@ -131,12 +135,16 @@ var DiscountService = /** @class */ (function (_super) {
         _this.discountRuleRepository_ = discountRuleRepository;
         /** @private @const {GiftCardRepository} */
         _this.giftCardRepository_ = giftCardRepository;
+        /** @private @const {DiscountConditionRepository} */
+        _this.discountConditionRepository_ = discountConditionRepository;
         /** @private @const {TotalsService} */
         _this.totalsService_ = totalsService;
         /** @private @const {ProductService} */
         _this.productService_ = productService;
         /** @private @const {RegionService} */
         _this.regionService_ = regionService;
+        /** @private @const {CustomerService} */
+        _this.customerService_ = customerService;
         /** @private @const {EventBus} */
         _this.eventBus_ = eventBusService;
         return _this;
@@ -150,12 +158,15 @@ var DiscountService = /** @class */ (function (_super) {
             discountRepository: this.discountRepository_,
             discountRuleRepository: this.discountRuleRepository_,
             giftCardRepository: this.giftCardRepository_,
+            discountConditionRepository: this.discountConditionRepository_,
             totalsService: this.totalsService_,
             productService: this.productService_,
             regionService: this.regionService_,
+            customerService: this.customerService_,
             eventBusService: this.eventBus_,
         });
         cloned.transactionManager_ = transactionManager;
+        cloned.manager_ = transactionManager;
         return cloned;
     };
     /**
@@ -170,7 +181,6 @@ var DiscountService = /** @class */ (function (_super) {
             type: medusa_core_utils_1.Validator.string().required(),
             value: medusa_core_utils_1.Validator.number().min(0).required(),
             allocation: medusa_core_utils_1.Validator.string().required(),
-            valid_for: medusa_core_utils_1.Validator.array().optional(),
             created_at: medusa_core_utils_1.Validator.date().optional(),
             updated_at: medusa_core_utils_1.Validator.date().allow(null).optional(),
             deleted_at: medusa_core_utils_1.Validator.date().allow(null).optional(),
@@ -209,7 +219,11 @@ var DiscountService = /** @class */ (function (_super) {
      */
     DiscountService.prototype.listAndCount = function (selector, config) {
         if (selector === void 0) { selector = {}; }
-        if (config === void 0) { config = { skip: 0, take: 50, order: { created_at: "DESC" } }; }
+        if (config === void 0) { config = {
+            take: 20,
+            skip: 0,
+            order: { created_at: "DESC" },
+        }; }
         return __awaiter(this, void 0, void 0, function () {
             var discountRepo, q, query, where_1, _a, discounts, count;
             return __generator(this, function (_b) {
@@ -250,51 +264,81 @@ var DiscountService = /** @class */ (function (_super) {
             var _this = this;
             return __generator(this, function (_a) {
                 return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var discountRepo, ruleRepo, validatedRule, _a, discountRule, createdDiscountRule, created, result, error_1;
+                        var discountRepo, ruleRepo, conditions, ruleToCreate, validatedRule, _a, discountRule, createdDiscountRule, created, result, conditions_1, conditions_1_1, cond, e_1_1, error_1;
+                        var e_1, _b;
                         var _this = this;
-                        var _b, _c;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
+                        var _c, _d;
+                        return __generator(this, function (_e) {
+                            switch (_e.label) {
                                 case 0:
                                     discountRepo = manager.getCustomRepository(this.discountRepository_);
                                     ruleRepo = manager.getCustomRepository(this.discountRuleRepository_);
-                                    if ((_b = discount.rule) === null || _b === void 0 ? void 0 : _b.valid_for) {
-                                        discount.rule.valid_for = discount.rule.valid_for.map(function (id) { return ({ id: id }); });
-                                    }
+                                    conditions = (_c = discount.rule) === null || _c === void 0 ? void 0 : _c.conditions;
+                                    ruleToCreate = (0, lodash_1.omit)(discount.rule, ["conditions"]);
+                                    discount.rule = ruleToCreate;
                                     validatedRule = this.validateDiscountRule_(discount.rule);
-                                    if (((_c = discount.regions) === null || _c === void 0 ? void 0 : _c.length) > 1 && discount.rule.type === "fixed") {
+                                    if ((discount === null || discount === void 0 ? void 0 : discount.regions) &&
+                                        (discount === null || discount === void 0 ? void 0 : discount.regions.length) > 1 &&
+                                        ((_d = discount === null || discount === void 0 ? void 0 : discount.rule) === null || _d === void 0 ? void 0 : _d.type) === "fixed") {
                                         throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Fixed discounts can have one region");
                                     }
-                                    _d.label = 1;
+                                    _e.label = 1;
                                 case 1:
-                                    _d.trys.push([1, 8, , 9]);
+                                    _e.trys.push([1, 16, , 17]);
                                     if (!discount.regions) return [3 /*break*/, 3];
                                     _a = discount;
                                     return [4 /*yield*/, Promise.all(discount.regions.map(function (regionId) {
                                             return _this.regionService_.withTransaction(manager).retrieve(regionId);
                                         }))];
                                 case 2:
-                                    _a.regions = _d.sent();
-                                    _d.label = 3;
+                                    _a.regions = _e.sent();
+                                    _e.label = 3;
                                 case 3: return [4 /*yield*/, ruleRepo.create(validatedRule)];
                                 case 4:
-                                    discountRule = _d.sent();
+                                    discountRule = _e.sent();
                                     return [4 /*yield*/, ruleRepo.save(discountRule)];
                                 case 5:
-                                    createdDiscountRule = _d.sent();
+                                    createdDiscountRule = _e.sent();
                                     discount.code = discount.code.toUpperCase();
                                     discount.rule = createdDiscountRule;
                                     return [4 /*yield*/, discountRepo.create(discount)];
                                 case 6:
-                                    created = _d.sent();
+                                    created = _e.sent();
                                     return [4 /*yield*/, discountRepo.save(created)];
                                 case 7:
-                                    result = _d.sent();
-                                    return [2 /*return*/, result];
+                                    result = _e.sent();
+                                    if (!(conditions === null || conditions === void 0 ? void 0 : conditions.length)) return [3 /*break*/, 15];
+                                    _e.label = 8;
                                 case 8:
-                                    error_1 = _d.sent();
+                                    _e.trys.push([8, 13, 14, 15]);
+                                    conditions_1 = __values(conditions), conditions_1_1 = conditions_1.next();
+                                    _e.label = 9;
+                                case 9:
+                                    if (!!conditions_1_1.done) return [3 /*break*/, 12];
+                                    cond = conditions_1_1.value;
+                                    return [4 /*yield*/, this.upsertDiscountCondition_(result.id, cond)];
+                                case 10:
+                                    _e.sent();
+                                    _e.label = 11;
+                                case 11:
+                                    conditions_1_1 = conditions_1.next();
+                                    return [3 /*break*/, 9];
+                                case 12: return [3 /*break*/, 15];
+                                case 13:
+                                    e_1_1 = _e.sent();
+                                    e_1 = { error: e_1_1 };
+                                    return [3 /*break*/, 15];
+                                case 14:
+                                    try {
+                                        if (conditions_1_1 && !conditions_1_1.done && (_b = conditions_1.return)) _b.call(conditions_1);
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                    return [7 /*endfinally*/];
+                                case 15: return [2 /*return*/, result];
+                                case 16:
+                                    error_1 = _e.sent();
                                     throw (0, exception_formatter_1.formatException)(error_1);
-                                case 9: return [2 /*return*/];
+                                case 17: return [2 /*return*/];
                             }
                         });
                     }); })];
@@ -375,66 +419,95 @@ var DiscountService = /** @class */ (function (_super) {
             var _this = this;
             return __generator(this, function (_a) {
                 return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var discountRepo, discount, rule, metadata, regions, rest, _a, _b, _c, _d, key, updated;
-                        var e_1, _e;
+                        var discountRepo, discount, conditions, ruleToUpdate, rule, metadata, regions, rest, conditions_2, conditions_2_1, cond, e_2_1, _a, _b, _c, _d, key, updated;
+                        var e_2, _e, e_3, _f;
                         var _this = this;
-                        return __generator(this, function (_f) {
-                            switch (_f.label) {
+                        var _g;
+                        return __generator(this, function (_h) {
+                            switch (_h.label) {
                                 case 0:
                                     discountRepo = manager.getCustomRepository(this.discountRepository_);
                                     return [4 /*yield*/, this.retrieve(discountId, {
                                             relations: ["rule"],
                                         })];
                                 case 1:
-                                    discount = _f.sent();
+                                    discount = _h.sent();
+                                    conditions = (_g = update === null || update === void 0 ? void 0 : update.rule) === null || _g === void 0 ? void 0 : _g.conditions;
+                                    ruleToUpdate = (0, lodash_1.omit)(update.rule, "conditions");
+                                    if (!(0, lodash_1.isEmpty)(ruleToUpdate)) {
+                                        update.rule = ruleToUpdate;
+                                    }
                                     rule = update.rule, metadata = update.metadata, regions = update.regions, rest = __rest(update, ["rule", "metadata", "regions"]);
                                     if (rest.ends_at) {
-                                        if (discount.starts_at >= new Date(update.ends_at)) {
+                                        if (discount.starts_at >= new Date(rest.ends_at)) {
                                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "\"ends_at\" must be greater than \"starts_at\"");
                                         }
                                     }
-                                    if ((regions === null || regions === void 0 ? void 0 : regions.length) > 1 && discount.rule.type === "fixed") {
+                                    if (regions && (regions === null || regions === void 0 ? void 0 : regions.length) > 1 && discount.rule.type === "fixed") {
                                         throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Fixed discounts can have one region");
                                     }
-                                    if (!regions) return [3 /*break*/, 3];
-                                    _a = discount;
-                                    return [4 /*yield*/, Promise.all(regions.map(function (regionId) { return _this.regionService_.retrieve(regionId); }))];
+                                    if (!(conditions === null || conditions === void 0 ? void 0 : conditions.length)) return [3 /*break*/, 9];
+                                    _h.label = 2;
                                 case 2:
-                                    _a.regions = _f.sent();
-                                    _f.label = 3;
+                                    _h.trys.push([2, 7, 8, 9]);
+                                    conditions_2 = __values(conditions), conditions_2_1 = conditions_2.next();
+                                    _h.label = 3;
                                 case 3:
-                                    if (!metadata) return [3 /*break*/, 5];
-                                    _b = discount;
-                                    return [4 /*yield*/, this.setMetadata_(discount.id, metadata)];
+                                    if (!!conditions_2_1.done) return [3 /*break*/, 6];
+                                    cond = conditions_2_1.value;
+                                    return [4 /*yield*/, this.upsertDiscountCondition_(discount.id, cond)];
                                 case 4:
-                                    _b.metadata = _f.sent();
-                                    _f.label = 5;
+                                    _h.sent();
+                                    _h.label = 5;
                                 case 5:
+                                    conditions_2_1 = conditions_2.next();
+                                    return [3 /*break*/, 3];
+                                case 6: return [3 /*break*/, 9];
+                                case 7:
+                                    e_2_1 = _h.sent();
+                                    e_2 = { error: e_2_1 };
+                                    return [3 /*break*/, 9];
+                                case 8:
+                                    try {
+                                        if (conditions_2_1 && !conditions_2_1.done && (_e = conditions_2.return)) _e.call(conditions_2);
+                                    }
+                                    finally { if (e_2) throw e_2.error; }
+                                    return [7 /*endfinally*/];
+                                case 9:
+                                    if (!regions) return [3 /*break*/, 11];
+                                    _a = discount;
+                                    return [4 /*yield*/, Promise.all(regions.map(function (regionId) { return _this.regionService_.retrieve(regionId); }))];
+                                case 10:
+                                    _a.regions = _h.sent();
+                                    _h.label = 11;
+                                case 11:
+                                    if (!metadata) return [3 /*break*/, 13];
+                                    _b = discount;
+                                    return [4 /*yield*/, this.setMetadata_(discount.id, metadata)];
+                                case 12:
+                                    _b.metadata = _h.sent();
+                                    _h.label = 13;
+                                case 13:
                                     if (rule) {
-                                        discount.rule = this.validateDiscountRule_(rule);
-                                        if (rule.valid_for) {
-                                            discount.rule.valid_for = discount.rule.valid_for.map(function (id) { return ({
-                                                id: id,
-                                            }); });
-                                        }
+                                        discount.rule = this.validateDiscountRule_(ruleToUpdate);
                                     }
                                     try {
-                                        for (_c = __values(Object.keys(rest).filter(function (k) { return rest[k] !== undefined; })), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                        for (_c = __values(Object.keys(rest).filter(function (k) { return typeof rest[k] !== "undefined"; })), _d = _c.next(); !_d.done; _d = _c.next()) {
                                             key = _d.value;
                                             discount[key] = rest[key];
                                         }
                                     }
-                                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
                                     finally {
                                         try {
-                                            if (_d && !_d.done && (_e = _c.return)) _e.call(_c);
+                                            if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
                                         }
-                                        finally { if (e_1) throw e_1.error; }
+                                        finally { if (e_3) throw e_3.error; }
                                     }
                                     discount.code = discount.code.toUpperCase();
                                     return [4 /*yield*/, discountRepo.save(discount)];
-                                case 6:
-                                    updated = _f.sent();
+                                case 14:
+                                    updated = _h.sent();
                                     return [2 /*return*/, updated];
                             }
                         });
@@ -520,85 +593,6 @@ var DiscountService = /** @class */ (function (_super) {
             });
         });
     };
-    /**
-     * Adds a valid product to the discount rule valid_for array.
-     * @param {string} discountId - id of discount
-     * @param {string} productId - id of product to add
-     * @return {Promise} the result of the update operation
-     */
-    DiscountService.prototype.addValidProduct = function (discountId, productId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var discountRuleRepo, discount, rule, exists, product, updated;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    discountRuleRepo = manager.getCustomRepository(this.discountRuleRepository_);
-                                    return [4 /*yield*/, this.retrieve(discountId, {
-                                            relations: ["rule", "rule.valid_for"],
-                                        })];
-                                case 1:
-                                    discount = _a.sent();
-                                    rule = discount.rule;
-                                    exists = rule.valid_for.find(function (p) { return p.id === productId; });
-                                    // If product is already present, we return early
-                                    if (exists) {
-                                        return [2 /*return*/, rule];
-                                    }
-                                    return [4 /*yield*/, this.productService_.retrieve(productId)];
-                                case 2:
-                                    product = _a.sent();
-                                    rule.valid_for = __spreadArray(__spreadArray([], __read(rule.valid_for), false), [product], false);
-                                    return [4 /*yield*/, discountRuleRepo.save(rule)];
-                                case 3:
-                                    updated = _a.sent();
-                                    return [2 /*return*/, updated];
-                            }
-                        });
-                    }); })];
-            });
-        });
-    };
-    /**
-     * Removes a product from the discount rule valid_for array
-     * @param {string} discountId - id of discount
-     * @param {string} productId - id of product to add
-     * @return {Promise} the result of the update operation
-     */
-    DiscountService.prototype.removeValidProduct = function (discountId, productId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var discountRuleRepo, discount, rule, exists, updated;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    discountRuleRepo = manager.getCustomRepository(this.discountRuleRepository_);
-                                    return [4 /*yield*/, this.retrieve(discountId, {
-                                            relations: ["rule", "rule.valid_for"],
-                                        })];
-                                case 1:
-                                    discount = _a.sent();
-                                    rule = discount.rule;
-                                    exists = rule.valid_for.find(function (p) { return p.id === productId; });
-                                    // If product is not present, we return early
-                                    if (!exists) {
-                                        return [2 /*return*/, rule];
-                                    }
-                                    rule.valid_for = rule.valid_for.filter(function (p) { return p.id !== productId; });
-                                    return [4 /*yield*/, discountRuleRepo.save(rule)];
-                                case 2:
-                                    updated = _a.sent();
-                                    return [2 /*return*/, updated];
-                            }
-                        });
-                    }); })];
-            });
-        });
-    };
     /**
      * Adds a region to the discount regions array.
      * @param {string} discountId - id of discount
@@ -711,37 +705,254 @@ var DiscountService = /** @class */ (function (_super) {
             });
         });
     };
-    /**
-     * Decorates a discount.
-     * @param {string} discountId -  id of discount to decorate
-     * @param {string[]} fields - the fields to include.
-     * @param {string[]} expandFields - fields to expand.
-     * @return {Discount} return the decorated discount.
-     */
-    DiscountService.prototype.decorate = function (discountId, fields, expandFields) {
-        if (fields === void 0) { fields = []; }
-        if (expandFields === void 0) { expandFields = []; }
+    DiscountService.prototype.resolveConditionType_ = function (data) {
+        var _a, _b, _c, _d, _e;
+        switch (true) {
+            case !!((_a = data.products) === null || _a === void 0 ? void 0 : _a.length):
+                return {
+                    type: discount_condition_1.DiscountConditionType.PRODUCTS,
+                    resource_ids: data.products,
+                };
+            case !!((_b = data.product_collections) === null || _b === void 0 ? void 0 : _b.length):
+                return {
+                    type: discount_condition_1.DiscountConditionType.PRODUCT_COLLECTIONS,
+                    resource_ids: data.product_collections,
+                };
+            case !!((_c = data.product_types) === null || _c === void 0 ? void 0 : _c.length):
+                return {
+                    type: discount_condition_1.DiscountConditionType.PRODUCT_TYPES,
+                    resource_ids: data.product_types,
+                };
+            case !!((_d = data.product_tags) === null || _d === void 0 ? void 0 : _d.length):
+                return {
+                    type: discount_condition_1.DiscountConditionType.PRODUCT_TAGS,
+                    resource_ids: data.product_tags,
+                };
+            case !!((_e = data.customer_groups) === null || _e === void 0 ? void 0 : _e.length):
+                return {
+                    type: discount_condition_1.DiscountConditionType.CUSTOMER_GROUPS,
+                    resource_ids: data.customer_groups,
+                };
+            default:
+                return undefined;
+        }
+    };
+    DiscountService.prototype.upsertDiscountCondition_ = function (discountId, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resolvedConditionType, res;
+            var _this = this;
+            return __generator(this, function (_a) {
+                resolvedConditionType = this.resolveConditionType_(data);
+                res = this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                    var discountConditionRepo, discount, created, discountCondition;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                discountConditionRepo = manager.getCustomRepository(this.discountConditionRepository_);
+                                if (!resolvedConditionType) {
+                                    throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Missing one of products, collections, tags, types or customer groups in data");
+                                }
+                                if (!data.id) return [3 /*break*/, 2];
+                                return [4 /*yield*/, discountConditionRepo.addConditionResources(data.id, resolvedConditionType.resource_ids, resolvedConditionType.type, true)];
+                            case 1: return [2 /*return*/, _a.sent()];
+                            case 2: return [4 /*yield*/, this.retrieve(discountId, {
+                                    relations: ["rule", "rule.conditions"],
+                                })];
+                            case 3:
+                                discount = _a.sent();
+                                created = discountConditionRepo.create({
+                                    discount_rule_id: discount.rule_id,
+                                    operator: data.operator,
+                                    type: resolvedConditionType.type,
+                                });
+                                return [4 /*yield*/, discountConditionRepo.save(created)];
+                            case 4:
+                                discountCondition = _a.sent();
+                                return [4 /*yield*/, discountConditionRepo.addConditionResources(discountCondition.id, resolvedConditionType.resource_ids, resolvedConditionType.type)];
+                            case 5: return [2 /*return*/, _a.sent()];
+                        }
+                    });
+                }); }, function (err) { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        if (err.code === exception_formatter_1.PostgresError.DUPLICATE_ERROR) {
+                            // A unique key constraint failed meaning the combination of
+                            // discount rule id, type, and operator already exists in the db.
+                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.DUPLICATE_ERROR, "Discount Condition with operator '".concat(data.operator, "' and type '").concat(resolvedConditionType === null || resolvedConditionType === void 0 ? void 0 : resolvedConditionType.type, "' already exist on a Discount Rule"));
+                        }
+                        return [2 /*return*/];
+                    });
+                }); });
+                return [2 /*return*/, res];
+            });
+        });
+    };
+    DiscountService.prototype.validateDiscountForProduct = function (discountRuleId, productId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                        var discountConditionRepo, product;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    discountConditionRepo = manager.getCustomRepository(this.discountConditionRepository_);
+                                    // In case of custom line items, we don't have a product id.
+                                    // Instead of throwing, we simply invalidate the discount.
+                                    if (!productId) {
+                                        return [2 /*return*/, false];
+                                    }
+                                    return [4 /*yield*/, this.productService_.retrieve(productId, {
+                                            relations: ["tags"],
+                                        })];
+                                case 1:
+                                    product = _a.sent();
+                                    return [4 /*yield*/, discountConditionRepo.isValidForProduct(discountRuleId, product.id)];
+                                case 2: return [2 /*return*/, _a.sent()];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    DiscountService.prototype.calculateDiscountForLineItem = function (discountId, lineItem, cart) {
+        return __awaiter(this, void 0, void 0, function () {
+            var adjustment, discount, _a, type, value, allocation, fullItemPrice, subtotal, nominator, itemRelativeToSubtotal, totalItemPercentage;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        adjustment = 0;
+                        if (!lineItem.allow_discounts) {
+                            return [2 /*return*/, adjustment];
+                        }
+                        return [4 /*yield*/, this.retrieve(discountId, { relations: ["rule"] })];
+                    case 1:
+                        discount = _b.sent();
+                        _a = discount.rule, type = _a.type, value = _a.value, allocation = _a.allocation;
+                        fullItemPrice = lineItem.unit_price * lineItem.quantity;
+                        if (type === discount_rule_1.DiscountRuleType.PERCENTAGE) {
+                            adjustment = Math.round((fullItemPrice / 100) * value);
+                        }
+                        else if (type === discount_rule_1.DiscountRuleType.FIXED &&
+                            allocation === discount_rule_1.AllocationType.TOTAL) {
+                            subtotal = this.totalsService_.getSubtotal(cart, {
+                                excludeNonDiscounts: true,
+                            });
+                            nominator = Math.min(value, subtotal);
+                            itemRelativeToSubtotal = lineItem.unit_price / subtotal;
+                            totalItemPercentage = itemRelativeToSubtotal * lineItem.quantity;
+                            adjustment = Math.round(nominator * totalItemPercentage);
+                        }
+                        else {
+                            adjustment = value * lineItem.quantity;
+                        }
+                        // if the amount of the discount exceeds the total price of the item,
+                        // we return the total item price, else the fixed amount
+                        return [2 /*return*/, adjustment >= fullItemPrice ? fullItemPrice : adjustment];
+                }
+            });
+        });
+    };
+    DiscountService.prototype.validateDiscountForCartOrThrow = function (cart, discount) {
         return __awaiter(this, void 0, void 0, function () {
-            var requiredFields, discount;
+            var isValidForRegion, canApplyForCustomer;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        requiredFields = ["id", "code", "is_dynamic", "metadata"];
-                        fields = fields.concat(requiredFields);
-                        return [4 /*yield*/, this.retrieve(discountId, {
-                                select: fields,
-                                relations: expandFields,
-                            })
-                            // const final = await this.runDecorators_(decorated)
-                        ];
+                        if (this.hasReachedLimit(discount)) {
+                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Discount has been used maximum allowed times");
+                        }
+                        if (this.hasNotStarted(discount)) {
+                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Discount is not valid yet");
+                        }
+                        if (this.hasExpired(discount)) {
+                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Discount is expired");
+                        }
+                        if (this.isDisabled(discount)) {
+                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "The discount code is disabled");
+                        }
+                        return [4 /*yield*/, this.isValidForRegion(discount, cart.region_id)];
                     case 1:
-                        discount = _a.sent();
-                        // const final = await this.runDecorators_(decorated)
-                        return [2 /*return*/, discount];
+                        isValidForRegion = _a.sent();
+                        if (!isValidForRegion) {
+                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "The discount is not available in current region");
+                        }
+                        if (!cart.customer_id) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.canApplyForCustomer(discount.rule.id, cart.customer_id)];
+                    case 2:
+                        canApplyForCustomer = _a.sent();
+                        if (!canApplyForCustomer) {
+                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Discount is not valid for customer");
+                        }
+                        _a.label = 3;
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
+    DiscountService.prototype.hasReachedLimit = function (discount) {
+        var count = discount.usage_count || 0;
+        var limit = discount.usage_limit;
+        return !!limit && count >= limit;
+    };
+    DiscountService.prototype.hasNotStarted = function (discount) {
+        return (0, date_helpers_1.isFuture)(discount.starts_at);
+    };
+    DiscountService.prototype.hasExpired = function (discount) {
+        return discount.ends_at && (0, date_helpers_1.isPast)(discount.ends_at);
+    };
+    DiscountService.prototype.isDisabled = function (discount) {
+        return discount.is_disabled;
+    };
+    DiscountService.prototype.isValidForRegion = function (discount, region_id) {
+        return __awaiter(this, void 0, void 0, function () {
+            var regions, parent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        regions = discount.regions;
+                        if (!discount.parent_discount_id) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.retrieve(discount.parent_discount_id, {
+                                relations: ["rule", "regions"],
+                            })];
+                    case 1:
+                        parent = _a.sent();
+                        regions = parent.regions;
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, regions.find(function (_a) {
+                            var id = _a.id;
+                            return id === region_id;
+                        }) !== undefined];
+                }
+            });
+        });
+    };
+    DiscountService.prototype.canApplyForCustomer = function (discountRuleId, customerId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                        var discountConditionRepo, customer;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    discountConditionRepo = manager.getCustomRepository(this.discountConditionRepository_);
+                                    // Instead of throwing on missing customer id, we simply invalidate the discount
+                                    if (!customerId) {
+                                        return [2 /*return*/, false];
+                                    }
+                                    return [4 /*yield*/, this.customerService_.retrieve(customerId, {
+                                            relations: ["groups"],
+                                        })];
+                                case 1:
+                                    customer = _a.sent();
+                                    return [4 /*yield*/, discountConditionRepo.canApplyForCustomer(discountRuleId, customer.id)];
+                                case 2: return [2 /*return*/, _a.sent()];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
     return DiscountService;
 }(medusa_interfaces_1.BaseService));
 exports.default = DiscountService;