ra-core/dist/auth/useCanAccessResources.js

Core components of react-admin, a frontend Framework for building admin applications on top of REST services, using ES6, React

import { useMemo } from 'react';
import { useQuery } from '@tanstack/react-query';
import useAuthProvider from "./useAuthProvider.js";
import { useRecordContext } from "../controller/index.js";
/**
 * Checks whether users can access the provided resources.
 *
 * `useCanAccessResources` returns an object describing the state of the request:
 *
 * - start: { isPending: true }
 * - success: { canAccess: Object<string, boolean>, isPending: false }
 * - error: { error: [error from provider], isPending: false }
 *
 * @param {Object} params Any params you want to pass to the authProvider
 * @param {string} params.action The action to check access for
 * @param {string[]} params.resources The list of resources to check access for
 * @param {Object} params.record Optional. The record to check access for
 *
 * @returns Return the react-query result and a canAccess property which is a map of the resources and their access status { [resource: string]: boolean }
 *
 * @example
 * import { useCanAccessResources } from 'react-admin';
 *
 * const UserList = ({ record }) => {
 *     const { isPending, canAccess } = useCanAccessResources({
 *         action: 'read',
 *         resources: ['users.id', 'users.name', 'users.email'],
 *         record
 *     });
 *
 *     if (isPending) {
 *         return null;
 *     }
 *     return (
 *         <SimpleList
 *              primaryText={record => canAccess.users.name ? record.name : ''}
 *              secondaryText={record => canAccess.users.email ? record.email : ''}
 *              tertiaryText={record => canAccess.users.id ? record.id : ''}
 *          />
 *     );
 * };
 */
export const useCanAccessResources = (params) => {
    const authProvider = useAuthProvider();
    const record = useRecordContext(params);
    const { action, resources, ...options } = params;
    const queryResult = useQuery({
        queryKey: ['auth', 'canAccess', resources, action, record],
        queryFn: async ({ signal }) => {
            const queries = await Promise.all(resources.map(async (resource) => {
                if (!authProvider || !authProvider.canAccess) {
                    return { canAccess: true, resource };
                }
                const canAccess = await authProvider.canAccess({
                    resource,
                    action,
                    record,
                    signal: authProvider.supportAbortSignal
                        ? signal
                        : undefined,
                });
                return { canAccess, resource };
            }));
            const result = queries.reduce((acc, { resource, canAccess }) => {
                acc[resource] = canAccess;
                return acc;
            }, {});
            return result;
        },
        ...options,
    });
    const result = useMemo(() => {
        return {
            canAccess: queryResult.data,
            ...queryResult,
        };
    }, [queryResult]);
    const resultWithoutAuthProvider = useMemo(() => {
        return {
            canAccess: resources.reduce((acc, resource) => {
                acc[resource] = true;
                return acc;
            }, {}),
            isPending: false,
            isError: false,
            error: null,
        };
    }, [resources]);
    return !authProvider || !authProvider.canAccess
        ? resultWithoutAuthProvider
        : result;
};
//# sourceMappingURL=useCanAccessResources.js.map