2/2 סדרה: RTK Query

RTK Query - המשך

המשך הסדרה על RTK Query: שליפה ועדכון של נתונים עם createApi, הגדרת cacheTime, ומפתחות מטמון שמבחינים בין פרמטרים שונים.

רציתי ללמוד על RTK Query, תוכל לתת לי קצת רקע?

בטח. RTK Query היא ספריית איסוף נתונים רבת עוצמה, המהווה חלק מהמערכת האקולוגית של Redux Toolkit ‏(RTK). היא נועדה לפשט את תהליך שליפת הנתונים מממשקי API וניהול הנתונים המתקבלים בחנות ה-Redux שלך.

RTK Query מספקת קבוצה של הוקים שבהם אפשר להשתמש כדי להביא נתונים מה-API ולנהל באופן אוטומטי את הנתונים המתקבלים בחנות ה-Redux. היא גם מספקת קבוצה של כלי עזר לאחסון במטמון, תשאול חוזר (polling) ועימוד, מה שמקל על בניית יישומים מורכבים מונעי נתונים.

אחד היתרונות המרכזיים של RTK Query הוא שהיא מספקת דרך סטנדרטית לאחזר נתונים בכל רחבי האפליקציה. זה מקל על שמירה על עקביות בלוגיקת איסוף הנתונים ומפחית את כמות קוד ה-boilerplate שצריך לכתוב.

בקיצור, RTK Query היא כלי רב עוצמה לבניית יישומים מונעי נתונים עם Redux. היא מפשטת את תהליך שליפת הנתונים מממשקי API וניהול הנתונים המתקבלים בחנות ה-Redux, מה שמקל על בניית יישומים מורכבים עם לוגיקה עקבית של שליפת נתונים.

איך מיישמים RTK Query לשליפה, לעדכון ולשמירה בקאש?

תוכל לתת לי דוגמה איך אני מיישם את השימוש ב-RTK Query, כדי לשלוף נתונים, לעדכן נתונים ולשמור בקאש למניעת שליפה לבקשות זהות?

הנה דוגמה כיצד להשתמש ב-RTK Query כדי להביא נתונים, לעדכן אותם ולשמור אותם במטמון כדי למנוע בקשות מיותרות. נניח שיש לך נקודת קצה של API שמחזירה רשימה של משתמשים. אפשר להגדיר שאילתה באמצעות RTK Query כך:

JavaScript
import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';

export const usersApi = createApi({
  reducerPath: 'usersApi',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://example.com/api' }),
  endpoints: (builder) => ({
    getUsers: builder.query({
      query: () => '/users',
    }),
    updateUser: builder.mutation({
      query: ({ id, data }) => ({
        url: `/users/${id}`,
        method: 'PUT',
        body: data,
      }),
    }),
  }),
});

export const { useGetUsersQuery, useUpdateUserMutation } = usersApi;

בדוגמה זו אנו מגדירים API באמצעות createApi ומציינים baseQuery, שאומר ל-RTK Query כיצד לבצע בקשות ל-API שלנו. לאחר מכן אנו מגדירים שתי נקודות קצה: getUsers ו-updateUser.

כדי להביא נתונים, אפשר להשתמש בהוק useGetUsersQuery כך:

JSX
import { useGetUsersQuery } from './usersApi';

