@atlaskit/teams-client 4.0.0

package/dist/cjs/services/rest-client/index.js

@@ -0,0 +1,381 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RestClient = void 0;
+exports.resetRedirectCountOnceFlag = resetRedirectCountOnceFlag;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _once = _interopRequireDefault(require("lodash/once"));
+var _error = require("../../common/utils/error");
+var _http = require("../../common/utils/http");
+var _statusCodeHandlersProvider = require("../../common/utils/status-code-handlers-provider");
+var _baseClient = require("../base-client");
+var _cookie = require("./utils/cookie");
+var _parseErrorMessage = require("./utils/parse-error-message");
+var _parseResponse = require("./utils/parse-response");
+var _stripUuid = require("./utils/strip-uuid");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var defaultFetchOptions = {
+  credentials: 'include',
+  headers: {
+    Accept: 'application/json'
+  },
+  mode: 'cors'
+};
+var incrementRedirectCount;
+var clearRedirectCount;
+resetRedirectCountOnceFlag();
+
+// Used by test to reset the once-ness of the functions above
+function resetRedirectCountOnceFlag() {
+  incrementRedirectCount = (0, _once.default)(function () {
+    return (0, _cookie.setCookie)(_cookie.REDIRECT_COUNT, (0, _cookie.getCookieAsInteger)(_cookie.REDIRECT_COUNT) + 1);
+  });
+  clearRedirectCount = (0, _once.default)(function () {
+    return (0, _cookie.clearCookie)(_cookie.REDIRECT_COUNT);
+  });
+}
+var RestClient = exports.RestClient = /*#__PURE__*/function (_BaseClient) {
+  function RestClient(_ref) {
+    var _this;
+    var _ref$serviceUrl = _ref.serviceUrl,
+      serviceUrl = _ref$serviceUrl === void 0 ? '' : _ref$serviceUrl,
+      _ref$config = _ref.config,
+      config = _ref$config === void 0 ? {
+        logException: function logException() {}
+      } : _ref$config;
+    (0, _classCallCheck2.default)(this, RestClient);
+    _this = _callSuper(this, RestClient, [config]);
+    /**
+     * This function is necessary for if `statusCodeHandler` prescribes a login
+     * redirect upon a 401 response.
+     * While the default redirect behaviour may be overriden, this function has
+     * been kept separate to ensure it cannot be overriden, lest a host
+     * application supply embeddable-directory with a custom handler that suffers
+     * the infinite redirect bug.
+     */
+    (0, _defineProperty2.default)(_this, "preventInfiniteRedirectLoop", function (response) {
+      if (!response.ok) {
+        var responseStatusCode = response.status;
+        if (responseStatusCode === 401) {
+          incrementRedirectCount();
+        }
+      } else {
+        clearRedirectCount();
+      }
+    });
+    _this.serviceUrl = serviceUrl;
+    return _this;
+  }
+  (0, _inherits2.default)(RestClient, _BaseClient);
+  return (0, _createClass2.default)(RestClient, [{
+    key: "setServiceUrl",
+    value: function setServiceUrl(serviceUrl) {
+      this.serviceUrl = serviceUrl;
+    }
+  }, {
+    key: "getResource",
+    value: function () {
+      var _getResource = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(path) {
+        var fetchOptions,
+          _args = arguments;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              fetchOptions = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+              return _context.abrupt("return", this.makeRequest(path, fetchOptions));
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function getResource(_x) {
+        return _getResource.apply(this, arguments);
+      }
+      return getResource;
+    }()
+  }, {
+    key: "getResourceCached",
+    value: function () {
+      var _getResourceCached = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(path) {
+        var fetchOptions,
+          cacheOptions,
+          cacheKey,
+          cacheRecord,
+          response,
+          _args2 = arguments;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              fetchOptions = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
+              cacheOptions = _args2.length > 2 ? _args2[2] : undefined;
+              cacheKey = path;
+              cacheRecord = this.getCachedValue(cacheKey);
+              if (!cacheRecord) {
+                _context2.next = 6;
+                break;
+              }
+              return _context2.abrupt("return", cacheRecord);
+            case 6:
+              _context2.next = 8;
+              return this.getResource(path, fetchOptions);
+            case 8:
+              response = _context2.sent;
+              this.cacheValue(cacheKey, response, cacheOptions === null || cacheOptions === void 0 ? void 0 : cacheOptions.expiration);
+              return _context2.abrupt("return", response);
+            case 11:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function getResourceCached(_x2) {
+        return _getResourceCached.apply(this, arguments);
+      }
+      return getResourceCached;
+    }()
+  }, {
+    key: "postResource",
+    value: function () {
+      var _postResource = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(path, data) {
+        var fetchOptions,
+          _args3 = arguments;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              fetchOptions = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : {};
+              return _context3.abrupt("return", this.postResourceRaw(path, JSON.stringify(data), fetchOptions));
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function postResource(_x3, _x4) {
+        return _postResource.apply(this, arguments);
+      }
+      return postResource;
+    }()
+  }, {
+    key: "postResourceRaw",
+    value: function () {
+      var _postResourceRaw = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(path, data) {
+        var fetchOptions,
+          _args4 = arguments;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              fetchOptions = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : {};
+              fetchOptions = _objectSpread({
+                method: 'post',
+                headers: {}
+              }, fetchOptions);
+              if (data) {
+                fetchOptions = _objectSpread(_objectSpread({
+                  body: data
+                }, fetchOptions), {}, {
+                  headers: _objectSpread({
+                    'Content-Type': 'application/json'
+                  }, fetchOptions.headers)
+                });
+              }
+              return _context4.abrupt("return", this.makeRequest(path, fetchOptions));
+            case 4:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function postResourceRaw(_x5, _x6) {
+        return _postResourceRaw.apply(this, arguments);
+      }
+      return postResourceRaw;
+    }()
+  }, {
+    key: "patchResource",
+    value: function () {
+      var _patchResource = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(path, data) {
+        var fetchOptions;
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              fetchOptions = {
+                /**
+                 * PATCH must be uppercase as per fetch spec only
+                 * DELETE, GET, HEAD, OPTIONS, POST, and PUT methods
+                 * are normalised to uppercase.
+                 *
+                 * https://github.com/github/fetch/issues/37
+                 * https://fetch.spec.whatwg.org/#methods
+                 */
+                method: 'PATCH'
+              };
+              if (data) {
+                fetchOptions = _objectSpread(_objectSpread({}, fetchOptions), {}, {
+                  body: JSON.stringify(data),
+                  headers: {
+                    'Content-Type': 'application/json'
+                  }
+                });
+              }
+              return _context5.abrupt("return", this.makeRequest(path, fetchOptions));
+            case 3:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function patchResource(_x7, _x8) {
+        return _patchResource.apply(this, arguments);
+      }
+      return patchResource;
+    }()
+  }, {
+    key: "putResource",
+    value: function () {
+      var _putResource = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(path, data) {
+        var additionalFetchOptions,
+          fetchOptions,
+          _args6 = arguments;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              additionalFetchOptions = _args6.length > 2 && _args6[2] !== undefined ? _args6[2] : {};
+              fetchOptions = {
+                method: 'put'
+              };
+              if (data) {
+                Object.assign(fetchOptions, {
+                  body: JSON.stringify(data),
+                  headers: {
+                    'Content-Type': 'application/json'
+                  }
+                });
+              }
+              return _context6.abrupt("return", this.makeRequest(path, _objectSpread(_objectSpread({}, fetchOptions), additionalFetchOptions)));
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function putResource(_x9, _x10) {
+        return _putResource.apply(this, arguments);
+      }
+      return putResource;
+    }()
+  }, {
+    key: "deleteResource",
+    value: function () {
+      var _deleteResource = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(path) {
+        var options,
+          fetchOptions,
+          _args7 = arguments;
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              options = _args7.length > 1 && _args7[1] !== undefined ? _args7[1] : {};
+              fetchOptions = _objectSpread(_objectSpread({}, options), {}, {
+                method: 'delete'
+              });
+              return _context7.abrupt("return", this.makeRequest(path, fetchOptions));
+            case 3:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function deleteResource(_x11) {
+        return _deleteResource.apply(this, arguments);
+      }
+      return deleteResource;
+    }()
+  }, {
+    key: "makeRequest",
+    value: function () {
+      var _makeRequest = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(path) {
+        var additionalFetchOptions,
+          url,
+          options,
+          response,
+          responseStatusCode,
+          traceId,
+          message,
+          httpError,
+          _args8 = arguments;
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              additionalFetchOptions = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : {
+                shouldLogError: function shouldLogError(e) {
+                  return e.status !== 429;
+                }
+              };
+              url = this.serviceUrl + path;
+              options = _objectSpread(_objectSpread({}, defaultFetchOptions), additionalFetchOptions);
+              _context8.next = 5;
+              return (0, _http.fetchWithExponentialBackoff)(url, options);
+            case 5:
+              response = _context8.sent;
+              this.preventInfiniteRedirectLoop(response);
+              (0, _statusCodeHandlersProvider.handleResponse)(response);
+              responseStatusCode = response.status;
+              traceId = response.headers.get('atl-traceid');
+              if (response.ok) {
+                _context8.next = 21;
+                break;
+              }
+              if (!(responseStatusCode === 401)) {
+                _context8.next = 15;
+                break;
+              }
+              throw new _error.SLOIgnoreError({
+                message: 'Unauthorized Request - incrementing redirect count'
+              });
+            case 15:
+              _context8.next = 17;
+              return (0, _parseErrorMessage.parseErrorMessage)(response);
+            case 17:
+              message = _context8.sent;
+              httpError = new _error.HttpError({
+                message: message,
+                status: responseStatusCode,
+                traceId: traceId !== null && traceId !== void 0 ? traceId : undefined,
+                path: path
+              });
+              if (options.shouldLogError && options.shouldLogError(httpError)) {
+                this.logException(httpError, (0, _stripUuid.stripUUIDFromPath)(path), {
+                  method: options.method || 'GET',
+                  url: url,
+                  status: responseStatusCode
+                });
+              }
+              throw httpError;
+            case 21:
+              return _context8.abrupt("return", additionalFetchOptions.ignoreResponse ? null : (0, _parseResponse.parseResponse)(response));
+            case 22:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function makeRequest(_x12) {
+        return _makeRequest.apply(this, arguments);
+      }
+      return makeRequest;
+    }()
+  }]);
+}(_baseClient.BaseClient);

package/dist/cjs/services/rest-client/utils/cookie.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.REDIRECT_COUNT = exports.IDENTITY_CSRF_TOKEN = void 0;
+exports.clearCookie = clearCookie;
+exports.getCookieAsInteger = getCookieAsInteger;
+exports.setCookie = setCookie;
+var REDIRECT_COUNT = exports.REDIRECT_COUNT = 'redirectCount';
+var IDENTITY_CSRF_TOKEN = exports.IDENTITY_CSRF_TOKEN = 'avatar.csrf.token';
+function setCookie(key, value) {
+  document.cookie = "".concat(key, "=").concat(value, ";path=/;max-age=30");
+}
+function getCookieAsInteger(key) {
+  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var regex = new RegExp("".concat(key, "=(\\d+)"));
+  var result = document.cookie.match(regex);
+  return result ? parseInt(result[1], 10) : defaultValue;
+}
+function clearCookie(key) {
+  document.cookie = "".concat(key, "=doesntmatter;path=/;expires=Thu, 01 Jan 1970 00:00:01 GMT");
+}

package/dist/cjs/services/rest-client/utils/parse-error-message.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseErrorMessage = parseErrorMessage;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+function parseErrorMessage(_x) {
+  return _parseErrorMessage.apply(this, arguments);
+}
+function _parseErrorMessage() {
+  _parseErrorMessage = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(response) {
+    var json, text, errs;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return response.text();
+        case 2:
+          text = _context.sent;
+          _context.prev = 3;
+          json = JSON.parse(text);
+          _context.next = 10;
+          break;
+        case 7:
+          _context.prev = 7;
+          _context.t0 = _context["catch"](3);
+          return _context.abrupt("return", text);
+        case 10:
+          delete json.timestamp; // to dedupe sentry, scrub non-unique 'timestamp' field from the error body
+          if (!json.error) {
+            _context.next = 15;
+            break;
+          }
+          return _context.abrupt("return", "".concat(json.status || 'UNKNOWN_STATUS', " ").concat(json.error || 'MISSING_ERROR_MESSAGE'));
+        case 15:
+          if (!json.status) {
+            _context.next = 19;
+            break;
+          }
+          return _context.abrupt("return", "".concat(json.status, " MISSING_ERROR_MESSAGE"));
+        case 19:
+          if (!json.errors) {
+            _context.next = 22;
+            break;
+          }
+          errs = json.errors.map(function (error) {
+            return typeof error === 'string' ? error : error.code || error.message || 'MISSING_ERROR_MESSAGE';
+          });
+          return _context.abrupt("return", errs.join('\n - '));
+        case 22:
+          return _context.abrupt("return", JSON.stringify(json));
+        case 23:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[3, 7]]);
+  }));
+  return _parseErrorMessage.apply(this, arguments);
+}

package/dist/cjs/services/rest-client/utils/parse-response.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseResponse = parseResponse;
+function parseResponse(response) {
+  var responseStatusCode = response.status;
+  if (responseStatusCode === 204 || responseStatusCode === 202) {
+    return null;
+  }
+  var contentType = response.headers.get('content-type');
+  if (!contentType || contentType.includes('text/html') || contentType.includes('text/plain')) {
+    return response.text();
+  }
+  if (contentType.includes('application/json')) {
+    return response.json();
+  }
+  return null;
+}

package/dist/cjs/services/rest-client/utils/strip-uuid.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stripUUIDFromPath = void 0;
+var UUID_REGEX = new RegExp(/((\w{4,12}-?)){5}/g);
+var stripUUIDFromPath = exports.stripUUIDFromPath = function stripUUIDFromPath(path) {
+  return path.replace(UUID_REGEX, '<UUID>');
+};

package/dist/cjs/services/sentry/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SENTRY_PUBLIC_KEY = exports.SENTRY_PROJECT_ID = exports.SENTRY_FEDRAMP_PUBLIC_KEY = exports.SENTRY_FEDRAMP_PROJECT_ID = exports.SENTRY_DSN = void 0;
+var _atlassianContext = require("@atlaskit/atlassian-context");
+// https://sentry.io/settings/atlassian-2y/projects/people-and-teams-directory/keys/
+var SENTRY_PUBLIC_KEY = exports.SENTRY_PUBLIC_KEY = '1dc056d49dfe4df8961dc1b810e4620d';
+var SENTRY_PROJECT_ID = exports.SENTRY_PROJECT_ID = '5988845';
+var SENTRY_FEDRAMP_PUBLIC_KEY = exports.SENTRY_FEDRAMP_PUBLIC_KEY = '067abcc494be9a87b3cdf9416f2b97d5';
+var SENTRY_FEDRAMP_PROJECT_ID = exports.SENTRY_FEDRAMP_PROJECT_ID = '47';
+var SENTRY_COMMERCIAL_DSN = "https://".concat(SENTRY_PUBLIC_KEY, "@o55978.ingest.sentry.io/").concat(SENTRY_PROJECT_ID);
+var SENTRY_FEDRAMP_DSN = "https://".concat(SENTRY_FEDRAMP_PUBLIC_KEY, "@sentry.atlassian-us-gov-mod.com/").concat(SENTRY_FEDRAMP_PROJECT_ID);
+var SENTRY_DSN = exports.SENTRY_DSN = (0, _atlassianContext.isFedRamp)() ? SENTRY_FEDRAMP_DSN : SENTRY_COMMERCIAL_DSN;

package/dist/cjs/services/sentry/index.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "addBreadcrumb", {
+  enumerable: true,
+  get: function get() {
+    return _main.addBreadcrumb;
+  }
+});
+Object.defineProperty(exports, "createErrorHandler", {
+  enumerable: true,
+  get: function get() {
+    return _main.createErrorHandler;
+  }
+});
+Object.defineProperty(exports, "createErrorHandlerWithPackageContext", {
+  enumerable: true,
+  get: function get() {
+    return _main.createErrorHandlerWithPackageContext;
+  }
+});
+Object.defineProperty(exports, "logErrorMessage", {
+  enumerable: true,
+  get: function get() {
+    return _main.logErrorMessage;
+  }
+});
+Object.defineProperty(exports, "logErrorMessageWithPackageContext", {
+  enumerable: true,
+  get: function get() {
+    return _main.logErrorMessageWithPackageContext;
+  }
+});
+Object.defineProperty(exports, "logException", {
+  enumerable: true,
+  get: function get() {
+    return _main.logException;
+  }
+});
+Object.defineProperty(exports, "logExceptionWithPackageContext", {
+  enumerable: true,
+  get: function get() {
+    return _main.logExceptionWithPackageContext;
+  }
+});
+Object.defineProperty(exports, "logInfoMessage", {
+  enumerable: true,
+  get: function get() {
+    return _main.logInfoMessage;
+  }
+});
+Object.defineProperty(exports, "logInfoMessageWithPackageContext", {
+  enumerable: true,
+  get: function get() {
+    return _main.logInfoMessageWithPackageContext;
+  }
+});
+Object.defineProperty(exports, "useTeamsSentryClientSetup", {
+  enumerable: true,
+  get: function get() {
+    return _useTeamsSentryClientSetup.useTeamsSentryClientSetup;
+  }
+});
+var _main = require("./main");
+var _useTeamsSentryClientSetup = require("./utils/use-teams-sentry-client-setup");