@jmruthers/pace-core 0.6.10 → 0.6.11

package/dist/chunk-WY6Y7KC3.js

@@ -0,0 +1,264 @@
+import { EventServiceContext, useEventService, useUnifiedAuth, useOrganisations } from './chunk-4R3T5ENU.js';
+import { logger } from './chunk-BTHN5MKC.js';
+import { useContext, useState, useEffect, useMemo, useRef, useCallback } from 'react';
+
+var EMPTY_OPTIONAL_EVENTS = { selectedEvent: null };
+function useOptionalEvents() {
+  const context = useContext(EventServiceContext);
+  const [selectedEvent, setSelectedEvent] = useState(
+    () => context?.eventService?.getSelectedEvent() ?? null
+  );
+  useEffect(() => {
+    if (!context) {
+      setSelectedEvent(null);
+      return void 0;
+    }
+    setSelectedEvent(context.eventService.getSelectedEvent());
+    const unsubscribe = context.eventService.subscribe(() => {
+      setSelectedEvent(context.eventService.getSelectedEvent());
+    });
+    return unsubscribe;
+  }, [context]);
+  return useMemo(() => {
+    if (!context) {
+      return EMPTY_OPTIONAL_EVENTS;
+    }
+    return { selectedEvent };
+  }, [context, selectedEvent]);
+}
+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(() => {
+    currentEventsIds.length;
+    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, error, isLoading, setSelectedEventCallback, refreshEventsCallback, clearEventSelectionCallback]);
+}
+async function validateOrganisationAccessImpl(ctx, orgId) {
+  if (!ctx.user || !ctx.session || !ctx.supabase) return false;
+  if (ctx.superAdminContext.isSuperAdmin) return true;
+  try {
+    const { data, error } = await ctx.supabase.from("rbac_organisation_roles").select("id").eq("user_id", ctx.user.id).eq("organisation_id", orgId).eq("status", "active").is("revoked_at", null).in("role", ["org_admin", "leader", "member"]).single();
+    if (error) {
+      logger.error("useOrganisationSecurity", "Error validating organisation access:", error);
+      return false;
+    }
+    return !!data;
+  } catch (error) {
+    logger.error("useOrganisationSecurity", "Exception validating organisation access:", error);
+    return false;
+  }
+}
+function hasMinimumRoleImpl(ctx, minRole, orgId) {
+  if (ctx.superAdminContext.isSuperAdmin) return true;
+  const targetOrgId = orgId || ctx.selectedOrganisation?.id;
+  if (!targetOrgId) return false;
+  const userRole = ctx.getUserRole(targetOrgId);
+  const roleHierarchy = ["supporter", "member", "leader", "org_admin"];
+  return roleHierarchy.indexOf(userRole) >= roleHierarchy.indexOf(minRole);
+}
+function canAccessChildOrganisationsImpl(ctx, orgId) {
+  if (ctx.superAdminContext.isSuperAdmin) return true;
+  const targetOrgId = orgId || ctx.selectedOrganisation?.id;
+  if (!targetOrgId) return false;
+  return ctx.getUserRole(targetOrgId) === "org_admin";
+}
+async function hasPermissionImpl(ctx, permission, orgId) {
+  if (ctx.superAdminContext.isSuperAdmin) return true;
+  const targetOrgId = orgId || ctx.selectedOrganisation?.id;
+  if (!targetOrgId || !ctx.user) return false;
+  try {
+    const { isPermittedCached } = await import('./api-BZR2CYXL.js');
+    const scope = {
+      organisationId: targetOrgId,
+      eventId: ctx.user.user_metadata?.eventId || ctx.user.app_metadata?.eventId,
+      appId: ctx.user.user_metadata?.appId || ctx.user.app_metadata?.appId
+    };
+    const result = await isPermittedCached({
+      userId: ctx.user.id,
+      scope,
+      permission
+    });
+    return result.ok ? result.data : false;
+  } catch (error) {
+    logger.error("useOrganisationSecurity", "Exception checking permission:", error);
+    return false;
+  }
+}
+async function getUserPermissionsImpl(ctx, orgId) {
+  if (ctx.superAdminContext.isSuperAdmin) return ["*"];
+  const targetOrgId = orgId || ctx.selectedOrganisation?.id;
+  if (!targetOrgId || !ctx.user) return [];
+  try {
+    const { getPermissionMap } = await import('./api-BZR2CYXL.js');
+    const scope = {
+      organisationId: targetOrgId,
+      eventId: ctx.user.user_metadata?.eventId || ctx.user.app_metadata?.eventId,
+      appId: ctx.user.user_metadata?.appId || ctx.user.app_metadata?.appId
+    };
+    const result = await getPermissionMap({ userId: ctx.user.id, scope });
+    if (!result.ok) return [];
+    const allPermissions = Object.entries(result.data).filter(([, allowed]) => allowed).map(([permission]) => permission);
+    return [...new Set(allPermissions)];
+  } catch (error) {
+    logger.error("useOrganisationSecurity", "Exception getting user permissions:", error);
+    return [];
+  }
+}
+async function logOrganisationAccessImpl(ctx, action, details) {
+  if (!ctx.user || !ctx.selectedOrganisation?.id) return;
+  try {
+    const { emitAuditEvent } = await import('./audit-HI2DHUVU.js');
+    await emitAuditEvent({
+      type: "permission_check",
+      userId: ctx.user.id,
+      organisationId: ctx.selectedOrganisation.id,
+      permission: action,
+      decision: true,
+      source: "api",
+      duration_ms: 0,
+      metadata: details || {}
+    });
+  } catch (error) {
+    logger.error("useOrganisationSecurity", "Error logging organisation access:", error);
+  }
+}
+async function ensureOrganisationAccessImpl(ctx, orgId) {
+  const hasAccess = await validateOrganisationAccessImpl(ctx, orgId);
+  if (!hasAccess) {
+    const error = new Error(`User does not have access to organisation ${orgId}`);
+    error.name = "OrganisationSecurityError";
+    error.code = "ACCESS_DENIED";
+    error.organisationId = orgId;
+    error.userId = ctx.user?.id;
+    throw error;
+  }
+}
+async function validateUserAccessImpl(ctx, userId, orgId) {
+  if (!ctx.supabase) return false;
+  if (ctx.superAdminContext.isSuperAdmin) return true;
+  if (userId !== ctx.user?.id) return false;
+  return validateOrganisationAccessImpl(ctx, orgId);
+}
+var useOrganisationSecurity = () => {
+  const { user, session, supabase } = useUnifiedAuth();
+  const { selectedOrganisation, getUserRole } = useOrganisations();
+  const [isSuperAdmin, setIsSuperAdmin] = useState(false);
+  const [_isCheckingSuperAdmin, setIsCheckingSuperAdmin] = useState(false);
+  useEffect(() => {
+    if (!user || !session || !supabase) {
+      setIsSuperAdmin(false);
+      return;
+    }
+    const checkSuperAdmin = async () => {
+      setIsCheckingSuperAdmin(true);
+      try {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const { data, error } = await supabase.from("rbac_global_roles").select("role").eq("user_id", user.id).eq("role", "super_admin").lte("valid_from", now).or(`valid_to.is.null,valid_to.gte.${now}`).limit(1);
+        setIsSuperAdmin(!error && data && data.length > 0);
+      } catch (error) {
+        logger.error("useOrganisationSecurity", "Error checking super admin status:", error);
+        setIsSuperAdmin(false);
+      } finally {
+        setIsCheckingSuperAdmin(false);
+      }
+    };
+    checkSuperAdmin();
+  }, [user, session, supabase]);
+  const superAdminContext = useMemo(
+    () => ({
+      isSuperAdmin,
+      hasGlobalAccess: isSuperAdmin,
+      canManageAllOrganisations: isSuperAdmin
+    }),
+    [isSuperAdmin]
+  );
+  const ctx = useMemo(
+    () => ({
+      user,
+      session,
+      supabase,
+      selectedOrganisation: selectedOrganisation ?? null,
+      getUserRole,
+      superAdminContext
+    }),
+    [user, session, supabase, selectedOrganisation, getUserRole, superAdminContext]
+  );
+  const validateOrganisationAccess = useCallback(
+    (orgId) => validateOrganisationAccessImpl(ctx, orgId),
+    [ctx]
+  );
+  const hasMinimumRole = useCallback(
+    (minRole, orgId) => hasMinimumRoleImpl(ctx, minRole, orgId),
+    [ctx]
+  );
+  const canAccessChildOrganisations = useCallback(
+    (orgId) => canAccessChildOrganisationsImpl(ctx, orgId),
+    [ctx]
+  );
+  const hasPermission = useCallback(
+    (permission, orgId) => hasPermissionImpl(ctx, permission, orgId),
+    [ctx]
+  );
+  const getUserPermissions = useCallback(
+    (orgId) => getUserPermissionsImpl(ctx, orgId),
+    [ctx]
+  );
+  const logOrganisationAccess = useCallback(
+    (action, details) => logOrganisationAccessImpl(ctx, action, details),
+    [ctx]
+  );
+  const ensureOrganisationAccess = useCallback(
+    (orgId) => ensureOrganisationAccessImpl(ctx, orgId),
+    [ctx]
+  );
+  const validateUserAccess = useCallback(
+    (userId, orgId) => validateUserAccessImpl(ctx, userId, orgId),
+    [ctx]
+  );
+  return {
+    superAdminContext,
+    validateOrganisationAccess,
+    hasMinimumRole,
+    canAccessChildOrganisations,
+    hasPermission,
+    getUserPermissions,
+    logOrganisationAccess,
+    ensureOrganisationAccess,
+    validateUserAccess
+  };
+};
+
+export { useEvents, useOptionalEvents, useOrganisationSecurity };

