@openmrs/esm-api 10.0.1-pre.5542 → 10.0.1-pre.5545

package/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
-[0] Successfully compiled: 14 files with swc (114.74ms)
+[0] Successfully compiled: 14 files with swc (65.51ms)
 [0] swc --strip-leading-paths src -d dist exited with code 0
 [1] tsc --project tsconfig.build.json exited with code 0

package/dist/current-user.d.ts

@@ -1,4 +1,3 @@
-import { Observable } from 'rxjs';
 import type { LoggedInUser, SessionLocation, Privilege, Role, Session } from './types';
 export type SessionStore = LoadedSessionStore | UnloadedSessionStore;
 export type LoadedSessionStore = {
@@ -12,62 +11,52 @@ export type UnloadedSessionStore = {
 /** @internal */
 export declare const sessionStore: import("zustand").StoreApi<SessionStore>;
 /**
- * The getCurrentUser function returns an observable that produces
- * **zero or more values, over time**. It will produce zero values
- * by default if the user is not logged in. And it will provide a
- * first value when the logged in user is fetched from the server.
- * Subsequent values will be produced whenever the user object is
- * updated.
- *
- * The function accepts an optional `opts` object with an `includeAuthStatus`
- * boolean property that defaults to `true`. When `includeAuthStatus` is `true`,
- * the entire {@link Session} object from the API will be provided. When
- * `includeAuthStatus` is `false`, only the {@link LoggedInUser} property of the
- * response object will be provided.
- *
- * @returns An Observable that produces zero or more values (as described above).
- *   The values produced will be a {@link LoggedInUser} object (if `includeAuthStatus`
- *   is set to `false`) or a {@link Session} object with authentication status
- *   (if `includeAuthStatus` is set to `true` or not provided).
+ * The getCurrentUser function returns a Promise that resolves once with the
+ * current user's session. If the session hasn't been loaded, was loaded more than
+ * a minute ago, or is in the middle of being refetched, the Promise waits for the
+ * fetch in question rather than resolving with data that may be out of date. The
+ * session it resolves with is therefore never more than a minute old.
+ *
+ * The function accepts an optional `opts` object with an `includeAuthStatus` boolean
+ * property that defaults to `true`. When `true`, the entire {@link Session} object
+ * from the API is provided. When `false`, only the {@link LoggedInUser} property of
+ * the response is provided.
+ *
+ * To react to subsequent session changes (login, logout, user-property updates),
+ * use {@link getSessionStore} (`getState()` / `subscribe()`) or the `useSession`
+ * React hook rather than calling this repeatedly.
+ *
+ * @returns A Promise resolving to a {@link LoggedInUser} object (if `includeAuthStatus`
+ *   is `false`) or a {@link Session} object (if `includeAuthStatus` is `true` or not
+ *   provided).
  *
  * @example
  *
  * ```js
  * import { getCurrentUser } from '@openmrs/esm-api'
- * const subscription = getCurrentUser().subscribe(
- *   user => console.log(user)
- * )
- * subscription.unsubscribe()
- * getCurrentUser({includeAuthStatus: true}).subscribe(
- *   data => console.log(data.authenticated)
- * )
+ * const session = await getCurrentUser({ includeAuthStatus: true })
+ * console.log(session.authenticated)
  * ```
- *
- * #### Be sure to unsubscribe when your component unmounts
- *
- * Otherwise your code will continue getting updates to the user object
- * even after the UI component is gone from the screen. This is a memory
- * leak and source of bugs.
  */
-declare function getCurrentUser(): Observable<Session>;
+declare function getCurrentUser(): Promise<Session>;
 /**
  * @param opts Options for controlling the response format.
- * @param opts.includeAuthStatus When `true`, returns the full {@link Session} object
+ * @param opts.includeAuthStatus When `true`, resolves with the full {@link Session} object
  *   including authentication status.
- * @returns An Observable that produces {@link Session} objects.
+ * @returns A Promise resolving to a {@link Session} object.
  */
 declare function getCurrentUser(opts: {
     includeAuthStatus: true;
-}): Observable<Session>;
+}): Promise<Session>;
 /**
  * @param opts Options for controlling the response format.
- * @param opts.includeAuthStatus When `false`, returns only the {@link LoggedInUser} object
+ * @param opts.includeAuthStatus When `false`, resolves with only the {@link LoggedInUser} object
  *   without the surrounding session information.
- * @returns An Observable that produces {@link LoggedInUser} objects.
+ * @returns A Promise resolving to a {@link LoggedInUser} object.
  */
 declare function getCurrentUser(opts: {
     includeAuthStatus: false;
-}): Observable<LoggedInUser>;
+}): Promise<LoggedInUser>;
 export { getCurrentUser };
 /**
  * Returns the global session store containing the current user's session information.
@@ -102,10 +91,10 @@ export declare function getSessionStore(): import("zustand").StoreApi<SessionSto
 export declare function setUserLanguage(data: Session): void;
 /**
  * The `refetchCurrentUser` function causes a network request to redownload
- * the user. All subscribers to the current user will be notified of the
- * new users once the new version of the user object is downloaded.
+ * the user. All subscribers to the session store will be notified of the
+ * new user once the new version of the user object is downloaded.
  *
- * @returns The same observable as returned by {@link getCurrentUser}.
+ * @returns A Promise resolving to the updated session store state.
  *
  * @example
  * ```js

package/dist/current-user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"current-user.d.ts","sourceRoot":"","sources":["../src/current-user.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAiB,MAAM,SAAS,CAAC;AAEtG,MAAM,MAAM,YAAY,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;AAErE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,IAAI,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,KAAK,CAAC;IACd,OAAO,EAAE,IAAI,CAAC;CACf,CAAC;AAEF,gBAAgB;AAChB,eAAO,MAAM,YAAY,0CAGvB,CAAC;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,iBAAS,cAAc,IAAI,UAAU,CAAC,OAAO,CAAC,CAAC;AAC/C;;;;;GAKG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE;IAAE,iBAAiB,EAAE,IAAI,CAAA;CAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;AAChF;;;;;GAKG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE;IAAE,iBAAiB,EAAE,KAAK,CAAA;CAAE,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;AAuBtF,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,6CAM9B;AAiBD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,QAc5C;AAwBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,yBAYtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,SAK/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAC3B,iBAAiB,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,EACzC,IAAI,EAAE;IAAE,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;CAAE,WAa3D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,0BAmB9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,yCAOjC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,CAW7G;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE;IACd,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACrB,EACD,eAAe,CAAC,EAAE,eAAe,GAChC,OAAO,CAAC,YAAY,CAAC,CAcvB"}
+{"version":3,"file":"current-user.d.ts","sourceRoot":"","sources":["../src/current-user.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAiB,MAAM,SAAS,CAAC;AAEtG,MAAM,MAAM,YAAY,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;AAErE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,IAAI,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,KAAK,CAAC;IACd,OAAO,EAAE,IAAI,CAAC;CACf,CAAC;AAEF,gBAAgB;AAChB,eAAO,MAAM,YAAY,0CAGvB,CAAC;AAoCH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iBAAS,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;AAC5C;;;;;GAKG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE;IAAE,iBAAiB,EAAE,IAAI,CAAA;CAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAC7E;;;;;GAKG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE;IAAE,iBAAiB,EAAE,KAAK,CAAA;CAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAmBnF,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,6CAG9B;AAiBD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,QAc5C;AAwBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,yBAwBtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,SAK/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAC3B,iBAAiB,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,EACzC,IAAI,EAAE;IAAE,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;CAAE,WAa3D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,0BAmB9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAG/E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,CAW7G;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE;IACd,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACrB,EACD,eAAe,CAAC,EAAE,eAAe,GAChC,OAAO,CAAC,YAAY,CAAC,CAcvB"}

package/dist/current-user.js

@@ -1,33 +1,51 @@
 /** @module @category API */ import { reportError } from "@openmrs/esm-error-handling";
 import { createGlobalStore } from "@openmrs/esm-state";
 import { isUndefined } from "lodash-es";
