@vtex/faststore-plugin-buyer-portal 1.1.112 → 1.1.114

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vtex/faststore-plugin-buyer-portal",
-	"version": "1.1.112",
+	"version": "1.1.114",
 	"description": "A plugin for faststore with buyer portal",
 	"main": "index.js",
 	"scripts": {

package/src/features/buying-policies/utils/orderFieldsCriteriaOptions.ts

@@ -13,11 +13,12 @@ export const orderFieldsCriteriaOptions = [
   {
     label: "If the order contains an exceeded budget",
     criteria:
-      "$exists(budgetData.unitAllocations.**.budgetBalance[remaining < 0])",
+      "$exists(budgetData.budgets.**.allocations[balance.remaining < 0])",
   },
   {
     label: "If the order contains an expired budget Pending confirmation",
-    criteria: "$exists(budgetData.unitAllocations.*[budgetEndDate < $now()])",
+    criteria:
+      "$exists(budgetData.budgets.**.cycleConfiguration[$toMillis(endDate) < $millis()])",
   },
   {
     label: "If the order contains a PO number",

package/src/features/shared/hooks/useCookieMonitor.ts

@@ -24,19 +24,33 @@ export const useCookieMonitor = () => {
         cookie.trim().startsWith(`${cookieName}=`)
       );
 
-      return !!authCookie && authCookie.split("=")[1]?.trim() !== "";
+      const hasCookieValue =
+        !!authCookie && authCookie.split("=")[1]?.trim() !== "";
+
+      console.log("[useCookieMonitor] Checking cookie:", {
+        cookieName,
+        hasCookie: hasCookieValue,
+        cookieValue: authCookie
+          ? authCookie.split("=")[1]?.substring(0, 10) + "..."
+          : "none",
+      });
+
+      return hasCookieValue;
     };
 
     // Check immediately
     const initialCheck = checkCookie();
+    console.log("[useCookieMonitor] Initial check:", initialCheck);
     setHasCookie(initialCheck);
 
     // If no cookie yet, poll for it
     if (!initialCheck) {
+      console.log("[useCookieMonitor] Starting cookie polling...");
       const interval = setInterval(() => {
         const hasAuthCookie = checkCookie();
 
         if (hasAuthCookie) {
+          console.log("[useCookieMonitor] Cookie found! Stopping poll.");
           setHasCookie(true);
           clearInterval(interval);
         }
@@ -44,6 +58,7 @@ export const useCookieMonitor = () => {
 
       // Cleanup after 5 seconds max
       const timeout = setTimeout(() => {
+        console.log("[useCookieMonitor] Polling timeout reached (5s)");
         clearInterval(interval);
       }, 5000);
 

package/src/features/shared/utils/withAuth.tsx

@@ -1,4 +1,4 @@
-import { useEffect, type ComponentType } from "react";
+import { useEffect, useRef, type ComponentType } from "react";
 
 import { useRouter } from "next/router";
 
@@ -17,17 +17,42 @@ export const withAuth = <T extends Record<string, unknown>>(
   return function AuthenticatedComponent(props: AuthRouteProps<T>) {
     const router = useRouter();
     const hasCookie = useCookieMonitor();
+    const reloadAttemptedRef = useRef(false);
+
+    // Debug logging
+    useEffect(() => {
+      console.log("[withAuth] Props state:", {
+        authorized: props?.authorized,
+        loading: props?.loading,
+        hasCookie,
+        reloadAttempted: reloadAttemptedRef.current,
+      });
+    }, [props?.authorized, props?.loading, hasCookie]);
 
     useEffect(() => {
       // If not authorized and not loading, reload the page
-      if (!props?.authorized && !props?.loading) {
-        router.reload();
+      if (
+        !props?.authorized &&
+        !props?.loading &&
+        !reloadAttemptedRef.current
+      ) {
+        console.log("[withAuth] Reloading: not authorized and not loading");
+        reloadAttemptedRef.current = true;
+        // Use replace to bypass Next.js data cache
+        router.replace(router.asPath);
       }
     }, [props?.authorized, props?.loading, router]);
 
     useEffect(() => {
-      if (props?.loading && hasCookie) {
-        router.reload();
+      if (props?.loading && hasCookie && !reloadAttemptedRef.current) {
+        console.log(
+          "[withAuth] Cookie available, performing hard reload to bypass cache"
+        );
+        reloadAttemptedRef.current = true;
+        // Hard reload to completely bypass Next.js cache
+        if (typeof window !== "undefined") {
+          window.location.href = router.asPath;
+        }
       }
     }, [props?.loading, hasCookie, router]);
 

package/src/features/shared/utils/withAuthLoader.ts

@@ -20,7 +20,13 @@ export const withAuthLoader = async <T>(
     // Check if auth cookie exists before proceeding
     const authCookie = getAuthCookie(data);
 
+    console.log("[withAuthLoader] Cookie check:", {
+      hasCookie: !!authCookie,
+      cookieLength: authCookie?.length,
+    });
+
     if (!authCookie || authCookie === "") {
+      console.log("[withAuthLoader] Returning loading state (no cookie)");
       return {
         authorized: false,
         loading: true,
@@ -31,7 +37,10 @@ export const withAuthLoader = async <T>(
 
     const hasAccess = await validateAccessService({ cookie });
 
+    console.log("[withAuthLoader] Access validation result:", hasAccess);
+
     if (!hasAccess) {
+      console.log("[withAuthLoader] Access denied, redirecting to /");
       data.res?.writeHead(302, { Location: "/" });
       data.res?.end();
 
@@ -43,6 +52,9 @@ export const withAuthLoader = async <T>(
 
     const pageData = await dataLoader({ cookie, userId, ...clientContext });
 
+    console.log(
+      "[withAuthLoader] Successfully loaded data, returning authorized"
+    );
     return {
       authorized: true,
       data: pageData,
@@ -50,7 +62,7 @@ export const withAuthLoader = async <T>(
       loading: false,
     };
   } catch (error) {
-    console.error("Auth validation failed:", error);
+    console.error("[withAuthLoader] Auth validation failed:", error);
 
     data.res?.writeHead(302, { Location: "/" });
     data.res?.end();

package/src/features/shared/utils/withAuthProvider.tsx

@@ -1,4 +1,4 @@
-import { useEffect, type ComponentType } from "react";
+import { useEffect, useRef, type ComponentType } from "react";
 
 import { useRouter } from "next/router";
 
@@ -19,23 +19,61 @@ export const withAuthProvider = <T,>(
   return function WrappedPage(props: AuthRouteProps<T>) {
     const router = useRouter();
     const hasCookie = useCookieMonitor();
+    const reloadAttemptedRef = useRef(false);
+    const isProduction = process.env.NODE_ENV === "production";
+
+    // Debug logging (only in development or when needed)
+    useEffect(() => {
+      if (!isProduction) {
+        console.log("[withAuthProvider] Props state:", {
+          authorized: props?.authorized,
+          loading: props?.loading,
+          hasCookie,
+          reloadAttempted: reloadAttemptedRef.current,
+          routerPath: router.asPath,
+        });
+      }
+    }, [
+      props?.authorized,
+      props?.loading,
+      hasCookie,
+      router.asPath,
+      isProduction,
+    ]);
 
     useEffect(() => {
       // Se não está autorizado e não está carregando, recarrega a página
-      if (!props?.authorized && !props?.loading) {
-        router.reload();
+      if (
+        !props?.authorized &&
+        !props?.loading &&
+        !reloadAttemptedRef.current
+      ) {
+        console.log(
+          "[withAuthProvider] Reloading: not authorized and not loading"
+        );
+        reloadAttemptedRef.current = true;
+        // Use replace to bypass Next.js data cache
+        router.replace(router.asPath);
       }
     }, [props?.authorized, props?.loading, router]);
 
     useEffect(() => {
-      // If we're in loading state and cookie becomes available, reload to fetch data
-      if (props?.loading && hasCookie) {
-        router.reload();
+      // If we're in loading state and cookie becomes available, do hard reload
+      if (props?.loading && hasCookie && !reloadAttemptedRef.current) {
+        console.log(
+          "[withAuthProvider] Cookie available, performing hard reload to bypass cache"
+        );
+        reloadAttemptedRef.current = true;
+        // Hard reload to completely bypass Next.js cache
+        if (typeof window !== "undefined") {
+          window.location.href = router.asPath;
+        }
       }
     }, [props?.loading, hasCookie, router]);
 
     if (!props?.authorized) {
       if (props?.loading) {
+        console.log("[withAuthProvider] Loading state");
         return <PageLoader />;
       }
       return null;