@medusajs/medusa 1.2.2-dev.53 → 1.3.1-alpha.63

package/dist/services/discount.js

@@ -109,10 +109,13 @@ 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_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 +124,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, discountConditionService = _a.discountConditionService, 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 +134,18 @@ var DiscountService = /** @class */ (function (_super) {
         _this.discountRuleRepository_ = discountRuleRepository;
         /** @private @const {GiftCardRepository} */
         _this.giftCardRepository_ = giftCardRepository;
+        /** @private @const {DiscountConditionRepository} */
+        _this.discountConditionRepository_ = discountConditionRepository;
+        /** @private @const {DiscountConditionRepository} */
+        _this.discountConditionService_ = discountConditionService;
         /** @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 +159,16 @@ var DiscountService = /** @class */ (function (_super) {
             discountRepository: this.discountRepository_,
             discountRuleRepository: this.discountRuleRepository_,
             giftCardRepository: this.giftCardRepository_,
+            discountConditionRepository: this.discountConditionRepository_,
+            discountConditionService: this.discountConditionService_,
             totalsService: this.totalsService_,
             productService: this.productService_,
             regionService: this.regionService_,
+            customerService: this.customerService_,
             eventBusService: this.eventBus_,
         });
         cloned.transactionManager_ = transactionManager;
+        cloned.manager_ = transactionManager;
         return cloned;
     };
     /**
@@ -164,26 +177,10 @@ var DiscountService = /** @class */ (function (_super) {
      * @return {Promise} the result of the create operation
      */
     DiscountService.prototype.validateDiscountRule_ = function (discountRule) {
-        var schema = medusa_core_utils_1.Validator.object().keys({
-            id: medusa_core_utils_1.Validator.string().optional(),
-            description: medusa_core_utils_1.Validator.string().optional(),
-            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(),
-            metadata: medusa_core_utils_1.Validator.object().allow(null).optional(),
-        });
-        var _a = schema.validate(discountRule), value = _a.value, error = _a.error;
-        if (error) {
-            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, error.details[0].message);
-        }
-        if (value.type === "percentage" && value.value > 100) {
+        if (discountRule.type === "percentage" && discountRule.value > 100) {
             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Discount value above 100 is not allowed when type is percentage");
         }
-        return value;
+        return discountRule;
     };
     /**
      * @param {Object} selector - the query object for find
@@ -209,7 +206,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,7 +251,7 @@ 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_1, error_1;
                         var _this = this;
                         var _b, _c;
                         return __generator(this, function (_d) {
@@ -258,11 +259,12 @@ var DiscountService = /** @class */ (function (_super) {
                                 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 }); });
-                                    }
-                                    validatedRule = this.validateDiscountRule_(discount.rule);
-                                    if (((_c = discount.regions) === null || _c === void 0 ? void 0 : _c.length) > 1 && discount.rule.type === "fixed") {
+                                    conditions = (_b = discount.rule) === null || _b === void 0 ? void 0 : _b.conditions;
+                                    ruleToCreate = (0, lodash_1.omit)(discount.rule, ["conditions"]);
+                                    validatedRule = this.validateDiscountRule_(ruleToCreate);
+                                    if ((discount === null || discount === void 0 ? void 0 : discount.regions) &&
+                                        (discount === null || discount === void 0 ? void 0 : discount.regions.length) > 1 &&
+                                        ((_c = discount === null || discount === void 0 ? void 0 : discount.rule) === null || _c === void 0 ? void 0 : _c.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;
@@ -276,21 +278,34 @@ var DiscountService = /** @class */ (function (_super) {
                                 case 2:
                                     _a.regions = _d.sent();
                                     _d.label = 3;
-                                case 3: return [4 /*yield*/, ruleRepo.create(validatedRule)];
-                                case 4:
-                                    discountRule = _d.sent();
+                                case 3:
+                                    discountRule = ruleRepo.create(validatedRule);
                                     return [4 /*yield*/, ruleRepo.save(discountRule)];
-                                case 5:
+                                case 4:
                                     createdDiscountRule = _d.sent();
                                     discount.code = discount.code.toUpperCase();
-                                    discount.rule = createdDiscountRule;
-                                    return [4 /*yield*/, discountRepo.create(discount)];
-                                case 6:
-                                    created = _d.sent();
+                                    created = discountRepo.create(discount);
+                                    created.rule = createdDiscountRule;
                                     return [4 /*yield*/, discountRepo.save(created)];
-                                case 7:
-                                    result = _d.sent();
-                                    return [2 /*return*/, result];
+                                case 5:
+                                    result_1 = _d.sent();
+                                    if (!(conditions === null || conditions === void 0 ? void 0 : conditions.length)) return [3 /*break*/, 7];
+                                    return [4 /*yield*/, Promise.all(conditions.map(function (cond) { return __awaiter(_this, void 0, void 0, function () {
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0: return [4 /*yield*/, this.discountConditionService_
+                                                            .withTransaction(manager)
+                                                            .upsertCondition(__assign({ rule_id: result_1.rule_id }, cond))];
+                                                    case 1:
+                                                        _a.sent();
+                                                        return [2 /*return*/];
+                                                }
+                                            });
+                                        }); }))];
+                                case 6:
+                                    _d.sent();
+                                    _d.label = 7;
+                                case 7: return [2 /*return*/, result_1];
                                 case 8:
                                     error_1 = _d.sent();
                                     throw (0, exception_formatter_1.formatException)(error_1);
@@ -331,28 +346,24 @@ var DiscountService = /** @class */ (function (_super) {
     /**
      * Gets a discount by discount code.
      * @param {string} discountCode - discount code of discount to retrieve
-     * @param {array} relations - list of relations
+     * @param {Object} config - the config object containing query settings
      * @return {Promise<Discount>} the discount document
      */
-    DiscountService.prototype.retrieveByCode = function (discountCode, relations) {
-        if (relations === void 0) { relations = []; }
+    DiscountService.prototype.retrieveByCode = function (discountCode, config) {
+        if (config === void 0) { config = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var discountRepo, discount;
+            var discountRepo, query, discount;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         discountRepo = this.manager_.getCustomRepository(this.discountRepository_);
-                        return [4 /*yield*/, discountRepo.findOne({
-                                where: { code: discountCode.toUpperCase(), is_dynamic: false },
-                                relations: relations,
-                            })];
+                        query = this.buildQuery_({ code: discountCode, is_dynamic: false }, config);
+                        return [4 /*yield*/, discountRepo.findOne(query)];
                     case 1:
                         discount = _a.sent();
                         if (!!discount) return [3 /*break*/, 3];
-                        return [4 /*yield*/, discountRepo.findOne({
-                                where: { code: discountCode.toUpperCase(), is_dynamic: true },
-                                relations: relations,
-                            })];
+                        query = this.buildQuery_({ code: discountCode, is_dynamic: true }, config);
+                        return [4 /*yield*/, discountRepo.findOne(query)];
                     case 2:
                         discount = _a.sent();
                         if (!discount) {
@@ -375,51 +386,78 @@ 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 discountRepo, ruleRepo, discount, conditions, ruleToUpdate, rule, metadata, regions, rest, _a, _b, ruleUpdate, updatedRule, _c, _d, key, updated;
                         var e_1, _e;
                         var _this = this;
-                        return __generator(this, function (_f) {
-                            switch (_f.label) {
+                        var _f;
+                        return __generator(this, function (_g) {
+                            switch (_g.label) {
                                 case 0:
                                     discountRepo = manager.getCustomRepository(this.discountRepository_);
+                                    ruleRepo = manager.getCustomRepository(this.discountRuleRepository_);
                                     return [4 /*yield*/, this.retrieve(discountId, {
                                             relations: ["rule"],
                                         })];
                                 case 1:
-                                    discount = _f.sent();
+                                    discount = _g.sent();
+                                    conditions = (_f = update === null || update === void 0 ? void 0 : update.rule) === null || _f === void 0 ? void 0 : _f.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*/, 3];
+                                    return [4 /*yield*/, Promise.all(conditions.map(function (cond) { return __awaiter(_this, void 0, void 0, function () {
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0: return [4 /*yield*/, this.discountConditionService_
+                                                            .withTransaction(manager)
+                                                            .upsertCondition(__assign({ rule_id: discount.rule_id }, cond))];
+                                                    case 1:
+                                                        _a.sent();
+                                                        return [2 /*return*/];
+                                                }
+                                            });
+                                        }); }))];
                                 case 2:
-                                    _a.regions = _f.sent();
-                                    _f.label = 3;
+                                    _g.sent();
+                                    _g.label = 3;
                                 case 3:
-                                    if (!metadata) return [3 /*break*/, 5];
-                                    _b = discount;
-                                    return [4 /*yield*/, this.setMetadata_(discount.id, metadata)];
+                                    if (!regions) return [3 /*break*/, 5];
+                                    _a = discount;
+                                    return [4 /*yield*/, Promise.all(regions.map(function (regionId) { return _this.regionService_.retrieve(regionId); }))];
                                 case 4:
-                                    _b.metadata = _f.sent();
-                                    _f.label = 5;
+                                    _a.regions = _g.sent();
+                                    _g.label = 5;
                                 case 5:
+                                    if (!metadata) return [3 /*break*/, 7];
+                                    _b = discount;
+                                    return [4 /*yield*/, this.setMetadata_(discount.id, metadata)];
+                                case 6:
+                                    _b.metadata = _g.sent();
+                                    _g.label = 7;
+                                case 7:
                                     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,
-                                            }); });
+                                        ruleUpdate = rule;
+                                        if (rule.value) {
+                                            this.validateDiscountRule_({
+                                                value: rule.value,
+                                                type: discount.rule.type,
+                                            });
                                         }
+                                        updatedRule = ruleRepo.create(__assign(__assign({}, discount.rule), ruleUpdate));
+                                        discount.rule = updatedRule;
                                     }
                                     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];
                                         }
@@ -433,8 +471,8 @@ var DiscountService = /** @class */ (function (_super) {
                                     }
                                     discount.code = discount.code.toUpperCase();
                                     return [4 /*yield*/, discountRepo.save(discount)];
-                                case 6:
-                                    updated = _f.sent();
+                                case 8:
+                                    updated = _g.sent();
                                     return [2 /*return*/, updated];
                             }
                         });
@@ -520,85 +558,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 +670,176 @@ 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.validateDiscountForProduct = function (discountRuleId, productId) {
         return __awaiter(this, void 0, void 0, function () {
-            var requiredFields, discount;
+            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 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) {
+        if (!discount.ends_at) {
+            return false;
+        }
+        return (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;