@inrupt/solid-client-authn-browser 1.13.4 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inrupt/solid-client-authn-browser",
-  "version": "1.13.4",
+  "version": "1.15.0",
   "license": "MIT",
   "types": "dist/index",
   "browser": "dist/index.js",
@@ -25,8 +25,9 @@
     "cross-fetch": "^3.1.5"
   },
   "dependencies": {
-    "@inrupt/oidc-client-ext": "^1.13.4",
-    "@inrupt/solid-client-authn-core": "^1.13.4",
+    "@inrupt/oidc-client-ext": "^1.15.0",
+    "@inrupt/solid-client-authn-core": "^1.15.0",
+    "@inrupt/universal-fetch": "^1.0.1",
     "@types/lodash.clonedeep": "^4.5.6",
     "@types/node": "^18.0.3",
     "@types/uuid": "^9.0.1",
@@ -38,8 +39,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "engines": {
-    "node": "^14.0.0 || ^16.0.0"
-  },
-  "gitHead": "ab437bbfb613f4f64b82b17e3a38177998a1762a"
+  "gitHead": "e8f87a62bf739970d3fb5bc3fb48e587871f3719"
 }

package/src/ClientAuthentication.spec.ts

@@ -36,6 +36,9 @@ import {
   mockHandleIncomingRedirect,
 } from "@inrupt/solid-client-authn-core/mocks";
 
