rbac-manager 0.0.0-stage → 1.0.0

package/src/core/hooks/useRoles.ts

@@ -0,0 +1,120 @@
+import { useState, useCallback } from 'react';
+import { useRBACConfig } from '../context/RBACConfigContext';
+import { StandardRole, PaginatedResult, RoleFormData } from '../types';
+import { buildPaginationQueryParams } from '../types/pagination.types';
+
+export function useRoles() {
+  const { config, http } = useRBACConfig();
+  const [roles, setRoles] = useState<StandardRole[]>([]);
+  const [total, setTotal] = useState<number>(0);
+  const [page, setPage] = useState<number>(1);
+  const [limit, setLimit] = useState<number>(10);
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchRoles = useCallback(
+    async (params?: { page?: number; limit?: number; search?: string; sortBy?: string; sortOrder?: 'asc' | 'desc'; [key: string]: any }) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const targetPage = params?.page ?? page;
+        const targetLimit = params?.limit ?? limit;
+
+        const pagParams = buildPaginationQueryParams(targetPage, targetLimit, config.pagination);
+        const queryParams = {
+          ...pagParams,
+          ...(params || {}),
+        };
+
+        const raw = await http.get(config.endpoints.ROLES_LIST, queryParams);
+        const result: PaginatedResult<StandardRole> = config.adapters.roles.transformRoleListResponse(raw);
+
+        setRoles(result.items);
+        setTotal(result.total);
+        setPage(result.page);
+        setLimit(result.limit);
+        return result;
+      } catch (err: any) {
+        setError(err);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [config.adapters.roles, config.endpoints.ROLES_LIST, config.pagination, http, limit, page]
+  );
+
+  const fetchRoleDetails = useCallback(
+    async (id: string | number) => {
+      const endpoint = config.endpoints.ROLES_DETAILS.replace(':id', String(id));
+      const raw = await http.get(endpoint);
+      return config.adapters.roles.transformRoleDetailsResponse(raw);
+    },
+    [config.adapters.roles, config.endpoints.ROLES_DETAILS, http]
+  );
+
+  const createRole = useCallback(
+    async (formData: RoleFormData) => {
+      const payload = config.adapters.roles.transformCreateRolePayload(formData);
+      const raw = await http.post(config.endpoints.ROLES_CREATE, payload);
+      await fetchRoles();
+      return raw;
+    },
+    [config.adapters.roles, config.endpoints.ROLES_CREATE, fetchRoles, http]
+  );
+
+  const editRole = useCallback(
+    async (id: string | number, formData: Partial<RoleFormData>) => {
+      const endpoint = config.endpoints.ROLES_EDIT.replace(':id', String(id));
+      const payload = config.adapters.roles.transformEditRolePayload(formData);
+      const raw = await http.patch(endpoint, payload);
+      await fetchRoles();
+      return raw;
+    },
+    [config.adapters.roles, config.endpoints.ROLES_EDIT, fetchRoles, http]
+  );
+
+  const deleteRole = useCallback(
+    async (id: string | number) => {
+      const endpoint = config.endpoints.ROLES_DELETE.replace(':id', String(id));
+      const raw = await http.delete(endpoint);
+      await fetchRoles();
+      return raw;
+    },
+    [config.endpoints.ROLES_DELETE, fetchRoles, http]
+  );
+
+  const fetchRolePermissions = useCallback(
+    async (roleId: string | number): Promise<(string | number)[]> => {
+      const endpoint = config.endpoints.ROLES_GET_PERMISSIONS.replace(':id', String(roleId));
+      const raw = await http.get(endpoint);
+      return config.adapters.roles.transformRolePermissionsResponse(raw);
+    },
+    [config.adapters.roles, config.endpoints.ROLES_GET_PERMISSIONS, http]
+  );
+
+  const assignPermissions = useCallback(
+    async (roleId: string | number, permissionActionIds: (string | number)[]) => {
+      const endpoint = config.endpoints.ROLES_ASSIGN_PERMISSIONS.replace(':id', String(roleId));
+      const payload = config.adapters.roles.transformAssignPermissionsPayload(roleId, permissionActionIds);
+      return http.post(endpoint, payload);
+    },
+    [config.adapters.roles, config.endpoints.ROLES_ASSIGN_PERMISSIONS, http]
+  );
+
+  return {
+    roles,
+    total,
+    page,
+    limit,
+    isLoading,
+    error,
+    fetchRoles,
+    fetchRoleDetails,
+    createRole,
+    editRole,
+    deleteRole,
+    fetchRolePermissions,
+    assignPermissions,
+  };
+}

package/src/core/types/adapter.types.ts

