@strato-admin/faker-ecommerce 0.1.0 → 0.3.0

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

@@ -0,0 +1,41 @@
+/**
+ * Get a callback for calling the authProvider.getPermissions() method.
+ *
+ * @see useAuthProvider
+ *
+ * @returns {Function} getPermissions callback
+ *
+ * This is a low level hook. See those more specialized hooks
+ * offering state handling.
+ *
+ * @see usePermissions
+ *
+ * @example
+ *
+ * import { useGetPermissions } from 'react-admin';
+ *
+ * const Roles = () => {
+ *     const [permissions, setPermissions] = useState([]);
+ *     const getPermissions = useGetPermissions();
+ *     useEffect(() => {
+ *         getPermissions().then(permissions => setPermissions(permissions))
+ *     }, [])
+ *     return (
+ *         <ul>
+ *             {permissions.map((permission, key) => (
+ *                 <li key={key}>{permission}</li>
+ *             ))}
+ *         </ul>
+ *     );
+ * }
+ */
+declare const useGetPermissions: () => GetPermissions;
+/**
+ * Proxy for calling authProvider.getPermissions()
+ *
+ * @param {Object} params The parameters to pass to the authProvider
+ *
+ * @return {Promise} The authProvider response
+ */
+type GetPermissions = (params?: any) => Promise<any>;
+export default useGetPermissions;

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

@@ -0,0 +1,47 @@
+import { useCallback } from 'react';
+import useAuthProvider from './useAuthProvider';
+/**
+ * Get a callback for calling the authProvider.getPermissions() method.
+ *
+ * @see useAuthProvider
+ *
+ * @returns {Function} getPermissions callback
+ *
+ * This is a low level hook. See those more specialized hooks
+ * offering state handling.
+ *
+ * @see usePermissions
+ *
+ * @example
+ *
+ * import { useGetPermissions } from 'react-admin';
+ *
+ * const Roles = () => {
+ *     const [permissions, setPermissions] = useState([]);
+ *     const getPermissions = useGetPermissions();
+ *     useEffect(() => {
+ *         getPermissions().then(permissions => setPermissions(permissions))
+ *     }, [])
+ *     return (
+ *         <ul>
+ *             {permissions.map((permission, key) => (
+ *                 <li key={key}>{permission}</li>
+ *             ))}
+ *         </ul>
+ *     );
+ * }
+ */
+const useGetPermissions = () => {
+    const authProvider = useAuthProvider();
+    const getPermissions = useCallback((params = {}) => {
+        // react-query requires the query to return something
+        if (authProvider && authProvider.getPermissions) {
+            return authProvider
+                .getPermissions(params)
+                .then(result => result ?? null);
+        }
+        return Promise.resolve([]);
+    }, [authProvider]);
+    return getPermissions;
+};
+export default useGetPermissions;

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

@@ -0,0 +1,20 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { AuthRedirectResult } from '../types';
+/**
+ * This hook calls the `authProvider.handleCallback()` method on mount. This is meant to be used in a route called
+ * by an external authentication service (e.g. Auth0) after the user has logged in.
+ * By default, it redirects to application home page upon success, or to the `redirectTo` location returned by `authProvider. handleCallback`.
+ *
+ * @returns An object containing { isPending, data, error, refetch }.
+ */
+export declare const useHandleAuthCallback: (options?: UseHandleAuthCallbackOptions) => import("@tanstack/react-query").UseQueryResult<void | AuthRedirectResult, Error>;
+/**
+ * Key used to store the previous location in localStorage.
+ * Used by the useHandleAuthCallback hook to redirect the user to their previous location after a successful login.
+ */
+export declare const PreviousLocationStorageKey = "@react-admin/nextPathname";
+export type UseHandleAuthCallbackOptions = Omit<UseQueryOptions<AuthRedirectResult | void>, 'queryKey' | 'queryFn'> & {
+    onSuccess?: (data: AuthRedirectResult | void) => void;
+    onError?: (err: Error) => void;
+    onSettled?: (data?: AuthRedirectResult | void, error?: Error | null) => void;
+};

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

