Migrate metrics entity to RTK (#40900)

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

@@ -12,3 +12,27 @@ export interface Metric {
   definition: StructuredQuery;
   revision_message?: string;
 }
+
+export interface CreateMetricRequest {
+  name: string;
+  table_id: TableId;
+  definition: StructuredQuery;
+  description?: string;
+}
+
+export interface UpdateMetricRequest {
+  id: MetricId;
+  name?: string;
+  definition?: StructuredQuery;
+  revision_message: string;
+  archived?: boolean;
+  caveats?: string;
+  description?: string;
+  points_of_interest?: string;
+  show_in_getting_started?: boolean;
+}
+
+export interface DeleteMetricRequest {
+  id: MetricId;
+  revision_message: string;
+}

frontend/src/metabase/api/index.ts

@@ -5,6 +5,7 @@ export * from "./database";
 export * from "./dataset";
 export * from "./field";
 export * from "./login-history";
+export * from "./metric";
 export * from "./segment";
 export * from "./session";
 export * from "./table";

frontend/src/metabase/api/metric.ts

+import type {
+  CreateMetricRequest,
+  DeleteMetricRequest,
+  Metric,
+  MetricId,
+  UpdateMetricRequest,
+} from "metabase-types/api";
+
+import { Api } from "./api";
+import { idTag, invalidateTags, listTag, tag } from "./tags";
+
+export const metricApi = Api.injectEndpoints({
+  endpoints: builder => ({
+    listMetrics: builder.query<Metric[], void>({
+      query: () => ({
+        method: "GET",
+        url: "/api/legacy-metric",
+      }),
+      providesTags: (metrics = []) => [
+        listTag("metric"),
+        ...(metrics.map(({ id }) => idTag("metric", id)) ?? []),
+      ],
+    }),
+    getMetric: builder.query<Metric, MetricId>({
+      query: id => ({
+        method: "GET",
+        url: `/api/legacy-metric/${id}`,
+      }),
+      providesTags: metric => (metric ? [idTag("metric", metric.id)] : []),
+    }),
+    createMetric: builder.mutation<Metric, CreateMetricRequest>({
+      query: body => ({
+        method: "POST",
+        url: "/api/legacy-metric",
+        body,
+      }),
+      invalidatesTags: (_, error) =>
+        invalidateTags(error, [listTag("metric"), tag("table")]),
+    }),
+    updateMetric: builder.mutation<Metric, UpdateMetricRequest>({
+      query: ({ id, ...body }) => ({
+        method: "PUT",
+        url: `/api/legacy-metric/${id}`,
+        body,
+      }),
+      invalidatesTags: (_, error, { id }) =>
+        invalidateTags(error, [
+          listTag("metric"),
+          idTag("metric", id),
+          tag("table"),
+        ]),
+    }),
+    deleteMetric: builder.mutation<Metric, DeleteMetricRequest>({
+      query: ({ id, ...body }) => ({
+        method: "DELETE",
+        url: `/api/legacy-metric/${id}`,
+        body,
+      }),
+      invalidatesTags: (_, error, { id }) =>
+        invalidateTags(error, [
+          listTag("metric"),
+          idTag("metric", id),
+          tag("table"),
+        ]),
+    }),
+  }),
+});
+
+export const {
+  useListMetricsQuery,
+  useGetMetricQuery,
+  useCreateMetricMutation,
+  useUpdateMetricMutation,
+  useDeleteMetricMutation,
+} = metricApi;

frontend/src/metabase/api/tags.ts

@@ -4,6 +4,7 @@ export const TAG_TYPES = [
   "database",
   "field",
   "field-values",
+  "metric",
   "schema",
   "segment",
   "table",

frontend/src/metabase/entities/metrics.js

+import { metricApi } from "metabase/api";
 import { color } from "metabase/lib/colors";
-import { createEntity } from "metabase/lib/entities";
+import { createEntity, entityCompatibleQuery } from "metabase/lib/entities";
 import * as Urls from "metabase/lib/urls";
 import { MetricSchema } from "metabase/schema";
 import { getMetadata } from "metabase/selectors/metadata";
@@ -13,6 +14,35 @@ const Metrics = createEntity({
   path: "/api/legacy-metric",
   schema: MetricSchema,
 
+  api: {
+    list: (entityQuery, dispatch) =>
+      entityCompatibleQuery(
+        entityQuery,
+        dispatch,
+        metricApi.endpoints.listMetrics,
+      ),
+    get: (entityQuery, options, dispatch) =>
+      entityCompatibleQuery(
+        entityQuery.id,
+        dispatch,
+        metricApi.endpoints.getMetric,
+      ),
+    create: (entityQuery, dispatch) =>
+      entityCompatibleQuery(
+        entityQuery,
+        dispatch,
+        metricApi.endpoints.createMetric,
+      ),
+    update: (entityQuery, dispatch) =>
+      entityCompatibleQuery(
+        entityQuery,
+        dispatch,
+        metricApi.endpoints.updateMetric,
+      ),
+    delete: ({ id }, dispatch) =>
+      entityCompatibleQuery(id, dispatch, metricApi.endpoints.deleteMetric),
+  },
+
   objectActions: {
     setArchived: (
       { id },