@strato-admin/faker-ecommerce 0.1.1 → 0.3.0

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

@@ -0,0 +1,56 @@
+import { QueryObserverLoadingErrorResult, QueryObserverLoadingResult, QueryObserverRefetchErrorResult, QueryObserverSuccessResult, UseQueryOptions } from '@tanstack/react-query';
+import { HintedString } from '../types';
+/**
+ * A hook that calls the authProvider.canAccess() method using react-query for a provided resource and action (and optionally a record).
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true }
+ * - success: { canAccess: true | false, isPending: false }
+ * - error: { error: [error from provider], isPending: false }
+ *
+ * Useful to enable or disable features based on users permissions.
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ * @param {string} params.resource The resource to check access for
+ * @param {string} params.action The action 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 boolean indicating the access status
+ *
+ * @example
+ *     import { useCanAccess } from 'react-admin';
+ *
+ *     const PostDetail = () => {
+ *         const { isPending, canAccess, error } = useCanAccess({
+ *             resource: 'posts',
+ *             action: 'read',
+ *         });
+ *         if (isPending || !canAccess) {
+ *             return null;
+ *         }
+ *         if (error) {
+ *             return <div>{error.message}</div>;
+ *         }
+ *         return <PostEdit />;
+ *     };
+ */
+export declare const useCanAccess: <RecordType extends Record<string, any> = Record<string, any>, ErrorType extends Error = Error>(params: UseCanAccessOptions<RecordType, ErrorType>) => UseCanAccessResult<ErrorType>;
+export interface UseCanAccessOptions<RecordType extends Record<string, any> = Record<string, any>, ErrorType extends Error = Error> extends Omit<UseQueryOptions<boolean, ErrorType>, 'queryKey' | 'queryFn'> {
+    resource?: string;
+    action: HintedString<'list' | 'create' | 'edit' | 'show' | 'delete'>;
+    record?: RecordType;
+}
+export type UseCanAccessResult<ErrorType = Error> = UseCanAccessLoadingResult<ErrorType> | UseCanAccessLoadingErrorResult<ErrorType> | UseCanAccessRefetchErrorResult<ErrorType> | UseCanAccessSuccessResult<ErrorType>;
+export interface UseCanAccessLoadingResult<ErrorType = Error> extends QueryObserverLoadingResult<boolean, ErrorType> {
+    canAccess: undefined;
+}
+export interface UseCanAccessLoadingErrorResult<ErrorType = Error> extends QueryObserverLoadingErrorResult<boolean, ErrorType> {
+    canAccess: undefined;
+}
+export interface UseCanAccessRefetchErrorResult<ErrorType = Error> extends QueryObserverRefetchErrorResult<boolean, ErrorType> {
+    canAccess: boolean;
+}
+export interface UseCanAccessSuccessResult<ErrorType = Error> extends QueryObserverSuccessResult<boolean, ErrorType> {
+    canAccess: boolean;
+}

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

