@inrupt/solid-client-authn-browser 1.14.0 → 1.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inrupt/solid-client-authn-browser",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "license": "MIT",
   "types": "dist/index",
   "browser": "dist/index.js",
@@ -25,10 +25,11 @@
     "cross-fetch": "^3.1.5"
   },
   "dependencies": {
-    "@inrupt/oidc-client-ext": "^1.14.0",
-    "@inrupt/solid-client-authn-core": "^1.14.0",
+    "@inrupt/oidc-client-ext": "^1.16.0",
+    "@inrupt/solid-client-authn-core": "^1.16.0",
+    "@inrupt/universal-fetch": "^1.0.1",
     "@types/lodash.clonedeep": "^4.5.6",
-    "@types/node": "^18.0.3",
+    "@types/node": "^20.1.0",
     "@types/uuid": "^9.0.1",
     "events": "^3.3.0",
     "jose": "^4.3.7",
@@ -38,8 +39,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "engines": {
-    "node": "^14.0.0 || ^16.0.0"
-  },
-  "gitHead": "fcdfb264ec59cfbeb0e2821ddb7fb716450c13e2"
+  "gitHead": "e0354ece5caa8863eb0704525b9a4abb2d2a6cfc"
 }

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,6 +27,8 @@ 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";
@@ -36,6 +38,16 @@ 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();
     });
   });
 

package/src/Session.ts

@@ -31,6 +31,7 @@ import {
   ISessionEventListener,
   buildProxyHandler,
 } from "@inrupt/solid-client-authn-core";
+import { fetch } from "@inrupt/universal-fetch";
 import { v4 } from "uuid";
 import EventEmitter from "events";
 import ClientAuthentication from "./ClientAuthentication";

package/src/login/oidc/ClientRegistrar.spec.ts

@@ -24,7 +24,7 @@ import {
   mockStorageUtility,
 } from "@inrupt/solid-client-authn-core/mocks";
 import { jest, it, describe, expect } from "@jest/globals";
-import { Response as NodeResponse } from "cross-fetch";
+import { Response as NodeResponse } from "@inrupt/universal-fetch";
 import ClientRegistrar from "./ClientRegistrar";
 import { IssuerConfigFetcherFetchConfigResponse } from "./__mocks__/IssuerConfigFetcher";
 

package/src/login/oidc/IssuerConfigFetcher.spec.ts

@@ -21,9 +21,20 @@
 
 import { jest, it, describe, expect } from "@jest/globals";
 import { mockStorageUtility } from "@inrupt/solid-client-authn-core";
-import { Response as NodeResponse } from "cross-fetch";
+import { fetch, Response as NodeResponse } from "@inrupt/universal-fetch";
+import * as UniversalFetch from "@inrupt/universal-fetch";
 import IssuerConfigFetcher from "./IssuerConfigFetcher";
 
+jest.mock("@inrupt/universal-fetch", () => {
+  const fetchModule = jest.requireActual(
+    "@inrupt/universal-fetch"
+  ) as typeof UniversalFetch;
+  return {
+    ...fetchModule,
+    fetch: jest.fn<typeof fetch>(),
+  };
+});
+
 /**
  * Test for IssuerConfigFetcher
  */