function UsersList() {
  const { data, isLoading, error } = useGetUsersQuery();

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (error) {
    return <div>Error: {error.message}</div>;
  }

  return (
    <ul>
      {data.map((user) => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

הוק זה שואב אוטומטית נתונים מנקודת הקצה /users כאשר הרכיב נטען, ומאחסן את התוצאה בחנות ה-Redux.

כדי לעדכן נתונים, אפשר להשתמש בהוק useUpdateUserMutation כך:

JSX
import { useUpdateUserMutation } from './usersApi';

function UserForm({ user }) {
  const [name, setName] = useState(user.name);
  const [email, setEmail] = useState(user.email);
  const [updateUser, { isLoading, error }] = useUpdateUserMutation();

  const handleSubmit = (e) => {
    e.preventDefault();

    updateUser({ id: user.id, data: { name, email } });
  };

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (error) {
    return <div>Error: {error.message}</div>;
  }

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Name:
        <input type="text" value={name} onChange={(e) => setName(e.target.value)} />
      </label>
      <label>
        Email:
        <input type="email" value={email} onChange={(e) => setEmail(e.target.value)} />
      </label>
      <button type="submit">Save</button>
    </form>
  );
}

הוק זה מחזיר פונקציית mutate, שבה נוכל להשתמש כדי לעדכן את השם והמייל של המשתמש. כאשר אנו קוראים לפונקציה זו, RTK Query שולחת בקשת PUT לנקודת הקצה /users/:id עם הנתונים המעודכנים.

כדי לשמור נתונים במטמון ולמנוע בקשות מיותרות, RTK Query מספקת מנגנון מטמון מובנה. כברירת מחדל, היא מאחסנת את כל בקשות ה-GET המוצלחות למשך חמש דקות. אפשר להתאים אישית התנהגות זו על ידי העברת אפשרות cacheTime לשאילתה או למוטציה. לדוגמה, כדי לשמור את התוצאה של השאילתה getUsers למשך שעה אחת, נוכל לשנות את הגדרת ה-API כך:

JavaScript
export const usersApi = createApi({
  reducerPath: 'usersApi',
  baseQuery: fetchBaseQuery

תוכל לתת לי דוגמה איך אני מעביר cacheTime?

בטח. הנה דוגמה כיצד אפשר להעביר את האפשרות cacheTime לשאילתה או למוטציה:

JavaScript
import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';

export const usersApi = createApi({
  reducerPath: 'usersApi',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://example.com/api' }),
  endpoints: (builder) => ({
    getUsers: builder.query({
      query: () => '/users',
      cacheTime: 60 * 60 * 1000, // cache for 1 hour
    }),
    updateUser: builder.mutation({
      query: ({ id, data }) => ({
        url: `/users/${id}`,
        method: 'PUT',
        body: data,
      }),
      // cache for 5 minutes
      invalidates: [{ type: 'User', id: (args) => args.id }],
      options: {
        cacheTime: 5 * 60 * 1000,
      },
    }),
  }),
});

export const { useGetUsersQuery, useUpdateUserMutation } = usersApi;

בדוגמה זו אנו מעבירים את האפשרות cacheTime גם לשאילתה getUsers וגם למוטציה updateUser. עבור השאילתה getUsers הגדרנו את cacheTime ל-60 * 60 * 1000, כלומר התוצאה תישמר במטמון למשך שעה אחת. עבור המוטציה updateUser הגדרנו את cacheTime ל-5 * 60 * 1000, כלומר התוצאה תישמר במטמון למשך חמש דקות. אנו גם מציינים שהמוטציה הזו מבטלת את המטמון עבור כל אובייקט User עם ה-id המקביל.

שימו לב שהאפשרות cacheTime מצוינת באלפיות שנייה. בשני המקרים אנו משתמשים בכפל פשוט כדי להמיר משעות או מדקות לאלפיות שנייה.

אני יכול להגדיר שאם הפרמטרים שונים, הנתונים לא יילקחו מהקאש?

כן, אפשר להגדיר מפתחות מטמון ב-RTK Query כדי למנוע שימוש בנתונים השמורים כאשר פרמטרי השאילתה משתנים. כברירת מחדל, RTK Query משתמשת באובייקט השאילתה כולו כמפתח המטמון. המשמעות היא שאם פרמטרי השאילתה משתנים, RTK Query תביא נתונים טריים במקום להשתמש בנתונים המאוחסנים במטמון.

עם זאת, אפשר להגדיר פונקציית מפתח מטמון משלך, כדי להתאים אישית את מפתח המטמון בהתבסס על פרמטרים ספציפיים של השאילתה. הנה דוגמה:

JavaScript
import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';

export const usersApi = createApi({
  reducerPath: 'usersApi',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://example.com/api' }),
  endpoints: (builder) => ({
    getUsers: builder.query({
      query: (page, pageSize) => ({
        url: '/users',
        params: { page, pageSize },
      }),
      cacheKey: (queryArgs, queryDefinition) => JSON.stringify(queryArgs),
    }),
  }),
});

export const { useGetUsersQuery } = usersApi;

בדוגמה זו אנו מגדירים שאילתת getUsers שלוקחת שני פרמטרים: page ו-pageSize. אנו משתמשים בפרמטרים אלה כדי לבנות את אובייקט השאילתה שיישלח אל ה-API.

כדי להתאים אישית את מפתח המטמון, אנו מגדירים פונקציה cacheKey שלוקחת שני ארגומנטים: queryArgs ו-queryDefinition. ‏queryArgs הוא מערך של הארגומנטים המועברים לפונקציית השאילתה, ו-queryDefinition הוא אובייקט שמכיל מטא-נתונים על השאילתה. במקרה זה אנו משתמשים ב-JSON.stringify כדי להמיר את המערך queryArgs למחרוזת, שבה אנו משתמשים לאחר מכן כמפתח המטמון. המשמעות היא שאם הפרמטרים page או pageSize משתנים, RTK Query תביא נתונים טריים במקום להשתמש בנתונים המאוחסנים במטמון.

שימו לב שאפשר להגדיר כל פונקציית מפתח מטמון, כל עוד היא מחזירה מחרוזת ייחודית עבור כל קבוצה של פרמטרי שאילתה.

מאיפה queryArgs לוקח את הנתונים, ומה queryDefinition מאחסן?

מאיפה queryArgs לוקחת את הנתונים, ומהם הנתונים ש-queryDefinition יאחסן, לדוגמה?

‏queryArgs הוא מערך של הארגומנטים המועברים לפונקציית השאילתה. בדוגמה הקודמת, השאילתה getUsers לוקחת שני פרמטרים: page ו-pageSize. כאשר קוראים ל-useGetUsersQuery, מעבירים את הארגומנטים האלה כך:

JavaScript
const { data, isLoading, error } = useGetUsersQuery(pageNumber, pageSize);

במקרה זה, queryArgs יהיה מערך המכיל את הערכים pageNumber ו-pageSize.

‏queryDefinition הוא אובייקט המכיל מטא-נתונים לגבי השאילתה. להלן כמה מהמאפיינים הזמינים ב-queryDefinition:

  • query: פונקציית השאילתה ששימשה להגדרת השאילתה.
  • endpointName: שם נקודת הקצה שאליה שייכת השאילתה.
  • providesTags: מערך של תגים המשויכים לתוצאת השאילתה. ניתן להשתמש בתגים אלה כדי לבטל את תוקף הנתונים המאוחסנים במטמון כאשר מוטציה משפיעה על אותם נתונים.
  • options: אובייקט המכיל אפשרויות נוספות שהועברו לפונקציית השאילתה, כגון cacheTime או pollingInterval.

הנה דוגמה לאופן שבו אפשר להשתמש ב-queryDefinition כדי להתאים אישית את מפתח המטמון על סמך שם נקודת הקצה:

JavaScript
import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';

export const usersApi = createApi({
  reducerPath: 'usersApi',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://example.com/api' }),
  endpoints: (builder) => ({
    getUsers: builder.query({
      query: (page, pageSize) => ({
        url: '/users',
        params: { page, pageSize },
      }),
      cacheKey: (queryArgs, queryDefinition) => {
        const { endpointName } = queryDefinition;
        return `${endpointName}:${JSON.stringify(queryArgs)}`;
      },
    }),
  }),
});

export const { useGetUsersQuery } = usersApi;

בדוגמה זו אנו משתמשים ב-queryDefinition.endpointName כדי לכלול את שם נקודת הקצה במפתח המטמון. המשמעות היא שאם יש לך שאילתות מרובות עם שמות נקודות קצה שונים המשתמשות באותם פרמטרים, הן יישמרו במטמון בנפרד.

חיפוש ופקודות