@@ -0,0 +1,83 @@
+import { useEffect } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { useRedirect, useLocation } from '../routing';
+import useAuthProvider from './useAuthProvider';
+import { useEvent } from '../util';
+/**
+ * This hook calls the `authProvider.handleCallback()` method on mount. This is meant to be used in a route called
+ * by an external authentication service (e.g. Auth0) after the user has logged in.
+ * By default, it redirects to application home page upon success, or to the `redirectTo` location returned by `authProvider. handleCallback`.
+ *
+ * @returns An object containing { isPending, data, error, refetch }.
+ */
+export const useHandleAuthCallback = (options) => {
+    const authProvider = useAuthProvider();
+    const redirect = useRedirect();
+    const location = useLocation();
+    const locationState = location.state;
+    const nextPathName = locationState && locationState.nextPathname;
+    const nextSearch = locationState && locationState.nextSearch;
+    const defaultRedirectUrl = nextPathName ? nextPathName + nextSearch : '/';
+    const { onSuccess, onError, onSettled, ...queryOptions } = options ?? {};
+    let handleCallbackPromise;
+    const queryResult = useQuery({
+        queryKey: ['auth', 'handleCallback'],
+        queryFn: ({ signal }) => {
+            if (!handleCallbackPromise) {
+                handleCallbackPromise =
+                    authProvider &&
+                        typeof authProvider.handleCallback === 'function'
+                        ? authProvider
+                            .handleCallback({ signal })
+                            .then(result => result ?? null)
+                        : Promise.resolve();
+            }
+            return handleCallbackPromise;
+        },
+        retry: false,
+        ...queryOptions,
+    });
+    const onSuccessEvent = useEvent(onSuccess ??
+        ((data) => {
+            // AuthProviders relying on a third party services redirect back to the app can't
+            // use the location state to store the path on which the user was before the login.
+            // So we support a fallback on the localStorage.
+            const previousLocation = localStorage.getItem(PreviousLocationStorageKey);
+            const redirectTo = data?.redirectTo ??
+                previousLocation;
+            if (redirectTo === false) {
+                return;
+            }
+            redirect(redirectTo ?? defaultRedirectUrl);
+        }));
+    const onErrorEvent = useEvent(onError ?? noop);
+    const onSettledEvent = useEvent(onSettled ?? noop);
+    useEffect(() => {
+        if (queryResult.error == null || queryResult.isFetching)
+            return;
+        onErrorEvent(queryResult.error);
+    }, [onErrorEvent, queryResult.error, queryResult.isFetching]);
+    useEffect(() => {
+        if (queryResult.data === undefined || queryResult.isFetching)
+            return;
+        onSuccessEvent(queryResult.data);
+    }, [onSuccessEvent, queryResult.data, queryResult.isFetching]);
+    useEffect(() => {
+        if (queryResult.status === 'pending' || queryResult.isFetching)
+            return;
+        onSettledEvent(queryResult.data, queryResult.error);
+    }, [
+        onSettledEvent,
+        queryResult.data,
+        queryResult.error,
+        queryResult.status,
+        queryResult.isFetching,
+    ]);
+    return queryResult;
+};
+/**
+ * Key used to store the previous location in localStorage.
+ * Used by the useHandleAuthCallback hook to redirect the user to their previous location after a successful login.
+ */
+export const PreviousLocationStorageKey = '@react-admin/nextPathname';
+const noop = () => { };

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

@@ -0,0 +1,13 @@
+import { HintedString } from '../types';
+/**
+ * A hook that returns true if the authProvider is currently checking the authentication status or the user's access rights.
+ * @param params
+ * @param params.action The action to check access for
+ * @param params.resource The resource to check access for (optional). Defaults to the resource of the current ResourceContext.
+ * @returns {boolean} true if the authProvider is currently checking the authentication status or the user's access rights, false otherwise.
+ */
+export declare const useIsAuthPending: (params: UseIsAuthPendingParams) => boolean;
+export type UseIsAuthPendingParams = {
+    resource?: string;
+    action: HintedString<'list' | 'create' | 'edit' | 'show' | 'delete'>;
+};

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