package/dist/{chunk-FN52B75D.js → chunk-XOJME5T7.js}

@@ -1,4 +1,5 @@
 import { createLogger } from './chunk-BTHN5MKC.js';
+import { err, ok } from './chunk-44CNXN4P.js';
 import { parseISO, isValid, addMinutes, differenceInHours } from 'date-fns';
 import { formatInTimeZone as formatInTimeZone$1, toZonedTime as toZonedTime$1, fromZonedTime as fromZonedTime$1 } from 'date-fns-tz';
 
@@ -176,20 +177,177 @@ function hasAppIcon(appName) {
   return getAppIcon(appName) !== void 0;
 }
 var appsWithIcons = Object.keys(appIcons);
+function formatDate(date) {
+  const dateObj = typeof date === "string" || typeof date === "number" ? new Date(date) : date;
+  return dateObj.toLocaleDateString("en-GB", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function formatTime(date) {
+  const dateObj = typeof date === "string" || typeof date === "number" ? new Date(date) : date;
+  return dateObj.toLocaleTimeString("en-GB", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+}
+function formatDateTime(date) {
+  const dateObj = typeof date === "string" || typeof date === "number" ? new Date(date) : date;
+  return dateObj.toLocaleString("en-GB", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+}
+function formatCurrency(value, currencyCode = "USD", locale = "en-US") {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currencyCode
+  }).format(value);
+}
+function formatNumber(value, options = {}, locale = "en-US") {
+  return new Intl.NumberFormat(locale, options).format(value);
+}
+function formatPercent(value, locale = "en-US", options) {
+  let decimals;
+  if (options && typeof options === "object") {
+    if (options.preserveDecimals) {
+      const valueStr = value.toString();
+      const decimalIndex = valueStr.indexOf(".");
+      if (decimalIndex !== -1) {
+        const detectedDecimals = valueStr.length - decimalIndex - 1;
+        const maxDecimals = options.maxDecimals ?? 10;
+        decimals = Math.min(detectedDecimals, maxDecimals);
+      } else {
+        decimals = 0;
+      }
+    } else {
+      decimals = options.decimals ?? 1;
+    }
+  } else {
+    decimals = 1;
+  }
+  return new Intl.NumberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(value / 100);
+}
+function formatCompactNumber(value, locale = "en-US") {
+  return new Intl.NumberFormat(locale, {
+    notation: "compact",
+    compactDisplay: "short"
+  }).format(value);
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function formatDateTimeForDisplay(utcDate, timezone, options = {}) {
+  if (!utcDate) {
+    return "";
+  }
+  if (!timezone) {
+    return "";
+  }
+  try {
+    const { includeTimezone = true, format: formatStr = "MMM dd, yyyy HH:mm" } = options;
+    let dateObj;
+    if (typeof utcDate === "string") {
+      dateObj = parseISO(utcDate);
+    } else {
+      dateObj = utcDate;
+    }
+    if (!isValid(dateObj)) {
+      return "";
+    }
+    const formatted = formatInTimeZone(dateObj, timezone, formatStr);
+    if (includeTimezone) {
+      const tzAbbr = getTimezoneAbbreviation(dateObj, timezone);
+      return `${formatted} (${tzAbbr})`;
+    }
+    return formatted;
+  } catch {
+    return "";
+  }
+}
+function formatDateOnlyForDisplay(utcDate) {
+  if (!utcDate) {
+    return "";
+  }
+  try {
+    let dateObj;
+    if (typeof utcDate === "string") {
+      dateObj = parseISO(utcDate);
+    } else {
+      dateObj = utcDate;
+    }
+    if (!isValid(dateObj)) {
+      return "";
+    }
+    return dateObj.toLocaleDateString("en-GB", {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+  } catch {
+    return "";
+  }
+}
+function formatDateTimeForTable(utcDate, timezone) {
+  return formatDateTimeForDisplay(utcDate, timezone, {
+    includeTimezone: true,
+    format: "MMM dd, yyyy HH:mm"
+  });
+}
+function formatDateTimeForMap(utcDate, timezone) {
+  if (!utcDate || !timezone) {
+    return "";
+  }
+  try {
+    let dateObj;
+    if (typeof utcDate === "string") {
+      dateObj = parseISO(utcDate);
+    } else {
+      dateObj = utcDate;
+    }
+    if (!isValid(dateObj)) {
+      return "";
+    }
+    const formatted = formatInTimeZone(dateObj, timezone, "MMM dd, HH:mm");
+    const tzAbbr = getTimezoneAbbreviation(dateObj, timezone);
+    return `${formatted} ${tzAbbr}`;
+  } catch {
+    return "";
+  }
+}
 
 // src/utils/app/appIdResolver.ts
 var log = createLogger("AppIdResolver");
+function toApiError(error) {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  const code = error instanceof Error && error.code ? error.code : "APP_ID_RESOLVER_ERROR";
+  return { code, message };
+}
 async function getAppId(supabase, appName) {
   try {
     const { data, error } = await supabase.from("rbac_apps").select("id").ilike("name", appName).eq("is_active", true).single();
     if (error) {
       log.error("Failed to resolve app ID for app name:", appName, error);
-      return null;
+      return err({ code: "APP_ID_RESOLVE_ERROR", message: error.message });
     }
-    return data?.id || null;
-  } catch (error) {
-    log.error("Error resolving app ID for app name:", appName, error);
-    return null;
+    return ok(data?.id ?? null);
+  } catch (e) {
+    log.error("Error resolving app ID for app name:", appName, e);
+    return err(toApiError(e));
   }
 }
 async function getAppIds(supabase, appNames) {
@@ -198,7 +356,7 @@ async function getAppIds(supabase, appNames) {
     const { data, error } = await supabase.from("rbac_apps").select("id, name").or(orConditions).eq("is_active", true);
     if (error) {
       log.error("Failed to resolve app IDs for app names:", appNames, error);
-      return {};
+      return err({ code: "APP_IDS_RESOLVE_ERROR", message: error.message });
     }
     const result = {};
     appNames.forEach((name) => {
@@ -212,10 +370,10 @@ async function getAppIds(supabase, appNames) {
         result[originalName] = app.id;
       }
     });
-    return result;
-  } catch (error) {
-    log.error("Error resolving app IDs for app names:", appNames, error);
-    return {};
+    return ok(result);
+  } catch (e) {
+    log.error("Error resolving app IDs for app names:", appNames, e);
+    return err(toApiError(e));
   }
 }
 var CachedAppIdResolver = class {
@@ -228,11 +386,14 @@ var CachedAppIdResolver = class {
     const now = Date.now();
     const cached = this.cache.get(appName);
     if (cached && cached.expires > now) {
-      return cached.id;
+      return ok(cached.id);
+    }
+    const result = await getAppId(supabase, appName);
+    if (!result.ok) {
+      return result;
     }
-    const id = await getAppId(supabase, appName);
-    this.cache.set(appName, { id, expires: now + this.ttl });
-    return id;
+    this.cache.set(appName, { id: result.data, expires: now + this.ttl });
+    return ok(result.data);
   }
   clearCache() {
     this.cache.clear();
@@ -243,4 +404,4 @@ var CachedAppIdResolver = class {
 };
 var cachedAppIdResolver = new CachedAppIdResolver();
 
-export { CachedAppIdResolver, appIcons, appsWithIcons, cachedAppIdResolver, formatInTimeZone, formatTimeInTimeZone, fromZonedTime, getAppIcon, getAppId, getAppIds, getTimeZoneDifference, getTimezoneAbbreviation, getUserTimeZone, hasAppIcon, roundToNearestMinutes, toZonedTime };
+export { CachedAppIdResolver, appIcons, appsWithIcons, cachedAppIdResolver, formatCompactNumber, formatCurrency, formatDate, formatDateOnlyForDisplay, formatDateTime, formatDateTimeForDisplay, formatDateTimeForMap, formatDateTimeForTable, formatFileSize, formatInTimeZone, formatNumber, formatPercent, formatTime, formatTimeInTimeZone, fromZonedTime, getAppIcon, getAppId, getAppIds, getTimeZoneDifference, getTimezoneAbbreviation, getUserTimeZone, hasAppIcon, roundToNearestMinutes, toZonedTime };