@ai-ecom/medusa-plugin-patient-record
Version:
A plugin for patient record
299 lines (293 loc) • 12 kB
JavaScript
"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 _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _utils = require("@medusajs/medusa/dist/utils");
// Import from dist to avoid circular deps which result in the base service to be undefined
/**
* Common functionality for Services
* @interface
* @deprecated use TransactionBaseService from @medusajs/medusa instead
*/
var BaseService = exports["default"] = /*#__PURE__*/function () {
function BaseService() {
(0, _classCallCheck2["default"])(this, BaseService);
this.decorators_ = [];
}
return (0, _createClass2["default"])(BaseService, [{
key: "withTransaction",
value: function withTransaction() {
console.log("WARN: withTransaction called without custom implementation");
return this;
}
/**
* Used to build TypeORM queries.
*/
}, {
key: "buildQuery_",
value: function buildQuery_(selector) {
var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
return (0, _utils.buildQuery)(selector, config);
}
/**
* Confirms whether a given raw id is valid. Fails if the provided
* id is null or undefined. The validate function takes an optional config
* param, to support checking id prefix and length.
* @param {string} rawId - the id to validate.
* @param {object?} config - optional config
* @returns {string} the rawId given that nothing failed
*/
}, {
key: "validateId_",
value: function validateId_(rawId) {
var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
return (0, _utils.validateId)(rawId, config);
}
}, {
key: "shouldRetryTransaction",
value: function shouldRetryTransaction(err) {
var code = (0, _typeof2["default"])(err) === "object" ? String(err.code) : null;
return code === "40001" || code === "40P01";
}
/**
* Wraps some work within a transactional block. If the service already has
* a transaction manager attached this will be reused, otherwise a new
* transaction manager is created.
* @param {function} work - the transactional work to be done
* @param {string} isolation - the isolation level to be used for the work.
* @return {any} the result of the transactional work
*/
}, {
key: "atomicPhase_",
value: (function () {
var _atomicPhase_ = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(work, isolationOrErrorHandler, maybeErrorHandlerOrDontFail) {
var _this = this;
var errorHandler, isolation, dontFail, doWork, temp, _doWork, result, _result;
return _regenerator["default"].wrap(function _callee3$(_context3) {
while (1) switch (_context3.prev = _context3.next) {
case 0:
errorHandler = maybeErrorHandlerOrDontFail;
isolation = isolationOrErrorHandler;
dontFail = false;
if (typeof isolationOrErrorHandler === "function") {
isolation = null;
errorHandler = isolationOrErrorHandler;
dontFail = !!maybeErrorHandlerOrDontFail;
}
if (!this.transactionManager_) {
_context3.next = 9;
break;
}
doWork = /*#__PURE__*/function () {
var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(m) {
var result, queryRunner;
return _regenerator["default"].wrap(function _callee$(_context) {
while (1) switch (_context.prev = _context.next) {
case 0:
_this.manager_ = m;
_this.transactionManager_ = m;
_context.prev = 2;
_context.next = 5;
return work(m);
case 5:
result = _context.sent;
return _context.abrupt("return", result);
case 9:
_context.prev = 9;
_context.t0 = _context["catch"](2);
if (!errorHandler) {
_context.next = 18;
break;
}
queryRunner = _this.transactionManager_.queryRunner;
if (!queryRunner.isTransactionActive) {
_context.next = 16;
break;
}
_context.next = 16;
return queryRunner.rollbackTransaction();
case 16:
_context.next = 18;
return errorHandler(_context.t0);
case 18:
throw _context.t0;
case 19:
case "end":
return _context.stop();
}
}, _callee, null, [[2, 9]]);
}));
return function doWork(_x4) {
return _ref.apply(this, arguments);
};
}();
return _context3.abrupt("return", doWork(this.transactionManager_));
case 9:
temp = this.manager_;
_doWork = /*#__PURE__*/function () {
var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(m) {
var result;
return _regenerator["default"].wrap(function _callee2$(_context2) {
while (1) switch (_context2.prev = _context2.next) {
case 0:
_this.manager_ = m;
_this.transactionManager_ = m;
_context2.prev = 2;
_context2.next = 5;
return work(m);
case 5:
result = _context2.sent;
_this.manager_ = temp;
_this.transactionManager_ = undefined;
return _context2.abrupt("return", result);
case 11:
_context2.prev = 11;
_context2.t0 = _context2["catch"](2);
_this.manager_ = temp;
_this.transactionManager_ = undefined;
throw _context2.t0;
case 16:
case "end":
return _context2.stop();
}
}, _callee2, null, [[2, 11]]);
}));
return function _doWork(_x5) {
return _ref2.apply(this, arguments);
};
}();
if (!isolation) {
_context3.next = 29;
break;
}
_context3.prev = 12;
_context3.next = 15;
return this.manager_.transaction(isolation, function (m) {
return _doWork(m);
});
case 15:
result = _context3.sent;
return _context3.abrupt("return", result);
case 19:
_context3.prev = 19;
_context3.t0 = _context3["catch"](12);
if (!this.shouldRetryTransaction(_context3.t0)) {
_context3.next = 25;
break;
}
return _context3.abrupt("return", this.manager_.transaction(isolation, function (m) {
return _doWork(m);
}));
case 25:
if (!errorHandler) {
_context3.next = 28;
break;
}
_context3.next = 28;
return errorHandler(_context3.t0);
case 28:
throw _context3.t0;
case 29:
_context3.prev = 29;
_context3.next = 32;
return this.manager_.transaction(function (m) {
return _doWork(m);
});
case 32:
return _context3.abrupt("return", _context3.sent);
case 35:
_context3.prev = 35;
_context3.t1 = _context3["catch"](29);
if (!errorHandler) {
_context3.next = 43;
break;
}
_context3.next = 40;
return errorHandler(_context3.t1);
case 40:
_result = _context3.sent;
if (!dontFail) {
_context3.next = 43;
break;
}
return _context3.abrupt("return", _result);
case 43:
throw _context3.t1;
case 44:
case "end":
return _context3.stop();
}
}, _callee3, this, [[12, 19], [29, 35]]);
}));
function atomicPhase_(_x, _x2, _x3) {
return _atomicPhase_.apply(this, arguments);
}
return atomicPhase_;
}()
/**
* Dedicated method to set metadata.
* @param {string} obj - the entity to apply metadata to.
* @param {object} metadata - the metadata to set
* @return {Promise} resolves to the updated result.
*/
)
}, {
key: "setMetadata_",
value: function setMetadata_(obj, metadata) {
return (0, _utils.setMetadata)(obj, metadata);
}
/**
* Adds a decorator to a service. The decorator must be a function and should
* return a decorated object.
* @param {function} fn - the decorator to add to the service
*/
}, {
key: "addDecorator",
value: function addDecorator(fn) {
if (typeof fn !== "function") {
throw Error("Decorators must be of type function");
}
this.decorators_.push(fn);
}
/**
* Runs the decorators registered on the service. The decorators are run in
* the order they have been registered in. Failing decorators will be skipped
* in order to ensure deliverability in spite of breaking code.
* @param {object} obj - the object to decorate.
* @return {object} the decorated object.
*/
}, {
key: "runDecorators_",
value: function runDecorators_(obj) {
var fields = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
var expandFields = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
return this.decorators_.reduce( /*#__PURE__*/function () {
var _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(acc, next) {
return _regenerator["default"].wrap(function _callee4$(_context4) {
while (1) switch (_context4.prev = _context4.next) {
case 0:
return _context4.abrupt("return", acc.then(function (res) {
return next(res, fields, expandFields);
})["catch"](function () {
return acc;
}));
case 1:
case "end":
return _context4.stop();
}
}, _callee4);
}));
return function (_x6, _x7) {
return _ref3.apply(this, arguments);
};
}(), Promise.resolve(obj));
}
}]);
}();