@openstax/ts-utils 1.32.0 → 1.32.2

package/dist/esm/services/authProvider/browser.d.ts

@@ -1,6 +1,7 @@
 import { ConfigProviderForConfig } from '../../config';
-import { FetchConfig, GenericFetch } from '../../fetch';
-import { ApiUser, User } from '.';
+import { GenericFetch } from '../../fetch';
+import { UserData } from './utils/embeddedAuthProvider';
+import { ApiUser, AuthProvider } from '.';
 type Config = {
     accountsBase: string;
 };
@@ -27,46 +28,13 @@ export interface Window {
     removeEventListener: (event: 'message', callback: EventHandler) => void;
 }
 export type UpdatableUserFields = Partial<Pick<ApiUser, 'consent_preferences' | 'first_name' | 'last_name'>>;
-export declare const browserAuthProvider: <C extends string = "auth">({ window, configSpace }: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => {
-    /**
-     * gets the authentication token
-     */
-    getAuthToken: () => Promise<string | null>;
-    /**
-     * adds auth parameters to the url. this is only safe to use when using javascript to navigate
-     * within the current window, eg `window.location = 'https://my.otherservice.com';` anchors
-     * should use getAuthorizedLinkUrl for their href.
-     *
-     * result unreliable unless `getUser` is resolved first.
-     */
+export type BrowserAuthProvider = AuthProvider & {
     getAuthorizedUrl: (urlString: string) => string;
-    /**
-     * all link href-s must be rendered with auth tokens so that they work when opened in a new tab
-     *
-     * result unreliable unless `getUser` is resolved first.
-     */
     getAuthorizedLinkUrl: (urlString: string) => string;
-    /**
-     * gets an authorized url for an iframe src. sets params on the url and saves its
-     * origin to trust releasing user identity to it
-     */
     getAuthorizedEmbedUrl: (urlString: string, extraParams?: {
         [key: string]: string;
     }) => string;
-    /**
-     * gets second argument for `fetch` that has authentication token or cookie
-     */
-    getAuthorizedFetchConfig: () => Promise<FetchConfig>;
-    /**
-     * loads current user identity. does not reflect changes in identity after being called the first time.
-     */
-    getUser: () => Promise<User | undefined>;
-    /**
-     * updates user settings, for example the cookie consent preferences
-     */
-    updateUser: (updates: UpdatableUserFields) => Promise<{
-        user: ApiUser;
-        token: string | null;
-    }>;
+    updateUser: (updates: UpdatableUserFields) => Promise<UserData<ApiUser>>;
 };
+export declare const browserAuthProvider: <C extends string = "auth">({ window, configSpace }: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => BrowserAuthProvider;
 export {};

package/dist/esm/services/authProvider/browser.js

@@ -142,6 +142,7 @@ export const browserAuthProvider = ({ window, configSpace }) => (configProvider)
          * loads current user identity. does not reflect changes in identity after being called the first time.
          */
         getUser,
+        loadUserData: getUser,
         /**
          * updates user settings, for example the cookie consent preferences
          */

package/dist/esm/services/authProvider/index.d.ts

@@ -43,6 +43,7 @@ export type AuthProvider = {
      * gets second argument for `fetch` that has authentication token or cookie
      */
     getAuthorizedFetchConfig: () => Promise<FetchConfig>;
+    loadUserData: () => Promise<ApiUser | undefined>;
 };
 export type CookieAuthProviderRequest = {
     cookies?: string[];

package/dist/esm/services/authProvider/index.js

@@ -1,11 +1,16 @@
 import cookie from 'cookie';
 import { tuple } from '../../misc/helpers';
 import { getHeader } from '../../routing/helpers';
-export const stubAuthProvider = (user) => ({
-    getAuthToken: () => Promise.resolve('authToken'),
-    getUser: () => Promise.resolve(user),
-    getAuthorizedFetchConfig: () => Promise.resolve(user ? { headers: { Authorization: user.uuid } } : {})
-});
+export const stubAuthProvider = (user) => {
+    const getUser = () => Promise.resolve(user);
+    return {
+        getAuthToken: () => Promise.resolve('authToken'),
+        getUser,
+        getAuthorizedFetchConfig: () => Promise.resolve(user ? { headers: { Authorization: user.uuid } } : {}),
+        // This is not technically correct, but most tests won't care
+        loadUserData: getUser
+    };
+};
 export const getAuthTokenOrCookie = (request, cookieName, queryKey = 'auth') => {
     var _a, _b;
     const authParam = request.queryStringParameters ? request.queryStringParameters[queryKey] : undefined;

package/dist/esm/services/authProvider/subrequest.js

@@ -29,15 +29,17 @@ export const subrequestAuthProvider = (initializer) => (configProvider) => {
             }
             return user;
         };
+        const getUser = async () => {
+            if (!user) {
+                user = await loadUser();
+            }
+            return user;
+        };
         return {
             getAuthToken,
             getAuthorizedFetchConfig,
-            getUser: async () => {
-                if (!user) {
-                    user = await loadUser();
-                }
-                return user;
-            }
+            getUser,
+            loadUserData: getUser
         };
     };
 };

package/dist/esm/services/authProvider/utils/embeddedAuthProvider.d.ts

@@ -1,7 +1,7 @@
 import { User } from '..';
 import { Window } from '../browser';
-export type UserData = {
-    user?: User;
+export type UserData<T = User> = {
+    user?: T;
     token: string | null;
 };
 type UserDataLoader = () => Promise<UserData>;