@medusajs/medusa 1.6.0 → 1.6.1

package/dist/services/payment-collection.js

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -69,13 +80,15 @@ var interfaces_1 = require("../interfaces");
 var PaymentCollectionService = /** @class */ (function (_super) {
     __extends(PaymentCollectionService, _super);
     function PaymentCollectionService(_a) {
-        var manager = _a.manager, paymentCollectionRepository = _a.paymentCollectionRepository, eventBusService = _a.eventBusService;
+        var manager = _a.manager, paymentCollectionRepository = _a.paymentCollectionRepository, paymentProviderService = _a.paymentProviderService, customerService = _a.customerService, eventBusService = _a.eventBusService;
         var _this = 
         // eslint-disable-next-line prefer-rest-params
         _super.call(this, arguments[0]) || this;
         _this.manager_ = manager;
         _this.paymentCollectionRepository_ = paymentCollectionRepository;
+        _this.paymentProviderService_ = paymentProviderService;
         _this.eventBusService_ = eventBusService;
+        _this.customerService_ = customerService;
         return _this;
     }
     PaymentCollectionService.prototype.retrieve = function (paymentCollectionId, config) {
@@ -89,13 +102,13 @@ var PaymentCollectionService = /** @class */ (function (_super) {
                         manager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
                         paymentCollectionRepository = manager.getCustomRepository(this.paymentCollectionRepository_);
                         query = (0, utils_1.buildQuery)({ id: paymentCollectionId }, config);
-                        return [4 /*yield*/, paymentCollectionRepository.findOne(query)];
+                        return [4 /*yield*/, paymentCollectionRepository.find(query)];
                     case 1:
                         paymentCollection = _b.sent();
-                        if (!paymentCollection) {
+                        if (!paymentCollection.length) {
                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Payment collection with id ".concat(paymentCollectionId, " was not found"));
                         }
-                        return [2 /*return*/, paymentCollection];
+                        return [2 /*return*/, paymentCollection[0]];
                 }
             });
         });
@@ -105,12 +118,12 @@ var PaymentCollectionService = /** @class */ (function (_super) {
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.atomicPhase_(function (transactionManager) { return __awaiter(_this, void 0, void 0, function () {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
                             var paymentCollectionRepository, paymentCollectionToCreate, paymentCollection;
                             return __generator(this, function (_a) {
                                 switch (_a.label) {
                                     case 0:
-                                        paymentCollectionRepository = transactionManager.getCustomRepository(this.paymentCollectionRepository_);
+                                        paymentCollectionRepository = manager.getCustomRepository(this.paymentCollectionRepository_);
                                         paymentCollectionToCreate = paymentCollectionRepository.create({
                                             region_id: data.region_id,
                                             type: data.type,
@@ -125,7 +138,7 @@ var PaymentCollectionService = /** @class */ (function (_super) {
                                     case 1:
                                         paymentCollection = _a.sent();
                                         return [4 /*yield*/, this.eventBusService_
-                                                .withTransaction(transactionManager)
+                                                .withTransaction(manager)
                                                 .emit(PaymentCollectionService.Events.CREATED, paymentCollection)];
                                     case 2:
                                         _a.sent();
@@ -228,10 +241,592 @@ var PaymentCollectionService = /** @class */ (function (_super) {
             });
         });
     };
+    PaymentCollectionService.prototype.isValidTotalAmount = function (total, sessionsInput) {
+        var sum = sessionsInput.reduce(function (cur, sess) { return cur + sess.amount; }, 0);
+        return total === sum;
+    };
+    PaymentCollectionService.prototype.setPaymentSessions = function (paymentCollectionId, sessions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sessionsInput;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sessionsInput = Array.isArray(sessions) ? sessions : [sessions];
+                        return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                                var paymentCollectionRepository, payCol, customer, selectedSessionIds, paymentSessions, _loop_1, this_1, sessionsInput_1, sessionsInput_1_1, session, e_2_1, removeIds;
+                                var e_2, _a;
+                                var _b, _c;
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0:
+                                            paymentCollectionRepository = manager.getCustomRepository(this.paymentCollectionRepository_);
+                                            return [4 /*yield*/, this.retrieve(paymentCollectionId, {
+                                                    relations: ["region", "region.payment_providers", "payment_sessions"],
+                                                })];
+                                        case 1:
+                                            payCol = _d.sent();
+                                            if (payCol.status !== models_1.PaymentCollectionStatus.NOT_PAID) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cannot set payment sessions for a payment collection with status ".concat(payCol.status));
+                                            }
+                                            sessionsInput = sessionsInput.filter(function (session) {
+                                                return !!payCol.region.payment_providers.find(function (_a) {
+                                                    var id = _a.id;
+                                                    return id === session.provider_id;
+                                                });
+                                            });
+                                            if (!this.isValidTotalAmount(payCol.amount, sessionsInput)) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.UNEXPECTED_STATE, "The sum of sessions is not equal to ".concat(payCol.amount, " on Payment Collection"));
+                                            }
+                                            customer = undefined;
+                                            selectedSessionIds = [];
+                                            paymentSessions = [];
+                                            _loop_1 = function (session) {
+                                                var existingSession, inputData, paymentSession, paymentSession;
+                                                return __generator(this, function (_e) {
+                                                    switch (_e.label) {
+                                                        case 0:
+                                                            if (!!customer) return [3 /*break*/, 2];
+                                                            return [4 /*yield*/, this_1.customerService_
+                                                                    .withTransaction(manager)
+                                                                    .retrieve(session.customer_id, {
+                                                                    select: ["id", "email", "metadata"],
+                                                                })];
+                                                        case 1:
+                                                            customer = _e.sent();
+                                                            _e.label = 2;
+                                                        case 2:
+                                                            existingSession = (_b = payCol.payment_sessions) === null || _b === void 0 ? void 0 : _b.find(function (sess) { return session.session_id === (sess === null || sess === void 0 ? void 0 : sess.id); });
+                                                            inputData = {
+                                                                resource_id: payCol.id,
+                                                                currency_code: payCol.currency_code,
+                                                                amount: session.amount,
+                                                                provider_id: session.provider_id,
+                                                                customer: customer,
+                                                                metadata: {
+                                                                    resource_id: payCol.id,
+                                                                },
+                                                            };
+                                                            if (!existingSession) return [3 /*break*/, 4];
+                                                            return [4 /*yield*/, this_1.paymentProviderService_
+                                                                    .withTransaction(manager)
+                                                                    .updateSessionNew(existingSession, inputData)];
+                                                        case 3:
+                                                            paymentSession = _e.sent();
+                                                            selectedSessionIds.push(existingSession.id);
+                                                            paymentSessions.push(paymentSession);
+                                                            return [3 /*break*/, 6];
+                                                        case 4: return [4 /*yield*/, this_1.paymentProviderService_
+                                                                .withTransaction(manager)
+                                                                .createSessionNew(inputData)];
+                                                        case 5:
+                                                            paymentSession = _e.sent();
+                                                            selectedSessionIds.push(paymentSession.id);
+                                                            paymentSessions.push(paymentSession);
+                                                            _e.label = 6;
+                                                        case 6: return [2 /*return*/];
+                                                    }
+                                                });
+                                            };
+                                            this_1 = this;
+                                            _d.label = 2;
+                                        case 2:
+                                            _d.trys.push([2, 7, 8, 9]);
+                                            sessionsInput_1 = __values(sessionsInput), sessionsInput_1_1 = sessionsInput_1.next();
+                                            _d.label = 3;
+                                        case 3:
+                                            if (!!sessionsInput_1_1.done) return [3 /*break*/, 6];
+                                            session = sessionsInput_1_1.value;
+                                            return [5 /*yield**/, _loop_1(session)];
+                                        case 4:
+                                            _d.sent();
+                                            _d.label = 5;
+                                        case 5:
+                                            sessionsInput_1_1 = sessionsInput_1.next();
+                                            return [3 /*break*/, 3];
+                                        case 6: return [3 /*break*/, 9];
+                                        case 7:
+                                            e_2_1 = _d.sent();
+                                            e_2 = { error: e_2_1 };
+                                            return [3 /*break*/, 9];
+                                        case 8:
+                                            try {
+                                                if (sessionsInput_1_1 && !sessionsInput_1_1.done && (_a = sessionsInput_1.return)) _a.call(sessionsInput_1);
+                                            }
+                                            finally { if (e_2) throw e_2.error; }
+                                            return [7 /*endfinally*/];
+                                        case 9:
+                                            if (!((_c = payCol.payment_sessions) === null || _c === void 0 ? void 0 : _c.length)) return [3 /*break*/, 11];
+                                            removeIds = payCol.payment_sessions
+                                                .map(function (sess) { return sess.id; })
+                                                .filter(function (id) { return !selectedSessionIds.includes(id); });
+                                            if (!removeIds.length) return [3 /*break*/, 11];
+                                            return [4 /*yield*/, paymentCollectionRepository.deleteMultiple(removeIds)];
+                                        case 10:
+                                            _d.sent();
+                                            _d.label = 11;
+                                        case 11:
+                                            payCol.payment_sessions = paymentSessions;
+                                            return [4 /*yield*/, paymentCollectionRepository.save(payCol)];
+                                        case 12: return [2 /*return*/, _d.sent()];
+                                    }
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    PaymentCollectionService.prototype.refreshPaymentSession = function (paymentCollectionId, sessionId, sessionInput) {
+        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 paymentCollectionRepository, payCol, session, customer, inputData, sessionRefreshed;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        paymentCollectionRepository = manager.getCustomRepository(this.paymentCollectionRepository_);
+                                        return [4 /*yield*/, paymentCollectionRepository.getPaymentCollectionIdBySessionId(sessionId, {
+                                                relations: [
+                                                    "region",
+                                                    "region.payment_providers",
+                                                    "payment_sessions",
+                                                ],
+                                            })];
+                                    case 1:
+                                        payCol = _a.sent();
+                                        if (paymentCollectionId !== payCol.id) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Payment Session ".concat(sessionId, " does not belong to Payment Collection ").concat(paymentCollectionId));
+                                        }
+                                        session = payCol.payment_sessions.find(function (sess) { return sessionId === (sess === null || sess === void 0 ? void 0 : sess.id); });
+                                        if ((session === null || session === void 0 ? void 0 : session.amount) !== sessionInput.amount) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "The amount has to be the same as the existing payment session");
+                                        }
+                                        return [4 /*yield*/, this.customerService_
+                                                .withTransaction(manager)
+                                                .retrieve(sessionInput.customer_id, {
+                                                select: ["id", "email", "metadata"],
+                                            })];
+                                    case 2:
+                                        customer = _a.sent();
+                                        inputData = {
+                                            resource_id: payCol.id,
+                                            currency_code: payCol.currency_code,
+                                            amount: session.amount,
+                                            provider_id: session.provider_id,
+                                            customer: customer,
+                                        };
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .refreshSessionNew(session, inputData)];
+                                    case 3:
+                                        sessionRefreshed = _a.sent();
+                                        payCol.payment_sessions = payCol.payment_sessions.map(function (sess) {
+                                            if (sess.id === sessionId) {
+                                                return sessionRefreshed;
+                                            }
+                                            return sess;
+                                        });
+                                        if (session.payment_authorized_at) {
+                                            payCol.authorized_amount -= session.amount;
+                                        }
+                                        return [4 /*yield*/, paymentCollectionRepository.save(payCol)];
+                                    case 4:
+                                        _a.sent();
+                                        return [2 /*return*/, sessionRefreshed];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    PaymentCollectionService.prototype.authorize = function (paymentCollectionId, context) {
+        if (context === void 0) { context = {}; }
+        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 paymentCollectionRepository, payCol, authorizedAmount, _a, _b, session, auth, inputData, _c, _d, e_3_1, payColCopy;
+                            var e_3, _e;
+                            var _f;
+                            return __generator(this, function (_g) {
+                                switch (_g.label) {
+                                    case 0:
+                                        paymentCollectionRepository = manager.getCustomRepository(this.paymentCollectionRepository_);
+                                        return [4 /*yield*/, this.retrieve(paymentCollectionId, {
+                                                relations: ["payment_sessions", "payments"],
+                                            })];
+                                    case 1:
+                                        payCol = _g.sent();
+                                        if (payCol.authorized_amount === payCol.amount) {
+                                            return [2 /*return*/, payCol];
+                                        }
+                                        if (!(payCol.amount <= 0)) return [3 /*break*/, 3];
+                                        payCol.authorized_amount = 0;
+                                        return [4 /*yield*/, paymentCollectionRepository.save(payCol)];
+                                    case 2: return [2 /*return*/, _g.sent()];
+                                    case 3:
+                                        if (!((_f = payCol.payment_sessions) === null || _f === void 0 ? void 0 : _f.length)) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "You cannot complete a Payment Collection without a payment session.");
+                                        }
+                                        authorizedAmount = 0;
+                                        _g.label = 4;
+                                    case 4:
+                                        _g.trys.push([4, 10, 11, 12]);
+                                        _a = __values(payCol.payment_sessions), _b = _a.next();
+                                        _g.label = 5;
+                                    case 5:
+                                        if (!!_b.done) return [3 /*break*/, 9];
+                                        session = _b.value;
+                                        if (session.payment_authorized_at) {
+                                            authorizedAmount += session.amount;
+                                            return [3 /*break*/, 8];
+                                        }
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .authorizePayment(session, context)];
+                                    case 6:
+                                        auth = _g.sent();
+                                        if (!((auth === null || auth === void 0 ? void 0 : auth.status) === models_1.PaymentSessionStatus.AUTHORIZED)) return [3 /*break*/, 8];
+                                        authorizedAmount += session.amount;
+                                        inputData = {
+                                            amount: session.amount,
+                                            currency_code: payCol.currency_code,
+                                            provider_id: session.provider_id,
+                                            resource_id: payCol.id,
+                                        };
+                                        _d = (_c = payCol.payments).push;
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .createPaymentNew(inputData)];
+                                    case 7:
+                                        _d.apply(_c, [_g.sent()]);
+                                        _g.label = 8;
+                                    case 8:
+                                        _b = _a.next();
+                                        return [3 /*break*/, 5];
+                                    case 9: return [3 /*break*/, 12];
+                                    case 10:
+                                        e_3_1 = _g.sent();
+                                        e_3 = { error: e_3_1 };
+                                        return [3 /*break*/, 12];
+                                    case 11:
+                                        try {
+                                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                                        }
+                                        finally { if (e_3) throw e_3.error; }
+                                        return [7 /*endfinally*/];
+                                    case 12:
+                                        if (authorizedAmount === 0) {
+                                            payCol.status = models_1.PaymentCollectionStatus.AWAITING;
+                                        }
+                                        else if (authorizedAmount < payCol.amount) {
+                                            payCol.status = models_1.PaymentCollectionStatus.PARTIALLY_AUTHORIZED;
+                                        }
+                                        else if (authorizedAmount === payCol.amount) {
+                                            payCol.status = models_1.PaymentCollectionStatus.AUTHORIZED;
+                                        }
+                                        payCol.authorized_amount = authorizedAmount;
+                                        return [4 /*yield*/, paymentCollectionRepository.save(payCol)];
+                                    case 13:
+                                        payColCopy = _g.sent();
+                                        return [4 /*yield*/, this.eventBusService_
+                                                .withTransaction(manager)
+                                                .emit(PaymentCollectionService.Events.PAYMENT_AUTHORIZED, payColCopy)];
+                                    case 14:
+                                        _g.sent();
+                                        return [2 /*return*/, payCol];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    PaymentCollectionService.prototype.capturePayment = function (payCol, payment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (payment === null || payment === void 0 ? void 0 : payment.captured_at) {
+                            return [2 /*return*/, payment];
+                        }
+                        return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                                var allowedStatuses, captureError, capturedPayment, paymentCollectionRepository;
+                                var _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            allowedStatuses = [
+                                                models_1.PaymentCollectionStatus.AUTHORIZED,
+                                                models_1.PaymentCollectionStatus.PARTIALLY_CAPTURED,
+                                                models_1.PaymentCollectionStatus.REQUIRES_ACTION,
+                                            ];
+                                            if (!allowedStatuses.includes(payCol.status)) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A Payment Collection with status ".concat(payCol.status, " cannot capture payment"));
+                                            }
+                                            captureError = null;
+                                            return [4 /*yield*/, this.paymentProviderService_
+                                                    .withTransaction(manager)
+                                                    .capturePayment(payment)
+                                                    .catch(function (err) {
+                                                    captureError = err;
+                                                })];
+                                        case 1:
+                                            capturedPayment = _b.sent();
+                                            payCol.captured_amount = (_a = payCol.captured_amount) !== null && _a !== void 0 ? _a : 0;
+                                            if (capturedPayment) {
+                                                payCol.captured_amount += payment.amount;
+                                            }
+                                            if (payCol.captured_amount === 0) {
+                                                payCol.status = models_1.PaymentCollectionStatus.REQUIRES_ACTION;
+                                            }
+                                            else if (payCol.captured_amount === payCol.amount) {
+                                                payCol.status = models_1.PaymentCollectionStatus.CAPTURED;
+                                            }
+                                            else {
+                                                payCol.status = models_1.PaymentCollectionStatus.PARTIALLY_CAPTURED;
+                                            }
+                                            paymentCollectionRepository = manager.getCustomRepository(this.paymentCollectionRepository_);
+                                            return [4 /*yield*/, paymentCollectionRepository.save(payCol)];
+                                        case 2:
+                                            _b.sent();
+                                            if (!!capturedPayment) return [3 /*break*/, 4];
+                                            return [4 /*yield*/, this.eventBusService_
+                                                    .withTransaction(manager)
+                                                    .emit(PaymentCollectionService.Events.PAYMENT_CAPTURE_FAILED, __assign(__assign({}, payment), { error: captureError }))];
+                                        case 3:
+                                            _b.sent();
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to capture Payment ".concat(payment.id));
+                                        case 4: return [4 /*yield*/, this.eventBusService_
+                                                .withTransaction(manager)
+                                                .emit(PaymentCollectionService.Events.PAYMENT_CAPTURED, capturedPayment)];
+                                        case 5:
+                                            _b.sent();
+                                            return [2 /*return*/, capturedPayment];
+                                    }
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    PaymentCollectionService.prototype.capture = function (paymentId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var manager, paymentCollectionRepository, payCol, payment;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        manager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        paymentCollectionRepository = manager.getCustomRepository(this.paymentCollectionRepository_);
+                        return [4 /*yield*/, paymentCollectionRepository.getPaymentCollectionIdByPaymentId(paymentId, {
+                                relations: ["payments"],
+                            })];
+                    case 1:
+                        payCol = _b.sent();
+                        payment = payCol.payments.find(function (payment) { return paymentId === (payment === null || payment === void 0 ? void 0 : payment.id); });
+                        return [4 /*yield*/, this.capturePayment(payCol, payment)];
+                    case 2: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    PaymentCollectionService.prototype.captureAll = function (paymentCollectionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payCol, allPayments, _a, _b, payment, captured, e_4_1;
+            var e_4, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.retrieve(paymentCollectionId, {
+                            relations: ["payments"],
+                        })];
+                    case 1:
+                        payCol = _d.sent();
+                        allPayments = [];
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = __values(payCol.payments), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        payment = _b.value;
+                        return [4 /*yield*/, this.capturePayment(payCol, payment).catch(function () { return void 0; })];
+                    case 4:
+                        captured = _d.sent();
+                        if (captured) {
+                            allPayments.push(captured);
+                        }
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_4_1 = _d.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/, allPayments];
+                }
+            });
+        });
+    };
+    PaymentCollectionService.prototype.refundPayment = function (payCol, payment, amount, reason, note) {
+        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 refundable, refundError, refund, paymentCollectionRepository;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        if (!payment.captured_at) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Payment ".concat(payment.id, " is not captured"));
+                                        }
+                                        refundable = payment.amount - payment.amount_refunded;
+                                        if (amount > refundable) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Only ".concat(refundable, " can be refunded from Payment ").concat(payment.id));
+                                        }
+                                        refundError = null;
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .refundFromPayment(payment, amount, reason, note)
+                                                .catch(function (err) {
+                                                refundError = err;
+                                            })];
+                                    case 1:
+                                        refund = _b.sent();
+                                        payCol.refunded_amount = (_a = payCol.refunded_amount) !== null && _a !== void 0 ? _a : 0;
+                                        if (refund) {
+                                            payCol.refunded_amount += refund.amount;
+                                        }
+                                        if (payCol.refunded_amount === 0) {
+                                            payCol.status = models_1.PaymentCollectionStatus.REQUIRES_ACTION;
+                                        }
+                                        else if (payCol.refunded_amount === payCol.amount) {
+                                            payCol.status = models_1.PaymentCollectionStatus.REFUNDED;
+                                        }
+                                        else {
+                                            payCol.status = models_1.PaymentCollectionStatus.PARTIALLY_REFUNDED;
+                                        }
+                                        paymentCollectionRepository = manager.getCustomRepository(this.paymentCollectionRepository_);
+                                        return [4 /*yield*/, paymentCollectionRepository.save(payCol)];
+                                    case 2:
+                                        _b.sent();
+                                        if (!!refund) return [3 /*break*/, 4];
+                                        return [4 /*yield*/, this.eventBusService_
+                                                .withTransaction(manager)
+                                                .emit(PaymentCollectionService.Events.REFUND_FAILED, __assign(__assign({}, payment), { error: refundError }))];
+                                    case 3:
+                                        _b.sent();
+                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to refund Payment ".concat(payment.id));
+                                    case 4: return [4 /*yield*/, this.eventBusService_
+                                            .withTransaction(manager)
+                                            .emit(PaymentCollectionService.Events.REFUND_CREATED, refund)];
+                                    case 5:
+                                        _b.sent();
+                                        return [2 /*return*/, refund];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    PaymentCollectionService.prototype.refund = function (paymentId, amount, reason, note) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var manager, paymentCollectionRepository, payCol, payment;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        manager = (_a = this.transactionManager_) !== null && _a !== void 0 ? _a : this.manager_;
+                        paymentCollectionRepository = manager.getCustomRepository(this.paymentCollectionRepository_);
+                        return [4 /*yield*/, paymentCollectionRepository.getPaymentCollectionIdByPaymentId(paymentId)];
+                    case 1:
+                        payCol = _b.sent();
+                        return [4 /*yield*/, this.paymentProviderService_.retrievePayment(paymentId)];
+                    case 2:
+                        payment = _b.sent();
+                        return [4 /*yield*/, this.refundPayment(payCol, payment, amount, reason, note)];
+                    case 3: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    PaymentCollectionService.prototype.refundAll = function (paymentCollectionId, reason, note) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payCol, allRefunds, _a, _b, payment, refunded, e_5_1;
+            var e_5, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.retrieve(paymentCollectionId, {
+                            relations: ["payments"],
+                        })];
+                    case 1:
+                        payCol = _d.sent();
+                        allRefunds = [];
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = __values(payCol.payments), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        payment = _b.value;
+                        return [4 /*yield*/, this.refundPayment(payCol, payment, payment.amount, reason, note).catch(function () { return void 0; })];
+                    case 4:
+                        refunded = _d.sent();
+                        if (refunded) {
+                            allRefunds.push(refunded);
+                        }
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_5_1 = _d.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/, allRefunds];
+                }
+            });
+        });
+    };
     PaymentCollectionService.Events = {
         CREATED: "payment-collection.created",
         UPDATED: "payment-collection.updated",
         DELETED: "payment-collection.deleted",
+        PAYMENT_AUTHORIZED: "payment-collection.payment_authorized",
+        PAYMENT_CAPTURED: "payment-collection.payment_captured",
+        PAYMENT_CAPTURE_FAILED: "payment-collection.payment_capture_failed",
+        REFUND_CREATED: "payment-collection.payment_refund_created",
+        REFUND_FAILED: "payment-collection.payment_refund_failed",
     };
     return PaymentCollectionService;
 }(interfaces_1.TransactionBaseService));