@medusajs/medusa 1.1.52 → 1.1.56

package/dist/api/routes/store/carts/complete-cart.js

@@ -1,24 +1,53 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _medusaCoreUtils = require("medusa-core-utils");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var medusa_core_utils_1 = require("medusa-core-utils");
 /**
  * @oas [post] /carts/{id}/complete
  * summary: "Complete a Cart"
@@ -52,380 +81,252 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
  *                cart:
  *                  $ref: "#/components/schemas/cart"
  */
-var _default = /*#__PURE__*/function () {
-  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(req, res) {
-    var id, idempotencyKeyService, headerKey, idempotencyKey;
-    return _regenerator["default"].wrap(function _callee4$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            id = req.params.id;
-            idempotencyKeyService = req.scope.resolve("idempotencyKeyService");
-            headerKey = req.get("Idempotency-Key") || "";
-            _context4.prev = 3;
-            _context4.next = 6;
-            return idempotencyKeyService.initializeRequest(headerKey, req.method, req.params, req.path);
-
-          case 6:
-            idempotencyKey = _context4.sent;
-            _context4.next = 14;
-            break;
-
-          case 9:
-            _context4.prev = 9;
-            _context4.t0 = _context4["catch"](3);
-            console.log(_context4.t0);
-            res.status(409).send("Failed to create idempotency key");
-            return _context4.abrupt("return");
-
-          case 14:
-            res.setHeader("Access-Control-Expose-Headers", "Idempotency-Key");
-            res.setHeader("Idempotency-Key", idempotencyKey.idempotency_key);
-            _context4.prev = 16;
-            return _context4.delegateYield( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
-              var cartService, orderService, swapService, inProgress, err, _yield$idempotencyKey, key, error, _yield$idempotencyKey2, _key, _error;
-
-              return _regenerator["default"].wrap(function _callee3$(_context3) {
-                while (1) {
-                  switch (_context3.prev = _context3.next) {
-                    case 0:
-                      cartService = req.scope.resolve("cartService");
-                      orderService = req.scope.resolve("orderService");
-                      swapService = req.scope.resolve("swapService");
-                      inProgress = true;
-                      err = false;
-
-                    case 5:
-                      if (!inProgress) {
-                        _context3.next = 31;
-                        break;
-                      }
-
-                      _context3.t0 = idempotencyKey.recovery_point;
-                      _context3.next = _context3.t0 === "started" ? 9 : _context3.t0 === "payment_authorized" ? 16 : _context3.t0 === "finished" ? 23 : 25;
-                      break;
-
-                    case 9:
-                      _context3.next = 11;
-                      return idempotencyKeyService.workStage(idempotencyKey.idempotency_key, /*#__PURE__*/function () {
-                        var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(manager) {
-                          var cart;
-                          return _regenerator["default"].wrap(function _callee$(_context) {
-                            while (1) {
-                              switch (_context.prev = _context.next) {
-                                case 0:
-                                  _context.next = 2;
-                                  return cartService.withTransaction(manager).retrieve(id);
-
-                                case 2:
-                                  cart = _context.sent;
-
-                                  if (!cart.completed_at) {
-                                    _context.next = 5;
-                                    break;
-                                  }
-
-                                  return _context.abrupt("return", {
-                                    response_code: 409,
-                                    response_body: {
-                                      code: _medusaCoreUtils.MedusaError.Codes.CART_INCOMPATIBLE_STATE,
-                                      message: "Cart has already been completed",
-                                      type: _medusaCoreUtils.MedusaError.Types.NOT_ALLOWED
-                                    }
-                                  });
-
-                                case 5:
-                                  _context.next = 7;
-                                  return cartService.withTransaction(manager).authorizePayment(id, _objectSpread(_objectSpread({}, req.request_context), {}, {
-                                    idempotency_key: idempotencyKey.idempotency_key
-                                  }));
-
-                                case 7:
-                                  cart = _context.sent;
-
-                                  if (!cart.payment_session) {
-                                    _context.next = 11;
-                                    break;
-                                  }
-
-                                  if (!(cart.payment_session.status === "requires_more" || cart.payment_session.status === "pending")) {
-                                    _context.next = 11;
-                                    break;
-                                  }
-
-                                  return _context.abrupt("return", {
-                                    response_code: 200,
-                                    response_body: {
-                                      data: cart,
-                                      payment_status: cart.payment_session.status,
-                                      type: "cart"
+exports.default = (function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+    var id, idempotencyKeyService, headerKey, idempotencyKey, error_1, cartService, orderService, swapService, inProgress, err, _a, _b, key, error, _c, key, error;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                id = req.params.id;
+                idempotencyKeyService = req.scope.resolve("idempotencyKeyService");
+                headerKey = req.get("Idempotency-Key") || "";
+                _d.label = 1;
+            case 1:
+                _d.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, idempotencyKeyService.initializeRequest(headerKey, req.method, req.params, req.path)];
+            case 2:
+                idempotencyKey = _d.sent();
+                return [3 /*break*/, 4];
+            case 3:
+                error_1 = _d.sent();
+                console.log(error_1);
+                res.status(409).send("Failed to create idempotency key");
+                return [2 /*return*/];
+            case 4:
+                res.setHeader("Access-Control-Expose-Headers", "Idempotency-Key");
+                res.setHeader("Idempotency-Key", idempotencyKey.idempotency_key);
+                cartService = req.scope.resolve("cartService");
+                orderService = req.scope.resolve("orderService");
+                swapService = req.scope.resolve("swapService");
+                inProgress = true;
+                err = false;
+                _d.label = 5;
+            case 5:
+                if (!inProgress) return [3 /*break*/, 14];
+                _a = idempotencyKey.recovery_point;
+                switch (_a) {
+                    case "started": return [3 /*break*/, 6];
+                    case "payment_authorized": return [3 /*break*/, 8];
+                    case "finished": return [3 /*break*/, 10];
+                }
+                return [3 /*break*/, 11];
+            case 6: return [4 /*yield*/, idempotencyKeyService.workStage(idempotencyKey.idempotency_key, function (manager) { return __awaiter(void 0, void 0, void 0, function () {
+                    var cart;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, cartService.withTransaction(manager).retrieve(id)];
+                            case 1:
+                                cart = _a.sent();
+                                if (cart.completed_at) {
+                                    return [2 /*return*/, {
+                                            response_code: 409,
+                                            response_body: {
+                                                code: medusa_core_utils_1.MedusaError.Codes.CART_INCOMPATIBLE_STATE,
+                                                message: "Cart has already been completed",
+                                                type: medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED,
+                                            },
+                                        }];
+                                }
+                                return [4 /*yield*/, cartService
+                                        .withTransaction(manager)
+                                        .authorizePayment(id, __assign(__assign({}, req.request_context), { idempotency_key: idempotencyKey.idempotency_key }))];
+                            case 2:
+                                cart = _a.sent();
+                                if (cart.payment_session) {
+                                    if (cart.payment_session.status === "requires_more" ||
+                                        cart.payment_session.status === "pending") {
+                                        return [2 /*return*/, {
+                                                response_code: 200,
+                                                response_body: {
+                                                    data: cart,
+                                                    payment_status: cart.payment_session.status,
+                                                    type: "cart",
+                                                },
+                                            }];
                                     }
-                                  });
-
-                                case 11:
-                                  return _context.abrupt("return", {
-                                    recovery_point: "payment_authorized"
-                                  });
-
-                                case 12:
-                                case "end":
-                                  return _context.stop();
-                              }
-                            }
-                          }, _callee);
-                        }));
-
-                        return function (_x3) {
-                          return _ref2.apply(this, arguments);
-                        };
-                      }());
-
-                    case 11:
-                      _yield$idempotencyKey = _context3.sent;
-                      key = _yield$idempotencyKey.key;
-                      error = _yield$idempotencyKey.error;
-
-                      if (error) {
-                        inProgress = false;
-                        err = error;
-                      } else {
-                        idempotencyKey = key;
-                      }
-
-                      return _context3.abrupt("break", 29);
-
-                    case 16:
-                      _context3.next = 18;
-                      return idempotencyKeyService.workStage(idempotencyKey.idempotency_key, /*#__PURE__*/function () {
-                        var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(manager) {
-                          var cart, order, _cart$metadata, swapId, swap;
-
-                          return _regenerator["default"].wrap(function _callee2$(_context2) {
-                            while (1) {
-                              switch (_context2.prev = _context2.next) {
-                                case 0:
-                                  _context2.next = 2;
-                                  return cartService.withTransaction(manager).retrieve(id, {
+                                }
+                                return [2 /*return*/, {
+                                        recovery_point: "payment_authorized",
+                                    }];
+                        }
+                    });
+                }); })];
+            case 7:
+                _b = _d.sent(), key = _b.key, error = _b.error;
+                if (error) {
+                    inProgress = false;
+                    err = error;
+                }
+                else {
+                    idempotencyKey = key;
+                }
+                return [3 /*break*/, 13];
+            case 8: return [4 /*yield*/, idempotencyKeyService.workStage(idempotencyKey.idempotency_key, function (manager) { return __awaiter(void 0, void 0, void 0, function () {
+                    var cart, order, _a, swapId, swap, error_2, error_3;
+                    var _b;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0: return [4 /*yield*/, cartService
+                                    .withTransaction(manager)
+                                    .retrieve(id, {
                                     select: ["total"],
-                                    relations: ["payment", "payment_sessions"]
-                                  });
-
-                                case 2:
-                                  cart = _context2.sent;
-                                  _context2.t0 = cart.type;
-                                  _context2.next = _context2.t0 === "swap" ? 6 : 24;
-                                  break;
-
-                                case 6:
-                                  _context2.prev = 6;
-                                  swapId = (_cart$metadata = cart.metadata) === null || _cart$metadata === void 0 ? void 0 : _cart$metadata.swap_id;
-                                  _context2.next = 10;
-                                  return swapService.withTransaction(manager).registerCartCompletion(swapId);
-
-                                case 10:
-                                  swap = _context2.sent;
-                                  _context2.next = 13;
-                                  return swapService.withTransaction(manager).retrieve(swap.id, {
-                                    relations: ["shipping_address"]
-                                  });
-
-                                case 13:
-                                  swap = _context2.sent;
-                                  return _context2.abrupt("return", {
-                                    response_code: 200,
-                                    response_body: {
-                                      data: swap,
-                                      type: "swap"
-                                    }
-                                  });
-
-                                case 17:
-                                  _context2.prev = 17;
-                                  _context2.t1 = _context2["catch"](6);
-
-                                  if (!(_context2.t1 && _context2.t1.code === _medusaCoreUtils.MedusaError.Codes.INSUFFICIENT_INVENTORY)) {
-                                    _context2.next = 23;
-                                    break;
-                                  }
-
-                                  return _context2.abrupt("return", {
-                                    response_code: 409,
-                                    response_body: {
-                                      message: _context2.t1.message,
-                                      type: _context2.t1.type,
-                                      code: _context2.t1.code
-                                    }
-                                  });
-
-                                case 23:
-                                  throw _context2.t1;
-
-                                case 24:
-                                  if (!(!cart.payment && cart.total > 0)) {
-                                    _context2.next = 26;
-                                    break;
-                                  }
-
-                                  throw new _medusaCoreUtils.MedusaError(_medusaCoreUtils.MedusaError.Types.INVALID_DATA, "Cart payment not authorized");
-
-                                case 26:
-                                  _context2.prev = 26;
-                                  _context2.next = 29;
-                                  return orderService.withTransaction(manager).createFromCart(cart.id);
-
-                                case 29:
-                                  order = _context2.sent;
-                                  _context2.next = 46;
-                                  break;
-
-                                case 32:
-                                  _context2.prev = 32;
-                                  _context2.t2 = _context2["catch"](26);
-
-                                  if (!(_context2.t2 && _context2.t2.message === "Order from cart already exists")) {
-                                    _context2.next = 41;
-                                    break;
-                                  }
-
-                                  _context2.next = 37;
-                                  return orderService.withTransaction(manager).retrieveByCartId(id, {
-                                    select: ["subtotal", "tax_total", "shipping_total", "discount_total", "total"],
-                                    relations: ["shipping_address", "items", "payments"]
-                                  });
-
-                                case 37:
-                                  order = _context2.sent;
-                                  return _context2.abrupt("return", {
-                                    response_code: 200,
-                                    response_body: {
-                                      data: order,
-                                      type: "order"
-                                    }
-                                  });
-
-                                case 41:
-                                  if (!(_context2.t2 && _context2.t2.code === _medusaCoreUtils.MedusaError.Codes.INSUFFICIENT_INVENTORY)) {
-                                    _context2.next = 45;
-                                    break;
-                                  }
-
-                                  return _context2.abrupt("return", {
-                                    response_code: 409,
-                                    response_body: {
-                                      message: _context2.t2.message,
-                                      type: _context2.t2.type,
-                                      code: _context2.t2.code
-                                    }
-                                  });
-
-                                case 45:
-                                  throw _context2.t2;
-
-                                case 46:
-                                  _context2.next = 48;
-                                  return orderService.withTransaction(manager).retrieve(order.id, {
-                                    select: ["subtotal", "tax_total", "shipping_total", "discount_total", "total"],
-                                    relations: ["shipping_address", "items", "payments"]
-                                  });
-
-                                case 48:
-                                  order = _context2.sent;
-                                  return _context2.abrupt("return", {
-                                    response_code: 200,
-                                    response_body: {
-                                      data: order,
-                                      type: "order"
-                                    }
-                                  });
-
-                                case 50:
-                                case "end":
-                                  return _context2.stop();
-                              }
-                            }
-                          }, _callee2, null, [[6, 17], [26, 32]]);
-                        }));
-
-                        return function (_x4) {
-                          return _ref3.apply(this, arguments);
-                        };
-                      }());
-
-                    case 18:
-                      _yield$idempotencyKey2 = _context3.sent;
-                      _key = _yield$idempotencyKey2.key;
-                      _error = _yield$idempotencyKey2.error;
-
-                      if (_error) {
-                        inProgress = false;
-                        err = _error;
-                      } else {
-                        idempotencyKey = _key;
-                      }
-
-                      return _context3.abrupt("break", 29);
-
-                    case 23:
-                      inProgress = false;
-                      return _context3.abrupt("break", 29);
-
-                    case 25:
-                      _context3.next = 27;
-                      return idempotencyKeyService.update(idempotencyKey.idempotency_key, {
-                        recovery_point: "finished",
-                        response_code: 500,
-                        response_body: {
-                          message: "Unknown recovery point"
+                                    relations: ["payment", "payment_sessions"],
+                                })];
+                            case 1:
+                                cart = _c.sent();
+                                _a = cart.type;
+                                switch (_a) {
+                                    case "swap": return [3 /*break*/, 2];
+                                }
+                                return [3 /*break*/, 6];
+                            case 2:
+                                _c.trys.push([2, 5, , 6]);
+                                swapId = (_b = cart.metadata) === null || _b === void 0 ? void 0 : _b.swap_id;
+                                return [4 /*yield*/, swapService
+                                        .withTransaction(manager)
+                                        .registerCartCompletion(swapId)];
+                            case 3:
+                                swap = _c.sent();
+                                return [4 /*yield*/, swapService
+                                        .withTransaction(manager)
+                                        .retrieve(swap.id, { relations: ["shipping_address"] })];
+                            case 4:
+                                swap = _c.sent();
+                                return [2 /*return*/, {
+                                        response_code: 200,
+                                        response_body: { data: swap, type: "swap" },
+                                    }];
+                            case 5:
+                                error_2 = _c.sent();
+                                if (error_2 &&
+                                    error_2.code === medusa_core_utils_1.MedusaError.Codes.INSUFFICIENT_INVENTORY) {
+                                    return [2 /*return*/, {
+                                            response_code: 409,
+                                            response_body: {
+                                                message: error_2.message,
+                                                type: error_2.type,
+                                                code: error_2.code,
+                                            },
+                                        }];
+                                }
+                                else {
+                                    throw error_2;
+                                }
+                                return [3 /*break*/, 6];
+                            case 6:
+                                if (!cart.payment && cart.total > 0) {
+                                    throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Cart payment not authorized");
+                                }
+                                _c.label = 7;
+                            case 7:
+                                _c.trys.push([7, 9, , 13]);
+                                return [4 /*yield*/, orderService
+                                        .withTransaction(manager)
+                                        .createFromCart(cart.id)];
+                            case 8:
+                                order = _c.sent();
+                                return [3 /*break*/, 13];
+                            case 9:
+                                error_3 = _c.sent();
+                                if (!(error_3 &&
+                                    error_3.message === "Order from cart already exists")) return [3 /*break*/, 11];
+                                return [4 /*yield*/, orderService
+                                        .withTransaction(manager)
+                                        .retrieveByCartId(id, {
+                                        select: [
+                                            "subtotal",
+                                            "tax_total",
+                                            "shipping_total",
+                                            "discount_total",
+                                            "total",
+                                        ],
+                                        relations: ["shipping_address", "items", "payments"],
+                                    })];
+                            case 10:
+                                order = _c.sent();
+                                return [2 /*return*/, {
+                                        response_code: 200,
+                                        response_body: { data: order, type: "order" },
+                                    }];
+                            case 11:
+                                if (error_3 &&
+                                    error_3.code === medusa_core_utils_1.MedusaError.Codes.INSUFFICIENT_INVENTORY) {
+                                    return [2 /*return*/, {
+                                            response_code: 409,
+                                            response_body: {
+                                                message: error_3.message,
+                                                type: error_3.type,
+                                                code: error_3.code,
+                                            },
+                                        }];
+                                }
+                                else {
+                                    throw error_3;
+                                }
+                                _c.label = 12;
+                            case 12: return [3 /*break*/, 13];
+                            case 13: return [4 /*yield*/, orderService
+                                    .withTransaction(manager)
+                                    .retrieve(order.id, {
+                                    select: [
+                                        "subtotal",
+                                        "tax_total",
+                                        "shipping_total",
+                                        "discount_total",
+                                        "total",
+                                    ],
+                                    relations: ["shipping_address", "items", "payments"],
+                                })];
+                            case 14:
+                                order = _c.sent();
+                                return [2 /*return*/, {
+                                        response_code: 200,
+                                        response_body: { data: order, type: "order" },
+                                    }];
                         }
-                      });
-
-                    case 27:
-                      idempotencyKey = _context3.sent;
-                      return _context3.abrupt("break", 29);
-
-                    case 29:
-                      _context3.next = 5;
-                      break;
-
-                    case 31:
-                      if (!err) {
-                        _context3.next = 33;
-                        break;
-                      }
-
-                      throw err;
-
-                    case 33:
-                      res.status(idempotencyKey.response_code).json(idempotencyKey.response_body);
-
-                    case 34:
-                    case "end":
-                      return _context3.stop();
-                  }
+                    });
+                }); })];
+            case 9:
+                _c = _d.sent(), key = _c.key, error = _c.error;
+                if (error) {
+                    inProgress = false;
+                    err = error;
+                }
+                else {
+                    idempotencyKey = key;
+                }
+                return [3 /*break*/, 13];
+            case 10:
+                {
+                    inProgress = false;
+                    return [3 /*break*/, 13];
+                }
+                _d.label = 11;
+            case 11: return [4 /*yield*/, idempotencyKeyService.update(idempotencyKey.idempotency_key, {
+                    recovery_point: "finished",
+                    response_code: 500,
+                    response_body: { message: "Unknown recovery point" },
+                })];
+            case 12:
+                idempotencyKey = _d.sent();
+                return [3 /*break*/, 13];
+            case 13: return [3 /*break*/, 5];
+            case 14:
+                if (err) {
+                    throw err;
                 }
-              }, _callee3);
-            })(), "t1", 18);
-
-          case 18:
-            _context4.next = 23;
-            break;
-
-          case 20:
-            _context4.prev = 20;
-            _context4.t2 = _context4["catch"](16);
-            throw _context4.t2;
-
-          case 23:
-          case "end":
-            return _context4.stop();
+                res.status(idempotencyKey.response_code).json(idempotencyKey.response_body);
+                return [2 /*return*/];
         }
-      }
-    }, _callee4, null, [[3, 9], [16, 20]]);
-  }));
-
-  return function (_x, _x2) {
-    return _ref.apply(this, arguments);
-  };
-}();
-
-exports["default"] = _default;
+    });
+}); });
+//# sourceMappingURL=complete-cart.js.map