1/2 סדרה: RTK Query

RTK Query

שאלות ותשובות על Redux Toolkit ו-RTK Query: createApi, נקודות קצה, הוקים שנוצרים אוטומטית, מוטציות, פרמטרים ושמירה במטמון.

מה ההבדל בין Redux ל-Redux Toolkit?

Redux Toolkit היא ספרייה המפשטת את תהליך כתיבת קוד Redux. היא מספקת קבוצה של כלי עזר והפשטות שמקלים על כתיבת קוד Redux עם פחות שורות קוד. ההבדל העיקרי בין Redux ל-Redux Toolkit הוא ש-Redux Toolkit מספקת קבוצה של כלים מוגדרים מראש המשמשים בדרך כלל ביישומי Redux, כגון פונקציה configureStore שמגדירה חנות Redux עם ברירות מחדל הגיוניות, פונקציה […] המייצרת פעולות Redux ומפחיתים (reducers) על סמך תחביר פשוט יותר, ופונקציה createSlice שמפשטת את תהליך הטיפול בפעולות אסינכרוניות.

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

ומה זה saga ו-slice? האם יש להם קשר ל-Redux?

כן, גם הסאגה וגם הפרוסה (slice) קשורות ל-Redux. ‏redux-saga היא ספריית תוכנת ביניים (middleware) עבור Redux, המספקת דרך להתמודד עם תופעות לוואי, כגון קריאות API אסינכרוניות או אינטראקציות עם האחסון בדפדפן, בצורה מאורגנת וניתנת לבדיקה. סאגות הן פונקציות מחולל (generator functions) שמקשיבות לפעולות Redux ספציפיות ואז מבצעות תופעות לוואי על סמך פעולות אלו.

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

בסך הכול, גם redux-saga וגם createSlice הם כלים שניתן להשתמש בהם בשילוב עם Redux, כדי לעזור לנהל מצב בצורה מאורגנת ויעילה יותר.

ומה לגבי RTK Query?

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

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

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

תוכל להרחיב עוד קצת על RTK Query ולתת גם דוגמה?

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

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

Shell
npm install @reduxjs/toolkit axios

לאחר מכן תוכל להגדיר נקודת קצה עבור ה-API שלך באמצעות הפונקציה createApi:

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

const api = createApi({
  reducerPath: 'api',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://api.example.com' }),
  endpoints: (builder) => ({
    getUser: builder.query({
      query: (id) => `/users/${id}`,
    }),
  }),
});

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

JSX
import { useGetUserQuery } from './api';

function User({ id }) {
  const { data, isLoading, isError } = useGetUserQuery(id);

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

  if (isError) {
    return <div>Error!</div>;
  }

  return (
    <div>
      <h1>{data.name}</h1>
      <p>{data.bio}</p>
    </div>
  );
}

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

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

איך אני מתקין את RTK Query? ומאיפה מגיע ההוק useGetUserQuery?

איך אני מתקין את RTK Query? לא הבנתי, ה-useGetUserQuery הוק מוגדר ב-createApi, מאיזו נקודה אני לומד על החלק הזה?

כדי להתקין את RTK Query, אפשר להשתמש ב-npm או ב-yarn:

Shell
npm install @reduxjs/toolkit query

או

Shell
yarn add @reduxjs/toolkit query

לגבי השאלה השנייה: useGetUserQuery אינו מוגדר ב-createApi. במקום זאת, הוא נוצר באופן אוטומטי על ידי createApi, בהתבסס על הגדרת ה-endpoints שאתה מספק. בדוגמה הקודמת הגדרנו נקודת קצה בשם getUser בשיטת builder.query:

JavaScript
endpoints: (builder) => ({
  getUser: builder.query({
    query: (id) => `/users/${id}`,
  }),
}),

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

אפשר ללמוד עוד על אופן השימוש ב-RTK Query בתיעוד הרשמי, המספק דוגמאות והסברים מפורטים יותר: https://redux-toolkit.js.org/rtk-query/overview