-import { Observable } from "rxjs";
 import { openmrsFetch, restBaseUrl, sessionEndpoint } from "./openmrs-fetch.js";
 /** @internal */ export const sessionStore = createGlobalStore('session', {
     loaded: false,
     session: null
 });
+/**
+ * The upper bound on how old the session handed to a reader may be. It is measured from the moment a
+ * fetch is *started*, not from the moment its response lands, so the session a reader sees is always
+ * strictly newer than this.
+ */ const sessionMaxAgeMillis = 60 * 1000;
 let lastFetchTimeMillis = 0;
-function getCurrentUser(opts = {
-    includeAuthStatus: true
-}) {
-    if (lastFetchTimeMillis < Date.now() - 1000 * 60 || !sessionStore.getState().loaded) {
-        refetchCurrentUser();
+let inFlightRefresh = null;
+/**
+ * Fetches the session if the store is unloaded or its session is older than `sessionMaxAgeMillis`.
+ * Returns `null` only when the store already holds a session fresh enough to be read as-is, so a
+ * caller that gets a promise back must wait for it rather than read the store.
+ *
+ * A fetch already in flight is joined rather than duplicated. This is what keeps `sessionMaxAgeMillis`
+ * an upper bound: while a fetch is running, the store still holds the previous session, and returning
+ * that would hand back data older than the bound allows.
+ *
+ * The returned promise rejects if the fetch fails, but the rejection is already handled and reported,
+ * so a caller that only needs the fetch started can ignore it.
+ */ function refreshSessionIfStale() {
+    if (inFlightRefresh) {
+        return inFlightRefresh;
     }
-    return new Observable((subscriber)=>{
-        const handler = (state)=>{
+    if (sessionStore.getState().loaded && lastFetchTimeMillis >= Date.now() - sessionMaxAgeMillis) {
+        return null;
+    }
+    return refetchCurrentUser();
+}
+function getCurrentUser(opts) {
+    const includeAuthStatus = opts?.includeAuthStatus ?? true;
+    const select = (session)=>includeAuthStatus ? session : session.user;
+    if (!refreshSessionIfStale()) {
+        return Promise.resolve(select(sessionStore.getState().session));
+    }
+    return new Promise((resolve)=>{
+        const unsubscribe = sessionStore.subscribe((state)=>{
             if (state.loaded) {
-                if (opts.includeAuthStatus) {
-                    subscriber.next(state.session);
-                } else {
-                    subscriber.next(state.session?.user);
-                }
+                unsubscribe();
+                resolve(select(state.session));
             }
-        };
-        handler(sessionStore.getState());
-        // The observable subscribe function should return an unsubscribe function,
-        // which happens to be exactly what `subscribe` returns.
-        return sessionStore.subscribe(handler);
+        });
     });
 }
 export { getCurrentUser };
@@ -49,9 +67,7 @@ export { getCurrentUser };
  * });
  * ```
  */ export function getSessionStore() {
-    if (lastFetchTimeMillis < Date.now() - 1000 * 60 || !sessionStore.getState().loaded) {
-        refetchCurrentUser();
-    }
+    refreshSessionIfStale();
     return sessionStore;
 }
 // NB locale is string only if this returns true
@@ -109,10 +125,10 @@ function isSuperUser(user) {
 }
 /**
  * The `refetchCurrentUser` function causes a network request to redownload
- * the user. All subscribers to the current user will be notified of the
- * new users once the new version of the user object is downloaded.
+ * the user. All subscribers to the session store will be notified of the
+ * new user once the new version of the user object is downloaded.
  *
- * @returns The same observable as returned by {@link getCurrentUser}.
+ * @returns A Promise resolving to the updated session store state.
  *
  * @example
  * ```js
@@ -125,9 +141,19 @@ function isSuperUser(user) {
     if (username && password) {
         headers['Authorization'] = `Basic ${window.btoa(`${username}:${password}`)}`;
     }
-    return handleSessionResponse(openmrsFetch(sessionEndpoint, {
+    const refresh = handleSessionResponse(openmrsFetch(sessionEndpoint, {
         headers
     }));
+    // Publish the request so that readers can wait on it instead of reading the session it is about to
+    // replace. Each call still issues its own request; this only tracks the most recent one.
+    const clear = ()=>{
+        if (inFlightRefresh === refresh) {
+            inFlightRefresh = null;
+        }
+    };
+    refresh.then(clear, clear);
+    inFlightRefresh = refresh;
+    return refresh;
 }
 /**
  * Clears the current user session from the session store, setting the session
@@ -226,13 +252,9 @@ function isSuperUser(user) {
  *   console.log('Current location:', location.display);
  * }
  * ```
- */ export function getSessionLocation() {
-    return new Promise((res, rej)=>{
-        const sub = getCurrentUser().subscribe((session)=>{
-            res(session.sessionLocation);
-        }, rej);
-        sub.unsubscribe();
-    });
+ */ export async function getSessionLocation() {
+    const session = await getCurrentUser();
+    return session.sessionLocation;
 }
 /**
  * Sets the session location for the current user. The session location represents

package/dist/openmrs-fetch.d.ts

@@ -1,5 +1,3 @@
-/** @module @category API */
-import { Observable } from 'rxjs';
 import type { FetchResponse } from './types';
 /** The base URL for the OpenMRS REST API (e.g., '/ws/rest/v1'). */
 export declare const restBaseUrl = "/ws/rest/v1";
@@ -72,36 +70,6 @@ export declare function makeUrl(path: string): string;
  * @category API
  */
 export declare function openmrsFetch<T = any>(path: string, fetchInit?: FetchConfig): Promise<FetchResponse<T>>;
-/**
- * The openmrsObservableFetch function is a wrapper around openmrsFetch
- * that returns an [Observable](https://rxjs-dev.firebaseapp.com/guide/observable)
- * instead of a promise. It exists in case using an Observable is
- * preferred or more convenient than a promise.
- *
- * @param url See [[openmrsFetch]]
- * @param fetchInit See [[openmrsFetch]]
- * @returns An Observable that produces exactly one Response object.
- * The response object is exactly the same as for [[openmrsFetch]].
- *
- * @example
- *
- * ```js
- * import { openmrsObservableFetch } from '@openmrs/esm-api'
- * const subscription = openmrsObservableFetch(`${restBaseUrl}/session').subscribe(
- *   response => console.log(response.data),
- *   err => {throw err},
- *   () => console.log('finished')
- * )
- * subscription.unsubscribe()
- * ```
- *
- * #### Cancellation
- *
- * To cancel the network request, simply call `subscription.unsubscribe();`
- *
- * @category API
- */
-export declare function openmrsObservableFetch<T>(url: string, fetchInit?: FetchConfig): Observable<FetchResponse<T>>;
 export declare class OpenmrsFetchError extends Error implements FetchError {
     constructor(url: string, response: Response, responseBody: ResponseBody | null, requestStacktrace: Error);
     response: Response;

package/dist/openmrs-fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openmrs-fetch.d.ts","sourceRoot":"","sources":["../src/openmrs-fetch.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAIlC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7C,mEAAmE;AACnE,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,uEAAuE;AACvE,eAAO,MAAM,WAAW,iBAAiB,CAAC;AAC1C,sDAAsD;AACtD,eAAO,MAAM,eAAe,wBAA2B,CAAC;AAExD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,UASnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,YAAY,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,WAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAuK1G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,GAAE,WAAgB,gCA8BjF;AAED,qBAAa,iBAAkB,SAAQ,KAAM,YAAW,UAAU;gBACpD,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI,EAAE,iBAAiB,EAAE,KAAK;IAQxG,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAAC;CACjD;AAED,MAAM,WAAW,WAAY,SAAQ,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACxE,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CAC3B;AAED,KAAK,YAAY,GAAG,MAAM,GAAG,iBAAiB,CAAC;AAE/C,MAAM,WAAW,YAAY;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,UAAU,SAAS;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;CACnC"}
+{"version":3,"file":"openmrs-fetch.d.ts","sourceRoot":"","sources":["../src/openmrs-fetch.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7C,mEAAmE;AACnE,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,uEAAuE;AACvE,eAAO,MAAM,WAAW,iBAAiB,CAAC;AAC1C,sDAAsD;AACtD,eAAO,MAAM,eAAe,wBAA2B,CAAC;AAExD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,UASnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,YAAY,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,WAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAuK1G;AAED,qBAAa,iBAAkB,SAAQ,KAAM,YAAW,UAAU;gBACpD,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI,EAAE,iBAAiB,EAAE,KAAK;IAQxG,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAAC;CACjD;AAED,MAAM,WAAW,WAAY,SAAQ,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACxE,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CAC3B;AAED,KAAK,YAAY,GAAG,MAAM,GAAG,iBAAiB,CAAC;AAE/C,MAAM,WAAW,YAAY;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,UAAU,SAAS;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;CACnC"}

package/dist/openmrs-fetch.js

@@ -11,8 +11,7 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-/** @module @category API */ import { Observable } from "rxjs";
-import { isPlainObject } from "lodash-es";
+/** @module @category API */ import { isPlainObject } from "lodash-es";
 import { getConfig } from "@openmrs/esm-config";
 import { clearHistory, navigate } from "@openmrs/esm-navigation";
 import { defaultRedirectAuthFailureUrl } from "./config-schema.js";
@@ -216,57 +215,6 @@ import { defaultRedirectAuthFailureUrl } from "./config-schema.js";
         }
     });
 }
-/**
- * The openmrsObservableFetch function is a wrapper around openmrsFetch
- * that returns an [Observable](https://rxjs-dev.firebaseapp.com/guide/observable)
- * instead of a promise. It exists in case using an Observable is
- * preferred or more convenient than a promise.
- *
- * @param url See [[openmrsFetch]]
- * @param fetchInit See [[openmrsFetch]]
- * @returns An Observable that produces exactly one Response object.
- * The response object is exactly the same as for [[openmrsFetch]].
- *
- * @example
- *
- * ```js
- * import { openmrsObservableFetch } from '@openmrs/esm-api'
- * const subscription = openmrsObservableFetch(`${restBaseUrl}/session').subscribe(
- *   response => console.log(response.data),
- *   err => {throw err},
- *   () => console.log('finished')
- * )
- * subscription.unsubscribe()
- * ```
- *
- * #### Cancellation
- *
- * To cancel the network request, simply call `subscription.unsubscribe();`
- *
- * @category API
- */ export function openmrsObservableFetch(url, fetchInit = {}) {
-    if (typeof fetchInit !== 'object') {
-        throw Error('The second argument to openmrsObservableFetch must be either omitted or an object');
-    }
-    const abortController = new AbortController();
-    fetchInit.signal = abortController.signal;
-    return new Observable((observer)=>{
-        let hasResponse = false;
-        openmrsFetch(url, fetchInit).then((response)=>{
-            hasResponse = true;
-            observer.next(response);
-            observer.complete();
-        }, (err)=>{
-            hasResponse = true;
-            observer.error(err);
-        });
-        return ()=>{
-            if (!hasResponse) {
-                abortController.abort();
-            }
-        };
-    });
-}
 export class OpenmrsFetchError extends Error {
     constructor(url, response, responseBody, requestStacktrace){
         super(), _define_property(this, "response", void 0), _define_property(this, "responseBody", void 0);

package/mock-jest.ts

@@ -1,12 +1,10 @@
-import { of } from 'rxjs';
 import { createGlobalStore } from '@openmrs/esm-state/mock';
 import { type SessionStore } from './src/current-user';
 
 export const setSessionLocation = jest.fn(() => Promise.resolve());
 export const openmrsFetch = jest.fn((url?: string) => new Promise(() => {}));
-export const openmrsObservableFetch = jest.fn(() => of({ data: { entry: [] } }));
 export function getCurrentUser() {
-  return of({ authenticated: false });
+  return Promise.resolve({ authenticated: false });
 }
 export const mockSessionStore = createGlobalStore<SessionStore>('mock-session-store', {
   loaded: false,

package/mock.ts

@@ -1,13 +1,11 @@
 import { vi } from 'vitest';
-import { of } from 'rxjs';
 import { createGlobalStore } from '@openmrs/esm-state/mock';
 import { type SessionStore } from './src/current-user';
 
 export const setSessionLocation = vi.fn(() => Promise.resolve());
 export const openmrsFetch = vi.fn((_url?: string) => new Promise(() => {}));
-export const openmrsObservableFetch = vi.fn(() => of({ data: { entry: [] } }));
 export function getCurrentUser() {
-  return of({ authenticated: false });
+  return Promise.resolve({ authenticated: false });
 }
 export const mockSessionStore = createGlobalStore<SessionStore>('mock-session-store', {
   loaded: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-api",
-  "version": "10.0.1-pre.5542",
+  "version": "10.0.1-pre.5545",
   "license": "MPL-2.0",
   "description": "The javascript module for interacting with the OpenMRS API",
   "type": "module",
@@ -57,16 +57,16 @@
     "lodash-es": "^4.17.21"
   },
   "peerDependencies": {
-    "@openmrs/esm-config": "^10.0.1-pre.5542",
-    "@openmrs/esm-error-handling": "^10.0.1-pre.5542",
-    "@openmrs/esm-globals": "^10.0.1-pre.5542",
-    "@openmrs/esm-navigation": "^10.0.1-pre.5542"
+    "@openmrs/esm-config": "^10.0.1-pre.5545",
+    "@openmrs/esm-error-handling": "^10.0.1-pre.5545",
+    "@openmrs/esm-globals": "^10.0.1-pre.5545",
+    "@openmrs/esm-navigation": "^10.0.1-pre.5545"
   },
   "devDependencies": {
-    "@openmrs/esm-config": "10.0.1-pre.5542",
-    "@openmrs/esm-error-handling": "10.0.1-pre.5542",
-    "@openmrs/esm-globals": "10.0.1-pre.5542",
-    "@openmrs/esm-navigation": "10.0.1-pre.5542",
+    "@openmrs/esm-config": "10.0.1-pre.5545",
+    "@openmrs/esm-error-handling": "10.0.1-pre.5545",
+    "@openmrs/esm-globals": "10.0.1-pre.5545",
+    "@openmrs/esm-navigation": "10.0.1-pre.5545",
     "@swc/cli": "0.8.1",
     "@swc/core": "1.15.21",
     "@vitest/coverage-v8": "^4.1.2",
@@ -74,7 +74,6 @@
     "cross-env": "^10.1.0",
     "happy-dom": "^20.6.0",
     "rimraf": "^6.1.3",
-    "rxjs": "^6.5.3",
     "vitest": "^4.1.2"
   },
   "stableVersion": "10.0.0"

package/src/current-user.test.ts

@@ -1,6 +1,5 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
 import '@testing-library/jest-dom/vitest';
-import { Observable } from 'rxjs';
 import {
   userHasAccess,
   getCurrentUser,
@@ -314,11 +313,10 @@ describe('getLoggedInUser', () => {
 });
 
 describe('getCurrentUser', () => {
-  let subscriptions: Array<{ unsubscribe?: () => void }> = [];
-
   beforeEach(() => {
     sessionStore.setState({ loaded: false, session: null });
     mockOpenmrsFetch.mockClear();
+    mockReportError.mockClear();
     // Mock openmrsFetch to prevent unhandled promise rejections
     mockOpenmrsFetch.mockResolvedValue(
       createMockFetchResponse({
@@ -328,183 +326,151 @@ describe('getCurrentUser', () => {
     );
   });
 
-  afterEach(() => {
-    // Clean up any active subscriptions
-    subscriptions.forEach((sub) => sub.unsubscribe?.());
-    subscriptions = [];
+  const buildMockUser = (): LoggedInUser => ({
+    uuid: 'user-uuid',
+    display: 'Test User',
+    username: 'testuser',
+    systemId: 'test-sys-id',
+    userProperties: {},
+    person: {} as any,
+    privileges: [],
+    roles: [],
+    retired: false,
+    locale: 'en',
+    allowedLocales: ['en'],
   });
 
-  it('should return an Observable', () => {
-    const result = getCurrentUser();
-    expect(result).toBeInstanceOf(Observable);
+  it('should return a Promise', () => {
+    expect(getCurrentUser()).toBeInstanceOf(Promise);
   });
 
-  it('should emit user when session is loaded and includeAuthStatus is false', () => {
-    return new Promise<void>((resolve) => {
-      const mockUser: LoggedInUser = {
-        uuid: 'user-uuid',
-        display: 'Test User',
-        username: 'testuser',
-        systemId: 'test-sys-id',
-        userProperties: {},
-        person: {} as any,
-        privileges: [],
-        roles: [],
-        retired: false,
-        locale: 'en',
-        allowedLocales: ['en'],
-      };
+  it('should resolve with the user when the session is fresh and includeAuthStatus is false', async () => {
+    const mockUser = buildMockUser();
+    mockOpenmrsFetch.mockResolvedValue(
+      createMockFetchResponse({ authenticated: true, sessionId: 'test-session', user: mockUser }),
+    );
+    await refetchCurrentUser();
+    mockOpenmrsFetch.mockClear();
 
-      sessionStore.setState({
-        loaded: true,
-        session: {
-          authenticated: true,
-          sessionId: 'test-session',
-          user: mockUser,
-        },
-      });
+    await expect(getCurrentUser({ includeAuthStatus: false })).resolves.toEqual(mockUser);
+    expect(mockOpenmrsFetch).not.toHaveBeenCalled();
+  });
 
-      const sub = getCurrentUser({ includeAuthStatus: false }).subscribe((user) => {
-        expect(user).toEqual(mockUser);
-        resolve();
-      });
-      subscriptions.push(sub);
-    });
+  it('should resolve with the full session when includeAuthStatus is true', async () => {
+    const mockSession: Session = {
+      authenticated: true,
+      sessionId: 'test-session',
+      user: buildMockUser(),
+    };
+    mockOpenmrsFetch.mockResolvedValue(createMockFetchResponse(mockSession));
+    await refetchCurrentUser();
+    mockOpenmrsFetch.mockClear();
+
+    await expect(getCurrentUser({ includeAuthStatus: true })).resolves.toEqual(mockSession);
+    expect(mockOpenmrsFetch).not.toHaveBeenCalled();
   });
 
-  it('should emit full session when includeAuthStatus is true', () => {
-    return new Promise<void>((resolve) => {
-      const mockUser: LoggedInUser = {
-        uuid: 'user-uuid',
-        display: 'Test User',
-        username: 'testuser',
-        systemId: 'test-sys-id',
-        userProperties: {},
-        person: {} as any,
-        privileges: [],
-        roles: [],
-        retired: false,
-        locale: 'en',
-        allowedLocales: ['en'],
-      };
-
-      const mockSession: Session = {
-        authenticated: true,
-        sessionId: 'test-session',
-        user: mockUser,
-      };
+  it('should refetch and resolve with the fresh session when the loaded session is stale', async () => {
+    vi.useFakeTimers();
 
-      sessionStore.setState({
-        loaded: true,
-        session: mockSession,
-      });
+    try {
+      const staleSession: Session = { authenticated: true, sessionId: 'stale-session', user: buildMockUser() };
+      const freshSession: Session = { authenticated: true, sessionId: 'fresh-session', user: buildMockUser() };
 
-      const sub = getCurrentUser({ includeAuthStatus: true }).subscribe((session) => {
-        expect(session).toEqual(mockSession);
-        resolve();
-      });
-      subscriptions.push(sub);
-    });
+      mockOpenmrsFetch.mockResolvedValue(createMockFetchResponse(staleSession));
+      await refetchCurrentUser();
+
+      vi.setSystemTime(Date.now() + 61 * 1000);
+      mockOpenmrsFetch.mockResolvedValue(createMockFetchResponse(freshSession));
+
+      await expect(getCurrentUser({ includeAuthStatus: true })).resolves.toEqual(freshSession);
+    } finally {
+      vi.useRealTimers();
+    }
   });
 
-  it('should not emit when session is not loaded', () => {
-    const handler = vi.fn();
-    const sub = getCurrentUser({ includeAuthStatus: false }).subscribe(handler);
-    subscriptions.push(sub);
-
-    expect(handler).not.toHaveBeenCalled();
-  });
-
-  it('should emit updates when session changes', () => {
-    return new Promise<void>((resolve) => {
-      const mockUser1: LoggedInUser = {
-        uuid: 'user-1',
-        display: 'User 1',
-        username: 'user1',
-        systemId: 'sys-1',
-        userProperties: {},
-        person: {} as any,
-        privileges: [],
-        roles: [],
-        retired: false,
-        locale: 'en',
-        allowedLocales: ['en'],
-      };
-
-      const mockUser2: LoggedInUser = {
-        uuid: 'user-2',
-        display: 'User 2',
-        username: 'user2',
-        systemId: 'sys-2',
-        userProperties: {},
-        person: {} as any,
-        privileges: [],
-        roles: [],
-        retired: false,
-        locale: 'en',
-        allowedLocales: ['en'],
-      };
-
-      const emittedUsers: LoggedInUser[] = [];
+  it('should wait for a refetch already in flight rather than resolving with the session it replaces', async () => {
+    const oldSession: Session = { authenticated: true, sessionId: 'old-session', user: buildMockUser() };
+    const newSession: Session = { authenticated: true, sessionId: 'new-session', user: buildMockUser() };
 
-      sessionStore.setState({
-        loaded: true,
-        session: {
-          authenticated: true,
-          sessionId: 'session-1',
-          user: mockUser1,
-        },
-      });
+    mockOpenmrsFetch.mockResolvedValue(createMockFetchResponse(oldSession));
+    await refetchCurrentUser();
+    mockOpenmrsFetch.mockClear();
 
-      const sub = getCurrentUser({ includeAuthStatus: false }).subscribe((user) => {
-        emittedUsers.push(user);
-        if (emittedUsers.length === 2) {
-          expect(emittedUsers[0]).toEqual(mockUser1);
-          expect(emittedUsers[1]).toEqual(mockUser2);
-          resolve();
-        }
-      });
-      subscriptions.push(sub);
-
-      setTimeout(() => {
-        sessionStore.setState({
-          loaded: true,
-          session: {
-            authenticated: true,
-            sessionId: 'session-2',
-            user: mockUser2,
-          },
-        });
-      }, 10);
+    // The store still holds `oldSession` and its fetch timestamp is well inside the freshness window,
+    // so only the in-flight refetch stops `getCurrentUser` from handing back the session on its way out.
+    let resolveFetch: (response: unknown) => void;
+    mockOpenmrsFetch.mockReturnValue(
+      new Promise((resolve) => {
+        resolveFetch = resolve;
+      }),
+    );
+    const refetch = refetchCurrentUser();
+
+    const pending = getCurrentUser({ includeAuthStatus: true });
+    expect(mockOpenmrsFetch).toHaveBeenCalledTimes(1);
+
+    resolveFetch!(createMockFetchResponse(newSession));
+    await refetch;
+
+    await expect(pending).resolves.toEqual(newSession);
+  });
+
+  it('should share a single request between concurrent callers', async () => {
+    const mockSession: Session = {
+      authenticated: true,
+      sessionId: 'test-session',
+      user: buildMockUser(),
+    };
+    mockOpenmrsFetch.mockResolvedValue(createMockFetchResponse(mockSession));
+
+    await expect(Promise.all([getCurrentUser(), getCurrentUser()])).resolves.toEqual([mockSession, mockSession]);
+    expect(mockOpenmrsFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('should not reject when the fetch fails, resolving once a session is loaded', async () => {
+    mockOpenmrsFetch.mockRejectedValue(new Error('Network error'));
+
+    let resolvedSession: Session | undefined;
+    const promise = getCurrentUser({ includeAuthStatus: true }).then((session) => {
+      resolvedSession = session;
     });
+
+    await vi.waitFor(() => expect(mockReportError).toHaveBeenCalled());
+    expect(resolvedSession).toBeUndefined();
+
+    const mockSession: Session = { authenticated: true, sessionId: 'test-session', user: buildMockUser() };
+    sessionStore.setState({ loaded: true, session: mockSession });
+
+    await promise;
+    expect(resolvedSession).toEqual(mockSession);
   });
 
-  it('should allow unsubscribing', () => {
-    const handler = vi.fn();
-    const subscription = getCurrentUser({ includeAuthStatus: false }).subscribe(handler);
-    subscriptions.push(subscription);
+  it('should not resolve until the session is loaded', async () => {
+    // Prevent the automatic refetch from resolving the session so the only way
+    // the promise settles is the manual store update below.
+    mockOpenmrsFetch.mockReturnValue(new Promise(() => {}));
+    const mockUser = buildMockUser();
 
-    sessionStore.setState({
-      loaded: true,
-      session: {
-        authenticated: true,
-        sessionId: 'test-session',
-        user: {} as LoggedInUser,
-      },
+    let resolvedUser: LoggedInUser | undefined;
+    const promise = getCurrentUser({ includeAuthStatus: false }).then((user) => {
+      resolvedUser = user as LoggedInUser;
     });
 
-    handler.mockClear();
-    subscription.unsubscribe();
+    await Promise.resolve();
+    expect(resolvedUser).toBeUndefined();
 
     sessionStore.setState({
       loaded: true,
       session: {
-        authenticated: false,
-        sessionId: 'new-session',
+        authenticated: true,
+        sessionId: 'test-session',
+        user: mockUser,
       },
     });
 
-    expect(handler).not.toHaveBeenCalled();
+    await promise;
+    expect(resolvedUser).toEqual(mockUser);
   });
 });
 

package/src/current-user.ts

@@ -2,7 +2,6 @@
 import { reportError } from '@openmrs/esm-error-handling';
 import { createGlobalStore } from '@openmrs/esm-state';
 import { isUndefined } from 'lodash-es';
-import { Observable } from 'rxjs';
 import { openmrsFetch, restBaseUrl, sessionEndpoint } from './openmrs-fetch';
 import type { LoggedInUser, SessionLocation, Privilege, Role, Session, FetchResponse } from './types';
 
@@ -23,80 +22,99 @@ export const sessionStore = createGlobalStore<SessionStore>('session', {
   loaded: false,
   session: null,
 });
+
+/**
+ * The upper bound on how old the session handed to a reader may be. It is measured from the moment a
+ * fetch is *started*, not from the moment its response lands, so the session a reader sees is always
+ * strictly newer than this.
+ */
+const sessionMaxAgeMillis = 60 * 1000;
+
 let lastFetchTimeMillis = 0;
+let inFlightRefresh: Promise<SessionStore> | null = null;
+
+/**
+ * Fetches the session if the store is unloaded or its session is older than `sessionMaxAgeMillis`.
+ * Returns `null` only when the store already holds a session fresh enough to be read as-is, so a
+ * caller that gets a promise back must wait for it rather than read the store.
+ *
+ * A fetch already in flight is joined rather than duplicated. This is what keeps `sessionMaxAgeMillis`
+ * an upper bound: while a fetch is running, the store still holds the previous session, and returning
+ * that would hand back data older than the bound allows.
+ *
+ * The returned promise rejects if the fetch fails, but the rejection is already handled and reported,
+ * so a caller that only needs the fetch started can ignore it.
+ */
+function refreshSessionIfStale(): Promise<SessionStore> | null {
+  if (inFlightRefresh) {
+    return inFlightRefresh;
+  }
+
+  if (sessionStore.getState().loaded && lastFetchTimeMillis >= Date.now() - sessionMaxAgeMillis) {
+    return null;
+  }
+
+  return refetchCurrentUser();
+}
 
 /**
- * The getCurrentUser function returns an observable that produces
- * **zero or more values, over time**. It will produce zero values
- * by default if the user is not logged in. And it will provide a
- * first value when the logged in user is fetched from the server.
- * Subsequent values will be produced whenever the user object is
- * updated.
+ * The getCurrentUser function returns a Promise that resolves once with the
+ * current user's session. If the session hasn't been loaded, was loaded more than
+ * a minute ago, or is in the middle of being refetched, the Promise waits for the
+ * fetch in question rather than resolving with data that may be out of date. The
+ * session it resolves with is therefore never more than a minute old.
+ *
+ * The function accepts an optional `opts` object with an `includeAuthStatus` boolean
+ * property that defaults to `true`. When `true`, the entire {@link Session} object
+ * from the API is provided. When `false`, only the {@link LoggedInUser} property of
+ * the response is provided.
  *
- * The function accepts an optional `opts` object with an `includeAuthStatus`
- * boolean property that defaults to `true`. When `includeAuthStatus` is `true`,
- * the entire {@link Session} object from the API will be provided. When
- * `includeAuthStatus` is `false`, only the {@link LoggedInUser} property of the
- * response object will be provided.
+ * To react to subsequent session changes (login, logout, user-property updates),
+ * use {@link getSessionStore} (`getState()` / `subscribe()`) or the `useSession`
+ * React hook rather than calling this repeatedly.
  *
- * @returns An Observable that produces zero or more values (as described above).
- *   The values produced will be a {@link LoggedInUser} object (if `includeAuthStatus`
- *   is set to `false`) or a {@link Session} object with authentication status
- *   (if `includeAuthStatus` is set to `true` or not provided).
+ * @returns A Promise resolving to a {@link LoggedInUser} object (if `includeAuthStatus`
+ *   is `false`) or a {@link Session} object (if `includeAuthStatus` is `true` or not
+ *   provided).
  *
  * @example
  *
  * ```js
  * import { getCurrentUser } from '@openmrs/esm-api'
- * const subscription = getCurrentUser().subscribe(
- *   user => console.log(user)
- * )
- * subscription.unsubscribe()
- * getCurrentUser({includeAuthStatus: true}).subscribe(
- *   data => console.log(data.authenticated)
- * )
+ * const session = await getCurrentUser({ includeAuthStatus: true })
+ * console.log(session.authenticated)
  * ```
- *
- * #### Be sure to unsubscribe when your component unmounts
- *
- * Otherwise your code will continue getting updates to the user object
- * even after the UI component is gone from the screen. This is a memory
- * leak and source of bugs.
  */
-function getCurrentUser(): Observable<Session>;
+function getCurrentUser(): Promise<Session>;
 /**
  * @param opts Options for controlling the response format.
- * @param opts.includeAuthStatus When `true`, returns the full {@link Session} object
+ * @param opts.includeAuthStatus When `true`, resolves with the full {@link Session} object
  *   including authentication status.
- * @returns An Observable that produces {@link Session} objects.
+ * @returns A Promise resolving to a {@link Session} object.
  */
-function getCurrentUser(opts: { includeAuthStatus: true }): Observable<Session>;
+function getCurrentUser(opts: { includeAuthStatus: true }): Promise<Session>;
 /**
  * @param opts Options for controlling the response format.
- * @param opts.includeAuthStatus When `false`, returns only the {@link LoggedInUser} object
+ * @param opts.includeAuthStatus When `false`, resolves with only the {@link LoggedInUser} object
  *   without the surrounding session information.
- * @returns An Observable that produces {@link LoggedInUser} objects.
+ * @returns A Promise resolving to a {@link LoggedInUser} object.
  */
-function getCurrentUser(opts: { includeAuthStatus: false }): Observable<LoggedInUser>;
-function getCurrentUser(opts = { includeAuthStatus: true }): Observable<Session | LoggedInUser> {
-  if (lastFetchTimeMillis < Date.now() - 1000 * 60 || !sessionStore.getState().loaded) {
-    refetchCurrentUser();
+function getCurrentUser(opts: { includeAuthStatus: false }): Promise<LoggedInUser>;
+function getCurrentUser(opts?: { includeAuthStatus?: boolean }): Promise<Session | LoggedInUser> {
+  const includeAuthStatus = opts?.includeAuthStatus ?? true;
+  const select = (session: Session) => (includeAuthStatus ? session : (session.user as LoggedInUser));
+
+  if (!refreshSessionIfStale()) {
+    return Promise.resolve(select((sessionStore.getState() as LoadedSessionStore).session));
   }
 
-  return new Observable((subscriber) => {
-    const handler = (state: SessionStore) => {
+  return new Promise<Session | LoggedInUser>((resolve) => {
+    const unsubscribe = sessionStore.subscribe((state) => {
       if (state.loaded) {
-        if (opts.includeAuthStatus) {
-          subscriber.next(state.session);
-        } else {
-          subscriber.next(state.session?.user);
-        }
+        unsubscribe();
+        resolve(select(state.session));
       }
-    };
-    handler(sessionStore.getState());
-    // The observable subscribe function should return an unsubscribe function,
-    // which happens to be exactly what `subscribe` returns.
-    return sessionStore.subscribe(handler);
+    });
   });
 }
 
@@ -121,10 +139,7 @@ export { getCurrentUser };
  * ```
  */
 export function getSessionStore() {
-  if (lastFetchTimeMillis < Date.now() - 1000 * 60 || !sessionStore.getState().loaded) {
-    refetchCurrentUser();
-  }
-
+  refreshSessionIfStale();
   return sessionStore;
 }
 
@@ -194,10 +209,10 @@ function isSuperUser(user: { roles: Array<Role> }) {
 
 /**
  * The `refetchCurrentUser` function causes a network request to redownload
- * the user. All subscribers to the current user will be notified of the
- * new users once the new version of the user object is downloaded.
+ * the user. All subscribers to the session store will be notified of the
+ * new user once the new version of the user object is downloaded.
  *
- * @returns The same observable as returned by {@link getCurrentUser}.
+ * @returns A Promise resolving to the updated session store state.
  *
  * @example
  * ```js
@@ -212,11 +227,23 @@ export function refetchCurrentUser(username?: string, password?: string) {
     headers['Authorization'] = `Basic ${window.btoa(`${username}:${password}`)}`;
   }
 
-  return handleSessionResponse(
+  const refresh = handleSessionResponse(
     openmrsFetch(sessionEndpoint, {
       headers,
     }),
   );
+
+  // Publish the request so that readers can wait on it instead of reading the session it is about to
+  // replace. Each call still issues its own request; this only tracks the most recent one.
+  const clear = () => {
+    if (inFlightRefresh === refresh) {
+      inFlightRefresh = null;
+    }
+  };
+  refresh.then(clear, clear);
+  inFlightRefresh = refresh;
+
+  return refresh;
 }
 
 /**
@@ -326,13 +353,9 @@ export function getLoggedInUser() {
  * }
  * ```
  */
-export function getSessionLocation() {
-  return new Promise<SessionLocation | undefined>((res, rej) => {
-    const sub = getCurrentUser().subscribe((session) => {
-      res(session.sessionLocation);
-    }, rej);
-    sub.unsubscribe();
-  });
+export async function getSessionLocation(): Promise<SessionLocation | undefined> {
+  const session = await getCurrentUser();
+  return session.sessionLocation;
 }
 
 /**

package/src/openmrs-fetch.test.ts

@@ -1,8 +1,7 @@
-import { isObservable } from 'rxjs';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { getConfig } from '@openmrs/esm-config';
 import { navigate } from '@openmrs/esm-navigation';
-import { openmrsFetch, openmrsObservableFetch } from './openmrs-fetch';
+import { openmrsFetch } from './openmrs-fetch';
 
 vi.mock('@openmrs/esm-navigation', () => ({
   clearHistory: vi.fn(),
@@ -335,61 +334,3 @@ describe('openmrsFetch', () => {
     });
   });
 });
-
-describe('openmrsObservableFetch', () => {
-  beforeEach(() => {
-    window.openmrsBase = '/openmrs';
-    window.fetch = vi.fn();
-  });
-
-  it('calls window.fetch with the correct arguments for a basic GET request', async () => {
-    // @ts-ignore
-    window.fetch.mockReturnValue(
-      Promise.resolve({
-        ok: true,
-        status: 200,
-        headers: {
-          has: () => false,
-          get: () => null,
-        },
-        clone: () => ({
-          text: () => Promise.resolve('{"value": "hi"}'),
-        }),
-      }),
-    );
-
-    const observable = openmrsObservableFetch('/ws/rest/v1/session');
-    expect(isObservable(observable)).toBe(true);
-
-    await new Promise<void>((resolve, reject) =>
-      observable.subscribe(
-        (response) => {
-          expect(response.data).toEqual({ value: 'hi' });
-          resolve();
-        },
-        (err) => {
-          reject(err);
-        },
-      ),
-    );
-
-    expect(window.fetch).toHaveBeenCalled();
-    // @ts-expect-error
-    expect(window.fetch.mock.calls[0][0]).toEqual('/openmrs/ws/rest/v1/session');
-    // @ts-expect-error
-    expect(window.fetch.mock.calls[0][1].headers.Accept).toEqual('application/json');
-  });
-
-  it('aborts the fetch request when subscription is unsubscribed', () => {
-    // @ts-expect-error
-    window.fetch.mockReturnValue(new Promise(() => {}));
-
-    const subscription = openmrsObservableFetch('/ws/rest/v1/session').subscribe();
-    // @ts-expect-error
-    const abortSignal: AbortSignal = window.fetch.mock.calls[0][1].signal;
-    expect(abortSignal.aborted).toBe(false);
-
-    subscription.unsubscribe();
-    expect(abortSignal.aborted).toBe(true);
-  });
-});

package/src/openmrs-fetch.ts

@@ -1,5 +1,4 @@
 /** @module @category API */
-import { Observable } from 'rxjs';
 import { isPlainObject } from 'lodash-es';
 import { getConfig } from '@openmrs/esm-config';
 import { clearHistory, navigate } from '@openmrs/esm-navigation';
@@ -256,67 +255,6 @@ export function openmrsFetch<T = any>(path: string, fetchInit: FetchConfig = {})
   });
 }
 
-/**
- * The openmrsObservableFetch function is a wrapper around openmrsFetch
- * that returns an [Observable](https://rxjs-dev.firebaseapp.com/guide/observable)
- * instead of a promise. It exists in case using an Observable is
- * preferred or more convenient than a promise.
- *
- * @param url See [[openmrsFetch]]
- * @param fetchInit See [[openmrsFetch]]
- * @returns An Observable that produces exactly one Response object.
- * The response object is exactly the same as for [[openmrsFetch]].
- *
- * @example
- *
- * ```js
- * import { openmrsObservableFetch } from '@openmrs/esm-api'
- * const subscription = openmrsObservableFetch(`${restBaseUrl}/session').subscribe(
- *   response => console.log(response.data),
- *   err => {throw err},
- *   () => console.log('finished')
- * )
- * subscription.unsubscribe()
- * ```
- *
- * #### Cancellation
- *
- * To cancel the network request, simply call `subscription.unsubscribe();`
- *
- * @category API
- */
-export function openmrsObservableFetch<T>(url: string, fetchInit: FetchConfig = {}) {
-  if (typeof fetchInit !== 'object') {
-    throw Error('The second argument to openmrsObservableFetch must be either omitted or an object');
-  }
-
-  const abortController = new AbortController();
-
-  fetchInit.signal = abortController.signal;
-
-  return new Observable<FetchResponse<T>>((observer) => {
-    let hasResponse = false;
-
-    openmrsFetch(url, fetchInit).then(
-      (response) => {
-        hasResponse = true;
-        observer.next(response);
-        observer.complete();
-      },
-      (err) => {
-        hasResponse = true;
-        observer.error(err);
-      },
-    );
-
-    return () => {
-      if (!hasResponse) {
-        abortController.abort();
-      }
-    };
-  });
-}
-
 export class OpenmrsFetchError extends Error implements FetchError {
   constructor(url: string, response: Response, responseBody: ResponseBody | null, requestStacktrace: Error) {
     super();