refactor(frontend): inline single-use handleMutationError in alert hooks

Replaces four call sites in AlertDetails/hooks.tsx with the same
showErrorModal(convertToApiError(...)) expression directly; the helper
added no semantics beyond the type cast it wrapped. The two pure
onError arrows end up byte-identical, so the delete hook carries an
eslint-disable for sonarjs/no-identical-functions (same pattern already
used in providers/QueryBuilder.tsx).

frontend/src/api/alerts/create.ts

@@ -1,20 +0,0 @@
-import axios from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/alerts/create';
-
-const create = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	const response = await axios.post('/rules', {
-		...props.data,
-	});
-
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data.data,
-	};
-};
-
-export default create;

frontend/src/api/alerts/createAlertRule.ts

@@ -1,28 +0,0 @@
-import axios from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import {
-	AlertRuleV2,
-	PostableAlertRuleV2,
-} from 'types/api/alerts/alertTypesV2';
-
-export interface CreateAlertRuleResponse {
-	data: AlertRuleV2;
-	status: string;
-}
-
-const createAlertRule = async (
-	props: PostableAlertRuleV2,
-): Promise<SuccessResponse<CreateAlertRuleResponse> | ErrorResponse> => {
-	const response = await axios.post(`/rules`, {
-		...props,
-	});
-
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data.data,
-	};
-};
-
-export default createAlertRule;

frontend/src/api/alerts/delete.ts

@@ -1,18 +0,0 @@
-import axios from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/alerts/delete';
-
-const deleteAlerts = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	const response = await axios.delete(`/rules/${props.id}`);
-
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data.data.rules,
-	};
-};
-
-export default deleteAlerts;

frontend/src/api/alerts/get.ts

@@ -1,16 +0,0 @@
-import axios from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/alerts/get';
-
-const get = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	const response = await axios.get(`/rules/${props.id}`);
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data,
-	};
-};
-export default get;

frontend/src/api/alerts/getAll.ts

@@ -1,24 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps } from 'types/api/alerts/getAll';
-
-const getAll = async (): Promise<
-	SuccessResponse<PayloadProps> | ErrorResponse
-> => {
-	try {
-		const response = await axios.get('/rules');
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data.rules,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default getAll;

frontend/src/api/alerts/getGroup.ts

@@ -1,29 +0,0 @@
-import { AxiosAlertManagerInstance } from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import convertObjectIntoParams from 'lib/query/convertObjectIntoParams';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/alerts/getGroups';
-
-const getGroups = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const queryParams = convertObjectIntoParams(props);
-
-		const response = await AxiosAlertManagerInstance.get(
-			`/alerts/groups?${queryParams}`,
-		);
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default getGroups;

frontend/src/api/alerts/patch.ts

@@ -1,20 +0,0 @@
-import axios from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/alerts/patch';
-
-const patch = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	const response = await axios.patch(`/rules/${props.id}`, {
-		...props.data,
-	});
-
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data.data,
-	};
-};
-
-export default patch;

frontend/src/api/alerts/patchRulePartial.ts

@@ -0,0 +1,12 @@
+import { patchRuleByID } from 'api/generated/services/rules';
+import type { RuletypesPostableRuleDTO } from 'api/generated/services/sigNoz.schemas';
+
+// why: patchRuleByID's generated body type is the full RuletypesPostableRuleDTO
+// because the backend OpenAPI spec currently advertises PostableRule. The
+// endpoint itself accepts any subset of fields. Until the backend introduces
+// PatchableRule, this wrapper localizes the cast so callers stay typed.
+export const patchRulePartial = (
+	id: string,
+	patch: Partial<RuletypesPostableRuleDTO>,
+): ReturnType<typeof patchRuleByID> =>
+	patchRuleByID({ id }, patch as RuletypesPostableRuleDTO);

frontend/src/api/alerts/put.ts

@@ -1,20 +0,0 @@
-import axios from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/alerts/save';
-
-const put = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	const response = await axios.put(`/rules/${props.id}`, {
-		...props.data,
-	});
-
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data.data,
-	};
-};
-
-export default put;

frontend/src/api/alerts/save.ts

@@ -1,18 +0,0 @@
-import { isEmpty } from 'lodash-es';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/alerts/save';
-
-import create from './create';
-import put from './put';
-
-const save = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	if (props.id && !isEmpty(props.id)) {
-		return put({ ...props });
-	}
-
-	return create({ ...props });
-};
-
-export default save;

frontend/src/api/alerts/testAlert.ts

@@ -1,26 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PayloadProps, Props } from 'types/api/alerts/testAlert';
-
-const testAlert = async (
-	props: Props,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.post('/testRule', {
-			...props.data,
-		});
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default testAlert;

frontend/src/api/alerts/testAlertRule.ts

@@ -1,28 +0,0 @@
-import axios from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PostableAlertRuleV2 } from 'types/api/alerts/alertTypesV2';
-
-export interface TestAlertRuleResponse {
-	data: {
-		alertCount: number;
-		message: string;
-	};
-	status: string;
-}
-
-const testAlertRule = async (
-	props: PostableAlertRuleV2,
-): Promise<SuccessResponse<TestAlertRuleResponse> | ErrorResponse> => {
-	const response = await axios.post(`/testRule`, {
-		...props,
-	});
-
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data.data,
-	};
-};
-
-export default testAlertRule;

frontend/src/api/alerts/updateAlertRule.ts

@@ -1,26 +0,0 @@
-import axios from 'api';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PostableAlertRuleV2 } from 'types/api/alerts/alertTypesV2';
-
-export interface UpdateAlertRuleResponse {
-	data: string;
-	status: string;
-}
-
-const updateAlertRule = async (
-	id: string,
-	postableAlertRule: PostableAlertRuleV2,
-): Promise<SuccessResponse<UpdateAlertRuleResponse> | ErrorResponse> => {
-	const response = await axios.put(`/rules/${id}`, {
-		...postableAlertRule,
-	});
-
-	return {
-		statusCode: 200,
-		error: null,
-		message: response.data.status,
-		payload: response.data.data,
-	};
-};
-
-export default updateAlertRule;

frontend/src/api/plannedDowntime/createDowntimeSchedule.ts