@@ -0,0 +1,30 @@
+import { useQueryClient } from '@tanstack/react-query';
+import { useResourceContext } from '../core';
+import useAuthProvider from './useAuthProvider';
+/**
+ * A hook that returns true if the authProvider is currently checking the authentication status or the user's access rights.
+ * @param params
+ * @param params.action The action to check access for
+ * @param params.resource The resource to check access for (optional). Defaults to the resource of the current ResourceContext.
+ * @returns {boolean} true if the authProvider is currently checking the authentication status or the user's access rights, false otherwise.
+ */
+export const useIsAuthPending = (params) => {
+    const { action, ...props } = params;
+    const queryClient = useQueryClient();
+    const authProvider = useAuthProvider();
+    const resource = useResourceContext(props);
+    if (!authProvider) {
+        return false;
+    }
+    const authQueryState = queryClient.getQueryState(['auth', 'checkAuth', {}]);
+    const canAccessQueryState = queryClient.getQueryState([
+        'auth',
+        'canAccess',
+        { action, resource },
+    ]);
+    if (authQueryState?.status === 'pending' ||
+        (authProvider.canAccess && canAccessQueryState?.status === 'pending')) {
+        return true;
+    }
+    return false;
+};

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

@@ -0,0 +1,34 @@
+/**
+ * Get a callback for calling the authProvider.login() method
+ * and redirect to the previous authenticated page (or the home page) on success.
+ *
+ * @see useAuthProvider
+ *
+ * @returns {Function} login callback
+ *
+ * @example
+ *
+ * import { useLogin } from 'react-admin';
+ *
+ * const LoginButton = () => {
+ *     const [loading, setLoading] = useState(false);
+ *     const login = useLogin();
+ *     const handleClick = {
+ *         setLoading(true);
+ *         login({ username: 'john', password: 'p@ssw0rd' }, '/posts')
+ *             .then(() => setLoading(false));
+ *     }
+ *     return <button onClick={handleClick}>Login</button>;
+ * }
+ */
+declare const useLogin: () => Login;
+/**
+ * Log a user in by calling the authProvider.login() method
+ *
+ * @param {Object} params Login parameters to pass to the authProvider. May contain username/email, password, etc
+ * @param {string} pathName The path to redirect to after login. By default, redirects to the home page, or to the last page visited after disconnection.
+ *
+ * @return {Promise} The authProvider response
+ */
+type Login = (params: any, pathName?: string) => Promise<any>;
+export default useLogin;

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

@@ -0,0 +1,78 @@
+import { useCallback } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { useNotificationContext } from '../notification';
+import { useBasename, useLocation, useNavigate } from '../routing';
+import useAuthProvider, { defaultAuthParams } from './useAuthProvider';
+import { removeDoubleSlashes } from '../routing/useCreatePath';
+/**
+ * Get a callback for calling the authProvider.login() method
+ * and redirect to the previous authenticated page (or the home page) on success.
+ *
+ * @see useAuthProvider
+ *
+ * @returns {Function} login callback
+ *
+ * @example
+ *
+ * import { useLogin } from 'react-admin';
+ *
+ * const LoginButton = () => {
+ *     const [loading, setLoading] = useState(false);
+ *     const login = useLogin();
+ *     const handleClick = {
+ *         setLoading(true);
+ *         login({ username: 'john', password: 'p@ssw0rd' }, '/posts')
+ *             .then(() => setLoading(false));
+ *     }
+ *     return <button onClick={handleClick}>Login</button>;
+ * }
+ */
+const useLogin = () => {
+    const authProvider = useAuthProvider();
+    const queryClient = useQueryClient();
+    const location = useLocation();
+    const locationState = location.state;
+    const navigate = useNavigate();
+    const basename = useBasename();
+    const { resetNotifications } = useNotificationContext();
+    const nextPathName = locationState && locationState.nextPathname;
+    const nextSearch = locationState && locationState.nextSearch;
+    const afterLoginUrl = removeDoubleSlashes(`${basename}/${defaultAuthParams.afterLoginUrl}`);
+    const login = useCallback((params = {}, pathName) => {
+        if (authProvider) {
+            return authProvider.login(params).then(ret => {
+                resetNotifications();
+                queryClient.invalidateQueries({
+                    queryKey: ['auth', 'getPermissions'],
+                });
+                if (ret && ret.hasOwnProperty('redirectTo')) {
+                    if (ret) {
+                        navigate(ret.redirectTo);
+                    }
+                }
+                else {
+                    const redirectUrl = pathName
+                        ? pathName
+                        : nextPathName + nextSearch || afterLoginUrl;
+                    navigate(redirectUrl);
+                }
+                return ret;
+            });
+        }
+        else {
+            resetNotifications();
+            navigate(afterLoginUrl);
+            return Promise.resolve();
+        }
+    }, [
+        authProvider,
+        queryClient,
+        navigate,
+        nextPathName,
+        nextSearch,
+        resetNotifications,
+        afterLoginUrl,
+    ]);
+    return login;
+};
+export default useLogin;

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

