@goplusvn/core 0.1.0

package/dist/rbac/index.d.ts

@@ -0,0 +1,226 @@
+import { Permission, CrudPermissions } from '../types/index.js';
+import { Session } from 'next-auth';
+export { R as ResourcePrismaClient, a as RoleData, b as RoleFilters, c as RolePrismaClient, g as getActionsForPermissionMatrix, d as getResourcesData, e as getResourcesForPermissionMatrix, f as getRolesData } from '../server-QuYCTa89.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import 'lucide-react';
+import 'react';
+import 'zod';
+
+/**
+ * Interface defining the subset of Prisma Client required for RBAC operations.
+ * This allows the service to be agnostic of the actual PrismaClient instance.
+ */
+interface RBACPrismaClient {
+    userRole: {
+        findMany: (args: {
+            where: {
+                userId: string;
+            };
+            select: {
+                roleCode: boolean;
+                role: {
+                    select: {
+                        rolePermissions: {
+                            select: {
+                                resourceCode: boolean;
+                                actionCode: boolean;
+                            };
+                        };
+                    };
+                };
+            };
+        }) => Promise<Array<{
+            roleCode: string;
+            role: {
+                rolePermissions: Array<{
+                    resourceCode: string;
+                    actionCode: string;
+                }>;
+            };
+        }>>;
+    };
+}
+/**
+ * Fetch user permissions from database based on roles.
+ * Deduplicates permissions by resourceCode:actionCode.
+ *
+ * @param db - The tenant-specific Prisma Client instance
+ * @param userId - The user ID to fetch permissions for
+ */
+declare function getUserPermissionsFromDB(db: RBACPrismaClient, userId: string): Promise<Permission[]>;
+/**
+ * Get permissions with caching.
+ *
+ * @param db - The tenant-specific Prisma Client instance
+ * @param userId - The user ID
+ * @param opts.forceRefresh - Bypass cache
+ */
+declare function getCachedUserPermissions(db: RBACPrismaClient, userId: string, opts?: {
+    forceRefresh?: boolean;
+}): Promise<Permission[]>;
+
+/**
+ * Resource Validator
+ * Validates resource codes against DB with caching
+ */
+interface ResourcePrismaClient {
+    resource: {
+        findUnique: (args: {
+            where: {
+                code: string;
+            };
+        }) => Promise<{
+            code: string;
+        } | null>;
+        findMany: (args?: {
+            select?: {
+                code: boolean;
+            };
+        }) => Promise<{
+            code: string;
+        }[]>;
+    };
+}
+/**
+ * Check if a resource code exists.
+ * Checks cache first, then DB if not found.
+ *
+ * @param db - Prisma client
+ * @param resourceCode - Resource code to validate
+ * @returns true if valid, false otherwise
+ */
+declare function isValidResourceCode(db: ResourcePrismaClient, resourceCode: string): Promise<boolean>;
+/**
+ * Get the correct resource code for permission checking.
+ * Priority: config.permissionResource > config.name > entity param
+ *
+ * @param config - Entity config (may be partial)
+ * @param entityParam - Entity param from URL
+ * @returns Resource code to use for permission check
+ */
+declare function getPermissionResourceCode(config: {
+    permissionResource?: string;
+    name?: string;
+} | null | undefined, entityParam: string): string;
+/**
+ * Validate and get resource code for permission checking.
+ * Combines getPermissionResourceCode with DB validation.
+ *
+ * @param db - Prisma client
+ * @param config - Entity config
+ * @param entityParam - Entity param from URL
+ * @returns Object with resourceCode and isValid flag
+ */
+declare function validatePermissionResource(db: ResourcePrismaClient, config: {
+    permissionResource?: string;
+    name?: string;
+} | null | undefined, entityParam: string): Promise<{
+    resourceCode: string;
+    isValid: boolean;
+}>;
+/**
+ * Preload all resource codes into cache.
+ * Call this on app startup for better performance.
+ *
+ * @param db - Prisma client
+ */
+declare function preloadResourceCodes(db: ResourcePrismaClient): Promise<void>;
+/**
+ * Clear resource cache.
+ * Call when resources are added/removed.
+ */
+declare function clearResourceCache(): Promise<void>;
+
+type User = {
+    id: string;
+    name: string | null;
+    email: string | null;
+    image: string | null;
+    isActive: boolean;
+    jobTitle?: string;
+};
+type Role = {
+    id: string;
+    name: string;
+    code: string;
+    description?: string | null | undefined;
+    status: string;
+    permissions: string[];
+    usersCount: number;
+    users: User[];
+    createdAt: string;
+    updatedAt: string;
+    createdBy?: string | null | undefined;
+    updatedBy?: string | null | undefined;
+};
+type RolesResponse = {
+    total: number;
+    page: number;
+    pageSize: number;
+    items: Role[];
+};
+
+interface RoleListPageProps {
+    dictionary: any;
+    permissions: CrudPermissions;
+    lang: string;
+    initialData: RolesResponse;
+    resources: Array<{
+        id: string;
+        code: string;
+        name: string;
+        group: string | null;
+        description: string | null;
+        icon: string | null;
+        order: number | null;
+        config: any;
+    }>;
+    actions: Array<{
+        id: string;
+        code: string;
+        name: string;
+        description: string | null;
+        isDefault?: boolean;
+    }>;
+}
+declare function RoleListPage({ dictionary, permissions, lang, initialData, resources, actions, }: RoleListPageProps): react_jsx_runtime.JSX.Element;
+
+declare const CRUD_ACTIONS: {
+    readonly create: "create";
+    readonly view: "view";
+    readonly update: "update";
+    readonly delete: "delete";
+    readonly export: "export";
+    readonly import: "import";
+    readonly approve: "approve";
+    readonly reject: "reject";
+};
+type CrudAction = keyof typeof CRUD_ACTIONS;
+declare function getActionCode(operation: CrudAction): string;
+declare function getAllCrudActionCodes(): string[];
+declare function isCrudAction(actionCode: string): boolean;
+declare function getFromCache(userId: string): Promise<Permission[] | undefined>;
+declare function setToCache(userId: string, data: Permission[]): Promise<void>;
+declare const pendingQueries: Map<string, Promise<Permission[]>>;
+declare function clearAllPermissionsCache(): Promise<void>;
+declare function clearUserPermissionsCache(userId: string): Promise<void>;
+declare function invalidateUserPermissions(userId: string): Promise<void>;
+
+declare function getUserPermissions(session: Session | null): Permission[];
+declare function getCrudPermissionsFromSession(session: Session | null, entity: string): {
+    create: boolean;
+    view: boolean;
+    update: boolean;
+    delete: boolean;
+    export: boolean;
+    import: boolean;
+    approve: boolean;
+    reject: boolean;
+};
+declare function checkPermission(session: Session | null, resourceCode: string, actionCode: string): boolean;
+declare function hasPermission(session: Session | null, resourceCode: string, actionCode: string): boolean;
+declare function requirePermission(session: Session | null, resourceCode: string, actionCode: string): void;
+declare function hasRole(session: Session | null, roleCode: string): boolean;
+declare function hasAnyRole(session: Session | null, roleCodes: string[]): boolean;
+
+export { CRUD_ACTIONS, type CrudAction, type RBACPrismaClient, RoleListPage, checkPermission, clearAllPermissionsCache, clearResourceCache, clearUserPermissionsCache, getActionCode, getAllCrudActionCodes, getCachedUserPermissions, getCrudPermissionsFromSession, getFromCache, getPermissionResourceCode, getUserPermissions, getUserPermissionsFromDB, hasAnyRole, hasPermission, hasRole, invalidateUserPermissions, isCrudAction, isValidResourceCode, pendingQueries, preloadResourceCodes, requirePermission, setToCache, validatePermissionResource };