מה המשמעות של endpoints?

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

נקודות קצה מוגדרות בשיטת endpoints של הפונקציה createApi. השיטה endpoints לוקחת פונקציה המספקת אובייקט builder, שבו אפשר להשתמש כדי להגדיר את נקודות הקצה. הנה דוגמה:

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

const api = createApi({
  reducerPath: 'api',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://api.example.com' }),
  endpoints: (builder) => ({
    getUsers: builder.query({
      query: () => '/users',
    }),
    createUser: builder.mutation({
      query: (user) => ({
        url: '/users',
        method: 'POST',
        body: user,
      }),
    }),
  }),
});

בדוגמה זו הגדרנו שתי נקודות קצה: getUsers ו-createUser. ‏getUsers היא נקודת קצה של שאילתה שמחזירה רשימה של משתמשים, בעוד ש-createUser היא נקודת קצה של מוטציה שיוצרת משתמש חדש.

כל הגדרת נקודת קצה כוללת אובייקט query המתאר את הפרטים של בקשת ה-API. עבור נקודות קצה של שאילתה, האובייקט query צריך לכלול מאפיין url המציין את נקודת הקצה של ה-API שממנה יש להביא נתונים. עבור נקודות קצה של מוטציה, האובייקט query צריך לכלול את המאפיינים url, ‏method ו-body, המציינים בהתאמה את נקודת הקצה של ה-API שאליה יש לשלוח נתונים, את שיטת ה-HTTP ואת הנתונים לשליחה.

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

ואיך RTK Query יכול לעזור בשמירת קאש או בניהול של מספר בקשות זהות במקביל?

RTK Query מספקת מספר תכונות שיכולות לעזור בשמירה במטמון ובניהול של בקשות זהות מרובות:

  1. מטמון אוטומטי: RTK Query מספקת שמירה אוטומטית במטמון של תגובות API, מה שיכול לעזור להפחית את מספר בקשות ה-API שהאפליקציה צריכה לבצע. כברירת מחדל, RTK Query מאחסנת תגובות במטמון למשך פרק זמן שניתן להגדרה, ומבטלת אוטומטית את המטמון כאשר הנתונים מיושנים.
  2. מטמון ידני: RTK Query מספקת גם דרך לאחסון ידני של תגובות API באמצעות האובייקט queryCache. זה יכול להיות שימושי אם אתה צריך שליטה עדינה יותר על התנהגות המטמון של היישום.
  3. שליפה מוקדמת: RTK Query מספקת שיטת prefetch המאפשרת לאחזר נתונים ברקע, לפני שהם באמת נחוצים ליישום. זה יכול לעזור לשפר את הביצועים הנתפסים של האפליקציה על ידי קיצור משך הזמן שלוקח לטעון נתונים.
  4. בקשות מקבילות: RTK Query מספקת דרך לנהל מספר בקשות זהות בו-זמנית באמצעות useBaseQuery. הוק זה מאפשר ליצור מופעים מרובים של האובייקט baseQuery, שניתן להשתמש בהם כדי לבצע בקשות מקבילות לממשקי API שונים.

הנה דוגמה לאופן שבו אפשר להשתמש ב-RTK Query כדי לנהל בקשות מרובות בו-זמנית:

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

const api = createApi({
  reducerPath: 'api',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://api.example.com' }),
  endpoints: (builder) => ({
    getUser: builder.query({
      query: (id) => `/users/${id}`,
    }),
    getProduct: builder.query({
      query: (id) => `/products/${id}`,
    }),
  }),
});

function App() {
  const { data: userData, isFetching: isUserFetching } = useGetUserQuery('1');
  const { data: productData, isFetching: isProductFetching } = useGetProductQuery('2');

  if (isUserFetching || isProductFetching) {
    return <div>Loading...</div>;
  }

  return (
    <div>
      <h1>{userData.name}</h1>
      <p>{productData.description}</p>
    </div>
  );
}

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

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

