@jbrowse/plugin-authentication 4.2.1 → 5.0.0-beta.1

package/esm/index.js

@@ -1,10 +1,26 @@
 import Plugin from '@jbrowse/core/Plugin';
 import InternetAccountType from '@jbrowse/core/pluggableElementTypes/InternetAccountType';
-import { configSchema as DropboxOAuthConfigSchema, modelFactory as DropboxOAuthInternetAccountModelFactory, } from "./DropboxOAuthModel/index.js";
-import { configSchema as ExternalTokenConfigSchema, modelFactory as ExternalTokenInternetAccountModelFactory, } from "./ExternalTokenModel/index.js";
-import { configSchema as GoogleDriveOAuthConfigSchema, modelFactory as GoogleDriveOAuthInternetAccountModelFactory, } from "./GoogleDriveOAuthModel/index.js";
-import { configSchema as HTTPBasicConfigSchema, modelFactory as HTTPBasicInternetAccountModelFactory, } from "./HTTPBasicModel/index.js";
-import { configSchema as OAuthConfigSchema, modelFactory as OAuthInternetAccountModelFactory, } from "./OAuthModel/index.js";
+import { configSchema as DropboxOAuthConfigSchema, modelFactory as DropboxOAuthInternetAccountModelFactory, } from './DropboxOAuthModel/index.js';
+import { configSchema as ExternalTokenConfigSchema, modelFactory as ExternalTokenInternetAccountModelFactory, } from './ExternalTokenModel/index.js';
+import { configSchema as GoogleDriveOAuthConfigSchema, modelFactory as GoogleDriveOAuthInternetAccountModelFactory, } from './GoogleDriveOAuthModel/index.js';
+import { configSchema as HTTPBasicConfigSchema, modelFactory as HTTPBasicInternetAccountModelFactory, } from './HTTPBasicModel/index.js';
+import { configSchema as OAuthConfigSchema, modelFactory as OAuthInternetAccountModelFactory, } from './OAuthModel/index.js';
+// Generic so each call checks its own factory against its own schema — the
+// three vary together and a table of them would only agree on their union
+function accountType(name, configSchema, modelFactory) {
+    return () => new InternetAccountType({
+        name,
+        configSchema,
+        stateModel: modelFactory(configSchema),
+    });
+}
+const internetAccountTypes = [
+    accountType('OAuthInternetAccount', OAuthConfigSchema, OAuthInternetAccountModelFactory),
+    accountType('ExternalTokenInternetAccount', ExternalTokenConfigSchema, ExternalTokenInternetAccountModelFactory),
+    accountType('HTTPBasicInternetAccount', HTTPBasicConfigSchema, HTTPBasicInternetAccountModelFactory),
+    accountType('DropboxOAuthInternetAccount', DropboxOAuthConfigSchema, DropboxOAuthInternetAccountModelFactory),
+    accountType('GoogleDriveOAuthInternetAccount', GoogleDriveOAuthConfigSchema, GoogleDriveOAuthInternetAccountModelFactory),
+];
 export default class AuthenticationPlugin extends Plugin {
     name = 'AuthenticationPlugin';
     exports = {
@@ -20,45 +36,13 @@ export default class AuthenticationPlugin extends Plugin {
         GoogleDriveOAuthInternetAccountModelFactory,
     };
     install(pluginManager) {
-        pluginManager.addInternetAccountType(() => {
-            return new InternetAccountType({
-                name: 'OAuthInternetAccount',
-                configSchema: OAuthConfigSchema,
-                stateModel: OAuthInternetAccountModelFactory(OAuthConfigSchema),
-            });
-        });
-        pluginManager.addInternetAccountType(() => {
-            return new InternetAccountType({
-                name: 'ExternalTokenInternetAccount',
-                configSchema: ExternalTokenConfigSchema,
-                stateModel: ExternalTokenInternetAccountModelFactory(ExternalTokenConfigSchema),
-            });
-        });
-        pluginManager.addInternetAccountType(() => {
-            return new InternetAccountType({
-                name: 'HTTPBasicInternetAccount',
-                configSchema: HTTPBasicConfigSchema,
-                stateModel: HTTPBasicInternetAccountModelFactory(HTTPBasicConfigSchema),
-            });
-        });
-        pluginManager.addInternetAccountType(() => {
-            return new InternetAccountType({
-                name: 'DropboxOAuthInternetAccount',
-                configSchema: DropboxOAuthConfigSchema,
-                stateModel: DropboxOAuthInternetAccountModelFactory(DropboxOAuthConfigSchema),
-            });
-        });
-        pluginManager.addInternetAccountType(() => {
-            return new InternetAccountType({
-                name: 'GoogleDriveOAuthInternetAccount',
-                configSchema: GoogleDriveOAuthConfigSchema,
-                stateModel: GoogleDriveOAuthInternetAccountModelFactory(GoogleDriveOAuthConfigSchema),
-            });
-        });
+        for (const makeAccountType of internetAccountTypes) {
+            pluginManager.addInternetAccountType(makeAccountType);
+        }
     }
 }
-export { configSchema as OAuthConfigSchema, modelFactory as OAuthInternetAccountModelFactory, } from "./OAuthModel/index.js";
-export { configSchema as ExternalTokenConfigSchema, modelFactory as ExternalTokenInternetAccountModelFactory, } from "./ExternalTokenModel/index.js";
-export { configSchema as HTTPBasicConfigSchema, modelFactory as HTTPBasicInternetAccountModelFactory, } from "./HTTPBasicModel/index.js";
-export { configSchema as DropboxOAuthConfigSchema, modelFactory as DropboxOAuthInternetAccountModelFactory, } from "./DropboxOAuthModel/index.js";
-export { configSchema as GoogleDriveOAuthConfigSchema, modelFactory as GoogleDriveOAuthInternetAccountModelFactory, } from "./GoogleDriveOAuthModel/index.js";
+export { configSchema as OAuthConfigSchema, modelFactory as OAuthInternetAccountModelFactory, } from './OAuthModel/index.js';
+export { configSchema as ExternalTokenConfigSchema, modelFactory as ExternalTokenInternetAccountModelFactory, } from './ExternalTokenModel/index.js';
+export { configSchema as HTTPBasicConfigSchema, modelFactory as HTTPBasicInternetAccountModelFactory, } from './HTTPBasicModel/index.js';
+export { configSchema as DropboxOAuthConfigSchema, modelFactory as DropboxOAuthInternetAccountModelFactory, } from './DropboxOAuthModel/index.js';
+export { configSchema as GoogleDriveOAuthConfigSchema, modelFactory as GoogleDriveOAuthInternetAccountModelFactory, } from './GoogleDriveOAuthModel/index.js';

package/esm/lazyLoginForms.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The forms and prompts the internet accounts ask the user for a credential
+ * with, behind their own chunks.
+ *
+ * An internet account's state model is registered when the plugin installs, and
+ * each of these models named its form at module scope — so every host shipped
+ * the form, `SubmitDialog` and the MUI text-field/dialog graph behind them
+ * before anything could possibly have asked for a credential. Most sessions
+ * never authenticate at all. See `agent-docs/reference/EAGER_BUNDLE.md`.
+ *
+ * `getTokenFromUser` passes the form to `session.queueDialog`, and `DialogQueue`
+ * renders it inside a `Suspense` boundary, so lazy needs nothing at the call
+ * site. All are named exports, hence the `.then` — `lazy` wants a module
+ * with a `default`.
+ */
+export declare const HTTPBasicLoginForm: import("react").LazyExoticComponent<typeof import("./HTTPBasicModel/HTTPBasicLoginForm.tsx").HTTPBasicLoginForm>;
+export declare const ExternalTokenEntryForm: import("react").LazyExoticComponent<typeof import("./ExternalTokenModel/ExternalTokenEntryForm.tsx").ExternalTokenEntryForm>;
+export declare const OAuthLoginPrompt: import("react").LazyExoticComponent<typeof import("./OAuthModel/OAuthLoginPrompt.tsx").OAuthLoginPrompt>;

package/esm/lazyLoginForms.js

@@ -0,0 +1,25 @@
+import { lazy } from 'react';
+/**
+ * The forms and prompts the internet accounts ask the user for a credential
+ * with, behind their own chunks.
+ *
+ * An internet account's state model is registered when the plugin installs, and
+ * each of these models named its form at module scope — so every host shipped
+ * the form, `SubmitDialog` and the MUI text-field/dialog graph behind them
+ * before anything could possibly have asked for a credential. Most sessions
+ * never authenticate at all. See `agent-docs/reference/EAGER_BUNDLE.md`.
+ *
+ * `getTokenFromUser` passes the form to `session.queueDialog`, and `DialogQueue`
+ * renders it inside a `Suspense` boundary, so lazy needs nothing at the call
+ * site. All are named exports, hence the `.then` — `lazy` wants a module
+ * with a `default`.
+ */
+export const HTTPBasicLoginForm = lazy(() => import('./HTTPBasicModel/HTTPBasicLoginForm.js').then(m => ({
+    default: m.HTTPBasicLoginForm,
+})));
+export const ExternalTokenEntryForm = lazy(() => import('./ExternalTokenModel/ExternalTokenEntryForm.js').then(m => ({
+    default: m.ExternalTokenEntryForm,
+})));
+export const OAuthLoginPrompt = lazy(() => import('./OAuthModel/OAuthLoginPrompt.js').then(m => ({
+    default: m.OAuthLoginPrompt,
+})));

package/esm/tokenEntryModelFactory.d.ts

@@ -0,0 +1,125 @@
+import type { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
+import type { UriLocation } from '@jbrowse/core/util/types';
+import type React from 'react';
+type TokenEntryForm = React.FC<{
+    internetAccountId: string;
+    handleClose: (token?: string) => void;
+}>;
+/**
+ * #stateModel TokenEntryInternetAccount
+ * Shared base for internet accounts whose token is supplied by the user through
+ * a dialog (HTTP Basic, external token). Such accounts differ only in their
+ * discriminating `type` and the dialog form used to collect the token, both
+ * passed here. Not registered on its own — see HTTPBasicInternetAccount and
+ * ExternalTokenInternetAccount.
+ */
+export declare function tokenEntryModelFactory<Type extends string>(modelName: string, typeName: Type, configSchema: AnyConfigurationSchemaType, LoginForm: TokenEntryForm): import("@jbrowse/mobx-state-tree").IModelType<Omit<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    configuration: import("@jbrowse/core/configuration/configurationSchema").IConfigurationReference<import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+        readonly name: {
+            readonly description: "descriptive name of the internet account";
+            readonly type: "string";
+            readonly defaultValue: "";
+        };
+        readonly description: {
+            readonly description: "a description of the internet account";
+            readonly type: "string";
+            readonly defaultValue: "";
+        };
+        readonly authHeader: {
+            readonly description: "request header for credentials";
+            readonly type: "string";
+            readonly defaultValue: "Authorization";
+        };
+        readonly tokenType: {
+            readonly description: "a custom name for a token to include in the header";
+            readonly type: "string";
+            readonly defaultValue: "";
+        };
+        readonly domains: {
+            readonly description: "array of valid domains the url can contain to use this account";
+            readonly type: "stringArray";
+            readonly defaultValue: readonly [];
+        };
+    }, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "internetAccountId">>>;
+}, "configuration" | "type"> & {
+    /**
+     * #property
+     */
+    type: import("@jbrowse/mobx-state-tree").ILiteralType<Type>;
+    /**
+     * #property
+     */
+    configuration: import("@jbrowse/core/configuration/configurationSchema").IConfigurationReference<AnyConfigurationSchemaType>;
+}, {
+    readonly name: string;
+    readonly description: string;
+    readonly internetAccountId: string;
+    readonly authHeader: string;
+    readonly tokenType: string;
+    readonly domains: string[];
+    readonly toggleContents: React.ReactNode;
+    readonly selectorLabel: string | undefined;
+    readonly showInFileSelector: boolean;
+} & {
+    handlesLocation(location: UriLocation): boolean;
+    readonly tokenKey: string;
+} & {
+    getTokenFromUser(_resolve: (token: string) => void, _reject: (error: Error) => void): void;
+    storeToken(token: string): void;
+    retrieveToken(): string | undefined;
+    validateToken(token: string, _loc: UriLocation): Promise<string>;
+} & {
+    removeToken(): void;
+    getToken(location?: UriLocation): Promise<string>;
+} & {
+    addAuthHeaderToInit(init?: RequestInit, token?: string): {
+        body?: BodyInit | null;
+        cache?: RequestCache;
+        credentials?: RequestCredentials;
+        integrity?: string;
+        keepalive?: boolean;
+        method?: string;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        window?: null;
+        headers: Headers;
+    };
+    fetchWithToken(loc: UriLocation | undefined, run: (token: string) => Promise<Response>): Promise<Response>;
+    getPreAuthorizationInformation(location: UriLocation): Promise<{
+        internetAccountType: string;
+        authInfo: {
+            token: string;
+            configuration: import("@jbrowse/mobx-state-tree").ModelSnapshotType<Record<string, any>>;
+        };
+    }>;
+} & {
+    getFetcher(loc?: UriLocation): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+} & {
+    openLocation(location: UriLocation): import("@gmod/range-cache-filehandle").RemoteFileWithRangeCache;
+} & {
+    /**
+     * #getter
+     * validate the token with a HEAD request before it is used
+     */
+    readonly validateWithHEAD: boolean;
+} & {
+    /**
+     * #action
+     * Prompt the user for a token via the account's dialog form, resolving
+     * with the entered token or rejecting if the user cancels.
+     */
+    getTokenFromUser(resolve: (token: string) => void, reject: (error: Error) => void): void;
+    /**
+     * #action
+     * Optionally validate the token with a HEAD request before use, per the
+     * `validateWithHEAD` config slot.
+     */
+    validateToken(token: string, location: UriLocation): Promise<string>;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
+export {};

package/esm/tokenEntryModelFactory.js

@@ -0,0 +1,85 @@
+import { ConfigurationReference, getConf } from '@jbrowse/core/configuration';
+import { InternetAccount } from '@jbrowse/core/pluggableElementTypes/models';
+import { getRoot, types } from '@jbrowse/mobx-state-tree';
+import { getResponseError } from './util.js';
+/**
+ * #stateModel TokenEntryInternetAccount
+ * Shared base for internet accounts whose token is supplied by the user through
+ * a dialog (HTTP Basic, external token). Such accounts differ only in their
+ * discriminating `type` and the dialog form used to collect the token, both
+ * passed here. Not registered on its own — see HTTPBasicInternetAccount and
+ * ExternalTokenInternetAccount.
+ */
+export function tokenEntryModelFactory(modelName, typeName, configSchema, LoginForm) {
+    return InternetAccount.named(modelName)
+        .props({
+        /**
+         * #property
+         */
+        type: types.literal(typeName),
+        /**
+         * #property
+         */
+        configuration: ConfigurationReference(configSchema),
+    })
+        .views(self => ({
+        /**
+         * #getter
+         * validate the token with a HEAD request before it is used
+         */
+        get validateWithHEAD() {
+            return getConf(self, 'validateWithHEAD');
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         * Prompt the user for a token via the account's dialog form, resolving
+         * with the entered token or rejecting if the user cancels.
+         */
+        getTokenFromUser(resolve, reject) {
+            const { session } = getRoot(self);
+            session.queueDialog((doneCallback) => [
+                LoginForm,
+                {
+                    internetAccountId: self.internetAccountId,
+                    handleClose: (token) => {
+                        if (token) {
+                            resolve(token);
+                        }
+                        else {
+                            reject(new Error('User cancelled entry'));
+                        }
+                        doneCallback();
+                    },
+                },
+            ]);
+        },
+        /**
+         * #action
+         * Optionally validate the token with a HEAD request before use, per the
+         * `validateWithHEAD` config slot.
+         */
+        async validateToken(token, location) {
+            if (!self.validateWithHEAD) {
+                return token;
+            }
+            const response = await fetch(location.uri, self.addAuthHeaderToInit({ method: 'HEAD' }, token));
+            if (!response.ok) {
+                // The HEAD just proved this credential unusable, and there is nothing
+                // to renew it with — the only source is the user. Dropping it is what
+                // lets the next read re-open the dialog; keeping it meant a mistyped
+                // password threw the same error on every request for the rest of the
+                // session and was never asked for again. `getPreAuthorizationInform-
+                // ation` already dropped it on this path, so only the direct
+                // main-thread reads were affected.
+                self.removeToken();
+                throw new Error(await getResponseError({
+                    response,
+                    reason: 'Error validating token',
+                }));
+            }
+            return token;
+        },
+    }));
+}

package/esm/util.d.ts

@@ -4,3 +4,13 @@ export declare function getResponseError({ response, reason, statusText, }: {
     statusText?: string;
 }): Promise<string>;
 export declare function getError(response: Response): Promise<string>;
+/**
+ * Builds the `describeError` a provider hands `validateTokenWithProbe` and
+ * throws from its fetcher: read the body, pull the human-readable part out of
+ * the provider's own error JSON, and fall back to the raw text when it is not
+ * that shape at all — an HTML error page from a proxy in front of the API, say.
+ *
+ * `extract` runs inside the same guard as the parse, so it may reach into the
+ * payload without checking each hop.
+ */
+export declare function descriptiveErrorMessage<T>(extract: (parsed: T) => string | undefined): (response: Response, reason?: string) => Promise<string>;

package/esm/util.js

@@ -4,14 +4,36 @@ export async function getResponseError({ response, reason, statusText, }) {
         reason,
         statusText ?? (await getError(response)),
     ]
-        .filter(f => !!f)
+        .filter(Boolean)
         .join(' - ');
 }
 export async function getError(response) {
     try {
         return await response.text();
     }
-    catch (e) {
+    catch {
         return response.statusText;
     }
 }
+/**
+ * Builds the `describeError` a provider hands `validateTokenWithProbe` and
+ * throws from its fetcher: read the body, pull the human-readable part out of
+ * the provider's own error JSON, and fall back to the raw text when it is not
+ * that shape at all — an HTML error page from a proxy in front of the API, say.
+ *
+ * `extract` runs inside the same guard as the parse, so it may reach into the
+ * payload without checking each hop.
+ */
+export function descriptiveErrorMessage(extract) {
+    return async (response, reason) => {
+        const text = await response.text();
+        let statusText = text;
+        try {
+            statusText = extract(JSON.parse(text)) ?? text;
+        }
+        catch {
+            // statusText stays as raw response text
+        }
+        return getResponseError({ response, reason, statusText });
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-authentication",
-  "version": "4.2.1",
+  "version": "5.0.0-beta.1",
   "type": "module",
   "description": "JBrowse 2 Authentication",
   "keywords": [
@@ -21,15 +21,15 @@
     "esm"
   ],
   "dependencies": {
-    "@jbrowse/mobx-state-tree": "^5.6.0",
-    "@mui/material": "^7.3.10",
-    "generic-filehandle2": "^2.1.4",
-    "mobx": "^6.15.0",
-    "@jbrowse/core": "^4.2.1"
+    "@jbrowse/mobx-state-tree": "^6.5.1",
+    "@mui/material": "^9.3.1",
+    "generic-filehandle2": "^2.4.0",
+    "mobx": "^7.0.3",
+    "@jbrowse/core": "^5.0.0-beta.1"
   },
   "peerDependencies": {
-    "react": ">=18.0.0",
-    "react-dom": ">=18.0.0"
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
   },
   "publishConfig": {
     "access": "public"
@@ -39,14 +39,11 @@
     "build": "pnpm run /^build:/",
     "test": "cd ../..; jest --passWithNoTests plugins/authentication",
     "prebuild": "pnpm clean",
-    "build:esm": "tsc -p tsconfig.build.esm.json",
+    "build:esm": "node ../../node_modules/typescript7/bin/tsc --build tsconfig.build.esm.json",
     "clean": "rimraf esm *.tsbuildinfo"
   },
   "types": "esm/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./esm/index.d.ts",
-      "import": "./esm/index.js"
-    }
+    ".": "./esm/index.js"
   }
 }