@@ -0,0 +1,108 @@
+import { useMemo } from 'react';
+import { useQuery, } from '@tanstack/react-query';
+import useAuthProvider from './useAuthProvider';
+import { useResourceContext } from '../core';
+import { useRecordContext } from '../controller';
+/**
+ * A hook that calls the authProvider.canAccess() method using react-query for a provided resource and action (and optionally a record).
+ *
+ * The return value updates according to the request state:
+ *
+ * - start: { isPending: true }
+ * - success: { canAccess: true | false, isPending: false }
+ * - error: { error: [error from provider], isPending: false }
+ *
+ * Useful to enable or disable features based on users permissions.
+ *
+ * @param {Object} params Any params you want to pass to the authProvider
+ * @param {string} params.resource The resource to check access for
+ * @param {string} params.action The action 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 boolean indicating the access status
+ *
+ * @example
+ *     import { useCanAccess } from 'react-admin';
+ *
+ *     const PostDetail = () => {
+ *         const { isPending, canAccess, error } = useCanAccess({
+ *             resource: 'posts',
+ *             action: 'read',
+ *         });
+ *         if (isPending || !canAccess) {
+ *             return null;
+ *         }
+ *         if (error) {
+ *             return <div>{error.message}</div>;
+ *         }
+ *         return <PostEdit />;
+ *     };
+ */
+export const useCanAccess = (params) => {
+    const authProvider = useAuthProvider();
+    const resource = useResourceContext(params);
+    if (!resource) {
+        throw new Error('useCanAccess must be used inside a <Resource> component or provide a resource prop');
+    }
+    const record = useRecordContext(params);
+    const { record: _record, ...restParams } = params;
+    const authProviderHasCanAccess = !!authProvider?.canAccess;
+    const queryResult = useQuery({
+        queryKey: [
+            'auth',
+            'canAccess',
+            { ...restParams, recordId: record?.id, resource },
+        ],
+        queryFn: async ({ signal }) => {
+            if (!authProvider || !authProvider.canAccess) {
+                return true;
+            }
+            return authProvider.canAccess({
+                ...params,
+                record,
+                resource,
+                signal: authProvider.supportAbortSignal ? signal : undefined,
+            });
+        },
+        enabled: authProviderHasCanAccess,
+        ...params,
+    });
+    const result = useMemo(() => {
+        // Don't check for the authProvider or authProvider.canAccess method in the useMemo
+        // to avoid unnecessary re-renders
+        return {
+            ...queryResult,
+            canAccess: queryResult.data,
+        };
+    }, [queryResult]);
+    return authProviderHasCanAccess
+        ? result
+        : emptyQueryObserverResult;
+};
+const emptyQueryObserverResult = {
+    canAccess: 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(emptyQueryObserverResult),
+};

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

@@ -0,0 +1,39 @@
+import { UseMutateAsyncFunction, UseMutationOptions } from '@tanstack/react-query';
+import { HintedString } from '../types';
+/**
+ * A hook that returns a function you can call to determine whether user has access to the given resource
+ *
+ * @example
+ *     import { Datagrid, List, TextField, useCanAccessCallback } from 'react-admin';
+ *
+ *     const UserList = () => {
+ *         const checkAccess = useCanAccessCallback();
+ *
+ *         const handleRowClick = (id: Identifier, resource: string, record: Record) => {
+ *             try {
+ *                 const canAccess = checkAccess({ resource: 'users', action: 'edit', record });
+ *                 return canAccess ? "edit" : "show";
+ *             } catch (error) {
+ *                 console.error(error);
+ *             }
+ *         };
+ *
+ *         return (
+ *             <List>
+ *                 <Datagrid onClick={handleRowClick}>
+ *                     <TextField source="id" />
+ *                     <TextField source="name" />
+ *                     <TextField source="email" />
+ *                 </Datagrid>
+ *             </List>
+ *         );
+ *     };
+ */
+export declare const useCanAccessCallback: <RecordType extends Record<string, any> = Record<string, any>, ErrorType = Error>(options?: Omit<UseMutationOptions<UseCanAccessCallbackResult, ErrorType, UseCanAccessCallbackOptions<RecordType>>, "mutationFn">) => UseMutateAsyncFunction<boolean, ErrorType, UseCanAccessCallbackOptions<Record<string, any>>, unknown>;
+export type UseCanAccessCallback<RecordType extends Record<string, any> = Record<string, any>, ErrorType = Error> = UseMutateAsyncFunction<UseCanAccessCallbackResult, ErrorType, UseCanAccessCallbackOptions<RecordType>, unknown>;
+export type UseCanAccessCallbackOptions<RecordType extends Record<string, any> = Record<string, any>> = {
+    resource: string;
+    action: HintedString<'list' | 'create' | 'edit' | 'show' | 'delete'>;
+    record?: RecordType;
+};
+export type UseCanAccessCallbackResult = boolean;

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

@@ -0,0 +1,45 @@
+import { useMutation, } from '@tanstack/react-query';
+import useAuthProvider from './useAuthProvider';
+/**
+ * A hook that returns a function you can call to determine whether user has access to the given resource
+ *
+ * @example
+ *     import { Datagrid, List, TextField, useCanAccessCallback } from 'react-admin';
+ *
+ *     const UserList = () => {
+ *         const checkAccess = useCanAccessCallback();
+ *
+ *         const handleRowClick = (id: Identifier, resource: string, record: Record) => {
+ *             try {
+ *                 const canAccess = checkAccess({ resource: 'users', action: 'edit', record });
+ *                 return canAccess ? "edit" : "show";
+ *             } catch (error) {
+ *                 console.error(error);
+ *             }
+ *         };
+ *
+ *         return (
+ *             <List>
+ *                 <Datagrid onClick={handleRowClick}>
+ *                     <TextField source="id" />
+ *                     <TextField source="name" />
+ *                     <TextField source="email" />
+ *                 </Datagrid>
+ *             </List>
+ *         );
+ *     };
+ */
+export const useCanAccessCallback = (options = {}) => {
+    const authProvider = useAuthProvider();
+    const { mutateAsync } = useMutation({
+        mutationFn: async (params) => {
+            if (!authProvider || !authProvider.canAccess) {
+                return true;
+            }
+            return authProvider.canAccess(params);
+        },
+        retry: false,
+        ...options,
+    });
+    return mutateAsync;
+};

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

