feat: updates

Author: DanielRivers

lib/utils/base64UrlEncode.ts

@@ -3,12 +3,21 @@
  * @param str String to encode
  * @returns encoded string
  */
-export const base64UrlEncode = (str: string): string => {
+export const base64UrlEncode = (str: string | ArrayBuffer): string => {
+  if (str instanceof ArrayBuffer) {
+    const numberArray = Array.from<number>(new Uint8Array(str));
+    return btoa(String.fromCharCode.apply(null, numberArray))
+      .replace(/\+/g, '-')
+      .replace(/\//g, '_')
+      .replace(/=+$/, '');
+  }
+  
   const encoder = new TextEncoder();
   const uintArray = encoder.encode(str);
   const charArray = Array.from(uintArray);
   return btoa(String.fromCharCode.apply(null, charArray))
     .replace(/\+/g, "-")
     .replace(/\//g, "_")
     .replace(/=+$/, "");
+
 };

lib/utils/exchangeAuthCode.ts

@@ -71,13 +71,13 @@ export const exchangeAuthCode = async ({
 
   const headers: {
     "Content-type": string;
-    "Cache-Control": string;
-    Pragma: string;
+    // "Cache-Control": string;
+    // Pragma: string;
     "Kinde-SDK"?: string;
   } = {
     "Content-type": "application/x-www-form-urlencoded; charset=UTF-8",
-    "Cache-Control": "no-store",
-    Pragma: "no-cache",
+    // "Cache-Control": "no-store",
+    // Pragma: "no-cache",
   };
 
   if (frameworkSettings.framework) {
@@ -88,8 +88,8 @@ export const exchangeAuthCode = async ({
   const response = await fetch(`${domain}/oauth2/token`, {
     method: "POST",
     // ...(isUseCookie && {credentials: 'include'}),
-    credentials: "include",
-    headers,
+    // credentials: "include",
+    headers: new Headers(headers),
     body: new URLSearchParams({
       client_id: clientId,
       code,

lib/utils/generateAuthUrl.ts

@@ -13,7 +13,7 @@ export const generateAuthUrl = async (
   domain: string,
   type: IssuerRouteTypes = IssuerRouteTypes.login,
   options: LoginOptions,
-): Promise<{ url: URL; state: string; nonce: string }> => {
+): Promise<{ url: URL; state: string; nonce: string; codeChallenge: string }> => {
   const authUrl = new URL(`${domain}/oauth2/auth`);
   const activeStorage = getActiveStorage();
   const searchParams: Record<string, string> = {
@@ -59,18 +59,19 @@ export const generateAuthUrl = async (
     url: authUrl,
     state: searchParams["state"],
     nonce: searchParams["nonce"],
+    codeChallenge: searchParams["code_challenge"],
   };
 };
 
-async function generatePKCEPair(): Promise<{
+export async function generatePKCEPair(): Promise<{
   codeVerifier: string;
   codeChallenge: string;
 }> {
-  const codeVerifier = generateRandomString(43);
+  const codeVerifier = generateRandomString(52);
   const data = new TextEncoder().encode(codeVerifier);
   const hashed = await crypto.subtle.digest("SHA-256", data);
-  const hashArray = Array.from(new Uint8Array(hashed));
-  const hashString = hashArray.map((b) => String.fromCharCode(b)).join("");
-  const codeChallenge = base64UrlEncode(hashString);
+  // const hashArray = Array.from(new Uint8Array(hashed));
+  // const hashString = hashArray.map((b) => String.fromCharCode(b)).join("");
+  const codeChallenge = base64UrlEncode(hashed);
   return { codeVerifier, codeChallenge };
 }

lib/utils/token/isAuthenticated.test.ts

@@ -91,4 +91,14 @@ describe("isAuthenticated", () => {
       mockError,
     );
   });
+
+  it("should return false if token is missing exp", async () => {
+    vi.spyOn(tokenUtils, "getDecodedToken").mockResolvedValue({
+      // Missing 'exp' field
+    });
+  
+    const result = await isAuthenticated();
+  
+    expect(result).toBe(false);
+  });
 });

lib/utils/token/isAuthenticated.ts

@@ -28,6 +28,11 @@ export const isAuthenticated = async (
     const token = await getDecodedToken<JWTDecoded>("accessToken");
     if (!token) return false;
 
+    if (!token.exp) {
+      console.error("Token does not have an expiry");
+      return false;
+    }
+
     const isExpired = token.exp < Math.floor(Date.now() / 1000);
 
     if (isExpired && props?.useRefreshToken) {

lib/utils/token/refreshToken.ts

@@ -7,8 +7,8 @@ import { sanatizeURL } from "..";
  * @returns { Promise<boolean> }
  */
 export const refreshToken = async (
-  domain?: string,
-  clientId?: string,
+  domain: string,
+  clientId: string,
 ): Promise<boolean> => {
   try {
     if (!domain) {
@@ -23,9 +23,15 @@ export const refreshToken = async (
 
     const storage = await getActiveStorage();
 
+    if (!storage) {
+      console.error("No active storage found");
+      return false;
+    }
+
     const refreshTokenValue = await storage.getSessionItem(
       StorageKeys.refreshToken,
-    );
+    ) as string;
+
 
     if (!refreshTokenValue) {
       console.error("No refresh token found");