האם useGetUserQuery ו-useGetProductQuery הם שמות שמורים?

useGetUserQuery ו-useGetProductQuery אלו שמות קבועים? שמות שמורים? או קונבנציה לשמות של query שעושה שימוש ב-RTK Query, שמוסיפים use ו-query לפני ואחרי שם המשתנה באובייקט ה-api?

השמות useGetUserQuery ו-useGetProductQuery אינם שמות קבועים או שמורים ב-RTK Query. הם נוצרים אוטומטית על ידי createApi, בהתבסס על שמות נקודות הקצה שאתה מגדיר באובייקט endpoints.

בדוגמה הקודמת הגדרנו שתי נקודות קצה: getUser ו-getProduct. כאשר אנו משתמשים ב-createApi כדי ליצור את ה-API שלנו, RTK Query מייצרת אוטומטית הוקים עבור כל נקודת קצה, בהתבסס על השם והסוג של נקודת הקצה. לדוגמה, מכיוון ש-getUser היא נקודת קצה של שאילתה, RTK Query מייצרת הוק useGetUserQuery שאנו יכולים להשתמש בו כדי להביא נתונים עבור משתמש ספציפי.

מוסכמת השמות של הוקים אלה מבוססת על השם והסוג של נקודת הקצה. עבור נקודות קצה של שאילתה, המוסכמה היא useGet{EndpointName}Query, כאשר EndpointName הוא שם נקודת הקצה, עם האות הראשונה כאות גדולה. עבור נקודות קצה של מוטציה, המוסכמה היא use{EndpointName}Mutation.

אפשר גם להתאים אישית את שמות ההוקים שנוצרים, על ידי מתן אפשרות name בעת הגדרת נקודות הקצה. לדוגמה:

JavaScript
endpoints: (builder) => ({
  getUser: builder.query({
    query: (id) => `/users/${id}`,
    name: 'fetchUser', // customize the name of the generated hook
  }),
}),

בדוגמה זו סיפקנו אפשרות name לנקודת הקצה getUser, שתיצור הוק useFetchUserQuery במקום הוק ברירת המחדל useGetUserQuery.

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

מה זה Mutation?

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

מוטציות מוגדרות בשיטת mutation של הפונקציה createApi. השיטה mutation לוקחת פונקציה המספקת אובייקט builder, שבו אפשר להשתמש כדי להגדיר את נקודת הקצה של המוטציה. הנה דוגמה:

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

const api = createApi({
  reducerPath: 'api',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://api.example.com' }),
  endpoints: (builder) => ({
    createUser: builder.mutation({
      query: (user) => ({
        url: '/users',
        method: 'POST',
        body: user,
      }),
    }),
  }),
});

בדוגמה זו הגדרנו נקודת קצה של מוטציה, createUser, ששולחת בקשת POST אל /users עם האובייקט user בגוף הבקשה.

כדי להשתמש בנקודת קצה של מוטציה, אפשר להשתמש בהוק use{EndpointName}Mutation ש-RTK Query יוצרת עבור נקודת הקצה. לדוגמה, כדי ליצור משתמש חדש, אפשר להשתמש בהוק useCreateUserMutation כך:

JSX
function CreateUserForm() {
  const [name, setName] = useState('');
  const [email, setEmail] = useState('');

  const [createUser, { isLoading, error, data }] = useCreateUserMutation();

  const handleSubmit = (e) => {
    e.preventDefault();
    createUser({ name, email });
  };

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" value={name} onChange={(e) => setName(e.target.value)} />
      <input type="email" value={email} onChange={(e) => setEmail(e.target.value)} />
      <button type="submit" disabled={isLoading}>
        {isLoading ? 'Creating user...' : 'Create user'}
      </button>
      {error && <div>{error.message}</div>}
      {data && <div>User created: {data.name} ({data.email})</div>}
    </form>
  );
}