@@ -0,0 +1,67 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { HintedString } from '../types';
+/**
+ * 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 declare const useCanAccessResources: <RecordType extends Record<string, any> = Record<string, any>, ErrorType extends Error = Error>(params: UseCanAccessResourcesOptions<RecordType>) => UseCanAccessResourcesResult<ErrorType>;
+export interface UseCanAccessResourcesOptions<RecordType extends Record<string, any> = Record<string, any>, ErrorType extends Error = Error> extends Omit<UseQueryOptions<Record<string, boolean>, ErrorType>, 'queryKey' | 'queryFn'> {
+    resources: string[];
+    action: HintedString<'list' | 'create' | 'edit' | 'show' | 'delete'>;
+    record?: RecordType;
+}
+export type UseCanAccessResourcesResult<ErrorType = Error> = UseCanAccessResourcesLoadingResult | UseCanAccessResourcesLoadingErrorResult<ErrorType> | UseCanAccessResourcesRefetchErrorResult<ErrorType> | UseCanAccessResourcesSuccessResult;
+export interface UseCanAccessResourcesLoadingResult {
+    canAccess: undefined;
+    error: null;
+    isPending: true;
+}
+export interface UseCanAccessResourcesLoadingErrorResult<ErrorType = Error> {
+    canAccess: undefined;
+    error: ErrorType;
+    isPending: false;
+}
+export interface UseCanAccessResourcesRefetchErrorResult<ErrorType = Error> {
+    canAccess: Record<string, boolean>;
+    error: ErrorType;
+    isPending: false;
+}
+export interface UseCanAccessResourcesSuccessResult {
+    canAccess: Record<string, boolean>;
+    error: null;
+    isPending: false;
+}

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

@@ -0,0 +1,92 @@
+import { useMemo } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import useAuthProvider from './useAuthProvider';
+import { useRecordContext } from '../controller';
+/**
+ * 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;
+};

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

@@ -0,0 +1,48 @@
+/**
+ * Get a callback for calling the authProvider.checkAuth() method.
+ * In case of rejection, redirects to the login page, displays a notification,
+ * and throws an error.
+ *
+ * This is a low level hook. See those more specialized hooks
+ * for common authentication tasks, based on useCheckAuth.
+ *
+ * @see useAuthenticated
+ * @see useAuthState
+ *
+ * @returns {Function} checkAuth callback
+ *
+ * @example
+ *
+ * import { useCheckAuth } from 'react-admin';
+ *
+ * const MyProtectedPage = () => {
+ *     const checkAuth = useCheckAuth();
+ *     useEffect(() => {
+ *         checkAuth().catch(() => {});
+ *     }, []);
+ *     return <p>Private content: EZAEZEZAET</p>
+ * } // tip: use useAuthenticated() hook instead
+ *
+ * const MyPage = () => {
+ *     const checkAuth = useCheckAuth();
+ *     const [authenticated, setAuthenticated] = useState(true); // optimistic auth
+ *     useEffect(() => {
+ *         checkAuth({}, false)
+ *              .then(() => setAuthenticated(true))
+ *              .catch(() => setAuthenticated(false));
+ *     }, []);
+ *     return authenticated ? <Bar /> : <BarNotAuthenticated />;
+ * } // tip: use useAuthState() hook instead
+ */
+export declare const useCheckAuth: () => CheckAuth;
+/**
+ * Check if the current user is authenticated by calling authProvider.checkAuth().
+ * Logs the user out on failure.
+ *
+ * @param {Object} params The parameters to pass to the authProvider
+ * @param {boolean} logoutOnFailure Whether the user should be logged out if the authProvider fails to authenticate them. True by default.
+ * @param {string} redirectTo The login form url. Defaults to '/login'
+ *
+ * @return {Promise} Resolved to the authProvider response if the user passes the check, or rejected with an error otherwise
+ */
+export type CheckAuth = (params?: any, logoutOnFailure?: boolean, redirectTo?: string) => Promise<any>;

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

