chore: bridging field evolution with promoted

cmd/community/server.go

@@ -33,7 +33,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/query-service/app"
@@ -101,8 +100,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing, tagModule tag.Module) dashboard.Module {
-			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, tagModule)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, _ querier.Querier, _ licensing.Licensing) dashboard.Module {
+			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser)
 		},
 		func(_ licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return noopgateway.NewProviderFactory()

cmd/enterprise/server.go

@@ -50,7 +50,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/retention"
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/prometheus"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
@@ -134,8 +133,8 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 			}
 			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, licensing, onBeforeRoleDelete, authtypes.NewRegistry()), nil
 		},
-		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
-			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing, tagModule)
+		func(store sqlstore.SQLStore, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
+			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing)
 		},
 		func(licensing licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config] {
 			return httpgateway.NewProviderFactory(licensing)

ee/modules/dashboard/impldashboard/module.go

@@ -11,7 +11,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	pkgimpldashboard "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -31,9 +30,9 @@ type module struct {
 	licensing          licensing.Licensing
 }
 
-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing, tagModule tag.Module) dashboard.Module {
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, querier querier.Querier, licensing licensing.Licensing) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/ee/modules/dashboard/impldashboard")
-	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser, tagModule)
+	pkgDashboardModule := pkgimpldashboard.NewModule(store, settings, analytics, orgGetter, queryParser)
 
 	return &module{
 		pkgDashboardModule: pkgDashboardModule,
@@ -213,63 +212,6 @@ func (module *module) Create(ctx context.Context, orgID valuer.UUID, createdBy s
 	return module.pkgDashboardModule.Create(ctx, orgID, createdBy, creator, source, data)
 }
 
-func (module *module) CreateV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, source dashboardtypes.Source, postable dashboardtypes.PostableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.CreateV2(ctx, orgID, createdBy, creator, source, postable)
-}
-
-func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.GetV2(ctx, orgID, id)
-}
-
-func (module *module) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.UpdateV2(ctx, orgID, id, updatedBy, updateable)
-}
-
-func (module *module) PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	return module.pkgDashboardModule.PatchV2(ctx, orgID, id, updatedBy, patch)
-}
-
-func (module *module) DeleteV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	return module.store.RunInTx(ctx, func(ctx context.Context) error {
-		if err := module.store.DeletePublic(ctx, id.String()); err != nil && !errors.Ast(err, errors.TypeNotFound) {
-			return err
-		}
-		return module.pkgDashboardModule.DeleteV2(ctx, orgID, id)
-	})
-}
-
-func (module *module) LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
-	return module.pkgDashboardModule.LockUnlockV2(ctx, orgID, id, updatedBy, isAdmin, lock)
-}
-
-func (module *module) ListV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardV2, error) {
-	return module.pkgDashboardModule.ListV2(ctx, orgID, userID, params)
-}
-
-func (module *module) PinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error {
-	return module.pkgDashboardModule.PinV2(ctx, orgID, userID, id)
-}
-
-func (module *module) UnpinV2(ctx context.Context, userID valuer.UUID, id valuer.UUID) error {
-	return module.pkgDashboardModule.UnpinV2(ctx, userID, id)
-}
-
-func (module *module) CreateView(ctx context.Context, orgID valuer.UUID, createdBy string, postable dashboardtypes.PostableDashboardView) (*dashboardtypes.DashboardView, error) {
-	return module.pkgDashboardModule.CreateView(ctx, orgID, createdBy, postable)
-}
-
-func (module *module) ListViews(ctx context.Context, orgID valuer.UUID) (*dashboardtypes.ListableDashboardView, error) {
-	return module.pkgDashboardModule.ListViews(ctx, orgID)
-}
-
-func (module *module) UpdateView(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardView) (*dashboardtypes.DashboardView, error) {
-	return module.pkgDashboardModule.UpdateView(ctx, orgID, id, updatedBy, updateable)
-}
-
-func (module *module) DeleteView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	return module.pkgDashboardModule.DeleteView(ctx, orgID, id)
-}
-
 func (module *module) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.Dashboard, error) {
 	return module.pkgDashboardModule.Get(ctx, orgID, id)
 }

ee/sqlstore/postgressqlstore/listfilter_test.go

@@ -1,65 +0,0 @@
-package postgressqlstore
-
-// Lives in this package (rather than the listfilter package) so it can use
-// the unexported newFormatter constructor without driving a real Postgres
-// connection. Covers the only listfilter cases whose emitted SQL differs
-// between SQLite and Postgres — the ones that go through JSONExtractString
-// (`name`, `description`). All other operators (=, !=, BETWEEN, LIKE, IN,
-// EXISTS, lower(...)) emit identical ANSI SQL on both dialects and are
-// covered by the SQLite tests in the listfilter package itself.
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/uptrace/bun/dialect/pgdialect"
-
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes/listfilter"
-)
-
-func TestListFilterCompile_Postgres(t *testing.T) {
-	f := newFormatter(pgdialect.New())
-
-	cases := []struct {
-		name     string
-		query    string
-		wantSQL  string
-		wantArgs []any
-	}{
-		{
-			name:     "name = uses Postgres -> / ->> chain",
-			query:    `name = 'overview'`,
-			wantSQL:  `"dashboard"."data"->'data'->'display'->>'name' = ?`,
-			wantArgs: []any{"overview"},
-		},
-		{
-			name:     "name CONTAINS — same JSON path, LIKE pattern",
-			query:    `name CONTAINS 'overview'`,
-			wantSQL:  `"dashboard"."data"->'data'->'display'->>'name' LIKE ?`,
-			wantArgs: []any{"%overview%"},
-		},
-		{
-			name:     "name ILIKE — LOWER wraps the JSON path",
-			query:    `name ILIKE 'Prod%'`,
-			wantSQL:  `lower("dashboard"."data"->'data'->'display'->>'name') LIKE LOWER(?)`,
-			wantArgs: []any{"Prod%"},
-		},
-		{
-			name:     "description = follows the same path shape",
-			query:    `description = 'd1'`,
-			wantSQL:  `"dashboard"."data"->'data'->'display'->>'description' = ?`,
-			wantArgs: []any{"d1"},
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			out, err := listfilter.Compile(c.query, f)
-			require.NoError(t, err)
-			require.NotNil(t, out)
-			assert.Equal(t, c.wantSQL, out.SQL)
-			assert.Equal(t, c.wantArgs, out.Args)
-		})
-	}
-}

frontend/src/api/generated/services/dashboard/index.ts

@@ -18,34 +18,18 @@ import type {
 } from 'react-query';
 
 import type {
-	CreateDashboardV2201,
 	CreatePublicDashboard201,
 	CreatePublicDashboardPathParameters,
-	DashboardtypesJSONPatchDocumentDTO,
-	DashboardtypesPostableDashboardV2DTO,
 	DashboardtypesPostablePublicDashboardDTO,
 	DashboardtypesUpdatablePublicDashboardDTO,
-	DeleteDashboardV2PathParameters,
 	DeletePublicDashboardPathParameters,
-	GetDashboardV2200,
-	GetDashboardV2PathParameters,
 	GetPublicDashboard200,
 	GetPublicDashboardData200,
 	GetPublicDashboardDataPathParameters,
 	GetPublicDashboardPathParameters,
 	GetPublicDashboardWidgetQueryRange200,
 	GetPublicDashboardWidgetQueryRangePathParameters,
-	ListDashboardsV2200,
-	ListDashboardsV2Params,
-	LockDashboardV2PathParameters,
-	PatchDashboardV2200,
-	PatchDashboardV2PathParameters,
-	PinDashboardV2PathParameters,
 	RenderErrorResponseDTO,
-	UnlockDashboardV2PathParameters,
-	UnpinDashboardV2PathParameters,
-	UpdateDashboardV2200,
-	UpdateDashboardV2PathParameters,
 	UpdatePublicDashboardPathParameters,
 } from '../sigNoz.schemas';
 
@@ -644,878 +628,3 @@ export const invalidateGetPublicDashboardWidgetQueryRange = async (
 
 	return queryClient;
 };
