@jbrowse/core 1.6.3 → 1.6.6

package/pluggableElementTypes/models/InternetAccountModel.js

@@ -9,6 +9,8 @@ exports.InternetAccount = 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 _mobxStateTree = require("mobx-state-tree");
@@ -19,6 +21,12 @@ var _io = require("../../util/io");
 
 var _mst = require("../../util/types/mst");
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var inWebWorker = typeof sessionStorage === 'undefined';
+
 var InternetAccount = _mobxStateTree.types.model('InternetAccount', {
   id: _mst.ElementId,
   type: _mobxStateTree.types.string
@@ -28,48 +36,111 @@ var InternetAccount = _mobxStateTree.types.model('InternetAccount', {
       return (0, _configuration.getConf)(self, 'name');
     },
 
+    get description() {
+      return (0, _configuration.getConf)(self, 'description');
+    },
+
     get internetAccountId() {
       return (0, _configuration.getConf)(self, 'internetAccountId');
     },
 
+    get authHeader() {
+      return (0, _configuration.getConf)(self, 'authHeader');
+    },
+
     get tokenType() {
       return (0, _configuration.getConf)(self, 'tokenType');
     },
 
-    get accountConfig() {
-      return (0, _configuration.getConf)(self);
+    get domains() {
+      return (0, _configuration.getConf)(self, 'domains');
     },
 
+    /**
+     * Can use this to customize what is displayed in fileSelector's toggle box
+     */
     get toggleContents() {
       return null;
     },
 
+    /**
+     * Can use this to customize what the fileSelector. It takes a prop called
+     * `setLocation` that should be used to set a UriLocation
+     */
     get SelectorComponent() {
       return undefined;
     },
 
+    /**
+     * Can use this to add a label to the UrlChooser. Has no effect if a custom
+     * SelectorComponent is supplied
+     */
     get selectorLabel() {
       return undefined;
-    },
+    }
 
+  };
+}).views(function (self) {
+  return {
+    /**
+     * Determine whether this internetAccount provides credentials for a URL
+     * @param location  - UriLocation of resource
+     * @returns true or false
+     */
     handlesLocation: function handlesLocation(location) {
-      return false;
+      return self.domains.some(function (domain) {
+        return location === null || location === void 0 ? void 0 : location.uri.includes(domain);
+      });
+    },
+
+    /**
+     * The key used to store this internetAccount's token in sessionStorage
+     */
+    get tokenKey() {
+      return "".concat(self.internetAccountId, "-token");
     }
+
   };
 }).actions(function (self) {
   return {
-    openLocation: function openLocation(location) {
-      return new _io.RemoteFileWithRangeCache(String(location.uri));
+    /**
+     * Must be implemented by a model extending or composing this one. Pass the
+     * user's token to `resolve`.
+     * @param resolve - Pass the token to this function
+     * @param reject - If there is an error getting the token, call this function
+     */
+    getTokenFromUser: function getTokenFromUser(resolve, reject) {
+      throw new Error('getTokenFromUser must be implemented by extending model');
     },
-    getPreAuthorizationInformation: function getPreAuthorizationInformation(location) {
+    storeToken: function storeToken(token) {
+      sessionStorage.setItem(self.tokenKey, token);
+    },
+    removeToken: function removeToken() {
+      sessionStorage.removeItem(self.tokenKey);
+    },
+    retrieveToken: function retrieveToken() {
+      return sessionStorage.getItem(self.tokenKey);
+    },
+
+    /**
+     * This can be used by an internetAccount to validate a token works before
+     * it is used. This is run when preAuthorizationInformation is requested, so
+     * it can be used to check that a token is valid before sending it to a
+     * worker thread. It expects the token to be returned so that this action
+     * can also be used to generate a new token (e.g. by using a refresh token)
+     * if the original one was invalid. Should throw an error if a token is
+     * invalid.
+     * @param token - Auth token
+     * @param location - UriLocation of the resource
+     * @returns - Valid auth token
+     */
+    validateToken: function validateToken(token, location) {
       return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
         return _regenerator.default.wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
-                return _context.abrupt("return", {
-                  internetAccountType: self.type
-                });
+                return _context.abrupt("return", token);
 
               case 1:
               case "end":
@@ -80,6 +151,221 @@ var InternetAccount = _mobxStateTree.types.model('InternetAccount', {
       }))();
     }
   };
+}).actions(function (self) {
+  var tokenPromise = undefined;
+  return {
+    /**
+     * Try to get the token from the location pre-auth, from local storage,
+     * or from a previously cached promise. If token is not available, uses
+     * `getTokenFromUser`.
+     * @param location - UriLocation of the resource
+     * @returns A promise for the token
+     */
+    getToken: function getToken(location) {
+      return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        var _location$internetAcc, _location$internetAcc2;
+
+        var token;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                if (!tokenPromise) {
+                  _context3.next = 2;
+                  break;
+                }
+
+                return _context3.abrupt("return", tokenPromise);
+
+              case 2:
+                token = location === null || location === void 0 ? void 0 : (_location$internetAcc = location.internetAccountPreAuthorization) === null || _location$internetAcc === void 0 ? void 0 : (_location$internetAcc2 = _location$internetAcc.authInfo) === null || _location$internetAcc2 === void 0 ? void 0 : _location$internetAcc2.token;
+
+                if (!token) {
+                  _context3.next = 6;
+                  break;
+                }
+
+                tokenPromise = Promise.resolve(token);
+                return _context3.abrupt("return", tokenPromise);
+
+              case 6:
+                if (!inWebWorker) {
+                  _context3.next = 8;
+                  break;
+                }
+
+                throw new Error('Did not get internet account pre-authorization info in worker');
+
+              case 8:
+                token = self.retrieveToken();
+
+                if (!token) {
+                  _context3.next = 12;
+                  break;
+                }
+
+                tokenPromise = Promise.resolve(token);
+                return _context3.abrupt("return", tokenPromise);
+
+              case 12:
+                tokenPromise = new Promise( /*#__PURE__*/function () {
+                  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(r, x) {
+                    var resolve, reject;
+                    return _regenerator.default.wrap(function _callee2$(_context2) {
+                      while (1) {
+                        switch (_context2.prev = _context2.next) {
+                          case 0:
+                            reject = function _reject(error) {
+                              self.removeToken();
+                              x(error);
+                            };
+
+                            resolve = function _resolve(token) {
+                              self.storeToken(token);
+                              r(token);
+                            };
+
+                            self.getTokenFromUser(resolve, reject);
+
+                          case 3:
+                          case "end":
+                            return _context2.stop();
+                        }
+                      }
+                    }, _callee2);
+                  }));
+
+                  return function (_x, _x2) {
+                    return _ref.apply(this, arguments);
+                  };
+                }());
+                return _context3.abrupt("return", tokenPromise);
+
+              case 14:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }))();
+    }
+  };
+}).actions(function (self) {
+  return {
+    addAuthHeaderToInit: function addAuthHeaderToInit() {
+      var init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var token = arguments.length > 1 ? arguments[1] : undefined;
+      var tokenInfoString = self.tokenType ? "".concat(self.tokenType, " ").concat(token) : token;
+      var newHeaders = new Headers(init.headers || {});
+      newHeaders.append(self.authHeader, tokenInfoString);
+      return _objectSpread(_objectSpread({}, init), {}, {
+        headers: newHeaders
+      });
+    },
+
+    /**
+     * Gets the token and returns it along with the information needed to
+     * create a new internetAccount.
+     * @param location - UriLocation of the resource
+     * @returns
+     */
+    getPreAuthorizationInformation: function getPreAuthorizationInformation(location) {
+      return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+        var authToken, validatedToken;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                _context4.next = 2;
+                return self.getToken(location);
+
+              case 2:
+                authToken = _context4.sent;
+                _context4.prev = 3;
+                _context4.next = 6;
+                return self.validateToken(authToken, location);
+
+              case 6:
+                validatedToken = _context4.sent;
+                _context4.next = 13;
+                break;
+
+              case 9:
+                _context4.prev = 9;
+                _context4.t0 = _context4["catch"](3);
+                self.removeToken();
+                throw _context4.t0;
+
+              case 13:
+                return _context4.abrupt("return", {
+                  internetAccountType: self.type,
+                  authInfo: {
+                    token: validatedToken,
+                    configuration: (0, _configuration.getConf)(self)
+                  }
+                });
+
+              case 14:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, null, [[3, 9]]);
+      }))();
+    }
+  };
+}).actions(function (self) {
+  return {
+    /**
+     * Get a fetch method that will add any needed authentication headers to
+     * the request before sending it. If location is provided, it will be
+     * checked to see if it includes a token in it pre-auth information.
+     * @param location - UriLocation of the resource
+     * @returns A function that can be used to fetch
+     */
+    getFetcher: function getFetcher(location) {
+      return /*#__PURE__*/function () {
+        var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(input, init) {
+          var authToken, newInit;
+          return _regenerator.default.wrap(function _callee5$(_context5) {
+            while (1) {
+              switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.next = 2;
+                  return self.getToken(location);
+
+                case 2:
+                  authToken = _context5.sent;
+                  newInit = self.addAuthHeaderToInit(init, authToken);
+                  return _context5.abrupt("return", fetch(input, newInit));
+
+                case 5:
+                case "end":
+                  return _context5.stop();
+              }
+            }
+          }, _callee5);
+        }));
+
+        return function (_x3, _x4) {
+          return _ref2.apply(this, arguments);
+        };
+      }();
+    }
+  };
+}).actions(function (self) {
+  return {
+    /**
+     * Gets a filehandle that uses a fetch that adds auth headers
+     * @param location - UriLocation of the resource
+     * @returns A filehandle
+     */
+    openLocation: function openLocation(location) {
+      return new _io.RemoteFileWithRangeCache(location.uri, {
+        fetch: self.getFetcher(location)
+      });
+    }
+  };
 });
 
 exports.InternetAccount = InternetAccount;