@@ -0,0 +1,76 @@
+import { useCallback } from 'react';
+import useAuthProvider, { defaultAuthParams } from './useAuthProvider';
+import useLogout from './useLogout';
+import { useNotify } from '../notification';
+import { useBasename } from '../routing';
+import { removeDoubleSlashes } from '../routing/useCreatePath';
+/**
+ * Get a callback for calling the authProvider.checkAuth() method.
+ * In case of rejection, redirects to the login page, displays a notification,
+ * and throws an error.
+ *
+ * This is a low level hook. See those more specialized hooks
+ * for common authentication tasks, based on useCheckAuth.
+ *
+ * @see useAuthenticated
+ * @see useAuthState
+ *
+ * @returns {Function} checkAuth callback
+ *
+ * @example
+ *
+ * import { useCheckAuth } from 'react-admin';
+ *
+ * const MyProtectedPage = () => {
+ *     const checkAuth = useCheckAuth();
+ *     useEffect(() => {
+ *         checkAuth().catch(() => {});
+ *     }, []);
+ *     return <p>Private content: EZAEZEZAET</p>
+ * } // tip: use useAuthenticated() hook instead
+ *
+ * const MyPage = () => {
+ *     const checkAuth = useCheckAuth();
+ *     const [authenticated, setAuthenticated] = useState(true); // optimistic auth
+ *     useEffect(() => {
+ *         checkAuth({}, false)
+ *              .then(() => setAuthenticated(true))
+ *              .catch(() => setAuthenticated(false));
+ *     }, []);
+ *     return authenticated ? <Bar /> : <BarNotAuthenticated />;
+ * } // tip: use useAuthState() hook instead
+ */
+export const useCheckAuth = () => {
+    const authProvider = useAuthProvider();
+    const notify = useNotify();
+    const logout = useLogout();
+    const basename = useBasename();
+    const loginUrl = removeDoubleSlashes(`${basename}/${defaultAuthParams.loginUrl}`);
+    const checkAuth = useCallback(async (params = {}, logoutOnFailure = true, redirectTo = loginUrl) => {
+        // The authProvider is optional in react-admin
+        if (!authProvider) {
+            return checkAuthWithoutAuthProvider();
+        }
+        try {
+            return await authProvider.checkAuth(params);
+        }
+        catch (error) {
+            if (logoutOnFailure) {
+                logout({}, error && error.redirectTo != null
+                    ? error.redirectTo
+                    : redirectTo);
+                const shouldSkipNotify = error && error.message === false;
+                !shouldSkipNotify &&
+                    notify(getErrorMessage(error, "strato.auth.auth_check_error'), { type: 'error' });
+            }
+            throw error;
+        }
+    }, [authProvider, logout, notify, loginUrl]);
+    return checkAuth;
+};
+const checkAuthWithoutAuthProvider = async () => undefined;
+const getErrorMessage = (error, defaultMessage) => typeof error === 'string'
+    ? error
+    : typeof error === 'undefined' || !error.message
+        ? defaultMessage
+        : error.message;

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

@@ -0,0 +1,41 @@
+import { UseQueryOptions, QueryObserverResult } from '@tanstack/react-query';
+import { UserIdentity } from '../types';
+/**
+ * Return the current user identity by calling authProvider.getIdentity() on mount
+ *
+ * The return value updates according to the call state:
+ *
+ * - mount: { isPending: true }
+ * - success: { identity, refetch: () => {}, isPending: false }
+ * - error: { error: Error, isPending: false }
+ *
+ * The implementation is left to the authProvider.
+ *
+ * @returns The current user identity. Destructure as { isPending, identity, error, refetch }.
+ *
+ * @example
+ * import { useGetIdentity, useGetOne } from 'react-admin';
+ *
+ * const PostDetail = ({ id }) => {
+ *     const { data: post, isPending: postLoading } = useGetOne('posts', { id });
+ *     const { identity, isPending: identityLoading } = useGetIdentity();
+ *     if (postLoading || identityLoading) return <>Loading...</>;
+ *     if (!post.lockedBy || post.lockedBy === identity.id) {
+ *         // post isn't locked, or is locked by me
+ *         return <PostEdit post={post} />
+ *     } else {
+ *         // post is locked by someone else and cannot be edited
+ *         return <PostShow post={post} />
+ *     }
+ * }
+ */
+export declare const useGetIdentity: <ErrorType extends Error = Error>(options?: UseGetIdentityOptions<ErrorType>) => UseGetIdentityResult<ErrorType>;
+export interface UseGetIdentityOptions<ErrorType extends Error = Error> extends Omit<UseQueryOptions<UserIdentity, ErrorType>, 'queryKey' | 'queryFn'> {
+    onSuccess?: (data: UserIdentity) => void;
+    onError?: (err: Error) => void;
+    onSettled?: (data?: UserIdentity, error?: Error | null) => void;
+}
+export type UseGetIdentityResult<ErrorType = Error> = QueryObserverResult<UserIdentity, ErrorType> & {
+    identity: UserIdentity | undefined;
+};
+export default useGetIdentity;

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

@@ -0,0 +1,86 @@
+import { useEffect, useMemo } from 'react';
+import { useQuery, } from '@tanstack/react-query';
+import useAuthProvider from './useAuthProvider';
+import { useEvent } from '../util';
+const defaultIdentity = {
+    id: '',
+};
+const defaultQueryParams = {
+    staleTime: 5 * 60 * 1000,
+};
+/**
+ * Return the current user identity by calling authProvider.getIdentity() on mount
+ *
+ * The return value updates according to the call state:
+ *
+ * - mount: { isPending: true }
+ * - success: { identity, refetch: () => {}, isPending: false }
+ * - error: { error: Error, isPending: false }
+ *
+ * The implementation is left to the authProvider.
+ *
+ * @returns The current user identity. Destructure as { isPending, identity, error, refetch }.
+ *
+ * @example
+ * import { useGetIdentity, useGetOne } from 'react-admin';
+ *
+ * const PostDetail = ({ id }) => {
+ *     const { data: post, isPending: postLoading } = useGetOne('posts', { id });
+ *     const { identity, isPending: identityLoading } = useGetIdentity();
+ *     if (postLoading || identityLoading) return <>Loading...</>;
+ *     if (!post.lockedBy || post.lockedBy === identity.id) {
+ *         // post isn't locked, or is locked by me
+ *         return <PostEdit post={post} />
+ *     } else {
+ *         // post is locked by someone else and cannot be edited
+ *         return <PostShow post={post} />
+ *     }
+ * }
+ */
+export const useGetIdentity = (options = defaultQueryParams) => {
+    const authProvider = useAuthProvider();
+    const { onSuccess, onError, onSettled, ...queryOptions } = options;
+    const result = useQuery({
+        queryKey: ['auth', 'getIdentity'],
+        queryFn: async ({ signal }) => {
+            if (authProvider &&
+                typeof authProvider.getIdentity === 'function') {
+                return authProvider.getIdentity({ signal });
+            }
+            else {
+                return defaultIdentity;
+            }
+        },
+        ...queryOptions,
+    });
+    const onSuccessEvent = useEvent(onSuccess ?? noop);
+    const onErrorEvent = useEvent(onError ?? noop);
+    const onSettledEvent = useEvent(onSettled ?? noop);
+    useEffect(() => {
+        if (result.data === undefined || result.isFetching)
+            return;
+        onSuccessEvent(result.data);
+    }, [onSuccessEvent, result.data, result.isFetching]);
+    useEffect(() => {
+        if (result.error == null || result.isFetching)
+            return;
+        onErrorEvent(result.error);
+    }, [onErrorEvent, result.error, result.isFetching]);
+    useEffect(() => {
+        if (result.status === 'pending' || result.isFetching)
+            return;
+        onSettledEvent(result.data, result.error);
+    }, [
+        onSettledEvent,
+        result.data,
+        result.error,
+        result.status,
+        result.isFetching,
+    ]);
+    return useMemo(() => ({
+        ...result,
+        identity: result.data,
+    }), [result]);
+};
+export default useGetIdentity;
+const noop = () => { };