@@ -0,0 +1,54 @@
+import { StandardAuthMeData, StandardUser, LoginCredentials } from './auth.types';
+import { StandardRole, StandardModuleWithActions, StandardAction, RoleFormData } from './rbac.types';
+import {
+  StandardEntityMaster,
+  StandardDepartmentMaster,
+  StandardDesignationMaster,
+  StandardEmployeeMaster,
+  StandardModuleMasterItem,
+} from './masters.types';
+
+export interface PaginatedResult<T> {
+  items: T[];
+  total: number;
+  page: number;
+  limit: number;
+  totalPages?: number;
+}
+
+export interface AuthAdapter {
+  transformLoginPayload: (credentials: LoginCredentials) => Record<string, any>;
+  transformLoginResponse: (raw: any) => { success: boolean; user?: Partial<StandardUser>; token?: string; message?: string };
+  transformAuthMeResponse: (raw: any) => StandardAuthMeData;
+}
+
+export interface RolesAdapter {
+  transformRoleListResponse: (raw: any) => PaginatedResult<StandardRole>;
+  transformRoleDetailsResponse: (raw: any) => StandardRole;
+  transformCreateRolePayload: (data: RoleFormData) => Record<string, any>;
+  transformEditRolePayload: (data: Partial<RoleFormData>) => Record<string, any>;
+  transformRolePermissionsResponse: (raw: any) => (string | number)[];
+  transformAssignPermissionsPayload: (roleId: string | number, permissionActionIds: (string | number)[]) => Record<string, any>;
+}
+
+export interface PermissionsAdapter {
+  transformActionsListResponse: (raw: any) => StandardAction[];
+  transformRegistryResponse: (raw: any) => PaginatedResult<StandardModuleWithActions>;
+  transformModuleParentsResponse: (raw: any) => PaginatedResult<StandardModuleWithActions>;
+  transformModuleSubmodulesResponse: (raw: any) => PaginatedResult<StandardModuleWithActions>;
+}
+
+export interface MastersAdapter {
+  transformEntityListResponse: (raw: any) => PaginatedResult<StandardEntityMaster>;
+  transformDepartmentListResponse: (raw: any) => PaginatedResult<StandardDepartmentMaster>;
+  transformDesignationListResponse: (raw: any) => PaginatedResult<StandardDesignationMaster>;
+  transformEmployeeListResponse: (raw: any) => PaginatedResult<StandardEmployeeMaster>;
+  transformModuleMasterListResponse: (raw: any) => PaginatedResult<StandardModuleMasterItem>;
+}
+
+export interface RBACAdapters {
+  auth: AuthAdapter;
+  roles: RolesAdapter;
+  permissions: PermissionsAdapter;
+  masters: MastersAdapter;
+}

package/src/core/types/auth.types.ts

@@ -0,0 +1,44 @@
+export interface StandardUser {
+  id: string | number;
+  email: string;
+  firstName?: string;
+  lastName?: string;
+  fullName: string;
+  mobileNumber?: string;
+  entityId?: string | number | null;
+  departmentId?: string | number | null;
+  role: {
+    id: string | number;
+    name: string;
+    key: string;
+  };
+}
+
+export interface StandardPermissionItem {
+  permissionKey: string;
+  routePath?: string;
+}
+
+export interface StandardNavigationItem {
+  id: string | number;
+  name: string;
+  slug: string;
+  routePath?: string;
+  sortOrder: number;
+  parentId: string | number;
+  children: StandardNavigationItem[];
+}
+
+export interface StandardAuthMeData {
+  user: StandardUser;
+  permissions: StandardPermissionItem[];
+  navigation: StandardNavigationItem[];
+}
+
+export interface LoginCredentials {
+  email: string;
+  password?: string;
+  mobileNumber?: string;
+  otp?: string;
+  [key: string]: any;
+}

package/src/core/types/index.ts

@@ -0,0 +1,7 @@
+export * from './auth.types';
+export * from './rbac.types';
+export * from './masters.types';
+export * from './adapter.types';
+export * from './style.types';
+export * from './router.types';
+export * from './pagination.types';

package/src/core/types/masters.types.ts

@@ -0,0 +1,63 @@
+export interface StandardEntityMaster {
+  id: string | number;
+  name: string;
+  code?: string;
+  state?: string;
+  city?: string;
+  pincode?: string;
+  isActive: boolean;
+  createdAt?: string;
+}
+
+export interface StandardDepartmentMaster {
+  id: string | number;
+  name: string;
+  code?: string;
+  entityId?: string | number | null;
+  entityName?: string | null;
+  isActive: boolean;
+  createdAt?: string;
+}
+
+export interface StandardDesignationMaster {
+  id: string | number;
+  name: string;
+  code?: string;
+  departmentId?: string | number | null;
+  departmentName?: string | null;
+  isActive: boolean;
+  createdAt?: string;
+}
+
+export interface StandardEmployeeMaster {
+  id: string | number;
+  employeeCode?: string;
+  firstName: string;
+  lastName: string;
+  fullName: string;
+  email: string;
+  mobileNumber?: string;
+  entityId?: string | number | null;
+  entityName?: string | null;
+  departmentId?: string | number | null;
+  departmentName?: string | null;
+  designationId?: string | number | null;
+  designationName?: string | null;
+  reportingManagerId?: string | number | null;
+  roleId?: string | number | null;
+  roleName?: string | null;
+  isActive: boolean;
+  createdAt?: string;
+}
+
+export interface StandardModuleMasterItem {
+  id: string | number;
+  name: string;
+  slug: string;
+  routePath?: string | null;
+  sortOrder: number;
+  parentId: string | number;
+  parentName?: string | null;
+  isActive: boolean;
+  createdAt?: string;
+}