בדוגמה זו אנו משתמשים בהוק useCreateUserMutation כדי ליצור משתמש חדש כאשר הטופס נשלח. ההוק מחזיר פונקציה createUser שאנו יכולים לקרוא לה עם נתוני המשתמש, וכן קבוצה של משתנים – isLoading, ‏error ו-data – שבהם נוכל להשתמש כדי להציג את מצב הבקשה.

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

אפשר באותה קריאת createApi לשלב גם מוטציה וגם query?

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

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

const api = createApi({
  reducerPath: 'api',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://api.example.com' }),
  endpoints: (builder) => ({
    getUsers: builder.query({
      query: () => '/users',
    }),
    createUser: builder.mutation({
      query: (user) => ({
        url: '/users',
        method: 'POST',
        body: user,
      }),
    }),
  }),
});

בדוגמה זו הגדרנו שתי נקודות קצה: getUsers ו-createUser. ‏getUsers היא נקודת קצה של שאילתה שמביאה רשימה של משתמשים, בעוד ש-createUser היא נקודת קצה של מוטציה שיוצרת משתמש חדש.

כדי להשתמש בנקודות קצה אלה ביישום, אפשר להשתמש בהוקים use{EndpointName}Query ו-use{EndpointName}Mutation ש-RTK Query מייצרת עבור כל נקודת קצה. לדוגמה:

JSX
function UserList() {
  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>
  );
}

function CreateUserForm() {
  const [name, setName] = useState('');
  const [email, setEmail] = useState('');

  const [createUser, { isLoading, error, data }] = useCreateUserMutation();

  const handleSubmit = (e) => {
    e.preventDefault();
    createUser({ name, email });
  };

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" value={name} onChange={(e) => setName(e.target.value)} />
      <input type="email" value={email} onChange={(e) => setEmail(e.target.value)} />
      <button type="submit" disabled={isLoading}>
        {isLoading ? 'Creating user...' : 'Create user'}
      </button>
      {error && <div>{error.message}</div>}
      {data && <div>User created: {data.name} ({data.email})</div>}
    </form>
  );
}

בדוגמה זו אנו משתמשים בהוק useGetUsersQuery כדי להביא רשימה של משתמשים, ובהוק useCreateUserMutation כדי ליצור משתמש חדש. אפשר להשתמש בהוקים אלה ברכיבים שונים של האפליקציה כדי להביא ולשנות נתונים מה-API.

איפה ואיך אני מגדיר אילו פרמטרים כל קריאה תקבל? ואיך אני מעביר את הפרמטרים?

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

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

const api = createApi({
  reducerPath: 'api',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://api.example.com' }),
  endpoints: (builder) => ({
    getUserById: builder.query({
      query: (id) => `/users/${id}`,
    }),
    updateUserById: builder.mutation({
      query: ({ id, name, email }) => ({
        url: `/users/${id}`,
        method: 'PATCH',
        body: { name, email },
      }),
    }),
  }),
});

בדוגמה זו הגדרנו שתי נקודות קצה: getUserById ו-updateUserById. ‏getUserById היא נקודת קצה של שאילתה שמקבלת פרמטר בודד, id, המשמש לבניית כתובת ה-URL עבור בקשת ה-API. ‏updateUserById היא נקודת קצה של מוטציה שמקבלת אובייקט בעל שלושה פרמטרים – id, ‏name ו-email – המשמשים לבניית כתובת האתר וגוף הבקשה.

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

JSX
function UserProfile({ userId }) {
  const { data, isLoading, error } = useGetUserByIdQuery(userId);

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

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

  return (
    <div>
      <h1>{data.name}</h1>
      <p>{data.email}</p>
    </div>
  );
}

בדוגמה זו אנו מעבירים את userId להוק useGetUserByIdQuery כדי להביא את המשתמש עם המזהה המתאים. המשתנה data המוחזר על ידי ההוק יכיל את אובייקט המשתמש לאחר השלמת הבקשה.

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

