@jmruthers/pace-core 0.5.189 → 0.5.191

package/dist/chunk-OETXORNB.js

@@ -0,0 +1,614 @@
+import {
+  useEventService,
+  useUnifiedAuth
+} from "./chunk-6LTQQAT6.js";
+import {
+  ContextValidator,
+  isSuperAdmin
+} from "./chunk-ROXMHMY2.js";
+import {
+  getCurrentAppName,
+  performanceBudgetMonitor
+} from "./chunk-I7PSE6JW.js";
+import {
+  createLogger,
+  logger
+} from "./chunk-PWLANIRT.js";
+
+// src/hooks/useEvents.ts
+import { useMemo, useRef } from "react";
+function useEvents() {
+  const eventService = useEventService();
+  const rawEvents = eventService.getEvents();
+  const selectedEvent = eventService.getSelectedEvent();
+  const isLoading = eventService.isLoading();
+  const error = eventService.getError();
+  const prevEventsRef = useRef([]);
+  const prevEventsIdsRef = useRef("");
+  const currentEventsIds = rawEvents.map((e) => e.event_id || e.id).join(",");
+  const eventsChanged = currentEventsIds !== prevEventsIdsRef.current;
+  if (eventsChanged) {
+    prevEventsRef.current = rawEvents;
+    prevEventsIdsRef.current = currentEventsIds;
+  }
+  const events = useMemo(() => {
+    return prevEventsRef.current;
+  }, [currentEventsIds]);
+  const setSelectedEventCallback = useMemo(
+    () => (event) => eventService.setSelectedEvent(event),
+    [eventService]
+  );
+  const refreshEventsCallback = useMemo(
+    () => () => eventService.refreshEvents(),
+    [eventService]
+  );
+  const clearEventSelectionCallback = useMemo(
+    () => () => eventService.clearEventSelection(),
+    [eventService]
+  );
+  return useMemo(() => ({
+    events,
+    selectedEvent,
+    isLoading,
+    error,
+    setSelectedEvent: setSelectedEventCallback,
+    refreshEvents: refreshEventsCallback,
+    clearEventSelection: clearEventSelectionCallback
+  }), [events, selectedEvent?.event_id, isLoading, error?.message, setSelectedEventCallback, refreshEventsCallback, clearEventSelectionCallback]);
+}
+
+// src/rbac/hooks/useResolvedScope.ts
+import { useEffect, useState, useRef as useRef2, useMemo as useMemo2 } from "react";
+var log = createLogger("useResolvedScope");
+var appConfigCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5 * 60 * 1e3;
+function useResolvedScope({
+  supabase,
+  selectedOrganisationId,
+  selectedEventId
+}) {
+  const [resolvedScope, setResolvedScope] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const stableScopeRef = useRef2({
+    organisationId: "",
+    appId: "",
+    eventId: void 0
+  });
+  useEffect(() => {
+    if (resolvedScope) {
+      const newScope = {
+        organisationId: resolvedScope.organisationId || "",
+        appId: resolvedScope.appId || "",
+        eventId: resolvedScope.eventId
+      };
+      if (stableScopeRef.current.organisationId !== newScope.organisationId || stableScopeRef.current.eventId !== newScope.eventId || stableScopeRef.current.appId !== newScope.appId) {
+        stableScopeRef.current = {
+          organisationId: newScope.organisationId,
+          appId: newScope.appId,
+          eventId: newScope.eventId
+        };
+      }
+    } else {
+      stableScopeRef.current = { organisationId: "", appId: "", eventId: void 0 };
+    }
+  }, [resolvedScope]);
+  const appName = getCurrentAppName();
+  const stableScope = stableScopeRef.current;
+  useEffect(() => {
+    let cancelled = false;
+    const resolveScope = async () => {
+      if (!supabase && !selectedOrganisationId && !selectedEventId) {
+        if (!cancelled) {
+          setResolvedScope(null);
+          setIsLoading(false);
+          setError(null);
+        }
+        return;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        const appName2 = getCurrentAppName();
+        let appId = void 0;
+        let appConfig = null;
+        if (supabase && appName2) {
+          try {
+            const cached = appConfigCache.get(appName2);
+            const now = Date.now();
+            if (cached && now - cached.timestamp < CACHE_TTL) {
+              appId = cached.appId;
+              appConfig = cached.appConfig;
+            } else {
+              const { data: app, error: error2 } = await supabase.from("rbac_apps").select("id, name, requires_event, is_active").eq("name", appName2).eq("is_active", true).single();
+              if (error2) {
+                const { data: inactiveApp } = await supabase.from("rbac_apps").select("id, name, is_active").eq("name", appName2).single();
+                if (inactiveApp) {
+                  log.error(`App "${appName2}" exists but is inactive (is_active: ${inactiveApp.is_active})`);
+                  appId = void 0;
+                } else {
+                  log.error(`App "${appName2}" not found in rbac_apps table`);
+                  appId = void 0;
+                }
+              } else if (app) {
+                appId = app.id;
+                appConfig = { requires_event: app.requires_event ?? false };
+                appConfigCache.set(appName2, { appId, appConfig, timestamp: now });
+              }
+            }
+          } catch (error2) {
+            log.error("Unexpected error resolving app config:", error2);
+          }
+        }
+        const initialScope = {
+          organisationId: appConfig?.requires_event ? void 0 : selectedOrganisationId || void 0,
+          eventId: selectedEventId || void 0,
+          appId
+        };
+        const validation = await ContextValidator.resolveRequiredContext(
+          initialScope,
+          appConfig,
+          appName2 || void 0,
+          supabase
+        );
+        if (!validation.isValid) {
+          if (appName2 === "PORTAL" || appName2 === "ADMIN") {
+            if (!cancelled) {
+              const optionalContextScope = {
+                organisationId: void 0,
+                eventId: void 0,
+                appId: appId || void 0
+                // appId might be undefined if query failed, that's OK
+              };
+              setResolvedScope(optionalContextScope);
+              setError(null);
+              setIsLoading(false);
+            }
+            return;
+          }
+          if (appConfig?.requires_event && selectedEventId) {
+            if (!cancelled) {
+              const eventScope = {
+                organisationId: void 0,
+                // Will be derived from event during permission check
+                eventId: selectedEventId,
+                appId: appId || void 0
+              };
+              setResolvedScope(eventScope);
+              setError(null);
+              setIsLoading(false);
+            }
+            return;
+          }
+          if (!cancelled) {
+            setResolvedScope(null);
+            setError(validation.error || new Error("Context validation failed"));
+            setIsLoading(false);
+          }
+          return;
+        }
+        if (!cancelled) {
+          setResolvedScope(validation.resolvedScope);
+          setError(null);
+          setIsLoading(false);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err);
+          setIsLoading(false);
+        }
+      }
+    };
+    resolveScope();
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedOrganisationId, selectedEventId, supabase]);
+  const allowsOptionalContexts = appName === "PORTAL" || appName === "ADMIN";
+  const hasValidScope = allowsOptionalContexts ? true : stableScope.appId || stableScope.organisationId;
+  const finalScope = useMemo2(() => {
+    if (!hasValidScope) {
+      return allowsOptionalContexts ? {} : null;
+    }
+    const scope = {};
+    if (stableScope.organisationId) {
+      scope.organisationId = stableScope.organisationId;
+    }
+    if (stableScope.eventId) {
+      scope.eventId = stableScope.eventId;
+    }
+    if (stableScope.appId) {
+      scope.appId = stableScope.appId;
+    }
+    return scope;
+  }, [hasValidScope, allowsOptionalContexts, stableScope.organisationId, stableScope.eventId, stableScope.appId]);
+  return {
+    resolvedScope: finalScope,
+    isLoading,
+    error
+  };
+}
+
+// src/components/ErrorBoundary/ErrorBoundary.tsx
+import { Component } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.retryTimeoutId = null;
+    this.reportError = (errorId, componentName) => {
+      if (import.meta.env.MODE === "production") {
+        logger.warn("ErrorBoundary", "Error reporting would be triggered in production:", { errorId, componentName });
+      }
+    };
+    this.handleRetry = () => {
+      const { maxRetries = 3 } = this.props;
+      const { retryCount } = this.state;
+      if (retryCount < maxRetries) {
+        logger.debug("ErrorBoundary", `Retrying component render (attempt ${retryCount + 1}/${maxRetries})`);
+        this.setState((prevState) => ({
+          hasError: false,
+          error: void 0,
+          errorInfo: void 0,
+          errorId: void 0,
+          retryCount: prevState.retryCount + 1
+        }));
+      }
+    };
+    this.state = {
+      hasError: false,
+      retryCount: 0
+    };
+  }
+  static getDerivedStateFromError(error) {
+    const errorId = `error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    return {
+      hasError: true,
+      error,
+      errorId
+    };
+  }
+  componentDidCatch(error, errorInfo) {
+    const { componentName = "Unknown Component", onError, enableReporting = true } = this.props;
+    const errorId = this.state.errorId;
+    this.setState({ errorInfo });
+    logger.error("ErrorBoundary", `[${componentName}] Caught error ${errorId}:`, error, errorInfo);
+    performanceBudgetMonitor.measure("ERROR_BOUNDARY_TRIGGER", 1, {
+      componentName,
+      errorId,
+      errorMessage: error.message,
+      stack: error.stack?.substring(0, 200)
+      // Truncated stack trace
+    });
+    if (enableReporting) {
+      this.reportError(errorId, componentName);
+    }
+    if (onError) {
+      onError(error, errorInfo, errorId);
+    }
+  }
+  componentWillUnmount() {
+    if (this.retryTimeoutId) {
+      clearTimeout(this.retryTimeoutId);
+    }
+  }
+  render() {
+    if (this.state.hasError) {
+      const {
+        componentName = "Component",
+        fallback,
+        enableRetry = true,
+        maxRetries = 3
+      } = this.props;
+      const { retryCount, errorId } = this.state;
+      if (fallback) {
+        return fallback;
+      }
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          role: "alert",
+          className: "p-6 bg-destructive/10 border border-destructive/20 rounded-lg",
+          "data-error-boundary": errorId,
+          children: /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-3", children: [
+            /* @__PURE__ */ jsx("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsx("svg", { className: "w-5 h-5 text-destructive", viewBox: "0 0 20 20", fill: "currentColor", children: /* @__PURE__ */ jsx("path", { fillRule: "evenodd", d: "M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7 4a1 1 0 11-2 0 1 1 0 012 0zm-1-9a1 1 0 00-1 1v4a1 1 0 102 0V6a1 1 0 00-1-1z", clipRule: "evenodd" }) }) }),
+            /* @__PURE__ */ jsxs("div", { className: "flex-1 min-w-0", children: [
+              /* @__PURE__ */ jsxs("h3", { className: "text-destructive", children: [
+                "Error in ",
+                componentName
+              ] }),
+              /* @__PURE__ */ jsx("p", { className: "text-destructive/80", children: this.state.error?.message || "An unexpected error occurred." }),
+              enableRetry && retryCount < maxRetries && /* @__PURE__ */ jsxs("div", { className: "flex gap-3 mb-4", children: [
+                /* @__PURE__ */ jsxs(
+                  "button",
+                  {
+                    onClick: this.handleRetry,
+                    className: "px-4 py-2 bg-destructive text-destructive-foreground rounded-md hover:bg-destructive/90 transition-colors text-sm font-medium",
+                    children: [
+                      "Retry (",
+                      retryCount + 1,
+                      "/",
+                      maxRetries,
+                      ")"
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    onClick: () => window.location.reload(),
+                    className: "px-4 py-2 bg-sec-600 text-main-50 rounded-md hover:bg-sec-700 transition-colors text-sm font-medium",
+                    children: "Reload Page"
+                  }
+                )
+              ] }),
+              retryCount >= maxRetries && /* @__PURE__ */ jsxs("div", { className: "mb-4 p-3 bg-acc-50 border border-acc-200 rounded-md", children: [
+                /* @__PURE__ */ jsx("p", { className: "text-acc-800", children: "Maximum retry attempts reached. Please reload the page or contact support." }),
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    onClick: () => window.location.reload(),
+                    className: "mt-2 px-3 py-1 bg-acc-600 text-main-50 rounded text-sm hover:bg-acc-700",
+                    children: "Reload Page"
+                  }
+                )
+              ] }),
+              import.meta.env.MODE === "development" && this.state.error && /* @__PURE__ */ jsxs("details", { className: "text-sm text-destructive/70", children: [
+                /* @__PURE__ */ jsx("summary", { className: "cursor-pointer font-medium mb-2", children: "Error Details (Development)" }),
+                /* @__PURE__ */ jsxs("div", { className: "bg-destructive/5 p-3 rounded border", children: [
+                  /* @__PURE__ */ jsxs("p", { className: "font-mono", children: [
+                    "Error ID: ",
+                    errorId
+                  ] }),
+                  /* @__PURE__ */ jsxs("pre", { className: "whitespace-pre-wrap text-xs overflow-auto max-h-32", children: [
+                    this.state.error.toString(),
+                    this.state.errorInfo?.componentStack
+                  ] })
+                ] })
+              ] })
+            ] })
+          ] })
+        }
+      );
+    }
+    return this.props.children;
+  }
+};
+
+// src/components/PublicLayout/PublicPageProvider.tsx
+import { createContext, useContext, useMemo as useMemo3 } from "react";
+import { createClient } from "@supabase/supabase-js";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var PublicPageContext = createContext(void 0);
+function PublicPageProvider({ children, appName }) {
+  const getEnvVar = (key) => {
+    if (typeof import.meta !== "undefined" && import.meta.env) {
+      const env = import.meta.env;
+      return env[key];
+    }
+    if (typeof process !== "undefined" && process.env) {
+      return process.env[key];
+    }
+    return void 0;
+  };
+  const supabaseUrl = getEnvVar("VITE_SUPABASE_URL") || getEnvVar("NEXT_PUBLIC_SUPABASE_URL") || null;
+  const supabaseKey = getEnvVar("VITE_SUPABASE_PUBLISHABLE_KEY") || getEnvVar("NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY") || getEnvVar("VITE_SUPABASE_ANON_KEY") || getEnvVar("NEXT_PUBLIC_SUPABASE_ANON_KEY") || null;
+  const supabase = useMemo3(() => {
+    if (!supabaseUrl || !supabaseKey) {
+      logger.warn("PublicPageProvider", "Missing Supabase environment variables. Please ensure VITE_SUPABASE_URL and VITE_SUPABASE_PUBLISHABLE_KEY are set in your environment.");
+      return null;
+    }
+    const client = createClient(supabaseUrl, supabaseKey);
+    logger.info("PublicPageProvider", "Supabase client created successfully for public pages");
+    return client;
+  }, [supabaseUrl, supabaseKey]);
+  const contextValue = {
+    isPublicPage: true,
+    supabase,
+    appName: appName || null,
+    environment: {
+      supabaseUrl,
+      supabaseKey
+    }
+  };
+  return /* @__PURE__ */ jsx2(PublicPageContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx2(ErrorBoundary, { componentName: "PublicPageProvider", children }) });
+}
+function usePublicPageContext() {
+  const context = useContext(PublicPageContext);
+  if (!context) {
+    throw new Error("usePublicPageContext must be used within a PublicPageProvider");
+  }
+  return context;
+}
+function useIsPublicPage() {
+  const context = useContext(PublicPageContext);
+  return context !== void 0;
+}
+
+// src/hooks/useAppConfig.ts
+import { useMemo as useMemo4, useContext as useContext2 } from "react";
+function useAppConfig() {
+  const isPublicPage = useIsPublicPage();
+  const publicPageContext = useContext2(PublicPageContext);
+  const hasPublicContext = publicPageContext !== void 0;
+  const contextAppName = publicPageContext?.appName || null;
+  const getNodeEnvVar = (key) => typeof process !== "undefined" && process.env ? process.env[key] : void 0;
+  if (isPublicPage) {
+    const getAppName = () => {
+      if (!hasPublicContext) {
+        return "PACE";
+      }
+      if (contextAppName) {
+        return contextAppName;
+      }
+      if (typeof import.meta !== "undefined" && import.meta.env) {
+        const env = import.meta.env;
+        return env.VITE_APP_NAME || env.NEXT_PUBLIC_APP_NAME || "PACE";
+      }
+      if (typeof import.meta !== "undefined" && import.meta.env) {
+        return import.meta.env.VITE_APP_NAME || import.meta.env.NEXT_PUBLIC_APP_NAME || "PACE";
+      }
+      const nodeEnvAppName = getNodeEnvVar("VITE_APP_NAME") || getNodeEnvVar("NEXT_PUBLIC_APP_NAME");
+      if (nodeEnvAppName) {
+        return nodeEnvAppName;
+      }
+      return "PACE";
+    };
+    return useMemo4(() => ({
+      supportsDirectAccess: false,
+      // Public pages don't support direct access
+      requiresEvent: true,
+      // Public pages always require an event
+      isLoading: false,
+      appName: getAppName()
+    }), [contextAppName, hasPublicContext]);
+  }
+  try {
+    const { appConfig, appName } = useUnifiedAuth();
+    return useMemo4(() => ({
+      supportsDirectAccess: !(appConfig?.requires_event ?? true),
+      requiresEvent: appConfig?.requires_event ?? true,
+      isLoading: appConfig === null,
+      appName
+    }), [appConfig?.requires_event, appName]);
+  } catch (error) {
+    return useMemo4(() => ({
+      supportsDirectAccess: false,
+      requiresEvent: true,
+      isLoading: false,
+      appName: contextAppName || getNodeEnvVar("VITE_APP_NAME") || getNodeEnvVar("NEXT_PUBLIC_APP_NAME") || "PACE"
+    }), [contextAppName]);
+  }
+}
+
+// src/rbac/hooks/useSuperAdminBypass.ts
+import { useEffect as useEffect2, useMemo as useMemo5, useRef as useRef3, useState as useState2 } from "react";
+
+// src/utils/context/superAdminOverride.ts
+var log2 = createLogger("superAdminOverride");
+async function setSuperAdminOverrideFlag({
+  supabase,
+  enabled,
+  reason = "client_request"
+}) {
+  if (!supabase) {
+    return;
+  }
+  try {
+    const { error } = await supabase.rpc("set_super_admin_override", {
+      p_enabled: enabled,
+      p_reason: reason
+    });
+    if (error) {
+      log2.error("Failed to toggle super admin override", {
+        enabled,
+        reason,
+        error: error.message
+      });
+    } else {
+      log2.debug("Super admin override flag updated", { enabled, reason });
+    }
+  } catch (rpcError) {
+    log2.error("Unexpected error toggling super admin override", {
+      enabled,
+      reason,
+      error: rpcError instanceof Error ? rpcError.message : rpcError
+    });
+  }
+}
+
+// src/rbac/hooks/useSuperAdminBypass.ts
+var log3 = createLogger("useSuperAdminBypass");
+function useSafeUnifiedAuth() {
+  try {
+    return useUnifiedAuth();
+  } catch (error) {
+    log3.debug("useSuperAdminBypass", "UnifiedAuthProvider not available, falling back to defaults", {
+      error: error instanceof Error ? error.message : error
+    });
+    return null;
+  }
+}
+function useSuperAdminBypass() {
+  const authContext = useSafeUnifiedAuth();
+  const user = authContext?.user ?? null;
+  const supabase = authContext?.supabase ?? null;
+  const metadataHint = Boolean(user?.app_metadata?.is_super_admin) || Boolean(user?.user_metadata?.is_super_admin);
+  const [isSuperAdminState, setIsSuperAdminState] = useState2(metadataHint);
+  const [hasVerified, setHasVerified] = useState2(!user?.id);
+  const [isLoading, setIsLoading] = useState2(!!user?.id);
+  const [error, setError] = useState2(null);
+  const lastOverrideValueRef = useRef3(null);
+  useEffect2(() => {
+    if (!user?.id) {
+      setIsSuperAdminState(false);
+      setHasVerified(true);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+    let cancelled = false;
+    setIsLoading(true);
+    setError(null);
+    isSuperAdmin(user.id).then((result) => {
+      if (cancelled) {
+        return;
+      }
+      setIsSuperAdminState(result);
+      setHasVerified(true);
+    }).catch((err) => {
+      if (cancelled) {
+        return;
+      }
+      const normalisedError = err instanceof Error ? err : new Error("Failed to resolve super admin status");
+      setError(normalisedError);
+      setIsSuperAdminState(false);
+      setHasVerified(false);
+      log3.error("Unable to verify super admin status", normalisedError);
+    }).finally(() => {
+      if (!cancelled) {
+        setIsLoading(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [user?.id]);
+  const shouldBypass = hasVerified && isSuperAdminState;
+  useEffect2(() => {
+    if (!supabase) {
+      return;
+    }
+    if (lastOverrideValueRef.current === shouldBypass) {
+      return;
+    }
+    lastOverrideValueRef.current = shouldBypass;
+    setSuperAdminOverrideFlag({
+      supabase,
+      enabled: shouldBypass,
+      reason: "pace-core-super-admin-bypass"
+    }).catch(() => {
+    });
+  }, [supabase, shouldBypass]);
+  return useMemo5(
+    () => ({
+      isSuperAdmin: shouldBypass,
+      isLoading,
+      error
+    }),
+    [shouldBypass, isLoading, error]
+  );
+}
+
+export {
+  useEvents,
+  useResolvedScope,
+  ErrorBoundary,
+  PublicPageContext,
+  PublicPageProvider,
+  usePublicPageContext,
+  useIsPublicPage,
+  useAppConfig,
+  useSuperAdminBypass
+};
+//# sourceMappingURL=chunk-OETXORNB.js.map