package/pluggableElementTypes/models/baseConnectionConfig.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../../configuration/configurationSchema").AnyConfigurationSchemaType;
+declare const _default: import("../../configuration").AnyConfigurationSchemaType;
 export default _default;

package/pluggableElementTypes/models/baseInternetAccountConfig.d.ts

@@ -1,4 +1,4 @@
 import { Instance } from 'mobx-state-tree';
-export declare const BaseInternetAccountConfig: import("../../configuration/configurationSchema").AnyConfigurationSchemaType;
+export declare const BaseInternetAccountConfig: import("../../configuration").AnyConfigurationSchemaType;
 export declare type BaseInternetAccountConfigModel = typeof BaseInternetAccountConfig;
 export declare type BaseInternetAccountConfig = Instance<BaseInternetAccountConfigModel>;

package/pluggableElementTypes/models/baseInternetAccountConfig.js

@@ -9,7 +9,7 @@ var _configuration = require("../../configuration");
 
 var BaseInternetAccountConfig = (0, _configuration.ConfigurationSchema)('InternetAccount', {
   name: {
-    description: 'descriptive name of the internet acount',
+    description: 'descriptive name of the internet account',
     type: 'string',
     defaultValue: ''
   },
@@ -17,6 +17,21 @@ var BaseInternetAccountConfig = (0, _configuration.ConfigurationSchema)('Interne
     description: 'a description of the internet account',
     type: 'string',
     defaultValue: ''
+  },
+  authHeader: {
+    description: 'request header for credentials',
+    type: 'string',
+    defaultValue: 'Authorization'
+  },
+  tokenType: {
+    description: 'a custom name for a token to include in the header',
+    type: 'string',
+    defaultValue: ''
+  },
+  domains: {
+    description: 'array of valid domains the url can contain to use this account',
+    type: 'stringArray',
+    defaultValue: []
   }
 }, {
   explicitIdentifier: 'internetAccountId',

package/pluggableElementTypes/models/baseTrackConfig.d.ts

@@ -1,5 +1,5 @@
 import { Instance } from 'mobx-state-tree';
 import PluginManager from '../../PluginManager';
-export declare function createBaseTrackConfig(pluginManager: PluginManager): import("../../configuration/configurationSchema").AnyConfigurationSchemaType;
+export declare function createBaseTrackConfig(pluginManager: PluginManager): import("../../configuration").AnyConfigurationSchemaType;
 export declare type BaseTrackConfigModel = ReturnType<typeof createBaseTrackConfig>;
 export declare type BaseTrackConfig = Instance<BaseTrackConfigModel>;

package/pluggableElementTypes/renderers/ComparativeServerSideRendererType.d.ts

@@ -32,6 +32,7 @@ export default class ComparativeServerSideRenderer extends ServerSideRenderer {
      * @param args - the arguments passed to render
      * @returns the same object
      */
+    renameRegionsIfNeeded(args: RenderArgs): Promise<RenderArgs>;
     serializeArgsInClient(args: RenderArgs): ServerSideRenderArgsSerialized;
     deserializeResultsInClient(result: ResultsSerialized, args: RenderArgs): ResultsDeserialized;
     /**

package/pluggableElementTypes/renderers/ComparativeServerSideRendererType.js

@@ -9,10 +9,10 @@ exports.default = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -50,7 +50,7 @@ var ComparativeServerSideRenderer = /*#__PURE__*/function (_ServerSideRenderer)
   }
 
   (0, _createClass2.default)(ComparativeServerSideRenderer, [{
-    key: "serializeArgsInClient",
+    key: "renameRegionsIfNeeded",
     value:
     /**
      * directly modifies the render arguments to prepare
@@ -65,7 +65,31 @@ var ComparativeServerSideRenderer = /*#__PURE__*/function (_ServerSideRenderer)
      * @param args - the arguments passed to render
      * @returns the same object
      */
-    function serializeArgsInClient(args) {
+    function () {
+      var _renameRegionsIfNeeded = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(args) {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                return _context.abrupt("return", args);
+
+              case 1:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function renameRegionsIfNeeded(_x) {
+        return _renameRegionsIfNeeded.apply(this, arguments);
+      }
+
+      return renameRegionsIfNeeded;
+    }()
+  }, {
+    key: "serializeArgsInClient",
+    value: function serializeArgsInClient(args) {
       var deserializedArgs = _objectSpread(_objectSpread({}, args), {}, {
         displayModel: {}
       });
@@ -89,22 +113,22 @@ var ComparativeServerSideRenderer = /*#__PURE__*/function (_ServerSideRenderer)
   }, {
     key: "renderInClient",
     value: function () {
-      var _renderInClient = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(rpcManager, args) {
-        return _regenerator.default.wrap(function _callee$(_context) {
+      var _renderInClient = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(rpcManager, args) {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
           while (1) {
-            switch (_context.prev = _context.next) {
+            switch (_context2.prev = _context2.next) {
               case 0:
-                return _context.abrupt("return", rpcManager.call(args.sessionId, 'ComparativeRender', args));
+                return _context2.abrupt("return", rpcManager.call(args.sessionId, 'ComparativeRender', args));
 
               case 1:
               case "end":
-                return _context.stop();
+                return _context2.stop();
             }
           }
-        }, _callee);
+        }, _callee2);
       }));
 
-      function renderInClient(_x, _x2) {
+      function renderInClient(_x2, _x3) {
         return _renderInClient.apply(this, arguments);
       }
 
@@ -128,33 +152,33 @@ var ComparativeServerSideRenderer = /*#__PURE__*/function (_ServerSideRenderer)
   }, {
     key: "getFeatures",
     value: function () {
-      var _getFeatures = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(renderArgs) {
+      var _getFeatures = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(renderArgs) {
         var _this = this;
 
         var signal, sessionId, adapterConfig, _yield$getAdapter, dataAdapter, regions, requestRegions, featureObservable;
 
-        return _regenerator.default.wrap(function _callee2$(_context2) {
+        return _regenerator.default.wrap(function _callee3$(_context3) {
           while (1) {
-            switch (_context2.prev = _context2.next) {
+            switch (_context3.prev = _context3.next) {
               case 0:
                 signal = renderArgs.signal, sessionId = renderArgs.sessionId, adapterConfig = renderArgs.adapterConfig;
-                _context2.next = 3;
+                _context3.next = 3;
                 return (0, _dataAdapterCache.getAdapter)(this.pluginManager, sessionId, adapterConfig);
 
               case 3:
-                _yield$getAdapter = _context2.sent;
+                _yield$getAdapter = _context3.sent;
                 dataAdapter = _yield$getAdapter.dataAdapter;
                 regions = []; // @ts-ignore this is instantiated by the getFeatures call
 
                 regions = renderArgs.regions;
 
                 if (!(!regions || regions.length === 0)) {
-                  _context2.next = 10;
+                  _context3.next = 10;
                   break;
                 }
 
                 console.warn('no regions supplied to comparative renderer');
-                return _context2.abrupt("return", []);
+                return _context3.abrupt("return", []);
 
               case 10:
                 requestRegions = regions.map(function (r) {
@@ -176,20 +200,20 @@ var ComparativeServerSideRenderer = /*#__PURE__*/function (_ServerSideRenderer)
                 featureObservable = dataAdapter.getFeaturesInMultipleRegions(requestRegions, {
                   signal: signal
                 });
-                return _context2.abrupt("return", featureObservable.pipe( // @ts-ignore
+                return _context3.abrupt("return", featureObservable.pipe( // @ts-ignore
                 (0, _operators.filter)(function (feature) {
                   return _this.featurePassesFilters(renderArgs, feature);
                 }), (0, _operators.toArray)()).toPromise());
 
               case 13:
               case "end":
-                return _context2.stop();
+                return _context3.stop();
             }
           }
-        }, _callee2, this);
+        }, _callee3, this);
       }));
 
-      function getFeatures(_x3) {
+      function getFeatures(_x4) {
         return _getFeatures.apply(this, arguments);
       }
 

package/rpc/BaseRpcDriver.d.ts

@@ -20,24 +20,24 @@ declare class LazyWorker {
     driver: BaseRpcDriver;
     worker?: WorkerHandle;
     constructor(driver: BaseRpcDriver);
-    getWorker(pluginManager: PluginManager, rpcDriverClassName: string): WorkerHandle;
+    getWorker(pluginManager: PluginManager, rpcDriverClassName: string): Promise<WorkerHandle>;
 }
 export default abstract class BaseRpcDriver {
     abstract name: string;
     private lastWorkerAssignment;
     private workerAssignments;
     private workerCount;
-    abstract makeWorker(pluginManager: PluginManager): WorkerHandle;
+    abstract makeWorker(pluginManager: PluginManager): Promise<WorkerHandle>;
     private workerPool?;
     maxPingTime: number;
     workerCheckFrequency: number;
     config: AnyConfigurationModel;
     constructor(args: RpcDriverConstructorArgs);
     filterArgs<THING_TYPE>(thing: THING_TYPE, pluginManager: PluginManager, sessionId: string): THING_TYPE;
-    remoteAbort(pluginManager: PluginManager, sessionId: string, functionName: string, signalId: number): void;
+    remoteAbort(pluginManager: PluginManager, sessionId: string, functionName: string, signalId: number): Promise<void>;
     createWorkerPool(): LazyWorker[];
     getWorkerPool(): LazyWorker[];
-    getWorker(sessionId: string, pluginManager: PluginManager): WorkerHandle;
+    getWorker(sessionId: string, pluginManager: PluginManager): Promise<WorkerHandle>;
     call(pluginManager: PluginManager, sessionId: string, functionName: string, args: {
         statusCallback?: (message: string) => void;
     }, options?: {}): Promise<unknown>;