fix: add more malformed query handling

docs/api/openapi.yml

@@ -2672,7 +2672,6 @@ components:
         unit:
           type: string
         value:
-          format: double
           type: number
       required:
       - value
@@ -3622,7 +3621,6 @@ components:
         unit:
           type: string
         value:
-          format: double
           type: number
       required:
       - value
@@ -3659,7 +3657,6 @@ components:
         unit:
           type: string
         value:
-          format: double
           type: number
       required:
       - value

frontend/.oxlintrc.json

@@ -328,11 +328,6 @@
           {
             "name": "immer",
             "message": "[State mgmt] Direct immer usage is deprecated. Use Zustand (which integrates immer via the immer middleware) instead."
-          },
-          {
-            "name": "api/generated/services/dashboard",
-            "importNames": ["patchDashboardV2", "usePatchDashboardV2"],
-            "message": "[dashboard-v2] Don't call patchDashboardV2/usePatchDashboardV2 directly — use useOptimisticPatch().patchAsync so spec edits update the react-query cache optimistically and reconcile on settle."
           }
         ]
       }

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -3384,7 +3384,6 @@ export interface DashboardtypesThresholdWithLabelDTO {
 	unit?: string;
 	/**
 	 * @type number
-	 * @format double
 	 */
 	value: number;
 }
@@ -3912,7 +3911,6 @@ export interface DashboardtypesComparisonThresholdDTO {
 	unit?: string;
 	/**
 	 * @type number
-	 * @format double
 	 */
 	value: number;
 }
@@ -4201,7 +4199,6 @@ export interface DashboardtypesTableThresholdDTO {
 	unit?: string;
 	/**
 	 * @type number
-	 * @format double
 	 */
 	value: number;
 }

frontend/src/container/PublicDashboardContainer/Panel.tsx

