Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Paginate caching dashboard (#68242)

Nathan Voxland24b7d886aa8e
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index 00bc4bfbf86..a82886e7fe0 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -276,6 +276,7 @@
events
models
premium-features
+ request
settings
util}}
diff --git a/e2e/test/scenarios/data-studio/data-studio-metrics.cy.spec.ts b/e2e/test/scenarios/data-studio/data-studio-metrics.cy.spec.ts
index f34075a8658..255bd8744c6 100644
--- a/e2e/test/scenarios/data-studio/data-studio-metrics.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/data-studio-metrics.cy.spec.ts
@@ -363,6 +363,10 @@ describe("scenarios > data studio > library > metrics", () => {
cy.findByRole("button", { name: "Save" }).click();
cy.findByRole("button", { name: /Saved/ }).should("exist");
+ // wait for the save button to disappear - that means the form is no longer dirty
+ // and navigating away won't show the confirmation modal that was causing flakes
+ cy.findByRole("button", { name: /Saved/ }).should("not.exist");
+
cy.log("Navigate away and come back to verify the change is persisted");
H.DataStudio.Metrics.overviewTab().click();
H.DataStudio.Metrics.cachingTab().click();
diff --git a/enterprise/frontend/src/metabase-enterprise/caching/components/SidebarCacheForm.tsx b/enterprise/frontend/src/metabase-enterprise/caching/components/SidebarCacheForm.tsx
index b50acc6eded..b4ac9acedc9 100644
--- a/enterprise/frontend/src/metabase-enterprise/caching/components/SidebarCacheForm.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/caching/components/SidebarCacheForm.tsx
@@ -26,19 +26,18 @@ export const SidebarCacheForm = ({
}: SidebarCacheFormProps) => {
const configurableModels = useMemo(() => [model], [model]);
const id: number = getItemId(model, item);
- const { configs, setConfigs, loading, error } = useCacheConfigs({
- configurableModels,
+ const { configs, isLoading, error } = useCacheConfigs({
+ model: configurableModels,
id,
});
- const { savedStrategy, filteredConfigs } = useMemo(() => {
- const targetConfig = _.findWhere(configs, { model_id: id });
+ const { savedStrategy } = useMemo(() => {
+ const targetConfig = _.findWhere(configs ?? [], { model_id: id });
const savedStrategy = targetConfig?.strategy;
- const filteredConfigs = _.compact([targetConfig]);
- return { savedStrategy, filteredConfigs };
+ return { savedStrategy };
}, [configs, id]);
- const saveStrategy = useSaveStrategy(id, filteredConfigs, setConfigs, model);
+ const saveStrategy = useSaveStrategy(id, model);
const saveAndBack = useCallback(
async (values: CacheStrategy) => {
await saveStrategy(values);
@@ -76,7 +75,7 @@ export const SidebarCacheForm = ({
aria-labelledby={headingId}
{...stackProps}
>
- <DelayedLoadingAndErrorWrapper loading={loading} error={error}>
+ <DelayedLoadingAndErrorWrapper loading={isLoading} error={error}>
<StrategyForm
targetId={id}
targetModel={model}
diff --git a/enterprise/frontend/src/metabase-enterprise/caching/components/SidebarCacheSection.tsx b/enterprise/frontend/src/metabase-enterprise/caching/components/SidebarCacheSection.tsx
index 9706729f65c..c19966cf426 100644
--- a/enterprise/frontend/src/metabase-enterprise/caching/components/SidebarCacheSection.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/caching/components/SidebarCacheSection.tsx
@@ -20,14 +20,14 @@ export const SidebarCacheSection = ({
const id = useMemo(() => getItemId(model, item), [model, item]);
const configurableModels = useMemo(() => [model], [model]);
- const { configs, loading, error } = useCacheConfigs({
- configurableModels,
+ const { configs, isLoading, error } = useCacheConfigs({
+ model: configurableModels,
id,
});
const targetConfig = useMemo(() => {
const id = getItemId(model, item);
- return _.findWhere(configs, { model, model_id: id });
+ return _.findWhere(configs ?? [], { model, model_id: id });
}, [configs, model, item]);
const savedStrategy = targetConfig?.strategy;
@@ -36,7 +36,7 @@ export const SidebarCacheSection = ({
const labelId = "question-caching-policy-label";
return (
- <DelayedLoadingAndErrorWrapper delay={0} loading={loading} error={error}>
+ <DelayedLoadingAndErrorWrapper delay={0} loading={isLoading} error={error}>
<Flex align="center" justify="space-between">
<span id={labelId}>{t`When to get new results`}</span>
<FormLauncher
diff --git a/enterprise/frontend/src/metabase-enterprise/caching/components/StrategyEditorForQuestionsAndDashboards/StrategyEditorForQuestionsAndDashboards.tsx b/enterprise/frontend/src/metabase-enterprise/caching/components/StrategyEditorForQuestionsAndDashboards/StrategyEditorForQuestionsAndDashboards.tsx
index aeaddc841ca..9b3625cfcb6 100644
--- a/enterprise/frontend/src/metabase-enterprise/caching/components/StrategyEditorForQuestionsAndDashboards/StrategyEditorForQuestionsAndDashboards.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/caching/components/StrategyEditorForQuestionsAndDashboards/StrategyEditorForQuestionsAndDashboards.tsx
@@ -7,29 +7,23 @@ import { StrategyForm } from "metabase/admin/performance/components/StrategyForm
import { useCacheConfigs } from "metabase/admin/performance/hooks/useCacheConfigs";
import { useConfirmIfFormIsDirty } from "metabase/admin/performance/hooks/useConfirmIfFormIsDirty";
import { useSaveStrategy } from "metabase/admin/performance/hooks/useSaveStrategy";
-import { skipToken, useSearchQuery } from "metabase/api";
import { DelayedLoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper/DelayedLoadingAndErrorWrapper";
import { Sidesheet } from "metabase/common/components/Sidesheet";
-import { ClientSortableTable } from "metabase/common/components/Table/ClientSortableTable";
+import { Table } from "metabase/common/components/Table";
import type { ColumnItem } from "metabase/common/components/Table/types";
+import { usePagination } from "metabase/common/hooks/use-pagination";
import { Center, Flex, Repeat, Skeleton, Stack } from "metabase/ui";
-import type { CacheableModel } from "metabase-types/api";
+import type { CacheSortColumn, CacheableModel } from "metabase-types/api";
import { CacheDurationUnit } from "metabase-types/api";
import { SortDirection } from "metabase-types/api/sorting";
-import type {
- CacheableItem,
- DashboardResult,
- QuestionResult,
- UpdateTarget,
-} from "../types";
+import type { CacheableItem, UpdateTarget } from "../types";
import Styles from "./StrategyEditorForQuestionsAndDashboards.module.css";
import { TableRowForCacheableItem } from "./TableRowForCacheableItem";
import { getConstants } from "./constants";
-import { formatValueForSorting } from "./utils";
-type CacheableItemResult = DashboardResult | QuestionResult;
+const PAGE_SIZE = 25;
export const StrategyEditorForQuestionsAndDashboards = () => {
const [
@@ -42,89 +36,46 @@ export const StrategyEditorForQuestionsAndDashboards = () => {
const [targetModel, setTargetModel] = useState<CacheableModel | null>(null);
- const configurableModels: CacheableModel[] = useMemo(
- () => ["dashboard", "question"],
- [],
- );
-
- const {
- configs,
- setConfigs,
- error: configsError,
- loading: configsAreLoading,
- } = useCacheConfigs({ configurableModels });
+ const { page, setPage, resetPage } = usePagination();
- const dashboardIds = useMemo(
- () =>
- configs
- .filter((config) => config.model === "dashboard")
- .map((c) => c.model_id),
- [configs],
+ const [sortColumn, setSortColumn] = useState<CacheSortColumn>("name");
+ const [sortDirection, setSortDirection] = useState<SortDirection>(
+ SortDirection.Asc,
);
- const questionIds = useMemo(
- () =>
- configs
- .filter((config) => config.model === "question")
- .map((c) => c.model_id),
- [configs],
- );
-
- const dashboardsResult = useSearchQuery(
- dashboardIds.length
- ? {
- models: ["dashboard"],
- ids: dashboardIds,
- //FIXME: Add `ancestors: true` once jds/ancestors-for-all-the-things is merged
- }
- : skipToken,
- );
- const questionsResult = useSearchQuery(
- questionIds.length
- ? {
- models: ["card"],
- ids: questionIds,
- include_dashboard_questions: true,
- //FIXME: Add `ancestors: true` once jds/ancestors-for-all-the-things is merged
- }
- : skipToken,
- );
-
- const dashboardsAndQuestions = useMemo(
- () =>
- (dashboardsResult.data?.data || []).concat(
- questionsResult.data?.data || [],
- ) as CacheableItemResult[],
- [dashboardsResult.data, questionsResult.data],
+ const { configs, total, error, isLoading } = useCacheConfigs({
+ model: ["dashboard", "question"],
+ limit: PAGE_SIZE,
+ offset: page * PAGE_SIZE,
+ sort_column: sortColumn,
+ sort_direction: sortDirection === SortDirection.Asc ? "asc" : "desc",
+ });
+
+ // Handle sort column click
+ const handleSort = useCallback(
+ (columnName: string, direction: SortDirection) => {
+ setSortColumn(columnName as CacheSortColumn);
+ setSortDirection(direction);
+ resetPage();
+ },
+ [resetPage],
);
- const cacheableItems = useMemo(() => {
- const items = new Map<string, CacheableItem>();
- for (const config of configs) {
- items.set(`${config.model}${config.model_id}`, {
- ..._.omit(config, "model_id"),
- id: config.model_id,
- });
+ const cacheableItems: CacheableItem[] = useMemo(() => {
+ if (configs === undefined) {
+ return [];
}
-
- // Hydrate data from the search results into the cacheable items
- for (const result of dashboardsAndQuestions ?? []) {
- const normalizedModel =
- result.model === "card" ? "question" : result.model;
- const item = items.get(`${normalizedModel}${result.id}`);
- if (item) {
- item.name = result.name;
- item.collection = result.collection;
- item.iconModel = result.model;
- }
- }
- // Filter out items that have no match in the dashboard and question list
- const hydratedCacheableItems: CacheableItem[] = [...items.values()].filter(
- (item) => item.name !== undefined,
- );
-
- return hydratedCacheableItems;
- }, [configs, dashboardsAndQuestions]);
+ return configs
+ .filter((config) => config.name !== undefined)
+ .map((config) => ({
+ id: config.model_id,
+ model: config.model,
+ strategy: config.strategy,
+ name: config.name,
+ collection: config.collection ?? undefined,
+ iconModel: config.model === "question" ? "card" : "dashboard",
+ }));
+ }, [configs]);
useEffect(
/** When the user configures an item to 'Use default' and that item
@@ -142,13 +93,24 @@ export const StrategyEditorForQuestionsAndDashboards = () => {
);
/** The config for the object currently being edited */
- const targetConfig = targetModel
- ? _.findWhere(configs, {
- model_id: targetId ?? undefined,
- model: targetModel,
- })
- : undefined;
- const savedStrategy = targetConfig?.strategy;
+ const targetConfig =
+ configs && targetModel
+ ? _.findWhere(configs, {
+ model_id: targetId ?? undefined,
+ model: targetModel,
+ })
+ : undefined;
+
+ const savedStrategy = useMemo(() => {
+ const strategy = targetConfig?.strategy;
+ if (!strategy) {
+ return undefined;
+ }
+ if (strategy.type === "duration") {
+ return { ...strategy, unit: CacheDurationUnit.Hours };
+ }
+ return { ...strategy };
+ }, [targetConfig?.strategy]);
const targetName = useMemo(() => {
if (targetId === null || targetModel === null) {
@@ -161,10 +123,6 @@ export const StrategyEditorForQuestionsAndDashboards = () => {
return item?.name;
}, [targetId, targetModel, cacheableItems]);
- if (savedStrategy?.type === "duration") {
- savedStrategy.unit = CacheDurationUnit.Hours;
- }
-
const {
askBeforeDiscardingChanges,
confirmationModal,
@@ -194,21 +152,9 @@ export const StrategyEditorForQuestionsAndDashboards = () => {
],
);
- const saveStrategy = useSaveStrategy(
- targetId,
- configs,
- setConfigs,
- targetModel,
- );
-
- const cacheableItemsAreLoading = configs.length > 0 && !cacheableItems.length;
+ const saveStrategy = useSaveStrategy(targetId, targetModel);
- const error = configsError || dashboardsResult.error || questionsResult.error;
- const loading =
- configsAreLoading ||
- dashboardsResult.isLoading ||
- questionsResult.isLoading ||
- cacheableItemsAreLoading;
+ const hasPagination = (total ?? 0) > PAGE_SIZE;
const rowRenderer = useCallback(
(item: CacheableItem) => (
@@ -246,30 +192,39 @@ export const StrategyEditorForQuestionsAndDashboards = () => {
<Flex>
<DelayedLoadingAndErrorWrapper
error={error}
- loading={loading}
+ loading={isLoading}
loader={<TableSkeleton columns={tableColumns} />}
>
- <Flex align="flex-start">
- <ClientSortableTable<CacheableItem>
- className={Styles.CacheableItemTable}
- columns={tableColumns}
- data-testid="cache-config-table"
- rows={cacheableItems}
- rowRenderer={rowRenderer}
- defaultSortColumn="name"
- defaultSortDirection={SortDirection.Asc}
- formatValueForSorting={formatValueForSorting}
- emptyBody={<NoResultsTableRow />}
- aria-labelledby={explanatoryAsideId}
- cols={
- <>
- <col />
- <col />
- <col />
- </>
- }
- />
- </Flex>
+ <Table<CacheableItem>
+ className={Styles.CacheableItemTable}
+ columns={tableColumns}
+ data-testid="cache-config-table"
+ rows={cacheableItems}
+ rowRenderer={rowRenderer}
+ emptyBody={<NoResultsTableRow />}
+ aria-labelledby={explanatoryAsideId}
+ sortColumnName={sortColumn}
+ sortDirection={sortDirection}
+ onSort={handleSort}
+ cols={
+ <>
+ <col />
+ <col />
+ <col />
+ </>
+ }
+ paginationProps={
+ hasPagination
+ ? {
+ page,
+ pageSize: PAGE_SIZE,
+ total,
+ showTotal: true,
+ onPageChange: setPage,
+ }
+ : undefined
+ }
+ />
</DelayedLoadingAndErrorWrapper>
</Flex>
</Stack>
@@ -298,7 +253,7 @@ export const StrategyEditorForQuestionsAndDashboards = () => {
};
const TableSkeleton = ({ columns }: { columns: ColumnItem[] }) => (
- <ClientSortableTable<{ id: number }>
+ <Table<{ id: number }>
columns={columns}
rows={[{ id: 0 }, { id: 1 }, { id: 2 }]}
rowRenderer={() => (
diff --git a/enterprise/frontend/src/metabase-enterprise/caching/components/StrategyFormLauncherPanel.tsx b/enterprise/frontend/src/metabase-enterprise/caching/components/StrategyFormLauncherPanel.tsx
index 046f127e150..9170a72ed07 100644
--- a/enterprise/frontend/src/metabase-enterprise/caching/components/StrategyFormLauncherPanel.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/caching/components/StrategyFormLauncherPanel.tsx
@@ -1,4 +1,4 @@
-import { type Dispatch, type SetStateAction, useMemo } from "react";
+import { useMemo } from "react";
import { t } from "ttag";
import { Panel } from "metabase/admin/performance/components/StrategyEditorForDatabases.styled";
@@ -19,7 +19,6 @@ import {
export const StrategyFormLauncherPanel = ({
configs,
- setConfigs,
targetId,
updateTargetId,
databases,
@@ -27,7 +26,6 @@ export const StrategyFormLauncherPanel = ({
shouldShowResetButton,
}: {
configs: CacheConfig[];
- setConfigs: Dispatch<SetStateAction<CacheConfig[]>>;
targetId: number | null;
updateTargetId: UpdateTargetId;
databases: Database[];
@@ -40,8 +38,6 @@ export const StrategyFormLauncherPanel = ({
handleSubmit: resetAllToDefault,
versionNumber: resetFormVersionNumber,
} = useResetToDefaultForm({
- configs,
- setConfigs,
databaseIds,
isFormVisible: targetId !== null,
});
diff --git a/enterprise/frontend/src/metabase-enterprise/caching/components/types.tsx b/enterprise/frontend/src/metabase-enterprise/caching/components/types.tsx
index 6778c5c3ccb..b9ea2a2acc4 100644
--- a/enterprise/frontend/src/metabase-enterprise/caching/components/types.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/caching/components/types.tsx
@@ -4,7 +4,6 @@ import type {
CacheableModel,
CollectionEssentials,
SearchModel,
- SearchResult,
} from "metabase-types/api";
/** Something with a configurable cache strategy */
@@ -17,9 +16,6 @@ export type CacheableItem = Omit<CacheConfig, "model_id"> & {
iconModel?: SearchModel;
};
-export type DashboardResult = SearchResult<number, "dashboard">;
-export type QuestionResult = SearchResult<number, "card">;
-
export type UpdateTarget = (
newValues: { id: number | null; model: CacheableModel | null },
isFormDirty: boolean,
diff --git a/enterprise/frontend/src/metabase-enterprise/caching/hooks/useResetToDefaultForm.tsx b/enterprise/frontend/src/metabase-enterprise/caching/hooks/useResetToDefaultForm.tsx
index b5c80e5ed57..a8daf28677d 100644
--- a/enterprise/frontend/src/metabase-enterprise/caching/hooks/useResetToDefaultForm.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/caching/hooks/useResetToDefaultForm.tsx
@@ -1,21 +1,16 @@
-import type { Dispatch, SetStateAction } from "react";
import { useCallback, useEffect, useState } from "react";
-import { CacheConfigApi } from "metabase/services";
-import type { CacheConfig } from "metabase-types/api";
+import { useDeleteCacheConfigsMutation } from "metabase/api";
export const useResetToDefaultForm = ({
- configs,
- setConfigs,
databaseIds,
isFormVisible,
}: {
- configs: CacheConfig[];
- setConfigs: Dispatch<SetStateAction<CacheConfig[]>>;
databaseIds: number[];
isFormVisible: boolean;
}) => {
const [versionNumber, setVersionNumber] = useState(0);
+ const [deleteCacheConfigs] = useDeleteCacheConfigsMutation();
useEffect(() => {
// Avoid stale context in the form
@@ -25,23 +20,14 @@ export const useResetToDefaultForm = ({
}, [isFormVisible]);
const handleSubmit = useCallback(async () => {
- const originalConfigs = [...configs];
if (databaseIds.length === 0) {
return;
}
- try {
- await CacheConfigApi.delete(
- { model_id: databaseIds, model: "database" },
- { hasBody: true },
- );
- setConfigs((configs: CacheConfig[]) =>
- configs.filter(({ model }) => model !== "database"),
- );
- } catch (e) {
- setConfigs(originalConfigs);
- throw e;
- }
- }, [configs, setConfigs, databaseIds]);
+ await deleteCacheConfigs({
+ model: "database",
+ model_id: databaseIds,
+ }).unwrap();
+ }, [databaseIds, deleteCacheConfigs]);
return { handleSubmit, versionNumber };
};
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/metrics/pages/MetricCachingPage/MetricCachingPage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/metrics/pages/MetricCachingPage/MetricCachingPage.tsx
index 6af21fc0e8b..c94dc298c0f 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/metrics/pages/MetricCachingPage/MetricCachingPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/metrics/pages/MetricCachingPage/MetricCachingPage.tsx
@@ -19,7 +19,7 @@ import type { CacheableModel } from "metabase-types/api";
import { MetricHeader } from "../../components/MetricHeader";
-const configurableModels: CacheableModel[] = ["question"];
+const model: CacheableModel[] = ["question"];
export function MetricCachingPage({ params }: MetricSettingsPageProps) {
const cardId = Urls.extractEntityId(params.cardId);
@@ -32,27 +32,20 @@ export function MetricCachingPage({ params }: MetricSettingsPageProps) {
const {
configs,
- setConfigs,
- loading: isLoadingConfigs,
+ isLoading: isLoadingConfigs,
error: configsError,
} = useCacheConfigs({
- configurableModels,
+ model,
id: cardId,
});
- const { savedStrategy, filteredConfigs } = useMemo(() => {
- const targetConfig = _.findWhere(configs, { model_id: cardId });
+ const { savedStrategy } = useMemo(() => {
+ const targetConfig = _.findWhere(configs ?? [], { model_id: cardId });
const savedStrategy = targetConfig?.strategy;
- const filteredConfigs = _.compact([targetConfig]);
- return { savedStrategy, filteredConfigs };
+ return { savedStrategy };
}, [configs, cardId]);
- const saveStrategy = useSaveStrategy(
- cardId ?? null,
- filteredConfigs,
- setConfigs,
- "question",
- );
+ const saveStrategy = useSaveStrategy(cardId ?? null, "question");
const { confirmationModal, setIsStrategyFormDirty } =
useConfirmIfFormIsDirty();
diff --git a/frontend/src/metabase-types/api/performance.ts b/frontend/src/metabase-types/api/performance.ts
index 46beae0e679..531fb4ce7db 100644
--- a/frontend/src/metabase-types/api/performance.ts
+++ b/frontend/src/metabase-types/api/performance.ts
@@ -1,3 +1,5 @@
+import type { CollectionType } from "./collection";
+
/** 'Model' as in 'type of object' */
export type CacheableModel = "root" | "database" | "dashboard" | "question";
@@ -64,6 +66,33 @@ export interface CacheConfig {
strategy: CacheStrategy;
}
-export type CacheConfigAPIResponse = {
- data: CacheConfig[];
-};
+export type CacheSortColumn = "name" | "collection" | "policy";
+export type SortDirection = "asc" | "desc";
+
+export interface ListCacheConfigsRequest {
+ model?: CacheableModel[];
+ collection?: number;
+ id?: number;
+ limit?: number;
+ offset?: number;
+ sort_column?: CacheSortColumn;
+ sort_direction?: SortDirection;
+}
+
+/** Cache config with hydrated name and collection data */
+export interface CacheConfigWithDetails extends CacheConfig {
+ name?: string;
+ collection?: {
+ id: number;
+ name: string;
+ authority_level?: "official" | null;
+ type?: CollectionType;
+ } | null;
+}
+
+export interface ListCacheConfigsResponse {
+ data: CacheConfigWithDetails[];
+ total: number;
+ limit: number | null;
+ offset: number | null;
+}
diff --git a/frontend/src/metabase/admin/performance/components/StrategyEditorForDatabases.tsx b/frontend/src/metabase/admin/performance/components/StrategyEditorForDatabases.tsx
index 1335953629b..fb434603ebe 100644
--- a/frontend/src/metabase/admin/performance/components/StrategyEditorForDatabases.tsx
+++ b/frontend/src/metabase/admin/performance/components/StrategyEditorForDatabases.tsx
@@ -29,7 +29,7 @@ export const StrategyEditorForDatabases: React.FC = () => {
setTargetId,
] = useState<number | null>(null);
- const configurableModels: CacheableModel[] = useMemo(() => {
+ const model: CacheableModel[] = useMemo(() => {
const ret: CacheableModel[] = ["root"];
if (canOverrideRootStrategy) {
ret.push("database");
@@ -39,12 +39,11 @@ export const StrategyEditorForDatabases: React.FC = () => {
const {
configs,
- setConfigs,
rootStrategyOverriddenOnce,
rootStrategyRecentlyOverridden,
error: configsError,
- loading: areConfigsLoading,
- } = useCacheConfigs({ configurableModels });
+ isLoading: areConfigsLoading,
+ } = useCacheConfigs({ model });
const databasesResult = useListDatabasesQuery();
const databases = databasesResult.data?.data ?? [];
@@ -53,14 +52,20 @@ export const StrategyEditorForDatabases: React.FC = () => {
rootStrategyOverriddenOnce || rootStrategyRecentlyOverridden;
/** The config for the model currently being edited */
- const targetConfig = findWhere(configs, {
+ const targetConfig = findWhere(configs ?? [], {
model_id: targetId ?? undefined,
});
- const savedStrategy = targetConfig?.strategy;
- if (savedStrategy?.type === "duration") {
- savedStrategy.unit = CacheDurationUnit.Hours;
- }
+ const savedStrategy = useMemo(() => {
+ const strategy = targetConfig?.strategy;
+ if (!strategy) {
+ return undefined;
+ }
+ if (strategy.type === "duration") {
+ return { ...strategy, unit: CacheDurationUnit.Hours };
+ }
+ return { ...strategy };
+ }, [targetConfig?.strategy]);
const {
askBeforeDiscardingChanges,
@@ -96,18 +101,13 @@ export const StrategyEditorForDatabases: React.FC = () => {
const inheritingRootStrategy = ["inherit", undefined].includes(
savedStrategy?.type,
);
- const rootConfig = findWhere(configs, { model_id: rootId });
+ const rootConfig = findWhere(configs ?? [], { model_id: rootId });
const inheritingDoNotCache =
inheritingRootStrategy && !rootConfig?.strategy;
return !inheritingDoNotCache;
}, [configs, savedStrategy?.type, targetId]);
- const saveStrategy = useSaveStrategy(
- targetId,
- configs,
- setConfigs,
- "database",
- );
+ const saveStrategy = useSaveStrategy(targetId, "database");
const error = configsError || databasesResult.error;
const loading = areConfigsLoading || databasesResult.isLoading;
@@ -132,8 +132,7 @@ export const StrategyEditorForDatabases: React.FC = () => {
<RoundedBox twoColumns={canOverrideRootStrategy}>
{canOverrideRootStrategy && (
<PLUGIN_CACHING.StrategyFormLauncherPanel
- configs={configs}
- setConfigs={setConfigs}
+ configs={configs ?? []}
targetId={targetId}
updateTargetId={updateTargetId}
databases={databases}
diff --git a/frontend/src/metabase/admin/performance/hooks/useCacheConfigs.tsx b/frontend/src/metabase/admin/performance/hooks/useCacheConfigs.tsx
index c127b1bf753..03317c26bb4 100644
--- a/frontend/src/metabase/admin/performance/hooks/useCacheConfigs.tsx
+++ b/frontend/src/metabase/admin/performance/hooks/useCacheConfigs.tsx
@@ -1,73 +1,36 @@
-import { useEffect, useState } from "react";
-import { useAsync } from "react-use";
-import _ from "underscore";
-
-import { CacheConfigApi } from "metabase/services";
-import type {
- CacheConfig,
- CacheConfigAPIResponse,
- CacheableModel,
-} from "metabase-types/api";
+import { useListCacheConfigsQuery } from "metabase/api";
+import type { ListCacheConfigsRequest } from "metabase-types/api";
import { rootId } from "../constants/simple";
import { translateConfigFromAPI } from "../utils";
import { useRecentlyTrue } from "./useRecentlyTrue";
-export const useCacheConfigs = ({
- configurableModels,
- id,
-}: {
- configurableModels: CacheableModel[];
- id?: number;
-}) => {
- const configsApiResult = useAsync(async () => {
- const configsForEachModel = await Promise.all(
- configurableModels.map((model) =>
- CacheConfigApi.list({ model, id }).then(
- (response: CacheConfigAPIResponse) => response.data,
- ),
- ),
- );
- const configs = _.flatten(configsForEachModel);
- const translatedConfigs = configs.map(translateConfigFromAPI);
- return translatedConfigs;
- }, [configurableModels, id]);
-
- const configsFromAPI = configsApiResult.value;
+export const useCacheConfigs = (
+ listCacheConfigsRequest: ListCacheConfigsRequest,
+) => {
+ const {
+ data: listCacheConfigsResponse,
+ error,
+ isLoading,
+ } = useListCacheConfigsQuery(listCacheConfigsRequest);
- const [configs, setConfigs] = useState<CacheConfig[]>([]);
+ const configs = listCacheConfigsResponse?.data.map(translateConfigFromAPI);
- const rootStrategyOverriddenOnce = configs.some(
- (config) => config.model_id !== rootId,
- );
+ const rootStrategyOverriddenOnce =
+ configs !== undefined &&
+ configs.some((config) => config.model_id !== rootId);
const [rootStrategyRecentlyOverridden] = useRecentlyTrue(
rootStrategyOverriddenOnce,
3000,
);
- const error = configsApiResult.error;
-
- // The configs are not considered fully loaded until the cache configuration data
- // has been loaded from the API _and_ has been copied into local state
- const [areConfigsInitialized, setAreConfigsInitialized] =
- useState<boolean>(false);
- const loading = configsApiResult.loading || !areConfigsInitialized;
-
- useEffect(() => {
- if (configsFromAPI) {
- setConfigs(configsFromAPI);
- setAreConfigsInitialized(true);
- }
- }, [configsFromAPI]);
-
return {
error,
- loading,
+ isLoading,
configs,
- setConfigs,
- configsFromAPI,
+ total: listCacheConfigsResponse?.total,
rootStrategyOverriddenOnce,
rootStrategyRecentlyOverridden,
};
diff --git a/frontend/src/metabase/admin/performance/hooks/useInvalidateTarget.tsx b/frontend/src/metabase/admin/performance/hooks/useInvalidateTarget.tsx
index 4f383d6852b..2114899054b 100644
--- a/frontend/src/metabase/admin/performance/hooks/useInvalidateTarget.tsx
+++ b/frontend/src/metabase/admin/performance/hooks/useInvalidateTarget.tsx
@@ -1,8 +1,8 @@
import { useCallback } from "react";
+import { useInvalidateCacheConfigsMutation } from "metabase/api";
import { useDispatch } from "metabase/lib/redux";
import { addUndo } from "metabase/redux/undo";
-import { CacheConfigApi } from "metabase/services";
import type { CacheableModel } from "metabase-types/api";
import { isErrorWithMessage, resolveSmoothly } from "../utils";
@@ -13,15 +13,16 @@ export const useInvalidateTarget = (
{ smooth = true, shouldThrowErrors = true } = {},
) => {
const dispatch = useDispatch();
+ const [invalidateCacheConfigs] = useInvalidateCacheConfigsMutation();
const invalidateTarget = useCallback(async () => {
if (targetId === null) {
return;
}
try {
- const invalidate = CacheConfigApi.invalidate(
- { include: "overrides", [targetModel]: targetId },
- { hasBody: false },
- );
+ const invalidate = invalidateCacheConfigs({
+ include: "overrides",
+ [targetModel]: targetId,
+ }).unwrap();
if (smooth) {
await resolveSmoothly([invalidate]);
} else {
@@ -42,6 +43,13 @@ export const useInvalidateTarget = (
throw e;
}
}
- }, [dispatch, targetId, targetModel, smooth, shouldThrowErrors]);
+ }, [
+ dispatch,
+ targetId,
+ targetModel,
+ smooth,
+ shouldThrowErrors,
+ invalidateCacheConfigs,
+ ]);
return invalidateTarget;
};
diff --git a/frontend/src/metabase/admin/performance/hooks/useSaveStrategy.tsx b/frontend/src/metabase/admin/performance/hooks/useSaveStrategy.tsx
index 6ac68806355..e0c39dc7960 100644
--- a/frontend/src/metabase/admin/performance/hooks/useSaveStrategy.tsx
+++ b/frontend/src/metabase/admin/performance/hooks/useSaveStrategy.tsx
@@ -1,9 +1,11 @@
-import type { Dispatch, SetStateAction } from "react";
import { useCallback } from "react";
import _ from "underscore";
+import {
+ useDeleteCacheConfigsMutation,
+ useUpdateCacheConfigMutation,
+} from "metabase/api";
import { PLUGIN_CACHING } from "metabase/plugins";
-import { CacheConfigApi } from "metabase/services";
import type {
CacheConfig,
CacheStrategy,
@@ -20,10 +22,11 @@ import {
export const useSaveStrategy = (
targetId: number | null,
- configs: CacheConfig[],
- setConfigs: Dispatch<SetStateAction<CacheConfig[]>>,
model: CacheableModel | null,
) => {
+ const [updateCacheConfig] = useUpdateCacheConfigMutation();
+ const [deleteCacheConfigs] = useDeleteCacheConfigsMutation();
+
const saveStrategy = useCallback(
async (values: CacheStrategy) => {
if (targetId === null || model === null) {
@@ -36,17 +39,12 @@ export const useSaveStrategy = (
model: isRoot ? "root" : model,
model_id: targetId,
};
-
- const otherConfigs = configs.filter(
- (config) => config.model_id !== targetId,
- );
const shouldDeleteStrategy =
values.type === "inherit" ||
// To set "don't cache" as the root strategy, we delete the root strategy
(isRoot && values.type === "nocache");
if (shouldDeleteStrategy) {
- await CacheConfigApi.delete(baseConfig, { hasBody: true });
- setConfigs(otherConfigs);
+ await deleteCacheConfigs(baseConfig).unwrap();
} else {
// If you change strategies, Formik will keep the old values
// for fields that are not in the new strategy,
@@ -64,16 +62,14 @@ export const useSaveStrategy = (
};
const translatedConfig = translateConfigToAPI(newConfig);
- await CacheConfigApi.update(translatedConfig);
+ await updateCacheConfig(translatedConfig).unwrap();
if (newConfig.strategy.type === "ttl") {
newConfig.strategy = populateMinDurationSeconds(newConfig.strategy);
}
-
- setConfigs([...otherConfigs, newConfig]);
}
},
- [configs, setConfigs, targetId, model],
+ [targetId, model, updateCacheConfig, deleteCacheConfigs],
);
return saveStrategy;
};
diff --git a/frontend/src/metabase/admin/performance/utils.tsx b/frontend/src/metabase/admin/performance/utils.tsx
index 6616eaa7060..b0a43ed0a8c 100644
--- a/frontend/src/metabase/admin/performance/utils.tsx
+++ b/frontend/src/metabase/admin/performance/utils.tsx
@@ -300,11 +300,11 @@ export const getFieldsForStrategyType = (strategyType: CacheStrategyType) => {
return fields;
};
-export const translateConfig = (
- config: CacheConfig,
+export const translateConfig = <T extends CacheConfig>(
+ config: T,
direction: "fromAPI" | "toAPI",
-): CacheConfig => {
- const translated: CacheConfig = { ...config };
+): T => {
+ const translated = { ...config, strategy: { ...config.strategy } } as T;
// If strategy type is unsupported, use a fallback
if (!isValidStrategyName(translated.strategy.type)) {
@@ -332,11 +332,11 @@ export const populateMinDurationSeconds = (strategy: AdaptiveStrategy) => ({
});
/** Translate a config from the API into a format the frontend can use */
-export const translateConfigFromAPI = (config: CacheConfig): CacheConfig =>
+export const translateConfigFromAPI = <T extends CacheConfig>(config: T): T =>
translateConfig(config, "fromAPI");
/** Translate a config from the frontend's format into the API's preferred format */
-export const translateConfigToAPI = (config: CacheConfig): CacheConfig =>
+export const translateConfigToAPI = <T extends CacheConfig>(config: T): T =>
translateConfig(config, "toAPI");
export const getPerformanceTabName = (tabId: PerformanceTabId) =>
diff --git a/frontend/src/metabase/api/cache-config.ts b/frontend/src/metabase/api/cache-config.ts
new file mode 100644
index 00000000000..e9fdbef4977
--- /dev/null
+++ b/frontend/src/metabase/api/cache-config.ts
@@ -0,0 +1,71 @@
+import type {
+ CacheConfig,
+ CacheableModel,
+ ListCacheConfigsRequest,
+ ListCacheConfigsResponse,
+} from "metabase-types/api";
+
+import { Api } from "./api";
+
+export const cacheConfigApi = Api.injectEndpoints({
+ endpoints: (builder) => ({
+ listCacheConfigs: builder.query<
+ ListCacheConfigsResponse,
+ ListCacheConfigsRequest | void
+ >({
+ query: (params) => ({
+ method: "GET",
+ url: "/api/cache",
+ params,
+ }),
+ providesTags: ["cache-config"],
+ }),
+ updateCacheConfig: builder.mutation<CacheConfig, CacheConfig>({
+ query: (config) => ({
+ method: "PUT",
+ url: "/api/cache",
+ body: config,
+ }),
+ invalidatesTags: ["cache-config"],
+ }),
+ deleteCacheConfigs: builder.mutation<
+ void,
+ { model: CacheableModel; model_id: number | number[] }
+ >({
+ query: (body) => ({
+ method: "DELETE",
+ url: "/api/cache",
+ body,
+ }),
+ extraOptions: {
+ hasBody: true,
+ },
+ invalidatesTags: ["cache-config"],
+ }),
+ invalidateCacheConfigs: builder.mutation<
+ void,
+ {
+ include?: "overrides";
+ database?: number | number[];
+ dashboard?: number | number[];
+ question?: number | number[];
+ }
+ >({
+ query: (params) => ({
+ method: "POST",
+ url: "/api/cache/invalidate",
+ params,
+ }),
+ extraOptions: {
+ hasBody: false,
+ },
+ }),
+ }),
+});
+
+export const {
+ useListCacheConfigsQuery,
+ useUpdateCacheConfigMutation,
+ useDeleteCacheConfigsMutation,
+ useInvalidateCacheConfigsMutation,
+} = cacheConfigApi;
diff --git a/frontend/src/metabase/api/index.ts b/frontend/src/metabase/api/index.ts
index 41fb0ac3e91..0bd9a75a0db 100644
--- a/frontend/src/metabase/api/index.ts
+++ b/frontend/src/metabase/api/index.ts
@@ -5,6 +5,7 @@ export * from "./api-key";
export * from "./automagic-dashboards";
export * from "./bookmark";
export * from "./bug-report";
+export * from "./cache-config";
export * from "./card";
export * from "./channel";
export * from "./cloud-migration";
diff --git a/frontend/src/metabase/api/query.ts b/frontend/src/metabase/api/query.ts
index 09aafe86a19..f04c9f79372 100644
--- a/frontend/src/metabase/api/query.ts
+++ b/frontend/src/metabase/api/query.ts
@@ -14,7 +14,7 @@ const isAllowedHTTPMethod = (method: any): method is AllowedHTTPMethods => {
};
// custom fetcher that wraps our Api client
-export const apiQuery: BaseQueryFn = async (args, ctx) => {
+export const apiQuery: BaseQueryFn = async (args, ctx, extraOptions) => {
const method = typeof args === "string" ? "GET" : (args?.method ?? "GET");
const url = typeof args === "string" ? args : args.url;
const { bodyParamName, noEvent, formData, fetch } = args;
@@ -34,6 +34,7 @@ export const apiQuery: BaseQueryFn = async (args, ctx) => {
noEvent,
formData,
fetch,
+ ...extraOptions,
},
);
return { data: response };
diff --git a/frontend/src/metabase/api/tags/constants.ts b/frontend/src/metabase/api/tags/constants.ts
index 2cb60623905..50a1738e682 100644
--- a/frontend/src/metabase/api/tags/constants.ts
+++ b/frontend/src/metabase/api/tags/constants.ts
@@ -5,6 +5,7 @@ export const TAG_TYPES = [
"alert",
"api-key",
"bookmark",
+ "cache-config",
"card",
"channel",
"cloud-migration",
diff --git a/frontend/src/metabase/common/components/Table/Table.tsx b/frontend/src/metabase/common/components/Table/Table.tsx
index a9389c0a3cd..c9839e4add7 100644
--- a/frontend/src/metabase/common/components/Table/Table.tsx
+++ b/frontend/src/metabase/common/components/Table/Table.tsx
@@ -5,7 +5,7 @@ import {
PaginationControls,
type PaginationControlsProps,
} from "metabase/common/components/PaginationControls";
-import { Box, Flex, type FlexProps, Icon } from "metabase/ui";
+import { Box, Flex, type FlexProps, Icon, Stack } from "metabase/ui";
import { SortDirection } from "metabase-types/api/sorting";
import CS from "./Table.module.css";
@@ -22,7 +22,7 @@ export type TableProps<Row extends BaseRow> = {
onSort?: (columnName: string, direction: SortDirection) => void;
paginationProps?: Pick<
PaginationControlsProps,
- "page" | "pageSize" | "total"
+ "page" | "pageSize" | "total" | "showTotal"
> & { onPageChange: (page: number) => void };
emptyBody?: React.ReactNode;
cols?: React.ReactNode;
@@ -57,7 +57,7 @@ export function Table<Row extends BaseRow>({
...rest
}: TableProps<Row>) {
return (
- <>
+ <Stack gap="sm">
<table className={cx(CS.Table, className)} {...rest}>
{cols && <colgroup>{cols}</colgroup>}
<thead>
@@ -104,6 +104,7 @@ export function Table<Row extends BaseRow>({
page={paginationProps.page}
pageSize={paginationProps.pageSize}
total={paginationProps.total}
+ showTotal={paginationProps.showTotal}
itemsLength={rows.length}
onNextPage={() =>
paginationProps.onPageChange(paginationProps.page + 1)
@@ -114,7 +115,7 @@ export function Table<Row extends BaseRow>({
/>
</Flex>
)}
- </>
+ </Stack>
);
}
diff --git a/frontend/src/metabase/services.js b/frontend/src/metabase/services.js
index 3c8fcf4729d..3aa821e6f98 100644
--- a/frontend/src/metabase/services.js
+++ b/frontend/src/metabase/services.js
@@ -345,10 +345,3 @@ export const ActionsApi = {
"/api/dashboard/:dashboardId/dashcard/:dashcardId/execute",
),
};
-
-export const CacheConfigApi = {
- list: GET("/api/cache"),
- update: PUT("/api/cache"),
- delete: DELETE("/api/cache"),
- invalidate: POST("/api/cache/invalidate"),
-};
diff --git a/frontend/test/__support__/server-mocks/performance.ts b/frontend/test/__support__/server-mocks/performance.ts
index 7fd46c89375..fbc3edda934 100644
--- a/frontend/test/__support__/server-mocks/performance.ts
+++ b/frontend/test/__support__/server-mocks/performance.ts
@@ -2,7 +2,24 @@ import fetchMock from "fetch-mock";
import type { CacheConfig } from "metabase-types/api";
export function setupPerformanceEndpoints(cacheConfigs: CacheConfig[]) {
- fetchMock.get("path:/api/cache", { data: cacheConfigs });
- fetchMock.put("path:/api/cache", {});
- fetchMock.delete("path:/api/cache", {});
+ let configs = [...cacheConfigs];
+
+ fetchMock.get("path:/api/cache", () => {
+ return { data: configs };
+ });
+
+ fetchMock.put("path:/api/cache", ({ options }) => {
+ const body = JSON.parse(options.body as string);
+ configs = [
+ ...configs.filter((config) => config.model_id !== body.model_id),
+ body,
+ ];
+ return {};
+ });
+
+ fetchMock.delete("path:/api/cache", ({ options }) => {
+ const body = JSON.parse(options.body as string);
+ configs = configs.filter((config) => config.model_id !== body.model_id);
+ return {};
+ });
}
diff --git a/src/metabase/cache/api.clj b/src/metabase/cache/api.clj
index 415e3f98f6c..bf0c78918af 100644
--- a/src/metabase/cache/api.clj
+++ b/src/metabase/cache/api.clj
@@ -5,6 +5,7 @@
[metabase.cache.models.cache-config :as cache-config]
[metabase.config.core :as config]
[metabase.premium-features.core :as premium-features]
+ [metabase.request.core :as request]
[metabase.util.cron :as u.cron]
[metabase.util.i18n :refer [tru trun]]
[metabase.util.malli :as mu]
@@ -114,21 +115,33 @@
;;
#_{:clj-kondo/ignore [:metabase/validate-defendpoint-has-response-schema]}
(api.macros/defendpoint :get "/"
- "Return cache configuration."
+ "Return cache configuration. Supports pagination via `limit` and `offset` query parameters,
+ and sorting via `sort_column` and `sort_direction`."
[_route-params
- {:keys [model collection id]}
- :- [:map
- [:model {:default ["root"]} (mu/with (ms/QueryVectorOf cache-config/CachingModel)
- {:description "Type of model"})]
- [:collection {:optional true} (mu/with [:maybe ms/PositiveInt]
- {:description "Collection id to filter results. Returns everything if not supplied."})]
- [:id {:optional true} (mu/with [:maybe ms/PositiveInt]
- {:description "Model id to get configuration for."})]]]
+ {:keys [model collection id] :as params}
+ :- [:merge
+ [:map
+ [:model {:default ["root"]} (mu/with (ms/QueryVectorOf cache-config/CachingModel)
+ {:description "Type of model"})]
+ [:collection {:optional true} (mu/with [:maybe ms/PositiveInt]
+ {:description "Collection id to filter results. Returns everything if not supplied."})]
+ [:id {:optional true} (mu/with [:maybe ms/PositiveInt]
+ {:description "Model id to get configuration for."})]]
+ cache-config/SortParams]]
(when (and (not (premium-features/enable-cache-granular-controls?))
(not= model ["root"]))
(throw (premium-features/ee-feature-error (tru "Granular Caching"))))
(check-cache-access (first model) id)
- {:data (cache-config/get-list model collection id)})
+ (let [sort-params (select-keys params [:sort_column :sort_direction])
+ limit (request/limit)
+ offset (request/offset)
+ data (cache-config/get-list model collection id limit offset sort-params)]
+ (if limit
+ {:data data
+ :total (cache-config/get-list-total model collection id)
+ :limit limit
+ :offset offset}
+ {:data data})))
;; TODO (Cam 2025-11-25) please add a response schema to this API endpoint, it makes it easier for our customers to
;; use our API + we will need it when we make auto-TypeScript-signature generation happen
diff --git a/src/metabase/cache/models/cache_config.clj b/src/metabase/cache/models/cache_config.clj
index e327eef2a97..6945513cdbf 100644
--- a/src/metabase/cache/models/cache_config.clj
+++ b/src/metabase/cache/models/cache_config.clj
@@ -7,12 +7,24 @@
[metabase.events.core :as events]
[metabase.models.interface :as mi]
[metabase.util :as u]
+ [metabase.util.malli :as mu]
+ [metabase.util.malli.schema :as ms]
[methodical.core :as methodical]
[toucan2.core :as t2]))
;; TODO (Cam 10/3/25) -- change these to keywords and let API coercion convert them for us automatically
(def CachingModel "Caching is configurable for those models" [:enum "root" "database" "dashboard" "question"])
+(def ^:private available-sort-columns
+ "Valid columns for sorting cache configs."
+ #{:name :collection :policy})
+
+(def SortParams
+ "Schema for sort parameters."
+ [:map
+ [:sort_column {:default :name} (into [:enum] available-sort-columns)]
+ [:sort_direction {:default :asc} [:enum :asc :desc]]])
+
(doto :model/CacheConfig
(derive :metabase/model)
(derive :hook/timestamped?))
@@ -46,13 +58,22 @@
"Transform from how cache config is stored to how it's used/exposed in the API."
[row]
(when row
- {:model (:model row)
- :model_id (:model_id row)
- :strategy (-> (:config row)
- (assoc :type (:strategy row))
- (cond->
- (#{:duration :schedule} (:strategy row))
- (assoc :refresh_automatically (:refresh_automatically row))))}))
+ (cond-> {:model (:model row)
+ :model_id (:model_id row)
+ :strategy (-> (:config row)
+ (assoc :type (:strategy row))
+ (cond->
+ (#{:duration :schedule} (:strategy row))
+ (assoc :refresh_automatically (:refresh_automatically row))))}
+ ;; Include name if present (from JOINed query)
+ (:item_name row)
+ (assoc :name (:item_name row))
+ ;; Include collection if present (from JOINed query)
+ (:collection_id row)
+ (assoc :collection {:id (:collection_id row)
+ :name (:collection_name row)
+ :authority_level (:collection_authority_level row)
+ :type (:collection_type row)}))))
(defn card-strategy
"Shapes `row` into strategy for a given `card`."
@@ -70,30 +91,73 @@
:config (dissoc strategy :type :refresh_automatically)
:refresh_automatically (:refresh_automatically strategy)})
-(defn get-list
- "Get a list of cache configurations for given `models` and a `collection`."
+(defn- sort-column->order-by
+ "Convert a sort column to the appropriate SQL order-by expression."
+ [sort-column]
+ (case sort-column
+ :name [:coalesce :report_card.name :report_dashboard.name]
+ :collection [:coalesce :report_card.collection_id :report_dashboard.collection_id]
+ :policy :cache_config.strategy))
+
+(defn- base-query
+ "Build the base query for cache configs with JOINs for name/collection access."
+ [models collection id]
+ (if id
+ {:select [:cache_config.*]
+ :from [:cache_config]
+ :where [:and [:in :model models] [:= :model_id id]]}
+ {:select [:cache_config.*
+ [[:coalesce :report_card.name :report_dashboard.name] :item_name]
+ [[:coalesce :report_card.collection_id :report_dashboard.collection_id] :collection_id]
+ [:collection.name :collection_name]
+ [:collection.authority_level :collection_authority_level]
+ [:collection.type :collection_type]]
+ :from [:cache_config]
+ :left-join [:report_card [:and
+ [:= :model [:inline "question"]]
+ [:= :model_id :report_card.id]
+ (when collection
+ [:= :report_card.collection_id collection])]
+ :report_dashboard [:and
+ [:= :model [:inline "dashboard"]]
+ [:= :model_id :report_dashboard.id]
+ (when collection
+ [:= :report_dashboard.collection_id collection])]
+ :collection [:= :collection.id
+ [:coalesce :report_card.collection_id
+ :report_dashboard.collection_id]]]
+ :where [:and
+ [:in :model models]
+ [:case
+ [:= :model [:inline "question"]] [:!= :report_card.id nil]
+ [:= :model [:inline "dashboard"]] [:!= :report_dashboard.id nil]
+ :else true]]}))
+
+(mu/defn get-list
+ "Get a list of cache configurations for given `models` and a `collection`.
+ Supports pagination via `limit` and `offset`, and sorting via `sort-params`."
+ [models collection id
+ limit :- [:maybe ms/PositiveInt]
+ offset :- [:maybe ms/IntGreaterThanOrEqualToZero]
+ sort-params :- [:maybe SortParams]]
+ (let [{:keys [sort_column sort_direction]
+ :or {sort_column :name sort_direction :asc}} sort-params
+ ;; Only apply sorting when paginating (limit provided) and not querying by id
+ apply-sorting? (and limit (nil? id))
+ query (cond-> (base-query models collection id)
+ apply-sorting? (assoc :order-by [[(sort-column->order-by sort_column) sort_direction]])
+ limit (assoc :limit limit)
+ offset (assoc :offset offset))]
+ (->> (t2/select :model/CacheConfig query)
+ (mapv row->config))))
+
+(mu/defn get-list-total
+ "Get the total count of cache configurations for given `models` and a `collection`."
[models collection id]
- (->>
- (if id
- (t2/select :model/CacheConfig {:where [:and [:in :model models] [:= :model_id id]]})
- (t2/select
- :model/CacheConfig
- :model [:in models]
- {:left-join [:report_card [:and
- [:= :model [:inline "question"]]
- [:= :model_id :report_card.id]
- (when collection
- [:= :report_card.collection_id collection])]
- :report_dashboard [:and
- [:= :model [:inline "dashboard"]]
- [:= :model_id :report_dashboard.id]
- (when collection
- [:= :report_dashboard.collection_id collection])]]
- :where [:case
- [:= :model [:inline "question"]] [:!= :report_card.id nil]
- [:= :model [:inline "dashboard"]] [:!= :report_dashboard.id nil]
- :else true]}))
- (mapv row->config)))
+ (let [query (-> (base-query models collection id)
+ (dissoc :select)
+ (assoc :select [[[:count :*] :count]]))]
+ (:count (t2/query-one query))))
(defn store!
"Store cache configuration in DB."