@strato-admin/faker-ecommerce 0.1.1 → 0.3.0

package/dist/dataProvider.js

@@ -2,5 +2,4 @@ import fakeRestDataProvider from 'ra-data-fakerest';
 import { generateEcommerceData } from './generate';
 const data = generateEcommerceData();
 export const dataProvider = fakeRestDataProvider(data, true, // logging
-500 // simulate network delay
-);
+500);

package/dist/generate.d.ts

@@ -1,8 +1,9 @@
-import { Category, Customer, Order, Product, Review } from './types';
+import { Category, Customer, Order, OrderItem, Product, Review } from './types';
 export declare const generateEcommerceData: () => {
     categories: Category[];
     customers: Customer[];
     products: Product[];
     reviews: Review[];
     orders: Order[];
+    'order-items': OrderItem[];
 };

package/dist/generate.js

@@ -31,7 +31,10 @@ export const generateEcommerceData = () => {
         const last_seen = faker.date.between({ from: first_seen, to: new Date() });
         const has_ordered = faker.datatype.boolean({ probability: 0.8 });
         const has_newsletter = faker.datatype.boolean({ probability: 0.3 });
-        const groups = faker.helpers.arrayElements(['collector', 'ordered_once', 'regular', 'reviewer'], { min: 0, max: 2 });
+        const groups = faker.helpers.arrayElements(['collector', 'ordered_once', 'regular', 'reviewer'], {
+            min: 0,
+            max: 2,
+        });
         return {
             id,
             first_name,
@@ -89,21 +92,24 @@ export const generateEcommerceData = () => {
         };
     });
     // 5. Generate Orders