@@ -0,0 +1,31 @@
+/**
+ * Get a callback for calling the authProvider.logout() method,
+ * redirect to the login page, and clear the store.
+ *
+ * @see useAuthProvider
+ *
+ * @returns {Function} logout callback
+ *
+ * @example
+ *
+ * import { useLogout } from 'react-admin';
+ *
+ * const LogoutButton = () => {
+ *     const logout = useLogout();
+ *     const handleClick = () => logout();
+ *     return <button onClick={handleClick}>Logout</button>;
+ * }
+ */
+declare const useLogout: () => Logout;
+/**
+ * Log the current user out by calling the authProvider.logout() method,
+ * and redirect them to the login screen.
+ *
+ * @param {Object} params The parameters to pass to the authProvider
+ * @param {string} redirectTo The path name to redirect the user to (optional, defaults to login)
+ * @param {boolean} redirectToCurrentLocationAfterLogin Whether the button shall record the current location to redirect to it after login. true by default.
+ *
+ * @return {Promise} The authProvider response
+ */
+type Logout = (params?: any, redirectTo?: string | false, redirectToCurrentLocationAfterLogin?: boolean) => Promise<any>;
+export default useLogout;

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

@@ -0,0 +1,117 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import useAuthProvider, { defaultAuthParams } from './useAuthProvider';
+import { useResetStore } from '../store';
+import { useBasename, useLocation, useNavigate } from '../routing';
+import { removeDoubleSlashes } from '../routing/useCreatePath';
+/**
+ * Get a callback for calling the authProvider.logout() method,
+ * redirect to the login page, and clear the store.
+ *
+ * @see useAuthProvider
+ *
+ * @returns {Function} logout callback
+ *
+ * @example
+ *
+ * import { useLogout } from 'react-admin';
+ *
+ * const LogoutButton = () => {
+ *     const logout = useLogout();
+ *     const handleClick = () => logout();
+ *     return <button onClick={handleClick}>Logout</button>;
+ * }
+ */
+const useLogout = () => {
+    const authProvider = useAuthProvider();
+    const queryClient = useQueryClient();
+    const resetStore = useResetStore();
+    const navigate = useNavigate();
+    const location = useLocation();
+    const locationRef = useRef(location);
+    const basename = useBasename();
+    const loginUrl = removeDoubleSlashes(`${basename}/${defaultAuthParams.loginUrl}`);
+    /*
+     * We need the current location to pass in the router state
+     * so that the login hook knows where to redirect to as next route after login.
+     *
+     * But if we used the location from useLocation as a dependency of the logout
+     * function, it would be rebuilt each time the user changes location.
+     * Consequently, that would force a rerender of all components using this hook
+     * upon navigation (CoreAdminRouter for example).
+     *
+     * To avoid that, we store the location in a ref.
+     */
+    useEffect(() => {
+        locationRef.current = location;
+    }, [location]);
+    const logout = useCallback((params = {}, redirectFromCaller, redirectToCurrentLocationAfterLogin = true) => {
+        if (authProvider) {
+            return authProvider.logout(params).then(redirectFromLogout => {
+                if (redirectFromLogout === false ||
+                    redirectFromCaller === false) {
+                    resetStore();
+                    queryClient.clear();
+                    // do not redirect
+                    return;
+                }
+                const finalRedirectTo = redirectFromCaller || redirectFromLogout || loginUrl;
+                if (finalRedirectTo?.startsWith('http')) {
+                    // absolute link (e.g. https://my.oidc.server/login)
+                    resetStore();
+                    queryClient.clear();
+                    window.location.href = finalRedirectTo;
+                    return finalRedirectTo;
+                }
+                // redirectTo is an internal location that may contain a query string, e.g. '/login?foo=bar'
+                // we must split it to pass a structured location to navigate()
+                const redirectToParts = finalRedirectTo.split('?');
+                const newLocation = {
+                    pathname: redirectToParts[0],
+                };
+                let newLocationOptions = {};
+                if (redirectToCurrentLocationAfterLogin &&
+                    locationRef.current &&
+                    locationRef.current.pathname) {
+                    newLocationOptions = {
+                        state: {
+                            nextPathname: locationRef.current.pathname,
+                            nextSearch: locationRef.current.search,
+                        },
+                    };
+                }
+                if (redirectToParts[1]) {
+                    newLocation.search = redirectToParts[1];
+                }
+                // We need to navigate and reset the store after a litte delay to avoid a race condition
+                // between the store reset and the navigation.
+                //
+                // This would only happen when the `authProvider.getPermissions` method returns
+                // a resolved promise with no delay: If the store was reset before the navigation,
+                // the `usePermissions` query would reset, causing the `CoreAdminRoutes` component to
+                // rerender the `LogoutOnMount` component leading to an infinite loop.
+                setTimeout(() => {
+                    navigate(newLocation, newLocationOptions);
+                    resetStore();
+                    queryClient.clear();
+                }, 0);
+                return redirectFromLogout;
+            });
+        }
+        else {
+            navigate({
+                pathname: loginUrl,
+            }, {
+                state: {
+                    nextPathname: locationRef.current &&
+                        locationRef.current.pathname,
+                },
+            });
+            resetStore();
+            queryClient.clear();
+            return Promise.resolve();
+        }
+    }, [authProvider, resetStore, loginUrl, queryClient, navigate]);
+    return logout;
+};
+export default useLogout;

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