@@ -1,45 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { Dayjs } from 'dayjs';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-
-import { Recurrence } from './getAllDowntimeSchedules';
-
-export interface DowntimeSchedulePayload {
-	name: string;
-	description?: string;
-	alertIds: string[];
-	schedule: {
-		timezone?: string;
-		startTime?: string | Dayjs;
-		endTime?: string | Dayjs;
-		recurrence?: Recurrence;
-	};
-}
-
-export interface PayloadProps {
-	status: string;
-	data: string;
-}
-
-const createDowntimeSchedule = async (
-	props: DowntimeSchedulePayload,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.post('/downtime_schedules', {
-			...props,
-		});
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default createDowntimeSchedule;

frontend/src/api/plannedDowntime/deleteDowntimeSchedule.ts

@@ -1,19 +0,0 @@
-import { useMutation, UseMutationResult } from 'react-query';
-import axios from 'api';
-
-export interface DeleteDowntimeScheduleProps {
-	id?: number;
-}
-
-export interface DeleteSchedulePayloadProps {
-	status: string;
-	data: string;
-}
-
-export const useDeleteDowntimeSchedule = (
-	props: DeleteDowntimeScheduleProps,
-): UseMutationResult<DeleteSchedulePayloadProps, Error, number> =>
-	useMutation({
-		mutationKey: [props.id],
-		mutationFn: () => axios.delete(`/downtime_schedules/${props.id}`),
-	});

frontend/src/api/plannedDowntime/getAllDowntimeSchedules.ts

@@ -1,51 +0,0 @@
-import { useQuery, UseQueryResult } from 'react-query';
-import axios from 'api';
-import { AxiosError, AxiosResponse } from 'axios';
-import { Option } from 'container/PlannedDowntime/PlannedDowntimeutils';
-
-export type Recurrence = {
-	startTime?: string | null;
-	endTime?: string | null;
-	duration?: number | string | null;
-	repeatType?: string | Option | null;
-	repeatOn?: string[] | null;
-};
-
-type Schedule = {
-	timezone: string | null;
-	startTime: string | null;
-	endTime: string | null;
-	recurrence: Recurrence | null;
-};
-
-export interface DowntimeSchedules {
-	id: number;
-	name: string | null;
-	description: string | null;
-	schedule: Schedule | null;
-	alertIds: string[] | null;
-	createdAt: string | null;
-	createdBy: string | null;
-	updatedAt: string | null;
-	updatedBy: string | null;
-	kind: string | null;
-}
-export type PayloadProps = { data: DowntimeSchedules[] };
-
-export const getAllDowntimeSchedules = async (
-	props?: GetAllDowntimeSchedulesPayloadProps,
-): Promise<AxiosResponse<PayloadProps>> =>
-	axios.get('/downtime_schedules', { params: props });
-
-export interface GetAllDowntimeSchedulesPayloadProps {
-	active?: boolean;
-	recurrence?: boolean;
-}
-
-export const useGetAllDowntimeSchedules = (
-	props?: GetAllDowntimeSchedulesPayloadProps,
-): UseQueryResult<AxiosResponse<PayloadProps>, AxiosError> =>
-	useQuery<AxiosResponse<PayloadProps>, AxiosError>({
-		queryKey: ['getAllDowntimeSchedules', props],
-		queryFn: () => getAllDowntimeSchedules(props),
-	});

frontend/src/api/plannedDowntime/updateDowntimeSchedule.ts

@@ -1,37 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-
-import { DowntimeSchedulePayload } from './createDowntimeSchedule';
-
-export interface DowntimeScheduleUpdatePayload {
-	data: DowntimeSchedulePayload;
-	id?: number;
-}
-
-export interface PayloadProps {
-	status: string;
-	data: string;
-}
-
-const updateDowntimeSchedule = async (
-	props: DowntimeScheduleUpdatePayload,
-): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {
-	try {
-		const response = await axios.put(`/downtime_schedules/${props.id}`, {
-			...props.data,
-		});
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: response.data.status,
-			payload: response.data.data,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};
-
-export default updateDowntimeSchedule;

frontend/src/constants/alerts.ts

@@ -1,3 +1,4 @@
+import { RuletypesAlertTypeDTO } from 'api/generated/services/sigNoz.schemas';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
 import { DataSource } from 'types/common/queryBuilder';
 
@@ -8,3 +9,17 @@ export const ALERTS_DATA_SOURCE_MAP: Record<AlertTypes, DataSource> = {
 	[AlertTypes.TRACES_BASED_ALERT]: DataSource.TRACES,
 	[AlertTypes.EXCEPTIONS_BASED_ALERT]: DataSource.TRACES,
 };
+
+export function dataSourceForAlertType(
+	alertType: RuletypesAlertTypeDTO | undefined,
+): DataSource {
+	switch (alertType) {
+		case RuletypesAlertTypeDTO.LOGS_BASED_ALERT:
+			return DataSource.LOGS;
+		case RuletypesAlertTypeDTO.TRACES_BASED_ALERT:
+		case RuletypesAlertTypeDTO.EXCEPTIONS_BASED_ALERT:
+			return DataSource.TRACES;
+		default:
+			return DataSource.METRICS;
+	}
+}

frontend/src/container/CreateAlertV2/CreateAlertHeader/__tests__/CreateAlertHeader.test.tsx

@@ -6,9 +6,7 @@ import { getCreateAlertLocalStateFromAlertDef } from 'container/CreateAlertV2/ut
 import * as useSafeNavigateHook from 'hooks/useSafeNavigate';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
 
-import * as useCreateAlertRuleHook from '../../../../hooks/alerts/useCreateAlertRule';
-import * as useTestAlertRuleHook from '../../../../hooks/alerts/useTestAlertRule';
-import * as useUpdateAlertRuleHook from '../../../../hooks/alerts/useUpdateAlertRule';
+import * as rulesHook from '../../../../api/generated/services/rules';
 import { CreateAlertProvider } from '../../context';
 import CreateAlertHeader from '../CreateAlertHeader';
 
@@ -17,15 +15,15 @@ jest.spyOn(useSafeNavigateHook, 'useSafeNavigate').mockReturnValue({
 	safeNavigate: mockSafeNavigate,
 });
 
-jest.spyOn(useCreateAlertRuleHook, 'useCreateAlertRule').mockReturnValue({
+jest.spyOn(rulesHook, 'useCreateRule').mockReturnValue({
 	mutate: jest.fn(),
 	isLoading: false,
 } as any);
-jest.spyOn(useTestAlertRuleHook, 'useTestAlertRule').mockReturnValue({
+jest.spyOn(rulesHook, 'useTestRule').mockReturnValue({
 	mutate: jest.fn(),
 	isLoading: false,
 } as any);
-jest.spyOn(useUpdateAlertRuleHook, 'useUpdateAlertRule').mockReturnValue({
+jest.spyOn(rulesHook, 'useUpdateRuleByID').mockReturnValue({
 	mutate: jest.fn(),
 	isLoading: false,
 } as any);

frontend/src/container/CreateAlertV2/EvaluationSettings/__tests__/testUtils.ts

@@ -34,6 +34,7 @@ export const createMockAlertContextState = (
 	isUpdatingAlertRule: false,
 	updateAlertRule: jest.fn(),
 	isEditMode: false,
+	ruleId: '',
 	...overrides,
 });
 

frontend/src/container/CreateAlertV2/Footer/Footer.tsx

@@ -1,9 +1,15 @@
 import { useCallback, useMemo } from 'react';
 import { toast } from '@signozhq/ui';
 import { Button, Tooltip, Typography } from 'antd';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import type { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import { Check, Loader, Send, X } from 'lucide-react';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import { toPostableRuleDTO } from 'types/api/alerts/convert';
+import APIError from 'types/api/error';
 import { isModifierKeyPressed } from 'utils/app';
 
 import { useCreateAlertState } from '../context';
@@ -30,9 +36,20 @@ function Footer(): JSX.Element {
 		updateAlertRule,
 		isUpdatingAlertRule,
 		isEditMode,
+		ruleId,
 	} = useCreateAlertState();
 	const { currentQuery } = useQueryBuilder();
 	const { safeNavigate } = useSafeNavigate();
+	const { showErrorModal } = useErrorModal();
+
+	const handleApiError = useCallback(
+		(error: unknown): void => {
+			showErrorModal(
+				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
+			);
+		},
+		[showErrorModal],
+	);
 
 	const handleDiscard = (e: React.MouseEvent): void => {
 		discardAlertRule();
@@ -71,20 +88,21 @@ function Footer(): JSX.Element {
 			notificationSettings,
 			query: currentQuery,
 		});
-		testAlertRule(payload, {
-			onSuccess: (response) => {
-				if (response.payload?.data?.alertCount === 0) {
-					toast.error(
-						'No alerts found during the evaluation. This happens when rule condition is unsatisfied. You may adjust the rule threshold and retry.',
-					);
-					return;
-				}
-				toast.success('Test notification sent successfully');
+		testAlertRule(
+			{ data: toPostableRuleDTO(payload) },
+			{
+				onSuccess: (response) => {
+					if (response.data?.alertCount === 0) {
+						toast.error(
+							'No alerts found during the evaluation. This happens when rule condition is unsatisfied. You may adjust the rule threshold and retry.',
+						);
+						return;
+					}
+					toast.success('Test notification sent successfully');
+				},
+				onError: handleApiError,
 			},
-			onError: (error) => {
-				toast.error(error.message);
-			},
-		});
+		);
 	}, [
 		alertType,
 		basicAlertState,
@@ -107,25 +125,30 @@ function Footer(): JSX.Element {
 			query: currentQuery,
 		});
 		if (isEditMode) {
-			updateAlertRule(payload, {
-				onSuccess: () => {
-					toast.success('Alert rule updated successfully');
-					safeNavigate('/alerts');
+			updateAlertRule(
+				{
+					pathParams: { id: ruleId },
+					data: toPostableRuleDTO(payload),
 				},
-				onError: (error) => {
-					toast.error(error.message);
+				{
+					onSuccess: () => {
+						toast.success('Alert rule updated successfully');
+						safeNavigate('/alerts');
+					},
+					onError: handleApiError,
 				},
-			});
+			);
 		} else {
-			createAlertRule(payload, {
-				onSuccess: () => {
-					toast.success('Alert rule created successfully');
-					safeNavigate('/alerts');
+			createAlertRule(
+				{ data: toPostableRuleDTO(payload) },
+				{
+					onSuccess: () => {
+						toast.success('Alert rule created successfully');
+						safeNavigate('/alerts');
+					},
+					onError: handleApiError,
 				},
-				onError: (error) => {
-					toast.error(error.message);
-				},
-			});
+			);
 		}
 	}, [
 		alertType,
@@ -136,9 +159,11 @@ function Footer(): JSX.Element {
 		notificationSettings,
 		currentQuery,
 		isEditMode,
+		ruleId,
 		updateAlertRule,
 		createAlertRule,
 		safeNavigate,
+		handleApiError,
 	]);
 
 	const disableButtons =

frontend/src/container/CreateAlertV2/Footer/__tests__/Footer.test.tsx

@@ -12,6 +12,11 @@ import Footer from '../Footer';
 jest.mock('hooks/queryBuilder/useQueryBuilder', () => ({
 	useQueryBuilder: jest.fn(),
 }));
+jest.mock('providers/ErrorModalProvider', () => ({
+	useErrorModal: (): { showErrorModal: jest.Mock } => ({
+		showErrorModal: jest.fn(),
+	}),
+}));
 
 jest.mock('hooks/useSafeNavigate', () => ({
 	useSafeNavigate: jest.fn(),

frontend/src/container/CreateAlertV2/context/index.tsx

@@ -10,11 +10,13 @@ import {
 	useState,
 } from 'react';
 import { useLocation } from 'react-router-dom';
+import {
+	useCreateRule,
+	useTestRule,
+	useUpdateRuleByID,
+} from 'api/generated/services/rules';
 import { QueryParams } from 'constants/query';
 import { AlertDetectionTypes } from 'container/FormAlertRules';
-import { useCreateAlertRule } from 'hooks/alerts/useCreateAlertRule';
-import { useTestAlertRule } from 'hooks/alerts/useTestAlertRule';
-import { useUpdateAlertRule } from 'hooks/alerts/useUpdateAlertRule';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
@@ -215,17 +217,14 @@ export function CreateAlertProvider(
 	const {
 		mutate: createAlertRule,
 		isLoading: isCreatingAlertRule,
-	} = useCreateAlertRule();
+	} = useCreateRule();
 
-	const {
-		mutate: testAlertRule,
-		isLoading: isTestingAlertRule,
-	} = useTestAlertRule();
+	const { mutate: testAlertRule, isLoading: isTestingAlertRule } = useTestRule();
 
 	const {
 		mutate: updateAlertRule,
 		isLoading: isUpdatingAlertRule,
-	} = useUpdateAlertRule(ruleId || '');
+	} = useUpdateRuleByID();
 
 	const contextValue: ICreateAlertContextProps = useMemo(
 		() => ({
@@ -249,6 +248,7 @@ export function CreateAlertProvider(
 			updateAlertRule,
 			isUpdatingAlertRule,
 			isEditMode: isEditMode || false,
+			ruleId: ruleId || '',
 		}),
 		[
 			createAlertState,
@@ -267,6 +267,7 @@ export function CreateAlertProvider(
 			updateAlertRule,
 			isUpdatingAlertRule,
 			isEditMode,
+			ruleId,
 		],
 	);
 

frontend/src/container/CreateAlertV2/context/types.ts

@@ -1,12 +1,15 @@
 import { Dispatch } from 'react';
 import { UseMutateFunction } from 'react-query';
-import { CreateAlertRuleResponse } from 'api/alerts/createAlertRule';
-import { TestAlertRuleResponse } from 'api/alerts/testAlertRule';
-import { UpdateAlertRuleResponse } from 'api/alerts/updateAlertRule';
+import type {
+	CreateRule201,
+	RenderErrorResponseDTO,
+	RuletypesPostableRuleDTO,
+	TestRule200,
+	UpdateRuleByIDPathParameters,
+} from 'api/generated/services/sigNoz.schemas';
+import type { BodyType, ErrorType } from 'api/generatedAPIInstance';
 import { Dayjs } from 'dayjs';
-import { ErrorResponse, SuccessResponse } from 'types/api';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
-import { PostableAlertRuleV2 } from 'types/api/alerts/alertTypesV2';
 import { Labels } from 'types/api/alerts/def';
 
 export interface ICreateAlertContextProps {
@@ -24,27 +27,33 @@ export interface ICreateAlertContextProps {
 	setNotificationSettings: Dispatch<NotificationSettingsAction>;
 	isCreatingAlertRule: boolean;
 	createAlertRule: UseMutateFunction<
-		SuccessResponse<CreateAlertRuleResponse, unknown> | ErrorResponse,
-		Error,
-		PostableAlertRuleV2,
+		CreateRule201,
+		ErrorType<unknown>,
+		{ data: BodyType<RuletypesPostableRuleDTO> },
 		unknown
 	>;
 	isTestingAlertRule: boolean;
 	testAlertRule: UseMutateFunction<
-		SuccessResponse<TestAlertRuleResponse, unknown> | ErrorResponse,
-		Error,
-		PostableAlertRuleV2,
+		TestRule200,
+		ErrorType<unknown>,
+		{ data: BodyType<RuletypesPostableRuleDTO> },
 		unknown
 	>;
 	discardAlertRule: () => void;
 	isUpdatingAlertRule: boolean;
 	updateAlertRule: UseMutateFunction<
-		SuccessResponse<UpdateAlertRuleResponse, unknown> | ErrorResponse,
-		Error,
-		PostableAlertRuleV2,
+		Awaited<
+			ReturnType<typeof import('api/generated/services/rules').updateRuleByID>
+		>,
+		ErrorType<RenderErrorResponseDTO>,
+		{
+			pathParams: UpdateRuleByIDPathParameters;
+			data: BodyType<RuletypesPostableRuleDTO>;
+		},
 		unknown
 	>;
 	isEditMode: boolean;
+	ruleId: string;
 }
 
 export interface ICreateAlertProviderProps {

frontend/src/container/EditAlertV2/utils.tsx

@@ -1,15 +1,14 @@
-import { ALERTS_DATA_SOURCE_MAP } from 'constants/alerts';
+import { RuletypesAlertTypeDTO } from 'api/generated/services/sigNoz.schemas';
+import { dataSourceForAlertType } from 'constants/alerts';
 import { initialQueryBuilderFormValuesMap } from 'constants/queryBuilder';
-import { AlertTypes } from 'types/api/alerts/alertTypes';
 import { Query } from 'types/api/queryBuilder/queryBuilderData';
 
 export function sanitizeDefaultAlertQuery(
 	query: Query,
-	alertType: AlertTypes,
+	alertType: RuletypesAlertTypeDTO | undefined,
 ): Query {
-	// If there are no queries, add a default one based on the alert type
 	if (query.builder.queryData.length === 0) {
-		const dataSource = ALERTS_DATA_SOURCE_MAP[alertType];
+		const dataSource = dataSourceForAlertType(alertType);
 		query.builder.queryData.push(initialQueryBuilderFormValuesMap[dataSource]);
 	}
 	return query;

frontend/src/container/FormAlertRules/index.tsx

@@ -6,9 +6,15 @@ import { useSelector } from 'react-redux';
 import { useLocation } from 'react-router-dom';
 import { ExclamationCircleOutlined, SaveOutlined } from '@ant-design/icons';
 import { Button, FormInstance, Modal, SelectProps, Typography } from 'antd';
-import saveAlertApi from 'api/alerts/save';
-import testAlertApi from 'api/alerts/testAlert';
 import logEvent from 'api/common/logEvent';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import {
+	createRule,
+	testRule,
+	updateRuleByID,
+} from 'api/generated/services/rules';
+import type { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
 import { getInvolvedQueriesInTraceOperator } from 'components/QueryBuilderV2/QueryV2/TraceOperator/utils/utils';
 import YAxisUnitSelector from 'components/YAxisUnitSelector';
 import { YAxisSource } from 'components/YAxisUnitSelector/types';
@@ -32,13 +38,16 @@ import { isEmpty, isEqual } from 'lodash-es';
 import { BellDot, ExternalLink } from 'lucide-react';
 import Tabs2 from 'periscope/components/Tabs2';
 import { useAppContext } from 'providers/App/App';
+import { useErrorModal } from 'providers/ErrorModalProvider';
 import { AppState } from 'store/reducers';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
+import { toPostableRuleDTOFromAlertDef } from 'types/api/alerts/convert';
 import {
 	AlertDef,
 	defaultEvalWindow,
 	defaultMatchType,
 } from 'types/api/alerts/def';
+import APIError from 'types/api/error';
 import { IBuilderQuery, Query } from 'types/api/queryBuilder/queryBuilderData';
 import { QueryFunction } from 'types/api/v5/queryRange';
 import { EQueryType } from 'types/common/dashboard';
@@ -368,6 +377,7 @@ function FormAlertRules({
 		redirectWithQueryBuilderData(query);
 	};
 	const { notifications } = useNotifications();
+	const { showErrorModal } = useErrorModal();
 
 	const validatePromParams = useCallback((): boolean => {
 		let retval = true;
@@ -533,59 +543,47 @@ function FormAlertRules({
 		};
 
 		try {
-			const apiReq =
-				ruleId && !isEmpty(ruleId)
-					? { data: postableAlert, id: ruleId }
-					: { data: postableAlert };
-
-			const response = await saveAlertApi(apiReq);
-
-			if (response.statusCode === 200) {
-				logData = {
-					status: 'success',
-					statusMessage: isNewRule ? t('rule_created') : t('rule_edited'),
-				};
-
-				notifications.success({
-					message: 'Success',
-					description: logData.statusMessage,
-				});
-
-				// invalidate rule in cache
-				ruleCache.invalidateQueries([
-					REACT_QUERY_KEY.ALERT_RULE_DETAILS,
-					`${ruleId}`,
-				]);
-
-				// eslint-disable-next-line sonarjs/no-identical-functions
-				setTimeout(() => {
-					urlQuery.delete(QueryParams.compositeQuery);
-					urlQuery.delete(QueryParams.panelTypes);
-					urlQuery.delete(QueryParams.ruleId);
-					urlQuery.delete(QueryParams.relativeTime);
-					safeNavigate(`${ROUTES.LIST_ALL_ALERT}?${urlQuery.toString()}`);
-				}, 2000);
+			if (ruleId && !isEmpty(ruleId)) {
+				await updateRuleByID(
+					{ id: ruleId },
+					toPostableRuleDTOFromAlertDef(postableAlert),
+				);
 			} else {
-				logData = {
-					status: 'error',
-					statusMessage: response.error || t('unexpected_error'),
-				};
-
-				notifications.error({
-					message: 'Error',
-					description: logData.statusMessage,
-				});
+				await createRule(toPostableRuleDTOFromAlertDef(postableAlert));
 			}
-		} catch (e) {
+
 			logData = {
-				status: 'error',
-				statusMessage: t('unexpected_error'),
+				status: 'success',
+				statusMessage: isNewRule ? t('rule_created') : t('rule_edited'),
 			};
 
-			notifications.error({
-				message: 'Error',
+			notifications.success({
+				message: 'Success',
 				description: logData.statusMessage,
 			});
+
+			// invalidate rule in cache
+			ruleCache.invalidateQueries([
+				REACT_QUERY_KEY.ALERT_RULE_DETAILS,
+				`${ruleId}`,
+			]);
+
+			// eslint-disable-next-line sonarjs/no-identical-functions
+			setTimeout(() => {
+				urlQuery.delete(QueryParams.compositeQuery);
+				urlQuery.delete(QueryParams.panelTypes);
+				urlQuery.delete(QueryParams.ruleId);
+				urlQuery.delete(QueryParams.relativeTime);
+				safeNavigate(`${ROUTES.LIST_ALL_ALERT}?${urlQuery.toString()}`);
+			}, 2000);
+		} catch (e) {
+			const apiError = convertToApiError(e as AxiosError<RenderErrorResponseDTO>);
+			logData = {
+				status: 'error',
+				statusMessage: apiError?.getErrorMessage() || t('unexpected_error'),
+			};
+
+			showErrorModal(apiError as APIError);
 		}
 
 		setLoading(false);
@@ -641,39 +639,30 @@ function FormAlertRules({
 		let statusResponse = { status: 'failed', message: '' };
 		setLoading(true);
 		try {
-			const response = await testAlertApi({ data: postableAlert });
+			const response = await testRule(
+				toPostableRuleDTOFromAlertDef(postableAlert),
+			);
 
-			if (response.statusCode === 200) {
-				const { payload } = response;
-				if (payload?.alertCount === 0) {
-					notifications.error({
-						message: 'Error',
-						description: t('no_alerts_found'),
-					});
-					statusResponse = { status: 'failed', message: t('no_alerts_found') };
-				} else {
-					notifications.success({
-						message: 'Success',
-						description: t('rule_test_fired'),
-					});
-					statusResponse = { status: 'success', message: t('rule_test_fired') };
-				}
-			} else {
+			if (response.data?.alertCount === 0) {
 				notifications.error({
 					message: 'Error',
-					description: response.error || t('unexpected_error'),
+					description: t('no_alerts_found'),
 				});
-				statusResponse = {
-					status: 'failed',
-					message: response.error || t('unexpected_error'),
-				};
+				statusResponse = { status: 'failed', message: t('no_alerts_found') };
+			} else {
+				notifications.success({
+					message: 'Success',
+					description: t('rule_test_fired'),
+				});
+				statusResponse = { status: 'success', message: t('rule_test_fired') };
 			}
 		} catch (e) {
-			notifications.error({
-				message: 'Error',
-				description: t('unexpected_error'),
-			});
-			statusResponse = { status: 'failed', message: t('unexpected_error') };
+			const apiError = convertToApiError(e as AxiosError<RenderErrorResponseDTO>);
+			statusResponse = {
+				status: 'failed',
+				message: apiError?.getErrorMessage() || t('unexpected_error'),
+			};
+			showErrorModal(apiError as APIError);
 		}
 		setLoading(false);
 		logEvent('Alert: Test notification', {

frontend/src/container/Home/AlertRules/AlertRules.tsx

@@ -1,9 +1,9 @@
 import { useEffect, useState } from 'react';
-import { useQuery } from 'react-query';
 import { Link, useLocation } from 'react-router-dom';
 import { Button, Skeleton, Tag } from 'antd';
-import getAll from 'api/alerts/getAll';
 import logEvent from 'api/common/logEvent';
+import { useListRules } from 'api/generated/services/rules';
+import type { RuletypesRuleDTO } from 'api/generated/services/sigNoz.schemas';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
 import history from 'lib/history';
@@ -11,7 +11,7 @@ import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/map
 import { ArrowRight, ArrowUpRight, Plus } from 'lucide-react';
 import Card from 'periscope/components/Card/Card';
 import { useAppContext } from 'providers/App/App';
-import { GettableAlert } from 'types/api/alerts/get';
+import { toCompositeMetricQuery } from 'types/api/alerts/convert';
 import { USER_ROLES } from 'types/roles';
 
 import beaconUrl from '@/assets/Icons/beacon.svg';
@@ -28,22 +28,23 @@ export default function AlertRules({
 	const { user } = useAppContext();
 	const [rulesExist, setRulesExist] = useState(false);
 
-	const [sortedAlertRules, setSortedAlertRules] = useState<GettableAlert[]>([]);
+	const [sortedAlertRules, setSortedAlertRules] = useState<RuletypesRuleDTO[]>(
+		[],
+	);
 
 	const location = useLocation();
 	const params = new URLSearchParams(location.search);
 
 	// Fetch Alerts
-	const { data: alerts, isError, isLoading } = useQuery('allAlerts', {
-		queryFn: getAll,
-		cacheTime: 0,
+	const { data: alerts, isError, isLoading } = useListRules({
+		query: { cacheTime: 0 },
 	});
 
 	useEffect(() => {
-		const rules = alerts?.payload || [];
+		const rules = alerts?.data ?? [];
 		setRulesExist(rules.length > 0);
 
-		const sortedRules = rules.sort((a, b) => {
+		const sortedRules = [...rules].sort((a, b) => {
 			// First, prioritize firing alerts
 			if (a.state === 'firing' && b.state !== 'firing') {
 				return -1;
@@ -52,10 +53,10 @@ export default function AlertRules({
 				return 1;
 			}
 
-			// Then sort by updateAt timestamp
-			const aUpdateAt = new Date(a.updateAt).getTime();
-			const bUpdateAt = new Date(b.updateAt).getTime();
-			return bUpdateAt - aUpdateAt;
+			// Then sort by updatedAt timestamp
+			return (
+				new Date(b.updatedAt ?? 0).getTime() - new Date(a.updatedAt ?? 0).getTime()
+			);
 		});
 
 		if (sortedRules.length > 0 && !loadingUserPreferences) {
@@ -118,22 +119,27 @@ export default function AlertRules({
 		</div>
 	);
 
-	const onEditHandler = (record: GettableAlert) => (): void => {
+	const onEditHandler = (record: RuletypesRuleDTO) => (): void => {
 		logEvent('Homepage: Alert clicked', {
 			ruleId: record.id,
 			ruleName: record.alert,
 			ruleState: record.state,
 		});
 
-		const compositeQuery = mapQueryDataFromApi(record.condition.compositeQuery);
+		const compositeQuery = mapQueryDataFromApi(
+			toCompositeMetricQuery(record.condition.compositeQuery),
+		);
 		params.set(
 			QueryParams.compositeQuery,
 			encodeURIComponent(JSON.stringify(compositeQuery)),
 		);
 
-		params.set(QueryParams.panelTypes, record.condition.compositeQuery.panelType);
+		const panelType = record.condition.compositeQuery.panelType;
+		if (panelType) {
+			params.set(QueryParams.panelTypes, panelType);
+		}
 
-		params.set(QueryParams.ruleId, record.id.toString());
+		params.set(QueryParams.ruleId, record.id);
 
 		history.push(`${ROUTES.ALERT_OVERVIEW}?${params.toString()}`);
 	};
@@ -169,9 +175,9 @@ export default function AlertRules({
 						<div className="alert-rule-item-description home-data-item-tag">
 							<Tag color={rule?.labels?.severity}>{rule?.labels?.severity}</Tag>
 
-							{rule?.state === 'firing' && (
+							{rule.state === 'firing' && (
 								<Tag color="red" className="firing-tag">
-									{rule?.state}
+									{rule.state}
 								</Tag>
 							)}
 						</div>

frontend/src/container/ListAlertRules/DeleteAlert.tsx

@@ -1,9 +1,16 @@
 import { Dispatch, SetStateAction, useState } from 'react';
 import type { NotificationInstance } from 'antd/es/notification/interface';
-import deleteAlerts from 'api/alerts/delete';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import { deleteRuleByID } from 'api/generated/services/rules';
+import type {
+	RenderErrorResponseDTO,
+	RuletypesRuleDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
 import { State } from 'hooks/useFetch';
+import { useErrorModal } from 'providers/ErrorModalProvider';
 import { PayloadProps as DeleteAlertPayloadProps } from 'types/api/alerts/delete';
-import { GettableAlert } from 'types/api/alerts/get';
+import APIError from 'types/api/error';
 
 import { ColumnButton } from './styles';
 
@@ -22,48 +29,31 @@ function DeleteAlert({
 		payload: undefined,
 	});
 
-	const defaultErrorMessage = 'Something went wrong';
+	const { showErrorModal } = useErrorModal();
 
 	const onDeleteHandler = async (id: string): Promise<void> => {
 		try {
-			const response = await deleteAlerts({
-				id,
+			await deleteRuleByID({ id });
+
+			setData((state) => state.filter((alert) => alert.id !== id));
+
+			setDeleteAlertState((state) => ({
+				...state,
+				loading: false,
+			}));
+			notifications.success({
+				message: 'Success',
 			});
-
-			if (response.statusCode === 200) {
-				setData((state) => state.filter((alert) => alert.id !== id));
-
-				setDeleteAlertState((state) => ({
-					...state,
-					loading: false,
-					payload: response.payload,
-				}));
-				notifications.success({
-					message: 'Success',
-				});
-			} else {
-				setDeleteAlertState((state) => ({
-					...state,
-					loading: false,
-					error: true,
-					errorMessage: response.error || defaultErrorMessage,
-				}));
-
-				notifications.error({
-					message: response.error || defaultErrorMessage,
-				});
-			}
 		} catch (error) {
 			setDeleteAlertState((state) => ({
 				...state,
 				loading: false,
 				error: true,
-				errorMessage: defaultErrorMessage,
 			}));
 
-			notifications.error({
-				message: defaultErrorMessage,
-			});
+			showErrorModal(
+				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
+			);
 		}
 	};
 
@@ -88,8 +78,8 @@ function DeleteAlert({
 }
 
 interface DeleteAlertProps {
-	id: GettableAlert['id'];
-	setData: Dispatch<SetStateAction<GettableAlert[]>>;
+	id: string;
+	setData: Dispatch<SetStateAction<RuletypesRuleDTO[]>>;
 	notifications: NotificationInstance;
 }
 

frontend/src/container/ListAlertRules/ListAlert.tsx

@@ -4,8 +4,16 @@ import { UseQueryResult } from 'react-query';
 import { PlusOutlined } from '@ant-design/icons';
 import { Button, Flex, Input, Typography } from 'antd';
 import type { ColumnsType } from 'antd/es/table/interface';
-import saveAlertApi from 'api/alerts/save';
 import logEvent from 'api/common/logEvent';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import { createRule } from 'api/generated/services/rules';
+import type {
+	ListRules200,
+	RenderErrorResponseDTO,
+	RuletypesRuleDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type { ErrorType } from 'api/generatedAPIInstance';
+import { AxiosError } from 'axios';
 import DropDown from 'components/DropDown/DropDown';
 import {
 	DynamicColumnsKey,
@@ -27,9 +35,9 @@ import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi';
 import { useAppContext } from 'providers/App/App';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { AlertTypes } from 'types/api/alerts/alertTypes';
-import { GettableAlert } from 'types/api/alerts/get';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import { toCompositeMetricQuery } from 'types/api/alerts/convert';
+import APIError from 'types/api/error';
 import { isModifierKeyPressed } from 'utils/app';
 
 import DeleteAlert from './DeleteAlert';
@@ -58,7 +66,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 	const paginationParam = params.get('page');
 	const searchParams = params.get('search');
 	const [searchString, setSearchString] = useState<string>(searchParams || '');
-	const [data, setData] = useState<GettableAlert[]>(() => {
+	const [data, setData] = useState<RuletypesRuleDTO[]>(() => {
 		const value = searchString.toLowerCase();
 		const filteredData = filterAlerts(allAlertRules, value);
 		return filteredData || [];
@@ -70,7 +78,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 			? orderQueryParam
 			: null;
 
-	const { sortedInfo, handleChange } = useSortableTable<GettableAlert>(
+	const { sortedInfo, handleChange } = useSortableTable<RuletypesRuleDTO>(
 		sortingOrder,
 		orderColumnParam || '',
 		searchString,
@@ -83,7 +91,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 			const { data: refetchData, status } = await refetch();
 			if (status === 'success') {
 				const value = searchString.toLowerCase();
-				const filteredData = filterAlerts(refetchData.payload || [], value);
+				const filteredData = filterAlerts(refetchData?.data ?? [], value);
 				setData(filteredData || []);
 			}
 			if (status === 'error') {
@@ -94,11 +102,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 		})();
 	}, 30000);
 
-	const handleError = useCallback((): void => {
-		notificationsApi.error({
-			message: t('something_went_wrong'),
-		});
-	}, [notificationsApi, t]);
+	const { showErrorModal } = useErrorModal();
 
 	const onClickNewAlertHandler = useCallback(
 		(e: React.MouseEvent): void => {
@@ -115,21 +119,24 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 	);
 
 	const onEditHandler = (
-		record: GettableAlert,
+		record: RuletypesRuleDTO,
 		options?: { newTab?: boolean },
 	): void => {
 		const compositeQuery = sanitizeDefaultAlertQuery(
-			mapQueryDataFromApi(record.condition.compositeQuery),
-			record.alertType as AlertTypes,
+			mapQueryDataFromApi(toCompositeMetricQuery(record.condition.compositeQuery)),
+			record.alertType,
 		);
 		params.set(
 			QueryParams.compositeQuery,
 			encodeURIComponent(JSON.stringify(compositeQuery)),
 		);
 
-		params.set(QueryParams.panelTypes, record.condition.compositeQuery.panelType);
+		const panelType = record.condition.compositeQuery.panelType;
+		if (panelType) {
+			params.set(QueryParams.panelTypes, panelType);
+		}
 
-		params.set(QueryParams.ruleId, record.id.toString());
+		params.set(QueryParams.ruleId, record.id);
 
 		setEditLoader(false);
 
@@ -139,47 +146,41 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 	};
 
 	const onCloneHandler = (
-		originalAlert: GettableAlert,
+		originalAlert: RuletypesRuleDTO,
 	) => async (): Promise<void> => {
-		const copyAlert = {
+		const copyAlert: RuletypesRuleDTO = {
 			...originalAlert,
-			alert: originalAlert.alert.concat(' - Copy'),
+			alert: `${originalAlert.alert} - Copy`,
 		};
-		const apiReq = { data: copyAlert };
 
 		try {
 			setCloneLoader(true);
-			const response = await saveAlertApi(apiReq);
+			await createRule(copyAlert);
 
-			if (response.statusCode === 200) {
-				notificationsApi.success({
-					message: 'Success',
-					description: 'Alert cloned successfully',
-				});
+			notificationsApi.success({
+				message: 'Success',
+				description: 'Alert cloned successfully',
+			});
 
-				const { data: refetchData, status } = await refetch();
-				if (status === 'success' && refetchData.payload) {
-					setData(refetchData.payload || []);
-					setTimeout(() => {
-						const clonedAlert = refetchData.payload[refetchData.payload.length - 1];
-						params.set(QueryParams.ruleId, String(clonedAlert.id));
-						safeNavigate(`${ROUTES.EDIT_ALERTS}?${params.toString()}`);
-					}, 2000);
-				}
-				if (status === 'error') {
-					notificationsApi.error({
-						message: t('something_went_wrong'),
-					});
-				}
-			} else {
+			const { data: refetchData, status } = await refetch();
+			const rules = refetchData?.data;
+			if (status === 'success' && rules) {
+				setData(rules);
+				setTimeout(() => {
+					const clonedAlert = rules[rules.length - 1];
+					params.set(QueryParams.ruleId, String(clonedAlert.id));
+					safeNavigate(`${ROUTES.EDIT_ALERTS}?${params.toString()}`);
+				}, 2000);
+			}
+			if (status === 'error') {
 				notificationsApi.error({
-					message: 'Error',
-					description: response.error || t('something_went_wrong'),
+					message: t('something_went_wrong'),
 				});
 			}
 		} catch (error) {
-			handleError();
-			console.error(error);
+			showErrorModal(
+				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
+			);
 		} finally {
 			setCloneLoader(false);
 		}
@@ -192,16 +193,16 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 		setData(filteredData);
 	});
 
-	const dynamicColumns: ColumnsType<GettableAlert> = [
+	const dynamicColumns: ColumnsType<RuletypesRuleDTO> = [
 		{
 			title: 'Created At',
-			dataIndex: 'createAt',
+			dataIndex: 'createdAt',
 			width: 80,
 			key: DynamicColumnsKey.CreatedAt,
 			align: 'center',
-			sorter: (a: GettableAlert, b: GettableAlert): number => {
-				const prev = new Date(a.createAt).getTime();
-				const next = new Date(b.createAt).getTime();
+			sorter: (a: RuletypesRuleDTO, b: RuletypesRuleDTO): number => {
+				const prev = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+				const next = b.createdAt ? new Date(b.createdAt).getTime() : 0;
 
 				return prev - next;
 			},
@@ -213,20 +214,20 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 		},
 		{
 			title: 'Created By',
-			dataIndex: 'createBy',
+			dataIndex: 'createdBy',
 			width: 80,
 			key: DynamicColumnsKey.CreatedBy,
 			align: 'center',
 		},
 		{
 			title: 'Updated At',
-			dataIndex: 'updateAt',
+			dataIndex: 'updatedAt',
 			width: 80,
 			key: DynamicColumnsKey.UpdatedAt,
 			align: 'center',
-			sorter: (a: GettableAlert, b: GettableAlert): number => {
-				const prev = new Date(a.updateAt).getTime();
-				const next = new Date(b.updateAt).getTime();
+			sorter: (a: RuletypesRuleDTO, b: RuletypesRuleDTO): number => {
+				const prev = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+				const next = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
 
 				return prev - next;
 			},
@@ -238,14 +239,14 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 		},
 		{
 			title: 'Updated By',
-			dataIndex: 'updateBy',
+			dataIndex: 'updatedBy',
 			width: 80,
 			key: DynamicColumnsKey.UpdatedBy,
 			align: 'center',
 		},
 	];
 
-	const columns: ColumnsType<GettableAlert> = [
+	const columns: ColumnsType<RuletypesRuleDTO> = [
 		{
 			title: 'Status',
 			dataIndex: 'state',
@@ -322,7 +323,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 			dataIndex: 'id',
 			key: 'action',
 			width: 10,
-			render: (id: GettableAlert['id'], record): JSX.Element => (
+			render: (id: RuletypesRuleDTO['id'], record): JSX.Element => (
 				<div data-testid="alert-actions">
 					<DropDown
 						onDropDownItemClick={(item): void =>
@@ -331,9 +332,9 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 						element={[
 							<ToggleAlertState
 								key="1"
-								disabled={record.disabled}
+								disabled={record.disabled ?? false}
 								setData={setData}
-								id={id}
+								id={id ?? ''}
 							/>,
 							<ColumnButton
 								key="2"
@@ -365,7 +366,7 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 								key="4"
 								notifications={notificationsApi}
 								setData={setData}
-								id={id}
+								id={id ?? ''}
 							/>,
 						]}
 					/>
@@ -420,9 +421,10 @@ function ListAlert({ allAlertRules, refetch }: ListAlertProps): JSX.Element {
 }
 
 interface ListAlertProps {
-	allAlertRules: GettableAlert[];
+	allAlertRules: RuletypesRuleDTO[];
 	refetch: UseQueryResult<
-		ErrorResponse | SuccessResponse<GettableAlert[]>
+		ListRules200,
+		ErrorType<RenderErrorResponseDTO>
 	>['refetch'];
 }
 

frontend/src/container/ListAlertRules/TableComponents/Status.tsx

@@ -1,5 +1,5 @@
 import { Tag } from 'antd';
-import { GettableAlert } from 'types/api/alerts/get';
+import type { RuletypesRuleDTO } from 'api/generated/services/sigNoz.schemas';
 
 function Status({ status }: StatusProps): JSX.Element {
 	switch (status) {
@@ -26,7 +26,7 @@ function Status({ status }: StatusProps): JSX.Element {
 }
 
 interface StatusProps {
-	status: GettableAlert['state'];
+	status: RuletypesRuleDTO['state'];
 }
 
 export default Status;

frontend/src/container/ListAlertRules/ToggleAlertState.tsx

@@ -1,9 +1,15 @@
 import { Dispatch, SetStateAction, useState } from 'react';
-import patchAlert from 'api/alerts/patch';
+import { patchRulePartial } from 'api/alerts/patchRulePartial';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import type {
+	RenderErrorResponseDTO,
+	RuletypesRuleDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
 import { State } from 'hooks/useFetch';
 import { useNotifications } from 'hooks/useNotifications';
-import { GettableAlert } from 'types/api/alerts/get';
-import { PayloadProps as PatchPayloadProps } from 'types/api/alerts/patch';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
 
 import { ColumnButton } from './styles';
 
@@ -12,7 +18,7 @@ function ToggleAlertState({
 	disabled,
 	setData,
 }: ToggleAlertStateProps): JSX.Element {
-	const [apiStatus, setAPIStatus] = useState<State<PatchPayloadProps>>({
+	const [apiStatus, setAPIStatus] = useState<State<RuletypesRuleDTO>>({
 		error: false,
 		errorMessage: '',
 		loading: false,
@@ -21,8 +27,7 @@ function ToggleAlertState({
 	});
 
 	const { notifications } = useNotifications();
-
-	const defaultErrorMessage = 'Something went wrong';
+	const { showErrorModal } = useErrorModal();
 
 	const onToggleHandler = async (
 		id: string,
@@ -34,58 +39,40 @@ function ToggleAlertState({
 				loading: true,
 			}));
 
-			const response = await patchAlert({
-				id,
-				data: {
-					disabled,
-				},
+			const response = await patchRulePartial(id, { disabled });
+			const { data: updatedRule } = response;
+
+			setData((state) =>
+				state.map((alert) => {
+					if (alert.id === id) {
+						return {
+							...alert,
+							disabled: updatedRule.disabled,
+							state: updatedRule.state,
+						};
+					}
+					return alert;
+				}),
+			);
+
+			setAPIStatus((state) => ({
+				...state,
+				loading: false,
+				payload: updatedRule,
+			}));
+			notifications.success({
+				message: 'Success',
 			});
-
-			if (response.statusCode === 200) {
-				setData((state) =>
-					state.map((alert) => {
-						if (alert.id === id) {
-							return {
-								...alert,
-								disabled: response.payload.disabled,
-								state: response.payload.state,
-							};
-						}
-						return alert;
-					}),
-				);
-
-				setAPIStatus((state) => ({
-					...state,
-					loading: false,
-					payload: response.payload,
-				}));
-				notifications.success({
-					message: 'Success',
-				});
-			} else {
-				setAPIStatus((state) => ({
-					...state,
-					loading: false,
-					error: true,
-					errorMessage: response.error || defaultErrorMessage,
-				}));
-
-				notifications.error({
-					message: response.error || defaultErrorMessage,
-				});
-			}
 		} catch (error) {
 			setAPIStatus((state) => ({
 				...state,
 				loading: false,
 				error: true,
-				errorMessage: defaultErrorMessage,
 			}));
 
-			notifications.error({
-				message: defaultErrorMessage,
-			});
+			showErrorModal(
+				convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
+			);
 		}
 	};
 
@@ -102,9 +89,9 @@ function ToggleAlertState({
 }
 
 interface ToggleAlertStateProps {
-	id: GettableAlert['id'];
+	id: string;
 	disabled: boolean;
-	setData: Dispatch<SetStateAction<GettableAlert[]>>;
+	setData: Dispatch<SetStateAction<RuletypesRuleDTO[]>>;
 }
 
 export default ToggleAlertState;

frontend/src/container/ListAlertRules/__test__/utils.test.ts

@@ -1,52 +1,69 @@
-import { GettableAlert } from 'types/api/alerts/get';
+import type {
+	RuletypesAlertStateDTO,
+	RuletypesCompareOperatorDTO,
+	RuletypesMatchTypeDTO,
+	RuletypesPanelTypeDTO,
+	RuletypesQueryTypeDTO,
+	RuletypesRuleDTO,
+} from 'api/generated/services/sigNoz.schemas';
 
 import { filterAlerts } from '../utils';
 
 describe('filterAlerts', () => {
-	const mockAlertBase: Partial<GettableAlert> = {
-		state: 'active',
+	const mockAlertBase: Partial<RuletypesRuleDTO> = {
+		state: 'active' as RuletypesAlertStateDTO,
 		disabled: false,
-		createAt: '2024-01-01T00:00:00Z',
-		createBy: 'test-user',
-		updateAt: '2024-01-01T00:00:00Z',
-		updateBy: 'test-user',
+		createdAt: new Date('2024-01-01T00:00:00Z'),
+		createdBy: 'test-user',
+		updatedAt: new Date('2024-01-01T00:00:00Z'),
+		updatedBy: 'test-user',
 		version: '1',
+		condition: {
+			compositeQuery: {
+				queries: [],
+				panelType: 'graph' as RuletypesPanelTypeDTO,
+				queryType: 'builder' as RuletypesQueryTypeDTO,
+			},
+			matchType: 'at_least_once' as RuletypesMatchTypeDTO,
+			op: 'above' as RuletypesCompareOperatorDTO,
+		},
+		ruleType: 'threshold_rule' as RuletypesRuleDTO['ruleType'],
 	};
 
-	const mockAlerts: GettableAlert[] = [
+	const mockAlerts: RuletypesRuleDTO[] = [
 		{
 			...mockAlertBase,
 			id: '1',
 			alert: 'High CPU Usage',
-			alertType: 'metrics',
+			alertType: 'METRIC_BASED_ALERT',
 			labels: {
 				severity: 'warning',
 				status: 'ok',
 				environment: 'production',
 			},
-		} as GettableAlert,
+		} as RuletypesRuleDTO,
 		{
 			...mockAlertBase,
 			id: '2',
 			alert: 'Memory Leak Detected',
-			alertType: 'metrics',
+			alertType: 'METRIC_BASED_ALERT',
 			labels: {
 				severity: 'critical',
 				status: 'firing',
 				environment: 'staging',
 			},
-		} as GettableAlert,
+		} as RuletypesRuleDTO,
 		{
 			...mockAlertBase,
 			id: '3',
 			alert: 'Database Connection Error',
-			alertType: 'metrics',
+			alertType: 'METRIC_BASED_ALERT',
 			labels: {
 				severity: 'error',
 				status: 'pending',
 				environment: 'production',
 			},
-		} as GettableAlert,
+		} as RuletypesRuleDTO,
 	];
 
 	it('should return all alerts when filter is empty', () => {
@@ -97,14 +114,14 @@ describe('filterAlerts', () => {
 	});
 
 	it('should handle alerts with missing labels', () => {
-		const alertsWithMissingLabels: GettableAlert[] = [
+		const alertsWithMissingLabels: RuletypesRuleDTO[] = [
 			{
 				...mockAlertBase,
 				id: '4',
 				alert: 'Test Alert',
-				alertType: 'metrics',
+				alertType: 'METRIC_BASED_ALERT',
 				labels: undefined,
-			} as GettableAlert,
+			} as RuletypesRuleDTO,
 		];
 		const result = filterAlerts(alertsWithMissingLabels, 'test');
 		expect(result).toHaveLength(1);
@@ -112,16 +129,16 @@ describe('filterAlerts', () => {
 	});
 
 	it('should handle alerts with missing alert name', () => {
-		const alertsWithMissingName: GettableAlert[] = [
+		const alertsWithMissingName: RuletypesRuleDTO[] = [
 			{
 				...mockAlertBase,
 				id: '5',
 				alert: '',
-				alertType: 'metrics',
+				alertType: 'METRIC_BASED_ALERT',
 				labels: {
 					severity: 'warning',
 				},
-			} as GettableAlert,
+			} as RuletypesRuleDTO,
 		];
 		const result = filterAlerts(alertsWithMissingName, 'warning');
 		expect(result).toHaveLength(1);

frontend/src/container/ListAlertRules/index.tsx

@@ -1,78 +1,66 @@
-import { useEffect, useRef } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
-import { useQuery } from 'react-query';
 import { Space } from 'antd';
-import getAll from 'api/alerts/getAll';
 import logEvent from 'api/common/logEvent';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import { useListRules } from 'api/generated/services/rules';
+import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
 import Spinner from 'components/Spinner';
 import { useNotifications } from 'hooks/useNotifications';
-import { isUndefined } from 'lodash-es';
 
 import { AlertsEmptyState } from './AlertsEmptyState/AlertsEmptyState';
 import ListAlert from './ListAlert';
 
 function ListAlertRules(): JSX.Element {
 	const { t } = useTranslation('common');
-	const { data, isError, isLoading, refetch, status } = useQuery('allAlerts', {
-		queryFn: getAll,
-		cacheTime: 0,
+	const { data, isError, isLoading, refetch, error } = useListRules({
+		query: { cacheTime: 0 },
 	});
 
+	const rules = data?.data ?? [];
+	const hasLoaded = !isLoading && data !== undefined;
 	const logEventCalledRef = useRef(false);
 
 	const { notifications } = useNotifications();
 
+	const apiError = useMemo(
+		() => convertToApiError(error as AxiosError<RenderErrorResponseDTO> | null),
+		[error],
+	);
+
 	useEffect(() => {
-		if (!logEventCalledRef.current && !isUndefined(data?.payload)) {
+		if (!logEventCalledRef.current && hasLoaded) {
 			logEvent('Alert: List page visited', {
-				number: data?.payload?.length,
+				number: rules.length,
 			});
 			logEventCalledRef.current = true;
 		}
-	}, [data?.payload]);
+	}, [hasLoaded, rules.length]);
 
 	useEffect(() => {
-		if (status === 'error' || (status === 'success' && data.statusCode >= 400)) {
+		if (isError) {
 			notifications.error({
-				message: data?.error || t('something_went_wrong'),
+				message: apiError?.getErrorMessage() || t('something_went_wrong'),
 			});
 		}
-	}, [data?.error, data?.statusCode, status, t, notifications]);
+	}, [isError, apiError, t, notifications]);
 
-	// api failed to load the data
 	if (isError) {
-		return <div>{data?.error || t('something_went_wrong')}</div>;
+		return <div>{apiError?.getErrorMessage() || t('something_went_wrong')}</div>;
 	}
 
-	// api is successful but error is present
-	if (status === 'success' && data.statusCode >= 400) {
-		return (
-			<ListAlert
-				{...{
-					allAlertRules: [],
-					refetch,
-				}}
-			/>
-		);
-	}
-
-	if (status === 'success' && !data.payload?.length) {
-		return <AlertsEmptyState />;
-	}
-
-	// in case of loading
-	if (isLoading || !data?.payload) {
+	if (isLoading || !data) {
 		return <Spinner height="75vh" tip="Loading Rules..." />;
 	}
 
+	if (rules.length === 0) {
+		return <AlertsEmptyState />;
+	}
+
 	return (
 		<Space direction="vertical" size="large" style={{ width: '100%' }}>
-			<ListAlert
-				{...{
-					allAlertRules: data.payload,
-					refetch,
-				}}
-			/>
+			<ListAlert allAlertRules={rules} refetch={refetch} />
 		</Space>
 	);
 }

frontend/src/container/ListAlertRules/utils.ts

@@ -1,19 +1,18 @@
 import logEvent from 'api/common/logEvent';
-import { ALERTS_DATA_SOURCE_MAP } from 'constants/alerts';
-import { AlertTypes } from 'types/api/alerts/alertTypes';
-import { GettableAlert } from 'types/api/alerts/get';
+import type { RuletypesRuleDTO } from 'api/generated/services/sigNoz.schemas';
+import { dataSourceForAlertType } from 'constants/alerts';
 
 export const filterAlerts = (
-	allAlertRules: GettableAlert[],
+	allAlertRules: RuletypesRuleDTO[],
 	filter: string,
-): GettableAlert[] => {
+): RuletypesRuleDTO[] => {
 	if (!filter.trim()) {
 		return allAlertRules;
 	}
 
 	const value = filter.trim().toLowerCase();
 	return allAlertRules.filter((alert) => {
-		const alertName = alert.alert?.toLowerCase();
+		const alertName = alert.alert.toLowerCase();
 		const severity = alert.labels?.severity?.toLowerCase();
 
 		// Create a string of all label keys and values for searching
@@ -23,7 +22,7 @@ export const filterAlerts = (
 			.toLowerCase();
 
 		return (
-			alertName?.includes(value) ||
+			alertName.includes(value) ||
 			severity?.includes(value) ||
 			labelSearchString.includes(value)
 		);
@@ -32,7 +31,7 @@ export const filterAlerts = (
 
 export const alertActionLogEvent = (
 	action: string,
-	record: GettableAlert,
+	record: RuletypesRuleDTO,
 ): void => {
 	let actionValue = '';
 	switch (action) {
@@ -52,9 +51,9 @@ export const alertActionLogEvent = (
 			break;
 	}
 	logEvent('Alert: Action', {
-		ruleId: record?.id,
-		dataSource: ALERTS_DATA_SOURCE_MAP[record.alertType as AlertTypes],
-		name: record?.alert,
+		ruleId: record.id,
+		dataSource: dataSourceForAlertType(record.alertType),
+		name: record.alert,
 		action: actionValue,
 	});
 };

frontend/src/container/PlannedDowntime/PlannedDowntime.tsx

@@ -1,21 +1,21 @@
 import React, { ChangeEvent, useEffect, useState } from 'react';
-import { useQuery } from 'react-query';
 import { useHistory } from 'react-router-dom';
 import { PlusOutlined } from '@ant-design/icons';
 import { Color } from '@signozhq/design-tokens';
 import { Button, Flex, Form, Input, Tooltip, Typography } from 'antd';
-import getAll from 'api/alerts/getAll';
-import { useDeleteDowntimeSchedule } from 'api/plannedDowntime/deleteDowntimeSchedule';
 import {
-	DowntimeSchedules,
-	useGetAllDowntimeSchedules,
-} from 'api/plannedDowntime/getAllDowntimeSchedules';
+	useDeleteDowntimeScheduleByID,
+	useListDowntimeSchedules,
+} from 'api/generated/services/downtimeschedules';
+import { useListRules } from 'api/generated/services/rules';
+import type { RuletypesPlannedMaintenanceDTO } from 'api/generated/services/sigNoz.schemas';
 import dayjs from 'dayjs';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
 import { useNotifications } from 'hooks/useNotifications';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { Search } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
+import { useErrorModal } from 'providers/ErrorModalProvider';
 import { USER_ROLES } from 'types/roles';
 
 import 'dayjs/locale/en';
@@ -33,28 +33,28 @@ import './PlannedDowntime.styles.scss';
 dayjs.locale('en');
 
 export function PlannedDowntime(): JSX.Element {
-	const { data, isError, isLoading } = useQuery('allAlerts', {
-		queryFn: getAll,
-		cacheTime: 0,
+	const { data: alertsData, isError, isLoading } = useListRules({
+		query: { cacheTime: 0 },
 	});
 	const [isOpen, setIsOpen] = React.useState(false);
 	const [form] = Form.useForm();
 	const { user } = useAppContext();
+	const { showErrorModal } = useErrorModal();
 	const history = useHistory();
 	const urlQuery = useUrlQuery();
 
 	const [initialValues, setInitialValues] = useState<
-		Partial<DowntimeSchedules & { editMode: boolean }>
+		Partial<RuletypesPlannedMaintenanceDTO & { editMode: boolean }>
 	>(defautlInitialValues);
 
-	const downtimeSchedules = useGetAllDowntimeSchedules();
+	const downtimeSchedules = useListDowntimeSchedules();
 	const alertOptions = React.useMemo(
 		() =>
-			data?.payload?.map((i) => ({
+			alertsData?.data?.map((i) => ({
 				label: i.alert,
 				value: i.id,
 			})),
-		[data],
+		[alertsData],
 	);
 
 	useEffect(() => {
@@ -66,7 +66,7 @@ export function PlannedDowntime(): JSX.Element {
 	const [searchValue, setSearchValue] = React.useState<string | number>(
 		urlQuery.get('search') || '',
 	);
-	const [deleteData, setDeleteData] = useState<{ id: number; name: string }>();
+	const [deleteData, setDeleteData] = useState<{ id: string; name: string }>();
 	const [isEditMode, setEditMode] = useState<boolean>(false);
 
 	const updateUrlWithSearch = useDebouncedFn((value) => {
@@ -105,12 +105,13 @@ export function PlannedDowntime(): JSX.Element {
 	const {
 		mutateAsync: deleteDowntimeScheduleAsync,
 		isLoading: isDeleteLoading,
-	} = useDeleteDowntimeSchedule({ id: deleteData?.id });
+	} = useDeleteDowntimeScheduleByID();
 
 	const onDeleteHandler = (): void => {
 		deleteDowntimeHandler({
 			deleteDowntimeScheduleAsync,
 			notifications,
+			showErrorModal,
 			refetchAllSchedules,
 			deleteId: deleteData?.id,
 			hideDeleteDowntimeScheduleModal,

frontend/src/container/PlannedDowntime/PlannedDowntimeForm.tsx

@@ -14,11 +14,18 @@ import {
 	Typography,
 } from 'antd';
 import type { DefaultOptionType } from 'antd/es/select';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
 import {
-	DowntimeSchedules,
-	Recurrence,
-} from 'api/plannedDowntime/getAllDowntimeSchedules';
-import { DowntimeScheduleUpdatePayload } from 'api/plannedDowntime/updateDowntimeSchedule';
+	createDowntimeSchedule,
+	updateDowntimeScheduleByID,
+} from 'api/generated/services/downtimeschedules';
+import type {
+	RuletypesPlannedMaintenanceDTO,
+	RuletypesPostablePlannedMaintenanceDTO,
+	RuletypesRecurrenceDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { RenderErrorResponseDTO } from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import {
 	ModalButtonWrapper,
@@ -29,15 +36,14 @@ import timezone from 'dayjs/plugin/timezone';
 import utc from 'dayjs/plugin/utc';
 import { useNotifications } from 'hooks/useNotifications';
 import { defaultTo, isEmpty } from 'lodash-es';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
 import { ALL_TIME_ZONES } from 'utils/timeZoneUtil';
 
 import 'dayjs/locale/en';
 
-import { SOMETHING_WENT_WRONG } from '../../constants/api';
-import { showErrorNotification } from '../../utils/error';
 import { AlertRuleTags } from './PlannedDowntimeList';
 import {
-	createEditDowntimeSchedule,
 	getAlertOptionsFromIds,
 	getDurationInfo,
 	getEndTime,
@@ -62,9 +68,9 @@ interface PlannedDowntimeFormData {
 	name: string;
 	startTime: dayjs.Dayjs | string;
 	endTime: dayjs.Dayjs | string;
-	recurrence?: Recurrence | null;
+	recurrence?: RuletypesRecurrenceDTO | null;
 	alertRules: DefaultOptionType[];
-	recurrenceSelect?: Recurrence;
+	recurrenceSelect?: RuletypesRecurrenceDTO;
 	timezone?: string;
 }
 
@@ -72,7 +78,7 @@ const customFormat = DATE_TIME_FORMATS.ORDINAL_DATETIME;
 
 interface PlannedDowntimeFormProps {
 	initialValues: Partial<
-		DowntimeSchedules & {
+		RuletypesPlannedMaintenanceDTO & {
 			editMode: boolean;
 		}
 	>;
@@ -111,9 +117,9 @@ export function PlannedDowntimeForm(
 			?.unit || 'm',
 	);
 
-	const [formData, setFormData] = useState<PlannedDowntimeFormData>(
-		initialValues?.schedule as PlannedDowntimeFormData,
-	);
+	const [formData, setFormData] = useState<Partial<PlannedDowntimeFormData>>({
+		timezone: initialValues.schedule?.timezone,
+	});
 
 	const [recurrenceType, setRecurrenceType] = useState<string | null>(
 		(initialValues.schedule?.recurrence?.repeatType as string) ||
@@ -125,6 +131,7 @@ export function PlannedDowntimeForm(
 		: undefined;
 
 	const { notifications } = useNotifications();
+	const { showErrorModal } = useErrorModal();
 
 	const datePickerFooter = (mode: any): any =>
 		mode === 'time' ? (
@@ -134,57 +141,54 @@ export function PlannedDowntimeForm(
 	const saveHanlder = useCallback(
 		async (values: PlannedDowntimeFormData) => {
 			const shouldKeepLocalTime = !isEditMode;
-			const createEditProps: DowntimeScheduleUpdatePayload = {
-				data: {
-					alertIds: values.alertRules
-						.map((alert) => alert.value)
-						.filter((alert) => alert !== undefined) as string[],
-					name: values.name,
-					schedule: {
-						startTime: handleTimeConversion(
+			const data: RuletypesPostablePlannedMaintenanceDTO = {
+				alertIds: values.alertRules
+					.map((alert) => alert.value)
+					.filter((alert) => alert !== undefined) as string[],
+				name: values.name,
+				schedule: {
+					startTime: new Date(
+						handleTimeConversion(
 							values.startTime,
 							timezoneInitialValue,
 							values.timezone,
 							shouldKeepLocalTime,
 						),
-						timezone: values.timezone,
-						endTime: values.endTime
-							? handleTimeConversion(
+					),
+					timezone: values.timezone as string,
+					endTime: values.endTime
+						? new Date(
+								handleTimeConversion(
 									values.endTime,
 									timezoneInitialValue,
 									values.timezone,
 									shouldKeepLocalTime,
-							  )
-							: undefined,
-						recurrence: values.recurrence as Recurrence,
-					},
+								),
+						  )
+						: undefined,
+					recurrence: values.recurrence as RuletypesRecurrenceDTO,
 				},
-				id: isEditMode ? initialValues.id : undefined,
 			};
 
 			setSaveLoading(true);
 			try {
-				const response = await createEditDowntimeSchedule({ ...createEditProps });
-				if (response.message === 'success') {
-					setIsOpen(false);
-					notifications.success({
-						message: 'Success',
-						description: isEditMode
-							? 'Schedule updated successfully'
-							: 'Schedule created successfully',
-					});
-					refetchAllSchedules();
+				if (isEditMode && initialValues.id) {
+					await updateDowntimeScheduleByID({ id: initialValues.id }, data);
 				} else {
-					notifications.error({
-						message: 'Error',
-						description:
-							typeof response.error === 'string'
-								? response.error
-								: response.error?.message || SOMETHING_WENT_WRONG,
-					});
+					await createDowntimeSchedule(data);
 				}
+				setIsOpen(false);
+				notifications.success({
+					message: 'Success',
+					description: isEditMode
+						? 'Schedule updated successfully'
+						: 'Schedule created successfully',
+				});
+				refetchAllSchedules();
 			} catch (e: unknown) {
-				showErrorNotification(notifications, e as Error);
+				showErrorModal(
+					convertToApiError(e as AxiosError<RenderErrorResponseDTO>) as APIError,
+				);
 			}
 			setSaveLoading(false);
 		},
@@ -195,10 +199,11 @@ export function PlannedDowntimeForm(
 			refetchAllSchedules,
 			setIsOpen,
 			timezoneInitialValue,
+			showErrorModal,
 		],
 	);
 	const onFinish = async (values: PlannedDowntimeFormData): Promise<void> => {
-		const recurrenceData: Recurrence | undefined =
+		const recurrenceData =
 			values?.recurrence?.repeatType === recurrenceOptions.doesNotRepeat.value
 				? undefined
 				: {
@@ -225,7 +230,10 @@ export function PlannedDowntimeForm(
 						repeatType: values.recurrence?.repeatType,
 				  };
 
-		const payloadValues = { ...values, recurrence: recurrenceData };
+		const payloadValues = {
+			...values,
+			recurrence: recurrenceData as RuletypesRecurrenceDTO | undefined,
+		};
 		await saveHanlder(payloadValues);
 	};
 
@@ -236,11 +244,9 @@ export function PlannedDowntimeForm(
 	];
 
 	const handleOk = async (): Promise<void> => {
-		try {
-			await form.validateFields();
-		} catch (error) {
-			console.error(error);
-		}
+		await form.validateFields().catch(() => {
+			// antd renders inline field-level errors; nothing more to do here.
+		});
 	};
 
 	const handleCancel = (): void => {
@@ -281,18 +287,19 @@ export function PlannedDowntimeForm(
 				: '',
 			recurrence: {
 				...initialValues.schedule?.recurrence,
-				repeatType: !isScheduleRecurring(initialValues?.schedule)
+				repeatType: (!isScheduleRecurring(initialValues?.schedule)
 					? recurrenceOptions.doesNotRepeat.value
-					: (initialValues.schedule?.recurrence?.repeatType as string),
-				duration: getDurationInfo(
-					initialValues.schedule?.recurrence?.duration as string,
-				)?.value,
-			},
+					: initialValues.schedule?.recurrence
+							?.repeatType) as RuletypesRecurrenceDTO['repeatType'],
+				duration: String(
+					getDurationInfo(initialValues.schedule?.recurrence?.duration as string)
+						?.value ?? '',
+				),
+			} as RuletypesRecurrenceDTO,
 			timezone: initialValues.schedule?.timezone as string,
 		};
 		return formData;
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [initialValues]);
+	}, [initialValues, alertOptions]);
 
 	useEffect(() => {
 		setSelectedTags(formatedInitialValues.alertRules);
@@ -325,7 +332,12 @@ export function PlannedDowntimeForm(
 	const startTimeText = useMemo((): string => {
 		let startTime = formData?.startTime;
 		if (recurrenceType !== recurrenceOptions.doesNotRepeat.value) {
-			startTime = formData?.recurrence?.startTime || formData?.startTime || '';
+			startTime =
+				(formData?.recurrence?.startTime
+					? dayjs(formData.recurrence.startTime).toISOString()
+					: '') ||
+				formData?.startTime ||
+				'';
 		}
 
 		if (!startTime) {
@@ -381,7 +393,10 @@ export function PlannedDowntimeForm(
 	const endTimeText = useMemo((): string => {
 		let endTime = formData?.endTime;
 		if (recurrenceType !== recurrenceOptions.doesNotRepeat.value) {
-			endTime = formData?.recurrence?.endTime || '';
+			endTime =
+				(formData?.recurrence?.endTime
+					? dayjs(formData.recurrence.endTime).toISOString()
+					: '') || '';
 
 			if (!isEditMode && !endTime) {
 				endTime = formData?.endTime || '';

frontend/src/container/PlannedDowntime/PlannedDowntimeList.tsx

@@ -12,13 +12,15 @@ import {
 	Typography,
 } from 'antd';
 import type { DefaultOptionType } from 'antd/es/select';
-import {
-	DowntimeSchedules,
-	PayloadProps,
-	Recurrence,
-} from 'api/plannedDowntime/getAllDowntimeSchedules';
-import { AxiosError, AxiosResponse } from 'axios';
+import type {
+	ListDowntimeSchedules200,
+	RenderErrorResponseDTO,
+	RuletypesPlannedMaintenanceDTO,
+	RuletypesRecurrenceDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type { ErrorType } from 'api/generatedAPIInstance';
 import cx from 'classnames';
+import dayjs from 'dayjs';
 import { useNotifications } from 'hooks/useNotifications';
 import { defaultTo } from 'lodash-es';
 import { CalendarClock, PenLine, Trash2 } from 'lucide-react';
@@ -143,7 +145,7 @@ export function CollapseListContent({
 	created_by_name?: string;
 	created_by_email?: string;
 	timeframe: [string | undefined | null, string | undefined | null];
-	repeats?: Recurrence | null;
+	repeats?: RuletypesRecurrenceDTO | null;
 	updated_at?: string;
 	updated_by_name?: string;
 	alertOptions?: DefaultOptionType[];
@@ -218,10 +220,10 @@ export function CollapseListContent({
 export function CustomCollapseList(
 	props: DowntimeSchedulesTableData & {
 		setInitialValues: React.Dispatch<
-			React.SetStateAction<Partial<DowntimeSchedules>>
+			React.SetStateAction<Partial<RuletypesPlannedMaintenanceDTO>>
 		>;
 		setModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
-		handleDeleteDowntime: (id: number, name: string) => void;
+		handleDeleteDowntime: (id: string, name: string) => void;
 		setEditMode: React.Dispatch<React.SetStateAction<boolean>>;
 	},
 ): JSX.Element {
@@ -241,12 +243,19 @@ export function CustomCollapseList(
 		kind,
 	} = props;
 
-	const scheduleTime = schedule?.startTime ? schedule.startTime : createdAt;
+	const scheduleTime = schedule?.startTime
+		? dayjs(schedule.startTime).toISOString()
+		: createdAt
+		? dayjs(createdAt).toISOString()
+		: '';
 	// Combine time and date
 	const formattedDateAndTime = `Start time ⎯ ${formatDateTime(
 		defaultTo(scheduleTime, ''),
 	)} ${schedule?.timezone}`;
-	const endTime = getEndTime({ kind, schedule });
+	const endTime = getEndTime({
+		kind,
+		schedule,
+	} as Partial<RuletypesPlannedMaintenanceDTO>);
 
 	return (
 		<>
@@ -257,7 +266,10 @@ export function CustomCollapseList(
 							duration={
 								schedule?.recurrence?.duration
 									? (schedule?.recurrence?.duration as string)
-									: getDuration(schedule?.startTime, schedule?.endTime)
+									: getDuration(
+											schedule?.startTime ? dayjs(schedule.startTime).toISOString() : '',
+											schedule?.endTime ? dayjs(schedule.endTime).toISOString() : '',
+									  )
 							}
 							name={defaultTo(name, '')}
 							handleEdit={(): void => {
@@ -266,21 +278,23 @@ export function CustomCollapseList(
 								setEditMode(true);
 							}}
 							handleDelete={(): void => {
-								handleDeleteDowntime(id, name || '');
+								handleDeleteDowntime(id ?? '', name || '');
 							}}
 						/>
 					}
-					key={id}
+					key={id ?? ''}
 				>
 					<CollapseListContent
-						created_at={defaultTo(createdAt, '')}
+						created_at={createdAt ? dayjs(createdAt).toISOString() : ''}
 						created_by_name={defaultTo(createdBy, '')}
 						timeframe={[
 							schedule?.startTime?.toString(),
 							typeof endTime === 'string' ? endTime : endTime?.toString(),
 						]}
-						repeats={schedule?.recurrence}
-						updated_at={defaultTo(updatedAt, '')}
+						repeats={
+							schedule?.recurrence as RuletypesRecurrenceDTO | null | undefined
+						}
+						updated_at={updatedAt ? dayjs(updatedAt).toISOString() : ''}
 						updated_by_name={defaultTo(updatedBy, '')}
 						alertOptions={alertOptions}
 						timezone={defaultTo(schedule?.timezone, '')}
@@ -295,7 +309,7 @@ export function CustomCollapseList(
 	);
 }
 
-export type DowntimeSchedulesTableData = DowntimeSchedules & {
+export type DowntimeSchedulesTableData = RuletypesPlannedMaintenanceDTO & {
 	alertOptions: DefaultOptionType[];
 };
 
@@ -309,15 +323,15 @@ export function PlannedDowntimeList({
 	searchValue,
 }: {
 	downtimeSchedules: UseQueryResult<
-		AxiosResponse<PayloadProps, any>,
-		AxiosError<unknown, any>
+		ListDowntimeSchedules200,
+		ErrorType<RenderErrorResponseDTO>
 	>;
 	alertOptions: DefaultOptionType[];
 	setInitialValues: React.Dispatch<
-		React.SetStateAction<Partial<DowntimeSchedules>>
+		React.SetStateAction<Partial<RuletypesPlannedMaintenanceDTO>>
 	>;
 	setModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
-	handleDeleteDowntime: (id: number, name: string) => void;
+	handleDeleteDowntime: (id: string, name: string) => void;
 	setEditMode: React.Dispatch<React.SetStateAction<boolean>>;
 	searchValue: string | number;
 }): JSX.Element {
@@ -337,19 +351,19 @@ export function PlannedDowntimeList({
 	];
 	const { notifications } = useNotifications();
 
-	const tableData = (downtimeSchedules.data?.data?.data || [])
+	const tableData = [...(downtimeSchedules.data?.data || [])]
 		.sort((a, b): number => {
 			if (a?.updatedAt && b?.updatedAt) {
-				return b.updatedAt.localeCompare(a.updatedAt);
+				return dayjs(b.updatedAt).diff(dayjs(a.updatedAt));
 			}
 			return 0;
 		})
-		?.filter(
+		.filter(
 			(data) =>
-				data?.name?.includes(searchValue.toLocaleString()) ||
-				data?.id.toLocaleString() === searchValue.toLocaleString(),
+				data.name.includes(searchValue.toLocaleString()) ||
+				data.id === searchValue.toLocaleString(),
 		)
-		.map?.((data) => {
+		.map((data) => {
 			const specificAlertOptions = getAlertOptionsFromIds(
 				data.alertIds || [],
 				alertOptions,

frontend/src/container/PlannedDowntime/PlannedDowntimeutils.ts

@@ -1,21 +1,19 @@
 import { UseMutateAsyncFunction } from 'react-query';
 import type { NotificationInstance } from 'antd/es/notification/interface';
 import type { DefaultOptionType } from 'antd/es/select';
-import createDowntimeSchedule from 'api/plannedDowntime/createDowntimeSchedule';
-import { DeleteSchedulePayloadProps } from 'api/plannedDowntime/deleteDowntimeSchedule';
-import {
-	DowntimeSchedules,
-	Recurrence,
-} from 'api/plannedDowntime/getAllDowntimeSchedules';
-import updateDowntimeSchedule, {
-	DowntimeScheduleUpdatePayload,
-	PayloadProps,
-} from 'api/plannedDowntime/updateDowntimeSchedule';
-import { showErrorNotification } from 'components/ExplorerCard/utils';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import type {
+	DeleteDowntimeScheduleByIDPathParameters,
+	RenderErrorResponseDTO,
+	RuletypesPlannedMaintenanceDTO,
+	RuletypesRecurrenceDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type { ErrorType } from 'api/generatedAPIInstance';
+import { AxiosError } from 'axios';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
 import dayjs from 'dayjs';
 import { isEmpty, isEqual } from 'lodash-es';
-import { ErrorResponse, SuccessResponse } from 'types/api';
+import APIError from 'types/api/error';
 
 type DateTimeString = string | null | undefined;
 
@@ -61,15 +59,21 @@ export const getAlertOptionsFromIds = (
 			alertIds?.includes(alert.value as string),
 	);
 
-export const recurrenceInfo = (recurrence?: Recurrence | null): string => {
+export const recurrenceInfo = (
+	recurrence?: RuletypesRecurrenceDTO | null,
+): string => {
 	if (!recurrence) {
 		return 'No';
 	}
 
 	const { startTime, duration, repeatOn, repeatType, endTime } = recurrence;
 
-	const formattedStartTime = startTime ? formatDateTime(startTime) : '';
-	const formattedEndTime = endTime ? `to ${formatDateTime(endTime)}` : '';
+	const formattedStartTime = startTime
+		? formatDateTime(dayjs(startTime).toISOString())
+		: '';
+	const formattedEndTime = endTime
+		? `to ${formatDateTime(dayjs(endTime).toISOString())}`
+		: '';
 	const weeklyRepeatString = repeatOn ? `on ${repeatOn.join(', ')}` : '';
 	const durationString = duration ? `- Duration: ${duration}` : '';
 
@@ -77,31 +81,32 @@ export const recurrenceInfo = (recurrence?: Recurrence | null): string => {
 };
 
 export const defautlInitialValues: Partial<
-	DowntimeSchedules & { editMode: boolean }
+	RuletypesPlannedMaintenanceDTO & { editMode: boolean }
 > = {
 	name: '',
 	description: '',
 	schedule: {
 		timezone: '',
-		endTime: '',
-		recurrence: null,
-		startTime: '',
+		endTime: undefined,
+		recurrence: undefined,
+		startTime: undefined,
 	},
 	alertIds: [],
-	createdAt: '',
-	createdBy: '',
+	createdAt: undefined,
+	createdBy: undefined,
 	editMode: false,
 };
 
 type DeleteDowntimeScheduleProps = {
 	deleteDowntimeScheduleAsync: UseMutateAsyncFunction<
-		DeleteSchedulePayloadProps,
-		Error,
-		number
+		void,
+		ErrorType<RenderErrorResponseDTO>,
+		{ pathParams: DeleteDowntimeScheduleByIDPathParameters }
 	>;
 	notifications: NotificationInstance;
+	showErrorModal: (error: APIError) => void;
 	refetchAllSchedules: VoidFunction;
-	deleteId?: number;
+	deleteId?: string;
 	hideDeleteDowntimeScheduleModal: () => void;
 	clearSearch: () => void;
 };
@@ -113,40 +118,33 @@ export const deleteDowntimeHandler = ({
 	hideDeleteDowntimeScheduleModal,
 	clearSearch,
 	notifications,
+	showErrorModal,
 }: DeleteDowntimeScheduleProps): void => {
 	if (!deleteId) {
-		const errorMsg = new Error('Something went wrong');
 		console.error('Unable to delete, please provide correct deleteId');
-		showErrorNotification(notifications, errorMsg);
+		notifications.error({ message: 'Something went wrong' });
 	} else {
-		deleteDowntimeScheduleAsync(deleteId, {
-			onSuccess: () => {
-				hideDeleteDowntimeScheduleModal();
-				clearSearch();
-				notifications.success({
-					message: 'Downtime schedule Deleted Successfully',
-				});
-				refetchAllSchedules();
+		deleteDowntimeScheduleAsync(
+			{ pathParams: { id: String(deleteId) } },
+			{
+				onSuccess: () => {
+					hideDeleteDowntimeScheduleModal();
+					clearSearch();
+					notifications.success({
+						message: 'Downtime schedule Deleted Successfully',
+					});
+					refetchAllSchedules();
+				},
+				onError: (err) => {
+					showErrorModal(
+						convertToApiError(err as AxiosError<RenderErrorResponseDTO>) as APIError,
+					);
+				},
 			},
-			onError: (err) => {
-				showErrorNotification(notifications, err);
-			},
-		});
+		);
 	}
 };
 
-export const createEditDowntimeSchedule = async (
-	props: DowntimeScheduleUpdatePayload,
-): Promise<
-	| SuccessResponse<PayloadProps>
-	| ErrorResponse<{ code: string; message: string } | string>
-> => {
-	if (props.id) {
-		return updateDowntimeSchedule({ ...props });
-	}
-	return createDowntimeSchedule({ ...props.data });
-};
-
 export const recurrenceOptions = {
 	doesNotRepeat: {
 		label: 'Does not repeat',
@@ -230,19 +228,21 @@ export const getEndTime = ({
 	kind,
 	schedule,
 }: Partial<
-	DowntimeSchedules & {
+	RuletypesPlannedMaintenanceDTO & {
 		editMode: boolean;
 	}
 >): string | dayjs.Dayjs => {
 	if (kind === 'fixed') {
-		return schedule?.endTime || '';
+		return schedule?.endTime ? dayjs(schedule.endTime).toISOString() : '';
 	}
 
-	return schedule?.recurrence?.endTime || '';
+	return schedule?.recurrence?.endTime
+		? dayjs(schedule.recurrence.endTime).toISOString()
+		: '';
 };
 
 export const isScheduleRecurring = (
-	schedule?: DowntimeSchedules['schedule'],
+	schedule?: RuletypesPlannedMaintenanceDTO['schedule'] | null,
 ): boolean => (schedule ? !isEmpty(schedule?.recurrence) : false);
 
 function convertUtcOffsetToTimezoneOffset(offsetMinutes: number): string {

frontend/src/container/PlannedDowntime/__test__/PlannedDowntime.test.tsx

@@ -1,7 +1,10 @@
 import { UseQueryResult } from 'react-query';
 import { fireEvent, screen } from '@testing-library/react';
-import { PayloadProps } from 'api/plannedDowntime/getAllDowntimeSchedules';
-import { AxiosError, AxiosResponse } from 'axios';
+import type {
+	ListDowntimeSchedules200,
+	RenderErrorResponseDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type { ErrorType } from 'api/generatedAPIInstance';
 import {
 	mockLocation,
 	mockQueryParams,
@@ -22,45 +25,53 @@ const MOCK_DATE_2 = '2024-01-02';
 const MOCK_DATE_3 = '2024-01-03';
 
 const MOCK_DOWNTIME_1 = createMockDowntime({
-	id: 1,
+	id: '1',
 	name: MOCK_DOWNTIME_1_NAME,
-	createdAt: MOCK_DATE_1,
-	updatedAt: MOCK_DATE_1,
-	schedule: buildSchedule({ startTime: MOCK_DATE_1, timezone: 'UTC' }),
+	createdAt: new Date(MOCK_DATE_1),
+	updatedAt: new Date(MOCK_DATE_1),
+	schedule: buildSchedule({
+		startTime: new Date(MOCK_DATE_1),
+		timezone: 'UTC',
+	}),
 	alertIds: [],
 });
 
 const MOCK_DOWNTIME_2 = createMockDowntime({
-	id: 2,
+	id: '2',
 	name: MOCK_DOWNTIME_2_NAME,
-	createdAt: MOCK_DATE_2,
-	updatedAt: MOCK_DATE_2,
-	schedule: buildSchedule({ startTime: MOCK_DATE_2, timezone: 'UTC' }),
+	createdAt: new Date(MOCK_DATE_2),
+	updatedAt: new Date(MOCK_DATE_2),
+	schedule: buildSchedule({
+		startTime: new Date(MOCK_DATE_2),
+		timezone: 'UTC',
+	}),
 	alertIds: [],
 });
 
 const MOCK_DOWNTIME_3 = createMockDowntime({
-	id: 3,
+	id: '3',
 	name: MOCK_DOWNTIME_3_NAME,
-	createdAt: MOCK_DATE_3,
-	updatedAt: MOCK_DATE_3,
-	schedule: buildSchedule({ startTime: MOCK_DATE_3, timezone: 'UTC' }),
+	createdAt: new Date(MOCK_DATE_3),
+	updatedAt: new Date(MOCK_DATE_3),
+	schedule: buildSchedule({
+		startTime: new Date(MOCK_DATE_3),
+		timezone: 'UTC',
+	}),
 	alertIds: [],
 });
 
-const MOCK_DOWNTIME_RESPONSE: Partial<AxiosResponse<PayloadProps>> = {
-	data: {
-		data: [MOCK_DOWNTIME_1, MOCK_DOWNTIME_2, MOCK_DOWNTIME_3],
-	},
+const MOCK_DOWNTIME_RESPONSE: ListDowntimeSchedules200 = {
+	data: [MOCK_DOWNTIME_1, MOCK_DOWNTIME_2, MOCK_DOWNTIME_3],
+	status: 'success',
 };
 
 type DowntimeQueryResult = UseQueryResult<
-	AxiosResponse<PayloadProps>,
-	AxiosError
+	ListDowntimeSchedules200,
+	ErrorType<RenderErrorResponseDTO>
 >;
 
 const mockDowntimeQueryResult: Partial<DowntimeQueryResult> = {
-	data: MOCK_DOWNTIME_RESPONSE as AxiosResponse<PayloadProps>,
+	data: MOCK_DOWNTIME_RESPONSE,
 	isLoading: false,
 	isFetching: false,
 	isError: false,
@@ -89,13 +100,27 @@ jest.mock('hooks/useSafeNavigate', () => ({
 	}),
 }));
 
-jest.mock('api/plannedDowntime/getAllDowntimeSchedules', () => ({
-	useGetAllDowntimeSchedules: (): DowntimeQueryResult =>
+jest.mock('api/generated/services/downtimeschedules', () => ({
+	useListDowntimeSchedules: (): DowntimeQueryResult =>
 		mockDowntimeQueryResult as DowntimeQueryResult,
+	useDeleteDowntimeScheduleByID: (): {
+		mutateAsync: jest.Mock;
+		isLoading: false;
+	} => ({
+		mutateAsync: jest.fn(),
+		isLoading: false,
+	}),
 }));
-jest.mock('api/alerts/getAll', () => ({
-	__esModule: true,
-	default: (): Promise<{ payload: [] }> => Promise.resolve({ payload: [] }),
+jest.mock('api/generated/services/rules', () => ({
+	useListRules: (): {
+		data: { data: [] };
+		isError: false;
+		isLoading: false;
+	} => ({
+		data: { data: [] },
+		isError: false,
+		isLoading: false,
+	}),
 }));
 
 describe('PlannedDowntime Component', () => {

frontend/src/container/PlannedDowntime/__test__/testUtils.ts

@@ -1,29 +1,37 @@
-import { DowntimeSchedules } from 'api/plannedDowntime/getAllDowntimeSchedules';
+import type {
+	RuletypesPlannedMaintenanceDTO,
+	RuletypesScheduleDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import {
+	RuletypesMaintenanceKindDTO,
+	RuletypesMaintenanceStatusDTO,
+} from 'api/generated/services/sigNoz.schemas';
 
 export const buildSchedule = (
-	schedule: Partial<DowntimeSchedules['schedule']>,
-): DowntimeSchedules['schedule'] => ({
-	timezone: schedule?.timezone ?? null,
-	startTime: schedule?.startTime ?? null,
-	endTime: schedule?.endTime ?? null,
-	recurrence: schedule?.recurrence ?? null,
+	schedule: Partial<RuletypesScheduleDTO>,
+): RuletypesScheduleDTO => ({
+	timezone: schedule?.timezone ?? '',
+	startTime: schedule?.startTime,
+	endTime: schedule?.endTime,
+	recurrence: schedule?.recurrence,
 });
 
 export const createMockDowntime = (
-	overrides: Partial<DowntimeSchedules>,
-): DowntimeSchedules => ({
-	id: overrides.id ?? 0,
-	name: overrides.name ?? null,
-	description: overrides.description ?? null,
+	overrides: Partial<RuletypesPlannedMaintenanceDTO>,
+): RuletypesPlannedMaintenanceDTO => ({
+	id: overrides.id ?? '0',
+	name: overrides.name ?? '',
+	description: overrides.description ?? '',
 	schedule: buildSchedule({
 		timezone: 'UTC',
-		startTime: '2024-01-01',
+		startTime: new Date('2024-01-01'),
 		...overrides.schedule,
 	}),
-	alertIds: overrides.alertIds ?? null,
-	createdAt: overrides.createdAt ?? null,
-	createdBy: overrides.createdBy ?? null,
-	updatedAt: overrides.updatedAt ?? null,
-	updatedBy: overrides.updatedBy ?? null,
-	kind: overrides.kind ?? null,
+	alertIds: overrides.alertIds ?? [],
+	createdAt: overrides.createdAt,
+	createdBy: overrides.createdBy ?? '',
+	updatedAt: overrides.updatedAt,
+	updatedBy: overrides.updatedBy ?? '',
+	kind: overrides.kind ?? RuletypesMaintenanceKindDTO.recurring,
+	status: overrides.status ?? RuletypesMaintenanceStatusDTO.active,
 });

frontend/src/hooks/alerts/useCreateAlertRule.ts

@@ -1,20 +0,0 @@
-import { useMutation, UseMutationResult } from 'react-query';
-import createAlertRule, {
-	CreateAlertRuleResponse,
-} from 'api/alerts/createAlertRule';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PostableAlertRuleV2 } from 'types/api/alerts/alertTypesV2';
-
-export function useCreateAlertRule(): UseMutationResult<
-	SuccessResponse<CreateAlertRuleResponse> | ErrorResponse,
-	Error,
-	PostableAlertRuleV2
-> {
-	return useMutation<
-		SuccessResponse<CreateAlertRuleResponse> | ErrorResponse,
-		Error,
-		PostableAlertRuleV2
-	>({
-		mutationFn: (alertData) => createAlertRule(alertData),
-	});
-}

frontend/src/hooks/alerts/useTestAlertRule.ts

@@ -1,18 +0,0 @@
-import { useMutation, UseMutationResult } from 'react-query';
-import testAlertRule, { TestAlertRuleResponse } from 'api/alerts/testAlertRule';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PostableAlertRuleV2 } from 'types/api/alerts/alertTypesV2';
-
-export function useTestAlertRule(): UseMutationResult<
-	SuccessResponse<TestAlertRuleResponse> | ErrorResponse,
-	Error,
-	PostableAlertRuleV2
-> {
-	return useMutation<
-		SuccessResponse<TestAlertRuleResponse> | ErrorResponse,
-		Error,
-		PostableAlertRuleV2
-	>({
-		mutationFn: (alertData) => testAlertRule(alertData),
-	});
-}

frontend/src/hooks/alerts/useUpdateAlertRule.ts

@@ -1,22 +0,0 @@
-import { useMutation, UseMutationResult } from 'react-query';
-import updateAlertRule, {
-	UpdateAlertRuleResponse,
-} from 'api/alerts/updateAlertRule';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { PostableAlertRuleV2 } from 'types/api/alerts/alertTypesV2';
-
-export function useUpdateAlertRule(
-	id: string,
-): UseMutationResult<
-	SuccessResponse<UpdateAlertRuleResponse> | ErrorResponse,
-	Error,
-	PostableAlertRuleV2
-> {
-	return useMutation<
-		SuccessResponse<UpdateAlertRuleResponse> | ErrorResponse,
-		Error,
-		PostableAlertRuleV2
-	>({
-		mutationFn: (alertData) => updateAlertRule(id, alertData),
-	});
-}

frontend/src/pages/AlertDetails/AlertDetails.tsx

@@ -1,5 +1,4 @@
 import React, { useEffect, useMemo } from 'react';
-import { useTranslation } from 'react-i18next';
 import { useLocation } from 'react-router-dom';
 import { Breadcrumb, Button, Divider } from 'antd';
 import logEvent from 'api/common/logEvent';
@@ -15,39 +14,16 @@ import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import history from 'lib/history';
 import { AlertTypes } from 'types/api/alerts/alertTypes';
-import {
-	NEW_ALERT_SCHEMA_VERSION,
-	PostableAlertRuleV2,
-} from 'types/api/alerts/alertTypesV2';
+import { NEW_ALERT_SCHEMA_VERSION } from 'types/api/alerts/alertTypesV2';
+import { fromRuleDTOToPostableRuleV2 } from 'types/api/alerts/convert';
 import { isModifierKeyPressed } from 'utils/app';
 
 import AlertHeader from './AlertHeader/AlertHeader';
 import AlertNotFound from './AlertNotFound';
 import { useGetAlertRuleDetails, useRouteTabUtils } from './hooks';
-import { AlertDetailsStatusRendererProps } from './types';
 
 import './AlertDetails.styles.scss';
 
-function AlertDetailsStatusRenderer({
-	isLoading,
-	isError,
-	isRefetching,
-	data,
-}: AlertDetailsStatusRendererProps): JSX.Element {
-	const alertRuleDetails = useMemo(() => data?.payload?.data, [data]);
-	const { t } = useTranslation('common');
-
-	if (isLoading || isRefetching) {
-		return <Spinner tip="Loading..." />;
-	}
-
-	if (isError) {
-		return <div>{data?.error || t('something_went_wrong')}</div>;
-	}
-
-	return <AlertHeader alertDetails={alertRuleDetails} />;
-}
-
 function BreadCrumbItem({
 	title,
 	isLast,
@@ -87,7 +63,6 @@ function AlertDetails(): JSX.Element {
 
 	const {
 		isLoading,
-		isRefetching,
 		isError,
 		ruleId,
 		isValidRuleId,
@@ -99,7 +74,7 @@ function AlertDetails(): JSX.Element {
 	}, [params]);
 
 	const getDocumentTitle = useMemo(() => {
-		const alertTitle = alertDetailsResponse?.payload?.data?.alert;
+		const alertTitle = alertDetailsResponse?.data?.alert;
 		if (alertTitle) {
 			return alertTitle;
 		}
@@ -110,14 +85,17 @@ function AlertDetails(): JSX.Element {
 			return document.title;
 		}
 		return 'Alert Not Found';
-	}, [alertDetailsResponse?.payload?.data?.alert, isTestAlert, isLoading]);
+	}, [alertDetailsResponse?.data?.alert, isTestAlert, isLoading]);
 
 	useEffect(() => {
 		document.title = getDocumentTitle;
 	}, [getDocumentTitle]);
 
 	const alertRuleDetails = useMemo(
-		() => alertDetailsResponse?.payload?.data as PostableAlertRuleV2 | undefined,
+		() =>
+			alertDetailsResponse?.data
+				? fromRuleDTOToPostableRuleV2(alertDetailsResponse.data)
+				: undefined,
 		[alertDetailsResponse],
 	);
 
@@ -126,12 +104,7 @@ function AlertDetails(): JSX.Element {
 		[alertRuleDetails],
 	);
 
-	if (
-		isError ||
-		!isValidRuleId ||
-		(alertDetailsResponse && alertDetailsResponse.statusCode !== 200) ||
-		(!isLoading && !alertRuleDetails)
-	) {
+	if (isError || !isValidRuleId || (!isLoading && !alertRuleDetails)) {
 		return <AlertNotFound isTestAlert={isTestAlert} />;
 	}
 
@@ -173,9 +146,7 @@ function AlertDetails(): JSX.Element {
 				/>
 				<Divider className="divider breadcrumb-divider" />
 
-				<AlertDetailsStatusRenderer
-					{...{ isLoading, isError, isRefetching, data: alertDetailsResponse }}
-				/>
+				{alertRuleDetails && <AlertHeader alertDetails={alertRuleDetails} />}
 				<Divider className="divider" />
 				<div className="tabs-and-filters">
 					<RouteTab

frontend/src/pages/AlertDetails/AlertHeader/AlertHeader.tsx

@@ -1,4 +1,5 @@
 import { useMemo, useState } from 'react';
+import type { RuletypesRuleDTO } from 'api/generated/services/sigNoz.schemas';
 import CreateAlertV2Header from 'container/CreateAlertV2/CreateAlertHeader';
 import LineClampedText from 'periscope/components/LineClampedText/LineClampedText';
 import { useAlertRule } from 'providers/Alert';
@@ -6,7 +7,6 @@ import {
 	NEW_ALERT_SCHEMA_VERSION,
 	PostableAlertRuleV2,
 } from 'types/api/alerts/alertTypesV2';
-import { GettableAlert } from 'types/api/alerts/get';
 
 import AlertActionButtons from './ActionButtons/ActionButtons';
 import AlertLabels from './AlertLabels/AlertLabels';
@@ -16,7 +16,7 @@ import AlertState from './AlertState/AlertState';
 import './AlertHeader.styles.scss';
 
 export type AlertHeaderProps = {
-	alertDetails: GettableAlert | PostableAlertRuleV2;
+	alertDetails: RuletypesRuleDTO | PostableAlertRuleV2;
 };
 function AlertHeader({ alertDetails }: AlertHeaderProps): JSX.Element {
 	const { state, alert: alertName, labels } = alertDetails;

frontend/src/pages/AlertDetails/hooks.tsx

@@ -3,15 +3,25 @@ import { useMutation, useQuery, useQueryClient } from 'react-query';
 import { generatePath, useLocation } from 'react-router-dom';
 import { TablePaginationConfig, TableProps } from 'antd';
 import type { FilterValue, SorterResult } from 'antd/es/table/interface';
-import deleteAlerts from 'api/alerts/delete';
-import get from 'api/alerts/get';
-import getAll from 'api/alerts/getAll';
-import patchAlert from 'api/alerts/patch';
+import { patchRulePartial } from 'api/alerts/patchRulePartial';
 import ruleStats from 'api/alerts/ruleStats';
-import save from 'api/alerts/save';
 import timelineGraph from 'api/alerts/timelineGraph';
 import timelineTable from 'api/alerts/timelineTable';
 import topContributors from 'api/alerts/topContributors';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import {
+	createRule,
+	deleteRuleByID,
+	updateRuleByID,
+	useGetRuleByID,
+	useListRules,
+} from 'api/generated/services/rules';
+import type {
+	GetRuleByID200,
+	RenderErrorResponseDTO,
+	RuletypesPostableRuleDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
 import { TabRoutes } from 'components/RouteTab/types';
 import { QueryParams } from 'constants/query';
 import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
@@ -21,7 +31,6 @@ import { TIMELINE_TABLE_PAGE_SIZE } from 'container/AlertHistory/constants';
 import { AlertDetailsTab, TimelineFilter } from 'container/AlertHistory/types';
 import { urlKey } from 'container/AllError/utils';
 import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
-import useAxiosError from 'hooks/useAxiosError';
 import { useNotifications } from 'hooks/useNotifications';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
@@ -34,7 +43,9 @@ import { OrderPreferenceItems } from 'pages/Logs/config';
 import BetaTag from 'periscope/components/BetaTag/BetaTag';
 import PaginationInfoText from 'periscope/components/PaginationInfoText/PaginationInfoText';
 import { useAlertRule } from 'providers/Alert';
+import { useErrorModal } from 'providers/ErrorModalProvider';
 import { ErrorResponse, SuccessResponse } from 'types/api';
+import { toPostableRuleDTOFromAlertDef } from 'types/api/alerts/convert';
 import {
 	AlertDef,
 	AlertRuleStatsPayload,
@@ -43,7 +54,7 @@ import {
 	AlertRuleTimelineTableResponsePayload,
 	AlertRuleTopContributorsPayload,
 } from 'types/api/alerts/def';
-import { PayloadProps } from 'types/api/alerts/get';
+import APIError from 'types/api/error';
 import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { nanoToMilli } from 'utils/timeUtils';
 
@@ -142,10 +153,7 @@ export const useRouteTabUtils = (): { routes: TabRoutes[] } => {
 type Props = {
 	ruleId: string | null;
 	isValidRuleId: boolean;
-	alertDetailsResponse:
-		| SuccessResponse<PayloadProps, unknown>
-		| ErrorResponse
-		| undefined;
+	alertDetailsResponse: GetRuleByID200 | undefined;
 	isLoading: boolean;
 	isRefetching: boolean;
 	isError: boolean;
@@ -161,14 +169,15 @@ export const useGetAlertRuleDetails = (): Props => {
 		data: alertDetailsResponse,
 		isRefetching,
 		isError,
-	} = useQuery([REACT_QUERY_KEY.ALERT_RULE_DETAILS, ruleId], {
-		queryFn: () =>
-			get({
-				id: ruleId || '',
-			}),
-		enabled: isValidRuleId,
-		refetchOnWindowFocus: false,
-	});
+	} = useGetRuleByID(
+		{ id: ruleId || '' },
+		{
+			query: {
+				enabled: isValidRuleId,
+				refetchOnWindowFocus: false,
+			},
+		},
+	);
 
 	return {
 		ruleId,
@@ -387,24 +396,27 @@ export const useAlertRuleStatusToggle = ({
 	const { notifications } = useNotifications();
 
 	const queryClient = useQueryClient();
-	const handleError = useAxiosError();
+	const { showErrorModal } = useErrorModal();
 
 	const { mutate: toggleAlertState } = useMutation(
 		[REACT_QUERY_KEY.TOGGLE_ALERT_STATE, ruleId],
-		patchAlert,
+		(args: { id: string; data: Partial<RuletypesPostableRuleDTO> }) =>
+			patchRulePartial(args.id, args.data),
 		{
 			onSuccess: (data) => {
-				setAlertRuleState(data?.payload?.state);
+				setAlertRuleState(data.data.state);
 				queryClient.refetchQueries([REACT_QUERY_KEY.ALERT_RULE_DETAILS, ruleId]);
 				notifications.success({
 					message: `Alert has been ${
-						data?.payload?.state === 'disabled' ? 'disabled' : 'enabled'
+						data.data.state === 'disabled' ? 'disabled' : 'enabled'
 					}.`,
 				});
 			},
 			onError: (error) => {
 				queryClient.refetchQueries([REACT_QUERY_KEY.ALERT_RULE_DETAILS, ruleId]);
-				handleError(error);
+				showErrorModal(
+					convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
+				);
 			},
 		},
 	);
@@ -431,14 +443,14 @@ export const useAlertRuleDuplicate = ({
 
 	const params = useUrlQuery();
 
-	const { refetch } = useQuery(REACT_QUERY_KEY.GET_ALL_ALLERTS, {
-		queryFn: getAll,
-		cacheTime: 0,
+	const { refetch } = useListRules({
+		query: { cacheTime: 0 },
 	});
-	const handleError = useAxiosError();
+	const { showErrorModal } = useErrorModal();
 	const { mutate: duplicateAlert } = useMutation(
 		[REACT_QUERY_KEY.DUPLICATE_ALERT_RULE],
-		save,
+		(args: { data: AlertDef }) =>
+			createRule(toPostableRuleDTOFromAlertDef(args.data)),
 		{
 			onSuccess: async () => {
 				notifications.success({
@@ -447,18 +459,17 @@ export const useAlertRuleDuplicate = ({
 
 				const { data: allAlertsData } = await refetch();
 
-				if (
-					allAlertsData &&
-					allAlertsData.payload &&
-					allAlertsData.payload.length > 0
-				) {
-					const clonedAlert =
-						allAlertsData.payload[allAlertsData.payload.length - 1];
+				const rules = allAlertsData?.data;
+				if (rules && rules.length > 0) {
+					const clonedAlert = rules[rules.length - 1];
 					params.set(QueryParams.ruleId, String(clonedAlert.id));
 					history.push(`${ROUTES.ALERT_OVERVIEW}?${params.toString()}`);
 				}
 			},
-			onError: handleError,
+			onError: (error) =>
+				showErrorModal(
+					convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
+				),
 		},
 	);
 
@@ -484,18 +495,21 @@ export const useAlertRuleUpdate = ({
 	isLoading: boolean;
 } => {
 	const { notifications } = useNotifications();
-	const handleError = useAxiosError();
+	const { showErrorModal } = useErrorModal();
 
 	const { mutate: updateAlertRule, isLoading } = useMutation(
 		[REACT_QUERY_KEY.UPDATE_ALERT_RULE, alertDetails.id],
-		save,
+		(args: { data: AlertDef; id: string }) =>
+			updateRuleByID({ id: args.id }, toPostableRuleDTOFromAlertDef(args.data)),
 		{
 			onMutate: () => setUpdatedName(intermediateName),
 			onSuccess: () =>
 				notifications.success({ message: 'Alert renamed successfully' }),
 			onError: (error) => {
 				setUpdatedName(alertDetails.alert);
-				handleError(error);
+				showErrorModal(
+					convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
+				);
 			},
 		},
 	);
@@ -503,7 +517,7 @@ export const useAlertRuleUpdate = ({
 	const handleAlertUpdate = (): void => {
 		updateAlertRule({
 			data: { ...alertDetails, alert: intermediateName },
-			id: alertDetails.id,
+			id: alertDetails.id || '',
 		});
 	};
 
@@ -518,11 +532,11 @@ export const useAlertRuleDelete = ({
 	handleAlertDelete: () => void;
 } => {
 	const { notifications } = useNotifications();
-	const handleError = useAxiosError();
+	const { showErrorModal } = useErrorModal();
 
 	const { mutate: deleteAlert } = useMutation(
 		[REACT_QUERY_KEY.REMOVE_ALERT_RULE, ruleId],
-		deleteAlerts,
+		(args: { id: string }) => deleteRuleByID({ id: args.id }),
 		{
 			onSuccess: async () => {
 				notifications.success({
@@ -531,7 +545,11 @@ export const useAlertRuleDelete = ({
 
 				history.push(ROUTES.LIST_ALL_ALERT);
 			},
-			onError: handleError,
+			// eslint-disable-next-line sonarjs/no-identical-functions
+			onError: (error) =>
+				showErrorModal(
+					convertToApiError(error as AxiosError<RenderErrorResponseDTO>) as APIError,
+				),
 		},
 	);
 

frontend/src/pages/AlertDetails/types.ts

@@ -1,6 +0,0 @@
-export type AlertDetailsStatusRendererProps = {
-	isLoading: boolean;
-	isError: boolean;
-	isRefetching: boolean;
-	data: any;
-};

frontend/src/pages/EditRules/constants.ts

@@ -1,6 +0,0 @@
-export const returnToAlertsPage = 'Return to Alerts Page';
-
-export const errorMessageReceivedFromBackend = 'sql: no rows in result set';
-
-export const improvedErrorMessage =
-	'The Alert that you are trying to access does not exist.';

frontend/src/pages/EditRules/index.tsx

@@ -1,11 +1,15 @@
-import { useEffect } from 'react';
+import { useEffect, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
-import { useQuery } from 'react-query';
 import { Button, Card } from 'antd';
-import get from 'api/alerts/get';
+import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
+import { useGetRuleByID } from 'api/generated/services/rules';
+import type {
+	RenderErrorResponseDTO,
+	RuletypesRuleDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { AxiosError } from 'axios';
 import Spinner from 'components/Spinner';
 import { QueryParams } from 'constants/query';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
 import ROUTES from 'constants/routes';
 import EditRulesContainer from 'container/EditRules';
 import { useNotifications } from 'hooks/useNotifications';
@@ -16,12 +20,10 @@ import {
 	NEW_ALERT_SCHEMA_VERSION,
 	PostableAlertRuleV2,
 } from 'types/api/alerts/alertTypesV2';
-
 import {
-	errorMessageReceivedFromBackend,
-	improvedErrorMessage,
-	returnToAlertsPage,
-} from './constants';
+	fromRuleDTOToAlertDef,
+	fromRuleDTOToPostableRuleV2,
+} from 'types/api/alerts/convert';
 
 import './EditRules.styles.scss';
 
@@ -33,16 +35,14 @@ function EditRules(): JSX.Element {
 
 	const isValidRuleId = ruleId !== null && String(ruleId).length !== 0;
 
-	const { isLoading, data, isRefetching, isError } = useQuery(
-		[REACT_QUERY_KEY.ALERT_RULE_DETAILS, ruleId],
+	const { isLoading, data, isRefetching, isError, error } = useGetRuleByID(
+		{ id: ruleId || '' },
 		{
-			queryFn: () =>
-				get({
-					id: ruleId || '',
-				}),
-			enabled: isValidRuleId,
-			refetchOnMount: false,
-			refetchOnWindowFocus: false,
+			query: {
+				enabled: isValidRuleId,
+				refetchOnMount: false,
+				refetchOnWindowFocus: false,
+			},
 		},
 	);
 
@@ -65,22 +65,26 @@ function EditRules(): JSX.Element {
 		}
 	}, [isValidRuleId, ruleId, notifications, safeNavigate]);
 
+	const ruleData: RuletypesRuleDTO | undefined = data?.data;
+
+	const apiError = useMemo(
+		() => convertToApiError(error as AxiosError<RenderErrorResponseDTO> | null),
+		[error],
+	);
+
 	if (
 		(isError && !isValidRuleId) ||
 		ruleId == null ||
-		(data?.payload?.data === undefined && !isLoading)
+		(ruleData === undefined && !isLoading)
 	) {
+		const errorMsg = apiError?.getErrorMessage() || '';
 		return (
 			<div className="edit-rules-container edit-rules-container--error">
 				<Card size="small" className="edit-rules-card">
-					<p className="content">
-						{data?.message === errorMessageReceivedFromBackend
-							? improvedErrorMessage
-							: data?.error || t('something_went_wrong')}
-					</p>
+					<p className="content">{errorMsg || t('something_went_wrong')}</p>
 					<div className="btn-container">
 						<Button type="default" size="large" onClick={clickHandler}>
-							{returnToAlertsPage}
+							Return to Alerts Page
 						</Button>
 					</div>
 				</Card>
@@ -88,20 +92,20 @@ function EditRules(): JSX.Element {
 		);
 	}
 
-	if (isLoading || isRefetching || !data?.payload) {
+	if (isLoading || isRefetching || !ruleData) {
 		return <Spinner tip="Loading Rules..." />;
 	}
 
 	let initialV2AlertValue: PostableAlertRuleV2 | null = null;
-	if (data.payload.data.schemaVersion === NEW_ALERT_SCHEMA_VERSION) {
-		initialV2AlertValue = data.payload.data as PostableAlertRuleV2;
+	if (ruleData.schemaVersion === NEW_ALERT_SCHEMA_VERSION) {
+		initialV2AlertValue = fromRuleDTOToPostableRuleV2(ruleData);
 	}
 
 	return (
 		<div className="edit-rules-container">
 			<EditRulesContainer
 				ruleId={ruleId || ''}
-				initialValue={data.payload.data}
+				initialValue={fromRuleDTOToAlertDef(ruleData)}
 				initialV2AlertValue={initialV2AlertValue}
 			/>
 		</div>

frontend/src/types/api/alerts/convert.ts

@@ -0,0 +1,153 @@
+import type {
+	RuletypesAlertCompositeQueryDTO,
+	RuletypesPostableRuleDTO,
+	RuletypesPostableRuleDTOLabels,
+	RuletypesRuleDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import {
+	RuletypesAlertTypeDTO,
+	RuletypesPanelTypeDTO,
+	RuletypesQueryTypeDTO,
+	RuletypesRuleTypeDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { EQueryType } from 'types/common/dashboard';
+
+import { AlertTypes } from './alertTypes';
+import { PostableAlertRuleV2 } from './alertTypesV2';
+import { ICompositeMetricQuery } from './compositeQuery';
+import { AlertDef, Labels } from './def';
+
+function toRuleTypeDTO(ruleType: string | undefined): RuletypesRuleTypeDTO {
+	switch (ruleType) {
+		case RuletypesRuleTypeDTO.promql_rule:
+			return RuletypesRuleTypeDTO.promql_rule;
+		case RuletypesRuleTypeDTO.anomaly_rule:
+			return RuletypesRuleTypeDTO.anomaly_rule;
+		default:
+			return RuletypesRuleTypeDTO.threshold_rule;
+	}
+}
+
+function toAlertTypeDTO(
+	alertType: AlertTypes | string | undefined,
+): RuletypesAlertTypeDTO | undefined {
+	switch (alertType) {
+		case AlertTypes.METRICS_BASED_ALERT:
+			return RuletypesAlertTypeDTO.METRIC_BASED_ALERT;
+		case AlertTypes.LOGS_BASED_ALERT:
+			return RuletypesAlertTypeDTO.LOGS_BASED_ALERT;
+		case AlertTypes.TRACES_BASED_ALERT:
+			return RuletypesAlertTypeDTO.TRACES_BASED_ALERT;
+		case AlertTypes.EXCEPTIONS_BASED_ALERT:
+			return RuletypesAlertTypeDTO.EXCEPTIONS_BASED_ALERT;
+		default:
+			return undefined;
+	}
+}
+
+function stripUndefinedLabels(
+	labels: Labels | undefined,
+): RuletypesPostableRuleDTOLabels | undefined {
+	if (!labels) {
+		return undefined;
+	}
+	const out: RuletypesPostableRuleDTOLabels = {};
+	Object.entries(labels).forEach(([key, value]) => {
+		if (typeof value === 'string') {
+			out[key] = value;
+		}
+	});
+	return out;
+}
+
+// why: local PostableAlertRuleV2/AlertDef diverge from RuletypesPostableRuleDTO
+// in several spots that match by string value but not by nominal TS type —
+// condition.{op,matchType}, evaluation.kind, notificationSettings.renotify.alertStates.
+// The backend accepts the local runtime shape, so one boundary cast encapsulates
+// the type-surface gap rather than leaking it to call sites.
+export function toPostableRuleDTO(
+	local: PostableAlertRuleV2,
+): RuletypesPostableRuleDTO {
+	const payload = {
+		alert: local.alert,
+		alertType: toAlertTypeDTO(local.alertType),
+		ruleType: toRuleTypeDTO(local.ruleType),
+		condition: local.condition,
+		annotations: local.annotations,
+		labels: stripUndefinedLabels(local.labels),
+		notificationSettings: local.notificationSettings,
+		evaluation: local.evaluation,
+		schemaVersion: local.schemaVersion,
+		source: local.source,
+		version: local.version,
+		disabled: local.disabled,
+	};
+	return (payload as unknown) as RuletypesPostableRuleDTO;
+}
+
+export function toPostableRuleDTOFromAlertDef(
+	local: AlertDef,
+): RuletypesPostableRuleDTO {
+	const payload = {
+		alert: local.alert,
+		alertType: toAlertTypeDTO(local.alertType),
+		ruleType: toRuleTypeDTO(local.ruleType),
+		condition: local.condition,
+		annotations: local.annotations,
+		labels: stripUndefinedLabels(local.labels),
+		evalWindow: local.evalWindow,
+		frequency: local.frequency,
+		preferredChannels: local.preferredChannels,
+		source: local.source,
+		version: local.version,
+		disabled: local.disabled,
+	};
+	return (payload as unknown) as RuletypesPostableRuleDTO;
+}
+
+export function fromRuleDTOToPostableRuleV2(
+	dto: RuletypesRuleDTO,
+): PostableAlertRuleV2 {
+	return (dto as unknown) as PostableAlertRuleV2;
+}
+
+export function fromRuleDTOToAlertDef(dto: RuletypesRuleDTO): AlertDef {
+	return (dto as unknown) as AlertDef;
+}
+
+function toEQueryType(queryType: RuletypesQueryTypeDTO): EQueryType {
+	switch (queryType) {
+		case RuletypesQueryTypeDTO.builder:
+			return EQueryType.QUERY_BUILDER;
+		case RuletypesQueryTypeDTO.clickhouse_sql:
+			return EQueryType.CLICKHOUSE;
+		case RuletypesQueryTypeDTO.promql:
+			return EQueryType.PROM;
+		default:
+			return EQueryType.QUERY_BUILDER;
+	}
+}
+
+function toPanelType(panelType: RuletypesPanelTypeDTO): PANEL_TYPES {
+	switch (panelType) {
+		case RuletypesPanelTypeDTO.value:
+			return PANEL_TYPES.VALUE;
+		case RuletypesPanelTypeDTO.table:
+			return PANEL_TYPES.TABLE;
+		case RuletypesPanelTypeDTO.graph:
+		default:
+			return PANEL_TYPES.TIME_SERIES;
+	}
+}
+
+export function toCompositeMetricQuery(
+	dto: RuletypesAlertCompositeQueryDTO,
+): ICompositeMetricQuery {
+	return {
+		queryType: toEQueryType(dto.queryType),
+		panelType: toPanelType(dto.panelType),
+		unit: dto.unit,
+		queries: (dto.queries ?? undefined) as ICompositeMetricQuery['queries'],
+	};
+}

frontend/src/types/api/alerts/get.ts

@@ -1,21 +0,0 @@
-import { AlertDef } from './def';
-
-export interface Props {
-	id: AlertDef['id'];
-}
-
-export interface GettableAlert extends AlertDef {
-	id: string;
-	alert: string;
-	state: string;
-	disabled: boolean;
-	createAt: string;
-	createBy: string;
-	updateAt: string;
-	updateBy: string;
-	schemaVersion: string;
-}
-
-export type PayloadProps = {
-	data: GettableAlert;
-};

frontend/src/types/api/alerts/getAll.ts

@@ -1,3 +0,0 @@
-import { GettableAlert } from './get';
-
-export type PayloadProps = GettableAlert[];

frontend/src/types/api/alerts/patch.ts

@@ -1,12 +0,0 @@
-import { GettableAlert } from './get';
-
-export type PayloadProps = GettableAlert;
-
-export interface PatchProps {
-	disabled?: boolean;
-}
-
-export interface Props {
-	id?: string;
-	data: PatchProps;
-}