richie-education 2.24.0 → 2.25.0-b2.dev101

package/js/hooks/useOrders.ts

@@ -1,13 +1,27 @@
 import { defineMessages } from 'react-intl';
-import { API, CourseLight, Order, OrderState, PaginatedResourceQuery, Product } from 'types/Joanie';
+import {
+  API,
+  CertificateOrder,
+  CourseLight,
+  CredentialOrder,
+  Enrollment,
+  OrderState,
+  PaginatedResourceQuery,
+  Product,
+  ProductType,
+} from 'types/Joanie';
 import { useJoanieApi } from 'contexts/JoanieApiContext';
 import { useSessionMutation } from 'utils/react-query/useSessionMutation';
 import { QueryOptions, useResource, useResourcesCustom, UseResourcesProps } from './useResources';
 
 export type OrderResourcesQuery = PaginatedResourceQuery & {
-  course?: CourseLight['code'];
-  product?: Product['id'];
+  course_code?: CourseLight['code'];
+  product_id?: Product['id'];
+  enrollment_id?: Enrollment['id'];
   state?: OrderState[];
+  state_exclude?: OrderState[];
+  product_type?: ProductType[];
+  product_type_exclude?: ProductType[];
 };
 
 const messages = defineMessages({
@@ -23,43 +37,72 @@ const messages = defineMessages({
   },
 });
 
-function omniscientFiltering(data: Order[], filter: OrderResourcesQuery): Order[] {
+function omniscientFiltering(
+  data: (CredentialOrder | CertificateOrder)[],
+  filter: OrderResourcesQuery,
+): (CredentialOrder | CertificateOrder)[] {
   if (!filter) return data;
 
   return data.filter(
     (order) =>
       // If filter.id is defined filter by order.id
       (!filter.id || order.id === filter.id) &&
-      // If filter.course is defined filter by order.course
-      (!filter.course ||
-        (typeof order.course === 'string' && order.course === filter.course) ||
-        (typeof order.course === 'object' && order.course?.code === filter.course)) &&
-      // If filter.product is defined filter by order.product
-      (!filter.product || order.product === filter.product) &&
+      // If filter.course_code is defined filter by order.course.code
+      (!filter.course_code || order.course?.code === filter.course_code) &&
+      // If filter.enrollment_id is defined filter by order.enrollment?.id
+      (!filter.enrollment_id || order.enrollment?.id === filter.enrollment_id) &&
+      // If filter.product_id is defined filter by order.product
+      (!filter.product_id || order.product_id === filter.product_id) &&
       // If filter.state is defined filter by order.state
-      (!filter.state || filter.state.includes(order.state)),
+      (!filter.state || filter.state.includes(order.state)) &&
+      // If filter.state_exclude is defined filter by order.state
+      (!filter.state_exclude || !filter.state_exclude.includes(order.state)),
   );
 }
 
-const props: UseResourcesProps<Order, OrderResourcesQuery, API['user']['orders']> = {
+const useOrdersBase =
+  (
+    props: UseResourcesProps<
+      CredentialOrder | CertificateOrder,
+      OrderResourcesQuery,
+      API['user']['orders']
+    >,
+  ) =>
+  (
+    filters?: OrderResourcesQuery,
+    queryOptions?: QueryOptions<CredentialOrder | CertificateOrder>,
+  ) => {
+    const custom = useResourcesCustom({ ...props, filters, queryOptions });
+    const abortHandler = useSessionMutation({
+      mutationFn: useJoanieApi().user.orders.abort,
+      onSuccess: () => {
+        custom.methods.invalidate();
+      },
+    });
+    const submitHandler = useSessionMutation({ mutationFn: useJoanieApi().user.orders.submit });
+    return {
+      ...custom,
+      methods: {
+        ...custom.methods,
+        abort: abortHandler.mutateAsync,
+        submit: submitHandler.mutateAsync,
+      },
+    };
+  };
+
+const props: UseResourcesProps<
+  CredentialOrder | CertificateOrder,
+  OrderResourcesQuery,
+  API['user']['orders']
+> = {
   queryKey: ['orders'],
   apiInterface: () => useJoanieApi().user.orders,
   messages,
-  omniscient: true,
-  omniscientFiltering,
   session: true,
 };
+const propsOmniscient = { ...props, omniscient: true, omniscientFiltering };
+export const useOmniscientOrders = useOrdersBase(propsOmniscient);
+export const useOmniscientOrder = useResource(propsOmniscient);
 
-export const useOrders = (filters?: OrderResourcesQuery, queryOptions?: QueryOptions<Order>) => {
-  const custom = useResourcesCustom({ ...props, filters, queryOptions });
-  const abortHandler = useSessionMutation(useJoanieApi().user.orders.abort);
-  return {
-    ...custom,
-    methods: {
-      ...custom.methods,
-      abort: abortHandler.mutateAsync,
-    },
-  };
-};
-
+export const useOrders = useOrdersBase(props);
 export const useOrder = useResource(props);

package/js/hooks/useOrganizations/index.ts

@@ -23,7 +23,7 @@ const messages = defineMessages({
  */
 const props: UseResourcesProps<Organization> = {
   queryKey: ['organizations'],
-  apiInterface: () => useJoanieApi().user.organizations,
+  apiInterface: () => useJoanieApi().organizations,
   session: true,
   messages,
 };

package/js/hooks/useProductOrder/index.spec.tsx

@@ -0,0 +1,113 @@
+import { QueryClientProvider } from '@tanstack/react-query';
+import { IntlProvider } from 'react-intl';
+import fetchMock from 'fetch-mock';
+import { PropsWithChildren } from 'react';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { faker } from '@faker-js/faker';
+import { RichieContextFactory as mockRichieContextFactory } from 'utils/test/factories/richie';
+import { CourseLightFactory, CredentialOrderFactory } from 'utils/test/factories/joanie';
+import { SessionProvider } from 'contexts/SessionContext';
+import { Deferred } from 'utils/test/deferred';
+import { createTestQueryClient } from 'utils/test/createTestQueryClient';
+import { ACTIVE_ORDER_STATES } from 'types/Joanie';
+import useProductOrder from '.';
+
+jest.mock('utils/context', () => ({
+  __esModule: true,
+  default: mockRichieContextFactory({
+    authentication: { backend: 'fonzie', endpoint: 'https://demo.endpoint' },
+    joanie_backend: { endpoint: 'https://joanie.endpoint' },
+  }).one(),
+}));
+
+describe('useProductOrder', () => {
+  let nbApiCalls: number;
+
+  beforeEach(() => {
+    fetchMock.get('https://joanie.endpoint/api/v1.0/credit-cards/', []);
+    fetchMock.get('https://joanie.endpoint/api/v1.0/orders/', []);
+    fetchMock.get('https://joanie.endpoint/api/v1.0/addresses/', []);
+    nbApiCalls = 3;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    fetchMock.restore();
+  });
+
+  const Wrapper = ({ children }: PropsWithChildren) => {
+    return (
+      <QueryClientProvider client={createTestQueryClient({ user: true })}>
+        <IntlProvider locale="en">
+          <SessionProvider>{children}</SessionProvider>
+        </IntlProvider>
+      </QueryClientProvider>
+    );
+  };
+
+  it.each(ACTIVE_ORDER_STATES)(
+    'should retrieves the last order when order.state is %s',
+    async (currentState) => {
+      // the most recent order of accepted state will be return
+      const order = CredentialOrderFactory({
+        state: currentState,
+        created_on: new Date().toISOString(),
+        course: CourseLightFactory({ code: '00000' }).one(),
+      }).one();
+      const ordersByState = ACTIVE_ORDER_STATES.filter((state) => state !== currentState).map(
+        (state) =>
+          CredentialOrderFactory({
+            state,
+            created_on: faker.date.past({ years: 1 }).toISOString(),
+            course: CourseLightFactory({ code: '00000' }).one(),
+            product_id: order.product_id,
+          }).one(),
+      );
+      ordersByState.push(order);
+
+      const responseDeferred = new Deferred();
+      fetchMock.get(
+        `https://joanie.endpoint/api/v1.0/orders/?course_code=00000&product_id=${order.product_id}&state=pending&state=validated&state=submitted`,
+        responseDeferred.promise,
+      );
+
+      const { result } = renderHook(
+        () => useProductOrder({ productId: order.product_id, courseCode: '00000' }),
+        {
+          wrapper: Wrapper,
+        },
+      );
+
+      await waitFor(() => {
+        expect(result.current.states.fetching).toBe(true);
+        expect(result.current.item).toBeUndefined();
+      });
+      nbApiCalls += 1; // call orders from useProductOrder
+      const calledUrls = fetchMock.calls().map((call) => call[0]);
+      expect(calledUrls).toHaveLength(nbApiCalls);
+      expect(calledUrls).toContain(
+        `https://joanie.endpoint/api/v1.0/orders/?course_code=00000&product_id=${order.product_id}&state=pending&state=validated&state=submitted`,
+      );
+      expect(result.current.states.creating).toBe(false);
+      expect(result.current.states.deleting).toBeUndefined();
+      expect(result.current.states.updating).toBeUndefined();
+      expect(result.current.states.isPending).toBe(true);
+      expect(result.current.states.error).toBe(undefined);
+
+      await act(async () => {
+        responseDeferred.resolve(ordersByState);
+      });
+
+      await waitFor(() => {
+        expect(result.current.states.fetching).toBe(false);
+        expect(result.current.item).toEqual(order);
+      });
+
+      expect(result.current.states.creating).toBe(false);
+      expect(result.current.states.deleting).toBeUndefined();
+      expect(result.current.states.updating).toBeUndefined();
+      expect(result.current.states.isPending).toBe(false);
+      expect(result.current.states.error).toBe(undefined);
+    },
+  );
+});

package/js/hooks/useProductOrder/index.tsx

@@ -0,0 +1,33 @@
+import { useMemo } from 'react';
+import { useOrders } from 'hooks/useOrders';
+import { ACTIVE_ORDER_STATES } from 'types/Joanie';
+
+interface UseProductOrderProps {
+  courseCode?: string;
+  enrollmentId?: string;
+  productId: string;
+}
+const useProductOrder = ({ courseCode, enrollmentId, productId }: UseProductOrderProps) => {
+  const ordersQuery = useOrders({
+    course_code: courseCode,
+    enrollment_id: enrollmentId,
+    product_id: productId,
+    state: ACTIVE_ORDER_STATES,
+  });
+
+  const order = useMemo(() => {
+    if (ordersQuery.items.length === 0) {
+      return undefined;
+    }
+    return ordersQuery.items.reduce((last, newOrder) =>
+      last.created_on > newOrder.created_on ? last : newOrder,
+    );
+  }, [ordersQuery.items]);
+
+  return {
+    ...ordersQuery,
+    item: order,
+  };
+};
+
+export default useProductOrder;

package/js/hooks/useQueryKeyInvalidateListener.tsx

@@ -0,0 +1,16 @@
+import { useQuery } from '@tanstack/react-query';
+import { useEffect } from 'react';
+import usePrevious from 'hooks/usePrevious';
+
+export const useQueryKeyInvalidateListener = (queryKey: string[], callback: Function) => {
+  const { data: refreshFlag } = useQuery({
+    queryKey: [...queryKey, 'refresh-flag'],
+    queryFn: () => Math.random(),
+  });
+  const previousRefreshFlag = usePrevious(refreshFlag);
+  useEffect(() => {
+    if (previousRefreshFlag) {
+      callback();
+    }
+  }, [refreshFlag]);
+};

package/js/hooks/useResources/index.spec.tsx

@@ -11,6 +11,7 @@ import { createTestQueryClient } from 'utils/test/createTestQueryClient';
 import { Deferred } from 'utils/test/deferred';
 import { SessionProvider, useSession } from 'contexts/SessionContext';
 import { Maybe } from 'types/utils';
+import { HttpStatusCode } from 'utils/errors/HttpError';
 import { ResourcesQuery, useResource, useResources, UseResourcesProps } from './index';
 
 jest.mock('utils/context', () => ({
@@ -105,13 +106,13 @@ describe('useResources (omniscient)', () => {
       wrapper: Wrapper,
     });
 
-    await waitFor(() => expect(result.current.states.isLoading).toBe(true));
+    await waitFor(() => expect(result.current.states.isPending).toBe(true));
     expect(result.current.states.fetching).toBe(true);
     expect(result.current.items).toEqual([]);
 
     responseDeferred.resolve(todos);
 
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     expect(result.current.states.fetching).toBe(false);
     expect(JSON.stringify(result.current.items)).toBe(JSON.stringify(todos));
   });
@@ -130,13 +131,13 @@ describe('useResources (omniscient)', () => {
     });
 
     // Loads without filters the first time.
-    expect(result.current.states.isLoading).toBe(true);
+    expect(result.current.states.isPending).toBe(true);
     expect(result.current.states.fetching).toBe(true);
     expect(result.current.items).toEqual([]);
 
     responseDeferred.resolve(todos);
 
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     expect(result.current.states.fetching).toBe(false);
     expect(JSON.stringify(result.current.items)).toBe(JSON.stringify(todos));
 
@@ -167,7 +168,7 @@ describe('useResources (omniscient)', () => {
     });
 
     // The get method is not deferred so everything is loaded synchronously.
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     expect(result.current.states.fetching).toBe(false);
     expect(JSON.stringify(result.current.items)).toBe(JSON.stringify(todos));
     expect(fetchMock.called('https://example.com/api/todos')).toBe(true);
@@ -175,15 +176,15 @@ describe('useResources (omniscient)', () => {
     // Trigger a mutation.
     result.current.methods.update({ ...todo, name: 'My super new task' });
 
-    // As the mutation is deferred, the state is still loading.
-    await waitFor(() => expect(result.current.states.isLoading).toBe(true));
+    // As the mutation is deferred, the state is still pending.
+    await waitFor(() => expect(result.current.states.isPending).toBe(true));
     expect(result.current.states.updating).toBe(true);
 
     // Update the get mock to return the mutated todos.
     fetchMock.get('https://example.com/api/todos', mutatedTodos, { overwriteRoutes: true });
     responseDeferred.resolve(true);
 
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     expect(result.current.states.updating).toBe(false);
     // The items are updated. Confirming that the mutation was triggered a new get request.
     expect(JSON.stringify(result.current.items)).toBe(JSON.stringify(mutatedTodos));
@@ -199,13 +200,13 @@ describe('useResources (omniscient)', () => {
       wrapper: Wrapper,
     });
 
-    expect(result.current.states.isLoading).toBe(true);
+    expect(result.current.states.isPending).toBe(true);
     expect(result.current.states.fetching).toBe(true);
     expect(result.current.item).toBe(undefined);
 
     responseDeferred.resolve(todos);
 
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     expect(result.current.states.fetching).toBe(false);
     expect(JSON.stringify(result.current.item)).toBe(JSON.stringify(expectedTodo));
   });
@@ -222,7 +223,7 @@ describe('useResources (omniscient)', () => {
       },
     );
 
-    expect(result.current.states.isLoading).toBe(true);
+    expect(result.current.states.isPending).toBe(true);
     expect(result.current.item).toBe(undefined);
     expect(fetchMock.called('https://example.com/api/todos')).toBe(false);
 
@@ -232,7 +233,7 @@ describe('useResources (omniscient)', () => {
       expect(JSON.stringify(result.current.item)).toBe(JSON.stringify(expectedTodo)),
     );
     expect(fetchMock.lastUrl()).toBe('https://example.com/api/todos');
-    expect(result.current.states.isLoading).toBe(false);
+    expect(result.current.states.isPending).toBe(false);
     expect(result.current.states.fetching).toBe(false);
   });
 
@@ -245,7 +246,7 @@ describe('useResources (omniscient)', () => {
       wrapper: Wrapper,
     });
 
-    expect(result.current.states.isLoading).toBe(true);
+    expect(result.current.states.isPending).toBe(true);
     expect(result.current.states.fetching).toBe(true);
     expect(result.current.item).toBe(undefined);
     expect(result.current.states.error).toBe(undefined);
@@ -268,7 +269,7 @@ describe('useResources (omniscient)', () => {
       },
     );
 
-    await waitFor(() => expect(result.current.states.isLoading).toBe(true));
+    await waitFor(() => expect(result.current.states.isPending).toBe(true));
     expect(result.current.item).toBe(undefined);
     expect(fetchMock.called('https://example.com/api/todos')).toBe(false);
 
@@ -276,7 +277,7 @@ describe('useResources (omniscient)', () => {
 
     await waitFor(() => expect(result.current.item).toEqual(expectedTodo));
     expect(fetchMock.lastUrl()).toBe('https://example.com/api/todos');
-    expect(result.current.states.isLoading).toBe(false);
+    expect(result.current.states.isPending).toBe(false);
     expect(result.current.states.fetching).toBe(false);
 
     rerender(undefined);
@@ -306,7 +307,7 @@ describe('useResource (omniscient) with session', () => {
     fetchMock.get('https://joanie.endpoint/api/v1.0/orders/', []);
     fetchMock.get('https://joanie.endpoint/api/v1.0/credit-cards/', []);
     fetchMock.get('https://joanie.endpoint/api/v1.0/addresses/', []);
-    fetchMock.get('https://demo.endpoint/logout', 200);
+    fetchMock.get('https://demo.endpoint/logout', HttpStatusCode.OK);
   });
 
   afterEach(() => {
@@ -336,7 +337,7 @@ describe('useResource (omniscient) with session', () => {
       },
     });
 
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     await waitFor(() => expect(result.current.items.length).toBe(5));
 
     const button = screen.getByRole('button', { name: 'Logout' });
@@ -344,8 +345,8 @@ describe('useResource (omniscient) with session', () => {
       fireEvent.click(button);
     });
 
-    // isLoading true means that the query is disabled, because no user is in session.
-    await waitFor(() => expect(result.current.states.isLoading).toBe(true));
+    // isPending true means that the query is disabled, because no user is in session.
+    await waitFor(() => expect(result.current.states.isPending).toBe(true));
     // Expect data to be cleared.
     await waitFor(() => expect(result.current.items.length).toBe(0));
   });
@@ -385,19 +386,19 @@ describe('useResource (non-omniscient)', () => {
       wrapper: Wrapper,
     });
 
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     expect(fetchMock.called('https://example.com/api/todos')).toBe(true);
     expect(fetchMock.called('https://example.com/api/todos?name=e')).toBe(false);
     expect(fetchMock.called('https://example.com/api/todos?name=ef')).toBe(false);
 
     rerender({ name: 'e' });
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     expect(fetchMock.called('https://example.com/api/todos')).toBe(true);
     expect(fetchMock.called('https://example.com/api/todos?name=e')).toBe(true);
     expect(fetchMock.called('https://example.com/api/todos?name=ef')).toBe(false);
 
     rerender({ name: 'ef' });
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     expect(fetchMock.called('https://example.com/api/todos')).toBe(true);
     expect(fetchMock.called('https://example.com/api/todos?name=e')).toBe(true);
     expect(fetchMock.called('https://example.com/api/todos?name=ef')).toBe(true);
@@ -411,17 +412,17 @@ describe('useResource (non-omniscient)', () => {
       wrapper: Wrapper,
     });
 
-    expect(result.current.states.isLoading).toBe(true);
+    expect(result.current.states.isPending).toBe(true);
     expect(result.current.states.fetching).toBe(true);
     expect(result.current.states.error).toBe(undefined);
     expect(result.current.items).toEqual([]);
 
     responseDeferred.reject({
-      status: 500,
+      status: HttpStatusCode.INTERNAL_SERVER_ERROR,
       body: 'Bad request',
     });
 
-    await waitFor(() => expect(result.current.states.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.states.isPending).toBe(false));
     expect(result.current.states.fetching).toBe(false);
     expect(result.current.states.error).toEqual(
       'An error occurred while fetching resources. Please retry later.',
@@ -442,7 +443,7 @@ describe('useResource (non-omniscient)', () => {
     });
 
     expect(result.current.states.fetching).toBe(true);
-    expect(result.current.states.isLoading).toBe(true);
+    expect(result.current.states.isPending).toBe(true);
     expect(result.current.item).toBeUndefined();
 
     responseDeferred.resolve(todo);
@@ -453,7 +454,7 @@ describe('useResource (non-omniscient)', () => {
     expect(fetchMock.called(`https://example.com/api/todos/${todo.id}?name=${todo.name}`)).toBe(
       true,
     );
-    expect(result.current.states.isLoading).toBe(false);
+    expect(result.current.states.isPending).toBe(false);
     expect(result.current.item).toStrictEqual(todo);
   });
 
@@ -467,7 +468,7 @@ describe('useResource (non-omniscient)', () => {
     });
 
     expect(result.current.states.fetching).toBe(true);
-    expect(result.current.states.isLoading).toBe(true);
+    expect(result.current.states.isPending).toBe(true);
     expect(result.current.items).toEqual([]);
 
     responseDeferred.resolve({
@@ -484,7 +485,7 @@ describe('useResource (non-omniscient)', () => {
     expect(result.current.meta).toStrictEqual({
       pagination: {
         next: 'next',
-        prev: 'prev',
+        previous: 'prev',
         count: todos.length,
       },
     });

package/js/hooks/useResources/index.tsx

@@ -25,24 +25,31 @@ export interface UseResourcesProps<
   TApiResource extends ApiResourceInterface<TData> = ApiResourceInterface<TData>,
 > {
   queryKey: QueryKey;
-  filters?: TResourceQuery;
   apiInterface: () => TApiResource;
   omniscient?: boolean;
   omniscientFiltering?: (data: TData[], filters: TResourceQuery) => TData[];
   session?: boolean;
   localized?: boolean;
   messages?: Record<string, MessageDescriptor>;
-  queryOptions?: QueryOptions<TData>;
   frozenQueryKey?: boolean;
   onMutationSuccess?: (queryClient: QueryClient) => void;
 }
 
+export interface UseResourcesCallbackProps<
+  TData extends Resource,
+  TResourceQuery extends ResourcesQuery = ResourcesQuery,
+  TApiResource extends ApiResourceInterface<TData> = ApiResourceInterface<TData>,
+> extends UseResourcesProps<TData, TResourceQuery, TApiResource> {
+  filters?: TResourceQuery;
+  queryOptions?: Omit<QueryOptions<TData>, 'queryFn' | 'queryKey'>;
+}
+
 export const useResourcesCustom = <
   TData extends Resource,
   TResourceQuery extends ResourcesQuery = ResourcesQuery,
   TApiResource extends ApiResourceInterface<TData> = ApiResourceInterface<TData>,
 >(
-  props: UseResourcesProps<TData, TResourceQuery, TApiResource>,
+  props: UseResourcesCallbackProps<TData, TResourceQuery, TApiResource>,
 ) => {
   if (props.omniscient) {
     return useResourcesOmniscient(props);
@@ -68,7 +75,7 @@ export const useResource =
   ) =>
   (id?: string, filters?: Omit<TResourceQuery, 'id'>, queryOptions?: QueryOptions<TData>) => {
     const resources = useResources<TData>(props);
-    const res = resources({ id, ...filters }, { ...queryOptions, enabled: !!id });
+    const res = resources({ id, ...filters }, { enabled: !!id, ...queryOptions });
     const { items, ...subRes } = res;
     return { ...subRes, item: items[0] };
   };

package/js/hooks/useResources/useResourcesOmniscient.ts

@@ -2,7 +2,7 @@ import { useIntl } from 'react-intl';
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { ApiResourceInterface } from 'types/Joanie';
 import { messages, useResourcesRoot } from './useResourcesRoot';
-import { Resource, ResourcesQuery, UseResourcesProps } from './index';
+import { Resource, ResourcesQuery, UseResourcesCallbackProps } from './index';
 
 /**
  * This hook internally wraps `useResourcesRoot` but will bulk-fetch all the whole set of resources
@@ -20,7 +20,7 @@ export const useResourcesOmniscient = <
 >({
   filters,
   ...props
-}: UseResourcesProps<TData, TResourceQuery, TApiResource>) => {
+}: UseResourcesCallbackProps<TData, TResourceQuery, TApiResource>) => {
   const intl = useIntl();
   const useResources = useResourcesRoot({ ...props, frozenQueryKey: true });
   const [data, setData] = useState<TData[]>([]);