+import { fetch } from "@inrupt/universal-fetch";
+import * as UniversalFetch from "@inrupt/universal-fetch";
+
 import { mockLoginHandler } from "./login/__mocks__/LoginHandler";
 import { mockLogoutHandler } from "./logout/__mocks__/LogoutHandler";
 import {
@@ -45,6 +48,16 @@ import {
 import ClientAuthentication from "./ClientAuthentication";
 import { mockDefaultIssuerConfigFetcher } from "./login/oidc/__mocks__/IssuerConfigFetcher";
 
+jest.mock("@inrupt/universal-fetch", () => {
+  const fetchModule = jest.requireActual(
+    "@inrupt/universal-fetch"
+  ) as typeof UniversalFetch;
+  return {
+    ...fetchModule,
+    fetch: jest.fn<typeof fetch>(),
+  };
+});
+
 jest.mock("@inrupt/solid-client-authn-core", () => {
   const actualCoreModule = jest.requireActual(
     "@inrupt/solid-client-authn-core"
@@ -284,13 +297,9 @@ describe("ClientAuthentication", () => {
 
   describe("fetch", () => {
     it("calls fetch", async () => {
-      window.fetch = jest.fn<typeof fetch>();
       const clientAuthn = getClientAuthentication();
       await clientAuthn.fetch("https://html5zombo.com");
-      expect(window.fetch).toHaveBeenCalledWith(
-        "https://html5zombo.com",
-        undefined
-      );
+      expect(fetch).toHaveBeenCalledWith("https://html5zombo.com", undefined);
     });
   });
 
@@ -299,7 +308,6 @@ describe("ClientAuthentication", () => {
     // TODO: add tests for events & errors
 
     it("reverts back to un-authenticated fetch on logout", async () => {
-      window.fetch = jest.fn<typeof fetch>();
       // eslint-disable-next-line no-restricted-globals
       history.replaceState = jest.fn();
       const clientAuthn = getClientAuthentication();
@@ -314,13 +322,12 @@ describe("ClientAuthentication", () => {
       expect(clientAuthn.fetch).not.toBe(unauthFetch);
 
       await clientAuthn.logout("mySession");
-      const spyFetch = jest.spyOn(window, "fetch");
       await clientAuthn.fetch("https://example.com", {
         credentials: "omit",
       });
       // Calling logout should revert back to our un-authenticated fetch.
       expect(clientAuthn.fetch).toBe(unauthFetch);
-      expect(spyFetch).toHaveBeenCalledWith("https://example.com", {
+      expect(fetch).toHaveBeenCalledWith("https://example.com", {
         credentials: "omit",
       });
     });

package/src/ClientAuthentication.ts

@@ -36,14 +36,14 @@ import {
   EVENTS,
   isValidRedirectUrl,
 } from "@inrupt/solid-client-authn-core";
+import { fetch } from "@inrupt/universal-fetch";
 import { removeOidcQueryParam } from "@inrupt/oidc-client-ext";
 import { EventEmitter } from "events";
 
 // By only referring to `window` at runtime, apps that do server-side rendering
 // won't run into errors when rendering code that instantiates a
 // ClientAuthentication:
-const globalFetch: typeof window.fetch = (request, init) =>
-  window.fetch(request, init);
+const globalFetch: typeof fetch = (request, init) => fetch(request, init);
 
 /**
  * @hidden

package/src/Session.spec.ts

@@ -27,15 +27,27 @@ import {
   USER_SESSION_PREFIX,
 } from "@inrupt/solid-client-authn-core";
 import { mockStorage } from "@inrupt/solid-client-authn-core/mocks";
+import { fetch } from "@inrupt/universal-fetch";
+import * as UniversalFetch from "@inrupt/universal-fetch";
 import { mockClientAuthentication } from "./__mocks__/ClientAuthentication";
 import { Session } from "./Session";
 import { LocalStorageMock } from "./storage/__mocks__/LocalStorage";
 import { mockSessionInfoManager } from "./sessionInfo/__mocks__/SessionInfoManager";
 import { KEY_CURRENT_SESSION, KEY_CURRENT_URL } from "./constant";
-import type ClientAuthentication from "./ClientAuthentication";
+import ClientAuthentication from "./ClientAuthentication";
 
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 
+jest.mock("@inrupt/universal-fetch", () => {
+  const fetchModule = jest.requireActual(
+    "@inrupt/universal-fetch"
+  ) as typeof UniversalFetch;
+  return {
+    ...fetchModule,
+    fetch: jest.fn<typeof fetch>(),
+  };
+});
+
 const mockLocalStorage = (stored: Record<string, string>) => {
   Object.defineProperty(window, "localStorage", {
     value: new LocalStorageMock(stored),
@@ -202,7 +214,6 @@ describe("Session", () => {
 
   describe("fetch", () => {
     it("wraps up ClientAuthentication fetch if logged in", async () => {
-      window.fetch = jest.fn<typeof fetch>();
       const clientAuthentication = mockClientAuthentication();
       const clientAuthnFetch = jest.spyOn(clientAuthentication, "fetch");
       const mySession = new Session({ clientAuthentication });
@@ -212,7 +223,6 @@ describe("Session", () => {
     });
 
     it("preserves a binding to its Session instance", async () => {
-      window.fetch = jest.fn<typeof fetch>();
       const clientAuthentication = mockClientAuthentication();
       const clientAuthnFetch = jest.spyOn(clientAuthentication, "fetch");
       const mySession = new Session({ clientAuthentication });
@@ -225,12 +235,10 @@ describe("Session", () => {
     });
 
     it("does not rebind window.fetch if logged out", async () => {
-      window.fetch = jest.fn<typeof fetch>();
       const clientAuthentication = mockClientAuthentication();
       const mySession = new Session({ clientAuthentication });
       await mySession.fetch("https://some.url/");
-      expect(window.fetch).toHaveBeenCalled();
-      expect((window.fetch as jest.Mock).mock.instances).toEqual([window]);
+      expect(fetch).toHaveBeenCalled();
     });
   });
 
@@ -408,19 +416,6 @@ describe("Session", () => {
     });
   });
 
-  describe("onError", () => {
-    it("calls the registered callback on error", async () => {
-      const onErrorCallback = jest.fn();
-      const mySession = new Session();
-      mySession.onError(onErrorCallback);
-      mySession.emit(EVENTS.ERROR, "error", "error_description");
-      expect(onErrorCallback).toHaveBeenCalledWith(
-        "error",
-        "error_description"
-      );
-    });
-  });
-
   describe("silent authentication", () => {
     it("does nothing if no previous session is available", async () => {
       mockLocalStorage({});
@@ -777,130 +772,271 @@ describe("Session", () => {
     });
   });
 
-  describe("onLogin", () => {
-    it("calls the registered callback on login", async () => {
-      const myCallback = jest.fn();
-      const clientAuthentication = mockClientAuthentication();
-      clientAuthentication.handleIncomingRedirect = (
-        jest.fn() as any
-      ).mockResolvedValue({
-        isLoggedIn: true,
-        sessionId: "a session ID",
-        webId: "https://some.webid#them",
+  describe("legacy events handlers", () => {
+    describe("onError", () => {
+      it("calls the registered callback on error", async () => {
+        const onErrorCallback = jest.fn();
+        const mySession = new Session();
+        mySession.onError(onErrorCallback);
+        mySession.emit(EVENTS.ERROR, "error", "error_description");
+        expect(onErrorCallback).toHaveBeenCalledWith(
+          "error",
+          "error_description"
+        );
       });
-      mockLocalStorage({});
-      const mySession = new Session({ clientAuthentication });
-      mySession.onLogin(myCallback);
-      await mySession.handleIncomingRedirect("https://some.url");
-      expect(myCallback).toHaveBeenCalled();
     });
 
-    it("does not call the registered callback if login isn't successful", async () => {
-      const failCallback = (): void => {
-        throw new Error(
-          "Should *NOT* call callback - this means test has failed!"
+    describe("onLogin", () => {
+      it("calls the registered callback on login", async () => {
+        const myCallback = jest.fn();
+        const clientAuthentication = mockClientAuthentication();
+        clientAuthentication.handleIncomingRedirect = (
+          jest.fn() as any
+        ).mockResolvedValue({
+          isLoggedIn: true,
+          sessionId: "a session ID",
+          webId: "https://some.webid#them",
+        });
+        mockLocalStorage({});
+        const mySession = new Session({ clientAuthentication });
+        mySession.onLogin(myCallback);
+        await mySession.handleIncomingRedirect("https://some.url");
+        expect(myCallback).toHaveBeenCalled();
+      });
+
+      it("does not call the registered callback if login isn't successful", async () => {
+        const failCallback = (): void => {
+          throw new Error(
+            "Should *NOT* call callback - this means test has failed!"
+          );
+        };
+        const clientAuthentication = mockClientAuthentication();
+        clientAuthentication.handleIncomingRedirect = jest.fn(
+          async (_url: string) => {
+            return {
+              isLoggedIn: false,
+              sessionId: "a session ID",
+              webId: "https://some.webid#them",
+            };
+          }
         );
-      };
-      const clientAuthentication = mockClientAuthentication();
-      clientAuthentication.handleIncomingRedirect = jest.fn(
-        async (_url: string) => {
-          return {
-            isLoggedIn: false,
-            sessionId: "a session ID",
-            webId: "https://some.webid#them",
-          };
-        }
-      );
-      const mySession = new Session({ clientAuthentication });
-      mySession.onLogin(failCallback);
-      await expect(
-        mySession.handleIncomingRedirect("https://some.url")
-      ).resolves.not.toThrow();
+        const mySession = new Session({ clientAuthentication });
+        mySession.onLogin(failCallback);
+        await expect(
+          mySession.handleIncomingRedirect("https://some.url")
+        ).resolves.not.toThrow();
+      });
+
+      it("sets the appropriate information before calling the callback", async () => {
+        const clientAuthentication = mockClientAuthentication();
+        clientAuthentication.handleIncomingRedirect = jest.fn(
+          async (_url: string) => {
+            return {
+              isLoggedIn: true,
+              sessionId: "a session ID",
+              webId: "https://some.webid#them",
+            };
+          }
+        );
+        const mySession = new Session({ clientAuthentication });
+        const myCallback = jest.fn((): void => {
+          expect(mySession.info.webId).toBe("https://some.webid#them");
+        });
+        mySession.onLogin(myCallback);
+        await mySession.handleIncomingRedirect("https://some.url");
+        expect(myCallback).toHaveBeenCalled();
+        // Verify that the conditional assertion has been called
+        expect.assertions(2);
+      });
     });
 
-    it("sets the appropriate information before calling the callback", async () => {
-      const clientAuthentication = mockClientAuthentication();
-      clientAuthentication.handleIncomingRedirect = jest.fn(
-        async (_url: string) => {
-          return {
-            isLoggedIn: true,
-            sessionId: "a session ID",
-            webId: "https://some.webid#them",
-          };
-        }
-      );
-      const mySession = new Session({ clientAuthentication });
-      const myCallback = jest.fn((): void => {
-        expect(mySession.info.webId).toBe("https://some.webid#them");
+    describe("onLogout", () => {
+      it("calls the registered callback on logout", async () => {
+        const myCallback = jest.fn();
+        const mySession = new Session({
+          clientAuthentication: mockClientAuthentication(),
+        });
+
+        mySession.onLogout(myCallback);
+        await mySession.logout();
+        expect(myCallback).toHaveBeenCalled();
       });
-      mySession.onLogin(myCallback);
-      await mySession.handleIncomingRedirect("https://some.url");
-      expect(myCallback).toHaveBeenCalled();
-      // Verify that the conditional assertion has been called
-      expect.assertions(2);
     });
-  });
 
-  describe("onLogout", () => {
-    it("calls the registered callback on logout", async () => {
-      const myCallback = jest.fn();
-      const mySession = new Session({
-        clientAuthentication: mockClientAuthentication(),
+    describe("onSessionRestore", () => {
+      it("calls the registered callback on session restore", async () => {
+        // Set our window's location to our test value.
+        const defaultLocation = "https://coolSite.com/resource";
+        const currentLocation = "https://coolSite.com/redirect";
+
+        // This pretends we have previously triggered silent authentication and stored
+        // the location.
+        mockLocalStorage({
+          [KEY_CURRENT_URL]: defaultLocation,
+        });
+        // This acts as the URL the user has been redirected to.
+        mockLocation(currentLocation);
+        // This pretends the login is successful.
+        const clientAuthentication = mockClientAuthentication();
+        clientAuthentication.handleIncomingRedirect = (
+          jest.fn() as any
+        ).mockResolvedValue({
+          isLoggedIn: true,
+          sessionId: "a session ID",
+          webId: "https://some.webid#them",
+        });
+
+        const mySession = new Session({
+          clientAuthentication,
+        });
+        const myCallback = (urlBeforeRestore: string): void => {
+          expect(urlBeforeRestore).toEqual(defaultLocation);
+        };
+
+        mySession.onSessionRestore(myCallback);
+        await mySession.handleIncomingRedirect(currentLocation);
+
+        // This verifies that the callback has been called
+        expect.assertions(1);
       });
+    });
 
-      mySession.onLogout(myCallback);
-      await mySession.logout();
-      expect(myCallback).toHaveBeenCalled();
+    describe("onSessionExpiration", () => {
+      it("calls the provided callback when receiving the appropriate event", async () => {
+        const myCallback = jest.fn();
+        const mySession = new Session({
+          clientAuthentication: mockClientAuthentication(),
+        });
+        mySession.onSessionExpiration(myCallback);
+        mySession.emit(EVENTS.SESSION_EXPIRED);
+        expect(myCallback).toHaveBeenCalled();
+      });
     });
   });
 
-  describe("onSessionRestore", () => {
-    it("calls the registered callback on session restore", async () => {
-      // Set our window's location to our test value.
-      const defaultLocation = "https://coolSite.com/resource";
-      const currentLocation = "https://coolSite.com/redirect";
+  describe("events.on", () => {
+    describe("login", () => {
+      it("calls the registered callback on login", async () => {
+        const myCallback = jest.fn();
+        const clientAuthentication = mockClientAuthentication();
+        clientAuthentication.handleIncomingRedirect = jest
+          .fn<ClientAuthentication["handleIncomingRedirect"]>()
+          .mockResolvedValue({
+            isLoggedIn: true,
+            sessionId: "a session ID",
+            webId: "https://some.webid#them",
+          });
+        mockLocalStorage({});
+        const mySession = new Session({ clientAuthentication });
+        mySession.events.on(EVENTS.LOGIN, myCallback);
+        await mySession.handleIncomingRedirect("https://some.url");
+        expect(myCallback).toHaveBeenCalled();
+      });
 
-      // This pretends we have previously triggered silent authentication and stored
-      // the location.
-      mockLocalStorage({
-        [KEY_CURRENT_URL]: defaultLocation,
+      it("does not call the registered callback if login isn't successful", async () => {
+        const myCallback = jest.fn();
+        const clientAuthentication = mockClientAuthentication();
+        clientAuthentication.handleIncomingRedirect = jest
+          .fn<ClientAuthentication["handleIncomingRedirect"]>()
+          .mockResolvedValue({
+            isLoggedIn: true,
+            sessionId: "a session ID",
+            webId: "https://some.webid#them",
+          });
+        const mySession = new Session({ clientAuthentication });
+        mySession.events.on(EVENTS.LOGIN, myCallback);
+        expect(myCallback).not.toHaveBeenCalled();
       });
-      // This acts as the URL the user has been redirected to.
-      mockLocation(currentLocation);
-      // This pretends the login is successful.
-      const clientAuthentication = mockClientAuthentication();
-      clientAuthentication.handleIncomingRedirect = (
-        jest.fn() as any
-      ).mockResolvedValue({
-        isLoggedIn: true,
-        sessionId: "a session ID",
-        webId: "https://some.webid#them",
+
+      it("sets the appropriate information before calling the callback", async () => {
+        const clientAuthentication = mockClientAuthentication();
+        clientAuthentication.handleIncomingRedirect = jest
+          .fn<ClientAuthentication["handleIncomingRedirect"]>()
+          .mockResolvedValue({
+            isLoggedIn: true,
+            sessionId: "a session ID",
+            webId: "https://some.webid#them",
+          });
+        const mySession = new Session({ clientAuthentication });
+        const myCallback = jest.fn((): void => {
+          expect(mySession.info.webId).toBe("https://some.webid#them");
+        });
+        mySession.events.on(EVENTS.LOGIN, myCallback);
+        await mySession.handleIncomingRedirect("https://some.url");
+        expect(myCallback).toHaveBeenCalled();
+        // Verify that the conditional assertion has been called
+        expect.assertions(2);
       });
+    });
 
-      const mySession = new Session({
-        clientAuthentication,
+    describe("logout", () => {
+      it("calls the registered callback on logout", async () => {
+        const myCallback = jest.fn();
+        const mySession = new Session({
+          clientAuthentication: mockClientAuthentication(),
+        });
+
+        mySession.events.on(EVENTS.LOGOUT, myCallback);
+        await mySession.logout();
+        expect(myCallback).toHaveBeenCalled();
       });
-      const myCallback = (urlBeforeRestore: string): void => {
-        expect(urlBeforeRestore).toEqual(defaultLocation);
-      };
+    });
 
-      mySession.onSessionRestore(myCallback);
-      await mySession.handleIncomingRedirect(currentLocation);
+    describe("sessionRestore", () => {
+      it("calls the registered callback on session restore", async () => {
+        // Set our window's location to our test value.
+        const defaultLocation = "https://coolSite.com/resource";
+        const currentLocation = "https://coolSite.com/redirect";
 
-      // This verifies that the callback has been called
-      expect.assertions(1);
+        // This pretends we have previously triggered silent authentication and stored
+        // the location.
+        mockLocalStorage({
+          [KEY_CURRENT_URL]: defaultLocation,
+        });
+        // This acts as the URL the user has been redirected to.
+        mockLocation(currentLocation);
+        // This pretends the login is successful.
+        const clientAuthentication = mockClientAuthentication();
+        clientAuthentication.handleIncomingRedirect = jest
+          .fn<ClientAuthentication["handleIncomingRedirect"]>()
+          .mockResolvedValue({
+            isLoggedIn: true,
+            sessionId: "a session ID",
+            webId: "https://some.webid#them",
+          });
+
+        const mySession = new Session({
+          clientAuthentication,
+        });
+        const myCallback = (urlBeforeRestore: string): void => {
+          expect(urlBeforeRestore).toEqual(defaultLocation);
+        };
+
+        mySession.events.on(EVENTS.SESSION_RESTORED, myCallback);
+        await mySession.handleIncomingRedirect(currentLocation);
+
+        // This verifies that the callback has been called
+        expect.assertions(1);
+      });
     });
   });
 
-  describe("onSessionExpiration", () => {
-    it("calls the provided callback when receiving the appropriate event", async () => {
-      const myCallback = jest.fn();
-      const mySession = new Session({
-        clientAuthentication: mockClientAuthentication(),
-      });
-      mySession.onSessionExpiration(myCallback);
-      mySession.emit(EVENTS.SESSION_EXPIRED);
-      expect(myCallback).toHaveBeenCalled();
+  describe("proxies events to the session", () => {
+    // This describe block is only required as long as Session extends the EventEmitter
+    // class.
+    it("proxies the EventEmitter calls from events to the session object", () => {
+      const mySession = new Session();
+      const spiedOn = jest.spyOn(mySession, "on");
+      mySession.events.on("login", jest.fn());
+      expect(spiedOn).toHaveBeenCalled();
+    });
+
+    it("throws on calls from events which aren't part of the EventEmitter interface", () => {
+      const mySession = new Session();
+      // @ts-expect-error onLogin is a function on Session, and not SessionEventEmitter
+      expect(() => mySession.events.onLogin(jest.fn())).toThrow(
+        "[onLogin] is not supported"
+      );
     });
   });
 });