@jmruthers/pace-core 0.6.4 → 0.6.6

package/src/rbac/hooks/permissions/useCachedPermissions.ts

@@ -1,79 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-
-import { getPermissionMap } from '../../api';
-import { PermissionMap, Scope, UUID } from '../../types';
-
-/**
- * Hook to get cached permissions with TTL management
- *
- * @param userId - User ID
- * @param scope - Scope for permission checking
- * @returns Cached permission state and methods
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { permissions, isLoading, error, invalidateCache } = useCachedPermissions(userId, scope);
- *
- *   if (isLoading) return <div>Loading cached permissions...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
- *
- *   return (
- *     <div>
- *       {permissions['read:users'] && <UserList />}
- *       <button onClick={invalidateCache}>Refresh Permissions</button>
- *     </div>
- *   );
- * }
- * ```
- */
-export function useCachedPermissions(userId: UUID, scope: Scope): {
-  permissions: PermissionMap;
-  isLoading: boolean;
-  error: Error | null;
-  invalidateCache: () => void;
-  refetch: () => Promise<void>;
-} {
-  const [permissions, setPermissions] = useState<PermissionMap>({} as PermissionMap);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-
-  const fetchCachedPermissions = useCallback(async () => {
-    if (!userId) {
-      setPermissions({} as PermissionMap);
-      setIsLoading(false);
-      return;
-    }
-
-    try {
-      setIsLoading(true);
-      setError(null);
-
-      const permissionMap = await getPermissionMap({ userId, scope });
-      setPermissions(permissionMap);
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error('Failed to fetch cached permissions'));
-    } finally {
-      setIsLoading(false);
-    }
-  }, [userId, scope.organisationId, scope.eventId, scope.appId]);
-
-  const invalidateCache = useCallback(() => {
-    // This would typically invalidate the cache in the actual implementation
-    // For now, we'll just refetch
-    fetchCachedPermissions();
-  }, [fetchCachedPermissions]);
-
-  useEffect(() => {
-    fetchCachedPermissions();
-  }, [fetchCachedPermissions]);
-
-  // Memoize the return object to prevent unnecessary re-renders
-  return useMemo(() => ({
-    permissions,
-    isLoading,
-    error,
-    invalidateCache,
-    refetch: fetchCachedPermissions
-  }), [permissions, isLoading, error, invalidateCache, fetchCachedPermissions]);
-}

package/src/rbac/hooks/permissions/useHasAllPermissions.ts

@@ -1,90 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-
-import { isPermitted, isPermittedCached } from '../../api';
-import { Permission, Scope, UUID } from '../../types';
-
-/**
- * Hook to check if user has all of the specified permissions
- *
- * @param userId - User ID
- * @param scope - Scope for permission checking
- * @param permissions - Array of permissions to check
- * @param useCache - Whether to use cached results
- * @returns Whether user has all of the permissions
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { hasAll, isLoading, error } = useHasAllPermissions(
- *     userId,
- *     scope,
- *     ['read:users', 'create:users', 'update:users']
- *   );
- *
- *   if (isLoading) return <div>Checking permissions...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
- *
- *   return hasAll ? <FullUserManagementPanel /> : <div>Insufficient permissions</div>;
- * }
- * ```
- */
-export function useHasAllPermissions(
-  userId: UUID,
-  scope: Scope,
-  permissions: Permission[],
-  useCache: boolean = true
-): {
-  hasAll: boolean;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-} {
-  const [hasAll, setHasAll] = useState<boolean>(false);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-
-  const checkAllPermissions = useCallback(async () => {
-    if (!userId || permissions.length === 0) {
-      setHasAll(false);
-      setIsLoading(false);
-      return;
-    }
-
-    try {
-      setIsLoading(true);
-      setError(null);
-
-      let hasAllPermissions = true;
-
-      for (const permission of permissions) {
-        const result = useCache
-          ? await isPermittedCached({ userId, scope, permission })
-          : await isPermitted({ userId, scope, permission });
-
-        if (!result) {
-          hasAllPermissions = false;
-          break;
-        }
-      }
-
-      setHasAll(hasAllPermissions);
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error('Failed to check permissions'));
-      setHasAll(false);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [userId, scope.organisationId, scope.eventId, scope.appId, permissions, useCache]);
-
-  useEffect(() => {
-    checkAllPermissions();
-  }, [checkAllPermissions]);
-
-  // Memoize the return object to prevent unnecessary re-renders
-  return useMemo(() => ({
-    hasAll,
-    isLoading,
-    error,
-    refetch: checkAllPermissions
-  }), [hasAll, isLoading, error, checkAllPermissions]);
-}

package/src/rbac/hooks/permissions/useHasAnyPermission.ts

@@ -1,90 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-
-import { isPermitted, isPermittedCached } from '../../api';
-import { Permission, Scope, UUID } from '../../types';
-
-/**
- * Hook to check if user has any of the specified permissions
- *
- * @param userId - User ID
- * @param scope - Scope for permission checking
- * @param permissions - Array of permissions to check
- * @param useCache - Whether to use cached results
- * @returns Whether user has any of the permissions
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { hasAny, isLoading, error } = useHasAnyPermission(
- *     userId,
- *     scope,
- *     ['read:users', 'create:users']
- *   );
- *
- *   if (isLoading) return <div>Checking permissions...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
- *
- *   return hasAny ? <UserManagementPanel /> : <div>No user permissions</div>;
- * }
- * ```
- */
-export function useHasAnyPermission(
-  userId: UUID,
-  scope: Scope,
-  permissions: Permission[],
-  useCache: boolean = true
-): {
-  hasAny: boolean;
-  isLoading: boolean;
-  error: Error | null;
-  refetch: () => Promise<void>;
-} {
-  const [hasAny, setHasAny] = useState<boolean>(false);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-
-  const checkAnyPermission = useCallback(async () => {
-    if (!userId || permissions.length === 0) {
-      setHasAny(false);
-      setIsLoading(false);
-      return;
-    }
-
-    try {
-      setIsLoading(true);
-      setError(null);
-
-      let hasAnyPermission = false;
-
-      for (const permission of permissions) {
-        const result = useCache
-          ? await isPermittedCached({ userId, scope, permission })
-          : await isPermitted({ userId, scope, permission });
-
-        if (result) {
-          hasAnyPermission = true;
-          break;
-        }
-      }
-
-      setHasAny(hasAnyPermission);
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error('Failed to check permissions'));
-      setHasAny(false);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [userId, scope.organisationId, scope.eventId, scope.appId, permissions, useCache]);
-
-  useEffect(() => {
-    checkAnyPermission();
-  }, [checkAnyPermission]);
-
-  // Memoize the return object to prevent unnecessary re-renders
-  return useMemo(() => ({
-    hasAny,
-    isLoading,
-    error,
-    refetch: checkAnyPermission
-  }), [hasAny, isLoading, error, checkAnyPermission]);
-}