upcoming: [DI-25355] - Added util function to filter region based on monitor capability

packages/api-v4/.changeset/pr-12573-added-1753364724800.md

@@ -0,0 +1,5 @@
+---
+"@linode/api-v4": Added
+---
+
+ACLP: `string` type for `capabilityServiceTypeMapping` constant ([#12573](https://github.com/linode/manager/pull/12573))

packages/api-v4/src/cloudpulse/types.ts

@@ -365,7 +365,7 @@ export interface DeleteAlertPayload {
 }
 
 export const capabilityServiceTypeMapping: Record<
-  MetricsServiceType,
+  AlertServiceType | MetricsServiceType | string,
   AccountCapability
 > = {
   linode: 'Linodes',

packages/manager/.changeset/pr-12573-added-1753364742642.md

@@ -0,0 +1,5 @@
+---
+"@linode/manager": Added
+---
+
+ACLP: `filterRegionByServiceType` method to alerts/utils/utils.ts, remove `supportedRegionIds` property from `CloudPulseResourceTypeMapFlag` feature flag  ([#12573](https://github.com/linode/manager/pull/12573))

packages/manager/cypress/e2e/core/cloudpulse/cloudpulse-dashboard-errors.spec.ts

@@ -55,13 +55,11 @@ const flags: Partial<Flags> = {
       dimensionKey: 'LINODE_ID',
       maxResourceSelections: 10,
       serviceType: 'linode',
-      supportedRegionIds: 'us-ord',
     },
     {
       dimensionKey: 'cluster_id',
       maxResourceSelections: 10,
       serviceType: 'dbaas',
-      supportedRegionIds: 'us-ord, us-east',
     },
   ],
 };
@@ -101,11 +99,19 @@ const mockRegions = [
     id: 'us-ord',
     label: 'Chicago, IL',
     capabilities: ['Managed Databases'],
+    monitors: {
+      metrics: ['Linodes', 'Managed Databases'],
+      alerts: [],
+    },
   }),
   regionFactory.build({
     id: 'us-east',
     label: 'Newark, NJ',
     capabilities: ['Managed Databases'],
+    monitors: {
+      metrics: ['Managed Databases'],
+      alerts: [],
+    },
   }),
 ];
 

packages/manager/cypress/e2e/core/cloudpulse/create-user-alert.spec.ts

@@ -47,11 +47,26 @@ const flags: Partial<Flags> = { aclp: { beta: true, enabled: true } };
 
 // Create mock data
 const mockAccount = accountFactory.build();
-const mockRegion = regionFactory.build({
-  capabilities: ['Managed Databases'],
-  id: 'us-ord',
-  label: 'Chicago, IL',
-});
+const mockRegions = [
+  regionFactory.build({
+    id: 'us-ord',
+    label: 'Chicago, IL',
+    capabilities: ['Managed Databases'],
+    monitors: {
+      alerts: ['Managed Databases'],
+      metrics: [],
+    },
+  }),
+  regionFactory.build({
+    id: 'us-east',
+    label: 'New York, NY',
+    capabilities: ['Managed Databases'],
+    monitors: {
+      alerts: ['Managed Databases'],
+      metrics: [],
+    },
+  }),
+];
 const { metrics, serviceType } = widgetDetails.dbaas;
 const databaseMock = databaseFactory.buildList(10, {
   cluster_size: 3,
@@ -164,7 +179,7 @@ describe('Create Alert', () => {
     mockGetAccount(mockAccount);
     mockGetProfile(mockProfile);
     mockGetCloudPulseServices([serviceType]);
-    mockGetRegions([mockRegion]);
+    mockGetRegions(mockRegions);
     mockGetCloudPulseMetricDefinitions(serviceType, metricDefinitions);
     mockGetDatabases(databaseMock);
     mockGetAllAlertDefinitions([mockAlerts]).as('getAlertDefinitionsList');

packages/manager/cypress/e2e/core/cloudpulse/dbaas-widgets-verification.spec.ts

@@ -63,13 +63,11 @@ const flags: Partial<Flags> = {
       dimensionKey: 'LINODE_ID',
       maxResourceSelections: 10,
       serviceType: 'linode',
-      supportedRegionIds: '',
     },
     {
       dimensionKey: 'cluster_id',
       maxResourceSelections: 10,
       serviceType: 'dbaas',
-      supportedRegionIds: 'us-ord',
     },
   ],
 };
@@ -123,6 +121,10 @@ const mockRegion = regionFactory.build({
   capabilities: ['Managed Databases'],
   id: 'us-ord',
   label: 'Chicago, IL',
+  monitors: {
+    metrics: ['Managed Databases'],
+    alerts: [],
+  },
 });
 
 const extendedMockRegion = regionFactory.build({

packages/manager/cypress/e2e/core/cloudpulse/linode-widget-verification.spec.ts

@@ -53,13 +53,11 @@ const flags: Partial<Flags> = {
       dimensionKey: 'LINODE_ID',
       maxResourceSelections: 10,
       serviceType: 'linode',
-      supportedRegionIds: 'us-ord',
     },
     {
       dimensionKey: 'cluster_id',
       maxResourceSelections: 10,
       serviceType: 'dbaas',
-      supportedRegionIds: '',
     },
   ],
 };
@@ -99,6 +97,10 @@ const mockRegion = regionFactory.build({
   capabilities: ['Linodes'],
   id: 'us-ord',
   label: 'Chicago, IL',
+  monitors: {
+    alerts: [],
+    metrics: ['Linodes'],
+  },
 });
 
 const extendedMockRegion = regionFactory.build({

packages/manager/cypress/e2e/core/cloudpulse/timerange-verification.spec.ts

@@ -52,6 +52,10 @@ const mockRegion = regionFactory.build({
   capabilities: ['Managed Databases'],
   id: 'us-ord',
   label: 'Chicago, IL',
+  monitors: {
+    metrics: ['Managed Databases'],
+    alerts: [],
+  },
 });
 
 const flags: Partial<Flags> = {
@@ -61,7 +65,6 @@ const flags: Partial<Flags> = {
       dimensionKey: 'cluster_id',
       maxResourceSelections: 10,
       serviceType: 'dbaas',
-      supportedRegionIds: 'us-ord',
     },
   ],
 };

packages/manager/src/featureFlags.ts

@@ -86,7 +86,6 @@ export interface CloudPulseResourceTypeMapFlag {
   dimensionKey: string;
   maxResourceSelections?: number;
   serviceType: string;
-  supportedRegionIds?: string;
 }
 
 interface GpuV2 {

packages/manager/src/features/CloudPulse/Alerts/AlertRegions/AlertRegions.test.tsx

@@ -8,21 +8,12 @@ import { renderWithTheme } from 'src/utilities/testHelpers';
 import { AlertRegions } from './AlertRegions';
 
 import type { AlertServiceType } from '@linode/api-v4';
-import type { Flags } from 'src/featureFlags';
 
-const regions = regionFactory.buildList(6);
+const regions = regionFactory.buildList(6, {
+  monitors: { alerts: ['Managed Databases'] },
+});
 const serviceType: AlertServiceType = 'dbaas';
 
-const flags: Partial<Flags> = {
-  aclpResourceTypeMap: [
-    {
-      serviceType,
-      supportedRegionIds: regions.map(({ id }) => id).join(','),
-      dimensionKey: 'region',
-    },
-  ],
-};
-
 const queryMocks = vi.hoisted(() => ({
   useFlags: vi.fn(),
   useRegionsQuery: vi.fn(),
@@ -65,7 +56,7 @@ const component = (
 );
 describe('Alert Regions', () => {
   it('Should render the filters and notices ', () => {
-    renderWithTheme(component, { flags });
+    renderWithTheme(component);
 
     const regionSearch = screen.getByTestId('region-search');
     const showSelectedOnly = screen.getByTestId('show-selected-only');

packages/manager/src/features/CloudPulse/Alerts/AlertRegions/AlertRegions.tsx

@@ -4,7 +4,6 @@ import { Typography } from '@linode/ui';
 import React from 'react';
 
 import { DebouncedSearchTextField } from 'src/components/DebouncedSearchTextField';
-import { useFlags } from 'src/hooks/useFlags';
 import { useResourcesQuery } from 'src/queries/cloudpulse/resources';
 
 import { type AlertFormMode } from '../constants';
@@ -39,7 +38,6 @@ interface AlertRegionsProps {
 
 export const AlertRegions = React.memo((props: AlertRegionsProps) => {
   const { serviceType, handleChange, value = [], errorText, mode } = props;
-  const { aclpResourceTypeMap } = useFlags();
   const [searchText, setSearchText] = React.useState<string>('');
   const { data: regions, isLoading: isRegionsLoading } = useRegionsQuery();
 
@@ -92,9 +90,8 @@ export const AlertRegions = React.memo((props: AlertRegionsProps) => {
         serviceType,
         resources,
         regions,
-        aclpResourceTypeMap,
       }),
-    [aclpResourceTypeMap, regions, resources, serviceType]
+    [regions, resources, serviceType]
   );
 
   if (isRegionsLoading || isResourcesLoading) {

packages/manager/src/features/CloudPulse/Alerts/AlertsResources/AlertsResources.tsx

@@ -5,7 +5,6 @@ import React from 'react';
 
 import EntityIcon from 'src/assets/icons/entityIcons/alertsresources.svg';
 import { DebouncedSearchTextField } from 'src/components/DebouncedSearchTextField';
-import { useFlags } from 'src/hooks/useFlags';
 import { useResourcesQuery } from 'src/queries/cloudpulse/resources';
 
 import { StyledPlaceholder } from '../AlertsDetail/AlertDetail';
@@ -129,14 +128,9 @@ export const AlertResources = React.memo((props: AlertResourcesProp) => {
     isLoading: isRegionsLoading,
   } = useRegionsQuery();
 
-  const flags = useFlags();
   const theme = useTheme();
 
-  // Validate launchDarkly region ids with the ids from regionOptions prop
-  const supportedRegionIds = getSupportedRegionIds(
-    flags.aclpResourceTypeMap,
-    serviceType
-  );
+  const supportedRegionIds = getSupportedRegionIds(regions, serviceType);
   const xFilterToBeApplied: Filter | undefined = React.useMemo(() => {
     const regionFilter: Filter = supportedRegionIds
       ? {

packages/manager/src/features/CloudPulse/Alerts/Utils/AlertResourceUtils.test.ts

@@ -181,30 +181,18 @@ describe('getFilteredResources', () => {
 });
 
 describe('getSupportedRegionIds', () => {
-  const mockResourceTypeMap = [
-    {
-      dimensionKey: 'LINODE_ID',
-      serviceType: 'linode',
-      supportedRegionIds: 'us-east,us-west,us-central,us-southeast',
+  const regions = regionFactory.buildList(4, {
+    monitors: {
+      alerts: ['Linodes'],
     },
-  ];
+  });
 
   it('should return supported region ids', () => {
-    const result = getSupportedRegionIds(
-      mockResourceTypeMap,
-      'linode'
-    ) as string[];
+    const result = getSupportedRegionIds(regions, 'linode') as string[];
     expect(result.length).toBe(4);
   });
-  it('should return undefined if no supported region ids are defined in resource type map for the given service type', () => {
-    const mockResourceTypeMap = [
-      {
-        dimensionKey: 'LINODE_ID',
-        serviceType: 'linode',
-      },
-    ];
-
-    const result = getSupportedRegionIds(mockResourceTypeMap, 'linode');
-    expect(result).toBeUndefined();
+  it('should return empty list if regions list empty', () => {
+    const result = getSupportedRegionIds([], 'linode');
+    expect(result).toHaveLength(0);
   });
 });

packages/manager/src/features/CloudPulse/Alerts/Utils/AlertResourceUtils.ts

@@ -2,6 +2,7 @@ import {
   alertAdditionalFilterKeyMap,
   applicableAdditionalFilterKeys,
 } from '../AlertsResources/constants';
+import { filterRegionByServiceType } from './utils';
 
 import type { CloudPulseResources } from '../../shared/CloudPulseResourcesSelect';
 import type { AlertInstance } from '../AlertsResources/DisplayAlertResources';
@@ -12,7 +13,6 @@ import type {
   AlertResourceFiltersProps,
 } from '../AlertsResources/types';
 import type { AlertServiceType, Region } from '@linode/api-v4';
-import type { CloudPulseResourceTypeMapFlag } from 'src/featureFlags';
 
 interface FilterResourceProps {
   /**
@@ -138,28 +138,19 @@ export const getRegionOptions = (
 };
 
 /**
- * @param aclpResourceTypeMap The launch darkly flag where supported region ids are listed
- * @param serviceType The service type associated with the alerts
- * @returns Array of supported regions associated with the resource ids of the alert
+ * Filters regions based on service type and returns their IDs.
+ * @param regions List of regions to filter
+ * @param serviceType The alert service type to filter regions by
+ * @returns An array of region IDs that support the specified alert service type,
+ *                                 or undefined if no regions are provided
  */
 export const getSupportedRegionIds = (
-  aclpResourceTypeMap: CloudPulseResourceTypeMapFlag[] | undefined,
-  serviceType: AlertServiceType | undefined
+  regions?: Region[],
+  serviceType?: AlertServiceType
 ): string[] | undefined => {
-  const resourceTypeFlag = aclpResourceTypeMap?.find(
-    (item: CloudPulseResourceTypeMapFlag) => item.serviceType === serviceType
+  return filterRegionByServiceType('alerts', regions, serviceType).map(
+    ({ id }) => id
   );
-
-  if (
-    resourceTypeFlag?.supportedRegionIds === null ||
-    resourceTypeFlag?.supportedRegionIds === undefined
-  ) {
-    return undefined;
-  }
-
-  return resourceTypeFlag.supportedRegionIds
-    .split(',')
-    .map((regionId: string) => regionId.trim());
 };
 
 /**