@@ -41,19 +52,22 @@ describe("IssuerConfigFetcher", () => {
   }
 
   it("should return a config based on the fetched config if none was stored in the storage", async () => {
-    const fetchResponse = new NodeResponse(
-      JSON.stringify({
-        issuer: "https://example.com",
-        // eslint-disable-next-line camelcase
-        claim_types_supported: "oidc",
-        bleepBloop: "Meep Moop",
-      })
-    ) as unknown as Response;
     const configFetcher = getIssuerConfigFetcher({
       storageUtility: mockStorageUtility({}),
     });
-    const mockFetch = (jest.fn() as any).mockResolvedValueOnce(fetchResponse);
-    window.fetch = mockFetch as typeof window.fetch;
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockResolvedValueOnce(
+      new NodeResponse(
+        JSON.stringify({
+          issuer: "https://example.com",
+          // eslint-disable-next-line camelcase
+          claim_types_supported: "oidc",
+          bleepBloop: "Meep Moop",
+        })
+      )
+    );
     const fetchedConfig = await configFetcher.fetchConfig(
       "https://arbitrary.url"
     );
@@ -65,34 +79,34 @@ describe("IssuerConfigFetcher", () => {
   });
 
   it("should throw an error if the fetched config could not be converted to JSON", async () => {
-    const mockFetch = (): Promise<Response> =>
-      Promise.resolve({
-        json: () => {
-          throw new Error("Some error");
-        },
-      } as unknown as Response);
-    window.fetch = mockFetch;
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockResolvedValueOnce(new NodeResponse("Not JSON."));
     const configFetcher = new IssuerConfigFetcher(mockStorageUtility({}));
 
     await expect(configFetcher.fetchConfig("https://some.url")).rejects.toThrow(
-      "[https://some.url] has an invalid configuration: Some error"
+      "[https://some.url] has an invalid configuration:"
     );
   });
 
   it("should return a config including the support for solid-oidc if present in the discovery profile", async () => {
-    const fetchResponse = new NodeResponse(
-      JSON.stringify({
-        issuer: "https://example.com",
-        // eslint-disable-next-line camelcase
-        claim_types_supported: "oidc",
-        scopes_supported: ["openid", "offline_access", "webid"],
-      })
-    ) as unknown as Response;
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockResolvedValueOnce(
+      new NodeResponse(
+        JSON.stringify({
+          issuer: "https://example.com",
+          // eslint-disable-next-line camelcase
+          claim_types_supported: "oidc",
+          scopes_supported: ["openid", "offline_access", "webid"],
+        })
+      )
+    );
     const configFetcher = getIssuerConfigFetcher({
       storageUtility: mockStorageUtility({}),
     });
-    const mockFetch = (jest.fn() as any).mockResolvedValueOnce(fetchResponse);
-    window.fetch = mockFetch as typeof window.fetch;
     const fetchedConfig = await configFetcher.fetchConfig(
       "https://arbitrary.url"
     );
@@ -102,18 +116,21 @@ describe("IssuerConfigFetcher", () => {
   });
 
   it("should return a default value for the supported scopes if not advertized by the OpenID provider", async () => {
-    const fetchResponse = new NodeResponse(
-      JSON.stringify({
-        issuer: "https://example.com",
-        // eslint-disable-next-line camelcase
-        claim_types_supported: "oidc",
-      })
-    ) as unknown as Response;
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockResolvedValueOnce(
+      new NodeResponse(
+        JSON.stringify({
+          issuer: "https://example.com",
+          // eslint-disable-next-line camelcase
+          claim_types_supported: "oidc",
+        })
+      )
+    );
     const configFetcher = getIssuerConfigFetcher({
       storageUtility: mockStorageUtility({}),
     });
-    const mockFetch = (jest.fn() as any).mockResolvedValueOnce(fetchResponse);
-    window.fetch = mockFetch as typeof window.fetch;
     const fetchedConfig = await configFetcher.fetchConfig(
       "https://arbitrary.url"
     );
@@ -122,17 +139,20 @@ describe("IssuerConfigFetcher", () => {
 
   it("should append the .well-known/openid-configuration path at the end of the issuer URL", async () => {
     // The response value is irrelevant to this test.
-    const mockFetch = jest.fn<typeof fetch>().mockImplementation(
+    const { fetch: mockFetch } = jest.requireMock(
+      "@inrupt/universal-fetch"
+    ) as jest.Mocked<typeof UniversalFetch>;
+    mockFetch.mockImplementation(
       async () =>
         new NodeResponse(
           JSON.stringify({
             issuer: "https://example.com",
             // eslint-disable-next-line camelcase
             claim_types_supported: "oidc",
+            scopes_supported: ["openid", "offline_access", "webid"],
           })
         )
     );
-    window.fetch = mockFetch as typeof window.fetch;
     const configFetcher = getIssuerConfigFetcher({
       storageUtility: mockStorageUtility({}),
     });

package/src/login/oidc/IssuerConfigFetcher.ts

@@ -33,6 +33,7 @@ import {
   IStorageUtility,
   ConfigurationError,
 } from "@inrupt/solid-client-authn-core";
+import { fetch } from "@inrupt/universal-fetch";
 
 export const WELL_KNOWN_OPENID_CONFIG = ".well-known/openid-configuration";
 
@@ -165,7 +166,7 @@ export default class IssuerConfigFetcher implements IIssuerConfigFetcher {
       // includes the full issuer path. See https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfig.
       issuer.endsWith("/") ? issuer : `${issuer}/`
     ).href;
-    const issuerConfigRequestBody = await window.fetch(openIdConfigUrl);
+    const issuerConfigRequestBody = await fetch(openIdConfigUrl);
     // Check the validity of the fetched config
     try {
       issuerConfig = processConfig(await issuerConfigRequestBody.json());

package/src/login/oidc/incomingRedirectHandler/AuthCodeRedirectHandler.spec.ts

@@ -35,7 +35,8 @@ import type * as SolidClientAuthnCore from "@inrupt/solid-client-authn-core";
 import { jest, it, describe, expect } from "@jest/globals";
 import { CodeExchangeResult, getBearerToken } from "@inrupt/oidc-client-ext";
 import type * as OidcClientExt from "@inrupt/oidc-client-ext";
-import { Response, Headers } from "cross-fetch";
+import { fetch, Response, Headers } from "@inrupt/universal-fetch";
+import * as UniversalFetch from "@inrupt/universal-fetch";
 import { JWK, importJWK } from "jose";
 import { KeyObject } from "crypto";
 import { AuthCodeRedirectHandler } from "./AuthCodeRedirectHandler";
@@ -46,6 +47,16 @@ import {
   mockTokenRefresher,
 } from "../refresh/__mocks__/TokenRefresher";
 
+jest.mock("@inrupt/universal-fetch", () => {
+  const fetchModule = jest.requireActual(
+    "@inrupt/universal-fetch"
+  ) as typeof UniversalFetch;
+  return {
+    ...fetchModule,
+    fetch: jest.fn<typeof fetch>(),
+  };
+});
+
 const mockJwk = (): JWK => {
   return {
     kty: "EC",
@@ -193,8 +204,10 @@ function mockClientRegistrar(client: IClient): IClientRegistrar {
 }
 
 const mockFetch = (response: Response) => {
-  const mockedFetch = jest.fn(global.fetch).mockResolvedValue(response);
-  window.fetch = mockedFetch;
+  const { fetch: mockedFetch } = jest.requireMock(
+    "@inrupt/universal-fetch"
+  ) as jest.Mocked<typeof UniversalFetch>;
+  mockedFetch.mockResolvedValueOnce(response);
   return mockedFetch;
 };
 
@@ -405,7 +418,7 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("returns an authenticated bearer fetch if requested", async () => {
       mockOidcClient();
-      const mockedFetch = jest.mocked<typeof fetch>(window.fetch);
+      const mockedFetch = jest.mocked<typeof fetch>(fetch);
       mockedFetch.mockResolvedValueOnce(
         new Response("", {
           status: 200,
@@ -433,7 +446,7 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("returns an authenticated DPoP fetch if requested", async () => {
       mockOidcClient();
-      const mockedFetch = jest.mocked<typeof fetch>(window.fetch);
+      const mockedFetch = jest.mocked<typeof fetch>(fetch);
       mockedFetch.mockResolvedValueOnce(
         new Response("", {
           status: 200,
@@ -454,13 +467,9 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("saves session information in storage on successful login", async () => {
       mockOidcClient();
-      window.fetch = jest.fn(global.fetch).mockReturnValue(
-        new Promise((resolve) => {
-          resolve(
-            new Response("", {
-              status: 200,
-            })
-          );
+      mockFetch(
+        new Response("", {
+          status: 200,
         })
       );
 
@@ -482,15 +491,11 @@ describe("AuthCodeRedirectHandler", () => {
     it("does not override the previously stored redirect URL", async () => {
       mockOidcClient();
 
-      window.fetch = (jest.fn() as any).mockReturnValue(
-        new Promise((resolve) => {
-          resolve(
-            new Response("", {
-              status: 200,
-            })
-          );
+      mockFetch(
+        new Response("", {
+          status: 200,
         })
-      ) as jest.Mock<typeof fetch>;
+      );
 
       const mockedStorage = mockDefaultStorageUtility();
 
@@ -510,7 +515,7 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("returns the expiration time normalised to the current time", async () => {
       mockOidcClient();
-      window.fetch = jest.fn<typeof fetch>();
+      mockFetch(new Response());
       const MOCK_TIMESTAMP = 10000;
       Date.now = jest
         .fn()
@@ -533,7 +538,7 @@ describe("AuthCodeRedirectHandler", () => {
 
     it("returns null for the expiration time if none was provided", async () => {
       const mockedOidcClient = mockOidcClient();
-      window.fetch = jest.fn<typeof fetch>();
+      mockFetch(new Response());
       mockedOidcClient.getBearerToken = jest
         .fn(getBearerToken)
         .mockResolvedValueOnce({

package/src/login/oidc/incomingRedirectHandler/AuthCodeRedirectHandler.ts

@@ -27,6 +27,8 @@
 // being unauthenticated. This should be looked into when migrating to universal-fetch.
 // import { fetch } from "cross-fetch";
 
+import { fetch } from "@inrupt/universal-fetch";
+
 import {
   buildAuthenticatedFetch,
   IClient,

package/src/login/oidc/incomingRedirectHandler/ErrorOidcHandler.spec.ts

@@ -22,8 +22,20 @@
 import { jest, it, describe, expect } from "@jest/globals";
 import { EventEmitter } from "events";
 import { EVENTS } from "@inrupt/solid-client-authn-core";
+import { fetch } from "@inrupt/universal-fetch";
+import * as UniversalFetch from "@inrupt/universal-fetch";
 import { ErrorOidcHandler } from "./ErrorOidcHandler";
 
+jest.mock("@inrupt/universal-fetch", () => {
+  const fetchModule = jest.requireActual(
+    "@inrupt/universal-fetch"
+  ) as typeof UniversalFetch;
+  return {
+    ...fetchModule,
+    fetch: jest.fn<typeof fetch>(),
+  };
+});
+
 describe("ErrorOidcHandler", () => {
   describe("canHandle", () => {
     it("Does not handle IRIs without an error parameter", async () => {
@@ -62,14 +74,12 @@ describe("ErrorOidcHandler", () => {
 
   describe("handle", () => {
     it("returns an unauthenticated session", async () => {
-      window.fetch = jest.fn<typeof fetch>();
       const redirectHandler = new ErrorOidcHandler();
       const mySession = await redirectHandler.handle("https://my.app");
       expect(mySession.isLoggedIn).toBe(false);
       expect(mySession.webId).toBeUndefined();
     });
     it("calls the onError callback if given with both parameters", async () => {
-      window.fetch = jest.fn<typeof fetch>();
       const mockEmitter = new EventEmitter();
       // error events must be handled: https://nodejs.org/dist/latest-v16.x/docs/api/events.html#error-events
       mockEmitter.on(EVENTS.ERROR, jest.fn());
@@ -90,7 +100,6 @@ describe("ErrorOidcHandler", () => {
     });
 
     it("calls the onError callback if given with just error parameters if no description is provided", async () => {
-      window.fetch = jest.fn<typeof fetch>();
       const mockEmitter = new EventEmitter();
       const mockEmit = jest.spyOn(mockEmitter, "emit");
       // error events must be handled: https://nodejs.org/dist/latest-v16.x/docs/api/events.html#error-events

package/src/login/oidc/incomingRedirectHandler/FallbackRedirectHandler.spec.ts

@@ -20,8 +20,20 @@
 //
 
 import { jest, it, describe, expect } from "@jest/globals";
+import { fetch } from "@inrupt/universal-fetch";
+import * as UniversalFetch from "@inrupt/universal-fetch";
 import { FallbackRedirectHandler } from "./FallbackRedirectHandler";
 
+jest.mock("@inrupt/universal-fetch", () => {
+  const fetchModule = jest.requireActual(
+    "@inrupt/universal-fetch"
+  ) as typeof UniversalFetch;
+  return {
+    ...fetchModule,
+    fetch: jest.fn<typeof fetch>(),
+  };
+});
+
 describe("FallbackRedirectHandler", () => {
   describe("canHandle", () => {
     it("always accept the given IRI", async () => {
@@ -51,7 +63,6 @@ describe("FallbackRedirectHandler", () => {
 
   describe("handle", () => {
     it("returns an unauthenticated session", async () => {
-      window.fetch = jest.fn<typeof fetch>();
       const redirectHandler = new FallbackRedirectHandler();
       const mySession = await redirectHandler.handle("https://my.app");
       expect(mySession.isLoggedIn).toBe(false);

package/src/sessionInfo/SessionInfoManager.ts

@@ -34,6 +34,7 @@ import {
 } from "@inrupt/solid-client-authn-core";
 import { v4 } from "uuid";
 import { clearOidcPersistentStorage } from "@inrupt/oidc-client-ext";
+import { fetch } from "@inrupt/universal-fetch";
 
 export function getUnauthenticatedSession(): ISessionInfo & {
   fetch: typeof fetch;

package/tsconfig.json

@@ -9,8 +9,9 @@
   "typedocOptions": {
     "out": "website/docs/api/browser",
     "entryPoints": ["./src/index.ts"],
-    "entryDocument": "index.md",
+    "entryDocument": "index.rst",
     "hideInPageTOC": true,
+    "plugin": ["typedoc-plugin-markdown"]
   },
 
   "include": ["src/**/*"],