package/src/core/types/pagination.types.ts

@@ -0,0 +1,37 @@
+export interface PaginationConfig {
+  pageIndexOffset?: 0 | 1; // 1 for 1-based (default), 0 for 0-based (Spring Boot, etc.)
+  pageParamName?: string;  // e.g. 'page' or 'pageNumber' or 'pageIndex'
+  limitParamName?: string; // e.g. 'limit' or 'size' or 'pageSize'
+  useOffsetLimit?: boolean;// If true, sends offset and limit instead of page and limit
+  offsetParamName?: string;// e.g. 'offset' or 'skip'
+}
+
+export const defaultPaginationConfig: Required<PaginationConfig> = {
+  pageIndexOffset: 1,
+  pageParamName: 'page',
+  limitParamName: 'limit',
+  useOffsetLimit: false,
+  offsetParamName: 'offset',
+};
+
+export function buildPaginationQueryParams(
+  page: number,
+  limit: number,
+  config?: PaginationConfig
+): Record<string, number> {
+  const cfg = { ...defaultPaginationConfig, ...(config || {}) };
+
+  if (cfg.useOffsetLimit) {
+    const offset = Math.max(0, (page - 1) * limit);
+    return {
+      [cfg.offsetParamName]: offset,
+      [cfg.limitParamName]: limit,
+    };
+  }
+
+  const backendPage = cfg.pageIndexOffset === 0 ? Math.max(0, page - 1) : page;
+  return {
+    [cfg.pageParamName]: backendPage,
+    [cfg.limitParamName]: limit,
+  };
+}

package/src/core/types/rbac.types.ts