JSX
function EditUserProfile({ userId }) {
  const [name, setName] = useState('');
  const [email, setEmail] = useState('');

  const [updateUserById, { isLoading, error, data }] = useUpdateUserByIdMutation();

  const handleSubmit = (e) => {
    e.preventDefault();
    updateUserById({ id: userId, name, email });
  };

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" value={name} onChange={(e) => setName(e.target.value)} />
      <input type="email" value={email} onChange={(e) => setEmail(e.target.value)} />
      <button type="submit" disabled={isLoading}>
        {isLoading ? 'Updating user...' : 'Update user'}
      </button>
      {error && <div>{error.message}</div>}
      {data && <div>User updated: {data.name} ({data.email})</div>}
    </form>
  );
}

בדוגמה זו אנו מעבירים אובייקט עם המאפיינים id, ‏name ו-email אל useUpdateUserByIdMutation, כדי לעדכן את המשתמש עם המזהה המתאים. המשתנה data המוחזר על ידי ההוק יכיל את אובייקט המשתמש המעודכן לאחר השלמת הבקשה.

איך אני יכול לשמור את מידע הפוסט שהתכתבנו בצורה קלה?

ב-RTK Query אפשר לשמור את הנתונים המוחזרים על ידי נקודת קצה של מוטציה באמצעות פונקציית ה-callback ‏onSuccess, המסופקת על ידי שיטת mutation של האובייקט builder. פונקציה זו נקראת כאשר בקשת המוטציה מצליחה, והיא מקבלת את נתוני התגובה כארגומנט. להלן דוגמה כיצד לשמור את הנתונים המוחזרים על ידי נקודת קצה של מוטציה:

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

const api = createApi({
  reducerPath: 'api',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://api.example.com' }),
  endpoints: (builder) => ({
    createPost: builder.mutation({
      query: (post) => ({
        url: '/posts',
        method: 'POST',
        body: post,
      }),
      onSuccess: (data, { dispatch }) => {
        dispatch(postsSlice.actions.addPost(data));
      },
    }),
  }),
});

const postsSlice = createSlice({
  name: 'posts',
  initialState: [],
  reducers: {
    addPost: (state, action) => {
      state.push(action.payload);
    },
  },
});

export const { addPost } = postsSlice.actions;

export default postsSlice.reducer;

בדוגמה זו הגדרנו נקודת קצה של מוטציה, createPost, שיוצרת פוסט חדש בשרת. הגדרנו גם פונקציית callback ‏onSuccess ששולחת פעולה להוספת הפוסט החדש לחנות ה-Redux שלנו.

כדי להשתמש בנקודת קצה זו ביישום, אפשר להשתמש בהוק useCreatePostMutation ש-RTK Query יוצרת עבור נקודת הקצה createPost. לדוגמה:

JSX
function CreatePostForm() {
  const [title, setTitle] = useState('');
  const [content, setContent] = useState('');

  const [createPost, { isLoading, error, data }] = useCreatePostMutation();

  const handleSubmit = (e) => {
    e.preventDefault();
    createPost({ title, content });
  };

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" value={title} onChange={(e) => setTitle(e.target.value)} />
      <textarea value={content} onChange={(e) => setContent(e.target.value)} />
      <button type="submit" disabled={isLoading}>
        {isLoading ? 'Creating post...' : 'Create post'}
      </button>
      {error && <div>{error.message}</div>}
      {data && <div>Post created: {data.title}</div>}
    </form>
  );
}

בדוגמה זו אנו משתמשים בהוק useCreatePostMutation כדי ליצור פוסט חדש. אנו מעבירים אובייקט עם המאפיינים title ו-content לפונקציה createPost, שתבצע את בקשת ה-API. לאחר השלמת הבקשה, המשתנה data המוחזר על ידי ההוק יכיל את אובייקט הפוסט החדש, ופונקציית ה-callback ‏onSuccess תשלח פעולה להוספת הפוסט החדש לחנות ה-Redux שלנו.

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

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