@@ -0,0 +1,42 @@
+/**
+ * Returns a callback used to call the authProvider.checkError() method
+ * and an error from the dataProvider. If the authProvider rejects the call,
+ * the hook logs the user out and shows a logged out notification.
+ *
+ * Used in the useDataProvider hook to check for access denied responses
+ * (e.g. 401 or 403 responses) and trigger a logout.
+ *
+ * @see useLogout
+ * @see useDataProvider
+ *
+ * @returns {Function} logoutIfAccessDenied callback
+ *
+ * @example
+ *
+ * import { useLogoutIfAccessDenied, useNotify, DataProviderContext } from 'react-admin';
+ *
+ * const FetchRestrictedResource = () => {
+ *     const dataProvider = useContext(DataProviderContext);
+ *     const logoutIfAccessDenied = useLogoutIfAccessDenied();
+ *     const notify = useNotify()
+ *     useEffect(() => {
+ *         dataProvider.getOne('secret', { id: 123 })
+ *             .catch(error => {
+ *                  logoutIfAccessDenied(error);
+ *                  notify('server error',  { type: 'error' });
+ *              })
+ *     }, []);
+ *     // ...
+ * }
+ */
+declare const useLogoutIfAccessDenied: () => LogoutIfAccessDenied;
+/**
+ * Call the authProvider.authError() method, using the error passed as argument.
+ * If the authProvider rejects the call, logs the user out and shows a logged out notification.
+ *
+ * @param {Error} error An Error object (usually returned by the dataProvider)
+ *
+ * @return {Promise} Resolved to true if there was a logout, false otherwise
+ */
+type LogoutIfAccessDenied = (error?: any) => Promise<boolean>;
+export default useLogoutIfAccessDenied;

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