@@ -0,0 +1,69 @@
+export interface StandardAction {
+  id: string | number;
+  name: string;
+  key: string;
+  isActive: boolean;
+  sortOrder?: number;
+}
+
+export interface StandardRole {
+  id: string | number;
+  name: string;
+  key: string;
+  description?: string | null;
+  isActive: boolean;
+  entityId?: string | number | null;
+  entityName?: string | null;
+  departmentId?: string | number | null;
+  departmentName?: string | null;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface StandardPermissionActionMapping {
+  permissionActionId: string | number;
+  moduleId: string | number;
+  actionId: string | number;
+  permissionKey: string;
+  routePath?: string | null;
+  description?: string | null;
+  sortOrder?: number;
+  actionDetails: StandardAction;
+}
+
+export interface StandardModuleWithActions {
+  id: string | number;
+  name: string;
+  slug: string;
+  routePath?: string | null;
+  sortOrder: number;
+  parentId: string | number;
+  isActive: boolean;
+  actions: StandardPermissionActionMapping[];
+  children?: StandardModuleWithActions[];
+}
+
+export interface RolePermissionMatrixRow {
+  moduleId: string | number;
+  moduleName: string;
+  slug: string;
+  parentId: string | number;
+  level: number;
+  actions: {
+    actionKey: string;
+    actionName: string;
+    actionId: string | number;
+    permissionActionId: string | number;
+    permissionKey: string;
+    isAssigned: boolean;
+  }[];
+}
+
+export interface RoleFormData {
+  role_name: string;
+  role_key: string;
+  description?: string;
+  entityId?: string | number | null;
+  departmentId?: string | number | null;
+  is_active?: boolean;
+}

package/src/core/types/router.types.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+
+export interface RouterAdapter {
+  navigate: (path: string) => void;
+  renderLink?: (props: { href: string; className?: string; children: React.ReactNode }) => React.ReactNode;
+  currentPath?: string;
+}
+
+/**
+ * Creates a router adapter for Next.js App Router or Pages Router
+ * Usage:
+ * createNextRouterAdapter(useRouter(), Link)
+ */
+export function createNextRouterAdapter(
+  router: { push: (url: string) => void },
+  LinkComponent?: React.ComponentType<any>
+): RouterAdapter {
+  return {
+    navigate: (path: string) => router.push(path),
+    renderLink: LinkComponent
+      ? ({ href, className, children }) =>
+          React.createElement(LinkComponent, { href, className }, children)
+      : undefined,
+  };
+}
+
+/**
+ * Creates a router adapter for React Router (v5/v6)
+ * Usage:
+ * createReactRouterAdapter(useNavigate(), Link)
+ */
+export function createReactRouterAdapter(
+  navigateFn: (path: string) => void,
+  LinkComponent?: React.ComponentType<any>
+): RouterAdapter {
+  return {
+    navigate: (path: string) => navigateFn(path),
+    renderLink: LinkComponent
+      ? ({ href, className, children }) =>
+          React.createElement(LinkComponent, { to: href, className }, children)
+      : undefined,
+  };
+}

package/src/core/types/style.types.ts

@@ -0,0 +1,53 @@
+export interface TableClassNames {
+  container?: string;
+  table?: string;
+  thead?: string;
+  th?: string;
+  tbody?: string;
+  tr?: string;
+  td?: string;
+  empty?: string;
+  pagination?: {
+    container?: string;
+    info?: string;
+    buttons?: string;
+    pageText?: string;
+  };
+}
+
+export interface MasterDataTableClassNames {
+  root?: string;
+  header?: {
+    container?: string;
+    title?: string;
+    description?: string;
+    addButton?: string;
+  };
+  search?: {
+    container?: string;
+    input?: string;
+  };
+  table?: TableClassNames;
+  modal?: {
+    backdrop?: string;
+    container?: string;
+    header?: string;
+    body?: string;
+    footer?: string;
+  };
+}
+
+export interface RoleListTableClassNames {
+  root?: string;
+  header?: {
+    container?: string;
+    title?: string;
+    description?: string;
+    createButton?: string;
+  };
+  search?: {
+    container?: string;
+    input?: string;
+  };
+  table?: TableClassNames;
+}

package/src/core/utils/permissionResolver.ts

@@ -0,0 +1,44 @@
+import { PERMISSION_KEYS } from '../../constants/permissions';
+
+export type PermissionKeyResolverFn = (moduleKey: string, actionKey: string) => string;
+
+/**
+ * Default resolver produces: `<module>.<action>` (e.g. "roles.add", "department_master.view")
+ */
+export const defaultPermissionResolver: PermissionKeyResolverFn = (moduleKey: string, actionKey: string): string => {
+  // Check if defined in PERMISSION_KEYS container
+  if (moduleKey === 'roles') {
+    const act = actionKey.toUpperCase() as keyof typeof PERMISSION_KEYS.roles;
+    if (PERMISSION_KEYS.roles[act]) return PERMISSION_KEYS.roles[act];
+  }
+
+  const masterModule = PERMISSION_KEYS.masters[moduleKey as keyof typeof PERMISSION_KEYS.masters];
+  if (masterModule) {
+    const act = actionKey.toUpperCase() as keyof typeof masterModule;
+    if (masterModule[act]) return masterModule[act];
+  }
+
+  return `${moduleKey}.${actionKey}`;
+};
+
+/**
+ * Resolves a permission string, checking alias maps if present
+ */
+export function resolvePermission(
+  input: { permissionKey?: string; module?: string; action?: string },
+  resolver: PermissionKeyResolverFn = defaultPermissionResolver,
+  aliasMap: Record<string, string> = {}
+): string {
+  let resolved = input.permissionKey || '';
+
+  if (!resolved && input.module && input.action) {
+    resolved = resolver(input.module, input.action);
+  }
+
+  // Check alias override if configured
+  if (resolved && aliasMap[resolved]) {
+    return aliasMap[resolved];
+  }
+
+  return resolved;
+}

package/src/index.ts

@@ -0,0 +1,44 @@
+// Central Constants & Customization
+export * from './constants';
+export * from './constants/permissions';
+
+// Configuration
+export * from './config/rbac.config';
+
+// Theming & UI Styling Customization
+export * from './theme';
+
+// Core Types
+export * from './core/types';
+
+// API Adapters & Transformers
+export * from './core/adapters';
+export * from './core/api/httpClient';
+
+// Contexts & State
+export * from './core/context/RBACConfigContext';
+export * from './core/context/PermissionContext';
+
+// Access Control Guards & Resolvers
+export * from './core/guards/Can';
+export * from './core/guards/RouteGuard';
+export * from './core/utils/permissionResolver';
+
+// Hooks
+export * from './core/hooks/useRoles';
+export * from './core/hooks/usePermissions';
+export * from './core/hooks/useMaster';
+
+// Shared UI Components
+export * from './shared/components/Button';
+export * from './shared/components/Input';
+export * from './shared/components/Modal';
+export * from './shared/components/Badge';
+export * from './shared/components/Table';
+export * from './shared/components/DynamicSidebar';
+
+// Roles & Permissions Module
+export * from './modules/roles-and-permissions';
+
+// Masters Module
+export * from './modules/masters';