@basictech/react 0.7.0-beta.3 → 0.7.0-beta.5

package/dist/index.mjs

@@ -139,15 +139,15 @@ var BasicSync = class extends Dexie2 {
     this.version(2).stores({});
     this.Collection.prototype.get = this.Collection.prototype.toArray;
   }
-  async connect({ access_token }) {
-    const WS_URL = `wss://pds.basic.id/ws`;
+  async connect({ access_token, ws_url }) {
+    const WS_URL = ws_url || "wss://pds.basic.id/ws";
     log("Connecting to", WS_URL);
     await this.updateSyncNodes();
     log("Starting connection...");
     return this.syncable.connect("websocket", WS_URL, { authToken: access_token, schema: this.basic_schema });
   }
-  async disconnect() {
-    const WS_URL = `wss://pds.basic.id/ws`;
+  async disconnect({ ws_url } = {}) {
+    const WS_URL = ws_url || "wss://pds.basic.id/ws";
     return this.syncable.disconnect(WS_URL);
   }
   async updateSyncNodes() {
@@ -251,7 +251,7 @@ var BasicSync = class extends Dexie2 {
 };
 
 // package.json
-var version = "0.7.0-beta.2";
+var version = "0.7.0-beta.4";
 
 // src/updater/versionUpdater.ts
 var VersionUpdater = class {
@@ -394,6 +394,8 @@ var STORAGE_KEYS = {
   REFRESH_TOKEN: "basic_refresh_token",
   USER_INFO: "basic_user_info",
   AUTH_STATE: "basic_auth_state",
+  REDIRECT_URI: "basic_redirect_uri",
+  SERVER_URL: "basic_server_url",
   DEBUG: "basic_debug"
 };
 function getCookie(name) {
@@ -591,6 +593,11 @@ async function validateAndCheckSchema(schema) {
 
 // src/AuthContext.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_AUTH_CONFIG = {
+  scopes: "profile,email,app:admin",
+  server_url: "https://api.basic.tech",
+  ws_url: "wss://pds.basic.id/ws"
+};
 var BasicContext = createContext({
   unicorn: "\u{1F984}",
   isAuthReady: false,
@@ -611,7 +618,8 @@ function BasicProvider({
   project_id,
   schema,
   debug = false,
-  storage
+  storage,
+  auth
 }) {
   const [isAuthReady, setIsAuthReady] = useState(false);
   const [isSignedIn, setIsSignedIn] = useState(false);
@@ -625,6 +633,13 @@ function BasicProvider({
   const [pendingRefresh, setPendingRefresh] = useState(false);
   const syncRef = useRef(null);
   const storageAdapter = storage || new LocalStorageAdapter();
+  const authConfig = {
+    scopes: auth?.scopes || DEFAULT_AUTH_CONFIG.scopes,
+    server_url: auth?.server_url || DEFAULT_AUTH_CONFIG.server_url,
+    ws_url: auth?.ws_url || DEFAULT_AUTH_CONFIG.ws_url
+  };
+  const scopesString = Array.isArray(authConfig.scopes) ? authConfig.scopes.join(" ") : authConfig.scopes;
+  const refreshPromiseRef = useRef(null);
   const isDevMode = () => isDevelopment(debug);
   const cleanOAuthParams = () => cleanOAuthParamsFromUrl();
   useEffect(() => {
@@ -712,7 +727,10 @@ function BasicProvider({
           return;
         }
         log("connecting to db...");
-        syncRef.current?.connect({ access_token: tok }).catch((e) => {
+        syncRef.current?.connect({
+          access_token: tok,
+          ws_url: authConfig.ws_url
+        }).catch((e) => {
           log("error connecting to db", e);
         });
       }
@@ -722,6 +740,17 @@ function BasicProvider({
   useEffect(() => {
     const initializeAuth = async () => {
       await storageAdapter.set(STORAGE_KEYS.DEBUG, debug ? "true" : "false");
+      const storedServerUrl = await storageAdapter.get(STORAGE_KEYS.SERVER_URL);
+      if (storedServerUrl && storedServerUrl !== authConfig.server_url) {
+        log("Server URL changed, clearing stored tokens");
+        await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
+        await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
+        await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE);
+        await storageAdapter.remove(STORAGE_KEYS.REDIRECT_URI);
+        clearCookie("basic_token");
+        clearCookie("basic_access_token");
+      }
+      await storageAdapter.set(STORAGE_KEYS.SERVER_URL, authConfig.server_url);
       try {
         const versionUpdater = createVersionUpdater(storageAdapter, version, getMigrations());
         const updateResult = await versionUpdater.checkAndUpdate();
@@ -792,16 +821,21 @@ function BasicProvider({
   useEffect(() => {
     async function fetchUser(acc_token) {
       console.info("fetching user");
-      const user2 = await fetch("https://api.basic.tech/auth/userInfo", {
-        method: "GET",
-        headers: {
-          "Authorization": `Bearer ${acc_token}`
+      try {
+        const response = await fetch(`${authConfig.server_url}/auth/userInfo`, {
+          method: "GET",
+          headers: {
+            "Authorization": `Bearer ${acc_token}`
+          }
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to fetch user info: ${response.status}`);
+        }
+        const user2 = await response.json();
+        if (user2.error) {
+          log("error fetching user", user2.error);
+          throw new Error(`User info error: ${user2.error}`);
         }
-      }).then((response) => response.json()).catch((error2) => log("Error:", error2));
-      if (user2.error) {
-        log("error fetching user", user2.error);
-        return;
-      } else {
         if (token?.refresh_token) {
           await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, token.refresh_token);
         }
@@ -812,6 +846,9 @@ function BasicProvider({
         setUser(user2);
         setIsSignedIn(true);
         setIsAuthReady(true);
+      } catch (error2) {
+        log("Failed to fetch user info:", error2);
+        setIsAuthReady(true);
       }
     }
     async function checkToken() {
@@ -821,7 +858,8 @@ function BasicProvider({
         return;
       }
       const decoded = jwtDecode(token?.access_token);
-      const isExpired = decoded.exp && decoded.exp < Date.now() / 1e3;
+      const expirationBuffer = 5;
+      const isExpired = decoded.exp && decoded.exp < Date.now() / 1e3 + expirationBuffer;
       if (isExpired) {
         log("token is expired - refreshing ...");
         try {
@@ -856,13 +894,15 @@ function BasicProvider({
       if (!redirectUrl || !redirectUrl.startsWith("http://") && !redirectUrl.startsWith("https://")) {
         throw new Error("Invalid redirect URI provided");
       }
-      let baseUrl = "https://api.basic.tech/auth/authorize";
+      await storageAdapter.set(STORAGE_KEYS.REDIRECT_URI, redirectUrl);
+      log("Stored redirect_uri for token exchange:", redirectUrl);
+      let baseUrl = `${authConfig.server_url}/auth/authorize`;
       baseUrl += `?client_id=${project_id}`;
       baseUrl += `&redirect_uri=${encodeURIComponent(redirectUrl)}`;
       baseUrl += `&response_type=code`;
-      baseUrl += `&scope=profile`;
+      baseUrl += `&scope=${encodeURIComponent(scopesString)}`;
       baseUrl += `&state=${randomState}`;
-      log("Generated sign-in link successfully");
+      log("Generated sign-in link successfully with scopes:", scopesString);
       return baseUrl;
     } catch (error2) {
       log("Error generating sign-in link:", error2);
@@ -878,7 +918,9 @@ function BasicProvider({
       }
       const signInLink = await getSignInLink();
       log("Generated sign-in link:", signInLink);
-      if (!signInLink || !signInLink.startsWith("https://")) {
+      try {
+        new URL(signInLink);
+      } catch {
         log("Error: Invalid sign-in link generated");
         throw new Error("Failed to generate valid sign-in URL");
       }
@@ -935,6 +977,8 @@ function BasicProvider({
     await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE);
     await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
     await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
+    await storageAdapter.remove(STORAGE_KEYS.REDIRECT_URI);
+    await storageAdapter.remove(STORAGE_KEYS.SERVER_URL);
     if (syncRef.current) {
       (async () => {
         try {
@@ -954,6 +998,18 @@ function BasicProvider({
       const refreshToken = await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN);
       if (refreshToken) {
         log("No token in memory, attempting to refresh from storage");
+        if (refreshPromiseRef.current) {
+          log("Token refresh already in progress, waiting...");
+          try {
+            const newToken = await refreshPromiseRef.current;
+            if (newToken?.access_token) {
+              return newToken.access_token;
+            }
+          } catch (error2) {
+            log("In-flight refresh failed:", error2);
+            throw error2;
+          }
+        }
         try {
           const newToken = await fetchToken(refreshToken, true);
           if (newToken?.access_token) {
@@ -976,9 +1032,24 @@ function BasicProvider({
       throw new Error("no token found");
     }
     const decoded = jwtDecode(token?.access_token);
-    const isExpired = decoded.exp && decoded.exp < Date.now() / 1e3;
+    const expirationBuffer = 5;
+    const isExpired = decoded.exp && decoded.exp < Date.now() / 1e3 + expirationBuffer;
     if (isExpired) {
       log("token is expired - refreshing ...");
+      if (refreshPromiseRef.current) {
+        log("Token refresh already in progress, waiting...");
+        try {
+          const newToken = await refreshPromiseRef.current;
+          return newToken?.access_token || "";
+        } catch (error2) {
+          log("In-flight refresh failed:", error2);
+          if (error2.message.includes("offline") || error2.message.includes("Network")) {
+            log("Network issue - using expired token until network is restored");
+            return token.access_token;
+          }
+          throw error2;
+        }
+      }
       const refreshToken = token?.refresh_token || await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN);
       if (refreshToken) {
         try {
@@ -999,73 +1070,117 @@ function BasicProvider({
     return token?.access_token || "";
   };
   const fetchToken = async (codeOrRefreshToken, isRefreshToken = false) => {
-    try {
-      if (!isOnline) {
-        log("Network is offline, marking refresh as pending");
-        setPendingRefresh(true);
-        throw new Error("Network offline - refresh will be retried when online");
-      }
-      const requestBody = isRefreshToken ? {
-        grant_type: "refresh_token",
-        refresh_token: codeOrRefreshToken
-      } : {
-        grant_type: "authorization_code",
-        code: codeOrRefreshToken
-      };
-      const token2 = await fetch("https://api.basic.tech/auth/token", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(requestBody)
-      }).then((response) => response.json()).catch((error2) => {
-        log("Network error fetching token:", error2);
+    if (isRefreshToken && refreshPromiseRef.current) {
+      log("Reusing in-flight refresh token request");
+      return refreshPromiseRef.current;
+    }
+    const refreshPromise = (async () => {
+      try {
         if (!isOnline) {
+          log("Network is offline, marking refresh as pending");
           setPendingRefresh(true);
           throw new Error("Network offline - refresh will be retried when online");
         }
-        throw new Error("Network error during token refresh");
-      });
-      if (token2.error) {
-        log("error fetching token", token2.error);
-        if (token2.error.includes("network") || token2.error.includes("timeout")) {
-          setPendingRefresh(true);
-          throw new Error("Network issue - refresh will be retried when online");
+        let requestBody;
+        if (isRefreshToken) {
+          requestBody = {
+            grant_type: "refresh_token",
+            refresh_token: codeOrRefreshToken
+          };
+          if (project_id) {
+            requestBody.client_id = project_id;
+          }
+        } else {
+          requestBody = {
+            grant_type: "authorization_code",
+            code: codeOrRefreshToken
+          };
+          const storedRedirectUri = await storageAdapter.get(STORAGE_KEYS.REDIRECT_URI);
+          if (storedRedirectUri) {
+            requestBody.redirect_uri = storedRedirectUri;
+            log("Including redirect_uri in token exchange:", storedRedirectUri);
+          } else {
+            log("Warning: No redirect_uri found in storage for token exchange");
+          }
+          if (project_id) {
+            requestBody.client_id = project_id;
+          }
         }
-        await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
-        await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
-        clearCookie("basic_token");
-        clearCookie("basic_access_token");
-        setUser({});
-        setIsSignedIn(false);
-        setToken(null);
-        setIsAuthReady(true);
-        throw new Error(`Token refresh failed: ${token2.error}`);
-      } else {
-        setToken(token2);
-        setPendingRefresh(false);
-        if (token2.refresh_token) {
-          await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, token2.refresh_token);
-          log("Updated refresh token in storage");
+        log("Token exchange request body:", { ...requestBody, refresh_token: isRefreshToken ? "[REDACTED]" : void 0, code: !isRefreshToken ? "[REDACTED]" : void 0 });
+        const token2 = await fetch(`${authConfig.server_url}/auth/token`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(requestBody)
+        }).then((response) => response.json()).catch((error2) => {
+          log("Network error fetching token:", error2);
+          if (!isOnline) {
+            setPendingRefresh(true);
+            throw new Error("Network offline - refresh will be retried when online");
+          }
+          throw new Error("Network error during token refresh");
+        });
+        if (token2.error) {
+          log("error fetching token", token2.error);
+          if (token2.error.includes("network") || token2.error.includes("timeout")) {
+            setPendingRefresh(true);
+            throw new Error("Network issue - refresh will be retried when online");
+          }
+          await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
+          await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
+          await storageAdapter.remove(STORAGE_KEYS.REDIRECT_URI);
+          await storageAdapter.remove(STORAGE_KEYS.SERVER_URL);
+          clearCookie("basic_token");
+          clearCookie("basic_access_token");
+          setUser({});
+          setIsSignedIn(false);
+          setToken(null);
+          setIsAuthReady(true);
+          throw new Error(`Token refresh failed: ${token2.error}`);
+        } else {
+          setToken(token2);
+          setPendingRefresh(false);
+          if (token2.refresh_token) {
+            await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, token2.refresh_token);
+            log("Updated refresh token in storage");
+          }
+          if (!isRefreshToken) {
+            await storageAdapter.remove(STORAGE_KEYS.REDIRECT_URI);
+            log("Cleaned up redirect_uri from storage after successful exchange");
+          }
+          setCookie("basic_access_token", token2.access_token, { httpOnly: false });
+          setCookie("basic_token", JSON.stringify(token2));
+          log("Updated access token and full token in cookies");
         }
-        setCookie("basic_access_token", token2.access_token, { httpOnly: false });
-        log("Updated access token in cookie");
-      }
-      return token2;
-    } catch (error2) {
-      log("Token refresh error:", error2);
-      if (!error2.message.includes("offline") && !error2.message.includes("Network")) {
-        await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
-        await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
-        clearCookie("basic_token");
-        clearCookie("basic_access_token");
-        setUser({});
-        setIsSignedIn(false);
-        setToken(null);
-        setIsAuthReady(true);
+        return token2;
+      } catch (error2) {
+        log("Token refresh error:", error2);
+        if (!error2.message.includes("offline") && !error2.message.includes("Network")) {
+          await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN);
+          await storageAdapter.remove(STORAGE_KEYS.USER_INFO);
+          await storageAdapter.remove(STORAGE_KEYS.REDIRECT_URI);
+          await storageAdapter.remove(STORAGE_KEYS.SERVER_URL);
+          clearCookie("basic_token");
+          clearCookie("basic_access_token");
+          setUser({});
+          setIsSignedIn(false);
+          setToken(null);
+          setIsAuthReady(true);
+        }
+        throw error2;
       }
-      throw error2;
+    })();
+    if (isRefreshToken) {
+      refreshPromiseRef.current = refreshPromise;
+      refreshPromise.finally(() => {
+        if (refreshPromiseRef.current === refreshPromise) {
+          refreshPromiseRef.current = null;
+          log("Cleared refresh promise reference");
+        }
+      });
     }
+    return refreshPromise;
   };
   const noDb = {
     collection: () => {