fix(admin): Rename some variables (#43817)

enterprise/frontend/src/metabase-enterprise/caching/components/DashboardStrategySidebar.tsx

@@ -11,7 +11,7 @@ import { DelayedLoadingAndErrorWrapper } from "metabase/components/LoadingAndErr
 import type { DashboardSidebarPageProps } from "metabase/dashboard/components/DashboardInfoSidebar";
 import { color } from "metabase/lib/colors";
 import { Button, Flex, Icon, Title } from "metabase/ui";
-import type { CacheableModel, Strategy } from "metabase-types/api";
+import type { CacheableModel, CacheStrategy } from "metabase-types/api";
 
 import { DashboardStrategySidebarBody } from "./DashboardStrategySidebar.styled";
 
@@ -49,7 +49,7 @@ const DashboardStrategySidebar_Base = ({
     "dashboard",
   );
   const saveAndCloseSidebar = useCallback(
-    async (values: Strategy) => {
+    async (values: CacheStrategy) => {
       await saveStrategy(values);
       setPage("default");
     },

enterprise/frontend/src/metabase-enterprise/caching/components/SidebarCacheForm.tsx

@@ -11,7 +11,7 @@ import { DelayedLoadingAndErrorWrapper } from "metabase/components/LoadingAndErr
 import { color } from "metabase/lib/colors";
 import type { SidebarCacheFormProps } from "metabase/plugins";
 import { Button, Flex, Icon, Title } from "metabase/ui";
-import type { Strategy } from "metabase-types/api";
+import type { CacheStrategy } from "metabase-types/api";
 
 import { SidebarCacheFormBody } from "./SidebarCacheForm.styled";
 import { getItemId, getItemName } from "./utils";
@@ -38,7 +38,7 @@ const SidebarCacheForm_Base = ({
 
   const saveStrategy = useSaveStrategy(id, filteredConfigs, setConfigs, model);
   const saveAndCloseSidebar = useCallback(
-    async (values: Strategy) => {
+    async (values: CacheStrategy) => {
       await saveStrategy(values);
       setPage("default");
     },

enterprise/frontend/src/metabase-enterprise/caching/components/StrategyFormLauncher.tsx

@@ -5,7 +5,7 @@ import { rootId } from "metabase/admin/performance/constants/simple";
 import type { UpdateTargetId } from "metabase/admin/performance/types";
 import { getShortStrategyLabel } from "metabase/admin/performance/utils";
 import { FixedSizeIcon, Flex, Title, Tooltip, useHover } from "metabase/ui";
-import type { Config } from "metabase-types/api";
+import type { CacheConfig } from "metabase-types/api";
 
 import { PolicyToken, StyledLauncher } from "./StrategyFormLauncher.styled";
 
@@ -21,7 +21,7 @@ export const StrategyFormLauncher = ({
   targetId: number | null;
   title: string;
   updateTargetId: UpdateTargetId;
-  configs: Config[];
+  configs: CacheConfig[];
   isFormDirty: boolean;
 }) => {
   const forRoot = forId === rootId;

enterprise/frontend/src/metabase-enterprise/caching/components/StrategyFormLauncherPanel.tsx

@@ -7,7 +7,7 @@ import type { UpdateTargetId } from "metabase/admin/performance/types";
 import { FormProvider } from "metabase/forms";
 import { color } from "metabase/lib/colors";
 import type Database from "metabase-lib/v1/metadata/Database";
-import type { Config } from "metabase-types/api";
+import type { CacheConfig } from "metabase-types/api";
 
 import { useResetToDefaultForm } from "../hooks/useResetToDefaultForm";
 
@@ -27,8 +27,8 @@ export const StrategyFormLauncherPanel = ({
   isStrategyFormDirty,
   shouldShowResetButton,
 }: {
-  configs: Config[];
-  setConfigs: Dispatch<SetStateAction<Config[]>>;
+  configs: CacheConfig[];
+  setConfigs: Dispatch<SetStateAction<CacheConfig[]>>;
   targetId: number | null;
   updateTargetId: UpdateTargetId;
   databases: Database[];

enterprise/frontend/src/metabase-enterprise/caching/constants.ts

@@ -4,9 +4,11 @@ import * as Yup from "yup";
 import { positiveInteger } from "metabase/admin/performance/constants/complex";
 import type { StrategyData } from "metabase/admin/performance/types";
 import { defaultCron } from "metabase/admin/performance/utils";
-import { DurationUnit } from "metabase-types/api";
+import { CacheDurationUnit } from "metabase-types/api";
 
-export const durationUnits = new Set(Object.values(DurationUnit).map(String));
+export const durationUnits = new Set(
+  Object.values(CacheDurationUnit).map(String),
+);
 
 const scheduleStrategyValidationSchema = Yup.object({
   type: Yup.string().equals(["schedule"]),

enterprise/frontend/src/metabase-enterprise/caching/hooks/useResetToDefaultForm.tsx

@@ -2,7 +2,7 @@ import type { Dispatch, SetStateAction } from "react";
 import { useCallback, useEffect, useState } from "react";
 
 import { CacheConfigApi } from "metabase/services";
-import type { Config } from "metabase-types/api";
+import type { CacheConfig } from "metabase-types/api";
 
 export const useResetToDefaultForm = ({
   configs,
@@ -10,8 +10,8 @@ export const useResetToDefaultForm = ({
   databaseIds,
   isFormVisible,
 }: {
-  configs: Config[];
-  setConfigs: Dispatch<SetStateAction<Config[]>>;
+  configs: CacheConfig[];
+  setConfigs: Dispatch<SetStateAction<CacheConfig[]>>;
   databaseIds: number[];
   isFormVisible: boolean;
 }) => {
@@ -34,7 +34,7 @@ export const useResetToDefaultForm = ({
         { model_id: databaseIds, model: "database" },
         { hasBody: true },
       );
-      setConfigs((configs: Config[]) =>
+      setConfigs((configs: CacheConfig[]) =>
         configs.filter(({ model }) => model !== "database"),
       );
     } catch (e) {

frontend/src/metabase-types/api/mocks/performance.ts

-import { DurationUnit, type Config as CacheConfig } from "metabase-types/api";
+import { CacheDurationUnit, type CacheConfig } from "metabase-types/api";
 
 export const createMockCacheConfig = (
   opts?: Partial<CacheConfig>,
@@ -26,6 +26,6 @@ export const createMockCacheConfigWithDurationStrategy = (
   opts?: Partial<CacheConfig>,
 ): CacheConfig =>
   createMockCacheConfig({
-    strategy: { type: "duration", duration: 1, unit: DurationUnit.Hours },
+    strategy: { type: "duration", duration: 1, unit: CacheDurationUnit.Hours },
     ...opts,
   });

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

 /** 'Model' as in 'type of object' */
 export type CacheableModel = "root" | "database" | "dashboard" | "question";
 
-export type StrategyType =
+export type CacheStrategyType =
   | "nocache"
-  | "ttl" // aka Query duration multiplier
+  | "ttl" // aka Adaptive
   | "duration"
   | "schedule"
   | "inherit";
 
-interface StrategyBase {
-  type: StrategyType;
+interface CacheStrategyBase {
+  type: CacheStrategyType;
 }
 
-export enum DurationUnit {
+export enum CacheDurationUnit {
   Hours = "hours",
   Minutes = "minutes",
   Seconds = "seconds",
   Days = "days",
 }
 
-export interface MultiplierStrategy extends StrategyBase {
+export interface AdaptiveStrategy extends CacheStrategyBase {
   type: "ttl";
   multiplier: number;
   min_duration_ms: number;
   min_duration_seconds?: number;
 }
 
-export interface DoNotCacheStrategy extends StrategyBase {
+export interface DoNotCacheStrategy extends CacheStrategyBase {
   type: "nocache";
 }
 
-export interface DurationStrategy extends StrategyBase {
+export interface DurationStrategy extends CacheStrategyBase {
   type: "duration";
   duration: number;
-  unit: DurationUnit;
+  unit: CacheDurationUnit;
 }
 
-export interface InheritStrategy extends StrategyBase {
+export interface InheritStrategy extends CacheStrategyBase {
   type: "inherit";
 }
 
-export interface ScheduleStrategy extends StrategyBase {
+export interface ScheduleStrategy extends CacheStrategyBase {
   type: "schedule";
   schedule: string;
 }
 
 /** Cache invalidation strategy */
-export type Strategy =
+export type CacheStrategy =
   | DoNotCacheStrategy
-  | MultiplierStrategy
+  | AdaptiveStrategy
   | DurationStrategy
   | InheritStrategy
   | ScheduleStrategy;
 
 /** Cache invalidation configuration */
-export interface Config {
+export interface CacheConfig {
   /** The type of cacheable object this configuration concerns */
   model: CacheableModel;
   model_id: number;
   /** Cache invalidation strategy */
-  strategy: Strategy;
+  strategy: CacheStrategy;
 }
 
 export type CacheConfigAPIResponse = {
-  data: Config[];
+  data: CacheConfig[];
 };

frontend/src/metabase/admin/performance/components/StrategyEditorForDatabases.tsx

@@ -10,7 +10,7 @@ import { DelayedLoadingAndErrorWrapper } from "metabase/components/LoadingAndErr
 import { PLUGIN_CACHING } from "metabase/plugins";
 import { Stack, Flex } from "metabase/ui";
 import type { CacheableModel } from "metabase-types/api";
-import { DurationUnit } from "metabase-types/api";
+import { CacheDurationUnit } from "metabase-types/api";
 
 import { rootId } from "../constants/simple";
 import { useCacheConfigs } from "../hooks/useCacheConfigs";
@@ -70,7 +70,7 @@ const StrategyEditorForDatabases_Base = ({
   const savedStrategy = targetConfig?.strategy;
 
   if (savedStrategy?.type === "duration") {
-    savedStrategy.unit = DurationUnit.Hours;
+    savedStrategy.unit = CacheDurationUnit.Hours;
   }
 
   const {

frontend/src/metabase/admin/performance/components/StrategyForm.tsx

@@ -31,12 +31,12 @@ import {
 } from "metabase/ui";
 import type {
   CacheableModel,
+  CacheStrategy,
+  CacheStrategyType,
   ScheduleSettings,
   ScheduleStrategy,
-  Strategy,
-  StrategyType,
 } from "metabase-types/api";
-import { DurationUnit } from "metabase-types/api";
+import { CacheDurationUnit } from "metabase-types/api";
 
 import { strategyValidationSchema } from "../constants/complex";
 import { rootId } from "../constants/simple";
@@ -85,20 +85,20 @@ export const StrategyForm = ({
   targetModel: CacheableModel;
   targetName: string;
   setIsDirty: (isDirty: boolean) => void;
-  saveStrategy: (values: Strategy) => Promise<void>;
-  savedStrategy?: Strategy;
+  saveStrategy: (values: CacheStrategy) => Promise<void>;
+  savedStrategy?: CacheStrategy;
   shouldAllowInvalidation?: boolean;
   shouldShowName?: boolean;
   onReset?: () => void;
   buttonLabels?: ButtonLabels;
   isInSidebar?: boolean;
 }) => {
-  const defaultStrategy: Strategy = {
+  const defaultStrategy: CacheStrategy = {
     type: targetId === rootId ? "nocache" : "inherit",
   };
 
   return (
-    <FormProvider<Strategy>
+    <FormProvider<CacheStrategy>
       key={targetId}
       initialValues={savedStrategy ?? defaultStrategy}
       validationSchema={strategyValidationSchema}
@@ -139,7 +139,7 @@ const StrategyFormBody = ({
   buttonLabels: ButtonLabels;
   isInSidebar?: boolean;
 }) => {
-  const { dirty, values, setFieldValue } = useFormikContext<Strategy>();
+  const { dirty, values, setFieldValue } = useFormikContext<CacheStrategy>();
   const { setStatus } = useFormContext();
   const [wasDirty, setWasDirty] = useState(false);
 
@@ -159,7 +159,7 @@ const StrategyFormBody = ({
 
   useEffect(() => {
     if (selectedStrategyType === "duration") {
-      setFieldValue("unit", DurationUnit.Hours);
+      setFieldValue("unit", CacheDurationUnit.Hours);
     }
   }, [selectedStrategyType, values, setFieldValue]);
 
@@ -264,7 +264,7 @@ const FormButtons = ({
   buttonLabels,
   isInSidebar,
 }: FormButtonsProps) => {
-  const { dirty } = useFormikContext<Strategy>();
+  const { dirty } = useFormikContext<CacheStrategy>();
 
   if (targetId === rootId) {
     shouldAllowInvalidation = false;
@@ -381,7 +381,7 @@ const StrategySelector = ({
 }) => {
   const { strategies } = PLUGIN_CACHING;
 
-  const { values } = useFormikContext<Strategy>();
+  const { values } = useFormikContext<CacheStrategy>();
 
   const availableStrategies = useMemo(() => {
     return targetId === rootId ? _.omit(strategies, "inherit") : strategies;
@@ -432,7 +432,7 @@ export const PositiveNumberInput = ({
   strategyType,
   ...props
 }: {
-  strategyType: StrategyType;
+  strategyType: CacheStrategyType;
 } & Partial<FormTextInputProps>) => {
   return (
     <FormTextInput
@@ -476,7 +476,7 @@ const Field = ({
 };
 
 const getDefaultValueForField = (
-  strategyType: StrategyType,
+  strategyType: CacheStrategyType,
   fieldName?: string,
 ) => {
   return fieldName

frontend/src/metabase/admin/performance/components/test-utils.tsx

@@ -5,7 +5,7 @@ import { mockSettings } from "__support__/settings";
 import { createMockEntitiesState } from "__support__/store";
 import { act, fireEvent, renderWithProviders, screen } from "__support__/ui";
 import type { TokenFeatures } from "metabase-types/api";
-import { DurationUnit } from "metabase-types/api";
+import { CacheDurationUnit } from "metabase-types/api";
 import {
   createMockSettings,
   createMockTokenFeatures,
@@ -50,7 +50,11 @@ export const setupStrategyEditorForDatabases = ({
     createMockCacheConfig({
       model: "root",
       model_id: 0,
-      strategy: { type: "duration", duration: 1, unit: DurationUnit.Hours },
+      strategy: {
+        type: "duration",
+        duration: 1,
+        unit: CacheDurationUnit.Hours,
+      },
     }),
   ];
   setupPerformanceEndpoints(cacheConfigs);

frontend/src/metabase/admin/performance/hooks/useCacheConfigs.tsx

@@ -5,7 +5,7 @@ import _ from "underscore";
 import { CacheConfigApi } from "metabase/services";
 import type {
   CacheConfigAPIResponse,
-  Config,
+  CacheConfig,
   CacheableModel,
 } from "metabase-types/api";
 
@@ -36,7 +36,7 @@ export const useCacheConfigs = ({
 
   const configsFromAPI = configsApiResult.value;
 
-  const [configs, setConfigs] = useState<Config[]>([]);
+  const [configs, setConfigs] = useState<CacheConfig[]>([]);
 
   const rootStrategyOverriddenOnce = configs.some(
     config => config.model_id !== rootId,

frontend/src/metabase/admin/performance/hooks/useSaveStrategy.tsx

@@ -4,26 +4,30 @@ import _ from "underscore";
 
 import { PLUGIN_CACHING } from "metabase/plugins";
 import { CacheConfigApi } from "metabase/services";
-import type { Config, CacheableModel, Strategy } from "metabase-types/api";
+import type {
+  CacheConfig,
+  CacheableModel,
+  CacheStrategy,
+} from "metabase-types/api";
 
 import { rootId } from "../constants/simple";
 import { getFieldsForStrategyType, translateConfigToAPI } from "../utils";
 
 export const useSaveStrategy = (
   targetId: number | null,
-  configs: Config[],
-  setConfigs: Dispatch<SetStateAction<Config[]>>,
+  configs: CacheConfig[],
+  setConfigs: Dispatch<SetStateAction<CacheConfig[]>>,
   model: CacheableModel,
 ) => {
   const saveStrategy = useCallback(
-    async (values: Strategy) => {
+    async (values: CacheStrategy) => {
       if (targetId === null) {
         return;
       }
       const { strategies } = PLUGIN_CACHING;
 
       const isRoot = targetId === rootId;
-      const baseConfig: Pick<Config, "model" | "model_id"> = {
+      const baseConfig: Pick<CacheConfig, "model" | "model_id"> = {
         model: isRoot ? "root" : model,
         model_id: targetId,
       };
@@ -43,7 +47,7 @@ export const useSaveStrategy = (
         // for fields that are not in the new strategy,
         // so let's remove these fields
         const validFields = getFieldsForStrategyType(values.type);
-        const newStrategy = _.pick(values, validFields) as Strategy;
+        const newStrategy = _.pick(values, validFields) as CacheStrategy;
 
         const validatedStrategy =
           strategies[values.type].validateWith.validateSync(newStrategy);

frontend/src/metabase/admin/performance/strategies.ts

-import { t } from "ttag";
-import * as Yup from "yup";
-
-import { DurationUnit } from "metabase-types/api";
-
-const durationUnits = new Set(Object.values(DurationUnit).map(String));
-
-const positiveInteger = Yup.number()
-  .positive(t`Enter a positive number.`)
-  .integer(t`Enter an integer.`);
-
-export const inheritStrategyValidationSchema = Yup.object({
-  type: Yup.string().equals(["inherit"]),
-});
-
-export const doNotCacheStrategyValidationSchema = Yup.object({
-  type: Yup.string().equals(["nocache"]),
-});
-
-export const defaultMinDurationMs = 1000;
-export const adaptiveStrategyValidationSchema = Yup.object({
-  type: Yup.string().equals(["ttl"]),
-  min_duration_ms: positiveInteger.default(defaultMinDurationMs),
-  min_duration_seconds: positiveInteger.default(
-    Math.ceil(defaultMinDurationMs / 1000),
-  ),
-  multiplier: positiveInteger.default(10),
-});
-
-export const durationStrategyValidationSchema = Yup.object({
-  type: Yup.string().equals(["duration"]),
-  duration: positiveInteger.default(24),
-  unit: Yup.string().test(
-    "is-duration-unit",
-    "${path} is not a valid duration",
-    value => !!value && durationUnits.has(value),
-  ),
-});

frontend/src/metabase/admin/performance/utils.tsx

-import _, { memoize } from "underscore";
+import { memoize } from "underscore";
 import type { SchemaObjectDescription } from "yup/lib/schema";
 
 import {
@@ -9,14 +9,14 @@ import {
 import { isNullOrUndefined } from "metabase/lib/types";
 import { PLUGIN_CACHING } from "metabase/plugins";
 import type {
+  CacheConfig,
+  CacheStrategy,
+  CacheStrategyType,
   CacheableModel,
-  Config,
   ScheduleDayType,
   ScheduleFrameType,
   ScheduleSettings,
   ScheduleType,
-  Strategy,
-  StrategyType,
 } from "metabase-types/api";
 
 import { defaultMinDurationMs, rootId } from "./constants/simple";
@@ -188,7 +188,7 @@ export const getFrequencyFromCron = (cron: string) => {
 
 export const isValidStrategyName = (
   strategy: string,
-): strategy is StrategyType => {
+): strategy is CacheStrategyType => {
   const { strategies } = PLUGIN_CACHING;
   const validStrategyNames = new Set(Object.keys(strategies));
   return validStrategyNames.has(strategy);
@@ -198,7 +198,7 @@ export const getLabelString = (label: StrategyLabel, model?: CacheableModel) =>
   typeof label === "string" ? label : label(model);
 
 export const getShortStrategyLabel = (
-  strategy?: Strategy,
+  strategy?: CacheStrategy,
   model?: CacheableModel,
 ) => {
   const { strategies } = PLUGIN_CACHING;
@@ -215,7 +215,7 @@ export const getShortStrategyLabel = (
   }
 };
 
-export const getFieldsForStrategyType = (strategyType: StrategyType) => {
+export const getFieldsForStrategyType = (strategyType: CacheStrategyType) => {
   const { strategies } = PLUGIN_CACHING;
   const strategy = strategies[strategyType];
   const validationSchemaDescription =
@@ -226,10 +226,10 @@ export const getFieldsForStrategyType = (strategyType: StrategyType) => {
 };
 
 export const translateConfig = (
-  config: Config,
+  config: CacheConfig,
   direction: "fromAPI" | "toAPI",
-): Config => {
-  const translated: Config = { ...config };
+): CacheConfig => {
+  const translated: CacheConfig = { ...config };
 
   // If strategy type is unsupported, use a fallback
   if (!isValidStrategyName(translated.strategy.type)) {
@@ -253,7 +253,7 @@ export const translateConfig = (
   return translated;
 };
 
-export const translateConfigFromAPI = (config: Config): Config =>
+export const translateConfigFromAPI = (config: CacheConfig): CacheConfig =>
   translateConfig(config, "fromAPI");
-export const translateConfigToAPI = (config: Config): Config =>
+export const translateConfigToAPI = (config: CacheConfig): CacheConfig =>
   translateConfig(config, "toAPI");

frontend/test/__support__/server-mocks/performance.ts

 import fetchMock from "fetch-mock";
 
-import type { Config as CacheConfig } from "metabase-types/api";
+import type { CacheConfig } from "metabase-types/api";
 export function setupPerformanceEndpoints(cacheConfigs: CacheConfig[]) {
   fetchMock.get({ url: "path:/api/cache" }, { data: cacheConfigs });
   fetchMock.put({ url: "path:/api/cache" }, {});