Re-wire the `Revisions` entity to use RTK Query under the hood (#41558)

* Add RTK Query `revision` API

* Re-wire `Revisions` entity `list` to work with RTK Query

* Re-wire the `Revisions` entity `revert` to work with RTK Query

frontend/src/metabase-types/api/revision.ts

@@ -19,3 +19,14 @@ export interface RevisionListQuery {
   model_type: string;
   model_id: number | string;
 }
+
+export interface ListRevisionRequest {
+  entity: "card" | "dashboard";
+  id: number | string;
+}
+
+export interface RevertRevisionRequest {
+  entity: "card" | "dashboard";
+  id: number | string;
+  revision_id: number;
+}

frontend/src/metabase/api/index.ts

@@ -13,6 +13,7 @@ export * from "./field";
 export * from "./login-history";
 export * from "./metric";
 export * from "./permission";
+export * from "./revision";
 export * from "./search";
 export * from "./segment";
 export * from "./session";

frontend/src/metabase/api/revision.ts

+import type {
+  Revision,
+  ListRevisionRequest,
+  RevertRevisionRequest,
+} from "metabase-types/api";
+
+import { Api } from "./api";
+import { listTag, invalidateTags, provideRevisionListTags } from "./tags";
+
+export const revisionApi = Api.injectEndpoints({
+  endpoints: builder => ({
+    listRevision: builder.query<Revision[], ListRevisionRequest>({
+      query: params => ({
+        method: "GET",
+        url: "/api/revision",
+        params,
+      }),
+      providesTags: (revisions = []) => provideRevisionListTags(revisions),
+    }),
+    revertRevision: builder.mutation<Revision, RevertRevisionRequest>({
+      query: body => ({
+        method: "POST",
+        url: "/api/revision/revert",
+        body,
+      }),
+      invalidatesTags: (_, error) =>
+        invalidateTags(error, [listTag("revision")]),
+    }),
+  }),
+});
+
+export const { useListRevisionQuery, useRevertRevisionMutation } = revisionApi;

frontend/src/metabase/api/tags/constants.ts

@@ -14,6 +14,7 @@ export const TAG_TYPES = [
   "indexed-entity",
   "metric",
   "permissions-group",
+  "revision",
   "schema",
   "snippet",
   "segment",

frontend/src/metabase/api/tags/utils.ts

@@ -21,6 +21,7 @@ import type {
   Metric,
   PopularItem,
   RecentItem,
+  Revision,
   SearchModel,
   SearchResult,
   Segment,
@@ -287,6 +288,18 @@ export function providePermissionsGroupTags(
   return [idTag("permissions-group", group.id)];
 }
 
+export function provideRevisionListTags(
+  revisions: Revision[],
+): TagDescription<TagType>[] {
+  return [listTag("revision"), ...revisions.flatMap(provideRevisionTags)];
+}
+
+export function provideRevisionTags(
+  revision: Revision,
+): TagDescription<TagType>[] {
+  return [idTag("revision", revision.id)];
+}
+
 export function provideSearchItemListTags(
   items: SearchResult[],
   models: SearchModel[] = Array.from(SEARCH_MODELS),

frontend/src/metabase/entities/revisions.js

-import { GET, POST } from "metabase/lib/api";
-import { createEntity } from "metabase/lib/entities";
+import { revisionApi } from "metabase/api";
+import { createEntity, entityCompatibleQuery } from "metabase/lib/entities";
 
 import Dashboards from "./dashboards";
 import Questions from "./questions";
 
-const listRevisions = GET("/api/revision");
-
 /**
  * @deprecated use "metabase/api" instead
  */
 const Revision = createEntity({
   name: "revisions",
   api: {
-    list: ({ model_type, model_id }, options) =>
-      // add model_type and model_id to each object since they are required for revert
-      listRevisions({ entity: model_type, id: model_id }).then(revisions =>
-        revisions.map(revision => ({
-          model_type,
-          model_id,
-          ...revision,
-        })),
-      ),
-    revert: POST("/api/revision/revert"),
+    list: ({ model_type, model_id }, dispatch) =>
+      entityCompatibleQuery(
+        { entity: model_type, id: model_id },
+        dispatch,
+        revisionApi.endpoints.listRevision,
+      )
+        // add model_type and model_id to each object since they are required for revert
+        .then(revisions =>
+          revisions.map(revision => ({
+            model_type,
+            model_id,
+            ...revision,
+          })),
+        ),
   },
 
   objectActions: {
     // use thunk since we don't actually want to dispatch an action
-    revert: revision => async (dispatch, getState) => {
-      await Revision.api.revert({
-        entity: revision.model_type,
-        id: revision.model_id,
-        revision_id: revision.id,
-      });
+    revert: revision => async dispatch => {
+      await entityCompatibleQuery(
+        {
+          entity: revision.model_type,
+          id: revision.model_id,
+          revision_id: revision.id,
+        },
+        dispatch,
+        revisionApi.endpoints.revertRevision,
+      );
 
       return dispatch(Revision.actions.invalidateLists());
     },