create-lego-one 2.0.10 → 2.0.12

package/template/host/src/kernel/rbac/hooks.ts

@@ -0,0 +1,379 @@
+import { useCallback, useEffect, useState } from 'react';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { usePocketBase } from '../providers';
+import { RBACService } from './service';
+import type {
+  Organization,
+  CreateOrganizationData,
+  UpdateOrganizationData,
+  Role,
+  CreateRoleData,
+  UpdateRoleData,
+  Permission,
+  UserRole,
+  AssignRoleData,
+  UserWithRoles,
+  CreateUserRequest,
+  UpdateUserRequest,
+  ResourceType,
+  ActionType,
+} from './types';
+import { useGlobalKernelState } from '../shared-state';
+
+/**
+ * Get RBAC service instance
+ */
+function useRBACService(): RBACService | null {
+  const pb = usePocketBase();
+  if (!pb) return null;
+  return new RBACService(pb);
+}
+
+/**
+ * Manage current organization
+ */
+export function useCurrentOrganization() {
+  const { organization, setOrganization } = useGlobalKernelState();
+  const queryClient = useQueryClient();
+
+  const setCurrentOrganization = useCallback((org: Organization | null) => {
+    setOrganization(org);
+    // Clear related queries when switching organizations
+    queryClient.clear();
+  }, [setOrganization, queryClient]);
+
+  return {
+    organization,
+    setCurrentOrganization,
+  };
+}
+
+/**
+ * Get user's organizations
+ */
+export function useOrganizations() {
+  const service = useRBACService();
+
+  return useQuery({
+    queryKey: ['organizations'],
+    queryFn: () => service?.getUserOrganizations() || [],
+    enabled: !!service,
+  });
+}
+
+/**
+ * Get single organization
+ */
+export function useOrganization(id: string) {
+  const service = useRBACService();
+
+  return useQuery({
+    queryKey: ['organization', id],
+    queryFn: () => service?.getOrganization(id),
+    enabled: !!service && !!id,
+  });
+}
+
+/**
+ * Create organization
+ */
+export function useCreateOrganization() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+  const { setCurrentOrganization } = useCurrentOrganization();
+
+  return useMutation({
+    mutationFn: (data: CreateOrganizationData) => {
+      if (!service) throw new Error('Service not available');
+      return service.createOrganization(data);
+    },
+    onSuccess: (org) => {
+      queryClient.invalidateQueries({ queryKey: ['organizations'] });
+      setCurrentOrganization(org);
+    },
+  });
+}
+
+/**
+ * Update organization
+ */
+export function useUpdateOrganization() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string; data: UpdateOrganizationData }) => {
+      if (!service) throw new Error('Service not available');
+      return service.updateOrganization(id, data);
+    },
+    onSuccess: (_, { id }) => {
+      queryClient.invalidateQueries({ queryKey: ['organization', id] });
+      queryClient.invalidateQueries({ queryKey: ['organizations'] });
+    },
+  });
+}
+
+/**
+ * Get organization roles
+ */
+export function useOrganizationRoles(organizationId: string | null) {
+  const service = useRBACService();
+
+  return useQuery({
+    queryKey: ['roles', organizationId],
+    queryFn: () => {
+      if (!organizationId || !service) return [];
+      return service.getOrganizationRoles(organizationId);
+    },
+    enabled: !!service && !!organizationId,
+  });
+}
+
+/**
+ * Create custom role
+ */
+export function useCreateRole() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: CreateRoleData) => {
+      if (!service) throw new Error('Service not available');
+      return service.createRole(data);
+    },
+    onSuccess: (_, { organizationId }) => {
+      queryClient.invalidateQueries({ queryKey: ['roles', organizationId] });
+    },
+  });
+}
+
+/**
+ * Update role
+ */
+export function useUpdateRole() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string; data: UpdateRoleData }) => {
+      if (!service) throw new Error('Service not available');
+      return service.updateRole(id, data);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['roles'] });
+    },
+  });
+}
+
+/**
+ * Delete role
+ */
+export function useDeleteRole() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (id: string) => {
+      if (!service) throw new Error('Service not available');
+      return service.deleteRole(id);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['roles'] });
+    },
+  });
+}
+
+/**
+ * Get all permissions
+ */
+export function usePermissions() {
+  const service = useRBACService();
+
+  return useQuery({
+    queryKey: ['permissions'],
+    queryFn: () => service?.getAllPermissions() || [],
+    enabled: !!service,
+  });
+}
+
+/**
+ * Get organization users
+ */
+export function useOrganizationUsers(organizationId: string | null) {
+  const service = useRBACService();
+
+  return useQuery({
+    queryKey: ['users', organizationId],
+    queryFn: () => {
+      if (!organizationId || !service) return [];
+      return service.getOrganizationUsers(organizationId);
+    },
+    enabled: !!service && !!organizationId,
+  });
+}
+
+/**
+ * Assign role to user
+ */
+export function useAssignRole() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: AssignRoleData) => {
+      if (!service) throw new Error('Service not available');
+      return service.assignRole(data);
+    },
+    onSuccess: (_, { organizationId }) => {
+      queryClient.invalidateQueries({ queryKey: ['users', organizationId] });
+    },
+  });
+}
+
+/**
+ * Remove role from user
+ */
+export function useRemoveRole() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ userRoleId, organizationId }: { userRoleId: string; organizationId: string }) => {
+      if (!service) throw new Error('Service not available');
+      return service.removeRole(userRoleId);
+    },
+    onSuccess: (_, { organizationId }) => {
+      queryClient.invalidateQueries({ queryKey: ['users', organizationId] });
+    },
+  });
+}
+
+/**
+ * Create user
+ */
+export function useCreateUser() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: CreateUserRequest) => {
+      if (!service) throw new Error('Service not available');
+      return service.createUser(data);
+    },
+    onSuccess: (_, { organizationId }) => {
+      queryClient.invalidateQueries({ queryKey: ['users', organizationId] });
+    },
+  });
+}
+
+/**
+ * Update user
+ */
+export function useUpdateUser() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ userId, data }: { userId: string; data: UpdateUserRequest }) => {
+      if (!service) throw new Error('Service not available');
+      return service.updateUser(userId, data);
+    },
+    onSuccess: (_, { userId }) => {
+      queryClient.invalidateQueries({ queryKey: ['users'] });
+      queryClient.invalidateQueries({ queryKey: ['auth', 'user'] });
+    },
+  });
+}
+
+/**
+ * Delete user
+ */
+export function useDeleteUser() {
+  const service = useRBACService();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ userId, organizationId }: { userId: string; organizationId: string }) => {
+      if (!service) throw new Error('Service not available');
+      return service.deleteUser(userId);
+    },
+    onSuccess: (_, { organizationId }) => {
+      queryClient.invalidateQueries({ queryKey: ['users', organizationId] });
+    },
+  });
+}
+
+/**
+ * Check permissions
+ */
+export function useHasPermission() {
+  const service = useRBACService();
+  const { user, organization } = useGlobalKernelState();
+
+  return useCallback(
+    async (resource: ResourceType, action: ActionType): Promise<boolean> => {
+      if (!service || !user?.id || !organization?.id) return false;
+      const result = await service.hasPermission(user.id, organization.id, resource, action);
+      return result.allowed;
+    },
+    [service, user, organization]
+  );
+}
+
+/**
+ * Get user permissions for current organization
+ */
+export function useUserPermissions() {
+  const service = useRBACService();
+  const { user, organization } = useGlobalKernelState();
+
+  return useQuery({
+    queryKey: ['permissions', 'user', user?.id, organization?.id],
+    queryFn: () => {
+      if (!service || !user?.id || !organization?.id) return [];
+      return service.getUserPermissions(user.id, organization.id);
+    },
+    enabled: !!service && !!user?.id && !!organization?.id,
+  });
+}
+
+/**
+ * Require permission - returns whether user has permission
+ */
+export function useRequirePermission(resource: ResourceType, action: ActionType) {
+  const permissions = useUserPermissions();
+  const [hasPermission, setHasPermission] = useState(false);
+
+  useEffect(() => {
+    const perms = permissions.data || [];
+
+    const allowed =
+      perms.some(p => p.resource === 'all' && p.action === 'all') ||
+      perms.some(p => p.resource === resource && p.action === 'all') ||
+      perms.some(p => p.resource === 'all' && p.action === action) ||
+      perms.some(p => p.resource === resource && p.action === action);
+
+    setHasPermission(allowed);
+  }, [permissions.data, resource, action]);
+
+  return {
+    hasPermission,
+    isLoading: permissions.isLoading,
+  };
+}
+
+/**
+ * Get audit logs
+ */
+export function useAuditLogs(organizationId: string | null, page = 1) {
+  const service = useRBACService();
+
+  return useQuery({
+    queryKey: ['audit-logs', organizationId, page],
+    queryFn: () => {
+      if (!organizationId || !service) return null;
+      return service.getAuditLogs(organizationId, page);
+    },
+    enabled: !!service && !!organizationId,
+  });
+}

package/template/host/src/kernel/rbac/index.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './service';
+export * from './hooks';
+export * from './components/PermissionGate';
+export * from './components/OrganizationSelector';
+export * from './utils';