-
-/**
- * Returns a page of v2-shape dashboards for the calling user's org. Supports a filter DSL (`query`), sort (`updated_at`/`created_at`/`title`), order (`asc`/`desc`), and offset-based pagination (`limit`/`offset`). Pinned dashboards float to the top of each page.
- * @summary List dashboards (v2)
- */
-export const listDashboardsV2 = (
-	params?: ListDashboardsV2Params,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<ListDashboardsV2200>({
-		url: `/api/v2/dashboards`,
-		method: 'GET',
-		params,
-		signal,
-	});
-};
-
-export const getListDashboardsV2QueryKey = (
-	params?: ListDashboardsV2Params,
-) => {
-	return [`/api/v2/dashboards`, ...(params ? [params] : [])] as const;
-};
-
-export const getListDashboardsV2QueryOptions = <
-	TData = Awaited<ReturnType<typeof listDashboardsV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListDashboardsV2Params,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDashboardsV2>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getListDashboardsV2QueryKey(params);
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof listDashboardsV2>>> = ({
-		signal,
-	}) => listDashboardsV2(params, signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof listDashboardsV2>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type ListDashboardsV2QueryResult = NonNullable<
-	Awaited<ReturnType<typeof listDashboardsV2>>
->;
-export type ListDashboardsV2QueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary List dashboards (v2)
- */
-
-export function useListDashboardsV2<
-	TData = Awaited<ReturnType<typeof listDashboardsV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	params?: ListDashboardsV2Params,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof listDashboardsV2>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getListDashboardsV2QueryOptions(params, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary List dashboards (v2)
- */
-export const invalidateListDashboardsV2 = async (
-	queryClient: QueryClient,
-	params?: ListDashboardsV2Params,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getListDashboardsV2QueryKey(params) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint creates a dashboard in the v2 format that follows Perses spec.
- * @summary Create dashboard (v2)
- */
-export const createDashboardV2 = (
-	dashboardtypesPostableDashboardV2DTO?: BodyType<DashboardtypesPostableDashboardV2DTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<CreateDashboardV2201>({
-		url: `/api/v2/dashboards`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: dashboardtypesPostableDashboardV2DTO,
-		signal,
-	});
-};
-
-export const getCreateDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createDashboardV2>>,
-		TError,
-		{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof createDashboardV2>>,
-	TError,
-	{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> },
-	TContext
-> => {
-	const mutationKey = ['createDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof createDashboardV2>>,
-		{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return createDashboardV2(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type CreateDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof createDashboardV2>>
->;
-export type CreateDashboardV2MutationBody =
-	| BodyType<DashboardtypesPostableDashboardV2DTO>
-	| undefined;
-export type CreateDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Create dashboard (v2)
- */
-export const useCreateDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof createDashboardV2>>,
-		TError,
-		{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof createDashboardV2>>,
-	TError,
-	{ data?: BodyType<DashboardtypesPostableDashboardV2DTO> },
-	TContext
-> => {
-	return useMutation(getCreateDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint deletes a v2-shape dashboard along with its tag relations. Locked dashboards are rejected.
- * @summary Delete dashboard (v2)
- */
-export const deleteDashboardV2 = (
-	{ id }: DeleteDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getDeleteDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDashboardV2>>,
-		TError,
-		{ pathParams: DeleteDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof deleteDashboardV2>>,
-	TError,
-	{ pathParams: DeleteDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['deleteDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof deleteDashboardV2>>,
-		{ pathParams: DeleteDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return deleteDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type DeleteDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof deleteDashboardV2>>
->;
-
-export type DeleteDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Delete dashboard (v2)
- */
-export const useDeleteDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof deleteDashboardV2>>,
-		TError,
-		{ pathParams: DeleteDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof deleteDashboardV2>>,
-	TError,
-	{ pathParams: DeleteDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getDeleteDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint returns a v2-shape dashboard.
- * @summary Get dashboard (v2)
- */
-export const getDashboardV2 = (
-	{ id }: GetDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetDashboardV2200>({
-		url: `/api/v2/dashboards/${id}`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetDashboardV2QueryKey = ({
-	id,
-}: GetDashboardV2PathParameters) => {
-	return [`/api/v2/dashboards/${id}`] as const;
-};
-
-export const getGetDashboardV2QueryOptions = <
-	TData = Awaited<ReturnType<typeof getDashboardV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetDashboardV2PathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getDashboardV2>>,
-			TError,
-			TData
-		>;
-	},
-) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetDashboardV2QueryKey({ id });
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getDashboardV2>>> = ({
-		signal,
-	}) => getDashboardV2({ id }, signal);
-
-	return {
-		queryKey,
-		queryFn,
-		enabled: !!id,
-		...queryOptions,
-	} as UseQueryOptions<
-		Awaited<ReturnType<typeof getDashboardV2>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetDashboardV2QueryResult = NonNullable<
-	Awaited<ReturnType<typeof getDashboardV2>>
->;
-export type GetDashboardV2QueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get dashboard (v2)
- */
-
-export function useGetDashboardV2<
-	TData = Awaited<ReturnType<typeof getDashboardV2>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(
-	{ id }: GetDashboardV2PathParameters,
-	options?: {
-		query?: UseQueryOptions<
-			Awaited<ReturnType<typeof getDashboardV2>>,
-			TError,
-			TData
-		>;
-	},
-): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetDashboardV2QueryOptions({ id }, options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get dashboard (v2)
- */
-export const invalidateGetDashboardV2 = async (
-	queryClient: QueryClient,
-	{ id }: GetDashboardV2PathParameters,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetDashboardV2QueryKey({ id }) },
-		options,
-	);
-
-	return queryClient;
-};
-
-/**
- * This endpoint applies an RFC 6902 JSON Patch to a v2-shape dashboard. The patch is applied against the postable view of the dashboard (metadata, data, tags), so individual panels, queries, variables, layouts, or tags can be updated without re-sending the rest of the dashboard. Locked dashboards are rejected.
- * @summary Patch dashboard (v2)
- */
-export const patchDashboardV2 = (
-	{ id }: PatchDashboardV2PathParameters,
-	dashboardtypesJSONPatchDocumentDTONull?: BodyType<DashboardtypesJSONPatchDocumentDTO | null> | null,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<PatchDashboardV2200>({
-		url: `/api/v2/dashboards/${id}`,
-		method: 'PATCH',
-		headers: { 'Content-Type': 'application/json' },
-		data: dashboardtypesJSONPatchDocumentDTONull,
-		signal,
-	});
-};
-
-export const getPatchDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof patchDashboardV2>>,
-		TError,
-		{
-			pathParams: PatchDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof patchDashboardV2>>,
-	TError,
-	{
-		pathParams: PatchDashboardV2PathParameters;
-		data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-	},
-	TContext
-> => {
-	const mutationKey = ['patchDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof patchDashboardV2>>,
-		{
-			pathParams: PatchDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return patchDashboardV2(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PatchDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof patchDashboardV2>>
->;
-export type PatchDashboardV2MutationBody =
-	| BodyType<DashboardtypesJSONPatchDocumentDTO | null>
-	| undefined;
-export type PatchDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Patch dashboard (v2)
- */
-export const usePatchDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof patchDashboardV2>>,
-		TError,
-		{
-			pathParams: PatchDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof patchDashboardV2>>,
-	TError,
-	{
-		pathParams: PatchDashboardV2PathParameters;
-		data?: BodyType<DashboardtypesJSONPatchDocumentDTO | null>;
-	},
-	TContext
-> => {
-	return useMutation(getPatchDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint updates a v2-shape dashboard's metadata, data, and tag set. Locked dashboards are rejected.
- * @summary Update dashboard (v2)
- */
-export const updateDashboardV2 = (
-	{ id }: UpdateDashboardV2PathParameters,
-	dashboardtypesPostableDashboardV2DTO?: BodyType<DashboardtypesPostableDashboardV2DTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<UpdateDashboardV2200>({
-		url: `/api/v2/dashboards/${id}`,
-		method: 'PUT',
-		headers: { 'Content-Type': 'application/json' },
-		data: dashboardtypesPostableDashboardV2DTO,
-		signal,
-	});
-};
-
-export const getUpdateDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateDashboardV2>>,
-		TError,
-		{
-			pathParams: UpdateDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof updateDashboardV2>>,
-	TError,
-	{
-		pathParams: UpdateDashboardV2PathParameters;
-		data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['updateDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof updateDashboardV2>>,
-		{
-			pathParams: UpdateDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return updateDashboardV2(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UpdateDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof updateDashboardV2>>
->;
-export type UpdateDashboardV2MutationBody =
-	| BodyType<DashboardtypesPostableDashboardV2DTO>
-	| undefined;
-export type UpdateDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Update dashboard (v2)
- */
-export const useUpdateDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof updateDashboardV2>>,
-		TError,
-		{
-			pathParams: UpdateDashboardV2PathParameters;
-			data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof updateDashboardV2>>,
-	TError,
-	{
-		pathParams: UpdateDashboardV2PathParameters;
-		data?: BodyType<DashboardtypesPostableDashboardV2DTO>;
-	},
-	TContext
-> => {
-	return useMutation(getUpdateDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint unlocks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.
- * @summary Unlock dashboard (v2)
- */
-export const unlockDashboardV2 = (
-	{ id }: UnlockDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}/lock`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getUnlockDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unlockDashboardV2>>,
-		TError,
-		{ pathParams: UnlockDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof unlockDashboardV2>>,
-	TError,
-	{ pathParams: UnlockDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['unlockDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof unlockDashboardV2>>,
-		{ pathParams: UnlockDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return unlockDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UnlockDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof unlockDashboardV2>>
->;
-
-export type UnlockDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Unlock dashboard (v2)
- */
-export const useUnlockDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unlockDashboardV2>>,
-		TError,
-		{ pathParams: UnlockDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof unlockDashboardV2>>,
-	TError,
-	{ pathParams: UnlockDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getUnlockDashboardV2MutationOptions(options));
-};
-/**
- * This endpoint locks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.
- * @summary Lock dashboard (v2)
- */
-export const lockDashboardV2 = (
-	{ id }: LockDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}/lock`,
-		method: 'PUT',
-		signal,
-	});
-};
-
-export const getLockDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof lockDashboardV2>>,
-		TError,
-		{ pathParams: LockDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof lockDashboardV2>>,
-	TError,
-	{ pathParams: LockDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['lockDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof lockDashboardV2>>,
-		{ pathParams: LockDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return lockDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type LockDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof lockDashboardV2>>
->;
-
-export type LockDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Lock dashboard (v2)
- */
-export const useLockDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof lockDashboardV2>>,
-		TError,
-		{ pathParams: LockDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof lockDashboardV2>>,
-	TError,
-	{ pathParams: LockDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getLockDashboardV2MutationOptions(options));
-};
-/**
- * Removes the pin for the calling user. Idempotent — unpinning a dashboard that wasn't pinned still returns 204.
- * @summary Unpin a dashboard for the current user (v2)
- */
-export const unpinDashboardV2 = (
-	{ id }: UnpinDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}/pins/me`,
-		method: 'DELETE',
-		signal,
-	});
-};
-
-export const getUnpinDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unpinDashboardV2>>,
-		TError,
-		{ pathParams: UnpinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof unpinDashboardV2>>,
-	TError,
-	{ pathParams: UnpinDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['unpinDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof unpinDashboardV2>>,
-		{ pathParams: UnpinDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return unpinDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type UnpinDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof unpinDashboardV2>>
->;
-
-export type UnpinDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Unpin a dashboard for the current user (v2)
- */
-export const useUnpinDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof unpinDashboardV2>>,
-		TError,
-		{ pathParams: UnpinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof unpinDashboardV2>>,
-	TError,
-	{ pathParams: UnpinDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getUnpinDashboardV2MutationOptions(options));
-};
-/**
- * Pins the dashboard for the calling user. A user can pin at most 10 dashboards; pinning when at the limit returns 409. Re-pinning an already-pinned dashboard is a no-op success.
- * @summary Pin a dashboard for the current user (v2)
- */
-export const pinDashboardV2 = (
-	{ id }: PinDashboardV2PathParameters,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<string>({
-		url: `/api/v2/dashboards/${id}/pins/me`,
-		method: 'PUT',
-		signal,
-	});
-};
-
-export const getPinDashboardV2MutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof pinDashboardV2>>,
-		TError,
-		{ pathParams: PinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof pinDashboardV2>>,
-	TError,
-	{ pathParams: PinDashboardV2PathParameters },
-	TContext
-> => {
-	const mutationKey = ['pinDashboardV2'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof pinDashboardV2>>,
-		{ pathParams: PinDashboardV2PathParameters }
-	> = (props) => {
-		const { pathParams } = props ?? {};
-
-		return pinDashboardV2(pathParams);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type PinDashboardV2MutationResult = NonNullable<
-	Awaited<ReturnType<typeof pinDashboardV2>>
->;
-
-export type PinDashboardV2MutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Pin a dashboard for the current user (v2)
- */
-export const usePinDashboardV2 = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof pinDashboardV2>>,
-		TError,
-		{ pathParams: PinDashboardV2PathParameters },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof pinDashboardV2>>,
-	TError,
-	{ pathParams: PinDashboardV2PathParameters },
-	TContext
-> => {
-	return useMutation(getPinDashboardV2MutationOptions(options));
-};

frontend/src/container/DashboardContainer/visualization/panels/BarPanel/__tests__/utils.test.ts

@@ -1,282 +0,0 @@
-import { Widgets } from 'types/api/dashboard/getAll';
-import {
-	MetricRangePayloadProps,
-	MetricRangePayloadV3,
-} from 'types/api/metrics/getQueryRange';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { PanelMode } from '../../types';
-import { prepareBarPanelConfig } from '../utils';
-import { prepareChartData } from 'lib/uPlotV2/utils/dataUtils';
-
-jest.mock(
-	'container/DashboardContainer/visualization/panels/utils/legendVisibilityUtils',
-	() => ({
-		getStoredSeriesVisibility: jest.fn(),
-	}),
-);
-
-jest.mock('lib/uPlotLib/plugins/onClickPlugin', () => ({
-	__esModule: true,
-	default: jest.fn().mockReturnValue({ name: 'onClickPlugin' }),
-}));
-
-jest.mock('lib/dashboard/getQueryResults', () => ({
-	getLegend: jest.fn(
-		(_queryData: unknown, _query: unknown, labelName: string) =>
-			`legend-${labelName}`,
-	),
-}));
-
-jest.mock('lib/getLabelName', () => ({
-	__esModule: true,
-	default: jest.fn(
-		(_metric: unknown, _queryName: string, _legend: string) => 'baseLabel',
-	),
-}));
-
-jest.mock(
-	'container/DashboardContainer/visualization/charts/utils/stackSeriesUtils',
-	() => ({
-		getInitialStackedBands: jest.fn().mockReturnValue([]),
-	}),
-);
-
-const getLegendMock = jest.requireMock('lib/dashboard/getQueryResults')
-	.getLegend as jest.Mock;
-const getLabelNameMock = jest.requireMock('lib/getLabelName')
-	.default as jest.Mock;
-const getInitialStackedBandsMock = jest.requireMock(
-	'container/DashboardContainer/visualization/charts/utils/stackSeriesUtils',
-).getInitialStackedBands as jest.Mock;
-
-const createApiResponse = (
-	result: MetricRangePayloadProps['data']['result'] = [],
-): MetricRangePayloadProps => ({
-	data: {
-		result,
-		resultType: 'matrix',
-		newResult: null as unknown as MetricRangePayloadV3,
-	},
-});
-
-const createWidget = (overrides: Partial<Widgets> = {}): Widgets =>
-	({
-		id: 'widget-1',
-		yAxisUnit: 'ms',
-		isLogScale: false,
-		thresholds: [],
-		customLegendColors: {},
-		...overrides,
-	}) as Widgets;
-
-const defaultTimezone = {
-	name: 'UTC',
-	value: 'UTC',
-	offset: 'UTC',
-	searchIndex: 'UTC',
-};
-
-describe('BarPanel utils', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-		getLabelNameMock.mockReturnValue('baseLabel');
-		getLegendMock.mockImplementation(
-			(_queryData: unknown, _query: unknown, labelName: string) =>
-				`legend-${labelName}`,
-		);
-	});
-
-	describe('prepareBarPanelData', () => {
-		it('returns aligned data with timestamps and empty series when result is empty', () => {
-			const data = prepareChartData(createApiResponse([]));
-			expect(data).toHaveLength(1);
-			expect(data[0]).toStrictEqual([]);
-		});
-
-		it('returns timestamps and one series of y values for single series', () => {
-			const data = prepareChartData(
-				createApiResponse([
-					{
-						metric: {},
-						queryName: 'Q',
-						legend: 'Series A',
-						values: [
-							[1000, '10'],
-							[2000, '20'],
-						],
-					} as MetricRangePayloadProps['data']['result'][0],
-				]),
-			);
-			expect(data).toHaveLength(2);
-			expect(data[0]).toStrictEqual([1000, 2000]);
-			expect(data[1]).toStrictEqual([10, 20]);
-		});
-
-		it('merges timestamps and fills missing values with null for multiple series', () => {
-			const data = prepareChartData(
-				createApiResponse([
-					{
-						metric: {},
-						queryName: 'Q1',
-						values: [
-							[1000, '1'],
-							[3000, '3'],
-						],
-					} as MetricRangePayloadProps['data']['result'][0],
-					{
-						metric: {},
-						queryName: 'Q2',
-						values: [
-							[1000, '10'],
-							[2000, '20'],
-						],
-					} as MetricRangePayloadProps['data']['result'][0],
-				]),
-			);
-			expect(data[0]).toStrictEqual([1000, 2000, 3000]);
-			expect(data[1]).toStrictEqual([1, null, 3]);
-			expect(data[2]).toStrictEqual([10, 20, null]);
-		});
-	});
-
-	describe('prepareBarPanelConfig', () => {
-		const baseParams = {
-			widget: createWidget(),
-			isDarkMode: true,
-			currentQuery: {} as Query,
-			onClick: jest.fn(),
-			onDragSelect: jest.fn(),
-			apiResponse: createApiResponse(),
-			timezone: defaultTimezone,
-			panelMode: PanelMode.DASHBOARD_VIEW,
-		};
-
-		it('adds no series when apiResponse has empty result', () => {
-			const config = prepareBarPanelConfig(baseParams).getConfig();
-			expect(config.series).toHaveLength(1);
-		});
-
-		it('adds one series per result item', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-				{
-					metric: {},
-					queryName: 'Q2',
-					values: [[1000, '2']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			const config = prepareBarPanelConfig({
-				...baseParams,
-				apiResponse,
-			}).getConfig();
-			expect(config.series).toHaveLength(3);
-		});
-
-		it('uses getLegend for label when currentQuery is provided', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					legend: 'L1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			const config = prepareBarPanelConfig({
-				...baseParams,
-				apiResponse,
-				currentQuery: {} as Query,
-			}).getConfig();
-			expect(getLegendMock).toHaveBeenCalled();
-			expect(config.series?.[1]).toMatchObject({ label: 'legend-baseLabel' });
-		});
-
-		it('uses getLabelName for label when currentQuery is null', () => {
-			getLegendMock.mockReset();
-			const apiResponse = createApiResponse([
-				{
-					metric: { __name__: 'requests' },
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			prepareBarPanelConfig({
-				...baseParams,
-				apiResponse,
-				currentQuery: null as unknown as Query,
-			});
-			expect(getLabelNameMock).toHaveBeenCalled();
-			expect(getLegendMock).not.toHaveBeenCalled();
-		});
-
-		it('passes result metric to each series for cross-panel sync', () => {
-			const metric = { host: 'server1', __name__: 'http_requests' };
-			const apiResponse = createApiResponse([
-				{
-					metric,
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			const config = prepareBarPanelConfig({
-				...baseParams,
-				apiResponse,
-			}).getConfig();
-			expect(config.series?.[1]).toMatchObject({ metric });
-		});
-
-		it('uses widget customLegendColors for series stroke', () => {
-			const widget = createWidget({
-				customLegendColors: { 'legend-baseLabel': '#ff0000' },
-			});
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			const config = prepareBarPanelConfig({
-				...baseParams,
-				widget,
-				apiResponse,
-			}).getConfig();
-			expect(config.series?.[1]).toMatchObject({ stroke: '#ff0000' });
-		});
-
-		it('calls getInitialStackedBands when widget is stackedBarChart', () => {
-			const widget = createWidget({ stackedBarChart: true });
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-				{
-					metric: {},
-					queryName: 'Q2',
-					values: [[1000, '2']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			prepareBarPanelConfig({ ...baseParams, widget, apiResponse });
-			// seriesCount = result.length + 1 = 3
-			expect(getInitialStackedBandsMock).toHaveBeenCalledWith(3);
-		});
-
-		it('does not call getInitialStackedBands for non-stacked chart', () => {
-			const apiResponse = createApiResponse([
-				{
-					metric: {},
-					queryName: 'Q1',
-					values: [[1000, '1']],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-			prepareBarPanelConfig({ ...baseParams, apiResponse });
-			expect(getInitialStackedBandsMock).not.toHaveBeenCalled();
-		});
-	});
-});

frontend/src/container/DashboardContainer/visualization/panels/TimeSeriesPanel/__tests__/utils.test.ts

@@ -303,27 +303,6 @@ describe('TimeSeriesPanel utils', () => {
 			expect(seriesConfig!.stroke).toBe('#ff0000');
 		});
 
-		it('passes result metric to each series for cross-panel sync', () => {
-			const metric = { host: 'server1', __name__: 'cpu' };
-			const apiResponse = createApiResponse([
-				{
-					metric,
-					queryName: 'Q',
-					values: [
-						[1000, '1'],
-						[2000, '2'],
-					],
-				} as MetricRangePayloadProps['data']['result'][0],
-			]);
-
-			const config = prepareUPlotConfig({
-				...baseParams,
-				apiResponse,
-			}).getConfig();
-
-			expect(config.series?.[1]).toMatchObject({ metric });
-		});
-
 		it('adds multiple series when result has multiple items', () => {
 			const apiResponse = createApiResponse([
 				{

frontend/src/container/QueryTable/Drilldown/__tests__/useBaseDrilldownNavigate.test.ts

@@ -1,296 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import ROUTES from 'constants/routes';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { getViewQuery } from '../drilldownUtils';
-import { AggregateData } from '../useAggregateDrilldown';
-import useBaseDrilldownNavigate, {
-	buildDrilldownUrl,
-	getRoute,
-} from '../useBaseDrilldownNavigate';
-
-const mockSafeNavigate = jest.fn();
-
-jest.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: typeof mockSafeNavigate } => ({
-		safeNavigate: mockSafeNavigate,
-	}),
-}));
-
-jest.mock('../drilldownUtils', () => ({
-	...jest.requireActual('../drilldownUtils'),
-	getViewQuery: jest.fn(),
-}));
-
-const mockGetViewQuery = getViewQuery as jest.Mock;
-
-// ─── Fixtures ────────────────────────────────────────────────────────────────
-
-const MOCK_QUERY: Query = {
-	id: 'q1',
-	queryType: 'builder' as any,
-	builder: {
-		queryData: [
-			{
-				queryName: 'A',
-				dataSource: 'metrics' as any,
-				groupBy: [],
-				expression: '',
-				disabled: false,
-				functions: [],
-				legend: '',
-				having: [],
-				limit: null,
-				stepInterval: undefined,
-				orderBy: [],
-			},
-		],
-		queryFormulas: [],
-		queryTraceOperator: [],
-	},
-	promql: [],
-	clickhouse_sql: [],
-};
-
-const MOCK_VIEW_QUERY: Query = {
-	...MOCK_QUERY,
-	builder: {
-		...MOCK_QUERY.builder,
-		queryData: [
-			{
-				...MOCK_QUERY.builder.queryData[0],
-				filters: { items: [], op: 'AND' },
-			},
-		],
-	},
-};
-
-const MOCK_AGGREGATE_DATA: AggregateData = {
-	queryName: 'A',
-	filters: [{ filterKey: 'service_name', filterValue: 'auth', operator: '=' }],
-	timeRange: { startTime: 1000000, endTime: 2000000 },
-};
-
-// ─── getRoute ─────────────────────────────────────────────────────────────────
-
-describe('getRoute', () => {
-	it.each([
-		['view_logs', ROUTES.LOGS_EXPLORER],
-		['view_metrics', ROUTES.METRICS_EXPLORER],
-		['view_traces', ROUTES.TRACES_EXPLORER],
-	])('maps %s to the correct explorer route', (key, expected) => {
-		expect(getRoute(key)).toBe(expected);
-	});
-
-	it('returns empty string for an unknown key', () => {
-		expect(getRoute('view_dashboard')).toBe('');
-	});
-});
-
-// ─── buildDrilldownUrl ────────────────────────────────────────────────────────
-
-describe('buildDrilldownUrl', () => {
-	beforeEach(() => {
-		mockGetViewQuery.mockReturnValue(MOCK_VIEW_QUERY);
-	});
-
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('returns null for an unknown drilldown key', () => {
-		const url = buildDrilldownUrl(
-			MOCK_QUERY,
-			MOCK_AGGREGATE_DATA,
-			'view_dashboard',
-		);
-		expect(url).toBeNull();
-	});
-
-	it('returns null when getViewQuery returns null', () => {
-		mockGetViewQuery.mockReturnValue(null);
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).toBeNull();
-	});
-
-	it('returns a URL starting with the logs explorer route for view_logs', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).not.toBeNull();
-		expect(url).toContain(ROUTES.LOGS_EXPLORER);
-	});
-
-	it('returns a URL starting with the traces explorer route for view_traces', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_traces');
-		expect(url).toContain(ROUTES.TRACES_EXPLORER);
-	});
-
-	it('includes compositeQuery param in the URL', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).toContain('compositeQuery=');
-	});
-
-	it('includes startTime and endTime when aggregateData has a timeRange', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).toContain('startTime=1000000');
-		expect(url).toContain('endTime=2000000');
-	});
-
-	it('omits startTime and endTime when aggregateData has no timeRange', () => {
-		const { timeRange: _, ...withoutTimeRange } = MOCK_AGGREGATE_DATA;
-		const url = buildDrilldownUrl(MOCK_QUERY, withoutTimeRange, 'view_logs');
-		expect(url).not.toContain('startTime=');
-		expect(url).not.toContain('endTime=');
-	});
-
-	it('includes summaryFilters param for view_metrics', () => {
-		const url = buildDrilldownUrl(
-			MOCK_QUERY,
-			MOCK_AGGREGATE_DATA,
-			'view_metrics',
-		);
-		expect(url).toContain(ROUTES.METRICS_EXPLORER);
-		expect(url).toContain('summaryFilters=');
-	});
-
-	it('does not include summaryFilters param for non-metrics routes', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(url).not.toContain('summaryFilters=');
-	});
-
-	it('handles null aggregateData by passing empty filters and empty queryName', () => {
-		const url = buildDrilldownUrl(MOCK_QUERY, null, 'view_logs');
-		expect(url).not.toBeNull();
-		expect(mockGetViewQuery).toHaveBeenCalledWith(
-			MOCK_QUERY,
-			[],
-			'view_logs',
-			'',
-		);
-	});
-
-	it('passes aggregateData filters and queryName to getViewQuery', () => {
-		buildDrilldownUrl(MOCK_QUERY, MOCK_AGGREGATE_DATA, 'view_logs');
-		expect(mockGetViewQuery).toHaveBeenCalledWith(
-			MOCK_QUERY,
-			MOCK_AGGREGATE_DATA.filters,
-			'view_logs',
-			MOCK_AGGREGATE_DATA.queryName,
-		);
-	});
-});
-
-// ─── useBaseDrilldownNavigate ─────────────────────────────────────────────────
-
-describe('useBaseDrilldownNavigate', () => {
-	beforeEach(() => {
-		mockGetViewQuery.mockReturnValue(MOCK_VIEW_QUERY);
-	});
-
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	it('calls safeNavigate with the built URL on a valid key', () => {
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-			}),
-		);
-
-		result.current('view_logs');
-
-		expect(mockSafeNavigate).toHaveBeenCalledTimes(1);
-		const [url] = mockSafeNavigate.mock.calls[0];
-		expect(url).toContain(ROUTES.LOGS_EXPLORER);
-		expect(url).toContain('compositeQuery=');
-	});
-
-	it('opens the explorer in a new tab', () => {
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-			}),
-		);
-
-		result.current('view_traces');
-
-		expect(mockSafeNavigate).toHaveBeenCalledWith(expect.any(String), {
-			newTab: true,
-		});
-	});
-
-	it('calls callback after successful navigation', () => {
-		const callback = jest.fn();
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-				callback,
-			}),
-		);
-
-		result.current('view_logs');
-
-		expect(callback).toHaveBeenCalledTimes(1);
-	});
-
-	it('does not call safeNavigate for an unknown key', () => {
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-			}),
-		);
-
-		result.current('view_dashboard');
-
-		expect(mockSafeNavigate).not.toHaveBeenCalled();
-	});
-
-	it('still calls callback when the key is unknown', () => {
-		const callback = jest.fn();
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-				callback,
-			}),
-		);
-
-		result.current('view_dashboard');
-
-		expect(callback).toHaveBeenCalledTimes(1);
-		expect(mockSafeNavigate).not.toHaveBeenCalled();
-	});
-
-	it('still calls callback when getViewQuery returns null', () => {
-		mockGetViewQuery.mockReturnValue(null);
-		const callback = jest.fn();
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: MOCK_AGGREGATE_DATA,
-				callback,
-			}),
-		);
-
-		result.current('view_logs');
-
-		expect(callback).toHaveBeenCalledTimes(1);
-		expect(mockSafeNavigate).not.toHaveBeenCalled();
-	});
-
-	it('handles null aggregateData without throwing', () => {
-		const { result } = renderHook(() =>
-			useBaseDrilldownNavigate({
-				resolvedQuery: MOCK_QUERY,
-				aggregateData: null,
-			}),
-		);
-
-		expect(() => result.current('view_logs')).not.toThrow();
-		expect(mockSafeNavigate).toHaveBeenCalledTimes(1);
-	});
-});

frontend/src/container/QueryTable/Drilldown/drilldownUtils.tsx

@@ -168,7 +168,7 @@ export const getAggregateColumnHeader = (
 	};
 };
 
-export const getFiltersFromMetric = (metric: any): FilterData[] =>
+const getFiltersFromMetric = (metric: any): FilterData[] =>
 	Object.keys(metric).map((key) => ({
 		filterKey: key,
 		filterValue: metric[key],

frontend/src/container/QueryTable/Drilldown/useBaseAggregateOptions.tsx

@@ -2,10 +2,14 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useLocation } from 'react-router-dom';
 import { Link, Loader } from '@signozhq/icons';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
+import { QueryParams } from 'constants/query';
 import { PANEL_TYPES } from 'constants/queryBuilder';
+import ROUTES from 'constants/routes';
 import useUpdatedQuery from 'container/GridCardLayout/useResolveQuery';
 import { processContextLinks } from 'container/NewWidget/RightContainer/ContextLinks/utils';
 import useContextVariables from 'hooks/dashboard/useContextVariables';
+import { useSafeNavigate } from 'hooks/useSafeNavigate';
+import createQueryParams from 'lib/createQueryParams';
 import ContextMenu from 'periscope/components/ContextMenu';
 import { useDashboardStore } from 'providers/Dashboard/store/useDashboardStore';
 import { ContextLinksData } from 'types/api/dashboard/getAll';
@@ -14,10 +18,9 @@ import { openInNewTab } from 'utils/navigation';
 
 import { ContextMenuItem } from './contextConfig';
 import { getDataLinks } from './dataLinksUtils';
-import { getAggregateColumnHeader } from './drilldownUtils';
+import { getAggregateColumnHeader, getViewQuery } from './drilldownUtils';
 import { getBaseContextConfig } from './menuOptions';
 import { AggregateData } from './useAggregateDrilldown';
-import useBaseDrilldownNavigate from './useBaseDrilldownNavigate';
 
 interface UseBaseAggregateOptionsProps {
 	query: Query;
@@ -35,6 +38,19 @@ interface BaseAggregateOptionsConfig {
 	items?: ContextMenuItem;
 }
 
+const getRoute = (key: string): string => {
+	switch (key) {
+		case 'view_logs':
+			return ROUTES.LOGS_EXPLORER;
+		case 'view_metrics':
+			return ROUTES.METRICS_EXPLORER;
+		case 'view_traces':
+			return ROUTES.TRACES_EXPLORER;
+		default:
+			return '';
+	}
+};
+
 const useBaseAggregateOptions = ({
 	query,
 	onClose,
@@ -70,6 +86,8 @@ const useBaseAggregateOptions = ({
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 	}, [query, aggregateData, panelType]);
 
+	const { safeNavigate } = useSafeNavigate();
+
 	// Use the new useContextVariables hook
 	const { processedVariables } = useContextVariables({
 		maxValues: 2,
@@ -103,16 +121,50 @@ const useBaseAggregateOptions = ({
 					{label}
 				</ContextMenu.Item>
 			));
-		} catch {
+		} catch (error) {
 			return [];
 		}
 	}, [contextLinks, processedVariables, onClose, aggregateData, query]);
 
-	const handleBaseDrilldown = useBaseDrilldownNavigate({
-		resolvedQuery,
-		aggregateData,
-		callback: onClose,
-	});
+	const handleBaseDrilldown = useCallback(
+		(key: string): void => {
+			const route = getRoute(key);
+			const timeRange = aggregateData?.timeRange;
+			const filtersToAdd = aggregateData?.filters || [];
+			const viewQuery = getViewQuery(
+				resolvedQuery,
+				filtersToAdd,
+				key,
+				aggregateData?.queryName || '',
+			);
+
+			let queryParams = {
+				[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
+				...(timeRange && {
+					[QueryParams.startTime]: timeRange?.startTime.toString(),
+					[QueryParams.endTime]: timeRange?.endTime.toString(),
+				}),
+			} as Record<string, string>;
+
+			if (route === ROUTES.METRICS_EXPLORER) {
+				queryParams = {
+					...queryParams,
+					[QueryParams.summaryFilters]: JSON.stringify(
+						viewQuery?.builder.queryData[0].filters,
+					),
+				};
+			}
+
+			if (route) {
+				safeNavigate(`${route}?${createQueryParams(queryParams)}`, {
+					newTab: true,
+				});
+			}
+
+			onClose();
+		},
+		[resolvedQuery, safeNavigate, onClose, aggregateData],
+	);
 
 	const { pathname } = useLocation();
 

frontend/src/container/QueryTable/Drilldown/useBaseDrilldownNavigate.ts

@@ -1,117 +0,0 @@
-import { useCallback } from 'react';
-import { QueryParams } from 'constants/query';
-import ROUTES from 'constants/routes';
-import { useSafeNavigate } from 'hooks/useSafeNavigate';
-import createQueryParams from 'lib/createQueryParams';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import { getViewQuery } from './drilldownUtils';
-import { AggregateData } from './useAggregateDrilldown';
-
-type DrilldownKey = 'view_logs' | 'view_metrics' | 'view_traces';
-
-const DRILLDOWN_ROUTE_MAP: Record<DrilldownKey, string> = {
-	view_logs: ROUTES.LOGS_EXPLORER,
-	view_metrics: ROUTES.METRICS_EXPLORER,
-	view_traces: ROUTES.TRACES_EXPLORER,
-};
-
-const getRoute = (key: string): string =>
-	DRILLDOWN_ROUTE_MAP[key as DrilldownKey] ?? '';
-
-interface UseBaseDrilldownNavigateProps {
-	resolvedQuery: Query;
-	aggregateData: AggregateData | null;
-	callback?: () => void;
-}
-
-const useBaseDrilldownNavigate = ({
-	resolvedQuery,
-	aggregateData,
-	callback,
-}: UseBaseDrilldownNavigateProps): ((key: string) => void) => {
-	const { safeNavigate } = useSafeNavigate();
-
-	return useCallback(
-		(key: string): void => {
-			const route = getRoute(key);
-			const viewQuery = getViewQuery(
-				resolvedQuery,
-				aggregateData?.filters ?? [],
-				key,
-				aggregateData?.queryName ?? '',
-			);
-
-			if (!viewQuery || !route) {
-				callback?.();
-				return;
-			}
-
-			const timeRange = aggregateData?.timeRange;
-			let queryParams: Record<string, string> = {
-				[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
-				...(timeRange && {
-					[QueryParams.startTime]: timeRange.startTime.toString(),
-					[QueryParams.endTime]: timeRange.endTime.toString(),
-				}),
-			};
-
-			if (route === ROUTES.METRICS_EXPLORER) {
-				queryParams = {
-					...queryParams,
-					[QueryParams.summaryFilters]: JSON.stringify(
-						viewQuery.builder.queryData[0].filters,
-					),
-				};
-			}
-
-			safeNavigate(`${route}?${createQueryParams(queryParams)}`, {
-				newTab: true,
-			});
-
-			callback?.();
-		},
-		[resolvedQuery, safeNavigate, callback, aggregateData],
-	);
-};
-
-export function buildDrilldownUrl(
-	resolvedQuery: Query,
-	aggregateData: AggregateData | null,
-	key: string,
-): string | null {
-	const route = getRoute(key);
-	const viewQuery = getViewQuery(
-		resolvedQuery,
-		aggregateData?.filters ?? [],
-		key,
-		aggregateData?.queryName ?? '',
-	);
-
-	if (!viewQuery || !route) {
-		return null;
-	}
-
-	const timeRange = aggregateData?.timeRange;
-	let queryParams: Record<string, string> = {
-		[QueryParams.compositeQuery]: encodeURIComponent(JSON.stringify(viewQuery)),
-		...(timeRange && {
-			[QueryParams.startTime]: timeRange.startTime.toString(),
-			[QueryParams.endTime]: timeRange.endTime.toString(),
-		}),
-	};
-
-	if (route === ROUTES.METRICS_EXPLORER) {
-		queryParams = {
-			...queryParams,
-			[QueryParams.summaryFilters]: JSON.stringify(
-				viewQuery.builder.queryData[0].filters,
-			),
-		};
-	}
-
-	return `${route}?${createQueryParams(queryParams)}`;
-}
-
-export { getRoute };
-export default useBaseDrilldownNavigate;

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/__tests__/syncCursorRegistry.test.ts

@@ -1,29 +0,0 @@
-import { syncCursorRegistry } from '../syncCursorRegistry';
-
-describe('syncCursorRegistry', () => {
-	describe('metadata', () => {
-		it('returns undefined for unknown key', () => {
-			expect(syncCursorRegistry.getMetadata('unknown-meta')).toBeUndefined();
-		});
-
-		it('stores and retrieves metadata by syncKey', () => {
-			const metadata = { yAxisUnit: 'ms', groupBy: [] };
-			syncCursorRegistry.setMetadata('meta-key', metadata);
-			expect(syncCursorRegistry.getMetadata('meta-key')).toBe(metadata);
-		});
-	});
-
-	describe('activeSeriesMetric', () => {
-		it('returns null (not undefined) for unknown key', () => {
-			expect(
-				syncCursorRegistry.getActiveSeriesMetric('unknown-metric'),
-			).toBeNull();
-		});
-
-		it('stores and retrieves metric by syncKey', () => {
-			const metric = { host: 'server1', __name__: 'cpu' };
-			syncCursorRegistry.setActiveSeriesMetric('metric-key', metric);
-			expect(syncCursorRegistry.getActiveSeriesMetric('metric-key')).toBe(metric);
-		});
-	});
-});

frontend/src/lib/uPlotV2/plugins/TooltipPlugin/__tests__/syncDisplayHook.test.ts

@@ -1,627 +0,0 @@
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import uPlot from 'uplot';
-
-import { syncCursorRegistry } from '../syncCursorRegistry';
-import { createSyncDisplayHook } from '../syncDisplayHook';
-import {
-	SyncTooltipFilterMode,
-	type TooltipControllerState,
-	type TooltipSyncMetadata,
-} from '../types';
-
-jest.mock('../syncCursorRegistry', () => ({
-	syncCursorRegistry: {
-		setMetadata: jest.fn(),
-		getMetadata: jest.fn(),
-		setActiveSeriesMetric: jest.fn(),
-		getActiveSeriesMetric: jest.fn(),
-	},
-}));
-
-const mockRegistry = syncCursorRegistry as {
-	setMetadata: jest.Mock;
-	getMetadata: jest.Mock;
-	setActiveSeriesMetric: jest.Mock;
-	getActiveSeriesMetric: jest.Mock;
-};
-
-const SYNC_KEY = 'test-sync-key';
-
-// Builds a single-query groupByPerQuery from a list of dimension keys.
-const makeGroupByPerQuery = (
-	...keys: string[]
-): Record<string, BaseAutocompleteData[]> => ({
-	A: keys.map((key) => ({ key, type: 'tag' as const })),
-});
-
-function makeUPlotRoot(includeCrosshair = true): HTMLElement {
-	const root = document.createElement('div');
-	if (includeCrosshair) {
-		const el = document.createElement('div');
-		el.className = 'u-cursor-y';
-		root.append(el);
-	}
-	return root;
-}
-
-type FakeSeries = { metric?: Record<string, string>; show?: boolean };
-
-function makeFakeUPlot(opts: {
-	cursorEvent?: MouseEvent | null;
-	cursorLeft?: number;
-	series?: FakeSeries[];
-	includeCrosshair?: boolean;
-}): uPlot {
-	return {
-		root: makeUPlotRoot(opts.includeCrosshair ?? true),
-		cursor: {
-			event: opts.cursorEvent !== undefined ? opts.cursorEvent : null,
-			left: opts.cursorLeft ?? 50,
-		},
-		series: opts.series ?? [
-			{},
-			{ metric: { host: 'server1' } },
-			{ metric: { host: 'server2' } },
-		],
-		setSeries: jest.fn(),
-	} as unknown as uPlot;
-}
-
-function makeController(
-	focusedSeriesIndex: number | null = null,
-): TooltipControllerState {
-	return {
-		focusedSeriesIndex,
-		syncedSeriesIndexes: null,
-	} as TooltipControllerState;
-}
-
-// Convenience cast used throughout assertions.
-function mockSetSeries(u: uPlot): jest.Mock {
-	return (u as unknown as { setSeries: jest.Mock }).setSeries;
-}
-
-function getCrosshair(u: uPlot): HTMLElement {
-	const el = u.root.querySelector<HTMLElement>('.u-cursor-y');
-	if (!el) {
-		throw new Error('crosshair element missing');
-	}
-	return el;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('createSyncDisplayHook', () => {
-	beforeEach(() => {
-		jest.clearAllMocks();
-	});
-
-	// ── guard ────────────────────────────────────────────────────────────────
-
-	describe('no crosshair element', () => {
-		it('returns early without calling registry when .u-cursor-y absent', () => {
-			const hook = createSyncDisplayHook(SYNC_KEY, undefined, makeController());
-			const u = makeFakeUPlot({ includeCrosshair: false });
-			hook(u);
-			expect(mockRegistry.setMetadata).not.toHaveBeenCalled();
-			expect(mockRegistry.getMetadata).not.toHaveBeenCalled();
-			expect(mockSetSeries(u)).not.toHaveBeenCalled();
-		});
-	});
-
-	// ── source panel ─────────────────────────────────────────────────────────
-
-	describe('source behavior (cursor.event != null)', () => {
-		it('writes syncMetadata to registry', () => {
-			const syncMetadata: TooltipSyncMetadata = { yAxisUnit: 'ms' };
-			const hook = createSyncDisplayHook(SYNC_KEY, syncMetadata, makeController());
-			const u = makeFakeUPlot({ cursorEvent: new MouseEvent('mousemove') });
-			hook(u);
-			expect(mockRegistry.setMetadata).toHaveBeenCalledWith(
-				SYNC_KEY,
-				syncMetadata,
-			);
-		});
-
-		it('writes focused series metric when focusedSeriesIndex is set', () => {
-			const series: FakeSeries[] = [
-				{},
-				{ metric: { host: 'server1' } },
-				{ metric: { host: 'server2' } },
-			];
-			const hook = createSyncDisplayHook(SYNC_KEY, undefined, makeController(1));
-			const u = makeFakeUPlot({
-				cursorEvent: new MouseEvent('mousemove'),
-				series,
-			});
-			hook(u);
-			expect(mockRegistry.setActiveSeriesMetric).toHaveBeenCalledWith(SYNC_KEY, {
-				host: 'server1',
-			});
-		});
-
-		it('writes null metric when focusedSeriesIndex is null', () => {
-			const hook = createSyncDisplayHook(
-				SYNC_KEY,
-				undefined,
-				makeController(null),
-			);
-			const u = makeFakeUPlot({ cursorEvent: new MouseEvent('mousemove') });
-			hook(u);
-			expect(mockRegistry.setActiveSeriesMetric).toHaveBeenCalledWith(
-				SYNC_KEY,
-				null,
-			);
-		});
-
-		it('clears controller.syncedSeriesIndexes', () => {
-			const controller = makeController();
-			controller.syncedSeriesIndexes = [1, 2];
-			const hook = createSyncDisplayHook(SYNC_KEY, undefined, controller);
-			const u = makeFakeUPlot({ cursorEvent: new MouseEvent('mousemove') });
-			hook(u);
-			expect(controller.syncedSeriesIndexes).toBeNull();
-		});
-
-		it('shows crosshair and does not read from registry', () => {
-			const hook = createSyncDisplayHook(SYNC_KEY, undefined, makeController());
-			const u = makeFakeUPlot({ cursorEvent: new MouseEvent('mousemove') });
-			hook(u);
-			expect(getCrosshair(u).style.display).toBe('');
-			expect(mockRegistry.getMetadata).not.toHaveBeenCalled();
-		});
-	});
-
-	// ── receiver panel ───────────────────────────────────────────────────────
-
-	describe('receiver behavior (cursor.event is null)', () => {
-		describe('crosshair visibility', () => {
-			it('shows crosshair when yAxisUnit matches source', () => {
-				mockRegistry.getMetadata.mockReturnValue({ yAxisUnit: 'ms' });
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(null);
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms' },
-					makeController(),
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(getCrosshair(u).style.display).toBe('');
-			});
-
-			it('hides crosshair when yAxisUnit differs from source', () => {
-				mockRegistry.getMetadata.mockReturnValue({ yAxisUnit: 'bytes' });
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(null);
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms' },
-					makeController(),
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(getCrosshair(u).style.display).toBe('none');
-			});
-		});
-
-		// ── exact groupBy match ───────────────────────────────────────────────
-
-		describe('exact groupBy match', () => {
-			const groupByPerQuery = makeGroupByPerQuery('host');
-			const series: FakeSeries[] = [
-				{},
-				{ metric: { host: 'server1' } },
-				{ metric: { host: 'server2' } },
-			];
-
-			it('focuses the matching series and records it on the controller', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server2' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(2, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([2]);
-			});
-
-			it('unfocuses all and emits empty matches (Filtered) when active metric is null', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(null);
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(null, { focus: false });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('unfocuses all when metric matches no series', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({
-					host: 'unknown-server',
-				});
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(null, { focus: false });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('clears syncedSeriesIndexes when cursor is off-plot (left < 0)', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: -1, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(null, { focus: false });
-				expect(controller.syncedSeriesIndexes).toBeNull();
-				expect(mockRegistry.getActiveSeriesMetric).not.toHaveBeenCalled();
-			});
-
-			it('never focuses series at index 0 (x-axis)', () => {
-				const sameMetric = { host: 'server1' };
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(sameMetric);
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({
-					cursorEvent: null,
-					cursorLeft: 50,
-					// Index 0 has the same metric — it must always be skipped.
-					series: [{ metric: sameMetric }, { metric: { host: 'other' } }],
-				});
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(null, { focus: false });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('skips hidden series (show === false)', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery },
-					controller,
-				);
-				const u = makeFakeUPlot({
-					cursorEvent: null,
-					cursorLeft: 50,
-					series: [
-						{},
-						{ metric: { host: 'server1' }, show: false },
-						{ metric: { host: 'server1' } },
-					],
-				});
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(2, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([2]);
-			});
-		});
-
-		// ── partial groupBy overlap ───────────────────────────────────────────
-
-		describe('partial groupBy overlap', () => {
-			it('subset — records every receiver series matching on the common key', () => {
-				// Source groupBy=[host], receiver groupBy=[host, service].
-				// Hook focuses the first match; the rest are surfaced via controller.syncedSeriesIndexes.
-				const sourceGroupBy = makeGroupByPerQuery('host');
-				const receiverGroupBy = makeGroupByPerQuery('host', 'service');
-				const series: FakeSeries[] = [
-					{},
-					{ metric: { host: 'server1', service: 'api' } },
-					{ metric: { host: 'server1', service: 'frontend' } },
-					{ metric: { host: 'server2', service: 'api' } },
-				];
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: sourceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: receiverGroupBy },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(1, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([1, 2]);
-			});
-
-			it('superset — records the one receiver series matching on the common key', () => {
-				// Source groupBy=[host, service], receiver groupBy=[host].
-				const sourceGroupBy = makeGroupByPerQuery('host', 'service');
-				const receiverGroupBy = makeGroupByPerQuery('host');
-				const series: FakeSeries[] = [
-					{},
-					{ metric: { host: 'server1' } },
-					{ metric: { host: 'server2' } },
-				];
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: sourceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({
-					host: 'server1',
-					service: 'api',
-				});
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: receiverGroupBy },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(1, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([1]);
-			});
-
-			it('partial — matches on the intersecting key only', () => {
-				// Source groupBy=[host, service], receiver groupBy=[service, region].
-				// Common key is [service]. Both receiver series with service=api match.
-				const sourceGroupBy = makeGroupByPerQuery('host', 'service');
-				const receiverGroupBy = makeGroupByPerQuery('service', 'region');
-				const series: FakeSeries[] = [
-					{},
-					{ metric: { service: 'api', region: 'us-east' } },
-					{ metric: { service: 'api', region: 'eu-west' } },
-					{ metric: { service: 'frontend', region: 'us-east' } },
-				];
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: sourceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({
-					host: 'server1',
-					service: 'api',
-				});
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: receiverGroupBy },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(1, { focus: true });
-				expect(controller.syncedSeriesIndexes).toStrictEqual([1, 2]);
-			});
-		});
-
-		// ── union across queries in groupByPerQuery ───────────────────────────
-
-		describe('union across queries', () => {
-			it("treats the panel's effective groupBy as the union across its queries", () => {
-				// Source has query A=[host]; receiver has A=[host], B=[service].
-				// The shared key is `host` — receiver matches on that.
-				const sourceGroupBy: Record<string, BaseAutocompleteData[]> = {
-					A: [{ key: 'host', type: 'tag' }],
-				};
-				const receiverGroupBy: Record<string, BaseAutocompleteData[]> = {
-					A: [{ key: 'host', type: 'tag' }],
-					B: [{ key: 'service', type: 'tag' }],
-				};
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: sourceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: receiverGroupBy },
-					controller,
-				);
-				const u = makeFakeUPlot({
-					cursorEvent: null,
-					cursorLeft: 50,
-					series: [
-						{},
-						{ metric: { host: 'server1' } },
-						{ metric: { host: 'server2' } },
-					],
-				});
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toStrictEqual([1]);
-			});
-		});
-
-		// ── no overlap (Filtered mode default) ────────────────────────────────
-
-		describe('no overlap → Filtered mode emits []', () => {
-			it('emits [] when groupBy keys are completely different', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: makeGroupByPerQuery('host'),
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: makeGroupByPerQuery('service') },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('emits [] when receiver groupBy is empty', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: makeGroupByPerQuery('host'),
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: {} },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-
-			it('emits [] when source groupBy is absent', () => {
-				mockRegistry.getMetadata.mockReturnValue({ yAxisUnit: 'ms' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms', groupByPerQuery: makeGroupByPerQuery('host') },
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toStrictEqual([]);
-			});
-		});
-
-		// ── filterMode: All ──────────────────────────────────────────────────
-
-		describe('filterMode All', () => {
-			it('emits null (no filter) when there is no overlap in groupBy', () => {
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery: makeGroupByPerQuery('host'),
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{
-						yAxisUnit: 'ms',
-						groupByPerQuery: makeGroupByPerQuery('service'),
-						filterMode: SyncTooltipFilterMode.All,
-					},
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toBeNull();
-			});
-
-			it('emits null when metric matches no series', () => {
-				const groupByPerQuery = makeGroupByPerQuery('host');
-				mockRegistry.getMetadata.mockReturnValue({
-					yAxisUnit: 'ms',
-					groupByPerQuery,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'unknown' });
-				const controller = makeController();
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{
-						yAxisUnit: 'ms',
-						groupByPerQuery,
-						filterMode: SyncTooltipFilterMode.All,
-					},
-					controller,
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50 });
-				hook(u);
-				expect(controller.syncedSeriesIndexes).toBeNull();
-			});
-		});
-
-		// ── caching ───────────────────────────────────────────────────────────
-
-		describe('caching optimizations', () => {
-			it('reuses the crosshair element across multiple invocations', () => {
-				mockRegistry.getMetadata.mockReturnValue({ yAxisUnit: 'ms' });
-				mockRegistry.getActiveSeriesMetric.mockReturnValue(null);
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ yAxisUnit: 'ms' },
-					makeController(),
-				);
-				const u = makeFakeUPlot({ cursorEvent: null });
-				const spy = jest.spyOn(u.root, 'querySelector');
-				hook(u);
-				hook(u);
-				hook(u);
-				// querySelector should only be called once regardless of invocation count.
-				expect(spy).toHaveBeenCalledTimes(1);
-			});
-
-			it('recomputes common keys when source groupByPerQuery reference changes', () => {
-				const hostGroupBy = makeGroupByPerQuery('host');
-				const serviceGroupBy = makeGroupByPerQuery('service');
-				const series: FakeSeries[] = [
-					{},
-					{ metric: { host: 'server1', service: 'api' } },
-					{ metric: { host: 'server2', service: 'frontend' } },
-				];
-				const hook = createSyncDisplayHook(
-					SYNC_KEY,
-					{ groupByPerQuery: makeGroupByPerQuery('host', 'service') },
-					makeController(),
-				);
-				const u = makeFakeUPlot({ cursorEvent: null, cursorLeft: 50, series });
-
-				// First call: source groups by host → matches series 1.
-				mockRegistry.getMetadata.mockReturnValue({
-					groupByPerQuery: hostGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({ host: 'server1' });
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(1, { focus: true });
-
-				jest.clearAllMocks();
-
-				// Second call: source now groups by service → matches series 2.
-				mockRegistry.getMetadata.mockReturnValue({
-					groupByPerQuery: serviceGroupBy,
-				});
-				mockRegistry.getActiveSeriesMetric.mockReturnValue({
-					service: 'frontend',
-				});
-				hook(u);
-				expect(mockSetSeries(u)).toHaveBeenCalledWith(2, { focus: true });
-			});
-		});
-	});
-});

go.mod

@@ -89,7 +89,6 @@ require (
 	gonum.org/v1/gonum v0.17.0
 	google.golang.org/api v0.272.0
 	google.golang.org/protobuf v1.36.11
-	gopkg.in/evanphx/json-patch.v4 v4.13.0
 	gopkg.in/yaml.v2 v2.4.0
 	gopkg.in/yaml.v3 v3.0.1
 	k8s.io/apimachinery v0.35.3

pkg/apiserver/signozapiserver/dashboard.go

@@ -14,254 +14,6 @@ import (
 )
 
 func (provider *provider) addDashboardRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v2/dashboards", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.ListV2), handler.OpenAPIDef{
-		ID:                  "ListDashboardsV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "List dashboards (v2)",
-		Description:         "Returns a page of v2-shape dashboards for the calling user's org. Supports a filter DSL (`query`), sort (`updated_at`/`created_at`/`title`), order (`asc`/`desc`), and offset-based pagination (`limit`/`offset`). Pinned dashboards float to the top of each page.",
-		Request:             new(dashboardtypes.ListDashboardsV2Params),
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.ListableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.CreateV2), handler.OpenAPIDef{
-		ID:                  "CreateDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Create dashboard (v2)",
-		Description:         "This endpoint creates a dashboard in the v2 format that follows Perses spec.",
-		Request:             new(dashboardtypes.PostableDashboardV2),
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.GettableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusCreated,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	// Saved-view routes are registered before `/api/v2/dashboards/{id}` so the
-	// literal `views` segment isn't swallowed by the `{id}` pattern.
-	if err := router.Handle("/api/v2/dashboards/views", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.ListViews), handler.OpenAPIDef{
-		ID:                  "ListDashboardViews",
-		Tags:                []string{"dashboard"},
-		Summary:             "List dashboard saved views",
-		Description:         "Returns every saved view in the calling user's org. Saved views are shared org-wide; any user may read, create, edit, and delete any view.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            new(dashboardtypes.ListableDashboardView),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/views", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.CreateView), handler.OpenAPIDef{
-		ID:                  "CreateDashboardView",
-		Tags:                []string{"dashboard"},
-		Summary:             "Create dashboard saved view",
-		Description:         "Persists the calling user's dashboard listing state (query, sort, order) as a named, reusable view shared across the org.",
-		Request:             new(dashboardtypes.PostableDashboardView),
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.GettableDashboardView),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusCreated,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/views/{id}", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.UpdateView), handler.OpenAPIDef{
-		ID:                  "UpdateDashboardView",
-		Tags:                []string{"dashboard"},
-		Summary:             "Update dashboard saved view",
-		Description:         "Replaces a saved view's name and data. Saved views are shared org-wide; any user in the org may edit any view.",
-		Request:             new(dashboardtypes.UpdateableDashboardView),
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.GettableDashboardView),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/views/{id}", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.DeleteView), handler.OpenAPIDef{
-		ID:                  "DeleteDashboardView",
-		Tags:                []string{"dashboard"},
-		Summary:             "Delete dashboard saved view",
-		Description:         "Removes a saved view. Saved views are shared org-wide; any user in the org may delete any view. Idempotent — deleting a non-existent view returns 404.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.GetV2), handler.OpenAPIDef{
-		ID:                  "GetDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Get dashboard (v2)",
-		Description:         "This endpoint returns a v2-shape dashboard.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            new(dashboardtypes.GettableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.UpdateV2), handler.OpenAPIDef{
-		ID:                  "UpdateDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Update dashboard (v2)",
-		Description:         "This endpoint updates a v2-shape dashboard's metadata, data, and tag set. Locked dashboards are rejected.",
-		Request:             new(dashboardtypes.UpdateableDashboardV2),
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.GettableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.PatchV2), handler.OpenAPIDef{
-		ID:          "PatchDashboardV2",
-		Tags:        []string{"dashboard"},
-		Summary:     "Patch dashboard (v2)",
-		Description: "This endpoint applies an RFC 6902 JSON Patch to a v2-shape dashboard. The patch is applied against the postable view of the dashboard (metadata, data, tags), so individual panels, queries, variables, layouts, or tags can be updated without re-sending the rest of the dashboard. Locked dashboards are rejected.",
-		Request:     new(dashboardtypes.JSONPatchDocument),
-		// Strictly per RFC 6902 the content type is `application/json-patch+json`,
-		// but our OpenAPI generator only reflects schemas for content types it
-		// understands (application/json, form-urlencoded, multipart) — anything
-		// else degrades to `type: string`. Declaring application/json here keeps
-		// the array-of-ops schema visible to spec consumers; the runtime decoder
-		// parses JSON regardless of the request's actual Content-Type header.
-		RequestContentType:  "application/json",
-		Response:            new(dashboardtypes.GettableDashboardV2),
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusOK,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodPatch).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.DeleteV2), handler.OpenAPIDef{
-		ID:                  "DeleteDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Delete dashboard (v2)",
-		Description:         "This endpoint deletes a v2-shape dashboard along with its tag relations. Locked dashboards are rejected.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}/lock", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.LockV2), handler.OpenAPIDef{
-		ID:                  "LockDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Lock dashboard (v2)",
-		Description:         "This endpoint locks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}/lock", handler.New(provider.authzMiddleware.EditAccess(provider.dashboardHandler.UnlockV2), handler.OpenAPIDef{
-		ID:                  "UnlockDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Unlock dashboard (v2)",
-		Description:         "This endpoint unlocks a v2-shape dashboard. Only the dashboard's creator or an org admin may lock or unlock.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleEditor),
-	})).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
-	// ViewAccess: pinning only mutates the calling user's pin list, not the
-	// dashboard itself — anyone who can view a dashboard can bookmark it.
-	if err := router.Handle("/api/v2/dashboards/{id}/pins/me", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.PinV2), handler.OpenAPIDef{
-		ID:                  "PinDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Pin a dashboard for the current user (v2)",
-		Description:         "Pins the dashboard for the calling user. A user can pin at most 10 dashboards; pinning when at the limit returns 409. Re-pinning an already-pinned dashboard is a no-op success.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodPut).GetError(); err != nil {
-		return err
-	}
-
-	if err := router.Handle("/api/v2/dashboards/{id}/pins/me", handler.New(provider.authzMiddleware.ViewAccess(provider.dashboardHandler.UnpinV2), handler.OpenAPIDef{
-		ID:                  "UnpinDashboardV2",
-		Tags:                []string{"dashboard"},
-		Summary:             "Unpin a dashboard for the current user (v2)",
-		Description:         "Removes the pin for the calling user. Idempotent — unpinning a dashboard that wasn't pinned still returns 204.",
-		Request:             nil,
-		RequestContentType:  "",
-		Response:            nil,
-		ResponseContentType: "application/json",
-		SuccessStatusCode:   http.StatusNoContent,
-		ErrorStatusCodes:    []int{},
-		Deprecated:          false,
-		SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-	})).Methods(http.MethodDelete).GetError(); err != nil {
-		return err
-	}
-
 	if err := router.Handle("/api/v1/dashboards/{id}/public", handler.New(provider.authzMiddleware.AdminAccess(provider.dashboardHandler.CreatePublic), handler.OpenAPIDef{
 		ID:                  "CreatePublicDashboard",
 		Tags:                []string{"dashboard"},

pkg/modules/dashboard/dashboard.go

@@ -52,36 +52,6 @@ type Module interface {
 	GetByMetricNames(ctx context.Context, orgID valuer.UUID, metricNames []string) (map[string][]map[string]string, error)
 
 	statsreporter.StatsCollector
-
-	// ════════════════════════════════════════════════════════════════════════
-	// v2 dashboard methods
-	// ════════════════════════════════════════════════════════════════════════
-
-	CreateV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, source dashboardtypes.Source, postable dashboardtypes.PostableDashboardV2) (*dashboardtypes.DashboardV2, error)
-
-	GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error)
-
-	ListV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardV2, error)
-
-	UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardV2) (*dashboardtypes.DashboardV2, error)
-
-	LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error
-
-	PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error)
-
-	PinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error
-
-	UnpinV2(ctx context.Context, userID valuer.UUID, id valuer.UUID) error
-
-	DeleteV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
-
-	CreateView(ctx context.Context, orgID valuer.UUID, createdBy string, postable dashboardtypes.PostableDashboardView) (*dashboardtypes.DashboardView, error)
-
-	ListViews(ctx context.Context, orgID valuer.UUID) (*dashboardtypes.ListableDashboardView, error)
-
-	UpdateView(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardView) (*dashboardtypes.DashboardView, error)
-
-	DeleteView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
 }
 
 type Handler interface {
@@ -104,35 +74,4 @@ type Handler interface {
 	LockUnlock(http.ResponseWriter, *http.Request)
 
 	Delete(http.ResponseWriter, *http.Request)
-
-	// ════════════════════════════════════════════════════════════════════════
-	// v2 dashboard methods
-	// ════════════════════════════════════════════════════════════════════════
-	CreateV2(http.ResponseWriter, *http.Request)
-
-	GetV2(http.ResponseWriter, *http.Request)
-
-	ListV2(http.ResponseWriter, *http.Request)
-
-	UpdateV2(http.ResponseWriter, *http.Request)
-
-	LockV2(http.ResponseWriter, *http.Request)
-
-	UnlockV2(http.ResponseWriter, *http.Request)
-
-	PatchV2(http.ResponseWriter, *http.Request)
-
-	PinV2(http.ResponseWriter, *http.Request)
-
-	UnpinV2(http.ResponseWriter, *http.Request)
-
-	DeleteV2(http.ResponseWriter, *http.Request)
-
-	CreateView(http.ResponseWriter, *http.Request)
-
-	ListViews(http.ResponseWriter, *http.Request)
-
-	UpdateView(http.ResponseWriter, *http.Request)
-
-	DeleteView(http.ResponseWriter, *http.Request)
 }

pkg/modules/dashboard/impldashboard/module.go

@@ -10,7 +10,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/factory"
 	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/coretypes"
@@ -25,10 +24,9 @@ type module struct {
 	analytics   analytics.Analytics
 	orgGetter   organization.Getter
 	queryParser queryparser.QueryParser
-	tagModule   tag.Module
 }
 
-func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser, tagModule tag.Module) dashboard.Module {
+func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, analytics analytics.Analytics, orgGetter organization.Getter, queryParser queryparser.QueryParser) dashboard.Module {
 	scopedProviderSettings := factory.NewScopedProviderSettings(settings, "github.com/SigNoz/signoz/pkg/modules/dashboard/impldashboard")
 	return &module{
 		store:       store,
@@ -36,7 +34,6 @@ func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, an
 		analytics:   analytics,
 		orgGetter:   orgGetter,
 		queryParser: queryParser,
-		tagModule:   tagModule,
 	}
 }
 

pkg/modules/dashboard/impldashboard/store.go

@@ -2,14 +2,10 @@ package impldashboard
 
 import (
 	"context"
-	"strings"
-	"time"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes/listfilter"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/uptrace/bun"
 )
@@ -67,206 +63,6 @@ func (store *store) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID)
 	return storableDashboard, nil
 }
 
-func (store *store) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.StorableDashboard, *dashboardtypes.StorablePublicDashboard, error) {
-	type joinedRow struct {
-		*dashboardtypes.StorableDashboard `bun:",extend"`
-
-		PublicID               *valuer.UUID `bun:"public_id"`
-		PublicCreatedAt        *time.Time   `bun:"public_created_at"`
-		PublicUpdatedAt        *time.Time   `bun:"public_updated_at"`
-		PublicTimeRangeEnabled *bool        `bun:"public_time_range_enabled"`
-		PublicDefaultTimeRange *string      `bun:"public_default_time_range"`
-	}
-
-	row := &joinedRow{StorableDashboard: new(dashboardtypes.StorableDashboard)}
-	err := store.
-		sqlstore.
-		BunDB().
-		NewSelect().
-		Model(row).
-		ColumnExpr("dashboard.id, dashboard.org_id, dashboard.data, dashboard.locked, dashboard.created_at, dashboard.created_by, dashboard.updated_at, dashboard.updated_by").
-		ColumnExpr("pd.id AS public_id, pd.created_at AS public_created_at, pd.updated_at AS public_updated_at, pd.time_range_enabled AS public_time_range_enabled, pd.default_time_range AS public_default_time_range").
-		Join("LEFT JOIN public_dashboard AS pd ON pd.dashboard_id = dashboard.id").
-		Where("dashboard.id = ?", id).
-		Where("dashboard.org_id = ?", orgID).
-		Scan(ctx)
-	if err != nil {
-		return nil, nil, store.sqlstore.WrapNotFoundErrf(err, dashboardtypes.ErrCodeDashboardNotFound, "dashboard with id %s doesn't exist", id)
-	}
-
-	if row.PublicID == nil {
-		return row.StorableDashboard, nil, nil
-	}
-	public := &dashboardtypes.StorablePublicDashboard{
-		Identifiable:     types.Identifiable{ID: *row.PublicID},
-		TimeAuditable:    types.TimeAuditable{CreatedAt: *row.PublicCreatedAt, UpdatedAt: *row.PublicUpdatedAt},
-		TimeRangeEnabled: *row.PublicTimeRangeEnabled,
-		DefaultTimeRange: *row.PublicDefaultTimeRange,
-		DashboardID:      row.ID.StringValue(),
-	}
-	return row.StorableDashboard, public, nil
-}
-
-// ListV2 emits the joined dashboard ⨝ pinned_dashboard ⨝ public_dashboard
-// query the spec calls for. Aliases:
-//
-//	dashboard         — the visitor expects this
-//	pinned_dashboard  AS pin  — only used inside this query
-//	public_dashboard  AS pd   — the visitor expects this
-//
-// Sort is "is_pinned DESC, <sort> <order>" so pinned dashboards float to the
-// top inside the requested ordering. Title-sort goes through the same
-// JSONExtractString path the visitor uses for name/description filtering.
-func (store *store) ListV2(
-	ctx context.Context,
-	orgID valuer.UUID,
-	userID valuer.UUID,
-	params *dashboardtypes.ListDashboardsV2Params,
-) ([]*dashboardtypes.DashboardListRow, int64, error) {
-	compiled, err := listfilter.Compile(params.Query, store.sqlstore.Formatter())
-	if err != nil {
-		return nil, 0, err
-	}
-	type listedRow struct {
-		*dashboardtypes.StorableDashboard `bun:",extend"`
-
-		IsPinned bool  `bun:"is_pinned"`
-		Total    int64 `bun:"total"`
-
-		PublicID               *valuer.UUID `bun:"public_id"`
-		PublicCreatedAt        *time.Time   `bun:"public_created_at"`
-		PublicUpdatedAt        *time.Time   `bun:"public_updated_at"`
-		PublicTimeRangeEnabled *bool        `bun:"public_time_range_enabled"`
-		PublicDefaultTimeRange *string      `bun:"public_default_time_range"`
-	}
-
-	rows := make([]*listedRow, 0)
-
-	q := store.sqlstore.
-		BunDB().
-		NewSelect().
-		Model(&rows).
-		ColumnExpr("dashboard.id, dashboard.org_id, dashboard.data, dashboard.locked, dashboard.source, dashboard.created_at, dashboard.created_by, dashboard.updated_at, dashboard.updated_by").
-		ColumnExpr("CASE WHEN pin.user_id IS NOT NULL THEN 1 ELSE 0 END AS is_pinned").
-		ColumnExpr("COUNT(*) OVER () AS total").
-		ColumnExpr("pd.id AS public_id, pd.created_at AS public_created_at, pd.updated_at AS public_updated_at, pd.time_range_enabled AS public_time_range_enabled, pd.default_time_range AS public_default_time_range").
-		Join("LEFT JOIN pinned_dashboard AS pin ON pin.user_id = ? AND pin.dashboard_id = dashboard.id", userID).
-		Join("LEFT JOIN public_dashboard AS pd ON pd.dashboard_id = dashboard.id").
-		Where("dashboard.org_id = ?", orgID).
-		Where("dashboard.source != ?", dashboardtypes.SourceSystem)
-
-	if compiled != nil {
-		q = q.Where(compiled.SQL, compiled.Args...)
-	}
-
-	sortExpr, err := store.sortExprForListV2(params.Sort)
-	if err != nil {
-		return nil, 0, err
-	}
-	q = q.
-		OrderExpr("is_pinned DESC").
-		OrderExpr(sortExpr + " " + strings.ToUpper(string(params.Order))).
-		Limit(params.Limit).
-		Offset(params.Offset)
-
-	if err := q.Scan(ctx); err != nil {
-		return nil, 0, err
-	}
-
-	// COUNT(*) OVER () is computed pre-LIMIT, so any returned row carries the
-	// full filter total. Empty result page => zero matches.
-	var total int64
-	if len(rows) > 0 {
-		total = rows[0].Total
-	}
-
-	out := make([]*dashboardtypes.DashboardListRow, len(rows))
-	for i, r := range rows {
-		row := &dashboardtypes.DashboardListRow{
-			Dashboard: r.StorableDashboard,
-			Pinned:    r.IsPinned,
-		}
-		if r.PublicID != nil {
-			row.Public = &dashboardtypes.StorablePublicDashboard{
-				Identifiable:     types.Identifiable{ID: *r.PublicID},
-				TimeAuditable:    types.TimeAuditable{CreatedAt: *r.PublicCreatedAt, UpdatedAt: *r.PublicUpdatedAt},
-				TimeRangeEnabled: *r.PublicTimeRangeEnabled,
-				DefaultTimeRange: *r.PublicDefaultTimeRange,
-				DashboardID:      r.ID.StringValue(),
-			}
-		}
-		out[i] = row
-	}
-	return out, total, nil
-}
-
-// sortExprForListV2 maps a sort enum to the SQL expression to plug into
-// ORDER BY. Title-sort routes through the SQLFormatter so it stays
-// dialect-aware (matches what listfilter/visitor does for the name filter).
-func (store *store) sortExprForListV2(sort dashboardtypes.ListSort) (string, error) {
-	switch sort {
-	case dashboardtypes.ListSortUpdatedAt:
-		return "dashboard.updated_at", nil
-	case dashboardtypes.ListSortCreatedAt:
-		return "dashboard.created_at", nil
-	case dashboardtypes.ListSortName:
-		return string(store.sqlstore.Formatter().JSONExtractString("dashboard.data", "$.data.display.name")), nil
-	}
-	return "", errors.Newf(errors.TypeInvalidInput, dashboardtypes.ErrCodeDashboardListInvalid,
-		"unsupported sort field %q", sort)
-}
-
-func (store *store) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, data dashboardtypes.StorableDashboardData) error {
-	res, err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewUpdate().
-		Model((*dashboardtypes.StorableDashboard)(nil)).
-		Set("data = ?", data).
-		Set("updated_by = ?", updatedBy).
-		Set("updated_at = ?", time.Now()).
-		Where("id = ?", id).
-		Where("org_id = ?", orgID).
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-	rows, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	// Defends against the race where a delete lands between the caller's
-	// pre-update GetV2 and this update.
-	if rows == 0 {
-		return errors.Newf(errors.TypeNotFound, dashboardtypes.ErrCodeDashboardNotFound, "dashboard with id %s doesn't exist", id)
-	}
-	return nil
-}
-
-func (store *store) LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, locked bool, updatedBy string) error {
-	res, err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewUpdate().
-		Model((*dashboardtypes.StorableDashboard)(nil)).
-		Set("locked = ?", locked).
-		Set("updated_by = ?", updatedBy).
-		Set("updated_at = ?", time.Now()).
-		Where("id = ?", id).
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-	rows, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rows == 0 {
-		return errors.Newf(errors.TypeNotFound, dashboardtypes.ErrCodeDashboardNotFound, "dashboard with id %s doesn't exist", id)
-	}
-	return nil
-}
-
 func (store *store) GetPublic(ctx context.Context, dashboardID string) (*dashboardtypes.StorablePublicDashboard, error) {
 	storable := new(dashboardtypes.StorablePublicDashboard)
 	err := store.
@@ -421,133 +217,3 @@ func (store *store) RunInTx(ctx context.Context, cb func(ctx context.Context) er
 		return cb(ctx)
 	})
 }
-
-// PinForUser combines the count check, the existence check, and the upsert in
-// a single statement so the limit gate and the insert can't drift between two
-// round-trips.
-//
-//	pin exists? | count < 10? | WHERE passes?           | effect                            | rows
-//	------------|-------------|-------------------------|-----------------------------------|-----
-//	no          | yes         | yes (count branch)      | INSERT new row                    | 1
-//	no          | no          | no                      | nothing (limit hit)               | 0
-//	yes         | yes         | yes (count branch)      | INSERT → conflict → no-op UPDATE  | 1
-//	yes         | no          | yes (EXISTS OR branch)  | INSERT → conflict → no-op UPDATE  | 1
-//
-// rows = 0 is the only signal of a real limit hit.
-func (store *store) PinForUser(ctx context.Context, pd *dashboardtypes.PinnedDashboard) error {
-	res, err := store.sqlstore.BunDBCtx(ctx).NewRaw(`
-		INSERT INTO pinned_dashboard (user_id, dashboard_id, org_id, pinned_at)
-		SELECT ?, ?, ?, ?
-		WHERE (SELECT COUNT(*) FROM pinned_dashboard WHERE user_id = ?) < ?
-		   OR EXISTS (SELECT 1 FROM pinned_dashboard WHERE user_id = ? AND dashboard_id = ?)
-		ON CONFLICT (user_id, dashboard_id) DO UPDATE SET user_id = EXCLUDED.user_id
-	`,
-		pd.UserID, pd.DashboardID, pd.OrgID, pd.PinnedAt,
-		pd.UserID, dashboardtypes.MaxPinnedDashboardsPerUser,
-		pd.UserID, pd.DashboardID,
-	).Exec(ctx)
-	if err != nil {
-		return err
-	}
-	rows, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rows == 0 {
-		return errors.Newf(errors.TypeAlreadyExists, dashboardtypes.ErrCodePinnedDashboardLimitHit,
-			"cannot pin more than %d dashboards", dashboardtypes.MaxPinnedDashboardsPerUser)
-	}
-	return nil
-}
-
-func (store *store) UnpinForUser(ctx context.Context, userID valuer.UUID, dashboardID valuer.UUID) error {
-	_, err := store.sqlstore.BunDBCtx(ctx).
-		NewDelete().
-		Model((*dashboardtypes.PinnedDashboard)(nil)).
-		Where("user_id = ?", userID).
-		Where("dashboard_id = ?", dashboardID).
-		Exec(ctx)
-	return err
-}
-
-func (store *store) CreateDashboardView(ctx context.Context, view *dashboardtypes.DashboardView) error {
-	_, err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewInsert().
-		Model(view).
-		Exec(ctx)
-	if err != nil {
-		return store.sqlstore.WrapAlreadyExistsErrf(err, errors.CodeAlreadyExists, "dashboard view with id %s already exists", view.ID)
-	}
-	return nil
-}
-
-func (store *store) GetDashboardView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardView, error) {
-	view := new(dashboardtypes.DashboardView)
-	err := store.
-		sqlstore.
-		BunDB().
-		NewSelect().
-		Model(view).
-		Where("id = ?", id).
-		Where("org_id = ?", orgID).
-		Scan(ctx)
-	if err != nil {
-		return nil, store.sqlstore.WrapNotFoundErrf(err, dashboardtypes.ErrCodeDashboardViewNotFound, "dashboard view with id %s doesn't exist", id)
-	}
-	return view, nil
-}
-
-func (store *store) ListDashboardViews(ctx context.Context, orgID valuer.UUID) ([]*dashboardtypes.DashboardView, error) {
-	views := make([]*dashboardtypes.DashboardView, 0)
-	err := store.
-		sqlstore.
-		BunDB().
-		NewSelect().
-		Model(&views).
-		Where("org_id = ?", orgID).
-		OrderExpr("updated_at DESC").
-		Scan(ctx)
-	if err != nil {
-		return nil, err
-	}
-	return views, nil
-}
-
-func (store *store) UpdateDashboardView(ctx context.Context, view *dashboardtypes.DashboardView) error {
-	res, err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewUpdate().
-		Model(view).
-		WherePK().
-		Where("org_id = ?", view.OrgID).
-		Exec(ctx)
-	if err != nil {
-		return err
-	}
-	rows, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-	if rows == 0 {
-		return errors.Newf(errors.TypeNotFound, dashboardtypes.ErrCodeDashboardViewNotFound, "dashboard view with id %s doesn't exist", view.ID)
-	}
-	return nil
-}
-
-func (store *store) DeleteDashboardView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	_, err := store.
-		sqlstore.
-		BunDBCtx(ctx).
-		NewDelete().
-		Model(new(dashboardtypes.DashboardView)).
-		Where("id = ?", id).
-		Where("org_id = ?", orgID).
-		Exec(ctx)
-	if err != nil {
-		return store.sqlstore.WrapNotFoundErrf(err, dashboardtypes.ErrCodeDashboardViewNotFound, "dashboard view with id %s doesn't exist", id)
-	}
-	return nil
-}

pkg/modules/dashboard/impldashboard/v2_handler.go

@@ -1,358 +0,0 @@
-package impldashboard
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-func (handler *handler) CreateV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var req dashboardtypes.PostableDashboardV2
-	if err := binding.JSON.BindBody(r.Body, &req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	dashboard, err := handler.module.CreateV2(ctx, orgID, claims.Email, valuer.MustNewUUID(claims.IdentityID()), dashboardtypes.SourceUser, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusCreated, dashboard.ToGettableDashboardV2())
-}
-
-func (handler *handler) ListV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	userID, err := valuer.NewUUID(claims.IdentityID())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	params := new(dashboardtypes.ListDashboardsV2Params)
-	if err := binding.Query.BindQuery(r.URL.Query(), params); err != nil {
-		render.Error(rw, err)
-		return
-	}
-	if err := params.Validate(); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := handler.module.ListV2(ctx, orgID, userID, params)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (handler *handler) GetV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	dashboard, err := handler.module.GetV2(ctx, orgID, dashboardID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, dashboard.ToGettableDashboardV2())
-}
-
-func (handler *handler) LockV2(rw http.ResponseWriter, r *http.Request) {
-	handler.lockUnlockV2(rw, r, true)
-}
-
-func (handler *handler) UnlockV2(rw http.ResponseWriter, r *http.Request) {
-	handler.lockUnlockV2(rw, r, false)
-}
-
-func (handler *handler) lockUnlockV2(rw http.ResponseWriter, r *http.Request, lock bool) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	isAdmin := false
-	selectors := []coretypes.Selector{
-		coretypes.TypeRole.MustSelector(authtypes.SigNozAdminRoleName),
-	}
-	err = handler.authz.CheckWithTupleCreation(
-		ctx,
-		claims,
-		valuer.MustNewUUID(claims.OrgID),
-		authtypes.Relation{Verb: coretypes.VerbAssignee},
-		coretypes.NewResourceRole(),
-		selectors,
-		selectors,
-	)
-	if err == nil {
-		isAdmin = true
-	}
-
-	if err := handler.module.LockUnlockV2(ctx, orgID, dashboardID, claims.Email, isAdmin, lock); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (handler *handler) UpdateV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := dashboardtypes.UpdateableDashboardV2{}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	dashboard, err := handler.module.UpdateV2(ctx, orgID, dashboardID, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, dashboard.ToGettableDashboardV2())
-}
-
-func (handler *handler) PatchV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	req := dashboardtypes.PatchableDashboardV2{}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	dashboard, err := handler.module.PatchV2(ctx, orgID, dashboardID, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, dashboard.ToGettableDashboardV2())
-}
-
-func (handler *handler) PinV2(rw http.ResponseWriter, r *http.Request) {
-	handler.pinUnpinV2(rw, r, true)
-}
-
-func (handler *handler) UnpinV2(rw http.ResponseWriter, r *http.Request) {
-	handler.pinUnpinV2(rw, r, false)
-}
-
-func (handler *handler) pinUnpinV2(rw http.ResponseWriter, r *http.Request, pin bool) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	userID, err := valuer.NewUUID(claims.IdentityID())
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if pin {
-		err = handler.module.PinV2(ctx, orgID, userID, dashboardID)
-	} else {
-		err = handler.module.UnpinV2(ctx, userID, dashboardID)
-	}
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}
-
-func (handler *handler) DeleteV2(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	dashboardID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := handler.module.DeleteV2(ctx, orgID, dashboardID); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}

pkg/modules/dashboard/impldashboard/v2_module.go

@@ -1,214 +0,0 @@
-package impldashboard
-
-import (
-	"context"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-func (m *module) CreateV2(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, source dashboardtypes.Source, postable dashboardtypes.PostableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	if !source.IsValid() {
-		return nil, errors.Newf(errors.TypeInvalidInput, dashboardtypes.ErrCodeDashboardInvalidSource, "invalid dashboard source %q, must be one of user, system, integration", source.StringValue())
-	}
-	if err := postable.Validate(); err != nil {
-		return nil, err
-	}
-
-	dashboard := postable.NewDashboardV2(orgID, createdBy, source)
-	var storableDashboard *dashboardtypes.StorableDashboard
-
-	err := m.store.RunInTx(ctx, func(ctx context.Context) error {
-		resolvedTags, err := m.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, dashboard.ID, postable.Tags)
-		if err != nil {
-			return err
-		}
-		dashboard.Tags = resolvedTags
-
-		storable, err := dashboard.ToStorableDashboard()
-		if err != nil {
-			return err
-		}
-		storableDashboard = storable
-		return m.store.Create(ctx, storable)
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	m.analytics.TrackUser(ctx, orgID.String(), creator.String(), "Dashboard Created", dashboardtypes.NewStatsFromStorableDashboards([]*dashboardtypes.StorableDashboard{storableDashboard}))
-	return dashboard, nil
-}
-
-func (module *module) ListV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *dashboardtypes.ListDashboardsV2Params) (*dashboardtypes.ListableDashboardV2, error) {
-	rows, total, err := module.store.ListV2(ctx, orgID, userID, params)
-	if err != nil {
-		return nil, err
-	}
-
-	dashboardIDs := make([]valuer.UUID, len(rows))
-	for i, r := range rows {
-		dashboardIDs[i] = r.Dashboard.ID
-	}
-	tagsByDashboard, err := module.tagModule.ListForResources(ctx, orgID, coretypes.KindDashboard, dashboardIDs)
-	if err != nil {
-		return nil, err
-	}
-
-	return dashboardtypes.NewListableDashboardV2(rows, total, tagsByDashboard)
-}
-
-func (module *module) GetV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*dashboardtypes.DashboardV2, error) {
-	storable, err := module.store.Get(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-
-	tags, err := module.tagModule.ListForResource(ctx, orgID, coretypes.KindDashboard, id)
-	if err != nil {
-		return nil, err
-	}
-
-	return storable.ToDashboardV2(tags)
-}
-
-func (module *module) UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	if err := updateable.Validate(); err != nil {
-		return nil, err
-	}
-
-	existing, err := module.GetV2(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-	// Locked-dashboard / state gate — independent of tags, so run it before the tx.
-	if err := existing.CanUpdate(); err != nil {
-		return nil, err
-	}
-
-	err = module.store.RunInTx(ctx, func(ctx context.Context) error {
-		resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, updateable.Tags)
-		if err != nil {
-			return err
-		}
-
-		err = existing.Update(updateable, updatedBy, resolvedTags)
-		if err != nil {
-			return err
-		}
-
-		storable, err := existing.ToStorableDashboard()
-		if err != nil {
-			return err
-		}
-
-		return module.store.UpdateV2(ctx, orgID, id, updatedBy, storable.Data)
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return existing, nil
-}
-
-func (module *module) PatchV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, patch dashboardtypes.PatchableDashboardV2) (*dashboardtypes.DashboardV2, error) {
-	existing, err := module.GetV2(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-	// Locked-dashboard / state gate — independent of tags, so run it before the tx.
-	if err := existing.CanUpdate(); err != nil {
-		return nil, err
-	}
-
-	updateable, err := patch.Apply(existing)
-	if err != nil {
-		return nil, err
-	}
-
-	err = module.store.RunInTx(ctx, func(ctx context.Context) error {
-		resolvedTags, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, updateable.Tags)
-		if err != nil {
-			return err
-		}
-
-		err = existing.Update(*updateable, updatedBy, resolvedTags)
-		if err != nil {
-			return err
-		}
-
-		storable, err := existing.ToStorableDashboard()
-		if err != nil {
-			return err
-		}
-
-		return module.store.UpdateV2(ctx, orgID, id, updatedBy, storable.Data)
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return existing, nil
-}
-
-func (module *module) DeleteV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	existing, err := module.GetV2(ctx, orgID, id)
-	if err != nil {
-		return err
-	}
-	if existing.Locked {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot delete a locked dashboard, please unlock the dashboard to delete")
-	}
-
-	return module.store.RunInTx(ctx, func(ctx context.Context) error {
-		// Syncing to an empty tag set drops every tag link for the dashboard.
-		if _, err := module.tagModule.SyncTags(ctx, orgID, coretypes.KindDashboard, id, nil); err != nil {
-			return err
-		}
-		return module.store.Delete(ctx, orgID, id)
-	})
-}
-
-// CreatePublicV2 is not supported in the community build.
-func (module *module) CreatePublicV2(_ context.Context, _ valuer.UUID, _ valuer.UUID, _ dashboardtypes.PostablePublicDashboard) (*dashboardtypes.DashboardV2, error) {
-	return nil, errors.Newf(errors.TypeUnsupported, dashboardtypes.ErrCodePublicDashboardUnsupported, "not implemented")
-}
-
-// UpdatePublicV2 is not supported in the community build.
-func (module *module) UpdatePublicV2(_ context.Context, _ valuer.UUID, _ valuer.UUID, _ dashboardtypes.UpdatablePublicDashboard) (*dashboardtypes.DashboardV2, error) {
-	return nil, errors.Newf(errors.TypeUnsupported, dashboardtypes.ErrCodePublicDashboardUnsupported, "not implemented")
-}
-
-func (module *module) LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
-	existing, err := module.GetV2(ctx, orgID, id)
-	if err != nil {
-		return err
-	}
-	if err := existing.LockUnlock(lock, isAdmin, updatedBy); err != nil {
-		return err
-	}
-	storable, err := existing.ToStorableDashboard()
-	if err != nil {
-		return err
-	}
-	return module.store.UpdateV2(ctx, orgID, id, updatedBy, storable.Data)
-}
-
-func (module *module) PinV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, id valuer.UUID) error {
-	if _, err := module.GetV2(ctx, orgID, id); err != nil {
-		return err
-	}
-	return module.store.PinForUser(ctx, &dashboardtypes.PinnedDashboard{
-		UserID:      userID,
-		DashboardID: id,
-		OrgID:       orgID,
-		PinnedAt:    time.Now(),
-	})
-}
-
-func (module *module) UnpinV2(ctx context.Context, userID valuer.UUID, id valuer.UUID) error {
-	return module.store.UnpinForUser(ctx, userID, id)
-}

pkg/modules/dashboard/impldashboard/v2_view_handler.go

@@ -1,148 +0,0 @@
-package impldashboard
-
-import (
-	"context"
-	"net/http"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/binding"
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/gorilla/mux"
-)
-
-func (handler *handler) CreateView(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var req dashboardtypes.PostableDashboardView
-	if err := binding.JSON.BindBody(r.Body, &req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	view, err := handler.module.CreateView(ctx, orgID, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusCreated, view)
-}
-
-func (handler *handler) ListViews(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	out, err := handler.module.ListViews(ctx, orgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, out)
-}
-
-func (handler *handler) UpdateView(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	viewID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	var req dashboardtypes.UpdateableDashboardView
-	if err := binding.JSON.BindBody(r.Body, &req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	view, err := handler.module.UpdateView(ctx, orgID, viewID, claims.Email, req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, view)
-}
-
-func (handler *handler) DeleteView(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	id := mux.Vars(r)["id"]
-	if id == "" {
-		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "id is missing in the path"))
-		return
-	}
-	viewID, err := valuer.NewUUID(id)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := handler.module.DeleteView(ctx, orgID, viewID); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusNoContent, nil)
-}

pkg/modules/dashboard/impldashboard/v2_view_module.go

@@ -1,46 +0,0 @@
-package impldashboard
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-func (module *module) CreateView(ctx context.Context, orgID valuer.UUID, createdBy string, postable dashboardtypes.PostableDashboardView) (*dashboardtypes.DashboardView, error) {
-	if err := postable.Validate(); err != nil {
-		return nil, err
-	}
-	view := postable.NewDashboardView(orgID, createdBy)
-	if err := module.store.CreateDashboardView(ctx, view); err != nil {
-		return nil, err
-	}
-	return view, nil
-}
-
-func (module *module) ListViews(ctx context.Context, orgID valuer.UUID) (*dashboardtypes.ListableDashboardView, error) {
-	views, err := module.store.ListDashboardViews(ctx, orgID)
-	if err != nil {
-		return nil, err
-	}
-	return &dashboardtypes.ListableDashboardView{Views: views}, nil
-}
-
-func (module *module) UpdateView(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, updateable dashboardtypes.UpdateableDashboardView) (*dashboardtypes.DashboardView, error) {
-	if err := updateable.Validate(); err != nil {
-		return nil, err
-	}
-	view, err := module.store.GetDashboardView(ctx, orgID, id)
-	if err != nil {
-		return nil, err
-	}
-	view.Update(updateable, updatedBy)
-	if err := module.store.UpdateDashboardView(ctx, view); err != nil {
-		return nil, err
-	}
-	return view, nil
-}
-
-func (module *module) DeleteView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error {
-	return module.store.DeleteDashboardView(ctx, orgID, id)
-}

pkg/parser/filterquery/parse.go

@@ -1,33 +0,0 @@
-package filterquery
-
-import (
-	"fmt"
-
-	grammar "github.com/SigNoz/signoz/pkg/parser/filterquery/grammar"
-	"github.com/antlr4-go/antlr/v4"
-)
-
-func Parse(query string) (antlr.ParseTree, *antlr.CommonTokenStream, *ErrorCollector) {
-	collector := NewErrorCollector()
-	lexer := grammar.NewFilterQueryLexer(antlr.NewInputStream(query))
-	lexer.RemoveErrorListeners()
-	lexer.AddErrorListener(collector)
-	tokens := antlr.NewCommonTokenStream(lexer, 0)
-	parser := grammar.NewFilterQueryParser(tokens)
-	parser.RemoveErrorListeners()
-	parser.AddErrorListener(collector)
-	return parser.Query(), tokens, collector
-}
-
-type ErrorCollector struct {
-	*antlr.DefaultErrorListener
-	Errors []string
-}
-
-func NewErrorCollector() *ErrorCollector {
-	return &ErrorCollector{}
-}
-
-func (c *ErrorCollector) SyntaxError(_ antlr.Recognizer, _ any, line, column int, msg string, _ antlr.RecognitionException) {
-	c.Errors = append(c.Errors, fmt.Sprintf("syntax error at %d:%d — %s", line, column, msg))
-}

pkg/signoz/handler_test.go

@@ -49,7 +49,7 @@ func TestNewHandlers(t *testing.T) {
 	queryParser := queryparser.New(providerSettings)
 	require.NoError(t, err)
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
-	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule)
+	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser)
 
 	flagger, err := flagger.New(context.Background(), instrumentationtest.New().ToProviderSettings(), flagger.Config{}, flagger.MustNewRegistry())
 	require.NoError(t, err)

pkg/signoz/module_test.go

@@ -50,7 +50,7 @@ func TestNewModules(t *testing.T) {
 	queryParser := queryparser.New(providerSettings)
 	require.NoError(t, err)
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
-	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser, tagModule)
+	dashboardModule := impldashboard.NewModule(impldashboard.NewStore(sqlstore), providerSettings, nil, orgGetter, queryParser)
 
 	flagger, err := flagger.New(context.Background(), instrumentationtest.New().ToProviderSettings(), flagger.Config{}, flagger.MustNewRegistry())
 	require.NoError(t, err)

pkg/signoz/provider.go

@@ -208,9 +208,6 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewMigrateCloudIntegrationDashboardsFactory(sqlstore),
 		sqlmigration.NewAddScopeToPlannedMaintenanceFactory(sqlstore, sqlschema),
 		sqlmigration.NewMigrateInstalledIntegrationDashboardsFactory(sqlstore),
-		sqlmigration.NewAddDashboardNameFactory(sqlstore, sqlschema),
-		sqlmigration.NewAddPinnedDashboardFactory(sqlstore, sqlschema),
-		sqlmigration.NewAddDashboardViewFactory(sqlstore, sqlschema),
 	)
 }
 

pkg/signoz/signoz.go

@@ -33,7 +33,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/rulestatehistory"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount"
 	"github.com/SigNoz/signoz/pkg/modules/serviceaccount/implserviceaccount"
-	"github.com/SigNoz/signoz/pkg/modules/tag"
 	"github.com/SigNoz/signoz/pkg/modules/tag/impltag"
 	"github.com/SigNoz/signoz/pkg/modules/user/impluser"
 	"github.com/SigNoz/signoz/pkg/prometheus"
@@ -108,7 +107,7 @@ func New(
 	telemetrystoreProviderFactories factory.NamedMap[factory.ProviderFactory[telemetrystore.TelemetryStore, telemetrystore.Config]],
 	authNsCallback func(ctx context.Context, providerSettings factory.ProviderSettings, store authtypes.AuthNStore, licensing licensing.Licensing) (map[authtypes.AuthNProvider]authn.AuthN, error),
 	authzCallback func(context.Context, sqlstore.SQLStore, authz.Config, licensing.Licensing, []authz.OnBeforeRoleDelete) (factory.ProviderFactory[authz.AuthZ, authz.Config], error),
-	dashboardModuleCallback func(sqlstore.SQLStore, factory.ProviderSettings, analytics.Analytics, organization.Getter, queryparser.QueryParser, querier.Querier, licensing.Licensing, tag.Module) dashboard.Module,
+	dashboardModuleCallback func(sqlstore.SQLStore, factory.ProviderSettings, analytics.Analytics, organization.Getter, queryparser.QueryParser, querier.Querier, licensing.Licensing) dashboard.Module,
 	gatewayProviderFactory func(licensing.Licensing) factory.ProviderFactory[gateway.Gateway, gateway.Config],
 	auditorProviderFactories func(licensing.Licensing) factory.NamedMap[factory.ProviderFactory[auditor.Auditor, auditor.Config]],
 	meterReporterProviderFactories func(context.Context, factory.ProviderSettings, flagger.Flagger, licensing.Licensing, telemetrystore.TelemetryStore, retention.Getter, organization.Getter, zeus.Zeus) (factory.NamedMap[factory.ProviderFactory[meterreporter.Reporter, meterreporter.Config]], string),
@@ -341,7 +340,7 @@ func New(
 	tagModule := impltag.NewModule(impltag.NewStore(sqlstore))
 
 	// Initialize dashboard module
-	dashboard := dashboardModuleCallback(sqlstore, providerSettings, analytics, orgGetter, queryParser, querier, licensing, tagModule)
+	dashboard := dashboardModuleCallback(sqlstore, providerSettings, analytics, orgGetter, queryParser, querier, licensing)
 
 	// Initialize user getter
 	userGetter := impluser.NewGetter(userStore, userRoleStore, flagger)

pkg/sqlmigration/089_add_dashboard_name.go

@@ -1,85 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type addDashboardName struct {
-	sqlstore  sqlstore.SQLStore
-	sqlschema sqlschema.SQLSchema
-}
-
-func NewAddDashboardNameFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(
-		factory.MustNewName("add_dashboard_name"),
-		func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
-			return &addDashboardName{sqlstore: sqlstore, sqlschema: sqlschema}, nil
-		},
-	)
-}
-
-func (migration *addDashboardName) Register(migrations *migrate.Migrations) error {
-	return migrations.Register(migration.Up, migration.Down)
-}
-
-func (migration *addDashboardName) Up(ctx context.Context, db *bun.DB) error {
-	// dashboard is referenced by public_dashboard and integration_dashboard;
-	// FK enforcement must be off for the SQLite recreate-table fallback.
-	if err := migration.sqlschema.ToggleFKEnforcement(ctx, db, false); err != nil {
-		return err
-	}
-
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		_ = tx.Rollback()
-	}()
-
-	table, uniqueConstraints, err := migration.sqlschema.GetTable(ctx, sqlschema.TableName("dashboard"))
-	if err != nil {
-		return err
-	}
-
-	nameColumn := &sqlschema.Column{
-		Name:     sqlschema.ColumnName("name"),
-		DataType: sqlschema.DataTypeText,
-		Nullable: false,
-	}
-
-	// Only v2 dashboards populate this column. Existing v1 rows are left with
-	// the zero value (empty string) so v1 create/update paths can keep
-	// inserting without a name.
-	//
-	// TODO: once v1 dashboards are migrated to v2 and every row has a real
-	// name, a follow-up migration should add a unique index on
-	// (org_id, name) to enforce per-org name uniqueness.
-	sqls := migration.sqlschema.Operator().AddColumn(table, uniqueConstraints, nameColumn, nil)
-
-	for _, sql := range sqls {
-		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	if err := tx.Commit(); err != nil {
-		return err
-	}
-
-	if err := migration.sqlschema.ToggleFKEnforcement(ctx, db, true); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (migration *addDashboardName) Down(context.Context, *bun.DB) error {
-	return nil
-}

pkg/sqlmigration/090_add_pinned_dashboard.go

@@ -1,67 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type addPinnedDashboard struct {
-	sqlstore  sqlstore.SQLStore
-	sqlschema sqlschema.SQLSchema
-}
-
-func NewAddPinnedDashboardFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(factory.MustNewName("add_pinned_dashboard"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
-		return &addPinnedDashboard{
-			sqlstore:  sqlstore,
-			sqlschema: sqlschema,
-		}, nil
-	})
-}
-
-func (migration *addPinnedDashboard) Register(migrations *migrate.Migrations) error {
-	return migrations.Register(migration.Up, migration.Down)
-}
-
-func (migration *addPinnedDashboard) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = tx.Rollback() }()
-
-	sqls := migration.sqlschema.Operator().CreateTable(&sqlschema.Table{
-		Name: "pinned_dashboard",
-		Columns: []*sqlschema.Column{
-			{Name: "user_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "dashboard_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "org_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "pinned_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false, Default: "current_timestamp"},
-		},
-		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{ColumnNames: []sqlschema.ColumnName{"user_id", "dashboard_id"}},
-		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
-			{
-				ReferencingColumnName: sqlschema.ColumnName("org_id"),
-				ReferencedTableName:   sqlschema.TableName("organizations"),
-				ReferencedColumnName:  sqlschema.ColumnName("id"),
-			},
-		},
-	})
-
-	for _, sql := range sqls {
-		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (migration *addPinnedDashboard) Down(_ context.Context, _ *bun.DB) error {
-	return nil
-}

pkg/sqlmigration/091_add_dashboard_view.go

@@ -1,71 +0,0 @@
-package sqlmigration
-
-import (
-	"context"
-
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/sqlschema"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/uptrace/bun"
-	"github.com/uptrace/bun/migrate"
-)
-
-type addDashboardView struct {
-	sqlstore  sqlstore.SQLStore
-	sqlschema sqlschema.SQLSchema
-}
-
-func NewAddDashboardViewFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
-	return factory.NewProviderFactory(factory.MustNewName("add_dashboard_view"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
-		return &addDashboardView{
-			sqlstore:  sqlstore,
-			sqlschema: sqlschema,
-		}, nil
-	})
-}
-
-func (migration *addDashboardView) Register(migrations *migrate.Migrations) error {
-	return migrations.Register(migration.Up, migration.Down)
-}
-
-func (migration *addDashboardView) Up(ctx context.Context, db *bun.DB) error {
-	tx, err := db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = tx.Rollback() }()
-
-	sqls := migration.sqlschema.Operator().CreateTable(&sqlschema.Table{
-		Name: "dashboard_view",
-		Columns: []*sqlschema.Column{
-			{Name: "id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "name", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "data", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "org_id", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "created_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "created_by", DataType: sqlschema.DataTypeText, Nullable: false},
-			{Name: "updated_at", DataType: sqlschema.DataTypeTimestamp, Nullable: false},
-			{Name: "updated_by", DataType: sqlschema.DataTypeText, Nullable: false},
-		},
-		PrimaryKeyConstraint: &sqlschema.PrimaryKeyConstraint{ColumnNames: []sqlschema.ColumnName{"id"}},
-		ForeignKeyConstraints: []*sqlschema.ForeignKeyConstraint{
-			{
-				ReferencingColumnName: sqlschema.ColumnName("org_id"),
-				ReferencedTableName:   sqlschema.TableName("organizations"),
-				ReferencedColumnName:  sqlschema.ColumnName("id"),
-			},
-		},
-	})
-
-	for _, sql := range sqls {
-		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (migration *addDashboardView) Down(_ context.Context, _ *bun.DB) error {
-	return nil
-}

pkg/telemetrylogs/field_mapper.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	schema "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz-otel-collector/utils"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/flagger"
@@ -76,7 +77,7 @@ func NewFieldMapper(fl flagger.Flagger) qbtypes.FieldMapper {
 	return &fieldMapper{fl: fl}
 }
 
-func (m *fieldMapper) getColumn(ctx context.Context, key *telemetrytypes.TelemetryFieldKey) ([]*schema.Column, error) {
+func (m *fieldMapper) getColumns(ctx context.Context, key *telemetrytypes.TelemetryFieldKey) ([]*schema.Column, error) {
 	switch key.FieldContext {
 	case telemetrytypes.FieldContextResource:
 		columns := []*schema.Column{logsV2Columns["resources_string"], logsV2Columns["resource"]}
@@ -245,7 +246,7 @@ func selectEvolutionsForColumns(columns []*schema.Column, evolutions []*telemetr
 }
 
 func (m *fieldMapper) FieldFor(ctx context.Context, tsStart, tsEnd uint64, key *telemetrytypes.TelemetryFieldKey) (string, error) {
-	columns, err := m.getColumn(ctx, key)
+	columns, err := m.getColumns(ctx, key)
 	if err != nil {
 		return "", err
 	}
@@ -287,12 +288,14 @@ func (m *fieldMapper) FieldFor(ctx context.Context, tsStart, tsEnd uint64, key *
 					return "", qbtypes.ErrColumnNotFound
 				}
 
-				expr, err := m.buildFieldForJSON(key)
-				if err != nil {
-					return "", err
-				}
+				for _, column := range columns {
+					expr, err := m.buildFieldForJSON(key, column)
+					if err != nil {
+						return "", err
+					}
 
-				exprs = append(exprs, expr)
+					exprs = append(exprs, expr)
+				}
 			default:
 				return "", errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "only resource/body context fields are supported for json columns, got %s", key.FieldContext.String)
 			}
@@ -348,7 +351,7 @@ func (m *fieldMapper) FieldFor(ctx context.Context, tsStart, tsEnd uint64, key *
 }
 
 func (m *fieldMapper) ColumnFor(ctx context.Context, _, _ uint64, key *telemetrytypes.TelemetryFieldKey) ([]*schema.Column, error) {
-	return m.getColumn(ctx, key)
+	return m.getColumns(ctx, key)
 }
 
 func (m *fieldMapper) ColumnExpressionFor(
@@ -403,16 +406,13 @@ func (m *fieldMapper) ColumnExpressionFor(
 }
 
 // buildFieldForJSON builds the field expression for body JSON fields using arrayConcat pattern.
-func (m *fieldMapper) buildFieldForJSON(key *telemetrytypes.TelemetryFieldKey) (string, error) {
-	plan := key.JSONPlan
-	if len(plan) == 0 {
-		return "", errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput,
-			"Could not find any valid paths for: %s", key.Name)
+func (m *fieldMapper) buildFieldForJSON(key *telemetrytypes.TelemetryFieldKey, column *schemamigrator.Column) (string, error) {
+	node, err := key.PlanBuilder.Build(*column)
+	if err != nil {
+		return "", err
 	}
 
-	if plan[0].IsTerminal {
-		node := plan[0]
-
+	if node.IsTerminal {
 		expr := fmt.Sprintf("dynamicElement(%s, '%s')", node.FieldPath(), node.TerminalConfig.ElemType.StringValue())
 		// TODO(Piyush): Promoted path logic commented out. Materialized now means type hint
 		// promotion will be extracted from key field evolution
@@ -450,7 +450,7 @@ func (m *fieldMapper) buildFieldForJSON(key *telemetrytypes.TelemetryFieldKey) (
 	}
 
 	// Build arrayConcat pattern directly from the tree structure
-	arrayConcatExpr, err := m.buildArrayConcat(plan)
+	arrayConcatExpr, err := m.buildArrayConcat(node)
 	if err != nil {
 		return "", err
 	}
@@ -459,23 +459,18 @@ func (m *fieldMapper) buildFieldForJSON(key *telemetrytypes.TelemetryFieldKey) (
 }
 
 // buildArrayConcat builds the arrayConcat pattern directly from the tree structure.
-func (m *fieldMapper) buildArrayConcat(plan telemetrytypes.JSONAccessPlan) (string, error) {
-	if len(plan) == 0 {
-		return "", errors.Newf(errors.TypeInternal, CodeGroupByPlanEmpty, "group by plan is empty while building arrayConcat")
-	}
-
+func (m *fieldMapper) buildArrayConcat(node *telemetrytypes.JSONAccessNode) (string, error) {
 	// Build arrayMap expressions for ALL available branches at the root level.
 	// Iterate branches in deterministic order (JSON then Dynamic)
 	var arrayMapExpressions []string
-	for _, node := range plan {
-		for _, branchType := range node.BranchesInOrder() {
-			expr, err := m.buildArrayMap(node, branchType)
-			if err != nil {
-				return "", err
-			}
-			arrayMapExpressions = append(arrayMapExpressions, expr)
+	for _, branchType := range node.BranchesInOrder() {
+		expr, err := m.buildArrayMap(node, branchType)
+		if err != nil {
+			return "", err
 		}
+		arrayMapExpressions = append(arrayMapExpressions, expr)
 	}
+
 	if len(arrayMapExpressions) == 0 {
 		return "", errors.Newf(errors.TypeInternal, CodeArrayMapExpressionsEmpty, "array map expressions are empty while building arrayConcat")
 	}

pkg/telemetrylogs/json_condition_builder.go

@@ -33,32 +33,42 @@ func NewJSONConditionBuilder(key *telemetrytypes.TelemetryFieldKey, valueType te
 }
 
 // BuildCondition builds the full WHERE condition for body_v2 JSON paths.
-func (c *jsonConditionBuilder) buildJSONCondition(operator qbtypes.FilterOperator, value any, sb *sqlbuilder.SelectBuilder) (string, error) {
-	baseCond, err := c.emitPlannedCondition(operator, value, sb)
-	if err != nil {
-		return "", err
-	}
-
-	// path index
-	if operator.AddDefaultExistsFilter() {
-		pathIndex := fmt.Sprintf(`has(%s, '%s')`, schemamigrator.JSONPathsIndexExpr(LogsV2BodyV2Column), c.key.ArrayParentPaths()[0])
-		return sb.And(baseCond, pathIndex), nil
-	}
-
-	return baseCond, nil
-}
-
-func (c *jsonConditionBuilder) emitPlannedCondition(operator qbtypes.FilterOperator, value any, sb *sqlbuilder.SelectBuilder) (string, error) {
-	// Build traversal + terminal recursively per-hop
-	conditions := []string{}
-	for _, node := range c.key.JSONPlan {
-		condition, err := c.recurseArrayHops(node, operator, value, sb)
+func (c *jsonConditionBuilder) buildJSONCondition(columns []schemamigrator.Column, operator qbtypes.FilterOperator, value any, sb *sqlbuilder.SelectBuilder) (string, error) {
+	if len(columns) == 1 {
+		baseCond, err := c.emitPlannedCondition(columns[0], operator, value, sb)
 		if err != nil {
 			return "", err
 		}
-		conditions = append(conditions, condition)
+
+		// path index
+		if operator.AddDefaultExistsFilter() {
+			pathIndex := fmt.Sprintf(`has(%s, '%s')`, schemamigrator.JSONPathsIndexExpr(LogsV2BodyV2Column), c.key.ArrayParentPaths()[0])
+			return sb.And(baseCond, pathIndex), nil
+		}
+
+		return baseCond, nil
 	}
 
+	
+}
+
+func (c *jsonConditionBuilder) emitPlannedCondition(column schemamigrator.Column, operator qbtypes.FilterOperator, value any, sb *sqlbuilder.SelectBuilder) (string, error) {
+	if c.key.PlanBuilder == nil {
+		return "", errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "no plan builder for key %s", c.key.Name)
+	}
+
+	var conditions []string
+
+	node, err := c.key.PlanBuilder.Build(column)
+	if err != nil {
+		return "", err
+	}
+	cond, err := c.recurseArrayHops(node, operator, value, sb)
+	if err != nil {
+		return "", err
+	}
+	conditions = append(conditions, cond)
+
 	return sb.Or(conditions...), nil
 }
 

pkg/telemetrymetadata/body_json_metadata.go

@@ -85,27 +85,16 @@ func (t *telemetryMetaStore) enrichJSONKeys(ctx context.Context, selectors []*te
 		key.Indexes = indexes[key.Name]
 	}
 
-	// build JSON access plans using the pre-fetched parent type cache
-	return t.buildJSONPlans(filteredKeys, parentTypeCache)
-}
-
-// buildJSONPlans builds JSON access plans for the given keys
-// using the provided parent type cache (pre-fetched in the main UNION query).
-func (t *telemetryMetaStore) buildJSONPlans(keys []*telemetrytypes.TelemetryFieldKey, typeCache map[string][]telemetrytypes.FieldDataType) error {
-	if len(keys) == 0 {
-		return nil
-	}
-
+	// attach a lazy PlanBuilder so field_mapper can build plans on demand
 	columnMeta := t.jsonColumnMetadata[telemetrytypes.SignalLogs][telemetrytypes.FieldContextBody]
-	for _, key := range keys {
-		if err := key.SetJSONAccessPlan(columnMeta, typeCache); err != nil {
-			return err
-		}
+	for _, key := range filteredKeys {
+		key.PlanBuilder = telemetrytypes.NewFieldPlanBuilder(key, columnMeta, parentTypeCache)
 	}
 
 	return nil
 }
 
+
 func (t *telemetryMetaStore) getJSONPathIndexes(ctx context.Context, paths ...string) (map[string][]telemetrytypes.TelemetryFieldKeySkipIndex, error) {
 	filteredPaths := []string{}
 	for _, path := range paths {

pkg/types/dashboardtypes/dashboard.go

@@ -33,7 +33,6 @@ type StorableDashboard struct {
 	Locked bool                  `bun:"locked,notnull,default:false"`
 	OrgID  valuer.UUID           `bun:"org_id,notnull"`
 	Source Source                `bun:"source,type:text,notnull"`
-	Name   string                `bun:"name,type:text,notnull"`
 }
 
 type Dashboard struct {

pkg/types/dashboardtypes/dashboard_view.go

@@ -1,149 +0,0 @@
-package dashboardtypes
-
-import (
-	"bytes"
-	"encoding/json"
-	"strings"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-const (
-	DashboardViewSchemaVersion = "v1"
-	MaxDashboardViewNameLen    = 32
-)
-
-var (
-	ErrCodeDashboardViewInvalidInput = errors.MustNewCode("dashboard_view_invalid_input")
-	ErrCodeDashboardViewNotFound     = errors.MustNewCode("dashboard_view_not_found")
-)
-
-type DashboardViewData struct {
-	Version string    `json:"version" required:"true"`
-	Query   string    `json:"query,omitempty"`
-	Sort    ListSort  `json:"sort,omitempty"`
-	Order   ListOrder `json:"order,omitempty"`
-}
-
-func (d *DashboardViewData) Validate() error {
-	if d.Version != DashboardViewSchemaVersion {
-		return errors.NewInvalidInputf(ErrCodeDashboardViewInvalidInput,
-			"version must be %q, got %q", DashboardViewSchemaVersion, d.Version)
-	}
-	if d.Sort != "" {
-		s := ListSort(strings.ToLower(string(d.Sort)))
-		switch s {
-		case ListSortUpdatedAt, ListSortCreatedAt, ListSortName:
-		default:
-			return errors.NewInvalidInputf(ErrCodeDashboardViewInvalidInput,
-				"invalid sort %q — expected one of: `updated_at`, `created_at`, `name`", d.Sort)
-		}
-		d.Sort = s
-	}
-	if d.Order != "" {
-		o := ListOrder(strings.ToLower(string(d.Order)))
-		switch o {
-		case ListOrderAsc, ListOrderDesc:
-		default:
-			return errors.NewInvalidInputf(ErrCodeDashboardViewInvalidInput,
-				"invalid order %q — expected `asc` or `desc`", d.Order)
-		}
-		d.Order = o
-	}
-	return nil
-}
-
-type DashboardView struct {
-	bun.BaseModel `bun:"table:dashboard_view,alias:dashboard_view"`
-
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	Name  string            `bun:"name,type:text,notnull" json:"name" required:"true"`
-	Data  DashboardViewData `bun:"data,type:jsonb,notnull" json:"data" required:"true"`
-	OrgID valuer.UUID       `bun:"org_id,type:text,notnull" json:"orgId" required:"true"`
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Postable
-// ════════════════════════════════════════════════════════════════════════
-
-type PostableDashboardView struct {
-	Name string            `json:"name" required:"true"`
-	Data DashboardViewData `json:"data" required:"true"`
-}
-
-func (p *PostableDashboardView) UnmarshalJSON(data []byte) error {
-	dec := json.NewDecoder(bytes.NewReader(data))
-	dec.DisallowUnknownFields()
-	type alias PostableDashboardView
-	var tmp alias
-	if err := dec.Decode(&tmp); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardViewInvalidInput, "%s", err.Error())
-	}
-	*p = PostableDashboardView(tmp)
-	return p.Validate()
-}
-
-func (p *PostableDashboardView) Validate() error {
-	if err := validateDashboardViewName(p.Name); err != nil {
-		return err
-	}
-	return p.Data.Validate()
-}
-
-func (p PostableDashboardView) NewDashboardView(orgID valuer.UUID, createdBy string) *DashboardView {
-	now := time.Now()
-	return &DashboardView{
-		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
-		TimeAuditable: types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
-		UserAuditable: types.UserAuditable{CreatedBy: createdBy, UpdatedBy: createdBy},
-		OrgID:         orgID,
-		Name:          p.Name,
-		Data:          p.Data,
-	}
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Updateable
-// ════════════════════════════════════════════════════════════════════════
-
-type UpdateableDashboardView = PostableDashboardView
-
-func (v *DashboardView) Update(updateable UpdateableDashboardView, updatedBy string) {
-	v.Name = updateable.Name
-	v.Data = updateable.Data
-	v.UpdatedBy = updatedBy
-	v.UpdatedAt = time.Now()
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Gettable
-// ════════════════════════════════════════════════════════════════════════
-
-type GettableDashboardView = DashboardView
-
-type ListableDashboardView struct {
-	Views []*GettableDashboardView `json:"views" required:"true" nullable:"false"`
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Helpers
-// ════════════════════════════════════════════════════════════════════════
-
-func validateDashboardViewName(name string) error {
-	trimmed := strings.TrimSpace(name)
-	if trimmed == "" {
-		return errors.NewInvalidInputf(ErrCodeDashboardViewInvalidInput, "name is required")
-	}
-	if len(trimmed) > MaxDashboardViewNameLen {
-		return errors.NewInvalidInputf(ErrCodeDashboardViewInvalidInput,
-			"name must be at most %d characters, got %d", MaxDashboardViewNameLen, len(trimmed))
-	}
-	return nil
-}

pkg/types/dashboardtypes/list_v2.go

@@ -1,150 +0,0 @@
-package dashboardtypes
-
-import (
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/tagtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/perses/perses/pkg/model/api/v1/common"
-)
-
-const (
-	DefaultListLimit = 20
-	MaxListLimit     = 200
-)
-
-// ListSort is the sort field for the dashboard list endpoint. The value is a
-// stable enum so callers can't ask for arbitrary columns.
-type ListSort string
-
-const (
-	ListSortUpdatedAt ListSort = "updated_at"
-	ListSortCreatedAt ListSort = "created_at"
-	ListSortName      ListSort = "name"
-)
-
-type ListOrder string
-
-const (
-	ListOrderAsc  ListOrder = "asc"
-	ListOrderDesc ListOrder = "desc"
-)
-
-var ErrCodeDashboardListInvalid = errors.MustNewCode("dashboard_list_invalid")
-
-type ListDashboardsV2Params struct {
-	Query  string    `query:"query"`
-	Sort   ListSort  `query:"sort"`
-	Order  ListOrder `query:"order"`
-	Limit  int       `query:"limit"`
-	Offset int       `query:"offset"`
-}
-
-// Validate fills in defaults (sort=updated_at, order=desc, limit=20) and
-// rejects out-of-allowlist sort/order values and bad limit/offset. Limit is
-// clamped to MaxListLimit on the high side. Lowercases sort/order so callers
-// can pass them in any case.
-func (p *ListDashboardsV2Params) Validate() error {
-	if p.Sort == "" {
-		p.Sort = ListSortUpdatedAt
-	} else {
-		p.Sort = ListSort(strings.ToLower(string(p.Sort)))
-		switch p.Sort {
-		case ListSortUpdatedAt, ListSortCreatedAt, ListSortName:
-		default:
-			return errors.NewInvalidInputf(ErrCodeDashboardListInvalid,
-				"invalid sort %q — expected one of: updated_at, created_at, name", p.Sort)
-		}
-	}
-
-	if p.Order == "" {
-		p.Order = ListOrderDesc
-	} else {
-		p.Order = ListOrder(strings.ToLower(string(p.Order)))
-		switch p.Order {
-		case ListOrderAsc, ListOrderDesc:
-		default:
-			return errors.NewInvalidInputf(ErrCodeDashboardListInvalid,
-				"invalid order %q — expected asc or desc", p.Order)
-		}
-	}
-
-	if p.Limit == 0 {
-		p.Limit = DefaultListLimit
-	} else if p.Limit < 0 {
-		return errors.NewInvalidInputf(ErrCodeDashboardListInvalid,
-			"invalid limit %d — must be a positive integer", p.Limit)
-	} else if p.Limit > MaxListLimit {
-		p.Limit = MaxListLimit
-	}
-
-	if p.Offset < 0 {
-		return errors.NewInvalidInputf(ErrCodeDashboardListInvalid,
-			"invalid offset %d — must be a non-negative integer", p.Offset)
-	}
-
-	return nil
-}
-
-type listedDashboardV2 struct {
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID         valuer.UUID             `json:"orgId" required:"true"`
-	Locked        bool                    `json:"locked" required:"true"`
-	Source        Source                  `json:"source" required:"true"`
-	SchemaVersion string                  `json:"schemaVersion" required:"true"`
-	Name          string                  `json:"name" required:"true"`
-	Pinned        bool                    `json:"pinned" required:"true"`
-	Tags          []*tagtypes.GettableTag `json:"tags" required:"true" nullable:"false"`
-	Spec          listedDashboardV2Spec   `json:"spec" required:"true"`
-}
-
-type listedDashboardV2Spec struct {
-	Display *common.Display `json:"display,omitempty"`
-}
-
-type ListableDashboardV2 struct {
-	Dashboards []*listedDashboardV2 `json:"dashboards" required:"true" nullable:"false"`
-	Total      int64                `json:"total" required:"true"`
-}
-
-// DashboardListRow is the per-row shape Store.ListV2 returns. Bundles the
-// joined dashboard / public_dashboard / pinned_dashboard data so the module
-// layer can attach tags and assemble the gettable view.
-type DashboardListRow struct {
-	Dashboard *StorableDashboard
-	Public    *StorablePublicDashboard // nil if no public_dashboard row exists
-	Pinned    bool
-}
-
-func NewListableDashboardV2(rows []*DashboardListRow, total int64, tagsByEntity map[valuer.UUID][]*tagtypes.Tag) (*ListableDashboardV2, error) {
-	dashboards := make([]*listedDashboardV2, len(rows))
-	for i, r := range rows {
-		v2, err := r.Dashboard.ToDashboardV2(tagsByEntity[r.Dashboard.ID])
-		if err != nil {
-			return nil, err
-		}
-
-		dashboards[i] = &listedDashboardV2{
-			Identifiable:  v2.Identifiable,
-			TimeAuditable: v2.TimeAuditable,
-			UserAuditable: v2.UserAuditable,
-			OrgID:         v2.OrgID,
-			Locked:        v2.Locked,
-			Source:        v2.Source,
-			SchemaVersion: v2.SchemaVersion,
-			Name:          v2.Name,
-			Pinned:        r.Pinned,
-			Tags:          tagtypes.NewGettableTagsFromTags(v2.Tags),
-			Spec:          listedDashboardV2Spec{Display: v2.Spec.Display},
-		}
-	}
-	return &ListableDashboardV2{
-		Dashboards: dashboards,
-		Total:      total,
-	}, nil
-}

pkg/types/dashboardtypes/listfilter/constants.go

@@ -1,61 +0,0 @@
-package listfilter
-
-import (
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	qbtypesv5 "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-)
-
-var ErrCodeDashboardListFilterInvalid = errors.MustNewCode("dashboard_list_filter_invalid")
-
-// reservedOps lists the operators each reserved (column-level) DSL key accepts.
-// Any non-reserved key is treated as a tag key and uses tagKeyOps.
-var reservedOps = map[dashboardtypes.DSLKey]map[qbtypesv5.FilterOperator]struct{}{
-	dashboardtypes.DSLKeyName:        stringSearchOps(),
-	dashboardtypes.DSLKeyDescription: stringSearchOps(),
-	dashboardtypes.DSLKeyCreatedAt:   numericRangeOps(),
-	dashboardtypes.DSLKeyUpdatedAt:   numericRangeOps(),
-	dashboardtypes.DSLKeyCreatedBy:   stringSearchOps(),
-	dashboardtypes.DSLKeyLocked:      opsSet(qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual),
-	dashboardtypes.DSLKeyPublic:      opsSet(qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual),
-}
-
-// tagKeyOps applies to every non-reserved DSL key — the operator targets the
-// tag's value with an implicit case-insensitive match on the tag's key.
-var tagKeyOps = opsSet(
-	qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-	qbtypesv5.FilterOperatorLike, qbtypesv5.FilterOperatorNotLike,
-	qbtypesv5.FilterOperatorILike, qbtypesv5.FilterOperatorNotILike,
-	qbtypesv5.FilterOperatorContains, qbtypesv5.FilterOperatorNotContains,
-	qbtypesv5.FilterOperatorRegexp, qbtypesv5.FilterOperatorNotRegexp,
-	qbtypesv5.FilterOperatorIn, qbtypesv5.FilterOperatorNotIn,
-	qbtypesv5.FilterOperatorExists, qbtypesv5.FilterOperatorNotExists,
-)
-
-func stringSearchOps() map[qbtypesv5.FilterOperator]struct{} {
-	return opsSet(
-		qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-		qbtypesv5.FilterOperatorLike, qbtypesv5.FilterOperatorNotLike,
-		qbtypesv5.FilterOperatorILike, qbtypesv5.FilterOperatorNotILike,
-		qbtypesv5.FilterOperatorContains, qbtypesv5.FilterOperatorNotContains,
-		qbtypesv5.FilterOperatorRegexp, qbtypesv5.FilterOperatorNotRegexp,
-		qbtypesv5.FilterOperatorIn, qbtypesv5.FilterOperatorNotIn,
-	)
-}
-
-func numericRangeOps() map[qbtypesv5.FilterOperator]struct{} {
-	return opsSet(
-		qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-		qbtypesv5.FilterOperatorLessThan, qbtypesv5.FilterOperatorLessThanOrEq,
-		qbtypesv5.FilterOperatorGreaterThan, qbtypesv5.FilterOperatorGreaterThanOrEq,
-		qbtypesv5.FilterOperatorBetween, qbtypesv5.FilterOperatorNotBetween,
-	)
-}
-
-func opsSet(ops ...qbtypesv5.FilterOperator) map[qbtypesv5.FilterOperator]struct{} {
-	m := make(map[qbtypesv5.FilterOperator]struct{}, len(ops))
-	for _, op := range ops {
-		m[op] = struct{}{}
-	}
-	return m
-}

pkg/types/dashboardtypes/listfilter/listfilter.go

@@ -1,39 +0,0 @@
-package listfilter
-
-import (
-	"strings"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-)
-
-type Compiled struct {
-	SQL  string
-	Args []any
-}
-
-func Compile(query string, formatter sqlstore.SQLFormatter) (*Compiled, error) {
-	if len(query) == 0 {
-		return nil, nil
-	}
-
-	queryVisitor := newVisitor(formatter)
-	frag, syntaxErrs := queryVisitor.compile(query)
-
-	if len(syntaxErrs) > 0 {
-		return nil, errors.NewInvalidInputf(ErrCodeDashboardListFilterInvalid,
-			"invalid filter query: %s", strings.Join(syntaxErrs, "; "))
-	}
-	if len(queryVisitor.errors) > 0 {
-		return nil, errors.NewInvalidInputf(ErrCodeDashboardListFilterInvalid,
-			"invalid filter query: %s", strings.Join(queryVisitor.errors, "; "))
-	}
-	if frag == nil || frag.sql == "" {
-		return nil, nil
-	}
-
-	return &Compiled{
-		SQL:  frag.sql,
-		Args: frag.args,
-	}, nil
-}

pkg/types/dashboardtypes/listfilter/listfilter_test.go

@@ -1,507 +0,0 @@
-package listfilter
-
-import (
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/DATA-DOG/go-sqlmock"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/sqlstore/sqlstoretest"
-)
-
-type compileCase struct {
-	subtestName              string
-	dslQueryToCompile        string
-	nilExpected              bool
-	expectedSQL              string
-	expectedArgs             []any
-	expectedErrShouldContain string
-}
-
-func runCompileCases(t *testing.T, cases []compileCase) {
-	t.Helper()
-	for _, c := range cases {
-		t.Run(c.subtestName, func(t *testing.T) {
-			out, err := Compile(c.dslQueryToCompile, formatter(t))
-
-			if c.expectedErrShouldContain != "" {
-				require.Error(t, err)
-				assert.Contains(t, strings.ToLower(err.Error()), strings.ToLower(c.expectedErrShouldContain))
-				return
-			}
-
-			require.NoError(t, err)
-			if c.nilExpected {
-				assert.Nil(t, out)
-				return
-			}
-			require.NotNil(t, out)
-
-			if c.expectedSQL != "" {
-				assert.Equal(t, normalizeSQL(c.expectedSQL), normalizeSQL(out.SQL))
-			}
-			if c.expectedArgs != nil {
-				require.Len(t, out.Args, len(c.expectedArgs))
-				for i, want := range c.expectedArgs {
-					// time.Time values can carry semantically-equal instants
-					// in different *Location representations (UTC vs Local vs
-					// FixedZone). Compare via .Equal() instead of DeepEqual.
-					if wantT, ok := want.(time.Time); ok {
-						gotT, ok := out.Args[i].(time.Time)
-						require.True(t, ok, "arg[%d]: want time.Time, got %T", i, out.Args[i])
-						assert.True(t, wantT.Equal(gotT), "arg[%d]: want %s, got %s", i, wantT, gotT)
-						continue
-					}
-					assert.Equal(t, want, out.Args[i], "arg[%d]", i)
-				}
-			}
-		})
-	}
-}
-
-func TestCompile_Empty(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{subtestName: "empty query yields nil", dslQueryToCompile: "", nilExpected: true},
-	})
-}
-
-func TestCompile_Name(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "name =",
-			dslQueryToCompile: `name = 'overview'`,
-			expectedSQL:       `json_extract("dashboard"."data", '$.spec.display.name') = ?`,
-			expectedArgs:      []any{"overview"},
-		},
-		{
-			// QUOTED_TEXT in the grammar covers both '…' and "…" — visitor
-			// strips whichever quote pair surrounds the value.
-			subtestName:       "name = with double-quoted value",
-			dslQueryToCompile: `name = "something"`,
-			expectedSQL:       `json_extract("dashboard"."data", '$.spec.display.name') = ?`,
-			expectedArgs:      []any{"something"},
-		},
-		{
-			subtestName:       "name CONTAINS",
-			dslQueryToCompile: `name CONTAINS 'overview'`,
-			expectedSQL:       `json_extract("dashboard"."data", '$.spec.display.name') LIKE ?`,
-			expectedArgs:      []any{"%overview%"},
-		},
-		{
-			subtestName:       "name ILIKE — emitted as LOWER(col) LIKE LOWER(?) for dialect parity",
-			dslQueryToCompile: `name ILIKE 'Prod%'`,
-			expectedSQL:       `lower(json_extract("dashboard"."data", '$.spec.display.name')) LIKE LOWER(?)`,
-			expectedArgs:      []any{"Prod%"},
-		},
-		{
-			subtestName:       "CONTAINS escapes % in user input",
-			dslQueryToCompile: `name CONTAINS '50%'`,
-			expectedSQL:       `json_extract("dashboard"."data", '$.spec.display.name') LIKE ?`,
-			expectedArgs:      []any{`%50\%%`},
-		},
-	})
-}
-
-func TestCompile_CreatedByLocked(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "created_by LIKE",
-			dslQueryToCompile: `created_by LIKE '%@signoz.io'`,
-			expectedSQL:       `dashboard.created_by LIKE ?`,
-			expectedArgs:      []any{"%@signoz.io"},
-		},
-		{
-			subtestName:       "locked = true",
-			dslQueryToCompile: `locked = true`,
-			expectedSQL:       `dashboard.locked = ?`,
-			expectedArgs:      []any{true},
-		},
-	})
-}
-
-func TestCompile_Public(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{subtestName: "public = true", dslQueryToCompile: `public = true`, expectedSQL: `pd.id IS NOT NULL`},
-		{subtestName: "public = false", dslQueryToCompile: `public = false`, expectedSQL: `pd.id IS NULL`},
-		{subtestName: "public != true", dslQueryToCompile: `public != true`, expectedSQL: `pd.id IS NULL`},
-	})
-}
-
-func TestCompile_Timestamps(t *testing.T) {
-	ist := time.FixedZone("+05:30", 5*60*60+30*60)
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "created_at >= RFC3339",
-			dslQueryToCompile: `created_at >= '2026-03-10T00:00:00Z'`,
-			expectedSQL:       `dashboard.created_at >= ?`,
-			expectedArgs:      []any{time.Date(2026, 3, 10, 0, 0, 0, 0, time.UTC)},
-		},
-		{
-			subtestName:       "updated_at BETWEEN",
-			dslQueryToCompile: `updated_at BETWEEN '2026-03-10T00:00:00Z' AND '2026-03-20T00:00:00Z'`,
-			expectedSQL:       `dashboard.updated_at BETWEEN ? AND ?`,
-			expectedArgs: []any{
-				time.Date(2026, 3, 10, 0, 0, 0, 0, time.UTC),
-				time.Date(2026, 3, 20, 0, 0, 0, 0, time.UTC),
-			},
-		},
-		{
-			subtestName:       "created_at >= IST timestamp",
-			dslQueryToCompile: `created_at >= '2026-03-10T05:30:00+05:30'`,
-			expectedSQL:       `dashboard.created_at >= ?`,
-			expectedArgs:      []any{time.Date(2026, 3, 10, 5, 30, 0, 0, ist)},
-		},
-	})
-}
-
-// Tag operators wrap each predicate in EXISTS / NOT EXISTS. Any non-reserved
-// key is a tag key — `team = 'pulse'` matches a tag with key=team value=pulse,
-// `tag = 'prod'` matches a tag with key=tag value=prod, and so on.
-func TestCompile_Tag(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "team = wraps in EXISTS",
-			dslQueryToCompile: `team = 'pulse'`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"team", "pulse"},
-		},
-		{
-			subtestName:       "tag = is just a regular tag-key filter",
-			dslQueryToCompile: `tag = 'database'`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"tag", "database"},
-		},
-		{
-			subtestName:       "team != wraps in NOT EXISTS with positive inner",
-			dslQueryToCompile: `team != 'pulse'`,
-			expectedSQL: `
-				NOT EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"team", "pulse"},
-		},
-		{
-			subtestName:       "team IN — inner is single placeholder list on t.value",
-			dslQueryToCompile: `team IN ['pulse', 'events']`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value IN (?, ?)
-				)`,
-			expectedArgs: []any{"team", "pulse", "events"},
-		},
-		{
-			subtestName:       "team NOT IN",
-			dslQueryToCompile: `team NOT IN ['pulse', 'events']`,
-			expectedSQL: `
-				NOT EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value IN (?, ?)
-				)`,
-			expectedArgs: []any{"team", "pulse", "events"},
-		},
-		{
-			subtestName:       "team LIKE — wildcard on value",
-			dslQueryToCompile: `team LIKE 'pulse%'`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value LIKE ?
-				)`,
-			expectedArgs: []any{"team", "pulse%"},
-		},
-		{
-			subtestName:       "team NOT LIKE",
-			dslQueryToCompile: `team NOT LIKE 'staging%'`,
-			expectedSQL: `
-				NOT EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value LIKE ?
-				)`,
-			expectedArgs: []any{"team", "staging%"},
-		},
-		{
-			subtestName:       "database EXISTS — asserts a tag with key=database is present",
-			dslQueryToCompile: `database EXISTS`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-				)`,
-			expectedArgs: []any{"database"},
-		},
-		{
-			subtestName:       "database NOT EXISTS",
-			dslQueryToCompile: `database NOT EXISTS`,
-			expectedSQL: `
-				NOT EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-				)`,
-			expectedArgs: []any{"database"},
-		},
-		{
-			subtestName:       "tag-key matching is case-insensitive — TEAM lowercased",
-			dslQueryToCompile: `TEAM = 'pulse'`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"team", "pulse"},
-		},
-	})
-}
-
-func TestCompile_BooleanComposition(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "AND chain — flat arg list",
-			dslQueryToCompile: `locked = true AND public = true`,
-			expectedSQL:       `dashboard.locked = ? AND pd.id IS NOT NULL`,
-			expectedArgs:      []any{true},
-		},
-		{
-			subtestName:       "OR chain",
-			dslQueryToCompile: `locked = true OR public = true`,
-			expectedSQL:       `dashboard.locked = ? OR pd.id IS NOT NULL`,
-			expectedArgs:      []any{true},
-		},
-		{
-			subtestName:       "parens preserve precedence",
-			dslQueryToCompile: `(locked = true OR public = true) AND created_by = 'a@b.com'`,
-			expectedSQL:       `(dashboard.locked = ? OR pd.id IS NOT NULL) AND dashboard.created_by = ?`,
-			expectedArgs:      []any{true, "a@b.com"},
-		},
-	})
-}
-
-// Distinct from operator-suffix negation (NOT IN / NOT LIKE / NOT EXISTS).
-// Driven by the unaryExpression rule (`NOT? primary`), so NOT binds to
-// exactly one primary and only widens via parens.
-func TestCompile_NOT(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "NOT on a single comparison",
-			dslQueryToCompile: `NOT name = 'foo'`,
-			expectedSQL:       `NOT (json_extract("dashboard"."data", '$.spec.display.name') = ?)`,
-			expectedArgs:      []any{"foo"},
-		},
-		{
-			subtestName:       "NOT binds tightly to its primary in an AND chain",
-			dslQueryToCompile: `NOT name = 'foo' AND created_by = 'alice'`,
-			expectedSQL:       `NOT (json_extract("dashboard"."data", '$.spec.display.name') = ?) AND dashboard.created_by = ?`,
-			expectedArgs:      []any{"foo", "alice"},
-		},
-		{
-			subtestName:       "NOT applied to the second term in an AND chain",
-			dslQueryToCompile: `locked = true AND NOT name = 'foo'`,
-			expectedSQL:       `dashboard.locked = ? AND NOT (json_extract("dashboard"."data", '$.spec.display.name') = ?)`,
-			expectedArgs:      []any{true, "foo"},
-		},
-		{
-			subtestName:       "NOT around a parenthesized OR",
-			dslQueryToCompile: `NOT (locked = true OR public = true)`,
-			expectedSQL:       `NOT ((dashboard.locked = ? OR pd.id IS NOT NULL))`,
-			expectedArgs:      []any{true},
-		},
-		{
-			subtestName:       "double NOT via parens",
-			dslQueryToCompile: `NOT (NOT name = 'foo')`,
-			expectedSQL:       `NOT ((NOT (json_extract("dashboard"."data", '$.spec.display.name') = ?)))`,
-			expectedArgs:      []any{"foo"},
-		},
-		{
-			subtestName:       "NOT on a tag equality",
-			dslQueryToCompile: `NOT team = 'pulse'`,
-			expectedSQL: `
-				NOT (
-					EXISTS (
-						SELECT 1 FROM tag_relation tr
-						JOIN tag t ON t.id = tr.tag_id
-						WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-						AND LOWER(t.key) = LOWER(?)
-						AND t.value = ?
-					)
-				)`,
-			expectedArgs: []any{"team", "pulse"},
-		},
-		{
-			subtestName:       "NOT team = ... AND name = ...",
-			dslQueryToCompile: `NOT team = 'pulse' AND name = 'overview'`,
-			expectedSQL: `
-				NOT (
-					EXISTS (
-						SELECT 1 FROM tag_relation tr
-						JOIN tag t ON t.id = tr.tag_id
-						WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-						AND LOWER(t.key) = LOWER(?)
-						AND t.value = ?
-					)
-				)
-				AND json_extract("dashboard"."data", '$.spec.display.name') = ?`,
-			expectedArgs: []any{"team", "pulse", "overview"},
-		},
-	})
-}
-
-func TestCompile_ComplexExamples(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:       "name CONTAINS + tag LIKE + created_by + database =",
-			dslQueryToCompile: `name CONTAINS 'overview' AND tag LIKE 'prod%' AND created_by = 'naman.verma@signoz.io' AND database = 'mongo'`,
-			expectedSQL: `
-				json_extract("dashboard"."data", '$.spec.display.name') LIKE ?
-				AND EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value LIKE ?
-				)
-				AND dashboard.created_by = ?
-				AND EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value = ?
-				)`,
-			expectedArgs: []any{"%overview%", "tag", "prod%", "naman.verma@signoz.io", "database", "mongo"},
-		},
-		{
-			subtestName:       "team IN AND database EXISTS",
-			dslQueryToCompile: `team IN ['pulse', 'events'] AND database EXISTS`,
-			expectedSQL: `
-				EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-					AND t.value IN (?, ?)
-				)
-				AND EXISTS (
-					SELECT 1 FROM tag_relation tr
-					JOIN tag t ON t.id = tr.tag_id
-					WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-					AND LOWER(t.key) = LOWER(?)
-				)`,
-			expectedArgs: []any{"team", "pulse", "events", "database"},
-		},
-		{
-			subtestName:       "nested OR / AND with parens",
-			dslQueryToCompile: `(database IN ['sql', 'redis', 'mongo'] OR name LIKE '%database%') AND (team = 'pulse' OR name LIKE '%pulse%')`,
-			expectedSQL: `
-				(
-					EXISTS (
-						SELECT 1 FROM tag_relation tr
-						JOIN tag t ON t.id = tr.tag_id
-						WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-						AND LOWER(t.key) = LOWER(?)
-						AND t.value IN (?, ?, ?)
-					)
-					OR json_extract("dashboard"."data", '$.spec.display.name') LIKE ?
-				)
-				AND (
-					EXISTS (
-						SELECT 1 FROM tag_relation tr
-						JOIN tag t ON t.id = tr.tag_id
-						WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id
-						AND LOWER(t.key) = LOWER(?)
-						AND t.value = ?
-					)
-					OR json_extract("dashboard"."data", '$.spec.display.name') LIKE ?
-				)`,
-			expectedArgs: []any{"database", "sql", "redis", "mongo", "%database%", "team", "pulse", "%pulse%"},
-		},
-	})
-}
-
-func TestCompile_Rejections(t *testing.T) {
-	runCompileCases(t, []compileCase{
-		{
-			subtestName:              "rejects op outside per-reserved-key allowlist",
-			dslQueryToCompile:        `name BETWEEN 'a' AND 'z'`,
-			expectedErrShouldContain: "operator",
-		},
-		{
-			subtestName:              "rejects BETWEEN on a tag key",
-			dslQueryToCompile:        `team BETWEEN 'a' AND 'z'`,
-			expectedErrShouldContain: "operator",
-		},
-		{
-			subtestName:              "rejects non-bool on locked",
-			dslQueryToCompile:        `locked = 'yes'`,
-			expectedErrShouldContain: "boolean",
-		},
-		{
-			subtestName:              "rejects non-RFC3339 timestamp",
-			dslQueryToCompile:        `created_at >= 'not-a-date'`,
-			expectedErrShouldContain: "RFC3339",
-		},
-		{
-			subtestName:              "rejects REGEXP — not yet supported",
-			dslQueryToCompile:        `name REGEXP '.*'`,
-			expectedErrShouldContain: "REGEXP",
-		},
-		{
-			subtestName:              "rejects syntax error from grammar",
-			dslQueryToCompile:        `name = `,
-			expectedErrShouldContain: "syntax",
-		},
-	})
-}
-
-func formatter(t *testing.T) sqlstore.SQLFormatter {
-	t.Helper()
-	p := sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual)
-	return p.Formatter()
-}
-
-func normalizeSQL(s string) string {
-	s = strings.Join(strings.Fields(s), " ")
-	s = strings.ReplaceAll(s, "( ", "(")
-	s = strings.ReplaceAll(s, " )", ")")
-	return s
-}

pkg/types/dashboardtypes/listfilter/visitor.go

@@ -1,592 +0,0 @@
-package listfilter
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/parser/filterquery"
-	grammar "github.com/SigNoz/signoz/pkg/parser/filterquery/grammar"
-	"github.com/SigNoz/signoz/pkg/sqlstore"
-	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
-	qbtypesv5 "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
-	"github.com/antlr4-go/antlr/v4"
-)
-
-// fragment is one composable WHERE fragment. sql uses `?` placeholders;
-// args lines up positionally with the placeholders.
-type fragment struct {
-	sql  string
-	args []any
-}
-
-func newFragment(sql string, args ...any) *fragment {
-	return &fragment{sql: sql, args: args}
-}
-
-type visitor struct {
-	grammar.BaseFilterQueryVisitor
-	formatter sqlstore.SQLFormatter
-	errors    []string
-}
-
-func newVisitor(formatter sqlstore.SQLFormatter) *visitor {
-	return &visitor{
-		formatter: formatter,
-	}
-}
-
-// Emitted WHERE fragment uses aliases `dashboard` and `pd` (public_dashboard).
-func (v *visitor) compile(query string) (*fragment, []string) {
-	tree, _, collector := filterquery.Parse(query)
-	if len(collector.Errors) > 0 {
-		return nil, collector.Errors
-	}
-	frag, _ := v.visit(tree).(*fragment)
-	return frag, nil
-}
-
-func (v *visitor) visit(tree antlr.ParseTree) any {
-	if tree == nil {
-		return nil
-	}
-	return tree.Accept(v)
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// methods from grammar.BaseFilterQueryVisitor that are overridden
-// ════════════════════════════════════════════════════════════════════════
-
-func (v *visitor) VisitQuery(ctx *grammar.QueryContext) any {
-	return v.visit(ctx.Expression())
-}
-
-func (v *visitor) VisitExpression(ctx *grammar.ExpressionContext) any {
-	return v.visit(ctx.OrExpression())
-}
-
-func (v *visitor) VisitOrExpression(ctx *grammar.OrExpressionContext) any {
-	parts := ctx.AllAndExpression()
-	frags := make([]*fragment, 0, len(parts))
-	for _, p := range parts {
-		if f, ok := v.visit(p).(*fragment); ok && f != nil {
-			frags = append(frags, f)
-		}
-	}
-	return joinFragments(frags, "OR")
-}
-
-func (v *visitor) VisitAndExpression(ctx *grammar.AndExpressionContext) any {
-	parts := ctx.AllUnaryExpression()
-	frags := make([]*fragment, 0, len(parts))
-	for _, p := range parts {
-		if f, ok := v.visit(p).(*fragment); ok && f != nil {
-			frags = append(frags, f)
-		}
-	}
-	return joinFragments(frags, "AND")
-}
-
-func (v *visitor) VisitUnaryExpression(ctx *grammar.UnaryExpressionContext) any {
-	f, _ := v.visit(ctx.Primary()).(*fragment)
-	if f == nil {
-		return nil
-	}
-	if ctx.NOT() != nil {
-		return newFragment("NOT ("+f.sql+")", f.args...)
-	}
-	return f
-}
-
-func (v *visitor) VisitPrimary(ctx *grammar.PrimaryContext) any {
-	if ctx.OrExpression() != nil {
-		f, _ := v.visit(ctx.OrExpression()).(*fragment)
-		if f == nil {
-			return nil
-		}
-		return newFragment("("+f.sql+")", f.args...)
-	}
-	if ctx.Comparison() != nil {
-		return v.visit(ctx.Comparison())
-	}
-	// Bare keys, values, full text, and function calls are not part of the
-	// dashboard list DSL.
-	v.addErr("unsupported expression %q — every term must be of the form `key OP value`", ctx.GetText())
-	return nil
-}
-
-// VisitComparison dispatches a single `key OP value` term. A key that matches
-// a reserved DSL key (name, description, etc.) becomes a column-level
-// predicate; any other identifier is treated as a tag key — the operator
-// applies to the tag's value, with a case-insensitive match on the tag's key.
-func (v *visitor) VisitComparison(ctx *grammar.ComparisonContext) any {
-	key, ok := v.parseKey(ctx)
-	if !ok {
-		return nil
-	}
-
-	op, ok := v.opFromContext(ctx)
-	if !ok {
-		return nil
-	}
-
-	if reservedOpSet, isReserved := reservedOps[dashboardtypes.DSLKey(key)]; isReserved {
-		if _, allowed := reservedOpSet[op]; !allowed {
-			v.addErr("operator %s is not allowed for key %q", opName(op), key)
-			return nil
-		}
-		switch dashboardtypes.DSLKey(key) {
-		case dashboardtypes.DSLKeyName:
-			return v.emitJSONStringComparison(ctx, op, "$.spec.display.name")
-		case dashboardtypes.DSLKeyDescription:
-			return v.emitJSONStringComparison(ctx, op, "$.spec.display.description")
-		case dashboardtypes.DSLKeyCreatedAt:
-			return v.emitTimestampComparison(ctx, op, "dashboard.created_at")
-		case dashboardtypes.DSLKeyUpdatedAt:
-			return v.emitTimestampComparison(ctx, op, "dashboard.updated_at")
-		case dashboardtypes.DSLKeyCreatedBy:
-			return v.emitStringComparison(ctx, op, "dashboard.created_by")
-		case dashboardtypes.DSLKeyLocked:
-			return v.emitBoolComparison(ctx, op, "dashboard.locked")
-		case dashboardtypes.DSLKeyPublic:
-			return v.emitPublicComparison(ctx, op)
-		}
-	}
-
-	if _, allowed := tagKeyOps[op]; !allowed {
-		v.addErr("operator %s is not allowed on a tag-key filter", opName(op))
-		return nil
-	}
-	return v.emitTagComparison(ctx, op, key)
-}
-
-func (v *visitor) parseKey(ctx *grammar.ComparisonContext) (string, bool) {
-	keyText := strings.ToLower(strings.TrimSpace(ctx.Key().GetText()))
-	if keyText == "" {
-		v.addErr("filter key cannot be empty")
-		return "", false
-	}
-	return keyText, true
-}
-
-func (v *visitor) opFromContext(ctx *grammar.ComparisonContext) (qbtypesv5.FilterOperator, bool) {
-	switch {
-	case ctx.EQUALS() != nil:
-		return qbtypesv5.FilterOperatorEqual, true
-	case ctx.NOT_EQUALS() != nil, ctx.NEQ() != nil:
-		return qbtypesv5.FilterOperatorNotEqual, true
-	case ctx.LT() != nil:
-		return qbtypesv5.FilterOperatorLessThan, true
-	case ctx.LE() != nil:
-		return qbtypesv5.FilterOperatorLessThanOrEq, true
-	case ctx.GT() != nil:
-		return qbtypesv5.FilterOperatorGreaterThan, true
-	case ctx.GE() != nil:
-		return qbtypesv5.FilterOperatorGreaterThanOrEq, true
-	case ctx.BETWEEN() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotBetween, true
-		}
-		return qbtypesv5.FilterOperatorBetween, true
-	case ctx.LIKE() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotLike, true
-		}
-		return qbtypesv5.FilterOperatorLike, true
-	case ctx.ILIKE() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotILike, true
-		}
-		return qbtypesv5.FilterOperatorILike, true
-	case ctx.CONTAINS() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotContains, true
-		}
-		return qbtypesv5.FilterOperatorContains, true
-	case ctx.REGEXP() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotRegexp, true
-		}
-		return qbtypesv5.FilterOperatorRegexp, true
-	case ctx.InClause() != nil:
-		return qbtypesv5.FilterOperatorIn, true
-	case ctx.NotInClause() != nil:
-		return qbtypesv5.FilterOperatorNotIn, true
-	case ctx.EXISTS() != nil:
-		if ctx.NOT() != nil {
-			return qbtypesv5.FilterOperatorNotExists, true
-		}
-		return qbtypesv5.FilterOperatorExists, true
-	}
-	v.addErr("could not determine operator in expression %q", ctx.GetText())
-	return qbtypesv5.FilterOperatorUnknown, false
-}
-
-// ─── per-key emitters ────────────────────────────────────────────────────────
-
-func (v *visitor) emitJSONStringComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, jsonPath string) *fragment {
-	colExpr := string(v.formatter.JSONExtractString("dashboard.data", jsonPath))
-	return v.emitStringOp(ctx, op, colExpr, string(dashboardtypes.DSLKeyName))
-}
-
-func (v *visitor) emitStringComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, colExpr string) *fragment {
-	return v.emitStringOp(ctx, op, colExpr, string(dashboardtypes.DSLKeyCreatedBy))
-}
-
-// emitStringOp covers all the operators the spec allows on text-shaped keys
-// (name, description, created_by). Tag uses a separate emitter that wraps each
-// produced fragment in an EXISTS subquery.
-func (v *visitor) emitStringOp(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, colExpr, keyForErr string) *fragment {
-	switch op {
-	case qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-		qbtypesv5.FilterOperatorLike, qbtypesv5.FilterOperatorNotLike:
-		val, ok := v.singleString(ctx, keyForErr)
-		if !ok {
-			return nil
-		}
-		return newFragment(colExpr+" "+opName(op)+" ?", val)
-	case qbtypesv5.FilterOperatorILike, qbtypesv5.FilterOperatorNotILike:
-		val, ok := v.singleString(ctx, keyForErr)
-		if !ok {
-			return nil
-		}
-		// SQLite has no ILIKE keyword and Postgres LIKE is case-sensitive — emit
-		// LOWER(col) LIKE LOWER(?) so behavior is identical on both dialects.
-		lowerCol := string(v.formatter.LowerExpression(colExpr))
-		return newFragment(lowerCol+" "+opName(iLikeToLike(op))+" LOWER(?)", val)
-	case qbtypesv5.FilterOperatorContains, qbtypesv5.FilterOperatorNotContains:
-		val, ok := v.singleString(ctx, keyForErr)
-		if !ok {
-			return nil
-		}
-		return newFragment(colExpr+" "+opName(containsToLike(op))+" ?", "%"+escapeLike(val)+"%")
-	case qbtypesv5.FilterOperatorRegexp, qbtypesv5.FilterOperatorNotRegexp:
-		v.addErr("REGEXP filtering on %q is not yet supported", keyForErr)
-		return nil
-	case qbtypesv5.FilterOperatorIn, qbtypesv5.FilterOperatorNotIn:
-		vals, ok := v.stringList(ctx, keyForErr)
-		if !ok {
-			return nil
-		}
-		return inFragment(colExpr, op, vals)
-	}
-	v.addErr("operator %s on %q is not implemented", opName(op), keyForErr)
-	return nil
-}
-
-func (v *visitor) emitTimestampComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, colExpr string) *fragment {
-	switch op {
-	case qbtypesv5.FilterOperatorEqual, qbtypesv5.FilterOperatorNotEqual,
-		qbtypesv5.FilterOperatorLessThan, qbtypesv5.FilterOperatorLessThanOrEq,
-		qbtypesv5.FilterOperatorGreaterThan, qbtypesv5.FilterOperatorGreaterThanOrEq:
-		t, ok := v.singleTimestamp(ctx)
-		if !ok {
-			return nil
-		}
-		return newFragment(colExpr+" "+opName(op)+" ?", t)
-	case qbtypesv5.FilterOperatorBetween, qbtypesv5.FilterOperatorNotBetween:
-		ts, ok := v.twoTimestamps(ctx)
-		if !ok {
-			return nil
-		}
-		return newFragment(colExpr+" "+opName(op)+" ? AND ?", ts[0], ts[1])
-	}
-	v.addErr("operator %s on timestamp is not implemented", opName(op))
-	return nil
-}
-
-func (v *visitor) emitBoolComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, colExpr string) *fragment {
-	b, ok := v.singleBool(ctx)
-	if !ok {
-		return nil
-	}
-	return newFragment(colExpr+" "+opName(op)+" ?", b)
-}
-
-// emitPublicComparison renders `public = true|false` against the LEFT-joined
-// public_dashboard alias `pd`. The spec says public is a virtual column whose
-// truthiness is the existence of a row in public_dashboard.
-func (v *visitor) emitPublicComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator) *fragment {
-	b, ok := v.singleBool(ctx)
-	if !ok {
-		return nil
-	}
-	want := b
-	if op == qbtypesv5.FilterOperatorNotEqual {
-		want = !b
-	}
-	if want {
-		return newFragment("pd.id IS NOT NULL")
-	}
-	return newFragment("pd.id IS NULL")
-}
-
-// TODO: drop the extra quotes once coretypes.Kind stops being double-encoded
-// in the tag_relation.kind column.
-const tagSubqueryPrefix = "SELECT 1 FROM tag_relation tr JOIN tag t ON t.id = tr.tag_id " +
-	`WHERE tr.kind = '"dashboard"' AND tr.resource_id = dashboard.id ` +
-	"AND LOWER(t.key) = LOWER(?)"
-
-// emitTagComparison wraps the inner predicate in EXISTS (or NOT EXISTS for the
-// negated operators). The inner predicate matches the tag's key
-// case-insensitively and applies the user's operator to the tag's value.
-// EXISTS / NOT EXISTS skip the value predicate — they assert the existence
-// (or absence) of any tag with the given key.
-func (v *visitor) emitTagComparison(ctx *grammar.ComparisonContext, op qbtypesv5.FilterOperator, key string) *fragment {
-	if op == qbtypesv5.FilterOperatorExists || op == qbtypesv5.FilterOperatorNotExists {
-		wrapper := "EXISTS"
-		if op == qbtypesv5.FilterOperatorNotExists {
-			wrapper = "NOT EXISTS"
-		}
-		return newFragment(wrapper+" ("+tagSubqueryPrefix+")", key)
-	}
-
-	// All other tag operators take the positive form of the value predicate
-	// and toggle the EXISTS wrapper for negation. Inverse() flips Not<X> → <X>.
-	negated := op.IsNegativeOperator()
-	posOp := op
-	if negated {
-		posOp = op.Inverse()
-	}
-	inner := v.emitStringOp(ctx, posOp, "t.value", key)
-	if inner == nil {
-		return nil
-	}
-	wrapper := "EXISTS"
-	if negated {
-		wrapper = "NOT EXISTS"
-	}
-	args := append([]any{key}, inner.args...)
-	return newFragment(wrapper+" ("+tagSubqueryPrefix+" AND "+inner.sql+")", args...)
-}
-
-// ─── value extraction helpers ───────────────────────────────────────────────
-
-func (v *visitor) addErr(format string, args ...any) {
-	v.errors = append(v.errors, fmt.Sprintf(format, args...))
-}
-
-func (v *visitor) singleString(ctx *grammar.ComparisonContext, keyForErr string) (string, bool) {
-	values := ctx.AllValue()
-	if len(values) != 1 {
-		v.addErr("expected exactly one value for %q", keyForErr)
-		return "", false
-	}
-	return v.stringValue(values[0], keyForErr)
-}
-
-func (v *visitor) singleBool(ctx *grammar.ComparisonContext) (bool, bool) {
-	values := ctx.AllValue()
-	if len(values) != 1 {
-		v.addErr("expected a single boolean (true/false)")
-		return false, false
-	}
-	return v.boolValue(values[0])
-}
-
-func (v *visitor) singleTimestamp(ctx *grammar.ComparisonContext) (time.Time, bool) {
-	values := ctx.AllValue()
-	if len(values) != 1 {
-		v.addErr("expected a single RFC3339 timestamp")
-		return time.Time{}, false
-	}
-	return v.timestampValue(values[0])
-}
-
-func (v *visitor) twoTimestamps(ctx *grammar.ComparisonContext) ([2]time.Time, bool) {
-	values := ctx.AllValue()
-	if len(values) != 2 {
-		v.addErr("BETWEEN expects two RFC3339 timestamps")
-		return [2]time.Time{}, false
-	}
-	a, ok1 := v.timestampValue(values[0])
-	b, ok2 := v.timestampValue(values[1])
-	if !ok1 || !ok2 {
-		return [2]time.Time{}, false
-	}
-	return [2]time.Time{a, b}, true
-}
-
-func (v *visitor) stringList(ctx *grammar.ComparisonContext, keyForErr string) ([]string, bool) {
-	var valuesCtx []grammar.IValueContext
-	switch {
-	case ctx.InClause() != nil:
-		ic := ctx.InClause()
-		if ic.ValueList() != nil {
-			valuesCtx = ic.ValueList().AllValue()
-		} else {
-			valuesCtx = []grammar.IValueContext{ic.Value()}
-		}
-	case ctx.NotInClause() != nil:
-		nc := ctx.NotInClause()
-		if nc.ValueList() != nil {
-			valuesCtx = nc.ValueList().AllValue()
-		} else {
-			valuesCtx = []grammar.IValueContext{nc.Value()}
-		}
-	default:
-		v.addErr("IN clause is missing for %q", keyForErr)
-		return nil, false
-	}
-	if len(valuesCtx) == 0 {
-		v.addErr("IN list for %q is empty", keyForErr)
-		return nil, false
-	}
-	out := make([]string, 0, len(valuesCtx))
-	for _, vc := range valuesCtx {
-		s, ok := v.stringValue(vc, keyForErr)
-		if !ok {
-			return nil, false
-		}
-		out = append(out, s)
-	}
-	return out, true
-}
-
-func (v *visitor) stringValue(ctx grammar.IValueContext, keyForErr string) (string, bool) {
-	if ctx.QUOTED_TEXT() != nil {
-		return trimQuotes(ctx.QUOTED_TEXT().GetText()), true
-	}
-	if ctx.KEY() != nil {
-		// Bare tokens are accepted as strings, mirroring the FilterQuery lexer's
-		// treatment of unquoted identifiers on the value side.
-		return ctx.KEY().GetText(), true
-	}
-	v.addErr("expected a string value for %q, got %q", keyForErr, ctx.GetText())
-	return "", false
-}
-
-func (v *visitor) boolValue(ctx grammar.IValueContext) (bool, bool) {
-	if ctx.BOOL() == nil {
-		v.addErr("expected a boolean (true/false), got %q", ctx.GetText())
-		return false, false
-	}
-	return strings.EqualFold(ctx.BOOL().GetText(), "true"), true
-}
-
-func (v *visitor) timestampValue(ctx grammar.IValueContext) (time.Time, bool) {
-	if ctx.QUOTED_TEXT() == nil {
-		v.addErr("expected an RFC3339 timestamp string, got %q", ctx.GetText())
-		return time.Time{}, false
-	}
-	raw := trimQuotes(ctx.QUOTED_TEXT().GetText())
-	t, err := time.Parse(time.RFC3339, raw)
-	if err != nil {
-		v.addErr("invalid RFC3339 timestamp %q: %s", raw, err.Error())
-		return time.Time{}, false
-	}
-	return t, true
-}
-
-// ─── fragment helpers ────────────────────────────────────────────────────────
-
-func joinFragments(frags []*fragment, conn string) *fragment {
-	if len(frags) == 0 {
-		return nil
-	}
-	if len(frags) == 1 {
-		return frags[0]
-	}
-	parts := make([]string, len(frags))
-	args := make([]any, 0)
-	for i, f := range frags {
-		parts[i] = f.sql
-		args = append(args, f.args...)
-	}
-	return newFragment(strings.Join(parts, " "+conn+" "), args...)
-}
-
-func inFragment(colExpr string, op qbtypesv5.FilterOperator, vals []string) *fragment {
-	placeholders := strings.Repeat("?, ", len(vals))
-	placeholders = placeholders[:len(placeholders)-2]
-	args := make([]any, len(vals))
-	for i, s := range vals {
-		args[i] = s
-	}
-	return newFragment(colExpr+" "+opName(op)+" ("+placeholders+")", args...)
-}
-
-// opName returns the user-facing spelling of a FilterOperator. For the
-// operators we emit directly into SQL (=, !=, <, LIKE, IN, BETWEEN, …) the
-// spelling doubles as the SQL keyword. For the operators we don't emit
-// directly (ILIKE, CONTAINS, REGEXP, EXISTS, NOT EXISTS) it's only used in
-// error messages.
-func opName(op qbtypesv5.FilterOperator) string {
-	switch op {
-	case qbtypesv5.FilterOperatorEqual:
-		return "="
-	case qbtypesv5.FilterOperatorNotEqual:
-		return "!="
-	case qbtypesv5.FilterOperatorLessThan:
-		return "<"
-	case qbtypesv5.FilterOperatorLessThanOrEq:
-		return "<="
-	case qbtypesv5.FilterOperatorGreaterThan:
-		return ">"
-	case qbtypesv5.FilterOperatorGreaterThanOrEq:
-		return ">="
-	case qbtypesv5.FilterOperatorBetween:
-		return "BETWEEN"
-	case qbtypesv5.FilterOperatorNotBetween:
-		return "NOT BETWEEN"
-	case qbtypesv5.FilterOperatorLike:
-		return "LIKE"
-	case qbtypesv5.FilterOperatorNotLike:
-		return "NOT LIKE"
-	case qbtypesv5.FilterOperatorILike:
-		return "ILIKE"
-	case qbtypesv5.FilterOperatorNotILike:
-		return "NOT ILIKE"
-	case qbtypesv5.FilterOperatorContains:
-		return "CONTAINS"
-	case qbtypesv5.FilterOperatorNotContains:
-		return "NOT CONTAINS"
-	case qbtypesv5.FilterOperatorRegexp:
-		return "REGEXP"
-	case qbtypesv5.FilterOperatorNotRegexp:
-		return "NOT REGEXP"
-	case qbtypesv5.FilterOperatorIn:
-		return "IN"
-	case qbtypesv5.FilterOperatorNotIn:
-		return "NOT IN"
-	case qbtypesv5.FilterOperatorExists:
-		return "EXISTS"
-	case qbtypesv5.FilterOperatorNotExists:
-		return "NOT EXISTS"
-	}
-	return "?"
-}
-
-// iLikeToLike maps ILIKE → LIKE for the LOWER(col) LIKE LOWER(?) emission.
-func iLikeToLike(op qbtypesv5.FilterOperator) qbtypesv5.FilterOperator {
-	if op == qbtypesv5.FilterOperatorNotILike {
-		return qbtypesv5.FilterOperatorNotLike
-	}
-	return qbtypesv5.FilterOperatorLike
-}
-
-// containsToLike maps CONTAINS → LIKE for the LIKE '%val%' emission.
-func containsToLike(op qbtypesv5.FilterOperator) qbtypesv5.FilterOperator {
-	if op == qbtypesv5.FilterOperatorNotContains {
-		return qbtypesv5.FilterOperatorNotLike
-	}
-	return qbtypesv5.FilterOperatorLike
-}
-
-// escapeLike escapes the LIKE meta-characters % and _ in user input so that a
-// CONTAINS query of `50%` doesn't match every value containing `50`.
-func escapeLike(s string) string {
-	r := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`)
-	return r.Replace(s)
-}
-
-func trimQuotes(s string) string {
-	if len(s) >= 2 {
-		if (s[0] == '"' && s[len(s)-1] == '"') || (s[0] == '\'' && s[len(s)-1] == '\'') {
-			s = s[1 : len(s)-1]
-		}
-	}
-	s = strings.ReplaceAll(s, `\\`, `\`)
-	s = strings.ReplaceAll(s, `\'`, `'`)
-	return s
-}

pkg/types/dashboardtypes/perses_dashboard.go

@@ -1,453 +0,0 @@
-package dashboardtypes
-
-import (
-	"bytes"
-	"crypto/rand"
-	"encoding/json"
-	"strings"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/SigNoz/signoz/pkg/types/tagtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/perses/perses/pkg/model/api/v1/common"
-	"github.com/swaggest/jsonschema-go"
-	jsonpatch "gopkg.in/evanphx/json-patch.v4"
-	"k8s.io/apimachinery/pkg/util/validation"
-)
-
-const (
-	SchemaVersion          = "v6"
-	MaxTagsPerDashboard    = 10
-	dashboardNameSuffixLen = 8
-)
-
-type DSLKey string
-
-const (
-	DSLKeyName        DSLKey = "name"
-	DSLKeyDescription DSLKey = "description"
-	DSLKeyCreatedAt   DSLKey = "created_at"
-	DSLKeyUpdatedAt   DSLKey = "updated_at"
-	DSLKeyCreatedBy   DSLKey = "created_by"
-	DSLKeyLocked      DSLKey = "locked"
-	DSLKeyPublic      DSLKey = "public"
-	DSLKeySource      DSLKey = "source"
-)
-
-// reservedDSLKeys are dashboard column-level filter names in the list-query DSL.
-// A tag whose key collides with one of these would make the DSL ambiguous, so
-// they're rejected (case-insensitively) at write time.
-var reservedDSLKeys = map[DSLKey]struct{}{
-	DSLKeyName:        {},
-	DSLKeyDescription: {},
-	DSLKeyCreatedAt:   {},
-	DSLKeyUpdatedAt:   {},
-	DSLKeyCreatedBy:   {},
-	DSLKeyLocked:      {},
-	DSLKeyPublic:      {},
-	DSLKeySource:      {},
-}
-
-type DashboardV2 struct {
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID  valuer.UUID `json:"orgId" required:"true"`
-	Locked bool        `json:"locked" required:"true"`
-	Source Source      `json:"source" required:"true"`
-
-	DashboardV2MetadataBase
-	Name string          `json:"name" required:"true"`
-	Tags []*tagtypes.Tag `json:"tags" required:"true"`
-	Spec DashboardSpec   `json:"spec" required:"true"`
-}
-
-func (d *DashboardV2) CanUpdate() error {
-	if d.Source == SourceIntegration {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "integration dashboards cannot be modified")
-	}
-	if d.Locked {
-		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot update a locked dashboard, please unlock the dashboard to update")
-	}
-	return nil
-}
-
-func (d *DashboardV2) Update(updateable UpdateableDashboardV2, updatedBy string, resolvedTags []*tagtypes.Tag) error {
-	if err := d.CanUpdate(); err != nil {
-		return err
-	}
-	if updateable.Name != d.Name {
-		return errors.NewInvalidInputf(ErrCodeDashboardImmutable, "name is immutable; cannot change from %q to %q", d.Name, updateable.Name)
-	}
-	d.DashboardV2MetadataBase = updateable.DashboardV2MetadataBase
-	d.Tags = resolvedTags
-	d.Spec = updateable.Spec
-	d.UpdatedBy = updatedBy
-	d.UpdatedAt = time.Now()
-	return nil
-}
-
-func (d *DashboardV2) CanLockUnlock(isAdmin bool, updatedBy string) error {
-	if d.Source == SourceIntegration {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "integration dashboards cannot be locked or unlocked")
-	}
-	if d.Source == SourceSystem {
-		return errors.Newf(errors.TypeInvalidInput, ErrCodeDashboardImmutable, "system dashboards cannot be locked or unlocked")
-	}
-	if d.CreatedBy != updatedBy && !isAdmin {
-		return errors.Newf(errors.TypeForbidden, errors.CodeForbidden, "you are not authorized to lock/unlock this dashboard")
-	}
-	return nil
-}
-
-func (d *DashboardV2) LockUnlock(lock bool, isAdmin bool, updatedBy string) error {
-	if err := d.CanLockUnlock(isAdmin, updatedBy); err != nil {
-		return err
-	}
-	d.Locked = lock
-	d.UpdatedBy = updatedBy
-	d.UpdatedAt = time.Now()
-	return nil
-}
-
-type DashboardV2MetadataBase struct {
-	SchemaVersion string `json:"schemaVersion" required:"true"`
-	Image         string `json:"image,omitempty"`
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Postable
-// ════════════════════════════════════════════════════════════════════════
-
-type PostableDashboardV2 struct {
-	DashboardV2MetadataBase
-	Name         string                 `json:"name,omitempty"`
-	GenerateName bool                   `json:"generateName,omitempty"`
-	Tags         []tagtypes.PostableTag `json:"tags" required:"true"`
-	Spec         DashboardSpec          `json:"spec" required:"true"`
-}
-
-func (postable PostableDashboardV2) NewDashboardV2(orgID valuer.UUID, createdBy string, source Source) *DashboardV2 {
-	now := time.Now()
-
-	name := postable.Name
-	if postable.GenerateName {
-		name = generateDashboardName(postable.Spec.Display.Name)
-	}
-
-	return &DashboardV2{
-		Identifiable:            types.Identifiable{ID: valuer.GenerateUUID()},
-		TimeAuditable:           types.TimeAuditable{CreatedAt: now, UpdatedAt: now},
-		UserAuditable:           types.UserAuditable{CreatedBy: createdBy, UpdatedBy: createdBy},
-		OrgID:                   orgID,
-		Locked:                  source == SourceIntegration,
-		Source:                  source,
-		DashboardV2MetadataBase: postable.DashboardV2MetadataBase,
-		Name:                    name,
-		Tags:                    tagtypes.NewTagsFromPostableTags(orgID, coretypes.KindDashboard, postable.Tags),
-		Spec:                    postable.Spec,
-	}
-}
-
-func (p *PostableDashboardV2) UnmarshalJSON(data []byte) error {
-	dec := json.NewDecoder(bytes.NewReader(data))
-	dec.DisallowUnknownFields()
-	type alias PostableDashboardV2
-	var tmp alias
-	if err := dec.Decode(&tmp); err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s", err.Error())
-	}
-	*p = PostableDashboardV2(tmp)
-	if p.Spec.Display == nil {
-		p.Spec.Display = &common.Display{}
-	}
-	if !p.GenerateName && p.Spec.Display.Name == "" {
-		p.Spec.Display.Name = p.Name
-	}
-	return p.Validate()
-}
-
-func (p *PostableDashboardV2) Validate() error {
-	if p.SchemaVersion != SchemaVersion {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "schemaVersion must be %q, got %q", SchemaVersion, p.SchemaVersion)
-	}
-	if err := p.validateName(); err != nil {
-		return err
-	}
-	if err := p.validateTags(); err != nil {
-		return err
-	}
-	return p.Spec.Validate()
-}
-
-func (p *PostableDashboardV2) validateName() error {
-	if !p.GenerateName {
-		return validateDashboardName(p.Name)
-	}
-	if p.Name != "" {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name must be empty when generateName is true, got %q", p.Name)
-	}
-	if p.Spec.Display == nil || p.Spec.Display.Name == "" {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "spec.display.name is required when generateName is true")
-	}
-	return nil
-}
-
-// Matches https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-label-names.
-func validateDashboardName(name string) error {
-	if name == "" {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name is required")
-	}
-	if errs := validation.IsDNS1123Label(name); len(errs) > 0 {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "name %q is invalid: %s", name, strings.Join(errs, "; "))
-	}
-	return nil
-}
-
-func generateDashboardName(displayName string) string {
-	const dns1123LabelMaxLen = 63
-	suffixAlphabet := []byte("abcdefghijklmnopqrstuvwxyz0123456789")
-
-	var b strings.Builder
-	b.Grow(len(displayName))
-	prevHyphen := false
-	for _, r := range strings.ToLower(displayName) {
-		switch {
-		case (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9'):
-			b.WriteRune(r)
-			prevHyphen = false
-		case b.Len() > 0 && !prevHyphen:
-			b.WriteByte('-')
-			prevHyphen = true
-		}
-	}
-	prefix := strings.TrimRight(b.String(), "-")
-
-	suffix := make([]byte, dashboardNameSuffixLen)
-	if _, err := rand.Read(suffix); err != nil {
-		panic(errors.WrapInternalf(err, errors.CodeInternal, "read random for dashboard name suffix"))
-	}
-	for i := range suffix {
-		suffix[i] = suffixAlphabet[int(suffix[i])%len(suffixAlphabet)]
-	}
-
-	maxPrefix := dns1123LabelMaxLen - 1 - dashboardNameSuffixLen
-	if len(prefix) > maxPrefix {
-		prefix = strings.TrimRight(prefix[:maxPrefix], "-")
-	}
-	if prefix == "" {
-		return string(suffix)
-	}
-	return prefix + "-" + string(suffix)
-}
-
-func (p *PostableDashboardV2) validateTags() error {
-	if len(p.Tags) > MaxTagsPerDashboard {
-		return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "a dashboard can have at most %d tags", MaxTagsPerDashboard)
-	}
-	for _, tag := range p.Tags {
-		if _, reserved := reservedDSLKeys[DSLKey(strings.ToLower(strings.TrimSpace(tag.Key)))]; reserved {
-			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "tag key %q is reserved", tag.Key)
-		}
-	}
-	return nil
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Gettable
-// ════════════════════════════════════════════════════════════════════════
-
-type GettableDashboardV2 struct {
-	types.Identifiable
-	types.TimeAuditable
-	types.UserAuditable
-
-	OrgID  valuer.UUID `json:"orgId" required:"true"`
-	Locked bool        `json:"locked" required:"true"`
-	Source Source      `json:"source" required:"true"`
-
-	DashboardV2MetadataBase
-	Name string                  `json:"name" required:"true"`
-	Tags []*tagtypes.GettableTag `json:"tags" required:"true"`
-	Spec DashboardSpec           `json:"spec" required:"true"`
-}
-
-func (d DashboardV2) ToGettableDashboardV2() GettableDashboardV2 {
-	return GettableDashboardV2{
-		Identifiable:            d.Identifiable,
-		TimeAuditable:           d.TimeAuditable,
-		UserAuditable:           d.UserAuditable,
-		OrgID:                   d.OrgID,
-		Locked:                  d.Locked,
-		Source:                  d.Source,
-		DashboardV2MetadataBase: d.DashboardV2MetadataBase,
-		Name:                    d.Name,
-		Tags:                    tagtypes.NewGettableTagsFromTags(d.Tags),
-		Spec:                    d.Spec,
-	}
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Storable
-// ════════════════════════════════════════════════════════════════════════
-
-// StorableDashboardV2Data is exactly what serializes into the dashboard.data column.
-type StorableDashboardV2Data struct {
-	Metadata StorableDashboardV2Metadata `json:"metadata"`
-	Spec     DashboardSpec               `json:"spec"`
-}
-
-func (s StorableDashboardV2Data) toStorableDashboardData() (StorableDashboardData, error) {
-	raw, err := json.Marshal(s)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "marshal v2 dashboard data")
-	}
-	out := StorableDashboardData{}
-	if err := json.Unmarshal(raw, &out); err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "unmarshal v2 dashboard data")
-	}
-	return out, nil
-}
-
-type StorableDashboardV2Metadata = DashboardV2MetadataBase
-
-// ════════════════════════════════════════════════════════════════════════
-// Updateable
-// ════════════════════════════════════════════════════════════════════════
-
-type UpdateableDashboardV2 = PostableDashboardV2
-
-func (d DashboardV2) toUpdateableDashboardV2() UpdateableDashboardV2 {
-	return PostableDashboardV2{
-		DashboardV2MetadataBase: d.DashboardV2MetadataBase,
-		Name:                    d.Name,
-		Tags:                    tagtypes.NewPostableTagsFromTags(d.Tags),
-		Spec:                    d.Spec,
-	}
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Patchable
-// ════════════════════════════════════════════════════════════════════════
-
-// PatchableDashboardV2 is an RFC 6902 JSON Patch document applied against a
-// PostableDashboardV2-shaped view of an existing dashboard. Patch ops can
-// target any field — including individual entries inside `data.panels`,
-// `data.panels.<id>.spec.queries`, or `tags` — without re-sending the rest of
-// the dashboard.
-type PatchableDashboardV2 struct {
-	patch jsonpatch.Patch
-}
-
-// JSONPatchDocument is the OpenAPI-facing schema for an RFC 6902 patch body.
-// PatchableDashboardV2 has only an internal `jsonpatch.Patch` field, so the
-// reflector would emit an empty schema; the handler def points at this type
-// instead so consumers see the array-of-ops shape.
-type JSONPatchDocument []JSONPatchOperation
-
-// JSONPatchOperation is one RFC 6902 op. Not every field is valid on every
-// op kind (e.g. `value` is required for add/replace/test, ignored for remove;
-// `from` is required for move/copy) — the JSON Patch RFC governs that.
-type JSONPatchOperation struct {
-	Op    string `json:"op" required:"true"`
-	Path  string `json:"path" required:"true" description:"JSON Pointer (RFC 6901) into the dashboard's postable shape — e.g. /data/display/name, /data/panels/<id>, /data/panels/<id>/spec/queries/0, /tags/-."`
-	Value any    `json:"value,omitempty" description:"Value to add/replace/test against. The expected type depends on the path. Common shapes (see referenced schemas for the exact field set): /data/panels/<id> takes a DashboardtypesPanel; /data/panels/<id>/spec/queries/N (or /-) takes a DashboardtypesQuery; /data/variables/N takes a DashboardtypesVariable; /data/layouts/N takes a DashboardtypesLayout; /tags/N (or /-) takes a TagtypesPostableTag; /data/display/name and other leaf string fields take a string. Required for add/replace/test; ignored for remove/move/copy."`
-	From  string `json:"from,omitempty" description:"Source JSON Pointer for move/copy ops; ignored for other ops."`
-}
-
-// PrepareJSONSchema constrains the `op` field to the six RFC 6902 verbs.
-func (JSONPatchOperation) PrepareJSONSchema(s *jsonschema.Schema) error {
-	op, ok := s.Properties["op"]
-	if !ok || op.TypeObject == nil {
-		return errors.NewInternalf(errors.CodeInternal, "JSONPatchOperation schema missing `op` property")
-	}
-	op.TypeObject.WithEnum("add", "remove", "replace", "move", "copy", "test")
-	s.Properties["op"] = op
-	return nil
-}
-
-func (p *PatchableDashboardV2) UnmarshalJSON(data []byte) error {
-	patch, err := jsonpatch.DecodePatch(data)
-	if err != nil {
-		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s", err.Error())
-	}
-	p.patch = patch
-	return nil
-}
-
-func (p PatchableDashboardV2) Apply(existing *DashboardV2) (*UpdateableDashboardV2, error) {
-	existingAsUpdateable := existing.toUpdateableDashboardV2()
-	raw, err := json.Marshal(existingAsUpdateable)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "marshal existing dashboard for patch")
-	}
-	patched, err := p.patch.Apply(raw)
-	if err != nil {
-		return nil, errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "%s", err.Error())
-	}
-	out := &UpdateableDashboardV2{}
-	if err := json.Unmarshal(patched, out); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// ════════════════════════════════════════════════════════════════════════
-// Convertors
-// ════════════════════════════════════════════════════════════════════════
-
-func (d *DashboardV2) ToStorableDashboard() (*StorableDashboard, error) {
-	storableDashboardV2Data := StorableDashboardV2Data{
-		Metadata: StorableDashboardV2Metadata{
-			SchemaVersion: d.SchemaVersion,
-			Image:         d.Image,
-		},
-		Spec: d.Spec,
-	}
-
-	data, err := storableDashboardV2Data.toStorableDashboardData()
-	if err != nil {
-		return nil, err
-	}
-	return &StorableDashboard{
-		Identifiable:  types.Identifiable{ID: d.ID},
-		TimeAuditable: d.TimeAuditable,
-		UserAuditable: d.UserAuditable,
-		OrgID:         d.OrgID,
-		Locked:        d.Locked,
-		Name:          d.Name,
-		Data:          data,
-		Source:        d.Source,
-	}, nil
-}
-
-func (storable StorableDashboard) ToDashboardV2(tags []*tagtypes.Tag) (*DashboardV2, error) {
-	metadata, _ := storable.Data["metadata"].(map[string]any)
-	if metadata == nil || metadata["schemaVersion"] != SchemaVersion {
-		return nil, errors.Newf(errors.TypeUnsupported, ErrCodeDashboardInvalidData, "dashboard %s is not in %s schema", storable.ID, SchemaVersion)
-	}
-	raw, err := json.Marshal(storable.Data)
-	if err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "marshal stored v2 dashboard data")
-	}
-	var stored StorableDashboardV2Data
-	if err := json.Unmarshal(raw, &stored); err != nil {
-		return nil, errors.WrapInternalf(err, errors.CodeInternal, "unmarshal stored v2 dashboard data")
-	}
-	return &DashboardV2{
-		Identifiable:            storable.Identifiable,
-		TimeAuditable:           storable.TimeAuditable,
-		UserAuditable:           storable.UserAuditable,
-		OrgID:                   storable.OrgID,
-		Locked:                  storable.Locked,
-		Source:                  storable.Source,
-		DashboardV2MetadataBase: stored.Metadata,
-		Name:                    storable.Name,
-		Tags:                    tags,
-		Spec:                    stored.Spec,
-	}, nil
-}

pkg/types/dashboardtypes/perses_dashboard_convertors_test.go

@@ -1,225 +0,0 @@
-package dashboardtypes
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/coretypes"
-	"github.com/SigNoz/signoz/pkg/types/tagtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/perses/perses/pkg/model/api/v1/common"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func newTestDashboardV2(t *testing.T, orgID valuer.UUID, source Source) *DashboardV2 {
-	t.Helper()
-	createdAt := time.Date(2026, time.January, 1, 12, 0, 0, 0, time.UTC)
-	updatedAt := time.Date(2026, time.January, 2, 12, 0, 0, 0, time.UTC)
-
-	spec := DashboardSpec{
-		Panels: map[string]*Panel{
-			"p1": {
-				Kind: "Panel",
-				Spec: PanelSpec{
-					Plugin: PanelPlugin{
-						Kind: PanelKindTimeSeries,
-						Spec: &TimeSeriesPanelSpec{
-							Visualization: TimeSeriesVisualization{
-								BasicVisualization: BasicVisualization{TimePreference: TimePreferenceGlobalTime},
-							},
-							Formatting: PanelFormatting{DecimalPrecision: PrecisionOption2},
-							ChartAppearance: TimeSeriesChartAppearance{
-								LineInterpolation: LineInterpolationSpline,
-								LineStyle:         LineStyleSolid,
-								FillMode:          FillModeSolid,
-								SpanGaps:          SpanGaps{FillLessThan: valuer.MustParseTextDuration("60s")},
-							},
-							Legend: Legend{Position: LegendPositionBottom},
-						},
-					},
-					Queries: []Query{
-						{
-							Kind: "TimeSeriesQuery",
-							Spec: QuerySpec{
-								Plugin: QueryPlugin{
-									Kind: QueryKindPromQL,
-									Spec: &PromQLQuerySpec{Name: "A", Query: "up"},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		Layouts: []Layout{},
-	}
-
-	return &DashboardV2{
-		Identifiable:  types.Identifiable{ID: valuer.GenerateUUID()},
-		TimeAuditable: types.TimeAuditable{CreatedAt: createdAt, UpdatedAt: updatedAt},
-		UserAuditable: types.UserAuditable{CreatedBy: "alice", UpdatedBy: "bob"},
-		OrgID:         orgID,
-		Locked:        true,
-		Source:        source,
-		DashboardV2MetadataBase: DashboardV2MetadataBase{
-			SchemaVersion: SchemaVersion,
-			Image:         "data:image/png;base64,abc",
-		},
-		Name: "production-overview",
-		Tags: []*tagtypes.Tag{
-			tagtypes.NewTag(orgID, coretypes.KindDashboard, "team", "platform"),
-			tagtypes.NewTag(orgID, coretypes.KindDashboard, "env", "prod"),
-		},
-		Spec: spec,
-	}
-}
-
-func TestPostableDashboardV2NewDashboardV2(t *testing.T) {
-	orgID := valuer.GenerateUUID()
-
-	cases := []struct {
-		scenario       string
-		source         Source
-		expectedLocked bool
-	}{
-		{
-			scenario:       "user source is not locked",
-			source:         SourceUser,
-			expectedLocked: false,
-		},
-		{
-			scenario:       "system source is not locked",
-			source:         SourceSystem,
-			expectedLocked: false,
-		},
-		{
-			scenario:       "integration source is locked",
-			source:         SourceIntegration,
-			expectedLocked: true,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.scenario, func(t *testing.T) {
-			postable := PostableDashboardV2{
-				DashboardV2MetadataBase: DashboardV2MetadataBase{
-					SchemaVersion: SchemaVersion,
-					Image:         "img",
-				},
-				Name: "my-dashboard",
-				Tags: []tagtypes.PostableTag{
-					{Key: "team", Value: "platform"},
-					{Key: "env", Value: "prod"},
-				},
-				Spec: DashboardSpec{},
-			}
-
-			before := time.Now()
-			dashboard := postable.NewDashboardV2(orgID, "alice", tc.source)
-			after := time.Now()
-
-			require.NotNil(t, dashboard)
-			assert.False(t, dashboard.ID.IsZero(), "expected a freshly generated UUID")
-			assert.Equal(t, orgID, dashboard.OrgID)
-			assert.Equal(t, tc.source, dashboard.Source)
-			assert.Equal(t, tc.expectedLocked, dashboard.Locked)
-			assert.Equal(t, postable.DashboardV2MetadataBase, dashboard.DashboardV2MetadataBase)
-			assert.Equal(t, postable.Name, dashboard.Name)
-			assert.Equal(t, postable.Spec, dashboard.Spec)
-
-			assert.Equal(t, "alice", dashboard.CreatedBy)
-			assert.Equal(t, "alice", dashboard.UpdatedBy)
-			assert.True(t, dashboard.CreatedAt.Equal(dashboard.UpdatedAt), "createdAt should equal updatedAt on creation")
-			assert.False(t, dashboard.CreatedAt.Before(before), "createdAt should be >= before")
-			assert.False(t, dashboard.CreatedAt.After(after), "createdAt should be <= after")
-
-			require.Len(t, dashboard.Tags, 2, "expected 2 tags")
-			for i, expectedTag := range postable.Tags {
-				assert.Equal(t, expectedTag.Key, dashboard.Tags[i].Key)
-				assert.Equal(t, expectedTag.Value, dashboard.Tags[i].Value)
-				assert.Equal(t, orgID, dashboard.Tags[i].OrgID)
-				assert.Equal(t, coretypes.KindDashboard, dashboard.Tags[i].Kind)
-				assert.False(t, dashboard.Tags[i].ID.IsZero(), "tag should have a UUID")
-			}
-		})
-	}
-
-	t.Run("each invocation mints a distinct ID", func(t *testing.T) {
-		postable := PostableDashboardV2{
-			DashboardV2MetadataBase: DashboardV2MetadataBase{SchemaVersion: SchemaVersion},
-			Name:                    "x",
-			Spec:                    DashboardSpec{},
-		}
-
-		first := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		second := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		assert.NotEqual(t, first.ID, second.ID, "expected distinct UUIDs across invocations")
-	})
-
-	t.Run("generateName derives name from display.name with a random suffix", func(t *testing.T) {
-		postable := PostableDashboardV2{
-			DashboardV2MetadataBase: DashboardV2MetadataBase{SchemaVersion: SchemaVersion},
-			GenerateName:            true,
-			Spec: DashboardSpec{
-				Display: &common.Display{Name: "My Dashboard!"},
-			},
-		}
-
-		dashboard := postable.NewDashboardV2(orgID, "alice", SourceUser)
-		assert.True(t, strings.HasPrefix(dashboard.Name, "my-dashboard-"), "expected slug prefix, got %q", dashboard.Name)
-		assert.Len(t, dashboard.Name, len("my-dashboard-")+dashboardNameSuffixLen)
-	})
-}
-
-func TestDashboardV2ToGettableDashboardV2(t *testing.T) {
-	orgID := valuer.GenerateUUID()
-
-	t.Run("copies all scalar fields and converts tags", func(t *testing.T) {
-		dashboard := newTestDashboardV2(t, orgID, SourceUser)
-
-		gettable := dashboard.ToGettableDashboardV2()
-
-		assert.Equal(t, dashboard.Identifiable, gettable.Identifiable)
-		assert.Equal(t, dashboard.TimeAuditable, gettable.TimeAuditable)
-		assert.Equal(t, dashboard.UserAuditable, gettable.UserAuditable)
-		assert.Equal(t, dashboard.OrgID, gettable.OrgID)
-		assert.Equal(t, dashboard.Locked, gettable.Locked)
-		assert.Equal(t, dashboard.Source, gettable.Source)
-		assert.Equal(t, dashboard.DashboardV2MetadataBase, gettable.DashboardV2MetadataBase)
-		assert.Equal(t, dashboard.Name, gettable.Name)
-		assert.Equal(t, dashboard.Spec, gettable.Spec)
-
-		require.Len(t, gettable.Tags, len(dashboard.Tags))
-		for i, sourceTag := range dashboard.Tags {
-			require.NotNil(t, gettable.Tags[i])
-			assert.Equal(t, sourceTag.Key, gettable.Tags[i].Key)
-			assert.Equal(t, sourceTag.Value, gettable.Tags[i].Value)
-		}
-	})
-}
-
-func TestDashboardV2StorableRoundTrip(t *testing.T) {
-	orgID := valuer.GenerateUUID()
-	original := newTestDashboardV2(t, orgID, SourceIntegration)
-
-	storable, err := original.ToStorableDashboard()
-	require.NoError(t, err)
-	require.NotNil(t, storable)
-
-	// Simulate the DB hop on the text `data` column.
-	raw, err := json.Marshal(storable.Data)
-	require.NoError(t, err)
-	var reloadedData StorableDashboardData
-	require.NoError(t, json.Unmarshal(raw, &reloadedData))
-	storable.Data = reloadedData
-
-	restored, err := storable.ToDashboardV2(original.Tags)
-	require.NoError(t, err)
-	require.NotNil(t, restored)
-
-	assert.Equal(t, original, restored)
-}

pkg/types/dashboardtypes/perses_dashboard_data.go

@@ -12,11 +12,11 @@ import (
 	"github.com/perses/perses/pkg/model/api/v1/common"
 )
 
-// DashboardSpec is the SigNoz dashboard v2 spec shape. It mirrors
+// DashboardData is the SigNoz dashboard v2 spec shape. It mirrors
 // v1.DashboardSpec (Perses) field-for-field, except every common.Plugin
 // occurrence is replaced with a typed SigNoz plugin whose OpenAPI schema is a
 // per-site discriminated oneOf.
-type DashboardSpec struct {
+type DashboardData struct {
 	Display         *common.Display            `json:"display,omitempty"`
 	Datasources     map[string]*DatasourceSpec `json:"datasources,omitempty"`
 	Variables       []Variable                 `json:"variables,omitempty"`
@@ -31,15 +31,15 @@ type DashboardSpec struct {
 // Unmarshal + validate entry point
 // ══════════════════════════════════════════════
 
-func (d *DashboardSpec) UnmarshalJSON(data []byte) error {
+func (d *DashboardData) UnmarshalJSON(data []byte) error {
 	dec := json.NewDecoder(bytes.NewReader(data))
 	dec.DisallowUnknownFields()
-	type alias DashboardSpec
+	type alias DashboardData
 	var tmp alias
 	if err := dec.Decode(&tmp); err != nil {
 		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid dashboard spec")
 	}
-	*d = DashboardSpec(tmp)
+	*d = DashboardData(tmp)
 	return d.Validate()
 }
 
@@ -47,7 +47,7 @@ func (d *DashboardSpec) UnmarshalJSON(data []byte) error {
 // Cross-field validation
 // ══════════════════════════════════════════════
 
-func (d *DashboardSpec) Validate() error {
+func (d *DashboardData) Validate() error {
 	for key, panel := range d.Panels {
 		if panel == nil {
 			return errors.NewInvalidInputf(ErrCodeDashboardInvalidInput, "spec.panels.%s: panel must not be null", key)

pkg/types/dashboardtypes/perses_dashboard_patch_test.go

@@ -1,566 +0,0 @@
-package dashboardtypes
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/types/tagtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// basePostableJSON is the postable shape of a small but realistic v2
-// dashboard used as the base document for patch tests. Each panel carries
-// one builder query in the same shape production dashboards use
-// (aggregations, filter, groupBy populated), and the dashboard has one
-// variable — the variable is not patched in any test here, that's
-// covered in a separate variable-focused suite.
-const basePostableJSON = `{
-	"schemaVersion": "v6",
-	"name": "service-overview",
-	"tags": [{"key": "team", "value": "alpha"}, {"key": "env", "value": "prod"}],
-	"spec": {
-		"display": {"name": "Service overview"},
-		"variables": [
-			{
-				"kind": "ListVariable",
-				"spec": {
-					"name": "service",
-					"allowAllValue": true,
-					"allowMultiple": false,
-					"plugin": {
-						"kind": "signoz/DynamicVariable",
-						"spec": {"name": "service.name", "signal": "metrics"}
-					}
-				}
-			}
-		],
-		"panels": {
-			"p1": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {}},
-					"queries": [
-						{
-							"kind": "TimeSeriesQuery",
-							"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-								"name": "A",
-								"signal": "metrics",
-								"aggregations": [{
-									"metricName": "signoz_calls_total",
-									"temporality": "cumulative",
-									"timeAggregation": "rate",
-									"spaceAggregation": "sum"
-								}],
-								"filter": {"expression": "service.name IN $service"},
-								"groupBy": [{"name": "service.name", "fieldDataType": "string", "fieldContext": "tag"}]
-							}}}
-						}
-					]
-				}
-			},
-			"p2": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/NumberPanel", "spec": {}},
-					"queries": [
-						{
-							"kind": "TimeSeriesQuery",
-							"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-								"name": "X",
-								"signal": "metrics",
-								"aggregations": [{
-									"metricName": "signoz_latency_count",
-									"temporality": "cumulative",
-									"timeAggregation": "rate",
-									"spaceAggregation": "sum"
-								}]
-							}}}
-						}
-					]
-				}
-			}
-		},
-		"layouts": [
-			{
-				"kind": "Grid",
-				"spec": {
-					"display": {"title": "Row 1"},
-					"items": [
-						{"x": 0, "y": 0, "width": 6, "height": 6, "content": {"$ref": "#/spec/panels/p1"}},
-						{"x": 6, "y": 0, "width": 6, "height": 6, "content": {"$ref": "#/spec/panels/p2"}}
-					]
-				}
-			}
-		],
-		"duration": "1h"
-	}
-}`
-
-func TestPatchableDashboardV2_Apply(t *testing.T) {
-	// Apply doesn't mutate the input *DashboardV2 — it marshals it to
-	// JSON, applies the patch, and unmarshals the result into a fresh
-	// struct. Sharing one base across subtests is safe.
-	var p PostableDashboardV2
-	require.NoError(t, json.Unmarshal([]byte(basePostableJSON), &p), "base postable JSON must validate")
-	testOrgID := valuer.GenerateUUID()
-	base := p.NewDashboardV2(testOrgID, "somecreatedthisiguess@signoz.io", SourceUser)
-	base.Tags = []*tagtypes.Tag{
-		{Key: "team", Value: "alpha"},
-		{Key: "env", Value: "prod"},
-	}
-
-	decode := func(t *testing.T, body string) PatchableDashboardV2 {
-		t.Helper()
-		var patch PatchableDashboardV2
-		require.NoError(t, json.Unmarshal([]byte(body), &patch))
-		return patch
-	}
-
-	// jsonOf marshals the patched dashboard back to JSON so subtests can
-	// assert on field values without reaching into the typed plugin specs.
-	jsonOf := func(t *testing.T, out *UpdateableDashboardV2) string {
-		t.Helper()
-		raw, err := json.Marshal(out)
-		require.NoError(t, err)
-		return string(raw)
-	}
-
-	// ─────────────────────────────────────────────────────────────────
-	// Successful patches
-	// ─────────────────────────────────────────────────────────────────
-
-	t.Run("no-op preserves all fields", func(t *testing.T) {
-		out, err := decode(t, `[]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, base.DashboardV2MetadataBase, out.DashboardV2MetadataBase)
-		assert.Equal(t, tagtypes.NewPostableTagsFromTags(base.Tags), out.Tags)
-		assert.Equal(t, base.Spec.Display.Name, out.Spec.Display.Name)
-		require.Equal(t, len(base.Spec.Panels), len(out.Spec.Panels))
-		for k, panel := range base.Spec.Panels {
-			require.Contains(t, out.Spec.Panels, k)
-			assert.Equal(t, panel.Spec.Plugin.Kind, out.Spec.Panels[k].Spec.Plugin.Kind)
-		}
-		assert.Len(t, out.Tags, len(base.Tags))
-		assert.Len(t, out.Spec.Variables, len(base.Spec.Variables))
-		assert.Len(t, out.Spec.Layouts, len(base.Spec.Layouts))
-	})
-
-	t.Run("add metadata image", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "add", "path": "/image", "value": "https://example.com/img.png"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "https://example.com/img.png", out.Image)
-		assert.Equal(t, SchemaVersion, out.SchemaVersion, "schemaVersion preserved")
-	})
-
-	t.Run("replace display name", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/display/name", "value": "Renamed"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "Renamed", out.Spec.Display.Name)
-	})
-
-	// Per RFC 6902 § 4.1, `add` on an existing object member replaces the
-	// existing value rather than erroring — same effect as `replace`.
-	t.Run("add overwrites existing display name", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "add", "path": "/spec/display/name", "value": "Overwritten"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "Overwritten", out.Spec.Display.Name)
-	})
-
-	t.Run("add data refreshInterval", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "add", "path": "/spec/refreshInterval", "value": "30s"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "30s", string(out.Spec.RefreshInterval))
-	})
-
-	t.Run("add panel leaves others untouched", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "add",
-			"path": "/spec/panels/p3",
-			"value": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/TablePanel", "spec": {}},
-					"queries": [{
-						"kind": "TimeSeriesQuery",
-						"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-							"name": "A",
-							"signal": "logs",
-							"aggregations": [{"expression": "count()"}]
-						}}}
-					}]
-				}
-			}
-		}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Len(t, out.Spec.Panels, 3)
-		assert.Contains(t, out.Spec.Panels, "p3")
-		// Plugin specs round-trip through MarshalJSON which resolves defaults
-		// (e.g. timePreference → "global_time"), so compare the serialized
-		// shape rather than the in-memory structs to skip that normalization.
-		for _, id := range []string{"p1", "p2"} {
-			wantJSON, err := json.Marshal(base.Spec.Panels[id])
-			require.NoError(t, err)
-			gotJSON, err := json.Marshal(out.Spec.Panels[id])
-			require.NoError(t, err)
-			assert.JSONEq(t, string(wantJSON), string(gotJSON), "panel %s untouched", id)
-		}
-	})
-
-	t.Run("replace single panel", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p2",
-			"value": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/BarChartPanel", "spec": {}},
-					"queries": [{
-						"kind": "TimeSeriesQuery",
-						"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-							"name": "A",
-							"signal": "metrics",
-							"aggregations": [{
-								"metricName": "signoz_calls_total",
-								"temporality": "cumulative",
-								"timeAggregation": "rate",
-								"spaceAggregation": "sum"
-							}]
-						}}}
-					}]
-				}
-			}
-		}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, PanelPluginKind("signoz/BarChartPanel"), out.Spec.Panels["p2"].Spec.Plugin.Kind)
-		assert.Equal(t, PanelPluginKind("signoz/TimeSeriesPanel"), out.Spec.Panels["p1"].Spec.Plugin.Kind, "p1 untouched")
-	})
-
-	// Removing a panel realistically also drops its layout item — exercise
-	// the multi-op shape the UI sends.
-	t.Run("remove panel and its layout item", func(t *testing.T) {
-		out, err := decode(t, `[
-			{"op": "remove", "path": "/spec/panels/p2"},
-			{"op": "remove", "path": "/spec/layouts/0/spec/items/1"}
-		]`).Apply(base)
-		require.NoError(t, err)
-		assert.Len(t, out.Spec.Panels, 1)
-		assert.Contains(t, out.Spec.Panels, "p1")
-		assert.NotContains(t, out.Spec.Panels, "p2")
-		raw := jsonOf(t, out)
-		assert.NotContains(t, raw, `"$ref":"#/spec/panels/p2"`)
-		assert.Contains(t, raw, `"$ref":"#/spec/panels/p1"`)
-	})
-
-	// The headline use case: edit a single field of a single query inside
-	// one panel without re-sending any other part of the dashboard.
-	t.Run("rename single query inside panel", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p1/spec/queries/0/spec/plugin/spec/name",
-			"value": "renamed"
-		}]`).Apply(base)
-		require.NoError(t, err)
-
-		require.Len(t, out.Spec.Panels["p1"].Spec.Queries, 1)
-		assert.Contains(t, jsonOf(t, out), `"name":"renamed"`)
-	})
-
-	// Replace a query at a specific index — swaps query "A" out for "B"
-	// without re-sending the rest of the panel.
-	t.Run("replace query at index", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p1/spec/queries/0",
-			"value": {
-				"kind": "TimeSeriesQuery",
-				"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-					"name": "B",
-					"signal": "metrics",
-					"aggregations": [{
-						"metricName": "signoz_db_calls_total",
-						"temporality": "cumulative",
-						"timeAggregation": "rate",
-						"spaceAggregation": "sum"
-					}]
-				}}}
-			}
-		}]`).Apply(base)
-		require.NoError(t, err)
-		require.Len(t, out.Spec.Panels["p1"].Spec.Queries, 1)
-		raw := jsonOf(t, out)
-		assert.Contains(t, raw, `"name":"B"`)
-		assert.NotContains(t, raw, `"name":"A"`)
-	})
-
-	// ─────────────────────────────────────────────────────────────────
-	// Layout edits
-	// ─────────────────────────────────────────────────────────────────
-
-	t.Run("move panel by editing layout x coordinate", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/layouts/0/spec/items/0/x", "value": 6}]`).Apply(base)
-		require.NoError(t, err)
-		raw := jsonOf(t, out)
-		// The first item used to live at x=0, now lives at x=6.
-		assert.Contains(t, raw, `"x":6,"y":0,"width":6,"height":6,"content":{"$ref":"#/spec/panels/p1"}`)
-	})
-
-	t.Run("resize panel by editing layout width", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/layouts/0/spec/items/0/width", "value": 12}]`).Apply(base)
-		require.NoError(t, err)
-		raw := jsonOf(t, out)
-		assert.Contains(t, raw, `"width":12`)
-	})
-
-	t.Run("rename layout row title", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/layouts/0/spec/display/title", "value": "Latency"}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Contains(t, jsonOf(t, out), `"title":"Latency"`)
-	})
-
-	t.Run("append layout item", func(t *testing.T) {
-		out, err := decode(t, `[{
-			"op": "add",
-			"path": "/spec/layouts/0/spec/items/-",
-			"value": {"x": 0, "y": 6, "width": 12, "height": 6, "content": {"$ref": "#/spec/panels/p1"}}
-		}]`).Apply(base)
-		require.NoError(t, err)
-		// Item count went 2 → 3.
-		raw := jsonOf(t, out)
-		assert.Equal(t, 3, strings.Count(raw, `"$ref":"#/spec/panels/`))
-	})
-
-	// Composing add-panel + add-layout-item is the realistic shape of the
-	// "add a new chart to my dashboard" UI flow — exercise it end-to-end.
-	t.Run("add panel and corresponding layout item", func(t *testing.T) {
-		out, err := decode(t, `[
-			{
-				"op": "add",
-				"path": "/spec/panels/p3",
-				"value": {
-					"kind": "Panel",
-					"spec": {
-						"plugin": {"kind": "signoz/TablePanel", "spec": {}},
-						"queries": [{
-							"kind": "TimeSeriesQuery",
-							"spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-								"name": "A",
-								"signal": "logs",
-								"aggregations": [{"expression": "count()"}]
-							}}}
-						}]
-					}
-				}
-			},
-			{
-				"op": "add",
-				"path": "/spec/layouts/0/spec/items/-",
-				"value": {"x": 0, "y": 6, "width": 12, "height": 6, "content": {"$ref": "#/spec/panels/p3"}}
-			}
-		]`).Apply(base)
-		require.NoError(t, err)
-		assert.Len(t, out.Spec.Panels, 3)
-		raw := jsonOf(t, out)
-		assert.Contains(t, raw, `"$ref":"#/spec/panels/p3"`)
-	})
-
-	t.Run("append tag", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "add", "path": "/tags/-", "value": {"key": "env", "value": "staging"}}]`).Apply(base)
-		require.NoError(t, err)
-		require.Len(t, out.Tags, 3)
-		assert.Equal(t, "env", out.Tags[2].Key)
-		assert.Equal(t, "staging", out.Tags[2].Value)
-	})
-
-	t.Run("append tag when none exist", func(t *testing.T) {
-		noTagsBase := &DashboardV2{
-			DashboardV2MetadataBase: base.DashboardV2MetadataBase,
-			Name:                    base.Name,
-			Tags:                    nil,
-			Spec:                    base.Spec,
-		}
-		out, err := decode(t, `[{"op": "add", "path": "/tags/-", "value": {"key": "team", "value": "new"}}]`).Apply(noTagsBase)
-		require.NoError(t, err)
-		require.Len(t, out.Tags, 1)
-		assert.Equal(t, "team", out.Tags[0].Key)
-		assert.Equal(t, "new", out.Tags[0].Value)
-	})
-
-	t.Run("replace tag value", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/tags/0/value", "value": "beta"}]`).Apply(base)
-		require.NoError(t, err)
-		require.Len(t, out.Tags, 2)
-		assert.Equal(t, "team", out.Tags[0].Key)
-		assert.Equal(t, "beta", out.Tags[0].Value)
-		assert.Equal(t, "env", out.Tags[1].Key, "tag at index 1 untouched")
-		assert.Equal(t, "prod", out.Tags[1].Value, "tag at index 1 untouched")
-		for _, tag := range out.Tags {
-			assert.NotEqual(t, "alpha", tag.Value, "old tag value must be gone")
-		}
-	})
-
-	t.Run("multiple ops applied in order", func(t *testing.T) {
-		out, err := decode(t, `[
-			{"op": "replace", "path": "/spec/display/name", "value": "Multi-step"},
-			{"op": "remove",  "path": "/spec/panels/p2"},
-			{"op": "add",     "path": "/tags/-", "value": {"key": "env", "value": "staging"}}
-		]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "Multi-step", out.Spec.Display.Name)
-		assert.Len(t, out.Spec.Panels, 1)
-		assert.Len(t, out.Tags, 3)
-	})
-
-	// `test` is an RFC 6902 precondition op: aborts the patch if the value
-	// at the path doesn't equal the supplied value. Used for optimistic
-	// concurrency. Here it matches, so the subsequent ops apply.
-	t.Run("test op passes", func(t *testing.T) {
-		out, err := decode(t, `[
-			{"op": "test",    "path": "/spec/display/name", "value": "Service overview"},
-			{"op": "replace", "path": "/spec/display/name", "value": "Confirmed"}
-		]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, "Confirmed", out.Spec.Display.Name)
-	})
-
-	// ─────────────────────────────────────────────────────────────────
-	// Failure cases
-	// ─────────────────────────────────────────────────────────────────
-
-	t.Run("decode rejects non-array body", func(t *testing.T) {
-		var patch PatchableDashboardV2
-		err := json.Unmarshal([]byte(`{"op": "replace"}`), &patch)
-		require.Error(t, err)
-	})
-
-	t.Run("decode rejects malformed JSON", func(t *testing.T) {
-		var patch PatchableDashboardV2
-		// Outer json.Unmarshal rejects non-JSON before PatchableDashboardV2's
-		// UnmarshalJSON runs, so the error is a stdlib SyntaxError rather
-		// than the InvalidInput-classified wrap.
-		err := json.Unmarshal([]byte(`not json`), &patch)
-		require.Error(t, err)
-	})
-
-	// `test` precondition fails — the whole patch is rejected, including
-	// the subsequent replace.
-	t.Run("test op failure rejected", func(t *testing.T) {
-		_, err := decode(t, `[
-			{"op": "test", "path": "/spec/display/name", "value": "Wrong"},
-			{"op": "replace", "path": "/spec/display/name", "value": "Should not apply"}
-		]`).Apply(base)
-		require.Error(t, err)
-	})
-
-	t.Run("remove at missing path rejected", func(t *testing.T) {
-		_, err := decode(t, `[{"op": "remove", "path": "/spec/panels/does-not-exist"}]`).Apply(base)
-		require.Error(t, err)
-	})
-
-	t.Run("remove schemaVersion rejected", func(t *testing.T) {
-		_, err := decode(t, `[{"op": "remove", "path": "/schemaVersion"}]`).Apply(base)
-		require.Error(t, err)
-	})
-
-	t.Run("wrong schemaVersion rejected", func(t *testing.T) {
-		_, err := decode(t, `[{"op": "replace", "path": "/schemaVersion", "value": "v5"}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), SchemaVersion)
-	})
-
-	t.Run("empty display name defaults to dashboard name", func(t *testing.T) {
-		out, err := decode(t, `[{"op": "replace", "path": "/spec/display/name", "value": ""}]`).Apply(base)
-		require.NoError(t, err)
-		assert.Equal(t, base.Name, out.Spec.Display.Name, "empty display.name should default from name")
-	})
-
-	t.Run("unknown top-level field rejected", func(t *testing.T) {
-		_, err := decode(t, `[{"op": "add", "path": "/bogus", "value": 42}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "bogus")
-	})
-
-	t.Run("invalid panel kind rejected", func(t *testing.T) {
-		_, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p1",
-			"value": {
-				"kind": "Panel",
-				"spec": {"plugin": {"kind": "signoz/NotAPanel", "spec": {}}}
-			}
-		}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "NotAPanel")
-	})
-
-	t.Run("query kind incompatible with panel rejected", func(t *testing.T) {
-		// PromQLQuery is not allowed on ListPanel — verify the cross-check
-		// in Validate still runs after a patch.
-		_, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p2",
-			"value": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/ListPanel", "spec": {}},
-					"queries": [{"kind": "TimeSeriesQuery", "spec": {"plugin": {"kind": "signoz/PromQLQuery", "spec": {"name": "A", "query": "up"}}}}]
-				}
-			}
-		}]`).Apply(base)
-		require.Error(t, err)
-	})
-
-	t.Run("removing the only query rejected", func(t *testing.T) {
-		// Validate requires exactly one query per panel — leaving zero is rejected.
-		_, err := decode(t, `[{"op": "remove", "path": "/spec/panels/p2/spec/queries/0"}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "panel must have one query")
-	})
-
-	t.Run("two direct queries rejected", func(t *testing.T) {
-		// Validate requires exactly one query per panel. To display multiple
-		// data sources in one panel, wrap them in a CompositeQuery (see the
-		// "replace query with composite" subtest below).
-		_, err := decode(t, `[{
-			"op": "replace",
-			"path": "/spec/panels/p1",
-			"value": {
-				"kind": "Panel",
-				"spec": {
-					"plugin": {"kind": "signoz/TimeSeriesPanel", "spec": {}},
-					"queries": [
-						{"kind": "TimeSeriesQuery", "spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-							"name": "A", "signal": "metrics",
-							"aggregations": [{"metricName": "signoz_calls_total", "temporality": "cumulative", "timeAggregation": "rate", "spaceAggregation": "sum"}]
-						}}}},
-						{"kind": "TimeSeriesQuery", "spec": {"plugin": {"kind": "signoz/BuilderQuery", "spec": {
-							"name": "B", "signal": "metrics",
-							"aggregations": [{"metricName": "signoz_db_calls_total", "temporality": "cumulative", "timeAggregation": "rate", "spaceAggregation": "sum"}]
-						}}}}
-					]
-				}
-			}
-		}]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "panel must have one query")
-	})
-
-	t.Run("too many tags rejected", func(t *testing.T) {
-		// Base already has 2 tags; add 9 more to exceed MaxTagsPerDashboard (10).
-		_, err := decode(t, `[
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "1"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "2"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "3"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "4"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "5"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "6"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "7"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "8"}},
-			{"op": "add", "path": "/tags/-", "value": {"key": "t", "value": "9"}}
-		]`).Apply(base)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "at most")
-	})
-}

pkg/types/dashboardtypes/perses_dashboard_test.go

@@ -10,11 +10,10 @@ import (
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"k8s.io/apimachinery/pkg/util/validation"
 )
 
-func unmarshalDashboard(data []byte) (*DashboardSpec, error) {
-	var d DashboardSpec
+func unmarshalDashboard(data []byte) (*DashboardData, error) {
+	var d DashboardData
 	if err := json.Unmarshal(data, &d); err != nil {
 		return nil, err
 	}
@@ -41,7 +40,7 @@ func TestInvalidateNotAJSON(t *testing.T) {
 }
 
 // TestUnmarshalErrorPreservesNestedMessage guards the wrap on dec.Decode in
-// DashboardSpec.UnmarshalJSON. The wrap stamps a consistent type/code on
+// DashboardData.UnmarshalJSON. The wrap stamps a consistent type/code on
 // decode failures, but must not smother the rich messages produced by nested
 // UnmarshalJSON methods (panel/query/variable/datasource plugin envelopes).
 func TestUnmarshalErrorPreservesNestedMessage(t *testing.T) {
@@ -821,7 +820,7 @@ func TestPersesFixtureStorageRoundTrip(t *testing.T) {
 	raw, err := os.ReadFile("testdata/perses.json")
 	require.NoError(t, err)
 
-	var data DashboardSpec
+	var data DashboardData
 	require.NoError(t, json.Unmarshal(raw, &data), "initial unmarshal")
 
 	marshaled, err := json.Marshal(data)
@@ -833,7 +832,7 @@ func TestPersesFixtureStorageRoundTrip(t *testing.T) {
 	remarshaled, err := json.Marshal(asMap)
 	require.NoError(t, err, "map → JSON (read-back shape)")
 
-	var roundtripped DashboardSpec
+	var roundtripped DashboardData
 	require.NoError(t, json.Unmarshal(remarshaled, &roundtripped), "JSON → typed (the failure mode)")
 }
 
@@ -926,112 +925,6 @@ func TestStorageRoundTrip(t *testing.T) {
 		"expected operator:> after storage round-trip")
 }
 
-func TestPostableDashboardV2GenerateNameFlag(t *testing.T) {
-	const validSpec = `"spec": {"panels": {}, "layouts": []}`
-
-	tests := []struct {
-		scenario     string
-		body         string
-		wantErr      bool
-		wantErrMatch string
-		wantName     string
-		wantDisplay  string
-	}{
-		{
-			scenario:    "flag true with display.name derives name on conversion",
-			body:        `{"schemaVersion":"` + SchemaVersion + `","generateName":true,"spec":{"display":{"name":"My Dashboard!"},"panels":{},"layouts":[]}}`,
-			wantName:    "",
-			wantDisplay: "My Dashboard!",
-		},
-		{
-			scenario:     "flag true with non-empty name is rejected",
-			body:         `{"schemaVersion":"` + SchemaVersion + `","name":"already-set","generateName":true,"spec":{"display":{"name":"My Dashboard"},"panels":{},"layouts":[]}}`,
-			wantErr:      true,
-			wantErrMatch: "name must be empty when generateName is true",
-		},
-		{
-			scenario:     "flag true with empty display.name is rejected",
-			body:         `{"schemaVersion":"` + SchemaVersion + `","generateName":true,` + validSpec + `}`,
-			wantErr:      true,
-			wantErrMatch: "spec.display.name is required",
-		},
-		{
-			scenario:    "flag false",
-			body:        `{"schemaVersion":"` + SchemaVersion + `","name":"my-dashboard",` + validSpec + `}`,
-			wantName:    "my-dashboard",
-			wantDisplay: "my-dashboard",
-		},
-		{
-			scenario:     "flag false with missing name is rejected",
-			body:         `{"schemaVersion":"` + SchemaVersion + `",` + validSpec + `}`,
-			wantErr:      true,
-			wantErrMatch: "name is required",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.scenario, func(t *testing.T) {
-			var p PostableDashboardV2
-			err := json.Unmarshal([]byte(tt.body), &p)
-			if tt.wantErr {
-				require.Error(t, err, "expected validation error")
-				assert.Contains(t, err.Error(), tt.wantErrMatch)
-				return
-			}
-			require.NoError(t, err)
-			assert.Equal(t, tt.wantName, p.Name)
-			assert.Equal(t, tt.wantDisplay, p.Spec.Display.Name)
-		})
-	}
-}
-
-func TestGenerateDashboardName(t *testing.T) {
-	tests := []struct {
-		scenario   string
-		input      string
-		wantPrefix string // expected slug prefix before the "-<suffix>" tail (empty if prefix is dropped)
-	}{
-		{scenario: "simple words with spaces", input: "My Dashboard", wantPrefix: "my-dashboard"},
-		{scenario: "punctuation collapses", input: "Hello, World!", wantPrefix: "hello-world"},
-		{scenario: "leading and trailing whitespace", input: "  hello  ", wantPrefix: "hello"},
-		{scenario: "leading and trailing hyphens", input: "---abc---", wantPrefix: "abc"},
-		{scenario: "consecutive non-alphanumerics collapse", input: "a___b...c", wantPrefix: "a-b-c"},
-		{scenario: "digits are preserved", input: "Region us-east-1", wantPrefix: "region-us-east-1"},
-		{scenario: "no alphanumerics drops prefix and returns suffix only", input: "!!! ???", wantPrefix: ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.scenario, func(t *testing.T) {
-			got := generateDashboardName(tt.input)
-			require.NotEmpty(t, got)
-			require.LessOrEqual(t, len(got), 63)
-			require.Empty(t, validation.IsDNS1123Label(got), "result must be a valid DNS-1123 label")
-
-			if tt.wantPrefix == "" {
-				assert.Len(t, got, dashboardNameSuffixLen, "expected the bare random suffix")
-				return
-			}
-			expectedPrefix := tt.wantPrefix + "-"
-			assert.True(t, strings.HasPrefix(got, expectedPrefix), "expected prefix %q, got %q", expectedPrefix, got)
-			assert.Len(t, got, len(expectedPrefix)+dashboardNameSuffixLen)
-		})
-	}
-
-	t.Run("prefix is truncated to leave room for the suffix", func(t *testing.T) {
-		input := strings.Repeat("a", 100)
-		got := generateDashboardName(input)
-		require.LessOrEqual(t, len(got), 63)
-		require.Empty(t, validation.IsDNS1123Label(got))
-		assert.Equal(t, len(got), 63, "expected the result to be padded to the max DNS-1123 length")
-	})
-
-	t.Run("suffix differs across calls", func(t *testing.T) {
-		first := generateDashboardName("collision-test")
-		second := generateDashboardName("collision-test")
-		assert.NotEqual(t, first, second, "expected the random suffix to differ across calls")
-	})
-}
-
 func TestSpanGaps(t *testing.T) {
 	unmarshal := func(t *testing.T, val string) SpanGaps {
 		t.Helper()

pkg/types/dashboardtypes/perses_drift_test.go

@@ -1,6 +1,6 @@
 package dashboardtypes
 
-// TestDashboardSpecMatchesPerses asserts that DashboardData
+// TestDashboardDataMatchesPerses asserts that DashboardData
 // and every nested SigNoz-owned type cover the JSON field set of their Perses
 // counterpart.
 
@@ -16,13 +16,13 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestDashboardSpecMatchesPerses(t *testing.T) {
+func TestDashboardDataMatchesPerses(t *testing.T) {
 	cases := []struct {
 		name   string
 		ours   reflect.Type
 		perses reflect.Type
 	}{
-		{"DashboardSpec", typeOf[DashboardSpec](), typeOf[v1.DashboardSpec]()},
+		{"DashboardSpec", typeOf[DashboardData](), typeOf[v1.DashboardSpec]()},
 		{"Panel", typeOf[Panel](), typeOf[v1.Panel]()},
 		{"PanelSpec", typeOf[PanelSpec](), typeOf[v1.PanelSpec]()},
 		{"Query", typeOf[Query](), typeOf[v1.Query]()},
@@ -38,10 +38,10 @@ func TestDashboardSpecMatchesPerses(t *testing.T) {
 			missing, extra := drift(c.ours, c.perses)
 
 			assert.Empty(t, missing,
-				"DashboardSpec (%s) is missing json fields present on Perses %s — upstream likely added or renamed a field",
+				"DashboardData (%s) is missing json fields present on Perses %s — upstream likely added or renamed a field",
 				c.ours.Name(), c.perses.Name())
 			assert.Empty(t, extra,
-				"DashboardSpec (%s) has json fields absent on Perses %s — upstream likely removed a field or we added one without the counterpart",
+				"DashboardData (%s) has json fields absent on Perses %s — upstream likely removed a field or we added one without the counterpart",
 				c.ours.Name(), c.perses.Name())
 		})
 	}

pkg/types/dashboardtypes/perses_signoz_plugins.go

@@ -397,7 +397,12 @@ func (f *ThresholdFormat) UnmarshalJSON(data []byte) error {
 type ComparisonOperator struct{ valuer.String }
 
 var (
-	ComparisonOperatorAbove        = ComparisonOperator{valuer.NewString("above")} // default
+	ComparisonOperatorGT           = ComparisonOperator{valuer.NewString(">")} // default
+	ComparisonOperatorLT           = ComparisonOperator{valuer.NewString("<")}
+	ComparisonOperatorGTE          = ComparisonOperator{valuer.NewString(">=")}
+	ComparisonOperatorLTE          = ComparisonOperator{valuer.NewString("<=")}
+	ComparisonOperatorEQ           = ComparisonOperator{valuer.NewString("=")}
+	ComparisonOperatorAbove        = ComparisonOperator{valuer.NewString("above")}
 	ComparisonOperatorBelow        = ComparisonOperator{valuer.NewString("below")}
 	ComparisonOperatorAboveOrEqual = ComparisonOperator{valuer.NewString("above_or_equal")}
 	ComparisonOperatorBelowOrEqual = ComparisonOperator{valuer.NewString("below_or_equal")}
@@ -406,12 +411,12 @@ var (
 )
 
 func (ComparisonOperator) Enum() []any {
-	return []any{ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual, ComparisonOperatorEqual, ComparisonOperatorNotEqual}
+	return []any{ComparisonOperatorGT, ComparisonOperatorLT, ComparisonOperatorGTE, ComparisonOperatorLTE, ComparisonOperatorEQ, ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual, ComparisonOperatorEqual, ComparisonOperatorNotEqual}
 }
 
 func (o ComparisonOperator) ValueOrDefault() string {
 	if o.IsZero() {
-		return ComparisonOperatorAbove.StringValue()
+		return ComparisonOperatorGT.StringValue()
 	}
 	return o.StringValue()
 }
@@ -426,12 +431,13 @@ func (o *ComparisonOperator) UnmarshalJSON(data []byte) error {
 		return errors.WrapInvalidInputf(err, ErrCodeDashboardInvalidInput, "invalid comparison operator: must be a string, one of `>`, `<`, `>=`, `<=`, `=`, `above`, `below`, `above_or_equal`, `below_or_equal`, `equal`, or `not_equal`")
 	}
 	if v == "" {
-		*o = ComparisonOperatorAbove
+		*o = ComparisonOperatorGT
 		return nil
 	}
 	co := ComparisonOperator{valuer.NewString(v)}
 	switch co {
-	case ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual,
+	case ComparisonOperatorGT, ComparisonOperatorLT, ComparisonOperatorGTE, ComparisonOperatorLTE, ComparisonOperatorEQ,
+		ComparisonOperatorAbove, ComparisonOperatorBelow, ComparisonOperatorAboveOrEqual, ComparisonOperatorBelowOrEqual,
 		ComparisonOperatorEqual, ComparisonOperatorNotEqual:
 		*o = co
 		return nil

pkg/types/dashboardtypes/pinned_dashboard.go

@@ -1,22 +0,0 @@
-package dashboardtypes
-
-import (
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/valuer"
-	"github.com/uptrace/bun"
-)
-
-const MaxPinnedDashboardsPerUser = 10
-
-var ErrCodePinnedDashboardLimitHit = errors.MustNewCode("pinned_dashboard_limit_hit")
-
-type PinnedDashboard struct {
-	bun.BaseModel `bun:"table:pinned_dashboard,alias:pinned_dashboard"`
-
-	UserID      valuer.UUID `bun:"user_id,pk,type:text"`
-	DashboardID valuer.UUID `bun:"dashboard_id,pk,type:text"`
-	OrgID       valuer.UUID `bun:"org_id,type:text,notnull"`
-	PinnedAt    time.Time   `bun:"pinned_at,notnull,default:current_timestamp"`
-}

pkg/types/dashboardtypes/store.go

@@ -32,34 +32,4 @@ type Store interface {
 	DeletePublic(context.Context, string) error
 
 	RunInTx(context.Context, func(context.Context) error) error
-
-	// ════════════════════════════════════════════════════════════════════════
-	// v2 dashboard methods
-	// ════════════════════════════════════════════════════════════════════════
-	GetV2(context.Context, valuer.UUID, valuer.UUID) (*StorableDashboard, *StorablePublicDashboard, error)
-
-	UpdateV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, data StorableDashboardData) error
-
-	LockUnlockV2(ctx context.Context, orgID valuer.UUID, id valuer.UUID, locked bool, updatedBy string) error
-
-	// int64 return is the total row count for the filter (pre-limit/offset),
-	ListV2(ctx context.Context, orgID valuer.UUID, userID valuer.UUID, params *ListDashboardsV2Params) ([]*DashboardListRow, int64, error)
-
-	// Returns ErrCodePinnedDashboardLimitHit when the user is at MaxPinnedDashboardsPerUser.
-	PinForUser(ctx context.Context, pd *PinnedDashboard) error
-
-	UnpinForUser(ctx context.Context, userID valuer.UUID, dashboardID valuer.UUID) error
-
-	// ════════════════════════════════════════════════════════════════════════
-	// Dashboard saved view methods
-	// ════════════════════════════════════════════════════════════════════════
-	CreateDashboardView(ctx context.Context, view *DashboardView) error
-
-	GetDashboardView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) (*DashboardView, error)
-
-	ListDashboardViews(ctx context.Context, orgID valuer.UUID) ([]*DashboardView, error)
-
-	UpdateDashboardView(ctx context.Context, view *DashboardView) error
-
-	DeleteDashboardView(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
 }

pkg/types/tagtypes/tag.go

@@ -69,14 +69,6 @@ func NewPostableTagsFromTags(tags []*Tag) []PostableTag {
 	return out
 }
 
-func NewTagsFromPostableTags(orgID valuer.UUID, kind coretypes.Kind, tags []PostableTag) []*Tag {
-	out := make([]*Tag, len(tags))
-	for i, t := range tags {
-		out[i] = NewTag(orgID, kind, t.Key, t.Value)
-	}
-	return out
-}
-
 func NewTag(orgID valuer.UUID, kind coretypes.Kind, key, value string) *Tag {
 	now := time.Now()
 	return &Tag{

pkg/types/telemetrytypes/field.go

@@ -37,7 +37,7 @@ type TelemetryFieldKey struct {
 	FieldContext  FieldContext  `json:"fieldContext,omitzero"`
 	FieldDataType FieldDataType `json:"fieldDataType,omitzero"`
 
-	JSONPlan     JSONAccessPlan               `json:"-"`
+	PlanBuilder  *FieldPlanBuilder            `json:"-"`
 	Indexes      []TelemetryFieldKeySkipIndex `json:"-"`
 	Materialized bool                         `json:"-"` // refers to promoted in case of body.... fields
 
@@ -120,7 +120,7 @@ func (f *TelemetryFieldKey) OverrideMetadataFrom(src *TelemetryFieldKey) {
 	f.FieldDataType = src.FieldDataType
 	f.Indexes = src.Indexes
 	f.Materialized = src.Materialized
-	f.JSONPlan = src.JSONPlan
+	f.PlanBuilder = src.PlanBuilder
 	f.Evolutions = src.Evolutions
 }
 

pkg/types/telemetrytypes/json_access_plan.go

@@ -6,6 +6,7 @@ import (
 	"slices"
 	"strings"
 
+	schemamigrator "github.com/SigNoz/signoz-otel-collector/cmd/signozschemamigrator/schema_migrator"
 	"github.com/SigNoz/signoz-otel-collector/exporter/jsontypeexporter"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -28,8 +29,6 @@ type JSONColumnMetadata struct {
 	PromotedColumn string
 }
 
-type JSONAccessPlan = []*JSONAccessNode
-
 type TerminalConfig struct {
 	Key      *TelemetryFieldKey
 	ElemType JSONDataType
@@ -99,23 +98,48 @@ func (n *JSONAccessNode) BranchesInOrder() []JSONAccessBranchType {
 	})
 }
 
-type planBuilder struct {
+// FieldPlanBuilder builds JSON access nodes on demand for a specific field key.
+// It holds all necessary metadata (key, column info, type cache) and produces
+// the correct root node per column, dispatching between base and promoted plans
+// by column name — without any external "is promoted?" flag.
+type FieldPlanBuilder struct {
 	key        *TelemetryFieldKey
+	columnInfo JSONColumnMetadata
+	typeCache  map[string][]FieldDataType
 	paths      []string // cumulative paths for type cache lookups
 	segments   []string // individual path segments for node names
-	isPromoted bool
-	typeCache  map[string][]FieldDataType
+}
+
+func NewFieldPlanBuilder(key *TelemetryFieldKey, info JSONColumnMetadata, typeCache map[string][]FieldDataType) *FieldPlanBuilder {
+	return &FieldPlanBuilder{key: key, columnInfo: info, typeCache: typeCache}
+}
+
+// Build dispatches by column name — called by JSONConditionBuilder in field_mapper.
+func (b *FieldPlanBuilder) Build(column schemamigrator.Column) (*JSONAccessNode, error) {
+	if column.Name == b.columnInfo.BaseColumn {
+		return b.build(NewRootJSONAccessNode(b.columnInfo.BaseColumn, 32, 0))
+	}
+	return b.build(NewRootJSONAccessNode(b.columnInfo.PromotedColumn, 32, 1024))
+}
+
+func (b *FieldPlanBuilder) build(root *JSONAccessNode) (*JSONAccessNode, error) {
+	if b.key.Name == "" {
+		return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "path is empty")
+	}
+	b.paths = b.key.ArrayParentPaths()
+	b.segments = b.key.ArrayPathSegments()
+	return b.buildPlan(0, root, false)
 }
 
 // buildPlan recursively builds the path plan tree.
-func (pb *planBuilder) buildPlan(index int, parent *JSONAccessNode, isDynArrChild bool) (*JSONAccessNode, error) {
-	if index >= len(pb.paths) {
+func (b *FieldPlanBuilder) buildPlan(index int, parent *JSONAccessNode, isDynArrChild bool) (*JSONAccessNode, error) {
+	if index >= len(b.paths) {
 		return nil, errors.NewInvalidInputf(CodePlanIndexOutOfBounds, "index is out of bounds")
 	}
 
-	pathSoFar := pb.paths[index]      // cumulative path for type cache lookup
-	segmentName := pb.segments[index] // segment name for node
-	isTerminal := index == len(pb.paths)-1
+	pathSoFar := b.paths[index]      // cumulative path for type cache lookup
+	segmentName := b.segments[index] // segment name for node
+	isTerminal := index == len(b.paths)-1
 
 	// Calculate progression parameters based on parent's values
 	var maxTypes, maxPaths int
@@ -149,18 +173,18 @@ func (pb *planBuilder) buildPlan(index int, parent *JSONAccessNode, isDynArrChil
 	// Configure terminal if this is the last part
 	if isTerminal {
 		// fielddatatype must not be unspecified else expression can not be generated
-		if pb.key.FieldDataType == FieldDataTypeUnspecified {
+		if b.key.FieldDataType == FieldDataTypeUnspecified {
 			return nil, errors.NewInternalf(CodePlanFieldDataTypeMissing, "field data type is missing for path %s", pathSoFar)
 		}
 
 		node.TerminalConfig = &TerminalConfig{
-			Key:      pb.key,
-			ElemType: pb.key.GetJSONDataType(),
+			Key:      b.key,
+			ElemType: b.key.GetJSONDataType(),
 		}
 	} else {
 		var err error
 		// Use cached types from the batched metadata query
-		types, ok := pb.typeCache[pathSoFar]
+		types, ok := b.typeCache[pathSoFar]
 		if !ok {
 			return nil, errors.NewInternalf(errors.CodeInvalidInput, "types missing for path %s", pathSoFar)
 		}
@@ -172,13 +196,13 @@ func (pb *planBuilder) buildPlan(index int, parent *JSONAccessNode, isDynArrChil
 		}
 
 		if hasJSON {
-			node.Branches[BranchJSON], err = pb.buildPlan(index+1, node, false)
+			node.Branches[BranchJSON], err = b.buildPlan(index+1, node, false)
 			if err != nil {
 				return nil, err
 			}
 		}
 		if hasDynamic {
-			node.Branches[BranchDynamic], err = pb.buildPlan(index+1, node, true)
+			node.Branches[BranchDynamic], err = b.buildPlan(index+1, node, true)
 			if err != nil {
 				return nil, err
 			}
@@ -187,45 +211,3 @@ func (pb *planBuilder) buildPlan(index int, parent *JSONAccessNode, isDynArrChil
 
 	return node, nil
 }
-
-// buildJSONAccessPlan builds a tree structure representing the complete JSON path traversal
-// that precomputes all possible branches and their types.
-func (key *TelemetryFieldKey) SetJSONAccessPlan(columnInfo JSONColumnMetadata, typeCache map[string][]FieldDataType,
-) error {
-	// if path is empty, return nil
-	if key.Name == "" {
-		return errors.NewInvalidInputf(errors.CodeInvalidInput, "path is empty")
-	}
-
-	pb := &planBuilder{
-		key:        key,
-		paths:      key.ArrayParentPaths(),
-		segments:   key.ArrayPathSegments(),
-		isPromoted: key.Materialized,
-		typeCache:  typeCache,
-	}
-
-	node, err := pb.buildPlan(0,
-		NewRootJSONAccessNode(columnInfo.BaseColumn,
-			32, 0),
-		false,
-	)
-	if err != nil {
-		return err
-	}
-	key.JSONPlan = append(key.JSONPlan, node)
-
-	if pb.isPromoted {
-		node, err := pb.buildPlan(0,
-			NewRootJSONAccessNode(columnInfo.PromotedColumn,
-				32, 1024),
-			true,
-		)
-		if err != nil {
-			return err
-		}
-		key.JSONPlan = append(key.JSONPlan, node)
-	}
-
-	return nil
-}

tests/integration/tests/dashboard/03_v2_dashboard.py

@@ -1,288 +0,0 @@
-import json
-from collections.abc import Callable
-from http import HTTPStatus
-from pathlib import Path
-
-import pytest
-import requests
-
-from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
-from fixtures.types import Operation, SigNoz
-
-_PERSES_FIXTURE = (
-    Path(__file__).parents[4]
-    / "pkg/types/dashboardtypes/dashboardtypesv2/testdata/perses.json"
-)
-
-
-def _post_dashboard(signoz: SigNoz, token: str, body: dict) -> requests.Response:
-    return requests.post(
-        signoz.self.host_configs["8080"].get("/api/v2/dashboards"),
-        json=body,
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=2,
-    )
-
-
-def test_empty_body_rejected_for_missing_schema_version(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = _post_dashboard(signoz, admin_token, {})
-
-    assert response.status_code == HTTPStatus.BAD_REQUEST
-    body = response.json()
-    assert body["status"] == "error"
-    assert body["error"]["code"] == "dashboard_invalid_input"
-    assert body["error"]["message"] == 'metadata.schemaVersion must be "v6", got ""'
-
-
-def test_missing_display_name_rejected(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = _post_dashboard(signoz, admin_token, {"metadata": {"schemaVersion": "v6"}})
-
-    assert response.status_code == HTTPStatus.BAD_REQUEST
-    body = response.json()
-    assert body["status"] == "error"
-    assert body["error"]["code"] == "dashboard_invalid_input"
-    assert body["error"]["message"] == "data.display.name is required"
-
-
-def test_minimal_valid_body_creates_dashboard(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = _post_dashboard(
-        signoz,
-        admin_token,
-        {
-            "metadata": {"schemaVersion": "v6"},
-            "data": {"display": {"name": "test name"}},
-        },
-    )
-
-    assert response.status_code == HTTPStatus.CREATED
-    body = response.json()
-    assert body["status"] == "success"
-    data = body["data"]
-    assert data["info"]["data"]["display"]["name"] == "test name"
-    assert data["info"]["metadata"]["schemaVersion"] == "v6"
-
-
-def test_unknown_root_field_rejected(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = _post_dashboard(
-        signoz,
-        admin_token,
-        {
-            "metadata": {"schemaVersion": "v6"},
-            "data": {"display": {"name": "test name"}},
-            "unknownfieldattheroot": "shouldgiveanerror",
-        },
-    )
-
-    assert response.status_code == HTTPStatus.BAD_REQUEST
-    body = response.json()
-    assert body["status"] == "error"
-    assert body["error"]["code"] == "dashboard_invalid_input"
-    assert body["error"]["message"] == 'json: unknown field "unknownfieldattheroot"'
-
-
-def test_unknown_nested_field_rejected(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    response = _post_dashboard(
-        signoz,
-        admin_token,
-        {
-            "metadata": {"schemaVersion": "v6"},
-            "data": {
-                "display": {
-                    "name": "test name",
-                    "unknownfieldinside": "shouldgiveanerror",
-                },
-            },
-        },
-    )
-
-    assert response.status_code == HTTPStatus.BAD_REQUEST
-    body = response.json()
-    assert body["status"] == "error"
-    assert body["error"]["code"] == "dashboard_invalid_input"
-    assert body["error"]["message"] == 'json: unknown field "unknownfieldinside"'
-
-
-def test_perses_fixture_creates_dashboard(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    """The perses.json fixture is the kitchen-sink dashboard the schema tests
-    use; round-tripping it through the create API exercises the full plugin
-    surface end-to-end."""
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    data = json.loads(_PERSES_FIXTURE.read_text())
-    response = _post_dashboard(
-        signoz,
-        admin_token,
-        {"metadata": {"schemaVersion": "v6"}, "data": data},
-    )
-
-    assert response.status_code == HTTPStatus.CREATED
-    body = response.json()
-    assert body["status"] == "success"
-    assert body["data"]["info"]["data"]["display"]["name"] == data["display"]["name"]
-
-
-def test_tag_casing_is_inherited_from_existing_parent(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-):
-    """A second dashboard tagged with a sibling under a casing-variant parent
-    path should adopt the existing parent's casing while keeping the
-    user-supplied casing for the new leaf segment."""
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    first = _post_dashboard(
-        signoz,
-        admin_token,
-        {
-            "metadata": {"schemaVersion": "v6"},
-            "data": {"display": {"name": "dac"}},
-            "tags": [{"name": "engineering/US/NYC"}],
-        },
-    )
-    assert first.status_code == HTTPStatus.CREATED
-    first_tags = first.json()["data"]["info"]["tags"]
-    assert first_tags == [{"name": "engineering/US/NYC"}]
-
-    second = _post_dashboard(
-        signoz,
-        admin_token,
-        {
-            "metadata": {"schemaVersion": "v6"},
-            "data": {"display": {"name": "dac"}},
-            "tags": [{"name": "engineering/us/SF"}],
-        },
-    )
-    assert second.status_code == HTTPStatus.CREATED
-    second_tags = second.json()["data"]["info"]["tags"]
-    assert second_tags == [{"name": "engineering/US/SF"}]
-
-
-# ─── list filter DSL ─────────────────────────────────────────────────────────
-# All fixtures carry a marker tag so each test query can be ANDed with
-# `tag = '__lst_v2_filter_test'` server-side. That guarantees no leakage
-# from any other test file/module sharing the session-scoped DB. The marker
-# rules out a `tag NOT EXISTS` case (a fixture that's no-tags by design
-# can't also carry the marker) — that operator is covered by the visitor
-# unit tests in pkg/types/dashboardtypes/listfilter.
-
-_LIST_FIXTURE_MARKER_TAG = "__lst_v2_filter_test"
-
-_LIST_FIXTURE_DASHBOARDS = [
-    ("lst-overview-prod", ["team/pulse", "prod", "team/frontend"]),
-    ("lst-overview-dev", ["team/pulse", "dev"]),
-    ("lst-database-prod", ["team/storage", "prod", "database/postgres"]),
-    ("lst-database-test", ["team/storage", "test", "database/redis"]),
-    ("lst-frontend-team", ["team/pulse", "team/frontend"]),
-]
-
-
-@pytest.fixture(name="list_fixture_dashboards", scope="module")
-def list_fixture_dashboards(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-) -> None:
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-    for name, tags in _LIST_FIXTURE_DASHBOARDS:
-        body: dict = {
-            "metadata": {"schemaVersion": "v6"},
-            "data": {"display": {"name": name}},
-            "tags": [{"name": t} for t in [*tags, _LIST_FIXTURE_MARKER_TAG]],
-        }
-        response = _post_dashboard(signoz, admin_token, body)
-        assert response.status_code == HTTPStatus.CREATED, response.text
-
-
-@pytest.mark.parametrize(
-    ("filter_query", "expected_names"),
-    [
-        (
-            "name = 'lst-overview-prod' AND tag = 'team/frontend'",
-            {"lst-overview-prod"},
-        ),
-        (
-            "name LIKE 'database/%' AND tag = 'team/storage'",
-            {"lst-database-prod", "lst-database-test"},
-        ),
-        (
-            "(name CONTAINS 'overview' OR name CONTAINS 'frontend') AND tag NOT IN ['dev']",
-            {"lst-overview-prod", "lst-frontend-team"},
-        ),
-        (
-            "NOT tag = 'prod' AND name CONTAINS 'lst-'",
-            {"lst-overview-dev", "lst-database-test", "lst-frontend-team"},
-        ),
-        (
-            "tag = 'team/pulse' AND tag != 'dev'",
-            {"lst-overview-prod", "lst-frontend-team"},
-        ),
-        (
-            "tag IN ['dev', 'test'] OR name = 'lst-overview-prod'",
-            {"lst-overview-dev", "lst-database-test", "lst-overview-prod"},
-        ),
-        (
-            "tag = 'team/pulse' AND tag LIKE 'database/%'",
-            {"lst-overview-dev", "lst-database-test", "lst-overview-prod"},
-        ),
-    ],
-)
-def test_list_v2_filter_dsl(
-    signoz: SigNoz,
-    create_user_admin: Operation,  # pylint: disable=unused-argument
-    get_token: Callable[[str, str], str],
-    list_fixture_dashboards: None,  # pylint: disable=unused-argument
-    filter_query: str,
-    expected_names: set[str],
-):
-    admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
-
-    scoped_query = f"({filter_query}) AND tag = '{_LIST_FIXTURE_MARKER_TAG}'"
-    response = requests.get(
-        signoz.self.host_configs["8080"].get("/api/v2/dashboards"),
-        params={"query": scoped_query, "limit": 200},
-        headers={"Authorization": f"Bearer {admin_token}"},
-        timeout=2,
-    )
-    assert response.status_code == HTTPStatus.OK, response.text
-    body = response.json()
-    assert body["status"] == "success"
-
-    returned_names = {
-        d["info"]["data"]["display"]["name"] for d in body["data"]["dashboards"]
-    }
-    assert returned_names == expected_names