@jmruthers/pace-core 0.5.189 → 0.5.190

package/dist/{chunk-VGZZXKBR.js → chunk-J2XXC7R5.js}

@@ -1,3 +1,7 @@
+import {
+  getAppConfigByName,
+  isSuperAdmin
+} from "./chunk-RUYZKXOD.js";
 import {
   assertOrganisationId,
   assertUserId
@@ -653,6 +657,17 @@ var OrganisationService = class extends BaseService {
   }
   // Additional methods for testing
   setSelectedOrganisation(organisation) {
+    if (organisation && this._organisations.length > 0) {
+      const isValidOrg = this._organisations.some((org) => org.id === organisation.id);
+      if (!isValidOrg) {
+        logger.warn("OrganisationService", "Attempted to set invalid organisation - not in user's accessible organisations", {
+          organisationId: organisation.id,
+          organisationName: organisation.name,
+          accessibleOrgIds: this._organisations.map((o) => o.id)
+        });
+        return;
+      }
+    }
     this._selectedOrganisation = organisation;
     if (organisation) {
       localStorage.setItem("pace-core-selected-organisation", JSON.stringify(organisation));
@@ -1009,17 +1024,31 @@ var OrganisationService = class extends BaseService {
       if (!initialOrg) {
         throw new Error("No valid organisation found for user");
       }
+      const currentSelectedOrg = this._selectedOrganisation;
+      if (currentSelectedOrg && !activeOrgs.some((org) => org.id === currentSelectedOrg.id)) {
+        logger.warn("OrganisationService", "Current selected organisation is no longer valid, resetting", {
+          invalidOrgId: currentSelectedOrg.id,
+          validOrgIds: activeOrgs.map((o) => o.id)
+        });
+        this._selectedOrganisation = null;
+      }
       this._selectedOrganisation = initialOrg;
       localStorage.setItem("pace-core-selected-organisation", JSON.stringify(initialOrg));
       await this.setDatabaseOrganisationContext(initialOrg);
       this.retryCount = 0;
       this.hasFailedRef = false;
     } catch (err) {
-      logger.error("OrganisationService", "Failed to load organisations:", err);
-      this._error = err;
+      const error = err;
+      if (error.message === "User has no access to active organisations") {
+        logger.warn("OrganisationService", "User has no active organisations (this is expected for users without organisation access):", error);
+      } else {
+        logger.error("OrganisationService", "Failed to load organisations:", err);
+      }
+      this._error = error;
       this.retryCount = this.retryCount + 1;
       this.hasFailedRef = true;
       this.clearAllCachedData();
+      this._isContextReady = true;
     } finally {
       this.isLoadingRef = false;
       this._isLoading = false;
@@ -1058,7 +1087,12 @@ function OrganisationServiceProvider({
     let isMounted = true;
     organisationService.initialize().catch((error) => {
       if (isMounted) {
-        logger.error("OrganisationServiceProvider", "Failed to initialize organisation service:", error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage === "User has no access to active organisations") {
+          logger.warn("OrganisationServiceProvider", "User has no active organisations (this is expected for users without organisation access):", error);
+        } else {
+          logger.error("OrganisationServiceProvider", "Failed to initialize organisation service:", error);
+        }
       }
     });
     return () => {
@@ -1095,6 +1129,10 @@ var EventService = class extends BaseService {
     this.appName = "";
     this.selectedOrganisation = null;
     this.setSelectedEventId = null;
+    this.isSuperAdmin = false;
+    // Track super admin status for conditional validation
+    this.appConfig = null;
+    // Cache app config to avoid repeated lookups
     // Internal state management
     this.isInitializedRef = false;
     this.isFetchingRef = false;
@@ -1120,6 +1158,7 @@ var EventService = class extends BaseService {
     const newOrgId = selectedOrganisation?.id;
     const previousUserId = this.user?.id || null;
     const newUserId = user?.id || null;
+    const previousAppName = this.appName;
     if (previousUserId !== newUserId) {
       if (previousUserId !== null) {
         await this.clearEventSelectionForUser(previousUserId);
@@ -1128,6 +1167,9 @@ var EventService = class extends BaseService {
         this.selectedEvent = null;
         this.setSelectedEventId?.(null);
       }
+      this.resetInitialization();
+      this.isInitializedRef = false;
+      this.isFetchingRef = false;
     }
     this.supabaseClient = supabaseClient;
     this.user = user;
@@ -1135,6 +1177,23 @@ var EventService = class extends BaseService {
     this.appName = appName;
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
+    if (previousAppName !== appName) {
+      this.appConfig = null;
+    }
+    if (user?.id) {
+      try {
+        this.isSuperAdmin = await isSuperAdmin(user.id);
+        logger.debug("EventService", "Updated super admin status", {
+          userId: user.id,
+          isSuperAdmin: this.isSuperAdmin
+        });
+      } catch (error) {
+        logger.warn("EventService", "Failed to check super admin status", { error });
+        this.isSuperAdmin = false;
+      }
+    } else {
+      this.isSuperAdmin = false;
+    }
     if (previousOrgId !== newOrgId) {
       this.resetInitialization();
       this.isInitializedRef = false;
@@ -1165,18 +1224,6 @@ var EventService = class extends BaseService {
   // Event methods
   setSelectedEvent(event) {
     if (event) {
-      try {
-        if (this.selectedOrganisation && event.organisation_id !== this.selectedOrganisation.id) {
-          logger.error("EventService", "Event organisation_id does not match selected organisation", {
-            eventOrganisationId: event.organisation_id,
-            selectedOrganisationId: this.selectedOrganisation.id,
-            eventName: event.event_name
-          });
-          return;
-        }
-      } catch (error) {
-        logger.error("EventService", "Error during event validation:", error);
-      }
       this.selectedEvent = event;
       this.setSelectedEventId?.(event.event_id);
       this.persistEventSelection(event.event_id).catch((error) => {
@@ -1273,16 +1320,31 @@ var EventService = class extends BaseService {
   }
   // Lifecycle methods
   async initialize() {
+    logger.debug("EventService", "initialize() called", {
+      isInitializedRef: this.isInitializedRef,
+      hasUser: !!this.user,
+      hasSession: !!this.session,
+      appName: this.appName
+    });
     await super.initialize();
   }
   cleanup() {
     super.cleanup();
   }
   async doInitialize() {
+    logger.debug("EventService", "doInitialize() called", {
+      isInitializedRef: this.isInitializedRef,
+      isFetchingRef: this.isFetchingRef,
+      hasUser: !!this.user,
+      hasSession: !!this.session,
+      appName: this.appName
+    });
     if (this.isInitializedRef) {
+      logger.debug("EventService", "Skipping initialization - already initialized");
       return;
     }
     if (this.isFetchingRef) {
+      logger.debug("EventService", "Skipping initialization - already fetching");
       return;
     }
     try {
@@ -1292,31 +1354,107 @@ var EventService = class extends BaseService {
     } catch (error) {
       logger.warn("EventService", "Failed to clean up old storage keys:", error);
     }
-    if (!this.user || !this.selectedOrganisation) {
+    if (!this.user) {
+      logger.debug("EventService", "Skipping initialization - missing user");
       return;
     }
+    logger.debug("EventService", "Initializing - fetching events", {
+      userId: this.user.id,
+      organisationId: this.selectedOrganisation?.id || "derived-from-event",
+      appName: this.appName
+    });
     await this.fetchEvents(false);
+    this.isInitializedRef = true;
   }
   doCleanup() {
   }
   async fetchEvents(skipLoadPersisted = false) {
-    if (!this.user || !this.session || !this.supabaseClient || !this.appName || !this.selectedOrganisation) {
+    if (!this.user || !this.session || !this.supabaseClient || !this.appName) {
+      logger.debug("EventService", "Skipping fetchEvents - missing dependencies", {
+        hasUser: !!this.user,
+        hasSession: !!this.session,
+        hasSupabaseClient: !!this.supabaseClient,
+        appName: this.appName
+      });
       this.notify();
       return;
     }
     this._isLoading = true;
     this.notify();
     if (this.isFetchingRef) {
+      logger.debug("EventService", "Skipping fetchEvents - already fetching");
       return;
     }
     this.isFetchingRef = true;
     let isMounted = true;
     try {
-      const { data, error: rpcError } = await this.supabaseClient.rpc("data_user_events_get", {
+      if (!this.appConfig && this.appName) {
+        try {
+          this.appConfig = await getAppConfigByName(this.appName);
+        } catch (configError) {
+          logger.warn("EventService", "Failed to load app config, defaulting to event-required", {
+            error: configError
+          });
+          this.appConfig = { requires_event: true };
+        }
+      }
+      let organisationIdForRpc = null;
+      let userIsSuperAdmin = false;
+      try {
+        userIsSuperAdmin = await isSuperAdmin(this.user.id);
+        if (userIsSuperAdmin) {
+          organisationIdForRpc = null;
+          logger.debug("EventService", "Super admin detected - fetching all events", {
+            userId: this.user.id
+          });
+        } else {
+          if (this.selectedEvent) {
+            organisationIdForRpc = this.selectedEvent.organisation_id;
+          } else if (this.appConfig?.requires_event === true) {
+            organisationIdForRpc = null;
+            logger.debug("EventService", "Event-required app: fetching all accessible events (no event selected yet)", {
+              userId: this.user.id,
+              appName: this.appName
+            });
+          } else if (this.selectedOrganisation) {
+            organisationIdForRpc = this.selectedOrganisation.id;
+          } else {
+            logger.warn("EventService", "No organisation context available for event fetch", {
+              hasSelectedEvent: !!this.selectedEvent,
+              hasSelectedOrganisation: !!this.selectedOrganisation,
+              appRequiresEvent: this.appConfig?.requires_event
+            });
+            organisationIdForRpc = null;
+          }
+        }
+      } catch (superAdminCheckError) {
+        logger.warn("EventService", "Failed to check super admin status, using organisation-scoped query", {
+          error: superAdminCheckError
+        });
+        if (this.selectedEvent) {
+          organisationIdForRpc = this.selectedEvent.organisation_id;
+        } else if (this.appConfig?.requires_event === true) {
+          organisationIdForRpc = null;
+        } else if (this.selectedOrganisation) {
+          organisationIdForRpc = this.selectedOrganisation.id;
+        }
+      }
+      logger.debug("EventService", "Fetching events via RPC", {
+        userId: this.user.id,
+        organisationId: organisationIdForRpc,
+        appName: this.appName
+      });
+      let { data, error: rpcError } = await this.supabaseClient.rpc("data_user_events_get", {
         p_user_id: this.user.id,
-        p_organisation_id: this.selectedOrganisation.id,
+        p_organisation_id: organisationIdForRpc,
         p_app_name: this.appName
       });
+      logger.debug("EventService", "RPC response received", {
+        hasData: !!data,
+        dataLength: Array.isArray(data) ? data.length : "not array",
+        hasError: !!rpcError,
+        error: rpcError
+      });
       if (rpcError) {
         logger.error("EventService", "RPC error fetching events:", rpcError);
         throw new Error(rpcError.message || "Failed to fetch events");
@@ -1428,24 +1566,41 @@ function EventServiceProvider({
   setSelectedEventId
 }) {
   const eventServiceRef = useRef2(null);
+  const initializingRef = useRef2(false);
   if (!eventServiceRef.current) {
     eventServiceRef.current = new EventService(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
   }
   const eventService = eventServiceRef.current;
   useEffect3(() => {
     let isMounted = true;
+    if (initializingRef.current) {
+      return;
+    }
     const updateAndInitialize = async () => {
-      await eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
-      if (!isMounted) return;
-      await eventService.initialize().catch((error) => {
-        if (isMounted) {
-          logger.error("EventServiceProvider", "Failed to initialize event service:", error);
-        }
-      });
+      initializingRef.current = true;
+      try {
+        logger.debug("EventServiceProvider", "Updating dependencies and initializing", {
+          hasUser: !!user,
+          hasSession: !!session,
+          appName,
+          hasSelectedOrganisation: !!selectedOrganisation,
+          organisationId: selectedOrganisation?.id
+        });
+        await eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
+        if (!isMounted) return;
+        await eventService.initialize().catch((error) => {
+          if (isMounted) {
+            logger.error("EventServiceProvider", "Failed to initialize event service:", error);
+          }
+        });
+      } finally {
+        initializingRef.current = false;
+      }
     };
     updateAndInitialize();
     return () => {
       isMounted = false;
+      initializingRef.current = false;
     };
   }, [supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
   useEffect3(() => {
@@ -1750,8 +1905,10 @@ function InactivityServiceProvider({
   supabaseClient,
   user,
   session,
-  idleTimeoutMs = 30 * 60 * 1e3,
-  warnBeforeMs = 60 * 1e3,
+  idleTimeoutMs,
+  // REQUIRED: No default - must be explicitly provided
+  warnBeforeMs,
+  // REQUIRED: No default - must be explicitly provided
   onIdleLogout
 }) {
   const inactivityServiceRef = useRef3(null);
@@ -1810,6 +1967,29 @@ function useOrganisationService() {
   return context.organisationService;
 }
 
+// src/hooks/useOrganisations.ts
+function useOrganisations() {
+  const organisationService = useOrganisationService();
+  const selectedOrg = organisationService.getSelectedOrganisation();
+  return {
+    selectedOrganisation: selectedOrg,
+    organisations: organisationService.getOrganisations(),
+    userMemberships: organisationService.getUserMemberships(),
+    isLoading: organisationService.isLoading(),
+    error: organisationService.getError(),
+    hasValidOrganisationContext: organisationService.hasValidOrganisationContext(),
+    isContextReady: organisationService.isContextReady(),
+    setSelectedOrganisation: (org) => organisationService.setSelectedOrganisation(org),
+    switchOrganisation: (orgId) => organisationService.switchOrganisation(orgId),
+    getUserRole: (orgId) => organisationService.getUserRole(orgId),
+    validateOrganisationAccess: (orgId) => organisationService.validateOrganisationAccess(orgId),
+    refreshOrganisations: () => organisationService.refreshOrganisations(),
+    ensureOrganisationContext: () => organisationService.ensureOrganisationContext(),
+    isOrganisationSecure: () => organisationService.isOrganisationSecure(),
+    getPrimaryOrganisation: () => organisationService.getPrimaryOrganisation()
+  };
+}
+
 // src/hooks/services/useEventService.ts
 import { useContext as useContext3, useReducer as useReducer3, useEffect as useEffect7 } from "react";
 function useEventService() {
@@ -1893,6 +2073,7 @@ function UnifiedAuthContextProvider({
   appName,
   appConfig = { requires_event: true },
   // Default to requiring events
+  supabaseClient: supabaseClientProp,
   ...props
 }) {
   const authService = useAuthService();
@@ -1932,15 +2113,31 @@ function UnifiedAuthContextProvider({
   const currentUser = authService.getUser();
   const currentSession = authService.getSession();
   const isAuth = !!(currentUser && currentSession);
-  const supabase = authService.getSupabaseClient();
+  const supabase = useMemo6(() => supabaseClientProp, [supabaseClientProp]);
   const [appId, setAppId] = useState3(void 0);
   const isResolvingAppIdRef = useRef4(false);
+  const resolvedAppIdRef = useRef4(void 0);
+  const resolvedUserIdRef = useRef4(void 0);
   useEffect10(() => {
-    if (isAuth && currentUser?.id && supabase && appName && !appId && !isResolvingAppIdRef.current) {
+    if (!isAuth) {
+      resolvedAppIdRef.current = void 0;
+      resolvedUserIdRef.current = void 0;
+      setAppId(void 0);
+      return;
+    }
+    if (currentUser?.id && resolvedUserIdRef.current && resolvedUserIdRef.current !== currentUser.id) {
+      resolvedAppIdRef.current = void 0;
+      resolvedUserIdRef.current = void 0;
+      setAppId(void 0);
+    }
+    const currentUserId = currentUser?.id;
+    if (isAuth && currentUserId && supabase && appName && resolvedUserIdRef.current !== currentUserId && // Haven't resolved for this user yet
+    !isResolvingAppIdRef.current) {
       isResolvingAppIdRef.current = true;
-      const userId = currentUser.id;
+      resolvedUserIdRef.current = currentUserId;
+      const userId = currentUserId;
       const appNameValue = appName;
-      import("./api-YP7XD5L6.js").then(async ({ resolveAppContext, setupRBAC }) => {
+      import("./api-I6UCQ5S6.js").then(async ({ resolveAppContext, setupRBAC }) => {
         try {
           setupRBAC(supabase);
           const result = await resolveAppContext({
@@ -1948,11 +2145,14 @@ function UnifiedAuthContextProvider({
             appName: appNameValue
           });
           if (result?.appId) {
+            resolvedAppIdRef.current = result.appId;
             setAppId(result.appId);
             logger.debug("UnifiedAuthProvider", "appId resolved on login", {
               appId: result.appId,
               appName: appNameValue
             });
+          } else {
+            resolvedUserIdRef.current = void 0;
           }
         } catch (error) {
           logger.error("UnifiedAuthProvider", "Failed to resolve appId on login", {
@@ -1960,41 +2160,64 @@ function UnifiedAuthContextProvider({
             appName: appNameValue,
             userId
           });
+          resolvedUserIdRef.current = void 0;
         } finally {
           isResolvingAppIdRef.current = false;
         }
       }).catch((importError) => {
         logger.error("UnifiedAuthProvider", "Failed to import RBAC API", importError);
         isResolvingAppIdRef.current = false;
+        resolvedUserIdRef.current = void 0;
       });
     }
-    if (!isAuth) {
-      setAppId(void 0);
-    }
-  }, [isAuth, currentUser?.id, supabase, appName, appId]);
+  }, [isAuth, currentUser?.id, supabase, appName]);
   const [, forceUpdate] = useReducer5((x) => x + 1, 0);
+  const forceUpdateTimeoutRef = useRef4(null);
+  const debouncedForceUpdate = useCallback(() => {
+    if (forceUpdateTimeoutRef.current) {
+      clearTimeout(forceUpdateTimeoutRef.current);
+    }
+    forceUpdateTimeoutRef.current = setTimeout(() => {
+      forceUpdate();
+      forceUpdateTimeoutRef.current = null;
+    }, 0);
+  }, [forceUpdate]);
+  const authServiceRef = useRef4(authService);
+  const organisationServiceRef = useRef4(organisationService);
+  const eventServiceRef = useRef4(eventService);
+  const inactivityServiceRef = useRef4(inactivityService);
+  useEffect10(() => {
+    authServiceRef.current = authService;
+    organisationServiceRef.current = organisationService;
+    eventServiceRef.current = eventService;
+    inactivityServiceRef.current = inactivityService;
+  }, [authService, organisationService, eventService, inactivityService]);
   useEffect10(() => {
-    const unsubscribeAuth = authService.subscribe(() => forceUpdate());
-    const unsubscribeOrg = organisationService.subscribe(() => forceUpdate());
-    const unsubscribeEvent = eventService.subscribe(() => forceUpdate());
-    const unsubscribeInactivity = inactivityService.subscribe(() => forceUpdate());
+    const unsubscribeAuth = authServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubscribeOrg = organisationServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubscribeEvent = eventServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubscribeInactivity = inactivityServiceRef.current.subscribe(debouncedForceUpdate);
     return () => {
       unsubscribeAuth();
       unsubscribeOrg();
       unsubscribeEvent();
       unsubscribeInactivity();
+      if (forceUpdateTimeoutRef.current) {
+        clearTimeout(forceUpdateTimeoutRef.current);
+      }
     };
-  }, [authService, organisationService, eventService, inactivityService]);
+  }, [debouncedForceUpdate]);
   const authLoading = authService.isLoading();
   const orgLoading = organisationService.isLoading();
   const eventLoading = eventService.isLoading();
   const restorationLoading = sessionRestoration.isRestoring && !sessionRestorationTimedOut && !sessionRestoration.restorationError;
   const totalLoading = restorationLoading || authLoading || orgLoading || eventLoading;
   const authError = authService.getError();
-  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  const rawSelectedOrganisation = organisationService.getSelectedOrganisation();
   const organisations = organisationService.getOrganisations();
   const userMemberships = organisationService.getUserMemberships();
   const organisationError = organisationService.getError();
+  const selectedOrganisation = appConfig?.requires_event ? null : rawSelectedOrganisation;
   const hasValidOrganisationContext = organisationService.hasValidOrganisationContext();
   const isContextReady = organisationService.isContextReady();
   const events = eventService.getEvents();
@@ -2170,10 +2393,13 @@ function EventServiceProviderWrapper({
   supabaseClient,
   user,
   session,
-  appName
+  appName,
+  appConfig
 }) {
-  const organisationService = useOrganisationService();
-  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  const { selectedOrganisation: rawSelectedOrganisation } = useOrganisations();
+  const selectedOrganisation = appConfig?.requires_event ? null : rawSelectedOrganisation;
+  const setSelectedEventId = useCallback(() => {
+  }, []);
   return /* @__PURE__ */ jsx5(
     EventServiceProvider,
     {
@@ -2182,8 +2408,7 @@ function EventServiceProviderWrapper({
       session,
       appName,
       selectedOrganisation,
-      setSelectedEventId: () => {
-      },
+      setSelectedEventId,
       children
     }
   );
@@ -2216,6 +2441,7 @@ function ServiceAwareProviders({
           user: authService.getUser(),
           session: authService.getSession(),
           appName,
+          appConfig,
           children: /* @__PURE__ */ jsx5(
             InactivityServiceProvider,
             {
@@ -2258,11 +2484,12 @@ function UnifiedAuthProvider({
   persistState = true,
   enablePersistence,
   requireOrganisationContext = true,
-  idleTimeoutMs = 30 * 60 * 1e3,
-  // 30 minutes
-  warnBeforeMs = 60 * 1e3,
-  // 60 seconds
+  idleTimeoutMs,
+  // REQUIRED: No default - must be explicitly provided
+  warnBeforeMs,
+  // REQUIRED: No default - must be explicitly provided
   onIdleLogout,
+  // REQUIRED: No default - must be explicitly provided
   renderInactivityWarning,
   dangerouslyDisableInactivity = false
 }) {
@@ -2307,6 +2534,7 @@ export {
   InactivityServiceProvider,
   useAuthService,
   useOrganisationService,
+  useOrganisations,
   useEventService,
   useInactivityService,
   useSessionRestoration,
@@ -2314,4 +2542,4 @@ export {
   useUnifiedAuth,
   UnifiedAuthProvider
 };
-//# sourceMappingURL=chunk-VGZZXKBR.js.map
+//# sourceMappingURL=chunk-J2XXC7R5.js.map