+    const allOrderItems = [];
     const orders = Array.from({ length: 300 }, (_, id) => {
-        const customer = faker.helpers.arrayElement(customers.filter(c => c.has_ordered));
+        const customer = faker.helpers.arrayElement(customers.filter((c) => c.has_ordered));
         const date = faker.date.between({ from: customer.first_seen, to: customer.last_seen });
         const nbItems = faker.number.int({ min: 1, max: 5 });
-        const basket = Array.from({ length: nbItems }, (_, itemId) => {
+        const items = Array.from({ length: nbItems }, (_, itemId) => {
             const product = faker.helpers.arrayElement(products);
-            return {
+            const item = {
                 id: id * 10 + itemId,
                 order_id: id,
                 product_id: product.id,
                 quantity: faker.number.int({ min: 1, max: 10 }),
                 unit_price: product.price,
             };
+            allOrderItems.push(item);
+            return item;
         });
-        const total_ex_taxes = basket.reduce((sum, item) => sum + item.quantity * item.unit_price, 0);
+        const total_ex_taxes = items.reduce((sum, item) => sum + item.quantity * item.unit_price, 0);
         const delivery_fees = faker.number.float({ min: 0, max: 20, fractionDigits: 2 });
         const tax_rate = 0.2;
         const taxes = (total_ex_taxes + delivery_fees) * tax_rate;
@@ -117,8 +123,8 @@ export const generateEcommerceData = () => {
             customer.latest_purchase = date;
         }
         // Update product stats
-        basket.forEach(item => {
-            const product = products.find(p => p.id === item.product_id);
+        items.forEach((item) => {
+            const product = products.find((p) => p.id === item.product_id);
             if (product) {
                 product.sales += item.quantity;
             }
@@ -128,7 +134,7 @@ export const generateEcommerceData = () => {
             reference: faker.string.alphanumeric({ length: 6, casing: 'upper' }),
             date,
             customer_id: customer.id,
-            basket,
+            items,
             total_ex_taxes,
             delivery_fees,
             tax_rate,
@@ -144,5 +150,6 @@ export const generateEcommerceData = () => {
         products,
         reviews,
         orders,
+        'order-items': allOrderItems,
     };
 };

package/dist/ra-core/src/auth/LogoutOnMount.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Log the user out and redirect them to login.
+ *
+ * To be used as a catch-all route for anonymous users in a secure app.
+ *
+ * @see CoreAdminRoutes
+ */
+export declare const LogoutOnMount: () => null;

package/dist/ra-core/src/auth/LogoutOnMount.js

@@ -0,0 +1,16 @@
+import { useEffect } from 'react';
+import useLogout from './useLogout';
+/**
+ * Log the user out and redirect them to login.
+ *
+ * To be used as a catch-all route for anonymous users in a secure app.
+ *
+ * @see CoreAdminRoutes
+ */
+export const LogoutOnMount = () => {
+    const logout = useLogout();
+    useEffect(() => {
+        logout();
+    }, [logout]);
+    return null;
+};

package/dist/ra-core/src/auth/addRefreshAuthToAuthProvider.d.ts

@@ -0,0 +1,22 @@
+import { AuthProvider } from '../types';
+/**
+ * A higher-order function which wraps an authProvider to handle refreshing authentication.
+ * This is useful when the authentication service supports a refresh token mechanism.
+ * The wrapped provider will call the refreshAuth function before
+ * calling the authProvider checkAuth, getIdentity and getPermissions methods.
+ *
+ * The refreshAuth function should return a Promise that resolves when the authentication token has been refreshed.
+ * It might throw an error if the refresh failed. In this case, react-admin will handle the error as usual.
+ *
+ * @param provider An authProvider
+ * @param refreshAuth A function that refreshes the authentication token if needed and returns a Promise.
+ * @returns A wrapped authProvider.
+ *
+ * @example
+ * import { addRefreshAuthToAuthProvider } from 'react-admin';
+ * import { authProvider } from './authProvider';
+ * import { refreshAuth } from './refreshAuth';
+ *
+ * const authProvider = addRefreshAuthToAuthProvider(authProvider, refreshAuth);
+ */
+export declare const addRefreshAuthToAuthProvider: <AuthProviderType extends AuthProvider = AuthProvider>(provider: AuthProviderType, refreshAuth: () => Promise<void>) => AuthProviderType;

package/dist/ra-core/src/auth/addRefreshAuthToAuthProvider.js

@@ -0,0 +1,41 @@
+/**
+ * A higher-order function which wraps an authProvider to handle refreshing authentication.
+ * This is useful when the authentication service supports a refresh token mechanism.
+ * The wrapped provider will call the refreshAuth function before
+ * calling the authProvider checkAuth, getIdentity and getPermissions methods.
+ *
+ * The refreshAuth function should return a Promise that resolves when the authentication token has been refreshed.
+ * It might throw an error if the refresh failed. In this case, react-admin will handle the error as usual.
+ *
+ * @param provider An authProvider
+ * @param refreshAuth A function that refreshes the authentication token if needed and returns a Promise.
+ * @returns A wrapped authProvider.
+ *
+ * @example
+ * import { addRefreshAuthToAuthProvider } from 'react-admin';
+ * import { authProvider } from './authProvider';
+ * import { refreshAuth } from './refreshAuth';
+ *
+ * const authProvider = addRefreshAuthToAuthProvider(authProvider, refreshAuth);
+ */
+export const addRefreshAuthToAuthProvider = (provider, refreshAuth) => {
+    const proxy = new Proxy(provider, {
+        get(_, name) {
+            const shouldIntercept = AuthProviderInterceptedMethods.includes(name.toString()) &&
+                provider[name.toString()] != null;
+            if (shouldIntercept) {
+                return async (...args) => {
+                    await refreshAuth();
+                    return provider[name.toString()](...args);
+                };
+            }
+            return provider[name.toString()];
+        },
+    });
+    return proxy;
+};
+const AuthProviderInterceptedMethods = [
+    'checkAuth',
+    'getIdentity',
+    'getPermissions',
+];

package/dist/ra-core/src/auth/addRefreshAuthToDataProvider.d.ts

@@ -0,0 +1,21 @@
+import { DataProvider } from '../types';
+/**
+ * A higher-order function which wraps a dataProvider to handle refreshing authentication.
+ * This is useful when the authentication service supports a refresh token mechanism.
+ * The wrapped provider will call the refreshAuth function before calling any dataProvider methods.
+ *
+ * The refreshAuth function should return a Promise that resolves when the authentication token has been refreshed.
+ * It might throw an error if the refresh failed. In this case, react-admin will handle the error as usual.
+ *
+ * @param provider A dataProvider
+ * @param refreshAuth A function that refreshes the authentication token if needed and returns a Promise.
+ * @returns A wrapped dataProvider.
+ *
+ * @example
+ * import { addRefreshAuthToDataProvider } from 'react-admin';
+ * import { jsonServerProvider } from 'ra-data-json-server';
+ * import { refreshAuth } from './refreshAuth';
+ *
+ * const dataProvider = addRefreshAuthToDataProvider(jsonServerProvider('http://localhost:3000'), refreshAuth);
+ */
+export declare const addRefreshAuthToDataProvider: <DataProviderType extends DataProvider = DataProvider>(provider: DataProviderType, refreshAuth: () => Promise<void>) => DataProviderType;

package/dist/ra-core/src/auth/addRefreshAuthToDataProvider.js

@@ -0,0 +1,30 @@
+/**
+ * A higher-order function which wraps a dataProvider to handle refreshing authentication.
+ * This is useful when the authentication service supports a refresh token mechanism.
+ * The wrapped provider will call the refreshAuth function before calling any dataProvider methods.
+ *
+ * The refreshAuth function should return a Promise that resolves when the authentication token has been refreshed.
+ * It might throw an error if the refresh failed. In this case, react-admin will handle the error as usual.
+ *
+ * @param provider A dataProvider
+ * @param refreshAuth A function that refreshes the authentication token if needed and returns a Promise.
+ * @returns A wrapped dataProvider.
+ *
+ * @example
+ * import { addRefreshAuthToDataProvider } from 'react-admin';
+ * import { jsonServerProvider } from 'ra-data-json-server';
+ * import { refreshAuth } from './refreshAuth';
+ *
+ * const dataProvider = addRefreshAuthToDataProvider(jsonServerProvider('http://localhost:3000'), refreshAuth);
+ */
+export const addRefreshAuthToDataProvider = (provider, refreshAuth) => {
+    const proxy = new Proxy(provider, {
+        get(_, name) {
+            return async (...args) => {
+                await refreshAuth();
+                return provider[name.toString()](...args);
+            };
+        },
+    });
+    return proxy;
+};

package/dist/ra-core/src/auth/convertLegacyAuthProvider.d.ts

@@ -0,0 +1,12 @@
+import { AuthProvider, LegacyAuthProvider } from '../types';
+/**
+ * Turn a function-based authProvider to an object-based one
+ *
+ * Allows using legacy authProviders transparently.
+ *
+ * @param {Function} legacyAuthProvider A legacy authProvider (type, params) => Promise<any>
+ *
+ * @returns {Object} An authProvider that react-admin can use
+ */
+declare const _default: (legacyAuthProvider: LegacyAuthProvider) => AuthProvider;
+export default _default;

package/dist/ra-core/src/auth/convertLegacyAuthProvider.js

@@ -0,0 +1,19 @@
+import { AUTH_LOGIN, AUTH_LOGOUT, AUTH_CHECK, AUTH_ERROR, AUTH_GET_PERMISSIONS, } from './types';
+/**
+ * Turn a function-based authProvider to an object-based one
+ *
+ * Allows using legacy authProviders transparently.
+ *
+ * @param {Function} legacyAuthProvider A legacy authProvider (type, params) => Promise<any>
+ *
+ * @returns {Object} An authProvider that react-admin can use
+ */
+export default (legacyAuthProvider) => {
+    const authProvider = (...args) => legacyAuthProvider.apply(null, args);
+    authProvider.login = params => legacyAuthProvider(AUTH_LOGIN, params);
+    authProvider.logout = params => legacyAuthProvider(AUTH_LOGOUT, params);
+    authProvider.checkAuth = params => legacyAuthProvider(AUTH_CHECK, params);
+    authProvider.checkError = error => legacyAuthProvider(AUTH_ERROR, error);
+    authProvider.getPermissions = params => legacyAuthProvider(AUTH_GET_PERMISSIONS, params);
+    return authProvider;
+};

package/dist/ra-core/src/auth/index.d.ts

@@ -0,0 +1,27 @@
+import useAuthProvider from './useAuthProvider';
+import useAuthState from './useAuthState';
+import usePermissions from './usePermissions';
+import WithPermissions, { WithPermissionsProps } from './WithPermissions';
+import useLogin from './useLogin';
+import useLogout from './useLogout';
+import useGetPermissions from './useGetPermissions';
+import useLogoutIfAccessDenied from './useLogoutIfAccessDenied';
+import convertLegacyAuthProvider from './convertLegacyAuthProvider';
+export * from './Authenticated';
+export * from './AuthContext';
+export * from './CanAccess';
+export * from './LogoutOnMount';
+export * from './types';
+export * from './useAuthenticated';
+export * from './useCanAccess';
+export * from './useCanAccessResources';
+export * from './useCanAccessCallback';
+export * from './useCheckAuth';
+export * from './useGetIdentity';
+export * from './useHandleAuthCallback';
+export * from './useIsAuthPending';
+export * from './useRequireAccess';
+export * from './addRefreshAuthToAuthProvider';
+export * from './addRefreshAuthToDataProvider';
+export { useAuthProvider, convertLegacyAuthProvider, useLogin, useLogout, useGetPermissions, usePermissions, useAuthState, useLogoutIfAccessDenied, WithPermissions, };
+export type { WithPermissionsProps };

package/dist/ra-core/src/auth/index.js

@@ -0,0 +1,34 @@
+import useAuthProvider from './useAuthProvider';
+import useAuthState from './useAuthState';
+import usePermissions from './usePermissions';
+import WithPermissions from './WithPermissions';
+import useLogin from './useLogin';
+import useLogout from './useLogout';
+import useGetPermissions from './useGetPermissions';
+import useLogoutIfAccessDenied from './useLogoutIfAccessDenied';
+import convertLegacyAuthProvider from './convertLegacyAuthProvider';
+export * from './Authenticated';
+export * from './AuthContext';
+export * from './CanAccess';
+export * from './LogoutOnMount';
+export * from './types';
+export * from './useAuthenticated';
+export * from './useCanAccess';
+export * from './useCanAccessResources';
+export * from './useCanAccessCallback';
+export * from './useCheckAuth';
+export * from './useGetIdentity';
+export * from './useHandleAuthCallback';
+export * from './useIsAuthPending';
+export * from './useRequireAccess';
+export * from './addRefreshAuthToAuthProvider';
+export * from './addRefreshAuthToDataProvider';
+export { useAuthProvider, convertLegacyAuthProvider, 
+// low-level hooks for calling a particular verb on the authProvider
+useLogin, useLogout, useGetPermissions, 
+// hooks with state management
+usePermissions, useAuthState, 
+// hook with immediate effect
+useLogoutIfAccessDenied, 
+// components
+WithPermissions, };

package/dist/ra-core/src/auth/types.d.ts

@@ -0,0 +1,7 @@
+export type UserCheck = (payload: object, pathName: string, routeParams?: object) => void;
+export declare const AUTH_LOGIN = "AUTH_LOGIN";
+export declare const AUTH_CHECK = "AUTH_CHECK";
+export declare const AUTH_ERROR = "AUTH_ERROR";
+export declare const AUTH_LOGOUT = "AUTH_LOGOUT";
+export declare const AUTH_GET_PERMISSIONS = "AUTH_GET_PERMISSIONS";
+export type AuthActionType = typeof AUTH_LOGIN | typeof AUTH_LOGOUT | typeof AUTH_ERROR | typeof AUTH_CHECK | typeof AUTH_GET_PERMISSIONS;

package/dist/ra-core/src/auth/types.js

@@ -0,0 +1,5 @@
+export const AUTH_LOGIN = 'AUTH_LOGIN';
+export const AUTH_CHECK = 'AUTH_CHECK';
+export const AUTH_ERROR = 'AUTH_ERROR';
+export const AUTH_LOGOUT = 'AUTH_LOGOUT';
+export const AUTH_GET_PERMISSIONS = 'AUTH_GET_PERMISSIONS';

package/dist/ra-core/src/auth/useAuthProvider.d.ts

@@ -0,0 +1,10 @@
+import { AuthProvider } from '../types';
+export declare const defaultAuthParams: {
+    loginUrl: string;
+    afterLoginUrl: string;
+};
+/**
+ * Get the authProvider stored in the context
+ */
+declare const useAuthProvider: <AuthProviderType extends AuthProvider = AuthProvider>() => AuthProviderType | undefined;
+export default useAuthProvider;

package/dist/ra-core/src/auth/useAuthProvider.js

@@ -0,0 +1,11 @@
+import { useContext } from 'react';
+import { AuthContext } from './AuthContext';
+export const defaultAuthParams = {
+    loginUrl: '/login',
+    afterLoginUrl: '/',
+};
+/**
+ * Get the authProvider stored in the context
+ */
+const useAuthProvider = () => useContext(AuthContext);
+export default useAuthProvider;

package/dist/ra-core/src/auth/useAuthState.d.ts

@@ -0,0 +1,48 @@
+import { QueryObserverResult, UseQueryOptions } from '@tanstack/react-query';
+/**
+ * Hook for getting the authentication status
+ *
+ * Calls the authProvider.checkAuth() method asynchronously.
+ *
+ * The return value updates according to the authProvider request state:
+ *
+ * - isPending: true just after mount, while the authProvider is being called. false once the authProvider has answered.
+ * - authenticated: true while loading. then true or false depending on the authProvider response.
+ *
+ * To avoid rendering a component and force waiting for the authProvider response, use the useAuthState() hook
+ * instead of the useAuthenticated() hook.
+ *
+ * You can render different content depending on the authenticated status.
+ *
+ * @see useAuthenticated()
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ *
+ * @param {Boolean} logoutOnFailure: Optional. Whether the user should be logged out if the authProvider fails to authenticate them. False by default.
+ *
+ * @returns The current auth check state. Destructure as { authenticated, error, isPending }.
+ *
+ * @example
+ * import { useAuthState, Loading } from 'react-admin';
+ *
+ * const MyPage = () => {
+ *     const { isPending, authenticated } = useAuthState();
+ *     if (isPending) {
+ *         return <Loading />;
+ *     }
+ *     if (authenticated) {
+ *        return <AuthenticatedContent />;
+ *     }
+ *     return <AnonymousContent />;
+ * };
+ */
+declare const useAuthState: <ErrorType = Error>(params?: any, logoutOnFailure?: boolean, queryOptions?: UseAuthStateOptions<ErrorType>) => UseAuthStateResult<ErrorType>;
+type UseAuthStateOptions<ErrorType = Error> = Omit<UseQueryOptions<boolean, ErrorType>, 'queryKey' | 'queryFn'> & {
+    onSuccess?: (data: boolean) => void;
+    onError?: (err: ErrorType) => void;
+    onSettled?: (data?: boolean, error?: Error) => void;
+};
+export type UseAuthStateResult<ErrorType = Error> = QueryObserverResult<boolean, ErrorType> & {
+    authenticated?: QueryObserverResult<boolean, ErrorType>['data'];
+};
+export default useAuthState;

package/dist/ra-core/src/auth/useAuthState.js

@@ -0,0 +1,171 @@
+import { useEffect, useMemo } from 'react';
+import { useQuery, } from '@tanstack/react-query';
+import useAuthProvider, { defaultAuthParams } from './useAuthProvider';
+import useLogout from './useLogout';
+import { removeDoubleSlashes, useBasename } from '../routing';
+import { useNotify } from '../notification';
+import { useEvent } from '../util';
+const emptyParams = {};
+/**
+ * Hook for getting the authentication status
+ *
+ * Calls the authProvider.checkAuth() method asynchronously.
+ *
+ * The return value updates according to the authProvider request state:
+ *
+ * - isPending: true just after mount, while the authProvider is being called. false once the authProvider has answered.
+ * - authenticated: true while loading. then true or false depending on the authProvider response.
+ *
+ * To avoid rendering a component and force waiting for the authProvider response, use the useAuthState() hook
+ * instead of the useAuthenticated() hook.
+ *
+ * You can render different content depending on the authenticated status.
+ *
+ * @see useAuthenticated()
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ *
+ * @param {Boolean} logoutOnFailure: Optional. Whether the user should be logged out if the authProvider fails to authenticate them. False by default.
+ *
+ * @returns The current auth check state. Destructure as { authenticated, error, isPending }.
+ *
+ * @example
+ * import { useAuthState, Loading } from 'react-admin';
+ *
+ * const MyPage = () => {
+ *     const { isPending, authenticated } = useAuthState();
+ *     if (isPending) {
+ *         return <Loading />;
+ *     }
+ *     if (authenticated) {
+ *        return <AuthenticatedContent />;
+ *     }
+ *     return <AnonymousContent />;
+ * };
+ */
+const useAuthState = (params = emptyParams, logoutOnFailure = false, queryOptions = emptyParams) => {
+    const authProvider = useAuthProvider();
+    const logout = useLogout();
+    const basename = useBasename();
+    const notify = useNotify();
+    const { onSuccess, onError, onSettled, ...options } = queryOptions;
+    const queryResult = useQuery({
+        queryKey: ['auth', 'checkAuth', params],
+        queryFn: async ({ signal }) => {
+            // The authProvider is optional in react-admin
+            if (!authProvider) {
+                return true;
+            }
+            try {
+                await authProvider.checkAuth({ ...params, signal });
+                return true;
+            }
+            catch (error) {
+                // This is necessary because react-query requires the error to be defined
+                if (error != null) {
+                    throw error;
+                }
+                throw new Error();
+            }
+        },
+        retry: false,
+        ...options,
+    });
+    const onSuccessEvent = useEvent(onSuccess ?? noop);
+    const onSettledEvent = useEvent(onSettled ?? noop);
+    const onErrorEvent = useEvent(onError ??
+        ((error) => {
+            if (!logoutOnFailure)
+                return;
+            const loginUrl = removeDoubleSlashes(`${basename}/${defaultAuthParams.loginUrl}`);
+            logout({}, error && error.redirectTo != null
+                ? error.redirectTo
+                : loginUrl);
+            const shouldSkipNotify = error && error.message === false;
+            !shouldSkipNotify &&
+                notify(getErrorMessage(error, "strato.auth.auth_check_error'), {
+                    type: 'error',
+                });
+        }));
+    useEffect(() => {
+        if (queryResult.data === undefined || queryResult.isFetching)
+            return;
+        if (queryOptions.enabled === false)
+            return;
+        onSuccessEvent(queryResult.data);
+    }, [
+        onSuccessEvent,
+        queryResult.data,
+        queryResult.isFetching,
+        queryOptions.enabled,
+    ]);
+    useEffect(() => {
+        if (queryResult.error == null || queryResult.isFetching)
+            return;
+        if (queryOptions.enabled === false)
+            return;
+        onErrorEvent(queryResult.error);
+    }, [
+        onErrorEvent,
+        queryResult.error,
+        queryResult.isFetching,
+        queryOptions.enabled,
+    ]);
+    useEffect(() => {
+        if (queryResult.status === 'pending' || queryResult.isFetching)
+            return;
+        if (queryOptions.enabled === false)
+            return;
+        onSettledEvent(queryResult.data, queryResult.error);
+    }, [
+        onSettledEvent,
+        queryResult.data,
+        queryResult.error,
+        queryResult.status,
+        queryResult.isFetching,
+        queryOptions.enabled,
+    ]);
+    const result = useMemo(() => {
+        return {
+            ...queryResult,
+            authenticated: queryResult.error ? false : queryResult.data,
+        };
+    }, [queryResult]);
+    return authProvider != null
+        ? result
+        : noAuthProviderQueryResult;
+};
+export default useAuthState;
+const getErrorMessage = (error, defaultMessage) => typeof error === 'string'
+    ? error
+    : typeof error === 'undefined' || !error.message
+        ? defaultMessage
+        : error.message;
+const noop = () => { };
+const noAuthProviderQueryResult = {
+    authenticated: true,
+    data: true,
+    dataUpdatedAt: 0,
+    error: null,
+    errorUpdatedAt: 0,
+    errorUpdateCount: 0,
+    failureCount: 0,
+    failureReason: null,
+    fetchStatus: 'idle',
+    isError: false,
+    isInitialLoading: false,
+    isLoading: false,
+    isLoadingError: false,
+    isFetched: true,
+    isFetchedAfterMount: true,
+    isFetching: false,
+    isPaused: false,
+    isPlaceholderData: false,
+    isPending: false,
+    isRefetchError: false,
+    isRefetching: false,
+    isStale: false,
+    isSuccess: true,
+    status: 'success',
+    refetch: () => Promise.resolve(noAuthProviderQueryResult),
+};

package/dist/ra-core/src/auth/useAuthenticated.d.ts

@@ -0,0 +1,36 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+/**
+ * Restrict access to authenticated users.
+ * Redirect anonymous users to the login page.
+ *
+ * Use it in your custom page components to require
+ * authentication.
+ *
+ * You can set additional `authParams` at will if your authProvider
+ * requires it.
+ *
+ * @example
+ * import { Admin, CustomRoutes, useAuthenticated } from 'react-admin';
+ *
+ * const FooPage = () => {
+ *     const { isPending } = useAuthenticated();
+ *     if (isPending) return null;
+ *     return <Foo />;
+ * }
+ *
+ * const customRoutes = [
+ *     <Route path="/foo" element={<FooPage />} />
+ * ];
+ *
+ * const App = () => (
+ *     <Admin>
+ *         <CustomRoutes>{customRoutes}</CustomRoutes>
+ *     </Admin>
+ * );
+ */
+export declare const useAuthenticated: <ParamsType = any>({ params, logoutOnFailure, ...options }?: UseAuthenticatedOptions<ParamsType>) => import("./useAuthState").UseAuthStateResult<any>;
+export type UseAuthenticatedOptions<ParamsType> = Omit<UseQueryOptions<boolean, any> & {
+    params?: ParamsType;
+}, 'queryKey' | 'queryFn'> & {
+    logoutOnFailure?: boolean;
+};

package/dist/ra-core/src/auth/useAuthenticated.js

@@ -0,0 +1,34 @@
+import useAuthState from './useAuthState';
+/**
+ * Restrict access to authenticated users.
+ * Redirect anonymous users to the login page.
+ *
+ * Use it in your custom page components to require
+ * authentication.
+ *
+ * You can set additional `authParams` at will if your authProvider
+ * requires it.
+ *
+ * @example
+ * import { Admin, CustomRoutes, useAuthenticated } from 'react-admin';
+ *
+ * const FooPage = () => {
+ *     const { isPending } = useAuthenticated();
+ *     if (isPending) return null;
+ *     return <Foo />;
+ * }
+ *
+ * const customRoutes = [
+ *     <Route path="/foo" element={<FooPage />} />
+ * ];
+ *
+ * const App = () => (
+ *     <Admin>
+ *         <CustomRoutes>{customRoutes}</CustomRoutes>
+ *     </Admin>
+ * );
+ */
+export const useAuthenticated = ({ params, logoutOnFailure = true, ...options } = {}) => {
+    return useAuthState(params ?? emptyParams, logoutOnFailure, options);
+};
+const emptyParams = {};