@@ -0,0 +1,111 @@
+import { useCallback } from 'react';
+import useAuthProvider from './useAuthProvider';
+import useLogout from './useLogout';
+import { useNotify } from '../notification';
+import { useNavigate } from '../routing/useNavigate';
+let timer;
+/**
+ * Returns a callback used to call the authProvider.checkError() method
+ * and an error from the dataProvider. If the authProvider rejects the call,
+ * the hook logs the user out and shows a logged out notification.
+ *
+ * Used in the useDataProvider hook to check for access denied responses
+ * (e.g. 401 or 403 responses) and trigger a logout.
+ *
+ * @see useLogout
+ * @see useDataProvider
+ *
+ * @returns {Function} logoutIfAccessDenied callback
+ *
+ * @example
+ *
+ * import { useLogoutIfAccessDenied, useNotify, DataProviderContext } from 'react-admin';
+ *
+ * const FetchRestrictedResource = () => {
+ *     const dataProvider = useContext(DataProviderContext);
+ *     const logoutIfAccessDenied = useLogoutIfAccessDenied();
+ *     const notify = useNotify()
+ *     useEffect(() => {
+ *         dataProvider.getOne('secret', { id: 123 })
+ *             .catch(error => {
+ *                  logoutIfAccessDenied(error);
+ *                  notify('server error',  { type: 'error' });
+ *              })
+ *     }, []);
+ *     // ...
+ * }
+ */
+const useLogoutIfAccessDenied = () => {
+    const authProvider = useAuthProvider();
+    const logout = useLogout();
+    const notify = useNotify();
+    const navigate = useNavigate();
+    const handleRedirect = useCallback((url) => {
+        if (url.startsWith('http')) {
+            window.location.href = url;
+        }
+        else {
+            navigate(url);
+        }
+    }, [navigate]);
+    const logoutIfAccessDenied = useCallback(async (errorFromCheckAuth) => {
+        if (!authProvider) {
+            return logoutIfAccessDeniedWithoutProvider();
+        }
+        try {
+            await authProvider.checkError(errorFromCheckAuth);
+            return false;
+        }
+        catch (errorFromCheckError) {
+            const logoutUser = errorFromCheckError?.logoutUser ?? true;
+            // manual debounce
+            if (timer) {
+                return true; // side effects already triggered in this tick, exit
+            }
+            timer = setTimeout(() => {
+                timer = undefined;
+            }, 0);
+            const redirectTo = errorFromCheckError &&
+                errorFromCheckError.redirectTo != null
+                ? errorFromCheckError.redirectTo
+                : errorFromCheckAuth && errorFromCheckAuth.redirectTo
+                    ? errorFromCheckAuth.redirectTo
+                    : undefined;
+            const shouldNotify = !((errorFromCheckError &&
+                errorFromCheckError.message === false) ||
+                (errorFromCheckAuth &&
+                    errorFromCheckAuth.message === false) ||
+                redirectTo?.startsWith('http'));
+            if (shouldNotify) {
+                try {
+                    // notify only if not yet logged out
+                    await authProvider.checkAuth({});
+                    if (logoutUser) {
+                        notify(getErrorMessage(errorFromCheckError, "strato.notification.logged_out'), { type: 'error' });
+                    }
+                    else {
+                        notify(getErrorMessage(errorFromCheckError, "strato.notification.not_authorized'), { type: 'error' });
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (logoutUser) {
+                logout({}, redirectTo);
+            }
+            else if (redirectTo) {
+                handleRedirect(redirectTo);
+            }
+            return true;
+        }
+    }, [authProvider, logout, notify, handleRedirect]);
+    return logoutIfAccessDenied;
+};
+const logoutIfAccessDeniedWithoutProvider = async () => false;
+const getErrorMessage = (error, defaultMessage) => typeof error === 'string'
+    ? error
+    : typeof error === 'undefined' || !error.message
+        ? defaultMessage
+        : error.message;
+export default useLogoutIfAccessDenied;