@@ -79,11 +79,13 @@ function Panel({
 		},
 		ENTITY_VERSION_V5,
 		{
-			// Public data is fetched by index and the payload redacts each widget's
-			// filters, so query bodies are identical across panels. Key on panel
-			// identity + time — the only inputs that determine the response — so
-			// panels don't collapse onto one cache entry.
-			queryKey: [widget?.id, index, startTime, endTime],
+			queryKey: [
+				widget?.query,
+				widget?.panelTypes,
+				requestData,
+				startTime,
+				endTime,
+			],
 			retry(failureCount, error): boolean {
 				if (
 					String(error).includes('status: error') &&

frontend/src/container/PublicDashboardContainer/__tests__/Panel.test.tsx

@@ -1,79 +0,0 @@
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { render } from 'tests/test-utils';
-import { Widgets } from 'types/api/dashboard/getAll';
-
-import Panel from '../Panel';
-
-const useGetQueryRangeMock = jest.fn();
-
-jest.mock('hooks/queryBuilder/useGetQueryRange', () => ({
-	useGetQueryRange: (...args: unknown[]): unknown => {
-		useGetQueryRangeMock(...args);
-		return {
-			data: undefined,
-			isFetching: false,
-			isLoading: false,
-			isSuccess: true,
-			isError: false,
-		};
-	},
-}));
-
-jest.mock('container/GridCardLayout/GridCard/WidgetGraphComponent', () => ({
-	__esModule: true,
-	default: (): JSX.Element => <div data-testid="widget-graph" />,
-}));
-
-const buildWidget = (id: string): Widgets =>
-	({
-		id,
-		panelTypes: PANEL_TYPES.LIST,
-		query: {
-			builder: {
-				queryData: [{ dataSource: 'logs', limit: 100, orderBy: [] }],
-			},
-		},
-		timePreferance: 'GLOBAL_TIME',
-	}) as unknown as Widgets;
-
-describe('Public dashboard Panel', () => {
-	beforeEach(() => {
-		useGetQueryRangeMock.mockClear();
-	});
-
-	it('keys each panel by widget id + index so identical queries do not collide (bug 5503)', () => {
-		render(
-			<>
-				<Panel
-					widget={buildWidget('widget-a')}
-					index={2}
-					dashboardId="dash-1"
-					startTime={100}
-					endTime={200}
-				/>
-				<Panel
-					widget={buildWidget('widget-b')}
-					index={62}
-					dashboardId="dash-1"
-					startTime={100}
-					endTime={200}
-				/>
-			</>,
-		);
-
-		const [callA, callB] = useGetQueryRangeMock.mock.calls;
-		const queryKeyA = callA[2].queryKey;
-		const metaA = callA[4];
-		const queryKeyB = callB[2].queryKey;
-		const metaB = callB[4];
-
-		// Key is panel identity + time only — the redacted query body is not part
-		// of it, so identical query bodies can't collapse two panels onto one key.
-		expect(queryKeyA).toStrictEqual(['widget-a', 2, 100, 200]);
-		expect(queryKeyB).toStrictEqual(['widget-b', 62, 100, 200]);
-		expect(queryKeyA).not.toStrictEqual(queryKeyB);
-
-		expect(metaA.widgetIndex).toBe(2);
-		expect(metaB.widgetIndex).toBe(62);
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/index.tsx

@@ -4,6 +4,7 @@ import { toast } from '@signozhq/ui/sonner';
 import logEvent from 'api/common/logEvent';
 import {
 	lockDashboardV2,
+	patchDashboardV2,
 	unlockDashboardV2,
 } from 'api/generated/services/dashboard';
 import type {
@@ -17,7 +18,6 @@ import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
 import { useCreatePanel } from '../hooks/useCreatePanel';
-import { useOptimisticPatch } from '../hooks/useOptimisticPatch';
 import PanelTypeSelectionModal from '../PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeSelectionModal';
 import DashboardActions from './DashboardActions/DashboardActions';
 import DashboardInfo from './DashboardInfo/DashboardInfo';
@@ -51,7 +51,6 @@ function DashboardPageToolbar(props: DashboardPageToolbarProps): JSX.Element {
 
 	const { user } = useAppContext();
 	const { showErrorModal } = useErrorModal();
-	const { patchAsync } = useOptimisticPatch();
 	const { isPickerOpen, openPicker, closePicker, createPanel } =
 		useCreatePanel();
 
@@ -89,13 +88,14 @@ function DashboardPageToolbar(props: DashboardPageToolbarProps): JSX.Element {
 						value: next,
 					},
 				];
-				await patchAsync(patch);
+				await patchDashboardV2({ id }, patch);
 				toast.success('Dashboard renamed successfully');
+				refetch();
 			} catch (error) {
 				showErrorModal(error as APIError);
 			}
 		},
-		[id, patchAsync, showErrorModal],
+		[id, refetch, showErrorModal],
 	);
 
 	const { isEditing, draft, setDraft, startEdit, cancel, commit } =

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Overview/index.tsx

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import type {
 	DashboardtypesGettableDashboardV2DTO,
 	DashboardtypesJSONPatchOperationDTO,
@@ -8,7 +9,7 @@ import { isEqual } from 'lodash-es';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../hooks/useOptimisticPatch';
+import { useDashboardStore } from '../../store/useDashboardStore';
 import CrossPanelSync from './CrossPanelSync/CrossPanelSync';
 import DashboardInfoForm from './DashboardInfoForm/DashboardInfoForm';
 import UnsavedChangesFooter from './UnsavedChangesFooter/UnsavedChangesFooter';
@@ -22,7 +23,7 @@ interface OverviewProps {
 function Overview({ dashboard }: OverviewProps): JSX.Element {
 	const id = dashboard.id;
 
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 
 	const title = dashboard.spec.display.name;
 	const description = dashboard.spec.display.description ?? '';
@@ -95,14 +96,15 @@ function Overview({ dashboard }: OverviewProps): JSX.Element {
 
 		try {
 			setIsSaving(true);
-			await patchAsync(ops);
+			await patchDashboardV2({ id }, ops);
 			toast.success('Dashboard updated');
+			refetch();
 		} catch (error) {
 			showErrorModal(error as APIError);
 		} finally {
 			setIsSaving(false);
 		}
-	}, [buildPatch, patchAsync, showErrorModal]);
+	}, [id, buildPatch, refetch, showErrorModal]);
 
 	useEffect(() => {
 		let numberOfUnsavedChanges = 0;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/Variables/useSaveVariables.ts

@@ -1,9 +1,9 @@
 import { useCallback, useState } from 'react';
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import { toast } from '@signozhq/ui/sonner';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../hooks/useOptimisticPatch';
 import { useDashboardStore } from '../../store/useDashboardStore';
 import { formModelToDto } from './variableAdapters';
 import type { VariableFormModel } from './variableFormModel';
@@ -14,9 +14,14 @@ interface UseSaveVariables {
 	isSaving: boolean;
 }
 
+/**
+ * Persists the dashboard's variable list via a single `/spec/variables` patch,
+ * then refetches. Mirrors the General-settings save flow (patch → toast →
+ * refetch → surface errors).
+ */
 export function useSaveVariables(): UseSaveVariables {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 	const { showErrorModal } = useErrorModal();
 	const [isSaving, setIsSaving] = useState(false);
 
@@ -28,8 +33,9 @@ export function useSaveVariables(): UseSaveVariables {
 			const dtos = variables.map(formModelToDto);
 			try {
 				setIsSaving(true);
-				await patchAsync(buildVariablesPatch(dtos));
+				await patchDashboardV2({ id: dashboardId }, buildVariablesPatch(dtos));
 				toast.success('Variables updated');
+				refetch();
 				return true;
 			} catch (error) {
 				showErrorModal(error as APIError);
@@ -38,7 +44,7 @@ export function useSaveVariables(): UseSaveVariables {
 				setIsSaving(false);
 			}
 		},
-		[dashboardId, patchAsync, showErrorModal],
+		[dashboardId, refetch, showErrorModal],
 	);
 
 	return { save, isSaving };

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/__tests__/usePanelEditorSave.test.ts

@@ -1,36 +1,40 @@
 import { renderHook } from '@testing-library/react';
+import {
+	getGetDashboardV2QueryKey,
+	usePatchDashboardV2,
+} from 'api/generated/services/dashboard';
 import type { DashboardtypesPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';
 
 import { usePanelEditorSave } from '../usePanelEditorSave';
 
-const mockPatchAsync = jest.fn().mockResolvedValue(undefined);
-let mockIsPatching = false;
-jest.mock('../../../hooks/useOptimisticPatch', () => ({
-	useOptimisticPatch: (): {
-		patchAsync: jest.Mock;
-		isPatching: boolean;
-		error: Error | null;
-	} => ({ patchAsync: mockPatchAsync, isPatching: mockIsPatching, error: null }),
-}));
-
-// The hook reads getQueryData only for the isNew branch; a stub client is enough here.
+const mockInvalidateQueries = jest.fn();
 jest.mock('react-query', () => ({
-	useQueryClient: (): { getQueryData: jest.Mock } => ({
-		getQueryData: jest.fn(),
+	useQueryClient: (): { invalidateQueries: jest.Mock } => ({
+		invalidateQueries: mockInvalidateQueries,
 	}),
 }));
 
 jest.mock('api/generated/services/dashboard', () => ({
+	usePatchDashboardV2: jest.fn(),
 	getGetDashboardV2QueryKey: jest.fn(() => ['/api/v2/dashboards/dash-1']),
 }));
 
+const mockUsePatch = usePatchDashboardV2 as unknown as jest.Mock;
+const mockGetQueryKey = getGetDashboardV2QueryKey as unknown as jest.Mock;
+
 describe('usePanelEditorSave', () => {
+	const mutateAsync = jest.fn().mockResolvedValue(undefined);
+
 	beforeEach(() => {
 		jest.clearAllMocks();
-		mockIsPatching = false;
+		mockUsePatch.mockReturnValue({
+			mutateAsync,
+			isLoading: false,
+			error: null,
+		});
 	});
 
-	it('optimistically patches an add replacing the whole panel spec', async () => {
+	it('emits an add patch replacing the whole panel spec and invalidates the dashboard query', async () => {
 		const { result } = renderHook(() =>
 			usePanelEditorSave({ dashboardId: 'dash-1', panelId: 'panel-9' }),
 		);
@@ -46,17 +50,28 @@ describe('usePanelEditorSave', () => {
 
 		await result.current.save(spec);
 
-		expect(mockPatchAsync).toHaveBeenCalledWith([
-			{
-				op: 'add',
-				path: '/spec/panels/panel-9/spec',
-				value: spec,
-			},
+		expect(mutateAsync).toHaveBeenCalledWith({
+			pathParams: { id: 'dash-1' },
+			data: [
+				{
+					op: 'add',
+					path: '/spec/panels/panel-9/spec',
+					value: spec,
+				},
+			],
+		});
+		expect(mockGetQueryKey).toHaveBeenCalledWith({ id: 'dash-1' });
+		expect(mockInvalidateQueries).toHaveBeenCalledWith([
+			'/api/v2/dashboards/dash-1',
 		]);
 	});
 
-	it('surfaces the patch in-flight state as isSaving', () => {
-		mockIsPatching = true;
+	it('surfaces the mutation loading state as isSaving', () => {
+		mockUsePatch.mockReturnValue({
+			mutateAsync,
+			isLoading: true,
+			error: null,
+		});
 
 		const { result } = renderHook(() =>
 			usePanelEditorSave({ dashboardId: 'dash-1', panelId: 'panel-9' }),

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/usePanelEditorSave.ts

@@ -1,7 +1,10 @@
 import { useCallback } from 'react';
 import { useQueryClient } from 'react-query';
 import { v4 as uuid } from 'uuid';
-import { getGetDashboardV2QueryKey } from 'api/generated/services/dashboard';
+import {
+	getGetDashboardV2QueryKey,
+	usePatchDashboardV2,
+} from 'api/generated/services/dashboard';
 import {
 	type DashboardtypesJSONPatchOperationDTO,
 	type DashboardtypesPanelSpecDTO,
@@ -10,7 +13,6 @@ import {
 	type GetDashboardV2200,
 } from 'api/generated/services/sigNoz.schemas';
 
-import { useOptimisticPatch } from '../../hooks/useOptimisticPatch';
 import { createPanelOps } from '../../patchOps';
 
 interface UsePanelEditorSaveArgs {
@@ -41,14 +43,15 @@ export function usePanelEditorSave({
 	layoutIndex,
 }: UsePanelEditorSaveArgs): UsePanelEditorSaveApi {
 	const queryClient = useQueryClient();
-	const { patchAsync, isPatching, error } = useOptimisticPatch(dashboardId);
+	const { mutateAsync, isLoading, error } = usePatchDashboardV2();
 
 	const save = useCallback(
 		async (spec: DashboardtypesPanelSpecDTO): Promise<void> => {
+			const dashboardQueryKey = getGetDashboardV2QueryKey({ id: dashboardId });
+
 			let ops: DashboardtypesJSONPatchOperationDTO[];
 			if (isNew) {
 				// Resolve the target section against the freshest dashboard we have.
-				const dashboardQueryKey = getGetDashboardV2QueryKey({ id: dashboardId });
 				const cached =
 					queryClient.getQueryData<GetDashboardV2200>(dashboardQueryKey);
 				ops = createPanelOps({
@@ -67,11 +70,11 @@ export function usePanelEditorSave({
 				];
 			}
 
-			// Optimistic cache write + settle refetch (replaces the manual invalidate).
-			await patchAsync(ops);
+			await mutateAsync({ pathParams: { id: dashboardId }, data: ops });
+			await queryClient.invalidateQueries(dashboardQueryKey);
 		},
-		[dashboardId, panelId, isNew, layoutIndex, patchAsync, queryClient],
+		[dashboardId, panelId, isNew, layoutIndex, mutateAsync, queryClient],
 	);
 
-	return { save, isSaving: isPatching, error };
+	return { save, isSaving: isLoading, error: (error as Error) ?? null };
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeSelectionModal.module.scss

@@ -4,25 +4,19 @@
 	gap: 8px;
 }
 
-.panelTypeCard {
+.typeButton {
 	display: flex;
-	flex-direction: column;
 	align-items: center;
-	border: 1px solid var(--l2-border);
-	background: var(--l2-background);
+	gap: 8px;
 	padding: 12px;
-	gap: 12px;
-	cursor: pointer;
-	font: inherit;
+	background: var(--bg-ink-400, #0b0c0e);
+	border: 1px solid var(--l1-border);
 	border-radius: 4px;
 	color: var(--l1-foreground);
-	transition:
-		transform 180ms ease,
-		border-color 180ms ease;
+	cursor: pointer;
+	text-align: left;
 
 	&:hover {
-		background-color: var(--l2-background-hover);
-		transform: translateY(-2px);
-		border-color: var(--bg-robin-400);
+		border-color: var(--bg-robin-500);
 	}
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeSelectionModal.tsx

@@ -1,5 +1,5 @@
-import { Color } from '@signozhq/design-tokens';
-import { DialogWrapper } from '@signozhq/ui/dialog';
+import { Modal } from 'antd';
+import { Button } from '@signozhq/ui/button';
 
 import type { PanelKind } from '../../../Panels/types/panelKind';
 import { PANEL_TYPES } from './constants';
@@ -17,30 +17,29 @@ function PanelTypeSelectionModal({
 	onSelect,
 }: PanelTypeSelectionModalProps): JSX.Element {
 	return (
-		<DialogWrapper
+		<Modal
 			open={open}
-			onOpenChange={(isOpen): void => {
-				if (!isOpen) {
-					onClose();
-				}
-			}}
 			title="Select a panel type"
+			onCancel={onClose}
+			footer={null}
+			destroyOnClose
 		>
 			<div className={styles.grid}>
 				{PANEL_TYPES.map(({ panelKind, label, Icon }) => (
-					<button
+					<Button
 						key={panelKind}
 						type="button"
-						className={styles.panelTypeCard}
+						variant="ghost"
+						className={styles.typeButton}
 						data-testid={`panel-type-${panelKind}`}
 						onClick={(): void => onSelect(panelKind)}
 					>
-						<Icon size={24} color={Color.BG_ROBIN_400} />
+						<Icon size={14} />
 						{label}
-					</button>
+					</Button>
 				))}
 			</div>
-		</DialogWrapper>
+		</Modal>
 	);
 }
 

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/__tests__/useClonePanel.test.ts

@@ -1,15 +1,12 @@
 import { renderHook } from '@testing-library/react';
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 
 import { useDashboardStore } from '../../../../store/useDashboardStore';
 import type { DashboardSection } from '../../../../utils';
 import { useClonePanel } from '../useClonePanel';
 
-const mockPatchAsync = jest.fn().mockResolvedValue(undefined);
-jest.mock('../../../../hooks/useOptimisticPatch', () => ({
-	useOptimisticPatch: (): { patchAsync: jest.Mock; isPatching: boolean } => ({
-		patchAsync: mockPatchAsync,
-		isPatching: false,
-	}),
+jest.mock('api/generated/services/dashboard', () => ({
+	patchDashboardV2: jest.fn().mockResolvedValue(undefined),
 }));
 
 const mockToastPromise = jest.fn();
@@ -19,6 +16,8 @@ jest.mock('@signozhq/ui/sonner', () => ({
 
 jest.mock('uuid', () => ({ v4: (): string => 'cloned-id' }));
 
+const mockPatch = patchDashboardV2 as unknown as jest.Mock;
+
 const sourcePanel = {
 	kind: 'Panel',
 	spec: {
@@ -46,7 +45,7 @@ function sections(): DashboardSection[] {
 describe('useClonePanel', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
-		useDashboardStore.setState({ dashboardId: 'dash-1' });
+		useDashboardStore.setState({ dashboardId: 'dash-1', refetch: jest.fn() });
 	});
 
 	it('patches an add of the deep-copied spec + a new item under the same section', async () => {
@@ -54,7 +53,7 @@ describe('useClonePanel', () => {
 
 		await result.current({ panelId: 'p1', layoutIndex: 0 });
 
-		expect(mockPatchAsync).toHaveBeenCalledWith([
+		expect(mockPatch).toHaveBeenCalledWith({ id: 'dash-1' }, [
 			{
 				op: 'add',
 				path: '/spec/panels/cloned-id',
@@ -93,7 +92,7 @@ describe('useClonePanel', () => {
 
 		await result.current({ panelId: 'p1', layoutIndex: 0 });
 
-		const ops = mockPatchAsync.mock.calls[0][0];
+		const ops = mockPatch.mock.calls[0][1];
 		// Room in the last row (4 + 4 = 8 ≤ 12 cols) → sits to the right at y:0.
 		expect(ops[1].value).toMatchObject({ x: 4, y: 0, width: 4, height: 5 });
 	});
@@ -103,7 +102,7 @@ describe('useClonePanel', () => {
 
 		await result.current({ panelId: 'p1', layoutIndex: 0 });
 
-		const ops = mockPatchAsync.mock.calls[0][0];
+		const ops = mockPatch.mock.calls[0][1];
 		expect(ops[0].value).toStrictEqual(sourcePanel);
 		expect(ops[0].value).not.toBe(sourcePanel);
 	});
@@ -113,7 +112,7 @@ describe('useClonePanel', () => {
 
 		await result.current({ panelId: 'missing', layoutIndex: 0 });
 
-		expect(mockPatchAsync).not.toHaveBeenCalled();
+		expect(mockPatch).not.toHaveBeenCalled();
 		expect(mockToastPromise).not.toHaveBeenCalled();
 	});
 
@@ -133,7 +132,7 @@ describe('useClonePanel', () => {
 	});
 
 	it('swallows a patch rejection (toast owns the error UX) — does not throw', async () => {
-		mockPatchAsync.mockRejectedValueOnce(new Error('boom'));
+		mockPatch.mockRejectedValueOnce(new Error('boom'));
 		const { result } = renderHook(() => useClonePanel({ sections: sections() }));
 
 		await expect(

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/__tests__/useCreateAlertFromPanel.test.ts

@@ -1,7 +1,6 @@
 import { renderHook } from '@testing-library/react';
 import logEvent from 'api/common/logEvent';
 import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';
-import { Querybuildertypesv5VariableTypeDTO } from 'api/generated/services/sigNoz.schemas';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { useDashboardStore } from 'pages/DashboardPageV2/DashboardContainer/store/useDashboardStore';
 
@@ -19,55 +18,12 @@ jest.mock('hooks/useSafeNavigate', () => ({
 	}),
 }));
 
-const mockToastError = jest.fn();
-jest.mock('@signozhq/ui/sonner', () => ({
-	toast: { error: (...args: unknown[]): void => mockToastError(...args) },
-}));
-
-jest.mock('react-redux', () => ({
-	useSelector: (selector: (state: unknown) => unknown): unknown =>
-		selector({ globalTime: { minTime: 1_000_000, maxTime: 2_000_000 } }),
-}));
-
-const mockSubstituteVars = jest.fn();
-jest.mock('api/generated/services/querier', () => ({
-	useReplaceVariables: (): { mutate: jest.Mock } => ({
-		mutate: mockSubstituteVars,
-	}),
-}));
-
-// Stub the builders so this asserts only the hook's orchestration.
+// The V5→V1 query→URL translation is covered by buildCreateAlertUrl's own tests;
+// stub it so this asserts only the hook's side effects (analytics + navigation).
 jest.mock('../../utils/buildCreateAlertUrl', () => ({
-	buildCreateAlertUrl: (): string => '/alerts/new?composite=sync',
-	buildAlertUrl: (): string => '/alerts/new?composite=substituted',
-	readPanelUnit: (): string | undefined => undefined,
+	buildCreateAlertUrl: (): string => '/alerts/new?composite=1',
 }));
 
-// Keep the real exports (getPanelQueryType reads them); stub only the builder.
-const mockBuildQueryRangeRequest = jest.fn((_args?: unknown) => ({
-	request: 'payload',
-}));
-jest.mock(
-	'pages/DashboardPageV2/DashboardContainer/queryV5/buildQueryRangeRequest',
-	() => ({
-		...jest.requireActual(
-			'pages/DashboardPageV2/DashboardContainer/queryV5/buildQueryRangeRequest',
-		),
-		buildQueryRangeRequest: (args: unknown): unknown =>
-			mockBuildQueryRangeRequest(args),
-	}),
-);
-
-jest.mock(
-	'pages/DashboardPageV2/DashboardContainer/queryV5/persesQueryAdapters',
-	() => ({
-		...jest.requireActual(
-			'pages/DashboardPageV2/DashboardContainer/queryV5/persesQueryAdapters',
-		),
-		envelopesToQuery: (): unknown => ({ resolved: 'query' }),
-	}),
-);
-
 const mockLogEvent = logEvent as jest.Mock;
 
 const panel = {
@@ -82,7 +38,17 @@ const panel = {
 describe('useCreateAlertFromPanel', () => {
 	beforeEach(() => {
 		jest.clearAllMocks();
-		useDashboardStore.setState({ dashboardId: 'dash-1', resolvedVariables: {} });
+		useDashboardStore.setState({ dashboardId: 'dash-1' });
+	});
+
+	it('opens the seeded alert builder in a new tab', () => {
+		const { result } = renderHook(() => useCreateAlertFromPanel());
+
+		result.current(panel, 'panel-1');
+
+		expect(mockSafeNavigate).toHaveBeenCalledWith('/alerts/new?composite=1', {
+			newTab: true,
+		});
 	});
 
 	it('logs the create-alert action with panel and dashboard context (V1 parity)', () => {
@@ -100,80 +66,4 @@ describe('useCreateAlertFromPanel', () => {
 			}),
 		);
 	});
-
-	describe('with no variable selections', () => {
-		it('seeds the alert synchronously without a substitute round-trip', () => {
-			const { result } = renderHook(() => useCreateAlertFromPanel());
-
-			result.current(panel, 'panel-1');
-
-			expect(mockSubstituteVars).not.toHaveBeenCalled();
-			expect(mockSafeNavigate).toHaveBeenCalledWith('/alerts/new?composite=sync', {
-				newTab: true,
-			});
-		});
-	});
-
-	describe('with variable selections', () => {
-		beforeEach(() => {
-			useDashboardStore.setState({
-				dashboardId: 'dash-1',
-				resolvedVariables: {
-					'dash-1': {
-						service: {
-							type: Querybuildertypesv5VariableTypeDTO.query,
-							value: 'checkout',
-						},
-					},
-				},
-			});
-		});
-
-		it('substitutes variables before seeding, then opens the resolved alert', () => {
-			const { result } = renderHook(() => useCreateAlertFromPanel());
-
-			result.current(panel, 'panel-1');
-
-			// Round-trips the panel's queries + resolved variables.
-			expect(mockBuildQueryRangeRequest).toHaveBeenCalledWith(
-				expect.objectContaining({
-					queries: panel.spec.queries,
-					panelType: PANEL_TYPES.TIME_SERIES,
-					variables: { service: { type: 'query', value: 'checkout' } },
-				}),
-			);
-			expect(mockSubstituteVars).toHaveBeenCalledWith(
-				{ data: { request: 'payload' } },
-				expect.objectContaining({
-					onSuccess: expect.any(Function),
-					onError: expect.any(Function),
-				}),
-			);
-			// Nothing opens until the round-trip resolves.
-			expect(mockSafeNavigate).not.toHaveBeenCalled();
-
-			const { onSuccess } = mockSubstituteVars.mock.calls[0][1];
-			onSuccess({ data: { compositeQuery: { queries: [{ type: 'builder' }] } } });
-
-			expect(mockSafeNavigate).toHaveBeenCalledWith(
-				'/alerts/new?composite=substituted',
-				{ newTab: true },
-			);
-		});
-
-		it('notifies and does not navigate when substitution fails', () => {
-			const { result } = renderHook(() => useCreateAlertFromPanel());
-
-			result.current(panel, 'panel-1');
-
-			const { onError } = mockSubstituteVars.mock.calls[0][1];
-			onError();
-
-			expect(mockToastError).toHaveBeenCalledWith(
-				expect.any(String),
-				expect.objectContaining({ description: expect.any(String) }),
-			);
-			expect(mockSafeNavigate).not.toHaveBeenCalled();
-		});
-	});
 });

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useClonePanel.ts

@@ -3,7 +3,8 @@ import { toast } from '@signozhq/ui/sonner';
 import { cloneDeep } from 'lodash-es';
 import { v4 as uuid } from 'uuid';
 
-import { useOptimisticPatch } from '../../../hooks/useOptimisticPatch';
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+
 import {
 	addPanelToSectionOps,
 	findFreeSlot,
@@ -31,7 +32,7 @@ export function useClonePanel({
 	sections,
 }: Params): (args: ClonePanelArgs) => Promise<void> {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 
 	return useCallback(
 		async ({ panelId, layoutIndex }: ClonePanelArgs): Promise<void> => {
@@ -44,7 +45,8 @@ export function useClonePanel({
 			const newPanelId = uuid();
 			const { x, y } = findFreeSlot(section.items, source.width);
 
-			const clone = patchAsync(
+			const clone = patchDashboardV2(
+				{ id: dashboardId },
 				addPanelToSectionOps({
 					panelId: newPanelId,
 					panel: cloneDeep(source.panel),
@@ -66,14 +68,15 @@ export function useClonePanel({
 				position: 'top-center',
 			});
 
-			// toast.promise owns the error UX; swallow here to avoid an unhandled
-			// rejection (the optimistic cache write + settle refetch handle state).
+			// Refetch only on success; toast.promise owns the error UX, so swallow
+			// the rejection to avoid an unhandled rejection.
 			try {
 				await clone;
+				refetch();
 			} catch {
 				// no-op
 			}
 		},
-		[sections, dashboardId, patchAsync],
+		[sections, dashboardId, refetch],
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useCreateAlertFromPanel.ts

@@ -1,32 +1,18 @@
 import { useCallback } from 'react';
-// eslint-disable-next-line no-restricted-imports -- global time still lives in redux
-import { useSelector } from 'react-redux';
-import { toast } from '@signozhq/ui/sonner';
 import logEvent from 'api/common/logEvent';
-import { useReplaceVariables } from 'api/generated/services/querier';
 import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';
-import { SOMETHING_WENT_WRONG } from 'constants/api';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import { PANEL_KIND_TO_PANEL_TYPE } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/panelKind';
 import { getPanelQueryType } from 'pages/DashboardPageV2/DashboardContainer/Panels/utils/getPanelQueryType';
-import { buildQueryRangeRequest } from 'pages/DashboardPageV2/DashboardContainer/queryV5/buildQueryRangeRequest';
-import { envelopesToQuery } from 'pages/DashboardPageV2/DashboardContainer/queryV5/persesQueryAdapters';
-import { selectResolvedVariables } from 'pages/DashboardPageV2/DashboardContainer/store/slices/variableSelectionSlice';
 import { useDashboardStore } from 'pages/DashboardPageV2/DashboardContainer/store/useDashboardStore';
-import { AppState } from 'store/reducers';
-import { GlobalReducer } from 'types/reducer/globalTime';
 
-import {
-	buildAlertUrl,
-	buildCreateAlertUrl,
-	readPanelUnit,
-} from '../utils/buildCreateAlertUrl';
+import { buildCreateAlertUrl } from '../utils/buildCreateAlertUrl';
 
 /**
- * Callback that seeds the alert builder from a panel's query in a new tab (V1 parity
- * with `useCreateAlerts`; panel supplied at call time so the callback stays stable).
- * With variable selections, resolves them via `/substitute_vars` first; otherwise
- * seeds synchronously (the round-trip would be a no-op).
+ * Returns a callback that opens the alert builder in a new tab, seeded from a
+ * panel's query, and logs the action — mirroring V1's `useCreateAlerts`
+ * ('dashboardView' caller). The panel is supplied at call time so the callback
+ * stays stable across panels (and the dashboard's react-query refetches).
  */
 export function useCreateAlertFromPanel(): (
 	panel: DashboardtypesPanelDTO,
@@ -34,61 +20,18 @@ export function useCreateAlertFromPanel(): (
 ) => void {
 	const { safeNavigate } = useSafeNavigate();
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const variables = useDashboardStore(selectResolvedVariables(dashboardId));
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-	const { mutate: substituteVars } = useReplaceVariables();
 
 	return useCallback(
 		(panel: DashboardtypesPanelDTO, panelId: string): void => {
-			const panelType = PANEL_KIND_TO_PANEL_TYPE[panel.spec.plugin.kind];
-
 			void logEvent('Dashboard Detail: Panel action', {
 				action: 'createAlerts',
-				panelType,
+				panelType: PANEL_KIND_TO_PANEL_TYPE[panel.spec.plugin.kind],
 				dashboardId,
 				widgetId: panelId,
 				queryType: getPanelQueryType(panel),
 			});
-
-			if (Object.keys(variables).length === 0) {
-				safeNavigate(buildCreateAlertUrl(panel), { newTab: true });
-				return;
-			}
-
-			// Redux global time is nanoseconds; the request DTO takes epoch ms.
-			const request = buildQueryRangeRequest({
-				queries: panel.spec.queries,
-				panelType,
-				startMs: minTime / 1e6,
-				endMs: maxTime / 1e6,
-				variables,
-			});
-
-			substituteVars(
-				{ data: request },
-				{
-					onSuccess: (response) => {
-						const query = envelopesToQuery(
-							response.data.compositeQuery?.queries ?? [],
-							panelType,
-						);
-						const url = buildAlertUrl(
-							query,
-							panelType,
-							readPanelUnit(panel.spec.plugin),
-						);
-						safeNavigate(url, { newTab: true });
-					},
-					onError: () => {
-						toast.error(SOMETHING_WENT_WRONG, {
-							description: 'Failed to create alert from panel',
-						});
-					},
-				},
-			);
+			safeNavigate(buildCreateAlertUrl(panel), { newTab: true });
 		},
-		[dashboardId, variables, minTime, maxTime, substituteVars, safeNavigate],
+		[dashboardId, safeNavigate],
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDeletePanel.ts

@@ -1,9 +1,9 @@
 import { useCallback } from 'react';
 
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../../hooks/useOptimisticPatch';
 import { removePanelOp, replaceSectionItemsOp } from '../../../patchOps';
 import { useDashboardStore } from '../../../store/useDashboardStore';
 import type { DashboardSection } from '../../../utils';
@@ -25,7 +25,7 @@ export function useDeletePanel({
 	sections,
 }: Params): (args: DeletePanelArgs) => Promise<void> {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 	const { showErrorModal } = useErrorModal();
 
 	return useCallback(
@@ -40,14 +40,15 @@ export function useDeletePanel({
 
 			const nextItems = section.items.filter((i) => i.id !== panelId);
 			try {
-				await patchAsync([
+				await patchDashboardV2({ id: dashboardId }, [
 					replaceSectionItemsOp(layoutIndex, nextItems),
 					removePanelOp(panelId),
 				]);
+				refetch();
 			} catch (error) {
 				showErrorModal(error as APIError);
 			}
 		},
-		[sections, dashboardId, patchAsync, showErrorModal],
+		[sections, dashboardId, refetch, showErrorModal],
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useMovePanelToSection.ts

@@ -1,9 +1,9 @@
 import { useCallback } from 'react';
 
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../../hooks/useOptimisticPatch';
 import { movePanelBetweenSectionsOps } from '../../../patchOps';
 import { useDashboardStore } from '../../../store/useDashboardStore';
 import type { DashboardSection } from '../../../utils';
@@ -27,7 +27,7 @@ export function useMovePanelToSection({
 	sections,
 }: Params): (args: MovePanelArgs) => Promise<void> {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 	const { showErrorModal } = useErrorModal();
 
 	return useCallback(
@@ -60,7 +60,8 @@ export function useMovePanelToSection({
 			const targetItems = [...target.items, { ...moved, x: 0, y: nextY }];
 
 			try {
-				await patchAsync(
+				await patchDashboardV2(
+					{ id: dashboardId },
 					movePanelBetweenSectionsOps({
 						sourceIndex: fromLayoutIndex,
 						sourceItems,
@@ -68,10 +69,11 @@ export function useMovePanelToSection({
 						targetItems,
 					}),
 				);
+				refetch();
 			} catch (error) {
 				showErrorModal(error as APIError);
 			}
 		},
-		[sections, dashboardId, patchAsync, showErrorModal],
+		[sections, dashboardId, refetch, showErrorModal],
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/utils/buildCreateAlertUrl.ts

@@ -5,14 +5,11 @@ import type {
 import { YAxisSource } from 'components/YAxisUnitSelector/types';
 import { ENTITY_VERSION_V5 } from 'constants/app';
 import { QueryParams } from 'constants/query';
-import { PANEL_TYPES } from 'constants/queryBuilder';
 import ROUTES from 'constants/routes';
 import { PANEL_KIND_TO_PANEL_TYPE } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/panelKind';
 import { fromPerses } from 'pages/DashboardPageV2/DashboardContainer/queryV5/persesQueryAdapters';
-import type { Query } from 'types/api/queryBuilder/queryBuilderData';
 
-/** The panel's configured y-axis unit, for the kinds that carry one. */
-export function readPanelUnit(
+function readPanelUnit(
 	plugin: DashboardtypesPanelPluginDTO,
 ): string | undefined {
 	switch (plugin.kind) {
@@ -27,17 +24,20 @@ export function readPanelUnit(
 }
 
 /**
- * Assembles the `/alerts/new` URL from a ready V1 `Query`: the alert page reads it
- * from `compositeQuery`, tagged with the panel type, entity version, and a
- * `dashboards` source.
+ * Builds the `/alerts/new` URL that seeds the alert builder from a panel's query,
+ * mirroring V1's `useCreateAlerts`: the panel's V5 queries are translated to the
+ * V1 `Query` the alert page reads from `compositeQuery`, tagged with the panel
+ * type, entity version, and a `dashboards` source.
+ *
+ * Unlike V1 there is no `/substitute_vars` round-trip — V2 has no query-variable
+ * plumbing yet, so any dashboard-variable references travel through verbatim.
  */
-export function buildAlertUrl(
-	query: Query,
-	panelType: PANEL_TYPES,
-	unit?: string,
-): string {
+export function buildCreateAlertUrl(panel: DashboardtypesPanelDTO): string {
+	const panelType = PANEL_KIND_TO_PANEL_TYPE[panel.spec.plugin.kind];
+	const query = fromPerses(panel.spec.queries, panelType);
+
+	const unit = readPanelUnit(panel.spec.plugin);
 	if (unit) {
-		// eslint-disable-next-line no-param-reassign
 		query.unit = unit;
 	}
 
@@ -52,15 +52,3 @@ export function buildAlertUrl(
 
 	return `${ROUTES.ALERTS_NEW}?${params.toString()}`;
 }
-
-/**
- * Seeds the alert builder from a panel's query — the no-variable path, so any
- * dashboard-variable references travel through verbatim. When the dashboard has
- * selections, `useCreateAlertFromPanel` runs a `/substitute_vars` round-trip first
- * and assembles the URL from the resolved queries via {@link buildAlertUrl}.
- */
-export function buildCreateAlertUrl(panel: DashboardtypesPanelDTO): string {
-	const panelType = PANEL_KIND_TO_PANEL_TYPE[panel.spec.plugin.kind];
-	const query = fromPerses(panel.spec.queries, panelType);
-	return buildAlertUrl(query, panelType, readPanelUnit(panel.spec.plugin));
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useAddSection.ts

@@ -1,10 +1,10 @@
 import { useCallback, useState } from 'react';
 
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../../hooks/useOptimisticPatch';
 import {
 	addSectionOp,
 	newGridLayout,
@@ -15,9 +15,9 @@ import { useDashboardStore } from '../../../store/useDashboardStore';
 const SECTION_SELECTOR = '[data-testid^="dashboard-section-"]';
 
 /**
- * Waits (via rAF) for the appended section to render, then scrolls it into view.
- * Polls because the optimistic cache write commits to the DOM a frame or two after
- * the patch call; bails after ~40 frames.
+ * Waits (via rAF) for the refetch to render the appended section, then scrolls
+ * it into view. Polls because `refetch` resolves before React commits the new
+ * section to the DOM; bails after ~40 frames.
  */
 function scrollToNewSection(prevCount: number, attempts = 40): void {
 	const sections = document.querySelectorAll(SECTION_SELECTOR);
@@ -49,7 +49,7 @@ interface Result {
  */
 export function useAddSection({ layouts }: Params): Result {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 	const [isSaving, setIsSaving] = useState(false);
 	const { showErrorModal } = useErrorModal();
 
@@ -66,7 +66,8 @@ export function useAddSection({ layouts }: Params): Result {
 			const prevSectionCount = document.querySelectorAll(SECTION_SELECTOR).length;
 			try {
 				setIsSaving(true);
-				await patchAsync([op]);
+				await patchDashboardV2({ id: dashboardId }, [op]);
+				refetch();
 				scrollToNewSection(prevSectionCount);
 			} catch (error) {
 				showErrorModal(error as APIError);
@@ -74,7 +75,7 @@ export function useAddSection({ layouts }: Params): Result {
 				setIsSaving(false);
 			}
 		},
-		[layouts, dashboardId, patchAsync, showErrorModal],
+		[layouts, dashboardId, refetch, showErrorModal],
 	);
 
 	return { addSection, isSaving };

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useDeleteSection.ts

@@ -1,10 +1,10 @@
 import { useCallback, useState } from 'react';
 
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import type { DashboardtypesJSONPatchOperationDTO } from 'api/generated/services/sigNoz.schemas';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../../hooks/useOptimisticPatch';
 import { removePanelOp, removeSectionOp } from '../../../patchOps';
 import { useDashboardStore } from '../../../store/useDashboardStore';
 import type { DashboardSection } from '../../../utils';
@@ -24,7 +24,7 @@ interface Result {
  */
 export function useDeleteSection({ section }: Params): Result {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 	const [isSaving, setIsSaving] = useState(false);
 	const { showErrorModal } = useErrorModal();
 
@@ -38,13 +38,14 @@ export function useDeleteSection({ section }: Params): Result {
 		ops.push(removeSectionOp(section.layoutIndex));
 		try {
 			setIsSaving(true);
-			await patchAsync(ops);
+			await patchDashboardV2({ id: dashboardId }, ops);
+			refetch();
 		} catch (error) {
 			showErrorModal(error as APIError);
 		} finally {
 			setIsSaving(false);
 		}
-	}, [section, dashboardId, patchAsync, showErrorModal]);
+	}, [section, dashboardId, refetch, showErrorModal]);
 
 	return { deleteSection, isSaving };
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useFirstSectionMigration.ts

@@ -1,10 +1,10 @@
 import { useCallback, useState } from 'react';
 
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import type { DashboardtypesJSONPatchOperationDTO } from 'api/generated/services/sigNoz.schemas';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../../hooks/useOptimisticPatch';
 import { addSectionOp, titleUntitledSectionOp } from '../../../patchOps';
 import { useDashboardStore } from '../../../store/useDashboardStore';
 import type { DashboardSection } from '../../../utils';
@@ -26,7 +26,7 @@ interface Result {
  */
 export function useFirstSectionMigration({ sections }: Params): Result {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 	const [isSaving, setIsSaving] = useState(false);
 	const { showErrorModal } = useErrorModal();
 
@@ -49,14 +49,15 @@ export function useFirstSectionMigration({ sections }: Params): Result {
 
 			try {
 				setIsSaving(true);
-				await patchAsync(ops);
+				await patchDashboardV2({ id: dashboardId }, ops);
+				refetch();
 			} catch (error) {
 				showErrorModal(error as APIError);
 			} finally {
 				setIsSaving(false);
 			}
 		},
-		[sections, dashboardId, patchAsync, showErrorModal],
+		[sections, dashboardId, refetch, showErrorModal],
 	);
 
 	return { migrate, isSaving };

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/usePersistLayout.ts

@@ -1,10 +1,10 @@
 import { useCallback, useState } from 'react';
 import type { Layout } from 'react-grid-layout';
 
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../../hooks/useOptimisticPatch';
 import { replaceSectionItemsOp } from '../../../patchOps';
 import { useDashboardStore } from '../../../store/useDashboardStore';
 import type { GridItem } from '../../../utils';
@@ -65,7 +65,7 @@ function hasGeometryChanged(next: GridItem[], prev: GridItem[]): boolean {
  */
 export function usePersistLayout({ layoutIndex, items }: Params): Result {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 	const [isSaving, setIsSaving] = useState(false);
 	const { showErrorModal } = useErrorModal();
 
@@ -80,14 +80,17 @@ export function usePersistLayout({ layoutIndex, items }: Params): Result {
 			}
 			try {
 				setIsSaving(true);
-				await patchAsync([replaceSectionItemsOp(layoutIndex, nextItems)]);
+				await patchDashboardV2({ id: dashboardId }, [
+					replaceSectionItemsOp(layoutIndex, nextItems),
+				]);
+				refetch();
 			} catch (error) {
 				showErrorModal(error as APIError);
 			} finally {
 				setIsSaving(false);
 			}
 		},
-		[dashboardId, items, layoutIndex, patchAsync, showErrorModal],
+		[dashboardId, items, layoutIndex, refetch, showErrorModal],
 	);
 
 	return { handleLayoutChange, isSaving };

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useRenameSection.ts

@@ -1,9 +1,9 @@
 import { useCallback, useState } from 'react';
 
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../../hooks/useOptimisticPatch';
 import { renameSectionOp } from '../../../patchOps';
 import { useDashboardStore } from '../../../store/useDashboardStore';
 
@@ -19,7 +19,7 @@ interface Result {
 /** Renames a section's title via `replace /spec/layouts/<i>/spec/display/title`. */
 export function useRenameSection({ layoutIndex }: Params): Result {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 	const [isSaving, setIsSaving] = useState(false);
 	const { showErrorModal } = useErrorModal();
 
@@ -31,7 +31,10 @@ export function useRenameSection({ layoutIndex }: Params): Result {
 			}
 			try {
 				setIsSaving(true);
-				await patchAsync([renameSectionOp(layoutIndex, trimmed)]);
+				await patchDashboardV2({ id: dashboardId }, [
+					renameSectionOp(layoutIndex, trimmed),
+				]);
+				refetch();
 				return true;
 			} catch (error) {
 				showErrorModal(error as APIError);
@@ -40,7 +43,7 @@ export function useRenameSection({ layoutIndex }: Params): Result {
 				setIsSaving(false);
 			}
 		},
-		[dashboardId, layoutIndex, patchAsync, showErrorModal],
+		[dashboardId, layoutIndex, refetch, showErrorModal],
 	);
 
 	return { rename, isSaving };

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useSectionDragReorder.ts

@@ -9,11 +9,11 @@ import {
 } from '@dnd-kit/core';
 import { arrayMove, sortableKeyboardCoordinates } from '@dnd-kit/sortable';
 
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
 import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
-import { useOptimisticPatch } from '../../../hooks/useOptimisticPatch';
 import { reorderLayoutsOp } from '../../../patchOps';
 import { useDashboardStore } from '../../../store/useDashboardStore';
 import type { DashboardSection } from '../../../utils';
@@ -43,7 +43,7 @@ interface Result {
  */
 export function useSectionDragReorder({ sections, layouts }: Params): Result {
 	const dashboardId = useDashboardStore((s) => s.dashboardId);
-	const { patchAsync } = useOptimisticPatch();
+	const refetch = useDashboardStore((s) => s.refetch);
 	const [activeId, setActiveId] = useState<string | null>(null);
 	const [localOrderIds, setLocalOrderIds] = useState<string[] | null>(null);
 	const { showErrorModal } = useErrorModal();
@@ -99,13 +99,14 @@ export function useSectionDragReorder({ sections, layouts }: Params): Result {
 				.filter((l): l is DashboardtypesLayoutDTO => l !== undefined);
 
 			try {
-				await patchAsync([reorderLayoutsOp(newLayouts)]);
+				await patchDashboardV2({ id: dashboardId }, [reorderLayoutsOp(newLayouts)]);
+				refetch();
 			} catch (error) {
 				setLocalOrderIds(null); // revert optimistic order on failure
 				showErrorModal(error as APIError);
 			}
 		},
-		[orderedSections, layouts, dashboardId, patchAsync, showErrorModal],
+		[orderedSections, layouts, dashboardId, refetch, showErrorModal],
 	);
 
 	const activeSection = useMemo(

frontend/src/pages/DashboardPageV2/DashboardContainer/hooks/__tests__/useOptimisticPatch.test.ts

@@ -1,107 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { useMutation, useQueryClient } from 'react-query';
-// eslint-disable-next-line no-restricted-imports -- the hook's own test mocks and asserts the underlying patchDashboardV2 call.
-import { patchDashboardV2 } from 'api/generated/services/dashboard';
-import type { GetDashboardV2200 } from 'api/generated/services/sigNoz.schemas';
-import { DashboardtypesPatchOpDTO } from 'api/generated/services/sigNoz.schemas';
-
-import { useOptimisticPatch } from '../useOptimisticPatch';
-
-const QUERY_KEY = ['/api/v2/dashboards/dash-1'];
-
-jest.mock('react-query', () => ({
-	useMutation: jest.fn(),
-	useQueryClient: jest.fn(),
-}));
-
-jest.mock('api/generated/services/dashboard', () => ({
-	patchDashboardV2: jest.fn(),
-	getGetDashboardV2QueryKey: jest.fn(() => ['/api/v2/dashboards/dash-1']),
-}));
-
-jest.mock('../../store/useDashboardStore', () => ({
-	useDashboardStore: jest.fn(
-		(selector: (s: { dashboardId: string }) => unknown) =>
-			selector({ dashboardId: 'dash-1' }),
-	),
-}));
-
-const queryClient = {
-	cancelQueries: jest.fn().mockResolvedValue(undefined),
-	getQueryData: jest.fn(),
-	setQueryData: jest.fn(),
-	invalidateQueries: jest.fn().mockResolvedValue(undefined),
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let captured: { fn: (ops: any) => unknown; options: any };
-
-function dashboardEnvelope(name: string): GetDashboardV2200 {
-	return {
-		data: { spec: { display: { name } } },
-	} as unknown as GetDashboardV2200;
-}
-
-const replaceNameOp = {
-	op: DashboardtypesPatchOpDTO.replace,
-	path: '/spec/display/name',
-	value: 'B',
-};
-
-beforeEach(() => {
-	jest.clearAllMocks();
-	(useQueryClient as jest.Mock).mockReturnValue(queryClient);
-	(useMutation as jest.Mock).mockImplementation((fn, options) => {
-		captured = { fn, options };
-		return { mutateAsync: jest.fn(), isLoading: false };
-	});
-	renderHook(() => useOptimisticPatch());
-});
-
-describe('useOptimisticPatch', () => {
-	it('mutationFn sends the ops to patchDashboardV2 for the current dashboard', () => {
-		captured.fn([replaceNameOp]);
-		expect(patchDashboardV2).toHaveBeenCalledWith({ id: 'dash-1' }, [
-			replaceNameOp,
-		]);
-	});
-
-	it('onMutate cancels fetches, snapshots, and writes the patched dashboard to the cache', async () => {
-		const previous = dashboardEnvelope('A');
-		queryClient.getQueryData.mockReturnValue(previous);
-
-		const context = await captured.options.onMutate([replaceNameOp]);
-
-		expect(queryClient.cancelQueries).toHaveBeenCalledWith(QUERY_KEY);
-		// Optimistic write reflects the op immediately.
-		expect(queryClient.setQueryData).toHaveBeenCalledWith(QUERY_KEY, {
-			data: { spec: { display: { name: 'B' } } },
-		});
-		// Snapshot returned for rollback; original left untouched.
-		expect(context).toStrictEqual({ previous });
-		expect(previous.data).toStrictEqual({ spec: { display: { name: 'A' } } });
-	});
-
-	it('onMutate is a no-op write when there is no cached dashboard', async () => {
-		queryClient.getQueryData.mockReturnValue(undefined);
-		const context = await captured.options.onMutate([replaceNameOp]);
-		expect(queryClient.setQueryData).not.toHaveBeenCalled();
-		expect(context).toStrictEqual({ previous: undefined });
-	});
-
-	it('onError rolls the cache back to the snapshot', () => {
-		const previous = dashboardEnvelope('A');
-		captured.options.onError(new Error('boom'), [replaceNameOp], { previous });
-		expect(queryClient.setQueryData).toHaveBeenCalledWith(QUERY_KEY, previous);
-	});
-
-	it('onError without a snapshot does not touch the cache', () => {
-		captured.options.onError(new Error('boom'), [replaceNameOp], {});
-		expect(queryClient.setQueryData).not.toHaveBeenCalled();
-	});
-
-	it('onSettled invalidates the dashboard query to reconcile', () => {
-		captured.options.onSettled();
-		expect(queryClient.invalidateQueries).toHaveBeenCalledWith(QUERY_KEY);
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/hooks/useOptimisticPatch.ts

@@ -1,73 +0,0 @@
-import { useMutation, useQueryClient } from 'react-query';
-import {
-	getGetDashboardV2QueryKey,
-	// eslint-disable-next-line no-restricted-imports -- this hook is the one sanctioned caller of patchDashboardV2; everything else goes through patchAsync.
-	patchDashboardV2,
-} from 'api/generated/services/dashboard';
-import type {
-	DashboardtypesJSONPatchOperationDTO,
-	GetDashboardV2200,
-} from 'api/generated/services/sigNoz.schemas';
-import APIError from 'types/api/error';
-
-import { applyJsonPatch } from '../optimistic/applyJsonPatch';
-import { useDashboardStore } from '../store/useDashboardStore';
-
-/** Cached dashboard snapshot, kept for rollback on error. */
-interface OptimisticPatchContext {
-	previous?: GetDashboardV2200;
-}
-
-export interface UseOptimisticPatch {
-	patchAsync: (ops: DashboardtypesJSONPatchOperationDTO[]) => Promise<unknown>;
-	isPatching: boolean;
-	error: Error | null;
-}
-
-/**
- * Central optimistic mutation for V2 dashboard spec edits: writes the ops to the
- * cached dashboard immediately, rolls back on error, reconciles on settle.
- * `dashboardId` defaults to the edit-context store; the panel editor passes its own.
- */
-export function useOptimisticPatch(
-	dashboardIdOverride?: string,
-): UseOptimisticPatch {
-	const storeDashboardId = useDashboardStore((s) => s.dashboardId);
-	const dashboardId = dashboardIdOverride ?? storeDashboardId;
-	const queryClient = useQueryClient();
-	const queryKey = getGetDashboardV2QueryKey({ id: dashboardId });
-
-	const mutation = useMutation<
-		Awaited<ReturnType<typeof patchDashboardV2>>,
-		APIError,
-		DashboardtypesJSONPatchOperationDTO[],
-		OptimisticPatchContext
-	>((ops) => patchDashboardV2({ id: dashboardId }, ops), {
-		onMutate: async (ops) => {
-			await queryClient.cancelQueries(queryKey);
-			const previous = queryClient.getQueryData<GetDashboardV2200>(queryKey);
-			if (previous?.data) {
-				// Ops are rooted at the DTO's `/spec`, so patch `.data`, keep the envelope.
-				queryClient.setQueryData<GetDashboardV2200>(queryKey, {
-					...previous,
-					data: applyJsonPatch(previous.data, ops),
-				});
-			}
-			return { previous };
-		},
-		onError: (_error, _ops, context) => {
-			if (context?.previous) {
-				queryClient.setQueryData(queryKey, context.previous);
-			}
-		},
-		onSettled: () => {
-			void queryClient.invalidateQueries(queryKey);
-		},
-	});
-
-	return {
-		patchAsync: mutation.mutateAsync,
-		isPatching: mutation.isLoading,
-		error: mutation.error ?? null,
-	};
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/optimistic/__tests__/applyJsonPatch.test.ts

@@ -1,138 +0,0 @@
-import type { DashboardtypesJSONPatchOperationDTO } from 'api/generated/services/sigNoz.schemas';
-import { DashboardtypesPatchOpDTO } from 'api/generated/services/sigNoz.schemas';
-
-import { applyJsonPatch } from '../applyJsonPatch';
-
-const { add, replace, remove, move, test: testOp } = DashboardtypesPatchOpDTO;
-
-function op(
-	o: DashboardtypesPatchOpDTO,
-	path: string,
-	value?: unknown,
-): DashboardtypesJSONPatchOperationDTO {
-	return { op: o, path, value };
-}
-
-// A trimmed dashboard-spec shape; the applier is structural, so this stands in
-// for the full DTO.
-function spec(): Record<string, unknown> {
-	return {
-		spec: {
-			display: { name: 'dash' },
-			panels: { p1: { spec: { display: { name: 'A' } } } },
-			layouts: [
-				{ spec: { display: { title: 'S1' }, items: [{ x: 0 }] } },
-				{ spec: { items: [] } },
-			],
-			variables: [{ name: 'env' }],
-		},
-	};
-}
-
-describe('applyJsonPatch', () => {
-	it('does not mutate the input document', () => {
-		const doc = spec();
-		const snapshot = JSON.stringify(doc);
-		applyJsonPatch(doc, [op(replace, '/spec/display/name', 'renamed')]);
-		expect(JSON.stringify(doc)).toBe(snapshot);
-	});
-
-	it('replaces a leaf string', () => {
-		const next = applyJsonPatch(spec(), [
-			op(replace, '/spec/layouts/0/spec/display/title', 'S1-renamed'),
-		]);
-		const layouts = (next.spec as any).layouts;
-		expect(layouts[0].spec.display.title).toBe('S1-renamed');
-	});
-
-	it('adds a new object member (panel by id)', () => {
-		const next = applyJsonPatch(spec(), [
-			op(add, '/spec/panels/p2', { spec: { display: { name: 'B' } } }),
-		]);
-		expect((next.spec as any).panels.p2.spec.display.name).toBe('B');
-		// existing member untouched
-		expect((next.spec as any).panels.p1.spec.display.name).toBe('A');
-	});
-
-	it('appends to an array with the "-" token', () => {
-		const next = applyJsonPatch(spec(), [
-			op(add, '/spec/layouts/-', { spec: { items: [] } }),
-		]);
-		expect((next.spec as any).layouts).toHaveLength(3);
-	});
-
-	it('appends an item into a nested section array', () => {
-		const next = applyJsonPatch(spec(), [
-			op(add, '/spec/layouts/1/spec/items/-', { x: 5 }),
-		]);
-		expect((next.spec as any).layouts[1].spec.items).toStrictEqual([{ x: 5 }]);
-	});
-
-	it('replaces a whole array', () => {
-		const next = applyJsonPatch(spec(), [
-			op(replace, '/spec/variables', [{ name: 'region' }, { name: 'pod' }]),
-		]);
-		expect((next.spec as any).variables).toStrictEqual([
-			{ name: 'region' },
-			{ name: 'pod' },
-		]);
-	});
-
-	it('removes an array element by index (section)', () => {
-		const next = applyJsonPatch(spec(), [op(remove, '/spec/layouts/0')]);
-		const layouts = (next.spec as any).layouts;
-		expect(layouts).toHaveLength(1);
-		expect(layouts[0].spec.items).toStrictEqual([]);
-	});
-
-	it('removes an object member (panel by id)', () => {
-		const next = applyJsonPatch(spec(), [op(remove, '/spec/panels/p1')]);
-		expect((next.spec as any).panels).toStrictEqual({});
-	});
-
-	it('adds a missing object parent for an add op (title untitled section)', () => {
-		const next = applyJsonPatch(spec(), [
-			op(add, '/spec/layouts/1/spec/display', { title: 'S2' }),
-		]);
-		expect((next.spec as any).layouts[1].spec.display).toStrictEqual({
-			title: 'S2',
-		});
-	});
-
-	it('is lenient: remove on a missing path is a no-op', () => {
-		const next = applyJsonPatch(spec(), [op(remove, '/spec/panels/ghost')]);
-		expect((next.spec as any).panels.p1).toBeDefined();
-	});
-
-	it('is lenient: a path through a missing node is skipped', () => {
-		const next = applyJsonPatch(spec(), [op(replace, '/spec/nope/deep/leaf', 1)]);
-		expect(next).toStrictEqual(spec());
-	});
-
-	it('unescapes ~1 and ~0 in reference tokens', () => {
-		const doc = { spec: { m: { 'a/b': 1, 'c~d': 2 } } };
-		const next = applyJsonPatch(doc, [
-			op(replace, '/spec/m/a~1b', 9),
-			op(replace, '/spec/m/c~0d', 8),
-		]);
-		expect(next.spec.m).toStrictEqual({ 'a/b': 9, 'c~d': 8 });
-	});
-
-	it('applies multiple ops in order', () => {
-		const next = applyJsonPatch(spec(), [
-			op(add, '/spec/panels/p2', { spec: {} }),
-			op(remove, '/spec/panels/p1'),
-			op(replace, '/spec/display/name', 'z'),
-		]);
-		expect(Object.keys((next.spec as any).panels)).toStrictEqual(['p2']);
-		expect((next.spec as any).display.name).toBe('z');
-	});
-
-	it('treats move/copy/test as no-ops', () => {
-		const next = applyJsonPatch(spec(), [
-			op(move, '/spec/display/name'),
-			op(testOp, '/spec/display/name', 'dash'),
-		]);
-		expect(next).toStrictEqual(spec());
-	});
-});

frontend/src/pages/DashboardPageV2/DashboardContainer/optimistic/applyJsonPatch.ts

@@ -1,146 +0,0 @@
-import type { DashboardtypesJSONPatchOperationDTO } from 'api/generated/services/sigNoz.schemas';
-import { DashboardtypesPatchOpDTO } from 'api/generated/services/sigNoz.schemas';
-import { cloneDeep } from 'lodash-es';
-
-/**
- * Applies the RFC-6902 ops our `patchOps` builders emit to a document, so a
- * dashboard edit can be reflected in the react-query cache optimistically before
- * the server responds. Pure: deep-clones and returns a new document, never
- * mutating the input.
- *
- * Deliberately lenient — mirrors the backend's apply (a `remove`/`replace` on a
- * missing path is a no-op, `add` creates missing object parents) rather than
- * throwing as strict RFC-6902 would. This is safe because the mutation always
- * refetches on settle, so any mis-applied edge op self-corrects; the applier only
- * needs to be right for the common case to kill the perceived lag.
- *
- * Scope: `add` / `replace` / `remove` (the only ops the builders produce).
- * `move` / `copy` / `test` are never emitted, so they are treated as no-ops.
- */
-export function applyJsonPatch<T>(
-	doc: T,
-	ops: DashboardtypesJSONPatchOperationDTO[],
-): T {
-	const next = cloneDeep(doc);
-	ops.forEach((op) => applyOperation(next as unknown, op));
-	return next;
-}
-
-type JsonRecord = Record<string, unknown>;
-
-function isArray(value: unknown): value is unknown[] {
-	return Array.isArray(value);
-}
-
-function isRecord(value: unknown): value is JsonRecord {
-	return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-/** Unescape one JSON-Pointer reference token (RFC-6901): `~1`→`/`, `~0`→`~`. */
-function unescapeToken(token: string): string {
-	return token.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-
-/** Parse a JSON Pointer into its reference tokens (`""`/`"/"` → root, `[]`). */
-function parsePointer(path: string): string[] {
-	if (!path || path === '/') {
-		return [];
-	}
-	return path.slice(1).split('/').map(unescapeToken);
-}
-
-/**
- * Walks to the container that holds the pointer's last token. Returns `undefined`
- * when the path can't be resolved (lenient skip). For `add`, missing intermediate
- * object nodes are created (backend parity); array steps are never auto-created.
- */
-function navigateToParent(
-	root: unknown,
-	tokens: string[],
-	createMissing: boolean,
-): unknown {
-	let current: unknown = root;
-	for (let i = 0; i < tokens.length - 1; i += 1) {
-		const token = tokens[i];
-		if (isArray(current)) {
-			const index = token === '-' ? current.length : Number(token);
-			current = current[index];
-		} else if (isRecord(current)) {
-			if (current[token] === undefined && createMissing) {
-				current[token] = {};
-			}
-			current = current[token];
-		} else {
-			return undefined;
-		}
-		if (current === undefined || current === null) {
-			return undefined;
-		}
-	}
-	return current;
-}
-
-/** `add`: array-insert (`-` = append) or object-set. */
-function addAt(parent: unknown, key: string, value: unknown): void {
-	if (isArray(parent)) {
-		const index = key === '-' ? parent.length : Number(key);
-		parent.splice(index, 0, value);
-	} else if (isRecord(parent)) {
-		parent[key] = value;
-	}
-}
-
-/** `replace`: overwrite an in-range array index or an object key. */
-function replaceAt(parent: unknown, key: string, value: unknown): void {
-	if (isArray(parent)) {
-		const index = Number(key);
-		if (index >= 0 && index < parent.length) {
-			parent[index] = value;
-		}
-	} else if (isRecord(parent)) {
-		parent[key] = value;
-	}
-}
-
-/** `remove`: splice an in-range array index or delete an object key (lenient). */
-function removeAt(parent: unknown, key: string): void {
-	if (isArray(parent)) {
-		const index = Number(key);
-		if (index >= 0 && index < parent.length) {
-			parent.splice(index, 1);
-		}
-	} else if (isRecord(parent)) {
-		delete parent[key];
-	}
-}
-
-function applyOperation(
-	root: unknown,
-	op: DashboardtypesJSONPatchOperationDTO,
-): void {
-	const tokens = parsePointer(op.path);
-	// Whole-document ops would need to reassign the root reference — our builders
-	// never target root, so skip rather than complicate the contract.
-	if (tokens.length === 0) {
-		return;
-	}
-
-	const parent = navigateToParent(
-		root,
-		tokens,
-		op.op === DashboardtypesPatchOpDTO.add,
-	);
-	if (parent === undefined || parent === null) {
-		return;
-	}
-	const key = tokens[tokens.length - 1];
-
-	// move / copy / test are never emitted by our builders → no-op (reconciled by refetch).
-	if (op.op === DashboardtypesPatchOpDTO.add) {
-		addAt(parent, key, op.value);
-	} else if (op.op === DashboardtypesPatchOpDTO.replace) {
-		replaceAt(parent, key, op.value);
-	} else if (op.op === DashboardtypesPatchOpDTO.remove) {
-		removeAt(parent, key);
-	}
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/queryV5/__tests__/persesQueryAdapters.test.ts

@@ -1,13 +1,10 @@
-import type {
-	DashboardtypesQueryDTO,
-	Querybuildertypesv5QueryEnvelopeDTO,
-} from 'api/generated/services/sigNoz.schemas';
+import type { DashboardtypesQueryDTO } from 'api/generated/services/sigNoz.schemas';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
 import type { Query } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource } from 'types/common/queryBuilder';
 
-import { envelopesToQuery, fromPerses, toPerses } from '../persesQueryAdapters';
+import { fromPerses, toPerses } from '../persesQueryAdapters';
 
 /** A bare perses query (single plugin, not wrapped in a CompositeQuery). */
 function bareQuery(
@@ -61,26 +58,6 @@ describe('persesQueryAdapters', () => {
 		});
 	});
 
-	describe('envelopesToQuery', () => {
-		it('returns the metrics default for an empty envelope list', () => {
-			expect(envelopesToQuery([], PANEL_TYPES.TIME_SERIES)).toStrictEqual(
-				initialQueriesMap[DataSource.METRICS],
-			);
-		});
-
-		it('maps a promql envelope to a PromQL query', () => {
-			const envelopes: Querybuildertypesv5QueryEnvelopeDTO[] = [
-				{
-					type: 'promql',
-					spec: { name: 'A', query: 'up', disabled: false },
-				} as unknown as Querybuildertypesv5QueryEnvelopeDTO,
-			];
-			expect(envelopesToQuery(envelopes, PANEL_TYPES.TIME_SERIES).queryType).toBe(
-				EQueryType.PROM,
-			);
-		});
-	});
-
 	describe('toPerses', () => {
 		it('wraps the query in a single signoz/CompositeQuery keyed to the panel request type', () => {
 			const result = toPerses(

frontend/src/pages/DashboardPageV2/DashboardContainer/queryV5/persesQueryAdapters.ts

@@ -74,14 +74,14 @@ export function deriveQueryType(
 }
 
 /**
- * V5 query-envelope list → V1 `Query`, via `mapQueryDataFromApi`. An empty list opens
- * on a fresh metrics builder query. Used by `fromPerses` and by the envelopes a
- * `/substitute_vars` round-trip returns with dashboard variables resolved.
+ * Perses panel queries → V1 `Query` (to seed the query builder), via the V5 envelope
+ * list + `mapQueryDataFromApi`. An empty panel opens on a fresh metrics builder query.
  */
-export function envelopesToQuery(
-	envelopes: Querybuildertypesv5QueryEnvelopeDTO[],
+export function fromPerses(
+	queries: DashboardtypesQueryDTO[],
 	panelType: PANEL_TYPES,
 ): Query {
+	const envelopes = toQueryEnvelopes(queries);
 	if (envelopes.length === 0) {
 		return initialQueriesMap[DataSource.METRICS];
 	}
@@ -99,17 +99,6 @@ export function envelopesToQuery(
 	return mapQueryDataFromApi(composite);
 }
 
-/**
- * Perses panel queries → V1 `Query` (to seed the query builder), via the V5 envelope
- * list + `mapQueryDataFromApi`. An empty panel opens on a fresh metrics builder query.
- */
-export function fromPerses(
-	queries: DashboardtypesQueryDTO[],
-	panelType: PANEL_TYPES,
-): Query {
-	return envelopesToQuery(toQueryEnvelopes(queries), panelType);
-}
-
 /**
  * V1 `Query` → perses panel queries (to write the builder result back to the editor
  * draft). Wrapped in a single `signoz/CompositeQuery` to satisfy the

pkg/transition/migrate_common.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/telemetrytraces"
+	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 )
 
 type migrateCommon struct {
@@ -23,119 +24,10 @@ func NewMigrateCommon(logger *slog.Logger) *migrateCommon {
 	}
 }
 
+// WrapInV5Envelope delegates to querybuildertypesv5.WrapInV5Envelope; the
+// transform is stateless and shared with the v1→v2 dashboard conversion.
 func (migration *migrateCommon) WrapInV5Envelope(name string, queryMap map[string]any, queryType string) map[string]any {
-	// Create a properly structured v5 query
-	v5Query := map[string]any{
-		"name":     name,
-		"disabled": queryMap["disabled"],
-		"legend":   queryMap["legend"],
-	}
-
-	if name != queryMap["expression"] {
-		// formula
-		queryType = "builder_formula"
-		v5Query["expression"] = queryMap["expression"]
-		if functions, ok := queryMap["functions"]; ok {
-			v5Query["functions"] = functions
-		}
-		return map[string]any{
-			"type": queryType,
-			"spec": v5Query,
-		}
-	}
-
-	// Add signal based on data source
-	if dataSource, ok := queryMap["dataSource"].(string); ok {
-		switch dataSource {
-		case "traces":
-			v5Query["signal"] = "traces"
-		case "logs":
-			v5Query["signal"] = "logs"
-		case "metrics":
-			v5Query["signal"] = "metrics"
-		}
-	}
-
-	if stepInterval, ok := queryMap["stepInterval"]; ok {
-		v5Query["stepInterval"] = stepInterval
-	}
-
-	if aggregations, ok := queryMap["aggregations"]; ok {
-		v5Query["aggregations"] = aggregations
-	}
-
-	if filter, ok := queryMap["filter"]; ok {
-		v5Query["filter"] = filter
-	}
-
-	// Copy groupBy with proper structure
-	if groupBy, ok := queryMap["groupBy"].([]any); ok {
-		v5GroupBy := make([]any, len(groupBy))
-		for i, gb := range groupBy {
-			if gbMap, ok := gb.(map[string]any); ok {
-				v5GroupBy[i] = map[string]any{
-					"name":          gbMap["key"],
-					"fieldDataType": gbMap["dataType"],
-					"fieldContext":  gbMap["type"],
-				}
-			}
-		}
-		v5Query["groupBy"] = v5GroupBy
-	}
-
-	// Copy orderBy with proper structure
-	if orderBy, ok := queryMap["orderBy"].([]any); ok {
-		v5OrderBy := make([]any, len(orderBy))
-		for i, ob := range orderBy {
-			if obMap, ok := ob.(map[string]any); ok {
-				v5OrderBy[i] = map[string]any{
-					"key": map[string]any{
-						"name":          obMap["columnName"],
-						"fieldDataType": obMap["dataType"],
-						"fieldContext":  obMap["type"],
-					},
-					"direction": obMap["order"],
-				}
-			}
-		}
-		v5Query["order"] = v5OrderBy
-	}
-
-	// Copy selectColumns as selectFields
-	if selectColumns, ok := queryMap["selectColumns"].([]any); ok {
-		v5SelectFields := make([]any, len(selectColumns))
-		for i, col := range selectColumns {
-			if colMap, ok := col.(map[string]any); ok {
-				v5SelectFields[i] = map[string]any{
-					"name":          colMap["key"],
-					"fieldDataType": colMap["dataType"],
-					"fieldContext":  colMap["type"],
-				}
-			}
-		}
-		v5Query["selectFields"] = v5SelectFields
-	}
-
-	// Copy limit and offset
-	if limit, ok := queryMap["limit"]; ok {
-		v5Query["limit"] = limit
-	}
-	if offset, ok := queryMap["offset"]; ok {
-		v5Query["offset"] = offset
-	}
-
-	if having, ok := queryMap["having"]; ok {
-		v5Query["having"] = having
-	}
-
-	if functions, ok := queryMap["functions"]; ok {
-		v5Query["functions"] = functions
-	}
-
-	return map[string]any{
-		"type": queryType,
-		"spec": v5Query,
-	}
+	return querybuildertypesv5.WrapInV5Envelope(name, queryMap, queryType)
 }
 
 func (mc *migrateCommon) updateQueryData(ctx context.Context, queryData map[string]any, version, widgetType string) bool {

pkg/types/dashboardtypes/LEGACY_DASHBOARD_HANDLING.md

@@ -0,0 +1,79 @@
+# Legacy-dashboard handling in the frontend
+
+Reference for the v1→v2 (Perses) dashboard migration in this package.
+
+The frontend has long coped with **old saved dashboard content** by normalizing it
+*by shape* at load / query-build time — it does not trust the `version` /
+`schemaVersion` tag. This is the same job the backend converter
+(`perses_v1_to_v2_*.go`, especially the `normalizePreV5*` helpers in
+`perses_v1_to_v2_queries_malformed.go`) now does on the migration path.
+
+This file catalogs the frontend handlings that exist **specifically to support
+legacy content**, so we have a checklist of shapes the backend converter may
+also need to normalize. It excludes current-architecture plumbing (v5 API ↔
+internal query-builder adapters) and the new v2 Perses / `schemaVersion: v6`
+path — those run for every dashboard regardless of age and are not legacy coping.
+
+Line numbers are from a one-time code sweep — treat them as pointers, not gospel.
+Legacy-vs-plumbing is a judgment call; verify a specific site before relying on it.
+
+## Query body (old v3/v4 query shapes)
+
+| # | Legacy shape → v5 | Frontend location | Backend converter |
+|---|---|---|---|
+| 1 | `having` array `[{columnName,op,value}]` → `{expression}` | `convertHavingToExpression` (`QueryBuilderV2/utils.ts`) | ✅ `normalizePreV5Having` |
+| 2 | `filters {items:[{key,op,value}]}` → `filter {expression}` | `convertFiltersToExpression` (`prepareQueryRangePayloadV5.ts`) | ❌ not mirrored |
+| 3 | logs/traces aggregation expression: parse `func(args)`, lift inline `as alias` → `alias`, split multi-part, discard junk (`sum(x) ) )` → `sum(x)`), empty → `count()` | `parseAggregations` / `createAggregation` (`prepareQueryRangePayloadV5.ts`) | ✅ `normalizePreV5LogTraceAggregations` + `parseAggregations` (logs/traces only) |
+| 4 | old field key `{key,dataType,type}` → `{name,fieldContext,fieldDataType}` (via `name ?? key` fallbacks) | `convertNewToOldQueryBuilder.ts`, `prepareQueryRangePayloadV5.ts` | ✅ `normalizePreV5FieldKeys` (list-panel fields) |
+| 5 | `selectColumns` stored v5-shape (`{name,…}`) → readable by the old `{key,…}` mapper; drop empty columns | `name ?? key` read + empty filter (`prepareQueryRangePayloadV5.ts`) | ✅ `normalizePreV5SelectColumns` |
+| 6 | deprecated operators remapped (`regex→REGEXP`, `nin→NOT IN`, `nlike`, `nhas`, …) | `DEPRECATED_OPERATORS_MAP` (`constants/antlrQueryConstants.ts`) | ❌ not mirrored |
+| 7 | deprecated intrinsic trace fields stripped (`traceID`/`spanID`/`parentSpanID`/`statusCode`…) | `prepareQueryRangePayloadV5.ts` | ❌ not mirrored |
+| 8 | `limit ← pageSize` (old field name) | `prepareQueryRangePayloadV5.ts` | ❌ not mirrored |
+| 9 | flat v4 aggregation fields (`aggregateAttribute`/`aggregateOperator`/`timeAggregation`/`spaceAggregation`/`reduceTo`) → `aggregations[]` | `createAggregation`, `adjustQueryForV5` | n/a — the v4→v5 migrator (`pkg/transition`) already does this; only mislabeled-v5 bodies bypass it |
+| 10 | legacy V3 composite (`builderQueries`/`promQueries`/`chQueries` objects) → v5 `queries[]` | `mapQueryFromV3` (`mapQueryDataFromApi.ts`) | n/a (backend consumes v5-shaped envelopes) |
+
+### Confirmed NOT frontend-repaired (broken source data — fails in the live UI too, so not mirrored)
+
+- **Malformed `filter.expression`** — clauses juxtaposed with no `AND`/`OR` (e.g. `a in $x b in $y`). The frontend passes `filter.expression` verbatim to the query API and its ANTLR path returns the string unchanged on parse error; there is no repair. Manifests as `Found N errors while parsing the search expression`.
+- **Dotted variable substitution** (`$k8s.cluster.name`) — handled by the backend `substitute_vars`, not the frontend; not a migration concern.
+- **`field not found` (non-empty)** — the referenced metric/attribute genuinely doesn't exist in the query instance; data-dependent, not a shape issue.
+
+## Variables (old saved variable shapes)
+
+| # | Legacy handling | Frontend location |
+|---|---|---|
+| 10 | TEXTBOX `textboxValue` → `defaultValue` (explicit BWC) | `useTransformDashboardVariables.ts` |
+| 11 | backfill missing `id` (UUID) / `order` (pre-UUID, unordered legacy variables) | `useTransformDashboardVariables.ts` |
+| 12 | `name`-vs-key duality lookup (legacy mismatched variable name/key) | `useTransformDashboardVariables.ts` |
+| 13 | `selectedValue` string\|array polymorphic normalization against `multiSelect` | `normalizeUrlValue.ts` |
+| 14 | CUSTOM `"label : value"` comma parsing (legacy value syntax) | `customCommaValuesParser.ts` |
+
+## Widget / panel (old widget fields)
+
+| # | Legacy handling | Frontend location |
+|---|---|---|
+| 15 | `spanGaps` bool (legacy) — default `true`; polymorphic with newer numeric form | `UPlotSeriesBuilder.ts`, `NewWidget` |
+| 16 | `fillSpans` (legacy bool) promoted to `spanGaps`/`fillGaps` | `NewWidget/index.tsx` |
+| 17 | `decimalPrecision` string (legacy) \| number polymorphic | `NewWidget`, `getDefaultWidgetData` |
+| 18 | `timePreferance` (misspelled legacy field) → `GLOBAL_TIME` fallback | `GridCard`, `NewWidget` |
+| 19 | `selectedLogFields`/`selectedTracesFields` legacy null-default + `key→name` on list panels | `NewWidget/index.tsx` |
+
+Items **1, 3, 4** are the ones the backend converter implements today. Items **2,
+5, 6** are legacy handlings the backend does **not** yet mirror — none surfaced in
+the 122-dashboard repo run, but they are the same class of shape and could affect
+other dashboards.
+
+## Excluded (not legacy-content handling)
+
+- **`schemaVersion → 'v6'` default**, Perses adapters (`persesQueryAdapters`),
+  `titleUntitledSectionOp` / sections, wrapped-vs-bare import — the new v2 Perses
+  (v6) path.
+- **`convertV5ResponseToLegacy`** — adapts a current v5 *response* to the internal
+  model; not dashboard JSON.
+- **v5 ↔ internal adapter renames** (`signal↔dataSource`, `name↔queryName`,
+  `orderBy` flatten, `convertNewToOldQueryBuilder`, `compositeQueryToQueryEnvelope`)
+  — run for every dashboard; architecture plumbing.
+- **Routine optional-field defaults** (`yAxisUnit`, `opacity`, `legendPosition`, …)
+  and react-grid-layout `stripUndefined` / `panelMap` — defaults / UI plumbing.
+- **DYNAMIC missing `dynamicVariablesAttribute` → skip** — defensive against
+  malformed config of any era (the nvidia-dcgm case), not version-legacy.

pkg/types/dashboardtypes/dashboard.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/transition"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -22,6 +21,7 @@ var (
 	ErrCodeDashboardInvalidSource      = errors.MustNewCode("dashboard_invalid_source")
 	ErrCodeDashboardImmutable          = errors.MustNewCode("dashboard_immutable")
 	ErrCodeDashboardInvalidPatch       = errors.MustNewCode("dashboard_invalid_patch")
+	ErrCodeDashboardMigrationFailed    = errors.MustNewCode("dashboard_migration_failed")
 )
 
 type StorableDashboard struct {
@@ -406,27 +406,26 @@ func (dashboard *Dashboard) GetWidgetQuery(startTime, endTime, widgetIndex uint6
 	widgetData := data.Widgets[widgetIndex]
 	switch widgetData.Query.QueryType {
 	case "builder":
-		migrate := transition.NewMigrateCommon(logger)
 		for _, query := range widgetData.Query.Builder.QueryData {
 			queryName, ok := query["queryName"].(string)
 			if !ok {
 				return nil, errors.New(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "cannot type cast query name as string")
 			}
-			compositeQueries = append(compositeQueries, migrate.WrapInV5Envelope(queryName, query, "builder_query"))
+			compositeQueries = append(compositeQueries, querybuildertypesv5.WrapInV5Envelope(queryName, query, "builder_query"))
 		}
 		for _, query := range widgetData.Query.Builder.QueryFormulas {
 			queryName, ok := query["queryName"].(string)
 			if !ok {
 				return nil, errors.New(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "cannot type cast query name as string")
 			}
-			compositeQueries = append(compositeQueries, migrate.WrapInV5Envelope(queryName, query, "builder_formula"))
+			compositeQueries = append(compositeQueries, querybuildertypesv5.WrapInV5Envelope(queryName, query, "builder_formula"))
 		}
 		for _, query := range widgetData.Query.Builder.QueryTraceOperator {
 			queryName, ok := query["queryName"].(string)
 			if !ok {
 				return nil, errors.New(errors.TypeInvalidInput, ErrCodeDashboardInvalidWidgetQuery, "cannot type cast query name as string")
 			}
-			compositeQueries = append(compositeQueries, migrate.WrapInV5Envelope(queryName, query, "builder_trace_operator"))
+			compositeQueries = append(compositeQueries, querybuildertypesv5.WrapInV5Envelope(queryName, query, "builder_trace_operator"))
 		}
 	case "clickhouse_sql":
 		for _, query := range widgetData.Query.ClickhouseSQL {

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -1058,6 +1058,34 @@ func TestValidateRequiredFields(t *testing.T) {
 	}
 }
 
+// TestThresholdZeroValueAcceptedMissingRejected documents the *float64 Value:
+// a threshold at 0 (or 0.0) is valid, because the pointer lets validate:"required"
+// tell a present zero (non-nil) from an absent value (nil) — while a genuinely
+// missing value is still rejected.
+func TestThresholdZeroValueAcceptedMissingRejected(t *testing.T) {
+	numberPanel := func(thresholdSpec string) string {
+		return `{
+			"panels": {"p1": {"kind": "Panel", "spec": {
+				"plugin": {"kind": "signoz/NumberPanel", "spec": {"thresholds": [` + thresholdSpec + `]}},
+				"queries": [{"kind": "time_series", "spec": {"plugin": {"kind": "signoz/PromQLQuery", "spec": {"name": "A", "query": "up"}}}}]
+			}}},
+			"layouts": []
+		}`
+	}
+
+	_, errZero := unmarshalDashboard([]byte(numberPanel(`{"value": 0, "operator": "above", "format": "text", "color": "Red"}`)))
+	require.NoError(t, errZero, `a threshold "value": 0 is valid`)
+
+	// "value": 0.0 is the same float64 zero as "value": 0 — JSON has one number
+	// type — and is accepted identically.
+	_, errZeroFloat := unmarshalDashboard([]byte(numberPanel(`{"value": 0.0, "operator": "above", "format": "text", "color": "Red"}`)))
+	require.NoError(t, errZeroFloat, `"value": 0.0 is the same valid zero`)
+
+	_, errMissing := unmarshalDashboard([]byte(numberPanel(`{"operator": "above", "format": "text", "color": "Red"}`)))
+	require.Error(t, errMissing, "a genuinely missing value is still rejected")
+	require.Contains(t, errMissing.Error(), "Value")
+}
+
 func TestTimeSeriesPanelDefaults(t *testing.T) {
 	data := []byte(`{
 		"panels": {

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -251,14 +251,20 @@ type Legend struct {
 }
 
 type ThresholdWithLabel struct {
-	Value float64 `json:"value" validate:"required" required:"true"`
-	Unit  string  `json:"unit"`
-	Color string  `json:"color" validate:"required" required:"true"`
-	Label string  `json:"label"`
+	// Value is a pointer so a threshold at 0 is valid: validate:"required" treats
+	// the float64 zero as "missing", but a non-nil *float64 to 0 passes (and nil
+	// still fails, so a genuinely absent value is still rejected). nullable:"false"
+	// keeps it a plain required number in the schema — it is never null in valid
+	// data (validation rejects nil), so the pointer must not leak as `number|null`.
+	Value *float64 `json:"value" validate:"required" required:"true" nullable:"false"`
+	Unit  string   `json:"unit"`
+	Color string   `json:"color" validate:"required" required:"true"`
+	Label string   `json:"label"`
 }
 
 type ComparisonThreshold struct {
-	Value    float64            `json:"value" validate:"required" required:"true"`
+	// Value is a pointer so a threshold at 0 is valid (see ThresholdWithLabel.Value).
+	Value    *float64           `json:"value" validate:"required" required:"true" nullable:"false"`
 	Operator ComparisonOperator `json:"operator"`
 	Unit     string             `json:"unit"`
 	Color    string             `json:"color" validate:"required" required:"true"`

pkg/types/dashboardtypes/perses_v1_to_v2.go

@@ -0,0 +1,82 @@
+package dashboardtypes
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+// V1 → V2 migration. The v1 storable shape is the frontend's `DashboardData`
+// (see frontend/src/types/api/dashboard/getAll.ts); v2 is DashboardV2 /
+// DashboardSpec.
+//
+// Assumes the v1 widget query data has already been migrated to v5 shape
+// (transition.dashboardMigrateV5). Pre-v5 builder queries will produce
+// invalid v2 envelopes — run the v4→v5 migration first.
+//
+// The conversion is split across sibling files by concern:
+//   - perses_v1_to_v2_tags.go      tags
+//   - perses_v1_to_v2_panels.go    widgets → panels (+ panel field mappers)
+//   - perses_v1_to_v2_queries.go   widget queries
+//   - perses_v1_to_v2_layouts.go   grid layouts and sections
+//   - perses_v1_to_v2_variables.go variables
+//   - perses_v1_to_v2_decoder.go   v1Decoder: typed field reads + malformed-field detection
+
+// ══════════════════════════════════════════════
+// Entry point
+// ══════════════════════════════════════════════
+
+func (storable StorableDashboard) IsV2() bool {
+	metadata, _ := storable.Data["metadata"].(map[string]any)
+	if metadata == nil {
+		return false
+	}
+	version, _ := metadata["schemaVersion"].(string)
+	return version == SchemaVersion
+}
+
+func (storable StorableDashboard) ConvertV1ToV2() (result *DashboardV2, err error) {
+	// Legacy v1 data can be arbitrarily malformed. The accessors degrade
+	// gracefully, but recover from any unforeseen panic so one bad dashboard
+	// surfaces as an error (to be logged and skipped) rather than crashing the run.
+	defer func() {
+		if r := recover(); r != nil {
+			result, err = nil, errors.Newf(errors.TypeInternal, ErrCodeDashboardMigrationFailed, "panic converting dashboard %s: %v", storable.ID, r)
+		}
+	}()
+
+	if storable.IsV2() {
+		return nil, errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardMigrationFailed, "dashboard %s is already in %s schema", storable.ID, SchemaVersion)
+	}
+
+	d := &v1Decoder{}
+	title := d.readString(storable.Data, "title")
+	description := d.readString(storable.Data, "description")
+	image := d.readString(storable.Data, "image")
+
+	spec := DashboardSpec{
+		Display:   Display{Name: title, Description: description},
+		Variables: d.convertV1Variables(storable.Data["variables"]),
+		Panels:    d.convertV1Panels(storable.Data["widgets"]),
+		Layouts:   d.convertV1Layouts(storable.Data),
+	}
+	tags := d.convertV1TagsForOrg(storable.OrgID, storable.Data["tags"])
+
+	if err := d.errIfHasMalformedFields(); err != nil {
+		return nil, err
+	}
+
+	return &DashboardV2{
+		Identifiable:  storable.Identifiable,
+		TimeAuditable: storable.TimeAuditable,
+		UserAuditable: storable.UserAuditable,
+		OrgID:         storable.OrgID,
+		Locked:        storable.Locked,
+		Source:        storable.Source,
+		DashboardV2MetadataBase: DashboardV2MetadataBase{
+			SchemaVersion: SchemaVersion,
+			Image:         image,
+		},
+		Name: generateDashboardName(title),
+		Tags: tags,
+		Spec: spec,
+	}, nil
+}

pkg/types/dashboardtypes/perses_v1_to_v2_decoder.go

@@ -0,0 +1,168 @@
+package dashboardtypes
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+)
+
+// ══════════════════════════════════════════════
+// v1 decoder
+// ══════════════════════════════════════════════
+
+// v1Decoder reads fields out of the untyped v1 dashboard blob. Every read*
+// method follows the same contract: a field that is absent or null yields the
+// zero value; a field present with the wrong type yields zero AND records a
+// malformed-field error. Conversion proceeds (so one bad field doesn't abort
+// the rest) and ConvertV1ToV2 returns d.malformedFieldsErr() at the end so the
+// dashboard is logged and skipped.
+//
+// Polymorphic v1 fields (spanGaps bool|number, selectedValue string|array, …)
+// are read with a type switch on the already-extracted value, never through
+// these accessors, so they stay lenient by construction.
+type v1Decoder struct {
+	bad  []string
+	seen map[string]struct{}
+}
+
+// note records a decoding problem (malformed field, unknown value, swallowed
+// sub-parse error), deduping identical messages. ConvertV1ToV2 surfaces these
+// via errIfHasMalformedFields.
+func (d *v1Decoder) note(format string, args ...any) {
+	msg := fmt.Sprintf(format, args...)
+	if _, dup := d.seen[msg]; dup {
+		return
+	}
+	if d.seen == nil {
+		d.seen = make(map[string]struct{})
+	}
+	d.seen[msg] = struct{}{}
+	d.bad = append(d.bad, msg)
+}
+
+// noteMalformedField records a v1 field present with the wrong Go type.
+func (d *v1Decoder) noteMalformedField(field string, raw any) {
+	d.note("%q has unexpected type %T", field, raw)
+}
+
+// detailErr renders an error for a diagnostic note, unfolding the structured
+// detail our JSON binding attaches via WithAdditional. A plain %v on these
+// errors prints only the innermost message ("request body contains invalid
+// field value") and drops the field/type context that says which field was
+// wrong — the part that actually tells you what to fix.
+func detailErr(err error) string {
+	if err == nil {
+		return ""
+	}
+	j := errors.AsJSON(err)
+	if len(j.Errors) == 0 {
+		return err.Error()
+	}
+	details := make([]string, 0, len(j.Errors))
+	for _, e := range j.Errors {
+		details = append(details, e.Message)
+	}
+	return j.Message + ": " + strings.Join(details, "; ")
+}
+
+func (d *v1Decoder) errIfHasMalformedFields() error {
+	if len(d.bad) == 0 {
+		return nil
+	}
+	// One field per line: these lists run long (a bad widget query is reported
+	// once per widget), and a single "; "-joined line is an unscannable wall.
+	return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardInvalidData, "malformed v1 dashboard fields:\n  %s", strings.Join(d.bad, "\n  "))
+}
+
+func readField[T any](d *v1Decoder, m map[string]any, key string) T {
+	var zero T
+	v, present := m[key]
+	if !present || v == nil {
+		return zero
+	}
+	t, ok := v.(T)
+	if !ok {
+		d.noteMalformedField(key, v)
+		return zero
+	}
+	return t
+}
+
+func (d *v1Decoder) readString(m map[string]any, key string) string {
+	return readField[string](d, m, key)
+}
+func (d *v1Decoder) readFloat(m map[string]any, key string) float64 {
+	return readField[float64](d, m, key)
+}
+func (d *v1Decoder) readBool(m map[string]any, key string) bool   { return readField[bool](d, m, key) }
+func (d *v1Decoder) readArray(m map[string]any, key string) []any { return readField[[]any](d, m, key) }
+func (d *v1Decoder) readObject(m map[string]any, key string) map[string]any {
+	return readField[map[string]any](d, m, key)
+}
+
+// readInt narrows a numeric field to int (JSON numbers decode as float64).
+func (d *v1Decoder) readInt(m map[string]any, key string) int { return int(d.readFloat(m, key)) }
+
+func (d *v1Decoder) readFloatPtr(m map[string]any, key string) *float64 {
+	v, present := m[key]
+	if !present || v == nil {
+		return nil
+	}
+	f, ok := v.(float64)
+	if !ok {
+		d.noteMalformedField(key, v)
+		return nil
+	}
+	return &f
+}
+
+func (d *v1Decoder) readStringMap(m map[string]any, key string) map[string]string {
+	raw := d.readObject(m, key)
+	if len(raw) == 0 {
+		return nil
+	}
+	out := make(map[string]string, len(raw))
+	for k, v := range raw {
+		s, ok := v.(string)
+		if !ok {
+			d.noteMalformedField(key+"."+k, v)
+			continue
+		}
+		out[k] = s
+	}
+	return out
+}
+
+func (d *v1Decoder) readObjects(m map[string]any, key string) []map[string]any {
+	raw := d.readArray(m, key)
+	if len(raw) == 0 {
+		return nil
+	}
+	out := make([]map[string]any, 0, len(raw))
+	for i, item := range raw {
+		obj, ok := item.(map[string]any)
+		if !ok {
+			d.noteMalformedField(fmt.Sprintf("%s[%d]", key, i), item)
+			continue
+		}
+		out = append(out, obj)
+	}
+	return out
+}
+
+// decodeMapInto converts an untyped map[string]any into a typed T by
+// round-tripping through JSON, letting encoding/json (struct tags, custom
+// UnmarshalJSON) do the field mapping instead of hand-copying out of the map.
+func decodeMapInto[T any](src map[string]any) (T, error) {
+	var dst T
+	bytes, err := json.Marshal(src)
+	if err != nil {
+		return dst, err
+	}
+	if err := json.Unmarshal(bytes, &dst); err != nil {
+		return dst, err
+	}
+	return dst, nil
+}

pkg/types/dashboardtypes/perses_v1_to_v2_layouts.go

@@ -0,0 +1,155 @@
+package dashboardtypes
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/perses/spec/go/common"
+	"github.com/perses/spec/go/dashboard"
+)
+
+// ══════════════════════════════════════════════
+// Layouts (data.layout + data.panelMap)
+// ══════════════════════════════════════════════
+
+// convertV1Layouts groups v1 react-grid-layout entries into v2 grid layouts.
+// Membership is positional (as the frontend renders): each row widget owns the
+// panels below it until the next row; panels above the first row form an unnamed
+// grid with no section header. Collapsed rows are the exception — their children
+// live in panelMap[rowID].widgets, not `layout`.
+func (d *v1Decoder) convertV1Layouts(data StorableDashboardData) []Layout {
+	layout := d.readObjects(data, "layout")
+	if len(layout) == 0 {
+		return nil
+	}
+
+	rows := d.extractRowsAndCollapsedWidgets(data)
+
+	// `layout` ids must correspond to a real widget. react-grid-layout leaks a
+	// "__dropping-elem__" drag placeholder (and stale entries can outlive a
+	// deleted widget) into the saved layout; both would otherwise become grid
+	// items referencing a non-existent panel.
+	widgetIDs := make(map[string]bool)
+	for _, w := range d.readObjects(data, "widgets") {
+		if id := d.readString(w, "id"); id != "" {
+			widgetIDs[id] = true
+		}
+	}
+
+	// Skip collapsed-row children a malformed dashboard lists in `layout` too.
+	isWidgetCollapsed := make(map[string]bool)
+	for _, row := range rows {
+		for _, child := range row.collapsedWidgets {
+			if id := d.readString(child, "i"); id != "" {
+				isWidgetCollapsed[id] = true
+			}
+		}
+	}
+
+	d.sortByPosition(layout)
+
+	type section struct {
+		row   *rowInfo // nil for the unnamed grid of ungrouped panels
+		items []map[string]any
+	}
+	topSectionWithoutHeader := &section{}
+	sectionsWithHeader := make([]*section, 0, len(rows))
+	currentRowHeader := topSectionWithoutHeader
+	for _, item := range layout {
+		id := d.readString(item, "i")
+		if id == "" || isWidgetCollapsed[id] || !widgetIDs[id] {
+			continue
+		}
+		if row, ok := rows[id]; ok {
+			newRowHeader := &section{row: row, items: row.collapsedWidgets}
+			sectionsWithHeader = append(sectionsWithHeader, newRowHeader)
+			// A collapsed row owns only its stashed children; later panels → ungrouped.
+			if row.collapsed {
+				currentRowHeader = topSectionWithoutHeader
+			} else {
+				currentRowHeader = newRowHeader
+			}
+			continue
+		}
+		currentRowHeader.items = append(currentRowHeader.items, item)
+	}
+
+	out := make([]Layout, 0, len(sectionsWithHeader)+1)
+	if len(topSectionWithoutHeader.items) > 0 {
+		out = append(out, d.buildV2GridLayout(nil, topSectionWithoutHeader.items))
+	}
+	for _, sec := range sectionsWithHeader {
+		out = append(out, d.buildV2GridLayout(sec.row, sec.items))
+	}
+	return out
+}
+
+type rowInfo struct {
+	title            string
+	collapsed        bool
+	collapsedWidgets []map[string]any
+}
+
+// extractRowsAndCollapsedWidgets returns the row widgets keyed by id; collapsed
+// rows also carry their children stashed under panelMap[id].widgets.
+func (d *v1Decoder) extractRowsAndCollapsedWidgets(data StorableDashboardData) map[string]*rowInfo {
+	panelMap := d.readObject(data, "panelMap")
+	rows := make(map[string]*rowInfo)
+	for _, w := range d.readObjects(data, "widgets") {
+		id := d.readString(w, "id")
+		if d.readString(w, "panelTypes") != "row" || id == "" {
+			continue
+		}
+		row := &rowInfo{title: d.readString(w, "title")}
+		// Some templates store panelMap[id] as a bare []widgetID instead of the
+		// canonical {widgets, collapsed}. The frontend treats such a non-object
+		// entry as "not collapsed" (see GridCardLayout), so read it leniently: a
+		// non-map yields nil, which reads as not collapsed.
+		pm, _ := panelMap[id].(map[string]any)
+		if d.readBool(pm, "collapsed") {
+			row.collapsed = true
+			row.collapsedWidgets = d.readObjects(pm, "widgets")
+		}
+		rows[id] = row
+	}
+	return rows
+}
+
+// buildV2GridLayout builds one v2 grid. row is nil for the unnamed grid (no
+// display); otherwise the grid takes the row's title and collapse state. Items
+// are sorted by (y, x) and their y's normalized so the topmost sits at 0.
+func (d *v1Decoder) buildV2GridLayout(row *rowInfo, items []map[string]any) Layout {
+	d.sortByPosition(items)
+
+	spec := dashboard.GridLayoutSpec{Items: make([]dashboard.GridItem, 0, len(items))}
+	if row != nil {
+		spec.Display = &dashboard.GridLayoutDisplay{
+			Title:    row.title,
+			Collapse: &dashboard.GridLayoutCollapse{Open: !row.collapsed},
+		}
+	}
+
+	minY := 0
+	if len(items) > 0 {
+		minY = d.readInt(items[0], "y") // sorted by y, so the first item is topmost
+	}
+	for _, item := range items {
+		spec.Items = append(spec.Items, dashboard.GridItem{
+			X:       d.readInt(item, "x"),
+			Y:       d.readInt(item, "y") - minY,
+			Width:   d.readInt(item, "w"),
+			Height:  d.readInt(item, "h"),
+			Content: &common.JSONRef{Ref: fmt.Sprintf("#/spec/panels/%s", d.readString(item, "i"))},
+		})
+	}
+	return Layout{Kind: dashboard.KindGridLayout, Spec: &spec}
+}
+
+func (d *v1Decoder) sortByPosition(items []map[string]any) {
+	sort.SliceStable(items, func(i, j int) bool {
+		if yi, yj := d.readInt(items[i], "y"), d.readInt(items[j], "y"); yi != yj {
+			return yi < yj
+		}
+		return d.readInt(items[i], "x") < d.readInt(items[j], "x")
+	})
+}

pkg/types/dashboardtypes/perses_v1_to_v2_panels.go

@@ -0,0 +1,464 @@
+package dashboardtypes
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// ══════════════════════════════════════════════
+// Widgets → Panels
+// ══════════════════════════════════════════════
+
+// convertV1Panels walks the v1 `widgets` array and produces v2 panels keyed by
+// the v1 widget id. WidgetRow entries (panelTypes == "row") are dropped here
+// and consumed by convertV1Layouts as section headers.
+func (d *v1Decoder) convertV1Panels(raw any) map[string]*Panel {
+	if raw == nil {
+		return nil
+	}
+	widgetsRaw, ok := raw.([]any)
+	if !ok {
+		d.noteMalformedField("widgets", raw)
+		return nil
+	}
+	panels := make(map[string]*Panel, len(widgetsRaw))
+	for i, widgetRaw := range widgetsRaw {
+		widget, ok := widgetRaw.(map[string]any)
+		if !ok {
+			d.noteMalformedField(fmt.Sprintf("widgets[%d]", i), widgetRaw)
+			continue
+		}
+		id := d.readString(widget, "id")
+		if id == "" {
+			continue
+		}
+		var panel *Panel
+		panelType := d.readString(widget, "panelTypes")
+		switch panelType {
+		case "graph":
+			panel = d.convertGraphWidget(widget)
+		case "bar":
+			panel = d.convertBarWidget(widget)
+		case "value":
+			panel = d.convertValueWidget(widget)
+		case "pie":
+			panel = d.convertPieWidget(widget)
+		case "table":
+			panel = d.convertTableWidget(widget)
+		case "histogram":
+			panel = d.convertHistogramWidget(widget)
+		case "list":
+			panel = d.convertListWidget(widget)
+		case "row":
+			// "row" (section header) is handled by the layout pass;
+			continue
+		default:
+			d.note("widgets[%d] has unknown panel type %q", i, panelType)
+		}
+		if panel == nil {
+			continue
+		}
+		panels[id] = panel
+	}
+	return panels
+}
+
+func (d *v1Decoder) convertGraphWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindTimeSeries,
+				Spec: &TimeSeriesPanelSpec{
+					Visualization: TimeSeriesVisualization{
+						BasicVisualization: d.basicVisualization(w),
+						FillSpans:          d.readBool(w, "fillSpans"),
+					},
+					Formatting: d.panelFormatting(w),
+					ChartAppearance: TimeSeriesChartAppearance{
+						LineInterpolation: mapV1Enum(d.readString(w, "lineInterpolation"), LineInterpolationSpline,
+							LineInterpolationLinear, LineInterpolationSpline, LineInterpolationStepAfter, LineInterpolationStepBefore),
+						ShowPoints: d.readBool(w, "showPoints"),
+						LineStyle:  mapV1Enum(d.readString(w, "lineStyle"), LineStyleSolid, LineStyleSolid, LineStyleDashed),
+						FillMode:   mapV1Enum(d.readString(w, "fillMode"), FillModeSolid, FillModeSolid, FillModeGradient, FillModeNone),
+						SpanGaps:   mapV1SpanGaps(w["spanGaps"]),
+					},
+					Axes:       d.axesFromWidget(w),
+					Legend:     d.legendFromWidget(w),
+					Thresholds: d.mapV1ThresholdsWithLabel(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindTimeSeries),
+		},
+	}
+}
+
+func (d *v1Decoder) convertBarWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindBarChart,
+				Spec: &BarChartPanelSpec{
+					Visualization: BarChartVisualization{
+						BasicVisualization: d.basicVisualization(w),
+						FillSpans:          d.readBool(w, "fillSpans"),
+						StackedBarChart:    d.readBool(w, "stackedBarChart"),
+					},
+					Formatting: d.panelFormatting(w),
+					Axes:       d.axesFromWidget(w),
+					Legend:     d.legendFromWidget(w),
+					Thresholds: d.mapV1ThresholdsWithLabel(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindBarChart),
+		},
+	}
+}
+
+func (d *v1Decoder) convertValueWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindNumber,
+				Spec: &NumberPanelSpec{
+					Visualization: d.basicVisualization(w),
+					Formatting:    d.panelFormatting(w),
+					Thresholds:    d.mapV1ComparisonThresholds(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindNumber),
+		},
+	}
+}
+
+func (d *v1Decoder) convertPieWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindPieChart,
+				Spec: &PieChartPanelSpec{
+					Visualization: d.basicVisualization(w),
+					Formatting:    d.panelFormatting(w),
+					Legend:        d.legendFromWidget(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindPieChart),
+		},
+	}
+}
+
+func (d *v1Decoder) convertTableWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindTable,
+				Spec: &TablePanelSpec{
+					Visualization: d.basicVisualization(w),
+					Formatting: TableFormatting{
+						ColumnUnits:      d.readStringMap(w, "columnUnits"),
+						DecimalPrecision: mapV1Precision(w["decimalPrecision"]),
+					},
+					Thresholds: d.mapV1TableThresholds(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindTable),
+		},
+	}
+}
+
+func (d *v1Decoder) convertHistogramWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindHistogram,
+				Spec: &HistogramPanelSpec{
+					HistogramBuckets: HistogramBuckets{
+						BucketCount:           d.readFloatPtr(w, "bucketCount"),
+						BucketWidth:           d.readFloatPtr(w, "bucketWidth"),
+						MergeAllActiveQueries: d.readBool(w, "mergeAllActiveQueries"),
+					},
+					Legend: d.legendFromWidget(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindHistogram),
+		},
+	}
+}
+
+func (d *v1Decoder) convertListWidget(w map[string]any) *Panel {
+	return &Panel{
+		Kind: "Panel",
+		Spec: PanelSpec{
+			Display: d.widgetDisplay(w),
+			Plugin: PanelPlugin{
+				Kind: PanelKindList,
+				Spec: &ListPanelSpec{
+					SelectFields: d.mapV1SelectFields(w),
+				},
+			},
+			Queries: d.convertV1WidgetQuery(w, PanelKindList),
+		},
+	}
+}
+
+// ══════════════════════════════════════════════
+// Panel-spec shared helpers
+// ══════════════════════════════════════════════
+
+func (d *v1Decoder) widgetDisplay(w map[string]any) Display {
+	return Display{Name: d.readString(w, "title"), Description: d.readString(w, "description")}
+}
+
+func (d *v1Decoder) basicVisualization(w map[string]any) BasicVisualization {
+	return BasicVisualization{TimePreference: mapV1TimePreference(d.readString(w, "timePreferance"))}
+}
+
+func (d *v1Decoder) panelFormatting(w map[string]any) PanelFormatting {
+	return PanelFormatting{Unit: d.readString(w, "yAxisUnit"), DecimalPrecision: mapV1Precision(w["decimalPrecision"])}
+}
+
+func (d *v1Decoder) axesFromWidget(w map[string]any) Axes {
+	return Axes{
+		SoftMin:    d.readFloatPtr(w, "softMin"),
+		SoftMax:    d.readFloatPtr(w, "softMax"),
+		IsLogScale: d.readBool(w, "isLogScale"),
+	}
+}
+
+func (d *v1Decoder) legendFromWidget(w map[string]any) Legend {
+	return Legend{
+		Position:     mapV1Enum(d.readString(w, "legendPosition"), LegendPositionBottom, LegendPositionBottom, LegendPositionRight),
+		CustomColors: d.readStringMap(w, "customLegendColors"),
+	}
+}
+
+func (d *v1Decoder) mapV1SelectFields(w map[string]any) []telemetrytypes.TelemetryFieldKey {
+	field := "selectedLogFields"
+	raw := d.readArray(w, field)
+	if len(raw) == 0 {
+		field = "selectedTracesFields"
+		raw = d.readArray(w, field)
+	}
+	if len(raw) == 0 {
+		return nil
+	}
+	normalizePreV5FieldKeys(raw)
+	fields, err := decodeTelemetryFields(raw)
+	if err != nil {
+		d.note("widget %q has malformed %s: %v", d.readString(w, "id"), field, err)
+		return nil
+	}
+	return fields
+}
+
+func decodeTelemetryFields(raw []any) ([]telemetrytypes.TelemetryFieldKey, error) {
+	bytes, err := json.Marshal(raw)
+	if err != nil {
+		return nil, err
+	}
+	var fields []telemetrytypes.TelemetryFieldKey
+	if err := json.Unmarshal(bytes, &fields); err != nil {
+		return nil, err
+	}
+	return fields, nil
+}
+
+// ══════════════════════════════════════════════
+// Panel field mappers
+// ══════════════════════════════════════════════
+
+// v1 stores timePreferance as `GLOBAL_TIME`, `LAST_5_MIN`, … (see
+// frontend/src/container/NewWidget/RightContainer/timeItems.ts). v2 uses the
+// lowercase form, so the translation is just downcase.
+func mapV1TimePreference(s string) TimePreference {
+	if s == "" {
+		return TimePreferenceGlobalTime
+	}
+	candidate := TimePreference{valuer.NewString(strings.ToLower(s))}
+	for _, allowed := range candidate.Enum() {
+		if allowed == candidate {
+			return candidate
+		}
+	}
+	return TimePreferenceGlobalTime
+}
+
+// mapV1Precision is polymorphic (string|number), so it type-switches the raw
+// value rather than reading through a typed accessor.
+func mapV1Precision(raw any) PrecisionOption {
+	switch v := raw.(type) {
+	case string:
+		candidate := PrecisionOption{valuer.NewString(v)}
+		for _, allowed := range candidate.Enum() {
+			if allowed == candidate {
+				return candidate
+			}
+		}
+	case float64:
+		n := int(v)
+		if n >= 0 && n <= 4 {
+			return PrecisionOption{valuer.NewString(strconv.Itoa(n))}
+		}
+	}
+	return PrecisionOption2
+}
+
+// mapV1Enum picks the v1 string value if it matches one of the allowed v2
+// values, otherwise returns the fallback. v1 frontend enums (lineInterpolation,
+// lineStyle, fillMode, legendPosition) already use the v2 lowercase form.
+func mapV1Enum[T interface{ StringValue() string }](s string, fallback T, allowed ...T) T {
+	if s == "" {
+		return fallback
+	}
+	for _, a := range allowed {
+		if a.StringValue() == s {
+			return a
+		}
+	}
+	return fallback
+}
+
+// v1 spanGaps is `boolean | number`. true → span every gap; false → never span;
+// a number is interpreted (per frontend SeriesProps.spanGaps docs) as an
+// X-axis threshold in seconds. Polymorphic, so it type-switches the raw value.
+func mapV1SpanGaps(raw any) SpanGaps {
+	switch v := raw.(type) {
+	case bool:
+		if v {
+			return SpanGaps{FillOnlyBelow: false}
+		}
+		return SpanGaps{FillOnlyBelow: true}
+	case float64:
+		dur, err := valuer.ParseTextDuration(time.Duration(v * float64(time.Second)).String())
+		if err != nil {
+			return SpanGaps{FillOnlyBelow: false}
+		}
+		return SpanGaps{FillOnlyBelow: true, FillLessThan: dur}
+	}
+	return SpanGaps{FillOnlyBelow: false}
+}
+
+func (d *v1Decoder) mapV1ThresholdsWithLabel(w map[string]any) []ThresholdWithLabel {
+	rawSlice := d.readObjects(w, "thresholds")
+	if len(rawSlice) == 0 {
+		return nil
+	}
+	out := make([]ThresholdWithLabel, 0, len(rawSlice))
+	for _, t := range rawSlice {
+		color := d.readString(t, "thresholdColor")
+		label := d.readString(t, "thresholdLabel")
+		if color == "" || label == "" {
+			// v2 ThresholdWithLabel requires both; drop entries that wouldn't validate.
+			continue
+		}
+		value := d.readFloat(t, "thresholdValue")
+		out = append(out, ThresholdWithLabel{Value: &value, Unit: d.readString(t, "thresholdUnit"), Color: color, Label: label})
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func (d *v1Decoder) mapV1ComparisonThresholds(w map[string]any) []ComparisonThreshold {
+	rawSlice := d.readObjects(w, "thresholds")
+	if len(rawSlice) == 0 {
+		return nil
+	}
+	out := make([]ComparisonThreshold, 0, len(rawSlice))
+	for _, t := range rawSlice {
+		color := d.readString(t, "thresholdColor")
+		if color == "" {
+			continue
+		}
+		value := d.readFloat(t, "thresholdValue")
+		out = append(out, ComparisonThreshold{
+			Value:    &value,
+			Operator: d.mapV1ComparisonOperator(d.readString(t, "thresholdOperator")),
+			Unit:     d.readString(t, "thresholdUnit"),
+			Color:    color,
+			Format:   mapV1ThresholdFormat(d.readString(t, "thresholdFormat")),
+		})
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func (d *v1Decoder) mapV1TableThresholds(w map[string]any) []TableThreshold {
+	rawSlice := d.readObjects(w, "thresholds")
+	if len(rawSlice) == 0 {
+		return nil
+	}
+	out := make([]TableThreshold, 0, len(rawSlice))
+	for _, t := range rawSlice {
+		color := d.readString(t, "thresholdColor")
+		columnName := d.readString(t, "thresholdTableOptions")
+		if color == "" || columnName == "" {
+			continue
+		}
+		value := d.readFloat(t, "thresholdValue")
+		out = append(out, TableThreshold{
+			ComparisonThreshold: ComparisonThreshold{
+				Value:    &value,
+				Operator: d.mapV1ComparisonOperator(d.readString(t, "thresholdOperator")),
+				Unit:     d.readString(t, "thresholdUnit"),
+				Color:    color,
+				Format:   mapV1ThresholdFormat(d.readString(t, "thresholdFormat")),
+			},
+			ColumnName: columnName,
+		})
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func (d *v1Decoder) mapV1ComparisonOperator(s string) ComparisonOperator {
+	switch s {
+	case ">":
+		return ComparisonOperatorAbove
+	case ">=":
+		return ComparisonOperatorAboveOrEqual
+	case "<":
+		return ComparisonOperatorBelow
+	case "<=":
+		return ComparisonOperatorBelowOrEqual
+	case "=":
+		return ComparisonOperatorEqual
+	case "!=":
+		return ComparisonOperatorNotEqual
+	default:
+		d.note("threshold has unknown comparison operator %q", s)
+		return ComparisonOperatorAbove
+	}
+}
+
+func mapV1ThresholdFormat(s string) ThresholdFormat {
+	switch strings.ToLower(s) {
+	case "background":
+		return ThresholdFormatBackground
+	case "text":
+		return ThresholdFormatText
+	}
+	return ThresholdFormatText
+}

pkg/types/dashboardtypes/perses_v1_to_v2_queries.go

@@ -0,0 +1,251 @@
+package dashboardtypes
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	qb "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+// ══════════════════════════════════════════════
+// Queries
+// ══════════════════════════════════════════════
+
+// convertV1WidgetQuery returns exactly one Query (per Spec.Validate). The kind
+// chosen depends on the v1 widget query shape:
+//   - a single query (promql / clickhouse_sql / builder) → its native kind
+//   - multiple queries                                   → signoz/CompositeQuery
+//
+// A single query is never wrapped in a CompositeQuery; in particular List
+// panels accept only a bare signoz/BuilderQuery. Builder queries are routed
+// through qb.WrapInV5Envelope (in collectV1QueryEnvelopes), which translates v4
+// builder-field names (orderBy/selectColumns/dataSource) into their v5
+// equivalents and adds the `signal` field required by BuilderQuerySpec's
+// per-signal dispatch.
+func (d *v1Decoder) convertV1WidgetQuery(widget map[string]any, panelKind PanelPluginKind) []Query {
+	envelopes, signal := d.collectV1QueryEnvelopes(widget)
+	if len(envelopes) == 0 {
+		return nil
+	}
+	requestType := requestTypeForPanel(panelKind)
+
+	// A single query keeps its native kind — never wrapped in a CompositeQuery.
+	if len(envelopes) == 1 {
+		if q := singleQueryFromEnvelope(envelopes[0], requestType, signal); q != nil {
+			return []Query{*q}
+		}
+	}
+
+	// Default: wrap in CompositeQuery.
+	composite, err := parseCompositeFromEnvelopes(envelopes)
+	if err != nil || composite == nil {
+		d.note("widget %q: could not build query from %d envelope(s): %s", d.readString(widget, "id"), len(envelopes), detailErr(err))
+		return nil
+	}
+	return []Query{{
+		Kind: requestType,
+		Spec: QuerySpec{
+			Plugin: QueryPlugin{Kind: QueryKindComposite, Spec: composite},
+		},
+	}}
+}
+
+// requestTypeForPanel maps a v2 panel plugin kind to the request type (result
+// shape) its queries produce. Mirrors the frontend's panelTypeToRequestType
+// (buildQueryRangeRequest.ts): time series for line/bar/histogram (histogram
+// bins client-side from raw time series, V1 parity), scalar for
+// number/pie/table, raw rows for list.
+func requestTypeForPanel(panelKind PanelPluginKind) qb.RequestType {
+	switch panelKind {
+	case PanelKindTimeSeries, PanelKindBarChart, PanelKindHistogram:
+		return qb.RequestTypeTimeSeries
+	case PanelKindNumber, PanelKindPieChart, PanelKindTable:
+		return qb.RequestTypeScalar
+	case PanelKindList:
+		return qb.RequestTypeRaw
+	}
+	return qb.RequestTypeTimeSeries
+}
+
+// collectV1QueryEnvelopes inspects widget.query.queryType and produces a
+// flattened list of v5-shaped envelopes. The returned signal is the dominant
+// builder signal (if any), used for typed builder-query dispatch.
+func (d *v1Decoder) collectV1QueryEnvelopes(widget map[string]any) ([]map[string]any, telemetrytypes.Signal) {
+	queryMap := d.readObject(widget, "query")
+	if queryMap == nil {
+		return nil, telemetrytypes.Signal{}
+	}
+
+	queryType := d.readString(queryMap, "queryType")
+	switch queryType {
+	case "promql":
+		var out []map[string]any
+		for _, q := range d.readObjects(queryMap, "promql") {
+			out = append(out, promQLEnvelope(q))
+		}
+		return out, telemetrytypes.Signal{}
+
+	case "clickhouse_sql":
+		var out []map[string]any
+		for _, q := range d.readObjects(queryMap, "clickhouse_sql") {
+			out = append(out, clickhouseEnvelope(q))
+		}
+		return out, telemetrytypes.Signal{}
+
+	case "builder":
+		builder := d.readObject(queryMap, "builder")
+		if builder == nil {
+			return nil, telemetrytypes.Signal{}
+		}
+		var out []map[string]any
+		var signal telemetrytypes.Signal
+		for _, q := range d.readObjects(builder, "queryData") {
+			normalizePreV5Having(q)
+			normalizePreV5LogTraceAggregations(q)
+			normalizePreV5SelectColumns(q)
+			name := d.readString(q, "queryName")
+			out = append(out, qb.WrapInV5Envelope(name, q, string(qb.QueryTypeBuilder.StringValue())))
+			if signal.IsZero() {
+				signal = signalFromDataSource(q["dataSource"])
+			}
+		}
+		for _, f := range d.readObjects(builder, "queryFormulas") {
+			normalizePreV5Having(f)
+			name := d.readString(f, "queryName")
+			out = append(out, qb.WrapInV5Envelope(name, f, string(qb.QueryTypeFormula.StringValue())))
+		}
+		for _, op := range d.readObjects(builder, "queryTraceOperator") {
+			normalizePreV5Having(op)
+			name := d.readString(op, "queryName")
+			out = append(out, qb.WrapInV5Envelope(name, op, string(qb.QueryTypeTraceOperator.StringValue())))
+		}
+		return out, signal
+	default:
+		d.note("widget %q has unknown queryType %q", d.readString(widget, "id"), queryType)
+	}
+	return nil, telemetrytypes.Signal{}
+}
+
+func promQLEnvelope(q map[string]any) map[string]any {
+	return map[string]any{
+		"type": qb.QueryTypePromQL.StringValue(),
+		"spec": map[string]any{
+			"name":     q["name"],
+			"query":    q["query"],
+			"disabled": q["disabled"],
+			"legend":   q["legend"],
+		},
+	}
+}
+
+func clickhouseEnvelope(q map[string]any) map[string]any {
+	return map[string]any{
+		"type": qb.QueryTypeClickHouseSQL.StringValue(),
+		"spec": map[string]any{
+			"name":     q["name"],
+			"query":    q["query"],
+			"disabled": q["disabled"],
+			"legend":   q["legend"],
+		},
+	}
+}
+
+// singleQueryFromEnvelope returns a typed Query for one envelope, using its
+// native query kind (promql/clickhouse_sql/builder) rather than wrapping it in
+// a CompositeQuery. A bare signoz/BuilderQuery is valid for every panel kind
+// and is the only kind List panels accept.
+func singleQueryFromEnvelope(envelope map[string]any, requestType qb.RequestType, signal telemetrytypes.Signal) *Query {
+	t, _ := envelope["type"].(string)
+	spec, _ := envelope["spec"].(map[string]any)
+	switch t {
+	case qb.QueryTypePromQL.StringValue():
+		prom, err := decodeMapInto[qb.PromQuery](spec)
+		if err != nil {
+			return nil
+		}
+		return &Query{
+			Kind: requestType,
+			Spec: QuerySpec{
+				Name:   prom.Name,
+				Plugin: QueryPlugin{Kind: QueryKindPromQL, Spec: &prom},
+			},
+		}
+	case qb.QueryTypeClickHouseSQL.StringValue():
+		ch, err := decodeMapInto[qb.ClickHouseQuery](spec)
+		if err != nil {
+			return nil
+		}
+		return &Query{
+			Kind: requestType,
+			Spec: QuerySpec{
+				Name:   ch.Name,
+				Plugin: QueryPlugin{Kind: QueryKindClickHouseSQL, Spec: &ch},
+			},
+		}
+	case qb.QueryTypeBuilder.StringValue():
+		builderSpec := parseBuilderQuerySpec(spec, signal)
+		if builderSpec == nil {
+			return nil
+		}
+		name, _ := spec["name"].(string)
+		return &Query{
+			Kind: requestType,
+			Spec: QuerySpec{
+				Name:   name,
+				Plugin: QueryPlugin{Kind: QueryKindBuilder, Spec: &BuilderQuerySpec{Spec: builderSpec}},
+			},
+		}
+	}
+	return nil
+}
+
+func parseCompositeFromEnvelopes(envelopes []map[string]any) (*CompositeQuerySpec, error) {
+	bytes, err := json.Marshal(envelopes)
+	if err != nil {
+		return nil, errors.WrapInternalf(err, errors.CodeInternal, "marshal v1 query envelopes")
+	}
+	var parsed []qb.QueryEnvelope
+	if err := json.Unmarshal(bytes, &parsed); err != nil {
+		return nil, errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidWidgetQuery, "decode v5 query envelopes")
+	}
+	return &CompositeQuerySpec{Queries: parsed}, nil
+}
+
+func parseBuilderQuerySpec(rawSpec any, signal telemetrytypes.Signal) any {
+	spec, ok := rawSpec.(map[string]any)
+	if !ok {
+		return nil
+	}
+	if !signal.IsZero() {
+		spec["signal"] = signal.StringValue()
+	}
+	bytes, err := json.Marshal(spec)
+	if err != nil {
+		return nil
+	}
+	parsed, err := qb.UnmarshalBuilderQueryBySignal(bytes)
+	if err != nil {
+		return nil
+	}
+	return parsed
+}
+
+// signalFromDataSource maps a v1 data-source string to a v5 signal. Casing
+// varies by source: builder queries store lowercase ("traces"), while variable
+// `dynamicVariablesSource` stores capitalized ("Traces"), so match
+// case-insensitively. Unknown values (e.g. "All telemetry") map to the zero
+// Signal.
+func signalFromDataSource(raw any) telemetrytypes.Signal {
+	s, _ := raw.(string)
+	switch strings.ToLower(s) {
+	case "traces":
+		return telemetrytypes.SignalTraces
+	case "logs":
+		return telemetrytypes.SignalLogs
+	case "metrics":
+		return telemetrytypes.SignalMetrics
+	}
+	return telemetrytypes.Signal{}
+}

pkg/types/dashboardtypes/perses_v1_to_v2_queries_malformed.go

@@ -0,0 +1,205 @@
+package dashboardtypes
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+// ══════════════════════════════════════════════
+// Malformed-field normalization
+// ══════════════════════════════════════════════
+//
+// Reshape known-malformed query-builder fields from their pre-v5 shape into the
+// v5 form before decode. A common case: a dashboard stamped version:"v5" whose
+// bodies aren't actually v5-shaped bypasses the v4→v5 migrator (pkg/transition)
+// and then fails the strict v5 decode. These mirror the frontend, which
+// normalizes by shape regardless of the version tag.
+//
+// Only reshape known field shapes here; leave genuinely corrupt input (e.g. an
+// empty required field) to fail validation rather than grow per-case fixups.
+
+// normalizePreV5Having rewrites a builder query's v4 having (an array of
+// {columnName, op, value} clauses) into the v5 {"expression": ...} shape in
+// place. The v5 decoder wants an object, but a query can still carry the array
+// form — e.g. a dashboard stamped version:"v5" whose bodies predate v5, which
+// the v4→v5 migrator skips wholesale on the version tag. Mirrors the frontend's
+// convertHavingToExpression (QueryBuilderV2/utils.ts): each clause becomes
+// "columnName op value", clauses join with " AND ", array values render as
+// "[v1, v2]". A having that is already an object (or absent) is left untouched.
+func normalizePreV5Having(query map[string]any) {
+	clauses, ok := query["having"].([]any)
+	if !ok {
+		return
+	}
+	exprs := make([]string, 0, len(clauses))
+	for _, c := range clauses {
+		clause, ok := c.(map[string]any)
+		if !ok {
+			continue
+		}
+		col, _ := clause["columnName"].(string)
+		if col == "" {
+			continue
+		}
+		op, _ := clause["op"].(string)
+		exprs = append(exprs, fmt.Sprintf("%s %s %s", col, op, formatHavingValue(clause["value"])))
+	}
+	query["having"] = map[string]any{"expression": strings.Join(exprs, " AND ")}
+}
+
+// aggExprRe extracts a single "func(args)" aggregation with an optional
+// "as alias" (bare word or quoted). Mirrors the regex in the frontend's
+// parseAggregations (prepareQueryRangePayloadV5.ts). Because it only matches
+// well-formed func(args), it naturally discards trailing junk like the stray
+// ")" some source expressions carry ("sum(x) ) )" → "sum(x)").
+var aggExprRe = regexp.MustCompile(`([a-zA-Z0-9_]+\([^)]*\))(?:\s*as\s+('[^']*'|"[^"]*"|[a-zA-Z0-9_-]+))?`)
+
+// normalizePreV5LogTraceAggregations reshapes a logs/traces builder query's
+// aggregations into the v5 {"expression", "alias"} form in place, dropping the
+// metric-only fields (metricName/temporality/timeAggregation/spaceAggregation/
+// reduceTo) that some dashboards carry on non-metric queries — a logs query
+// with a metric-shaped aggregation fails the strict v5 decode ("unknown field
+// metricName"). Mirrors the frontend's createAggregation
+// (prepareQueryRangePayloadV5.ts): each source expression is run through
+// parseAggregations, which extracts the well-formed func(args) parts, lifts any
+// inline "as alias" into the alias field, and splits a comma-joined multi-part
+// expression into separate aggregations. An expression that yields nothing
+// falls back to "count()". Metric queries are left untouched, since a
+// metric-shaped aggregation is correct for them.
+func normalizePreV5LogTraceAggregations(query map[string]any) {
+	switch signalFromDataSource(query["dataSource"]) {
+	case telemetrytypes.SignalLogs, telemetrytypes.SignalTraces:
+	default:
+		return
+	}
+	aggs, ok := query["aggregations"].([]any)
+	if !ok {
+		return
+	}
+	out := make([]any, 0, len(aggs))
+	for _, a := range aggs {
+		agg, ok := a.(map[string]any)
+		if !ok {
+			continue
+		}
+		expr, _ := agg["expression"].(string)
+		alias, _ := agg["alias"].(string)
+		parsed := parseAggregations(expr, alias)
+		if len(parsed) == 0 {
+			parsed = []any{map[string]any{"expression": "count()"}}
+		}
+		out = append(out, parsed...)
+	}
+	query["aggregations"] = out
+}
+
+// parseAggregations extracts every func(args) aggregation from a v1 expression
+// string, pulling an inline "as alias" (or the passed-through availableAlias)
+// into a separate alias field and stripping surrounding quotes. Mirrors the
+// frontend's parseAggregations (prepareQueryRangePayloadV5.ts). Returns nil when
+// the expression contains no well-formed aggregation.
+func parseAggregations(expression, availableAlias string) []any {
+	matches := aggExprRe.FindAllStringSubmatch(expression, -1)
+	out := make([]any, 0, len(matches))
+	for _, m := range matches {
+		alias := m[2]
+		if alias == "" {
+			alias = availableAlias
+		}
+		agg := map[string]any{"expression": m[1]}
+		if alias != "" {
+			agg["alias"] = strings.Trim(alias, `'"`)
+		}
+		out = append(out, agg)
+	}
+	return out
+}
+
+// normalizePreV5SelectColumns fixes a builder query's selectColumns in place so
+// WrapInV5Envelope maps them correctly. That mapper reads the old
+// {key, dataType, type} shape, but some queries store selectColumns the v5 way
+// ({name, fieldDataType, fieldContext}) — those come out with an empty name
+// ("field `` not found"). Backfill the old keys from the v5 ones (so both
+// shapes work) and drop columns with no resolvable name, mirroring the
+// frontend's `name ?? key` read plus its empty-column filter
+// (prepareQueryRangePayloadV5.ts). This runs before WrapInV5Envelope; note it
+// is the inverse direction of normalizePreV5FieldKeys because the two consumers
+// (WrapInV5Envelope vs. the list-panel TelemetryFieldKey decode) expect
+// opposite shapes.
+func normalizePreV5SelectColumns(query map[string]any) {
+	cols, ok := query["selectColumns"].([]any)
+	if !ok {
+		return
+	}
+	out := make([]any, 0, len(cols))
+	for _, c := range cols {
+		col, ok := c.(map[string]any)
+		if !ok {
+			continue
+		}
+		if _, ok := col["key"]; !ok {
+			if name, ok := col["name"]; ok {
+				col["key"] = name
+			}
+		}
+		if _, ok := col["dataType"]; !ok {
+			if fdt, ok := col["fieldDataType"]; ok {
+				col["dataType"] = fdt
+			}
+		}
+		if _, ok := col["type"]; !ok {
+			if fc, ok := col["fieldContext"]; ok {
+				col["type"] = fc
+			}
+		}
+		if key, _ := col["key"].(string); key == "" {
+			continue
+		}
+		out = append(out, col)
+	}
+	query["selectColumns"] = out
+}
+
+// normalizePreV5FieldKeys renames telemetry field keys from the pre-v5
+// query-builder shape ({key, dataType, type}) to the v5 one ({name,
+// fieldDataType, fieldContext}) in place — the same mapping WrapInV5Envelope
+// does for groupBy/orderBy. Without it an old-shape field decodes with an empty
+// name, which TelemetryFieldKey rejects. Entries already carrying "name" are
+// left as-is.
+func normalizePreV5FieldKeys(fields []any) {
+	for _, f := range fields {
+		field, ok := f.(map[string]any)
+		if !ok {
+			continue
+		}
+		if _, hasName := field["name"]; hasName {
+			continue
+		}
+		if key, ok := field["key"]; ok {
+			field["name"] = key
+		}
+		if dataType, ok := field["dataType"]; ok {
+			field["fieldDataType"] = dataType
+		}
+		if typ, ok := field["type"]; ok {
+			field["fieldContext"] = typ
+		}
+	}
+}
+
+// formatHavingValue renders a having clause value: an array as "[v1, v2]", any
+// scalar as its default string form.
+func formatHavingValue(value any) string {
+	arr, ok := value.([]any)
+	if !ok {
+		return fmt.Sprintf("%v", value)
+	}
+	parts := make([]string, len(arr))
+	for i, v := range arr {
+		parts[i] = fmt.Sprintf("%v", v)
+	}
+	return "[" + strings.Join(parts, ", ") + "]"
+}

pkg/types/dashboardtypes/perses_v1_to_v2_tags.go

@@ -0,0 +1,122 @@
+package dashboardtypes
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/types/coretypes"
+	"github.com/SigNoz/signoz/pkg/types/tagtypes"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+// ══════════════════════════════════════════════
+// Tags
+// ══════════════════════════════════════════════
+
+// v1 carries tags as a flat []string; v2 tags are (key, value) pairs. Each v1
+// string is normalized into a pair (separator split, empty-side fallback,
+// reserved-key prefix, `/` scrub). Tags that normalize to the same
+// (lower(key), lower(value)) within a dashboard are collapsed, first occurrence
+// winning the display casing.
+//
+// Characters still illegal after normalization (spaces, punctuation) are molded
+// to fit the tag validators: disallowed runs collapse to "_" (see moldTagField).
+
+// defaultV1TagKey is the key assigned when a v1 tag string has no usable
+// separator (or one side of the split is empty).
+const defaultV1TagKey = "tag"
+
+func (d *v1Decoder) convertV1TagsForOrg(orgID valuer.UUID, raw any) []*tagtypes.Tag {
+	if raw == nil {
+		return nil
+	}
+	rawTagsList, ok := raw.([]any)
+	if !ok {
+		d.noteMalformedField("tags", raw)
+		return nil
+	}
+	seen := make(map[string]struct{}, len(rawTagsList))
+	tagsV2 := make([]*tagtypes.Tag, 0, len(rawTagsList))
+	for i, rawTag := range rawTagsList {
+		s, ok := rawTag.(string)
+		if !ok {
+			d.noteMalformedField(fmt.Sprintf("tags[%d]", i), rawTag)
+			continue
+		}
+		key, value, ok := normalizeV1Tag(s)
+		if !ok {
+			continue
+		}
+		dedupKey := strings.ToLower(key) + "\x00" + strings.ToLower(value)
+		if _, dup := seen[dedupKey]; dup {
+			continue
+		}
+		seen[dedupKey] = struct{}{}
+		tagsV2 = append(tagsV2, tagtypes.NewTag(orgID, coretypes.KindDashboard, key, value))
+	}
+	return tagsV2
+}
+
+// normalizeV1Tag derives a (key, value) pair from one v1 tag string. After
+// splitting and molding both sides, a lone survivor becomes a value under the
+// default key; ok is false if neither survives.
+func normalizeV1Tag(s string) (string, string, bool) {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return "", "", false
+	}
+
+	var rawKey, rawValue string
+	switch {
+	case strings.Contains(s, ":"):
+		rawKey, rawValue, _ = strings.Cut(s, ":")
+		// Only the first ":" separates key from value; collapse the rest.
+		rawValue = strings.ReplaceAll(rawValue, ":", "_")
+	case strings.Contains(s, "/"):
+		rawKey, rawValue, _ = strings.Cut(s, "/")
+	default:
+		rawValue = s
+	}
+	rawKey = strings.TrimSpace(rawKey)
+	rawValue = strings.TrimSpace(rawValue)
+
+	// Reserved-key collision: prefix "_" so the list-query DSL stays unambiguous.
+	if _, reserved := reservedDSLKeys[DSLKey(strings.ToLower(rawKey))]; rawKey != "" && reserved {
+		rawKey = "_" + rawKey
+	}
+
+	key := moldTagField(rawKey, tagKeyDisallowed, tagKeyNotLead, tagtypes.MAX_LEN_TAG_KEY)
+	value := moldTagField(rawValue, tagValueDisallowed, nil, tagtypes.MAX_LEN_TAG_VALUE)
+	switch {
+	case key == "" && value == "":
+		return "", "", false
+	case key == "":
+		return defaultV1TagKey, value, true
+	case value == "":
+		return defaultV1TagKey, key, true
+	default:
+		return key, value, true
+	}
+}
+
+// Inverse of tagKeyRegex/tagValueRegex ("/" always rejected); tagKeyNotLead
+// matches a bad first char for a key. TestMoldedV1TagsPassValidation guards drift.
+var (
+	tagKeyDisallowed   = regexp.MustCompile(`[^a-zA-Z0-9$_@#{}:-]+`)
+	tagValueDisallowed = regexp.MustCompile(`[^a-zA-Z0-9$_@#{}:.+=-]+`)
+	tagKeyNotLead      = regexp.MustCompile(`^[^a-zA-Z$_@{#]`)
+)
+
+// moldTagField collapses disallowed runs to "_", prefixes "_" if notLead hits
+// the first char, and caps at max. Keeps a leading "_", trims a trailing one.
+func moldTagField(s string, disallowed, notLead *regexp.Regexp, max int) string {
+	s = strings.TrimRight(disallowed.ReplaceAllString(s, "_"), "_")
+	if s != "" && notLead != nil && notLead.MatchString(s) {
+		s = "_" + s
+	}
+	if len(s) > max {
+		s = strings.TrimRight(s[:max], "_")
+	}
+	return s
+}

pkg/types/dashboardtypes/perses_v1_to_v2_variables.go

@@ -0,0 +1,169 @@
+package dashboardtypes
+
+import (
+	"sort"
+
+	"github.com/perses/spec/go/dashboard/variable"
+)
+
+// ══════════════════════════════════════════════
+// Variables
+// ══════════════════════════════════════════════
+
+// convertV1Variables walks the v1 `variables` map (UUID-keyed) and produces an
+// ordered []Variable. Variables sort by `order` first, then by id for stable
+// output. v1 variable types map as follows:
+//
+//	QUERY    → ListVariable + signoz/QueryVariable
+//	CUSTOM   → ListVariable + signoz/CustomVariable
+//	DYNAMIC  → ListVariable + signoz/DynamicVariable
+//	TEXTBOX  → TextVariable
+func (d *v1Decoder) convertV1Variables(raw any) []Variable {
+	if raw == nil {
+		return nil
+	}
+	rawVariablesMap, ok := raw.(map[string]any)
+	if !ok {
+		d.noteMalformedField("variables", raw)
+		return nil
+	}
+	type ordered struct {
+		variableID      string
+		variableContent map[string]any
+		order           float64
+	}
+	entries := make([]ordered, 0, len(rawVariablesMap))
+	for variableID, variableContentRaw := range rawVariablesMap {
+		variableContent, ok := variableContentRaw.(map[string]any)
+		if !ok {
+			d.noteMalformedField("variables."+variableID, variableContentRaw)
+			continue
+		}
+		entries = append(entries, ordered{variableID: variableID, variableContent: variableContent, order: d.readFloat(variableContent, "order")})
+	}
+	sort.SliceStable(entries, func(i, j int) bool {
+		if entries[i].order != entries[j].order {
+			return entries[i].order < entries[j].order
+		}
+		return entries[i].variableID < entries[j].variableID
+	})
+
+	variablesV2 := make([]Variable, 0, len(entries))
+	for _, e := range entries {
+		v, ok := d.convertV1Variable(e.variableContent)
+		if !ok {
+			continue
+		}
+		variablesV2 = append(variablesV2, v)
+	}
+	return variablesV2
+}
+
+func (d *v1Decoder) convertV1Variable(v map[string]any) (Variable, bool) {
+	name := d.readString(v, "name")
+	if name == "" {
+		return Variable{}, false
+	}
+	description := d.readString(v, "description")
+	kind := d.readString(v, "type")
+
+	switch kind {
+	case "TEXTBOX":
+		spec := &TextVariableSpec{
+			Display: Display{Name: name, Description: description},
+			Value:   d.readString(v, "textboxValue"),
+			Name:    name,
+		}
+		return Variable{Kind: variable.KindText, Spec: spec}, true
+
+	case "QUERY", "CUSTOM", "DYNAMIC":
+		listSpec := &ListVariableSpec{
+			Display:         Display{Name: name, Description: description},
+			AllowAllValue:   d.readBool(v, "showALLOption"),
+			AllowMultiple:   d.readBool(v, "multiSelect"),
+			CustomAllValue:  d.readString(v, "customAllValue"),
+			CapturingRegexp: d.readString(v, "capturingRegexp"),
+			Sort:            mapV1Sort(d.readString(v, "sort")),
+			Plugin:          d.variablePluginFor(kind, v),
+			Name:            name,
+		}
+		if dv := mapV1VariableDefault(v); dv != nil {
+			listSpec.DefaultValue = dv
+		}
+		return Variable{Kind: variable.KindList, Spec: listSpec}, true
+
+	default:
+		d.note("variable %q has unknown type %q", name, kind)
+		return Variable{}, false
+	}
+}
+
+func (d *v1Decoder) variablePluginFor(kind string, v map[string]any) VariablePlugin {
+	switch kind {
+	case "QUERY":
+		return VariablePlugin{
+			Kind: VariableKindQuery,
+			Spec: &QueryVariableSpec{QueryValue: d.readString(v, "queryValue")},
+		}
+	case "CUSTOM":
+		return VariablePlugin{
+			Kind: VariableKindCustom,
+			Spec: &CustomVariableSpec{CustomValue: d.readString(v, "customValue")},
+		}
+	case "DYNAMIC":
+		spec := &DynamicVariableSpec{Name: d.readString(v, "dynamicVariablesAttribute")}
+		if signal := signalFromDataSource(v["dynamicVariablesSource"]); !signal.IsZero() {
+			spec.Signal = signal
+		}
+		return VariablePlugin{Kind: VariableKindDynamic, Spec: spec}
+	}
+	return VariablePlugin{}
+}
+
+// mapV1VariableDefault reads selectedValue/defaultValue, both polymorphic
+// (string|array), so it indexes the raw value and lets defaultValueFromAny
+// type-switch — no typed accessor, intentionally lenient.
+func mapV1VariableDefault(v map[string]any) *VariableDefaultValue {
+	if raw, ok := v["selectedValue"]; ok {
+		return defaultValueFromAny(raw)
+	}
+	if raw, ok := v["defaultValue"]; ok {
+		return defaultValueFromAny(raw)
+	}
+	return nil
+}
+
+func defaultValueFromAny(raw any) *VariableDefaultValue {
+	switch v := raw.(type) {
+	case string:
+		if v == "" {
+			return nil
+		}
+		return &VariableDefaultValue{variable.DefaultValue{SingleValue: v}}
+	case []any:
+		if len(v) == 0 {
+			return nil
+		}
+		values := make([]string, 0, len(v))
+		for _, item := range v {
+			if s, ok := item.(string); ok && s != "" {
+				values = append(values, s)
+			}
+		}
+		if len(values) == 0 {
+			return nil
+		}
+		return &VariableDefaultValue{variable.DefaultValue{SliceValues: values}}
+	}
+	return nil
+}
+
+func mapV1Sort(s string) ListVariableSpecSort {
+	switch s {
+	case "ASC":
+		return SortAlphabeticalAsc
+	case "DESC":
+		return SortAlphabeticalDesc
+	}
+	return ListVariableSpecSort{} // zero (omitzero) — SortNone is the implicit default
+}

pkg/types/querybuildertypes/querybuildertypesv5/migrate_envelope.go

@@ -0,0 +1,127 @@
+package querybuildertypesv5
+
+// WrapInV5Envelope translates a single v4 builder query/formula map into a
+// v5 query envelope ({"type": ..., "spec": ...}). It is a pure shape transform
+// over untyped maps: v4 builder field names (groupBy/orderBy/selectColumns/
+// dataSource) are rewritten to their v5 equivalents and a `signal` is derived
+// from the data source. queryType selects the envelope type, except a formula
+// (detected when name != queryMap["expression"]) is always emitted as
+// "builder_formula".
+//
+// Migration code (pkg/transition) and the v1→v2 dashboard conversion both
+// produce v5 envelopes, so this lives here with the v5 query types rather than
+// in an infra-level package.
+func WrapInV5Envelope(name string, queryMap map[string]any, queryType string) map[string]any {
+	// Create a properly structured v5 query
+	v5Query := map[string]any{
+		"name":     name,
+		"disabled": queryMap["disabled"],
+		"legend":   queryMap["legend"],
+	}
+
+	if name != queryMap["expression"] {
+		// formula
+		queryType = "builder_formula"
+		v5Query["expression"] = queryMap["expression"]
+		if functions, ok := queryMap["functions"]; ok {
+			v5Query["functions"] = functions
+		}
+		return map[string]any{
+			"type": queryType,
+			"spec": v5Query,
+		}
+	}
+
+	// Add signal based on data source
+	if dataSource, ok := queryMap["dataSource"].(string); ok {
+		switch dataSource {
+		case "traces":
+			v5Query["signal"] = "traces"
+		case "logs":
+			v5Query["signal"] = "logs"
+		case "metrics":
+			v5Query["signal"] = "metrics"
+		}
+	}
+
+	if stepInterval, ok := queryMap["stepInterval"]; ok {
+		v5Query["stepInterval"] = stepInterval
+	}
+
+	if aggregations, ok := queryMap["aggregations"]; ok {
+		v5Query["aggregations"] = aggregations
+	}
+
+	if filter, ok := queryMap["filter"]; ok {
+		v5Query["filter"] = filter
+	}
+
+	// Copy groupBy with proper structure
+	if groupBy, ok := queryMap["groupBy"].([]any); ok {
+		v5GroupBy := make([]any, len(groupBy))
+		for i, gb := range groupBy {
+			if gbMap, ok := gb.(map[string]any); ok {
+				v5GroupBy[i] = map[string]any{
+					"name":          gbMap["key"],
+					"fieldDataType": gbMap["dataType"],
+					"fieldContext":  gbMap["type"],
+				}
+			}
+		}
+		v5Query["groupBy"] = v5GroupBy
+	}
+
+	// Copy orderBy with proper structure
+	if orderBy, ok := queryMap["orderBy"].([]any); ok {
+		v5OrderBy := make([]any, len(orderBy))
+		for i, ob := range orderBy {
+			if obMap, ok := ob.(map[string]any); ok {
+				v5OrderBy[i] = map[string]any{
+					"key": map[string]any{
+						"name":          obMap["columnName"],
+						"fieldDataType": obMap["dataType"],
+						"fieldContext":  obMap["type"],
+					},
+					"direction": obMap["order"],
+				}
+			}
+		}
+		v5Query["order"] = v5OrderBy
+	}
+
+	// Copy selectColumns as selectFields
+	if selectColumns, ok := queryMap["selectColumns"].([]any); ok {
+		v5SelectFields := make([]any, len(selectColumns))
+		for i, col := range selectColumns {
+			if colMap, ok := col.(map[string]any); ok {
+				v5SelectFields[i] = map[string]any{
+					"name":          colMap["key"],
+					"fieldDataType": colMap["dataType"],
+					"fieldContext":  colMap["type"],
+				}
+			}
+		}
+		v5Query["selectFields"] = v5SelectFields
+	}
+
+	// Copy limit and offset
+	if limit, ok := queryMap["limit"]; ok {
+		v5Query["limit"] = limit
+	}
+	if offset, ok := queryMap["offset"]; ok {
+		v5Query["offset"] = offset
+	}
+
+	if having, ok := queryMap["having"]; ok {
+		v5Query["having"] = having
+	}
+
+	if functions, ok := queryMap["functions"]; ok {
+		v5Query["functions"] = functions
+	}
+
+	return map[string]any{
+		"type": queryType,
+		"spec": v5Query,
+	}
+}