feat(typography): migrate to @signozhq/ui

* refactor: move authtypes to coretypes

* refactor: migrate downstream consumers to coretypes Kind/Type/Relation

Wire all consumers of the typeable infrastructure through coretypes:
- Replace authtypes.Name/Type/Relation references with coretypes equivalents
- Switch Typeable singletons to constructor calls (authtypes.NewTypeableUser
  etc.), with the embedded coretypes.Typeable populated so Kind/Type/Prefix/
  Scope dispatch correctly through the embed
- Update dashboardtypes meta-resource declarations to use authtypes
  constructors so they expose Tuples (authz callers need it)
- Rename Resource.Name field accesses to Resource.Kind to match the field
  rename in authtypes.Resource
- Fix typeable_metaresource.go calling the plural NewTypeableMetaResources
  helper — should be the singular NewTypeableMetaResource

go build ./... and go vet ./... clean (parser-generated unreachable-code
warnings are pre-existing). Authz unit tests pass.

* refactor(audittypes): unify Action with coretypes.Relation

Drop the duplicate Action enum from audittypes — the verbs (create/update/
delete) match coretypes.Relation exactly. Move PastTense onto Relation so
audit EventName derivation continues to work without a parallel hierarchy.

Also retypes AuditDef.ResourceKind from string to coretypes.Kind so audit
declarations get the same regex validation that authz already enforces.

* refactor(retentiontypes): extract TTLSetting into its own package

TTLSetting is the bun model for ClickHouse TTL settings — has nothing to do
with the Organization domain it was previously co-located with in
pkg/types/organization.go. Moved to pkg/types/retentiontypes/ alongside the
ClickHouse reader that's its sole consumer.

No schema change; the bun table tag (table:ttl_setting) is unchanged.

* chore(openapi): regenerate spec for coretypes.Relation and Resource.Kind

* chore(frontend): regenerate API client and migrate Resource.name → Resource.kind

Regenerated TypeScript API types after the AuthtypesResource field rename
and the new CoretypesRelation enum. Updated:

- frontend/scripts/generate-permissions-type.cjs to read `r.kind` from the
  /api/v1/authz/resources response and emit `kind:` in the static
  permissions.type.ts file.
- frontend/src/hooks/useAuthZ/{permissions.type,types,utils,useAuthZ}.tsx:
  Resource.name → Resource.kind throughout.
- frontend/src/container/RolesSettings/{utils.tsx,__tests__/utils.test.ts}:
  same field migration.
- frontend/src/components/createGuardedRoute/createGuardedRoute.test.tsx:
  same.
- useAuthZ/utils.ts: cast string relations to CoretypesRelationDTO at the
  AuthtypesTransactionDTO boundary now that relation is an enum, not a raw
  string.

yarn generate:api passes (orval generation + lint + typecheck).

* refactor: migrate downstream consumers to Resource/Verb rename

* chore(openapi): regenerate spec for Resource/Verb rename

* feat(coretypes): add ListResources accessor with stable sort

* feat(cmd): add 'generate authz' subcommand for permissions type

* refactor(authz): drop runtime authz/resources endpoint

* refactor(frontend): consume static permissions.type.ts directly

* chore(frontend): regenerate Orval client without authz/resources

* ci: move authz schema check from jsci to goci

* refactor(coretypes): move Selector/Object/Transaction from authtypes

* feat(coretypes): add managed role names and permission policy

* feat(coretypes): add Registry assembling resources, types, and managed-role transactions

* refactor(authz): wire *coretypes.Registry; drop RegisterTypeable

* refactor(cmd): wire coretypes.NewRegistry into server bootstraps

* chore: regenerate openapi spec for authtypes -> coretypes type moves

* chore(frontend): regenerate API client for Authtypes -> Coretypes type moves

* refactor(coretypes): rename GettableResource to ResourceRef

* refactor(authz): collapse Registry around static data; bridge once at construction

* refactor(coretypes): tighten Registry, restore anonymous public-dashboard grant

Drops passthrough fields from coretypes.Registry; adds an O(1) lookup map
for NewResourceFromTypeAndKind; replaces stringly-typed Type compares with
Type.Equals; removes the now-redundant getUniqueTypes helper. Restores the
signoz-anonymous read grant on metaresource/public-dashboard that was
silently dropped, and removes the invalid signoz-admin/VerbCreate/TypeUser
entry that panicked at startup.

* chore: regenerate openapi spec for coretypes -> authtypes type moves

* chore(frontend): regenerate API client for Coretypes -> Authtypes type moves

* fix(authz): disambiguate kind→type by relation, preserve multi-part selectors

permissions.type.ts now lists the same kind (dashboard, role,
public-dashboard) under both metaresource and metaresources, so the prior
kind→type map silently overwrote one with the other. Resolve the type
using the requesting relation's allowed types, and slice the selector at
the first colon so multi-part selectors (e.g. id:version) round-trip
correctly. Updates useAuthZ.test.tsx to use the regenerated kind field.

* refactor(authtypes): introduce Relation wrapper over coretypes.Verb

The authz layer modeled relations as raw coretypes.Verb everywhere, which
forced authz-level concepts (action, role-binding) to share a type with
schema-level enumerations. Introduce authtypes.Relation as a thin wrapper
over coretypes.Verb so the authz APIs (CheckWithTupleCreation, ListObjects,
GetObjects, PatchObjects, NewTuples, Transaction.Relation, etc.) can grow
authz-specific affordances without leaking back into coretypes.

Also reshuffles the static coretypes data into dedicated registry_*.go files
(types, kinds, verbs, resources, managed roles) to keep the schema declarations
isolated from the value types they configure.

* refactor(authtypes): expose Relation.Enum() and regenerate openapi spec

Without an Enum() method on Relation the openapi generator emitted an
empty AuthtypesRelation schema (no allowed values). Forward the enum
from the embedded coretypes.Verb so the wire contract is faithful.

* refactor(ee/authz): drop always-nil error returns from managed-role tuple helpers

getManagedRoleGrantTuples and getManagedRoleTransactionTuples never
returned a non-nil error, which the linter (unparam) had flagged. Drop
the unused error return; callers no longer need the err check either.

* chore(frontend): regenerate API client for authtypes.Relation

* fix(authz): satisfy go-lint — keyed Relation literal, drop redundant Verb selector

* refactor(coretypes): sync Kinds slice with full registry_kind declarations

* feat(coretypes): register metaresource and metaresources for all new kinds

Adds 21 metaresource and 21 metaresources entries (covering notification-channel,
route-policy, apdex-setting, auth-domain, session, cloud-integration,
cloud-integration-service, ingestion-key, ingestion-limit, pipeline,
user-preference, org-preference, quick-filter, ttl-setting, rule,
planned-maintenance, saved-view, trace-funnel, factor-password, factor-api-key,
license) so the authz schema covers every resource Kind declared in
registry_kind. Regenerates the static frontend permissions.type.ts to match.

* feat(coretypes): populate ManagedRoleToTransactions from signozapiserver routes

Enumerates every (verb, resource) tuple each managed role holds, derived
from the AdminAccess/EditAccess/ViewAccess middleware on routes in
pkg/apiserver/signozapiserver and the legacy http_handler in
pkg/query-service/app. Admin gets 123 transactions, editor 53, viewer 25,
anonymous keeps the single public-dashboard read.

* feat(coretypes): add integration kind with full CRUD for viewer/editor/admin

Install/uninstall/list integration routes (legacy /api/v1/integrations) all
sit behind ViewAccess, so every authenticated role gets the full CRUD
surface on (metaresource, integration) and (metaresources, integration).
Regenerates the static frontend permissions.type.ts to match.

* feat(coretypes): add subscription kind alongside license, document LCRUD shape

License covers the in-product license resource (Activate/Refresh/GetActive).
Subscription is the billing lifecycle (checkout/portal/billing) served by
ee/query-service routes. Both are admin-only and modeled with a uniform
LCRUD shape; comments call out which verbs actually map to routes versus
which are placeholders for shape parity (e.g. cancellation flows through
Stripe's portal, not an in-process delete).

* feat(coretypes): model telemetryresource for logs, traces, metrics

Mirrors the telemetryresource type from ee/authz/openfgaschema/base.fga
into coretypes: a read-only Type with three Kinds (logs, traces, metrics)
matching telemetrytypes.Signal. Selector is wildcard-only for v1; future
work can narrow per-service or per-environment when the use case lands.
Every managed role (admin/editor/viewer) gets read on each signal,
matching the schema's role#assignee grant. Anonymous stays unchanged.
Regenerates the static frontend permissions.type.ts.

* feat(coretypes): add audit-logs and meter-metrics kinds under telemetryresource

Audit logs (signal=logs, source=audit) and meter metrics (signal=metrics,
source=meter) are sensitive source-qualified telemetry streams that don't
belong under the broad read-grant every role gets on regular logs/traces/
metrics. Modeled as distinct Kinds so they can be permissioned
independently. Admin-only read for now; widen on explicit ask (e.g. an
auditor flow that needs viewer access to audit-logs). Regenerates the
static frontend permissions.type.ts.

* feat(coretypes): add logs-field and traces-field kinds for stored field config

GET/POST /logs/fields and /api/v2/traces/fields manage stored, mutable
field metadata (indexed/promoted columns) over each signal. They're
configuration, not telemetry data, so they sit under metaresource rather
than telemetryresource. Viewer reads, editor/admin update; no
create/delete since POST overwrites. Plural prefix (logs-field /
traces-field) matches the signal naming.

* chore(frontend): regenerate permissions.type.ts to match generate authz output

* feat(authz): add attach permissions to fga model

* fix(tests): use role permissions instead of dashboards

* fix(authz): couple of issues with register flow

* fix(authz): public dashboard read should be anomymous

* fix(tests): integration test for public dashboard access

---------

Co-authored-by: vikrantgupta25 <vikrant@signoz.io>

.github/CODEOWNERS

@@ -107,6 +107,7 @@ go.mod @therealpandey
 /pkg/modules/organization/ @therealpandey
 /pkg/modules/authdomain/ @therealpandey
 /pkg/modules/role/ @therealpandey
+/pkg/types/coretypes/ @therealpandey @vikrantgupta25
 
 # IdentN Owners
 

.github/workflows/goci.yaml

@@ -102,3 +102,20 @@ jobs:
         run: |
           go run cmd/enterprise/*.go generate openapi
           git diff --compact-summary --exit-code || (echo; echo "Unexpected difference in openapi spec. Run go run cmd/enterprise/*.go generate openapi locally and commit."; exit 1)
+  authz:
+    if: |
+      github.event_name == 'merge_group' ||
+      (github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork && github.event.pull_request.user.login != 'dependabot[bot]' && ! contains(github.event.pull_request.labels.*.name, 'safe-to-test')) ||
+      (github.event_name == 'pull_request_target' && contains(github.event.pull_request.labels.*.name, 'safe-to-test'))
+    runs-on: ubuntu-latest
+    steps:
+      - name: self-checkout
+        uses: actions/checkout@v4
+      - name: go-install
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24"
+      - name: generate-authz
+        run: |
+          go run cmd/enterprise/*.go generate authz
+          git diff --compact-summary --exit-code || (echo; echo "Unexpected difference in authz permissions. Run go run cmd/enterprise/*.go generate authz locally and commit."; exit 1)

.github/workflows/jsci.yaml

@@ -63,46 +63,6 @@ jobs:
         uses: actions/checkout@v4
       - name: run
         run: bash frontend/scripts/validate-md-languages.sh
-  authz:
-    if: |
-      github.event_name == 'merge_group' ||
-      (github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork && github.event.pull_request.user.login != 'dependabot[bot]' && ! contains(github.event.pull_request.labels.*.name, 'safe-to-test')) ||
-      (github.event_name == 'pull_request_target' && contains(github.event.pull_request.labels.*.name, 'safe-to-test'))
-    runs-on: ubuntu-latest
-    steps:
-      - name: self-checkout
-        uses: actions/checkout@v5
-      - name: node-install
-        uses: actions/setup-node@v5
-        with:
-          node-version: "22"
-      - name: deps-install
-        working-directory: ./frontend
-        run: |
-          yarn install
-      - name: uv-install
-        uses: astral-sh/setup-uv@v5
-      - name: uv-deps
-        working-directory: ./tests/integration
-        run: |
-          uv sync
-      - name: setup-test
-        run: |
-          make py-test-setup
-      - name: generate
-        working-directory: ./frontend
-        run: |
-          yarn generate:permissions-type
-      - name: teardown-test
-        if: always()
-        run: |
-          make py-test-teardown
-      - name: validate
-        run: |
-          if ! git diff --exit-code frontend/src/hooks/useAuthZ/permissions.type.ts; then
-            echo "::error::frontend/src/hooks/useAuthZ/permissions.type.ts is out of date. Please run the generator locally and commit the changes: npm run generate:permissions-type (from the frontend directory)"
-            exit 1
-          fi
   openapi:
     if: |
       github.event_name == 'merge_group' ||

cmd/authz.go

@@ -0,0 +1,117 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"sort"
+	"text/template"
+
+	"github.com/SigNoz/signoz/pkg/types/coretypes"
+	"github.com/spf13/cobra"
+)
+
+const permissionsTypePath = "frontend/src/hooks/useAuthZ/permissions.type.ts"
+
+var permissionsTypeTemplate = template.Must(template.New("permissions").Parse(
+	`// AUTO GENERATED FILE - DO NOT EDIT - GENERATED BY cmd/enterprise/*.go generate authz
+export default {
+	status: 'success',
+	data: {
+		resources: [
+{{- range .Resources }}
+			{
+				kind: '{{ .Kind }}',
+				type: '{{ .Type }}',
+			},
+{{- end }}
+		],
+		relations: {
+{{- range .Relations }}
+			{{ .Verb }}: [{{ range $i, $t := .Types }}{{ if $i }}, {{ end }}'{{ $t }}'{{ end }}],
+{{- end }}
+		},
+	},
+} as const;
+`))
+
+type permissionsTypeRelation struct {
+	Verb  string
+	Types []string
+}
+
+type permissionsTypeResource struct {
+	Kind string
+	Type string
+}
+
+type permissionsTypeData struct {
+	Resources []permissionsTypeResource
+	Relations []permissionsTypeRelation
+}
+
+func registerGenerateAuthz(parentCmd *cobra.Command) {
+	authzCmd := &cobra.Command{
+		Use:   "authz",
+		Short: "Generate authz permissions for the frontend",
+		RunE: func(currCmd *cobra.Command, args []string) error {
+			return runGenerateAuthz(currCmd.Context())
+		},
+	}
+
+	parentCmd.AddCommand(authzCmd)
+}
+
+func runGenerateAuthz(_ context.Context) error {
+	registry := coretypes.NewRegistry()
+
+	allowedResources := map[string]bool{
+		coretypes.NewResourceRef(coretypes.ResourceServiceAccount).String():    true,
+		coretypes.NewResourceRef(coretypes.ResourceRole).String():              true,
+		coretypes.NewResourceRef(coretypes.ResourceMetaResourcesRole).String(): true,
+	}
+
+	allowedTypes := map[string]bool{}
+
+	refs := registry.ResourceRefs()
+	resources := make([]permissionsTypeResource, 0, len(refs))
+	for _, ref := range refs {
+		if !allowedResources[ref.String()] {
+			continue
+		}
+		allowedTypes[ref.Type.StringValue()] = true
+		resources = append(resources, permissionsTypeResource{
+			Kind: ref.Kind.String(),
+			Type: ref.Type.StringValue(),
+		})
+	}
+
+	typesByVerb := registry.TypesByVerb()
+	verbs := make([]coretypes.Verb, 0, len(typesByVerb))
+	for verb := range typesByVerb {
+		verbs = append(verbs, verb)
+	}
+	sort.Slice(verbs, func(i, j int) bool { return verbs[i].StringValue() < verbs[j].StringValue() })
+
+	relations := make([]permissionsTypeRelation, 0, len(verbs))
+	for _, verb := range verbs {
+		types := make([]string, 0, len(typesByVerb[verb]))
+		for _, t := range typesByVerb[verb] {
+			if !allowedTypes[t.StringValue()] {
+				continue
+			}
+			types = append(types, t.StringValue())
+		}
+		relations = append(relations, permissionsTypeRelation{
+			Verb:  verb.StringValue(),
+			Types: types,
+		})
+	}
+
+	var buf bytes.Buffer
+	if err := permissionsTypeTemplate.Execute(&buf, permissionsTypeData{Resources: resources, Relations: relations}); err != nil {
+		return err
+	}
+
+	return os.WriteFile(permissionsTypePath, buf.Bytes(), 0o600)
+}

cmd/community/server.go

@@ -92,13 +92,13 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 		func(ctx context.Context, providerSettings factory.ProviderSettings, store authtypes.AuthNStore, licensing licensing.Licensing) (map[authtypes.AuthNProvider]authn.AuthN, error) {
 			return signoz.NewAuthNs(ctx, providerSettings, store, licensing)
 		},
-		func(ctx context.Context, sqlstore sqlstore.SQLStore, _ licensing.Licensing, _ []authz.OnBeforeRoleDelete, _ dashboard.Module) (factory.ProviderFactory[authz.AuthZ, authz.Config], error) {
-			openfgaDataStore, err := openfgaserver.NewSQLStore(sqlstore)
+		func(ctx context.Context, sqlstore sqlstore.SQLStore, config authz.Config, _ licensing.Licensing, _ []authz.OnBeforeRoleDelete) (factory.ProviderFactory[authz.AuthZ, authz.Config], error) {
+			openfgaDataStore, err := openfgaserver.NewSQLStore(sqlstore, config)
 			if err != nil {
 				return nil, err
 			}
 
-			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore), nil
+			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) dashboard.Module {
 			return impldashboard.NewModule(impldashboard.NewStore(store), settings, analytics, orgGetter, queryParser)

cmd/enterprise/server.go

@@ -137,12 +137,12 @@ func runServer(ctx context.Context, config signoz.Config, logger *slog.Logger) e
 
 			return authNs, nil
 		},
-		func(ctx context.Context, sqlstore sqlstore.SQLStore, licensing licensing.Licensing, onBeforeRoleDelete []authz.OnBeforeRoleDelete, dashboardModule dashboard.Module) (factory.ProviderFactory[authz.AuthZ, authz.Config], error) {
-			openfgaDataStore, err := openfgaserver.NewSQLStore(sqlstore)
+		func(ctx context.Context, sqlstore sqlstore.SQLStore, config authz.Config, licensing licensing.Licensing, onBeforeRoleDelete []authz.OnBeforeRoleDelete) (factory.ProviderFactory[authz.AuthZ, authz.Config], error) {
+			openfgaDataStore, err := openfgaserver.NewSQLStore(sqlstore, config)
 			if err != nil {
 				return nil, err
 			}
-			return openfgaauthz.NewProviderFactory(sqlstore, openfgaschema.NewSchema().Get(ctx), openfgaDataStore, licensing, onBeforeRoleDelete, dashboardModule), nil
+			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) dashboard.Module {
 			return impldashboard.NewModule(pkgimpldashboard.NewStore(store), settings, analytics, orgGetter, queryParser, querier, licensing)

cmd/generate.go

@@ -16,6 +16,7 @@ func RegisterGenerate(parentCmd *cobra.Command, logger *slog.Logger) {
 	}
 
 	registerGenerateOpenAPI(generateCmd)
+	registerGenerateAuthz(generateCmd)
 
 	parentCmd.AddCommand(generateCmd)
 }

conf/example.yaml

@@ -13,6 +13,8 @@ global:
   ingestion_url: <unset>
   # the url of the SigNoz MCP server. when unset, the MCP settings page is hidden in the frontend.
   # mcp_url: <unset>
+  # the url of the SigNoz AI Assistant server. when unset, the AI Assistant is hidden in the frontend.
+  # ai_assistant_url: <unset>
 
 ##################### Version #####################
 version:
@@ -426,4 +428,4 @@ authz:
   provider: openfga
   openfga:
     # maximum tuples allowed per openfga write operation.
-    max_tuples_per_write: 100
+    max_tuples_per_write: 300

docs/api/openapi.yml

@@ -96,6 +96,122 @@ components:
       - createdAt
       - updatedAt
       type: object
+    AlertmanagertypesPostableChannel:
+      oneOf:
+      - required:
+        - discord_configs
+      - required:
+        - email_configs
+      - required:
+        - incidentio_configs
+      - required:
+        - pagerduty_configs
+      - required:
+        - slack_configs
+      - required:
+        - webhook_configs
+      - required:
+        - opsgenie_configs
+      - required:
+        - wechat_configs
+      - required:
+        - pushover_configs
+      - required:
+        - victorops_configs
+      - required:
+        - sns_configs
+      - required:
+        - telegram_configs
+      - required:
+        - webex_configs
+      - required:
+        - msteams_configs
+      - required:
+        - msteamsv2_configs
+      - required:
+        - jira_configs
+      - required:
+        - rocketchat_configs
+      - required:
+        - mattermost_configs
+      properties:
+        discord_configs:
+          items:
+            $ref: '#/components/schemas/ConfigDiscordConfig'
+          type: array
+        email_configs:
+          items:
+            $ref: '#/components/schemas/ConfigEmailConfig'
+          type: array
+        incidentio_configs:
+          items:
+            $ref: '#/components/schemas/ConfigIncidentioConfig'
+          type: array
+        jira_configs:
+          items:
+            $ref: '#/components/schemas/ConfigJiraConfig'
+          type: array
+        mattermost_configs:
+          items:
+            $ref: '#/components/schemas/ConfigMattermostConfig'
+          type: array
+        msteams_configs:
+          items:
+            $ref: '#/components/schemas/ConfigMSTeamsConfig'
+          type: array
+        msteamsv2_configs:
+          items:
+            $ref: '#/components/schemas/ConfigMSTeamsV2Config'
+          type: array
+        name:
+          type: string
+        opsgenie_configs:
+          items:
+            $ref: '#/components/schemas/ConfigOpsGenieConfig'
+          type: array
+        pagerduty_configs:
+          items:
+            $ref: '#/components/schemas/ConfigPagerdutyConfig'
+          type: array
+        pushover_configs:
+          items:
+            $ref: '#/components/schemas/ConfigPushoverConfig'
+          type: array
+        rocketchat_configs:
+          items:
+            $ref: '#/components/schemas/ConfigRocketchatConfig'
+          type: array
+        slack_configs:
+          items:
+            $ref: '#/components/schemas/ConfigSlackConfig'
+          type: array
+        sns_configs:
+          items:
+            $ref: '#/components/schemas/ConfigSNSConfig'
+          type: array
+        telegram_configs:
+          items:
+            $ref: '#/components/schemas/ConfigTelegramConfig'
+          type: array
+        victorops_configs:
+          items:
+            $ref: '#/components/schemas/ConfigVictorOpsConfig'
+          type: array
+        webex_configs:
+          items:
+            $ref: '#/components/schemas/ConfigWebexConfig'
+          type: array
+        webhook_configs:
+          items:
+            $ref: '#/components/schemas/ConfigWebhookConfig'
+          type: array
+        wechat_configs:
+          items:
+            $ref: '#/components/schemas/ConfigWechatConfig'
+          type: array
+      required:
+      - name
+      type: object
     AlertmanagertypesPostableRoutePolicy:
       properties:
         channels:
@@ -133,6 +249,10 @@ components:
           type: string
       type: object
     AuthtypesAuthDomainConfig:
+      oneOf:
+      - $ref: '#/components/schemas/AuthtypesSamlConfig'
+      - $ref: '#/components/schemas/AuthtypesGoogleConfig'
+      - $ref: '#/components/schemas/AuthtypesOIDCConfig'
       properties:
         googleAuthConfig:
           $ref: '#/components/schemas/AuthtypesGoogleConfig'
@@ -145,8 +265,15 @@ components:
         ssoEnabled:
           type: boolean
         ssoType:
-          type: string
+          $ref: '#/components/schemas/AuthtypesAuthNProvider'
       type: object
+    AuthtypesAuthNProvider:
+      enum:
+      - google_auth
+      - saml
+      - email_password
+      - oidc
+      type: string
     AuthtypesAuthNProviderInfo:
       properties:
         relayStatePath:
@@ -169,7 +296,7 @@ components:
     AuthtypesCallbackAuthNSupport:
       properties:
         provider:
-          type: string
+          $ref: '#/components/schemas/AuthtypesAuthNProvider'
         url:
           type: string
       type: object
@@ -177,62 +304,23 @@ components:
       properties:
         authNProviderInfo:
           $ref: '#/components/schemas/AuthtypesAuthNProviderInfo'
+        config:
+          $ref: '#/components/schemas/AuthtypesAuthDomainConfig'
         createdAt:
           format: date-time
           type: string
-        googleAuthConfig:
-          $ref: '#/components/schemas/AuthtypesGoogleConfig'
         id:
           type: string
         name:
           type: string
-        oidcConfig:
-          $ref: '#/components/schemas/AuthtypesOIDCConfig'
         orgId:
           type: string
-        roleMapping:
-          $ref: '#/components/schemas/AuthtypesRoleMapping'
-        samlConfig:
-          $ref: '#/components/schemas/AuthtypesSamlConfig'
-        ssoEnabled:
-          type: boolean
-        ssoType:
-          type: string
         updatedAt:
           format: date-time
           type: string
       required:
       - id
       type: object
-    AuthtypesGettableObjects:
-      properties:
-        resource:
-          $ref: '#/components/schemas/AuthtypesResource'
-        selectors:
-          items:
-            type: string
-          type: array
-      required:
-      - resource
-      - selectors
-      type: object
-    AuthtypesGettableResources:
-      properties:
-        relations:
-          additionalProperties:
-            items:
-              type: string
-            type: array
-          nullable: true
-          type: object
-        resources:
-          items:
-            $ref: '#/components/schemas/AuthtypesResource'
-          type: array
-      required:
-      - resources
-      - relations
-      type: object
     AuthtypesGettableToken:
       properties:
         accessToken:
@@ -249,9 +337,9 @@ components:
         authorized:
           type: boolean
         object:
-          $ref: '#/components/schemas/AuthtypesObject'
+          $ref: '#/components/schemas/CoretypesObject'
         relation:
-          type: string
+          $ref: '#/components/schemas/AuthtypesRelation'
       required:
       - relation
       - object
@@ -299,16 +387,6 @@ components:
         issuerAlias:
           type: string
       type: object
-    AuthtypesObject:
-      properties:
-        resource:
-          $ref: '#/components/schemas/AuthtypesResource'
-        selector:
-          type: string
-      required:
-      - resource
-      - selector
-      type: object
     AuthtypesOrgSessionContext:
       properties:
         authNSupport:
@@ -323,23 +401,7 @@ components:
     AuthtypesPasswordAuthNSupport:
       properties:
         provider:
-          type: string
-      type: object
-    AuthtypesPatchableObjects:
-      properties:
-        additions:
-          items:
-            $ref: '#/components/schemas/AuthtypesGettableObjects'
-          nullable: true
-          type: array
-        deletions:
-          items:
-            $ref: '#/components/schemas/AuthtypesGettableObjects'
-          nullable: true
-          type: array
-      required:
-      - additions
-      - deletions
+          $ref: '#/components/schemas/AuthtypesAuthNProvider'
       type: object
     AuthtypesPatchableRole:
       properties:
@@ -378,16 +440,15 @@ components:
         refreshToken:
           type: string
       type: object
-    AuthtypesResource:
-      properties:
-        name:
-          type: string
-        type:
-          type: string
-      required:
-      - name
-      - type
-      type: object
+    AuthtypesRelation:
+      enum:
+      - create
+      - read
+      - update
+      - delete
+      - list
+      - assignee
+      type: string
     AuthtypesRole:
       properties:
         createdAt:
@@ -451,14 +512,14 @@ components:
     AuthtypesTransaction:
       properties:
         object:
-          $ref: '#/components/schemas/AuthtypesObject'
+          $ref: '#/components/schemas/CoretypesObject'
         relation:
-          type: string
+          $ref: '#/components/schemas/AuthtypesRelation'
       required:
       - relation
       - object
       type: object
-    AuthtypesUpdateableAuthDomain:
+    AuthtypesUpdatableAuthDomain:
       properties:
         config:
           $ref: '#/components/schemas/AuthtypesAuthDomainConfig'
@@ -2088,6 +2149,64 @@ components:
         to_user:
           type: string
       type: object
+    CoretypesObject:
+      properties:
+        resource:
+          $ref: '#/components/schemas/CoretypesResourceRef'
+        selector:
+          type: string
+      required:
+      - resource
+      - selector
+      type: object
+    CoretypesObjectGroup:
+      properties:
+        resource:
+          $ref: '#/components/schemas/CoretypesResourceRef'
+        selectors:
+          items:
+            type: string
+          type: array
+      required:
+      - resource
+      - selectors
+      type: object
+    CoretypesPatchableObjects:
+      properties:
+        additions:
+          items:
+            $ref: '#/components/schemas/CoretypesObjectGroup'
+          nullable: true
+          type: array
+        deletions:
+          items:
+            $ref: '#/components/schemas/CoretypesObjectGroup'
+          nullable: true
+          type: array
+      required:
+      - additions
+      - deletions
+      type: object
+    CoretypesResourceRef:
+      properties:
+        kind:
+          type: string
+        type:
+          $ref: '#/components/schemas/CoretypesType'
+      required:
+      - type
+      - kind
+      type: object
+    CoretypesType:
+      enum:
+      - user
+      - serviceaccount
+      - anonymous
+      - role
+      - organization
+      - metaresource
+      - metaresources
+      type: string
     DashboardtypesDashboard:
       properties:
         createdAt:
@@ -2363,6 +2482,9 @@ components:
       type: object
     GlobaltypesConfig:
       properties:
+        ai_assistant_url:
+          nullable: true
+          type: string
         external_url:
           type: string
         identN:
@@ -2376,6 +2498,7 @@ components:
       - external_url
       - ingestion_url
       - mcp_url
+      - ai_assistant_url
       type: object
     GlobaltypesIdentNConfig:
       properties:
@@ -5200,6 +5323,9 @@ components:
         sub_tree_node_count:
           minimum: 0
           type: integer
+        time_unix:
+          minimum: 0
+          type: integer
         trace_id:
           type: string
         trace_state:
@@ -5580,35 +5706,6 @@ paths:
       summary: Check permissions
       tags:
       - authz
-  /api/v1/authz/resources:
-    get:
-      deprecated: false
-      description: Gets all the available resources
-      operationId: AuthzResources
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/AuthtypesGettableResources'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      summary: Get resources
-      tags:
-      - authz
   /api/v1/channels:
     get:
       deprecated: false
@@ -5665,7 +5762,7 @@ paths:
         content:
           application/json:
             schema:
-              $ref: '#/components/schemas/ConfigReceiver'
+              $ref: '#/components/schemas/AlertmanagertypesPostableChannel'
       responses:
         "201":
           content:
@@ -6944,20 +7041,20 @@ paths:
             schema:
               $ref: '#/components/schemas/AuthtypesPostableAuthDomain'
       responses:
-        "200":
+        "201":
           content:
             application/json:
               schema:
                 properties:
                   data:
-                    $ref: '#/components/schemas/AuthtypesGettableAuthDomain'
+                    $ref: '#/components/schemas/TypesIdentifiable'
                   status:
                     type: string
                 required:
                 - status
                 - data
                 type: object
-          description: OK
+          description: Created
         "400":
           content:
             application/json:
@@ -7042,6 +7139,63 @@ paths:
       summary: Delete auth domain
       tags:
       - authdomains
+    get:
+      deprecated: false
+      description: This endpoint returns an auth domain by ID
+      operationId: GetAuthDomain
+      parameters:
+      - in: path
+        name: id
+        required: true
+        schema:
+          type: string
+      responses:
+        "200":
+          content:
+            application/json:
+              schema:
+                properties:
+                  data:
+                    $ref: '#/components/schemas/AuthtypesGettableAuthDomain'
+                  status:
+                    type: string
+                required:
+                - status
+                - data
+                type: object
+          description: OK
+        "401":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Unauthorized
+        "403":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Forbidden
+        "404":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Not Found
+        "500":
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/RenderErrorResponse'
+          description: Internal Server Error
+      security:
+      - api_key:
+        - ADMIN
+      - tokenizer:
+        - ADMIN
+      summary: Get auth domain by ID
+      tags:
+      - authdomains
     put:
       deprecated: false
       description: This endpoint updates an auth domain
@@ -7056,7 +7210,7 @@ paths:
         content:
           application/json:
             schema:
-              $ref: '#/components/schemas/AuthtypesUpdateableAuthDomain'
+              $ref: '#/components/schemas/AuthtypesUpdatableAuthDomain'
       responses:
         "204":
           description: No Content
@@ -8775,7 +8929,7 @@ paths:
                 properties:
                   data:
                     items:
-                      $ref: '#/components/schemas/AuthtypesGettableObjects'
+                      $ref: '#/components/schemas/CoretypesObjectGroup'
                     type: array
                   status:
                     type: string
@@ -8848,7 +9002,7 @@ paths:
         content:
           application/json:
             schema:
-              $ref: '#/components/schemas/AuthtypesPatchableObjects'
+              $ref: '#/components/schemas/CoretypesPatchableObjects'
       responses:
         "204":
           content:

ee/authz/openfgaauthz/provider.go

@@ -2,7 +2,6 @@ package openfgaauthz
 
 import (
 	"context"
-	"slices"
 
 	"github.com/SigNoz/signoz/ee/authz/openfgaserver"
 	"github.com/SigNoz/signoz/pkg/authz"
@@ -13,6 +12,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/licensing"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/coretypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
 	openfgapkgtransformer "github.com/openfga/language/pkg/go/transformer"
@@ -25,19 +25,19 @@ type provider struct {
 	openfgaServer      *openfgaserver.Server
 	licensing          licensing.Licensing
 	store              authtypes.RoleStore
-	registry           []authz.RegisterTypeable
+	registry           *authtypes.Registry
 	settings           factory.ScopedProviderSettings
 	onBeforeRoleDelete []authz.OnBeforeRoleDelete
 }
 
-func NewProviderFactory(sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, openfgaDataStore storage.OpenFGADatastore, licensing licensing.Licensing, onBeforeRoleDelete []authz.OnBeforeRoleDelete, registry ...authz.RegisterTypeable) factory.ProviderFactory[authz.AuthZ, authz.Config] {
+func NewProviderFactory(sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, openfgaDataStore storage.OpenFGADatastore, licensing licensing.Licensing, onBeforeRoleDelete []authz.OnBeforeRoleDelete, registry *authtypes.Registry) factory.ProviderFactory[authz.AuthZ, authz.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("openfga"), func(ctx context.Context, ps factory.ProviderSettings, config authz.Config) (authz.AuthZ, error) {
 		return newOpenfgaProvider(ctx, ps, config, sqlstore, openfgaSchema, openfgaDataStore, licensing, onBeforeRoleDelete, registry)
 	})
 }
 
-func newOpenfgaProvider(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, openfgaDataStore storage.OpenFGADatastore, licensing licensing.Licensing, onBeforeRoleDelete []authz.OnBeforeRoleDelete, registry []authz.RegisterTypeable) (authz.AuthZ, error) {
-	pkgOpenfgaAuthzProvider := pkgopenfgaauthz.NewProviderFactory(sqlstore, openfgaSchema, openfgaDataStore)
+func newOpenfgaProvider(ctx context.Context, settings factory.ProviderSettings, config authz.Config, sqlstore sqlstore.SQLStore, openfgaSchema []openfgapkgtransformer.ModuleFile, openfgaDataStore storage.OpenFGADatastore, licensing licensing.Licensing, onBeforeRoleDelete []authz.OnBeforeRoleDelete, registry *authtypes.Registry) (authz.AuthZ, error) {
+	pkgOpenfgaAuthzProvider := pkgopenfgaauthz.NewProviderFactory(sqlstore, openfgaSchema, openfgaDataStore, registry)
 	pkgAuthzService, err := pkgOpenfgaAuthzProvider.New(ctx, settings, config)
 	if err != nil {
 		return nil, err
@@ -74,11 +74,11 @@ func (provider *provider) Stop(ctx context.Context) error {
 	return provider.openfgaServer.Stop(ctx)
 }
 
-func (provider *provider) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, roleSelectors []authtypes.Selector) error {
+func (provider *provider) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, typeable coretypes.Resource, selectors []coretypes.Selector, roleSelectors []coretypes.Selector) error {
 	return provider.openfgaServer.CheckWithTupleCreation(ctx, claims, orgID, relation, typeable, selectors, roleSelectors)
 }
 
-func (provider *provider) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, roleSelectors []authtypes.Selector) error {
+func (provider *provider) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, relation authtypes.Relation, typeable coretypes.Resource, selectors []coretypes.Selector, roleSelectors []coretypes.Selector) error {
 	return provider.openfgaServer.CheckWithTupleCreationWithoutClaims(ctx, orgID, relation, typeable, selectors, roleSelectors)
 }
 
@@ -108,7 +108,7 @@ func (provider *provider) CheckTransactions(ctx context.Context, subject string,
 	return results, nil
 }
 
-func (provider *provider) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, objectType authtypes.Type) ([]*authtypes.Object, error) {
+func (provider *provider) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, objectType coretypes.Type) ([]*coretypes.Object, error) {
 	return provider.openfgaServer.ListObjects(ctx, subject, relation, objectType)
 }
 
@@ -159,16 +159,10 @@ func (provider *provider) CreateManagedRoles(ctx context.Context, orgID valuer.U
 func (provider *provider) CreateManagedUserRoleTransactions(ctx context.Context, orgID valuer.UUID, userID valuer.UUID) error {
 	tuples := make([]*openfgav1.TupleKey, 0)
 
-	grantTuples, err := provider.getManagedRoleGrantTuples(orgID, userID)
-	if err != nil {
-		return err
-	}
+	grantTuples := provider.getManagedRoleGrantTuples(orgID, userID)
 	tuples = append(tuples, grantTuples...)
 
-	managedRoleTuples, err := provider.getManagedRoleTransactionTuples(orgID)
-	if err != nil {
-		return err
-	}
+	managedRoleTuples := provider.getManagedRoleTransactionTuples(orgID)
 	tuples = append(tuples, managedRoleTuples...)
 
 	return provider.Write(ctx, tuples, nil)
@@ -208,21 +202,7 @@ func (provider *provider) GetOrCreate(ctx context.Context, orgID valuer.UUID, ro
 	return role, nil
 }
 
-func (provider *provider) GetResources(_ context.Context) []*authtypes.Resource {
-	resources := make([]*authtypes.Resource, 0)
-	for _, register := range provider.registry {
-		for _, typeable := range register.MustGetTypeables() {
-			resources = append(resources, &authtypes.Resource{Name: typeable.Name(), Type: typeable.Type()})
-		}
-	}
-	for _, typeable := range provider.MustGetTypeables() {
-		resources = append(resources, &authtypes.Resource{Name: typeable.Name(), Type: typeable.Type()})
-	}
-
-	return resources
-}
-
-func (provider *provider) GetObjects(ctx context.Context, orgID valuer.UUID, id valuer.UUID, relation authtypes.Relation) ([]*authtypes.Object, error) {
+func (provider *provider) GetObjects(ctx context.Context, orgID valuer.UUID, id valuer.UUID, relation authtypes.Relation) ([]*coretypes.Object, error) {
 	_, err := provider.licensing.GetActive(ctx, orgID)
 	if err != nil {
 		return nil, errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
@@ -233,16 +213,16 @@ func (provider *provider) GetObjects(ctx context.Context, orgID valuer.UUID, id
 		return nil, err
 	}
 
-	objects := make([]*authtypes.Object, 0)
-	for _, objectType := range provider.getUniqueTypes() {
-		if !slices.Contains(authtypes.TypeableRelations[objectType], relation) {
+	objects := make([]*coretypes.Object, 0)
+	for _, objectType := range provider.registry.Types() {
+		if coretypes.ErrIfVerbNotValidForType(relation.Verb, objectType) != nil {
 			continue
 		}
 
 		resourceObjects, err := provider.
 			ListObjects(
 				ctx,
-				authtypes.MustNewSubject(authtypes.TypeableRole, storableRole.Name, orgID, &authtypes.RelationAssignee),
+				authtypes.MustNewSubject(coretypes.NewResourceRole(), storableRole.Name, orgID, &coretypes.VerbAssignee),
 				relation,
 				objectType,
 			)
@@ -265,7 +245,7 @@ func (provider *provider) Patch(ctx context.Context, orgID valuer.UUID, role *au
 	return provider.store.Update(ctx, orgID, role)
 }
 
-func (provider *provider) PatchObjects(ctx context.Context, orgID valuer.UUID, name string, relation authtypes.Relation, additions, deletions []*authtypes.Object) error {
+func (provider *provider) PatchObjects(ctx context.Context, orgID valuer.UUID, name string, relation authtypes.Relation, additions, deletions []*coretypes.Object) error {
 	_, err := provider.licensing.GetActive(ctx, orgID)
 	if err != nil {
 		return errors.New(errors.TypeLicenseUnavailable, errors.CodeLicenseUnavailable, "a valid license is not available").WithAdditional("this feature requires a valid license").WithAdditional(err.Error())
@@ -318,84 +298,63 @@ func (provider *provider) Delete(ctx context.Context, orgID valuer.UUID, id valu
 	return provider.store.Delete(ctx, orgID, id)
 }
 
-func (provider *provider) MustGetTypeables() []authtypes.Typeable {
-	return []authtypes.Typeable{authtypes.TypeableRole, authtypes.TypeableResourcesRoles}
-}
-
-func (provider *provider) getManagedRoleGrantTuples(orgID valuer.UUID, userID valuer.UUID) ([]*openfgav1.TupleKey, error) {
+func (provider *provider) getManagedRoleGrantTuples(orgID valuer.UUID, userID valuer.UUID) []*openfgav1.TupleKey {
 	tuples := []*openfgav1.TupleKey{}
 
 	// Grant the admin role to the user
-	adminSubject := authtypes.MustNewSubject(authtypes.TypeableUser, userID.String(), orgID, nil)
-	adminTuple, err := authtypes.TypeableRole.Tuples(
+	adminSubject := authtypes.MustNewSubject(coretypes.NewResourceUser(), userID.String(), orgID, nil)
+	adminTuple := authtypes.NewTuples(
+		coretypes.NewResourceRole(),
 		adminSubject,
-		authtypes.RelationAssignee,
-		[]authtypes.Selector{
-			authtypes.MustNewSelector(authtypes.TypeRole, authtypes.SigNozAdminRoleName),
-		},
+		authtypes.Relation{Verb: coretypes.VerbAssignee},
+		[]coretypes.Selector{coretypes.TypeRole.MustSelector(authtypes.SigNozAdminRoleName)},
 		orgID,
 	)
-	if err != nil {
-		return nil, err
-	}
 	tuples = append(tuples, adminTuple...)
 
 	// Grant the admin role to the anonymous user
-	anonymousSubject := authtypes.MustNewSubject(authtypes.TypeableAnonymous, authtypes.AnonymousUser.String(), orgID, nil)
-	anonymousTuple, err := authtypes.TypeableRole.Tuples(
+	anonymousSubject := authtypes.MustNewSubject(coretypes.NewResourceAnonymous(), coretypes.AnonymousUser.String(), orgID, nil)
+	anonymousTuple := authtypes.NewTuples(
+		coretypes.NewResourceRole(),
 		anonymousSubject,
-		authtypes.RelationAssignee,
-		[]authtypes.Selector{
-			authtypes.MustNewSelector(authtypes.TypeRole, authtypes.SigNozAnonymousRoleName),
-		},
+		authtypes.Relation{Verb: coretypes.VerbAssignee},
+		[]coretypes.Selector{coretypes.TypeRole.MustSelector(authtypes.SigNozAnonymousRoleName)},
 		orgID,
 	)
-	if err != nil {
-		return nil, err
-	}
 	tuples = append(tuples, anonymousTuple...)
 
-	return tuples, nil
+	return tuples
 }
 
-func (provider *provider) getManagedRoleTransactionTuples(orgID valuer.UUID) ([]*openfgav1.TupleKey, error) {
-	transactionsByRole := make(map[string][]*authtypes.Transaction)
-	for _, register := range provider.registry {
-		for roleName, txns := range register.MustGetManagedRoleTransactions() {
-			transactionsByRole[roleName] = append(transactionsByRole[roleName], txns...)
-		}
-	}
-
+func (provider *provider) getManagedRoleTransactionTuples(orgID valuer.UUID) []*openfgav1.TupleKey {
 	tuples := make([]*openfgav1.TupleKey, 0)
-	for roleName, transactions := range transactionsByRole {
+	for roleName, transactions := range provider.registry.ManagedRoleTransactions() {
 		for _, txn := range transactions {
-			typeable := authtypes.MustNewTypeableFromType(txn.Object.Resource.Type, txn.Object.Resource.Name)
-			txnTuples, err := typeable.Tuples(
+			resource := coretypes.MustNewResourceFromTypeAndKind(txn.Object.Resource.Type, txn.Object.Resource.Kind)
+			txnTuples := authtypes.NewTuples(
+				resource,
 				authtypes.MustNewSubject(
-					authtypes.TypeableRole,
+					coretypes.NewResourceRole(),
 					roleName,
 					orgID,
-					&authtypes.RelationAssignee,
+					&coretypes.VerbAssignee,
 				),
 				txn.Relation,
-				[]authtypes.Selector{txn.Object.Selector},
+				[]coretypes.Selector{txn.Object.Selector},
 				orgID,
 			)
-			if err != nil {
-				return nil, err
-			}
 			tuples = append(tuples, txnTuples...)
 		}
 	}
 
-	return tuples, nil
+	return tuples
 }
 
 func (provider *provider) deleteTuples(ctx context.Context, roleName string, orgID valuer.UUID) error {
-	subject := authtypes.MustNewSubject(authtypes.TypeableRole, roleName, orgID, &authtypes.RelationAssignee)
+	subject := authtypes.MustNewSubject(coretypes.NewResourceRole(), roleName, orgID, &coretypes.VerbAssignee)
 
 	tuples := make([]*openfgav1.TupleKey, 0)
-	for _, objectType := range provider.getUniqueTypes() {
+	for _, objectType := range provider.registry.Types() {
 		typeTuples, err := provider.ReadTuples(ctx, &openfgav1.ReadRequestTupleKey{
 			User:   subject,
 			Object: objectType.StringValue() + ":",
@@ -424,28 +383,3 @@ func (provider *provider) deleteTuples(ctx context.Context, roleName string, org
 
 	return nil
 }
-
-func (provider *provider) getUniqueTypes() []authtypes.Type {
-	seen := make(map[string]struct{})
-	uniqueTypes := make([]authtypes.Type, 0)
-	for _, register := range provider.registry {
-		for _, typeable := range register.MustGetTypeables() {
-			typeKey := typeable.Type().StringValue()
-			if _, ok := seen[typeKey]; ok {
-				continue
-			}
-			seen[typeKey] = struct{}{}
-			uniqueTypes = append(uniqueTypes, typeable.Type())
-		}
-	}
-	for _, typeable := range provider.MustGetTypeables() {
-		typeKey := typeable.Type().StringValue()
-		if _, ok := seen[typeKey]; ok {
-			continue
-		}
-		seen[typeKey] = struct{}{}
-		uniqueTypes = append(uniqueTypes, typeable.Type())
-	}
-
-	return uniqueTypes
-}

ee/authz/openfgaschema/base.fga

@@ -1,6 +1,6 @@
 module base
 
-type organisation 
+type organization 
   relations
     define read: [user, serviceaccount, role#assignee]
     define update: [user, serviceaccount, role#assignee]
@@ -10,12 +10,14 @@ type user
     define read: [user, serviceaccount, role#assignee]
     define update: [user, serviceaccount, role#assignee]
     define delete: [user, serviceaccount, role#assignee]
+    define attach: [user, serviceaccount, role#assignee]
 
-type serviceaccount 
+type serviceaccount
   relations
     define read: [user, serviceaccount, role#assignee]
     define update: [user, serviceaccount, role#assignee]
-    define delete: [user, serviceaccount, role#assignee]  
+    define delete: [user, serviceaccount, role#assignee]
+    define attach: [user, serviceaccount, role#assignee]
 
 type anonymous
 
@@ -26,6 +28,7 @@ type role
     define read: [user, serviceaccount, role#assignee]
     define update: [user, serviceaccount, role#assignee]
     define delete: [user, serviceaccount, role#assignee]
+    define attach: [user, serviceaccount, role#assignee]
 
 type metaresources
   relations

ee/authz/openfgaserver/server.go

@@ -7,6 +7,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/coretypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	openfgav1 "github.com/openfga/api/proto/openfga/v1"
 )
@@ -33,18 +34,18 @@ func (server *Server) Stop(ctx context.Context) error {
 	return server.pkgAuthzService.Stop(ctx)
 }
 
-func (server *Server) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, _ []authtypes.Selector) error {
+func (server *Server) CheckWithTupleCreation(ctx context.Context, claims authtypes.Claims, orgID valuer.UUID, relation authtypes.Relation, typeable coretypes.Resource, selectors []coretypes.Selector, _ []coretypes.Selector) error {
 	subject := ""
 	switch claims.Principal {
 	case authtypes.PrincipalUser:
-		user, err := authtypes.NewSubject(authtypes.TypeableUser, claims.UserID, orgID, nil)
+		user, err := authtypes.NewSubject(coretypes.NewResourceUser(), claims.UserID, orgID, nil)
 		if err != nil {
 			return err
 		}
 
 		subject = user
 	case authtypes.PrincipalServiceAccount:
-		serviceAccount, err := authtypes.NewSubject(authtypes.TypeableServiceAccount, claims.ServiceAccountID, orgID, nil)
+		serviceAccount, err := authtypes.NewSubject(coretypes.NewResourceServiceAccount(), claims.ServiceAccountID, orgID, nil)
 		if err != nil {
 			return err
 		}
@@ -52,10 +53,7 @@ func (server *Server) CheckWithTupleCreation(ctx context.Context, claims authtyp
 		subject = serviceAccount
 	}
 
-	tupleSlice, err := typeable.Tuples(subject, relation, selectors, orgID)
-	if err != nil {
-		return err
-	}
+	tupleSlice := authtypes.NewTuples(typeable, subject, relation, selectors, orgID)
 
 	tuples := make(map[string]*openfgav1.TupleKey, len(tupleSlice))
 	for idx, tuple := range tupleSlice {
@@ -76,16 +74,13 @@ func (server *Server) CheckWithTupleCreation(ctx context.Context, claims authtyp
 	return errors.Newf(errors.TypeForbidden, authtypes.ErrCodeAuthZForbidden, "subjects are not authorized for requested access")
 }
 
-func (server *Server) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, relation authtypes.Relation, typeable authtypes.Typeable, selectors []authtypes.Selector, _ []authtypes.Selector) error {
-	subject, err := authtypes.NewSubject(authtypes.TypeableAnonymous, authtypes.AnonymousUser.String(), orgID, nil)
+func (server *Server) CheckWithTupleCreationWithoutClaims(ctx context.Context, orgID valuer.UUID, relation authtypes.Relation, typeable coretypes.Resource, selectors []coretypes.Selector, _ []coretypes.Selector) error {
+	subject, err := authtypes.NewSubject(coretypes.NewResourceAnonymous(), coretypes.AnonymousUser.String(), orgID, nil)
 	if err != nil {
 		return err
 	}
 
-	tupleSlice, err := typeable.Tuples(subject, relation, selectors, orgID)
-	if err != nil {
-		return err
-	}
+	tupleSlice := authtypes.NewTuples(typeable, subject, relation, selectors, orgID)
 
 	tuples := make(map[string]*openfgav1.TupleKey, len(tupleSlice))
 	for idx, tuple := range tupleSlice {
@@ -110,7 +105,7 @@ func (server *Server) BatchCheck(ctx context.Context, tupleReq map[string]*openf
 	return server.pkgAuthzService.BatchCheck(ctx, tupleReq)
 }
 
-func (server *Server) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, objectType authtypes.Type) ([]*authtypes.Object, error) {
+func (server *Server) ListObjects(ctx context.Context, subject string, relation authtypes.Relation, objectType coretypes.Type) ([]*coretypes.Object, error) {
 	return server.pkgAuthzService.ListObjects(ctx, subject, relation, objectType)
 }
 

ee/authz/openfgaserver/sqlstore.go

@@ -2,6 +2,7 @@ package openfgaserver
 
 import (
 	"github.com/SigNoz/signoz/ee/sqlstore/postgressqlstore"
+	"github.com/SigNoz/signoz/pkg/authz"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/sqlstore"
 	"github.com/openfga/openfga/pkg/storage"
@@ -10,11 +11,11 @@ import (
 	"github.com/openfga/openfga/pkg/storage/sqlite"
 )
 
-func NewSQLStore(store sqlstore.SQLStore) (storage.OpenFGADatastore, error) {
+func NewSQLStore(store sqlstore.SQLStore, config authz.Config) (storage.OpenFGADatastore, error) {
 	switch store.BunDB().Dialect().Name().String() {
 	case "sqlite":
 		return sqlite.NewWithDB(store.SQLDB(), &sqlcommon.Config{
-			MaxTuplesPerWriteField: 100,
+			MaxTuplesPerWriteField: config.OpenFGA.MaxTuplesPerWrite,
 			MaxTypesPerModelField:  100,
 		})
 	case "pg":
@@ -24,7 +25,7 @@ func NewSQLStore(store sqlstore.SQLStore) (storage.OpenFGADatastore, error) {
 		}
 
 		return postgres.NewWithDB(pgStore.Pool(), nil, &sqlcommon.Config{
-			MaxTuplesPerWriteField: 100,
+			MaxTuplesPerWriteField: config.OpenFGA.MaxTuplesPerWrite,
 			MaxTypesPerModelField:  100,
 		})
 	}

ee/modules/dashboard/impldashboard/module.go

@@ -14,7 +14,7 @@ import (
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/queryparser"
 	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
+	"github.com/SigNoz/signoz/pkg/types/coretypes"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
 	"github.com/SigNoz/signoz/pkg/types/dashboardtypes"
 	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
@@ -88,7 +88,7 @@ func (module *module) GetDashboardByPublicID(ctx context.Context, id valuer.UUID
 	return dashboardtypes.NewDashboardFromStorableDashboard(storableDashboard), nil
 }
 
-func (module *module) GetPublicDashboardSelectorsAndOrg(ctx context.Context, id valuer.UUID, orgs []*types.Organization) ([]authtypes.Selector, valuer.UUID, error) {
+func (module *module) GetPublicDashboardSelectorsAndOrg(ctx context.Context, id valuer.UUID, orgs []*types.Organization) ([]coretypes.Selector, valuer.UUID, error) {
 	orgIDs := make([]string, len(orgs))
 	for idx, org := range orgs {
 		orgIDs[idx] = org.ID.StringValue()
@@ -99,9 +99,9 @@ func (module *module) GetPublicDashboardSelectorsAndOrg(ctx context.Context, id
 		return nil, valuer.UUID{}, err
 	}
 
-	return []authtypes.Selector{
-		authtypes.MustNewSelector(authtypes.TypeMetaResource, id.StringValue()),
-		authtypes.MustNewSelector(authtypes.TypeMetaResource, authtypes.WildCardSelectorString),
+	return []coretypes.Selector{
+		coretypes.TypeMetaResource.MustSelector(id.StringValue()),
+		coretypes.TypeMetaResource.MustSelector(coretypes.WildCardSelectorString),
 	}, storableDashboard.OrgID, nil
 }
 
@@ -217,28 +217,6 @@ func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valu
 	return module.pkgDashboardModule.LockUnlock(ctx, orgID, id, updatedBy, isAdmin, lock)
 }
 
-func (module *module) MustGetTypeables() []authtypes.Typeable {
-	return module.pkgDashboardModule.MustGetTypeables()
-}
-
-func (module *module) MustGetManagedRoleTransactions() map[string][]*authtypes.Transaction {
-	return map[string][]*authtypes.Transaction{
-		authtypes.SigNozAnonymousRoleName: {
-			{
-				ID:       valuer.GenerateUUID(),
-				Relation: authtypes.RelationRead,
-				Object: *authtypes.MustNewObject(
-					authtypes.Resource{
-						Type: authtypes.TypeMetaResource,
-						Name: dashboardtypes.TypeableMetaResourcePublicDashboard.Name(),
-					},
-					authtypes.MustNewSelector(authtypes.TypeMetaResource, "*"),
-				),
-			},
-		},
-	}
-}
-
 func (module *module) deletePublic(ctx context.Context, _ valuer.UUID, dashboardID valuer.UUID) error {
 	return module.store.DeletePublic(ctx, dashboardID.StringValue())
 }

ee/query-service/app/api/queryrange.go

@@ -6,6 +6,8 @@ import (
 	"io"
 	"net/http"
 
+	"log/slog"
+
 	"github.com/SigNoz/signoz/ee/query-service/anomaly"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/http/render"
@@ -15,7 +17,6 @@ import (
 	v3 "github.com/SigNoz/signoz/pkg/query-service/model/v3"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
-	"log/slog"
 )
 
 func (aH *APIHandler) queryRangeV4(w http.ResponseWriter, r *http.Request) {
@@ -137,4 +138,3 @@ func (aH *APIHandler) queryRangeV4(w http.ResponseWriter, r *http.Request) {
 		aH.QueryRangeV4(w, r)
 	}
 }
-

ee/query-service/app/server.go

@@ -42,8 +42,8 @@ import (
 
 // Server runs HTTP, Mux and a grpc server
 type Server struct {
-	config      signoz.Config
-	signoz      *signoz.SigNoz
+	config signoz.Config
+	signoz *signoz.SigNoz
 
 	// public http router
 	httpConn     net.Listener
@@ -148,7 +148,7 @@ func NewServer(config signoz.Config, signoz *signoz.SigNoz) (*Server, error) {
 
 	s := &Server{
 		config:             config,
-		signoz:       signoz,
+		signoz:             signoz,
 		httpHostPort:       baseconst.HTTPHostPort,
 		unavailableChannel: make(chan healthcheck.Status),
 		usageManager:       usageManager,
@@ -317,4 +317,3 @@ func (s *Server) Stop(ctx context.Context) error {
 
 	return nil
 }
-

frontend/.oxfmtrc.json

@@ -23,6 +23,11 @@
     "**/*.md",
     "**/*.json",
     "src/parser/**",
-    "src/TraceOperator/parser/**"
+    "src/TraceOperator/parser/**",
+    ".claude",
+    ".opencode",
+    "dist",
+    "playwright-report",
+    ".temp_cache"
   ]
 }

frontend/.oxlintrc.json

@@ -289,6 +289,8 @@
     // Prevents navigator.clipboard - use useCopyToClipboard hook instead (disabled in tests via override)
     "signoz/no-raw-absolute-path": "error",
     // Prevents window.open(path), window.location.origin + path, window.location.href = path
+    "signoz/no-antd-components": "error",
+    // Prevents the usage of specific antd components in favor of our lib
     "no-restricted-globals": [
       "error",
       {

frontend/__mocks__/uplotMock.ts

@@ -1,53 +1,51 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
 // Mock for uplot library used in tests
-import { type Mock, vi } from 'vitest';
-
 export interface MockUPlotInstance {
-	setData: Mock;
-	setSize: Mock;
-	destroy: Mock;
-	redraw: Mock;
-	setSeries: Mock;
+	setData: jest.Mock;
+	setSize: jest.Mock;
+	destroy: jest.Mock;
+	redraw: jest.Mock;
+	setSeries: jest.Mock;
 }
 
 export interface MockUPlotPaths {
-	spline: Mock;
-	bars: Mock;
-	linear: Mock;
-	stepped: Mock;
+	spline: jest.Mock;
+	bars: jest.Mock;
+	linear: jest.Mock;
+	stepped: jest.Mock;
 }
 
 // Create mock instance methods
 const createMockUPlotInstance = (): MockUPlotInstance => ({
-	setData: vi.fn(),
-	setSize: vi.fn(),
-	destroy: vi.fn(),
-	redraw: vi.fn(),
-	setSeries: vi.fn(),
+	setData: jest.fn(),
+	setSize: jest.fn(),
+	destroy: jest.fn(),
+	redraw: jest.fn(),
+	setSeries: jest.fn(),
 });
 
 // Path builder: (self, seriesIdx, idx0, idx1) => paths or null
-const createMockPathBuilder = (name: string): Mock =>
-	vi.fn(() => ({
+const createMockPathBuilder = (name: string): jest.Mock =>
+	jest.fn(() => ({
 		name, // To test if the correct pathBuilder is used
-		stroke: vi.fn(),
-		fill: vi.fn(),
-		clip: vi.fn(),
+		stroke: jest.fn(),
+		fill: jest.fn(),
+		clip: jest.fn(),
 	}));
 
 // Create mock paths - linear, spline, stepped needed by UPlotSeriesBuilder.getPathBuilder
 const mockPaths = {
-	spline: vi.fn(() => createMockPathBuilder('spline')),
-	bars: vi.fn(() => createMockPathBuilder('bars')),
-	linear: vi.fn(() => createMockPathBuilder('linear')),
-	stepped: vi.fn((opts?: { align?: number }) =>
+	spline: jest.fn(() => createMockPathBuilder('spline')),
+	bars: jest.fn(() => createMockPathBuilder('bars')),
+	linear: jest.fn(() => createMockPathBuilder('linear')),
+	stepped: jest.fn((opts?: { align?: number }) =>
 		createMockPathBuilder(`stepped-(${opts?.align ?? 0})`),
 	),
 };
 
 // Mock static methods
-const mockTzDate = vi.fn(
+const mockTzDate = jest.fn(
 	(date: Date, _timezone: string) => new Date(date.getTime()),
 );
 

frontend/__mocks__/useSafeNavigate.ts

@@ -1,6 +1,4 @@
 // Mock for useSafeNavigate hook to avoid React Router version conflicts in tests
-import { type MockedFunction, vi } from 'vitest';
-
 interface SafeNavigateOptions {
 	replace?: boolean;
 	state?: unknown;
@@ -16,15 +14,15 @@ interface SafeNavigateTo {
 type SafeNavigateToType = string | SafeNavigateTo;
 
 interface UseSafeNavigateReturn {
-	safeNavigate: MockedFunction<
+	safeNavigate: jest.MockedFunction<
 		(to: SafeNavigateToType, options?: SafeNavigateOptions) => void
 	>;
 }
 
 export const useSafeNavigate = (): UseSafeNavigateReturn => ({
-	safeNavigate: vi.fn(
+	safeNavigate: jest.fn(
 		(_to: SafeNavigateToType, _options?: SafeNavigateOptions) => {},
-	) as MockedFunction<
+	) as jest.MockedFunction<
 		(to: SafeNavigateToType, options?: SafeNavigateOptions) => void
 	>,
 });

frontend/package.json

@@ -15,15 +15,15 @@
     "lint:generated": "oxlint ./src/api/generated --fix",
     "lint:fix": "oxlint ./src --fix",
     "lint:styles": "stylelint \"src/**/*.scss\"",
-    "postinstall": "yarn i18n:generate-hash && (is-ci || yarn husky:configure)  && node scripts/update-registry.cjs && patch-package",
+    "jest": "jest",
+    "jest:coverage": "jest --coverage",
+    "jest:watch": "jest --watch",
+    "postinstall": "yarn i18n:generate-hash && (is-ci || yarn husky:configure)  && node scripts/update-registry.cjs",
     "husky:configure": "cd .. && husky install frontend/.husky && cd frontend && chmod ug+x .husky/*",
     "commitlint": "commitlint --edit $1",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "test:changedsince": "vitest run --changed HEAD~1 --coverage",
-    "generate:api": "orval --config ./orval.config.ts && sh scripts/post-types-generation.sh",
-    "generate:permissions-type": "node scripts/generate-permissions-type.cjs"
+    "test": "jest",
+    "test:changedsince": "jest --changedSince=main --coverage --silent",
+    "generate:api": "orval --config ./orval.config.ts && sh scripts/post-types-generation.sh"
   },
   "engines": {
     "node": ">=22.0.0"
@@ -50,7 +50,7 @@
     "@signozhq/design-tokens": "2.1.4",
     "@signozhq/icons": "0.1.0",
     "@signozhq/resizable": "0.0.2",
-    "@signozhq/ui": "0.0.12",
+    "@signozhq/ui": "0.0.14",
     "@tanstack/react-table": "8.21.3",
     "@tanstack/react-virtual": "3.13.22",
     "@uiw/codemirror-theme-copilot": "4.23.11",
@@ -170,7 +170,7 @@
     "@commitlint/config-conventional": "^20.4.2",
     "@faker-js/faker": "9.3.0",
     "@jest/globals": "30.2.0",
-    "@testing-library/jest-dom": "6.9.1",
+    "@testing-library/jest-dom": "5.16.5",
     "@testing-library/react": "13.4.0",
     "@testing-library/user-event": "14.4.3",
     "@types/color": "^3.0.3",
@@ -198,11 +198,9 @@
     "@types/styled-components": "^5.1.4",
     "@types/uuid": "^8.3.1",
     "@typescript/native-preview": "7.0.0-dev.20260421.2",
-    "@vitest/coverage-v8": "4.1.5",
     "autoprefixer": "10.4.19",
     "babel-plugin-styled-components": "^1.12.0",
     "eslint-plugin-sonarjs": "4.0.2",
-    "happy-dom": "20.9.0",
     "husky": "^7.0.4",
     "imagemin": "^8.0.1",
     "imagemin-svgo": "^10.0.1",
@@ -217,7 +215,6 @@
     "oxfmt": "0.47.0",
     "oxlint": "1.62.0",
     "oxlint-tsgolint": "0.22.1",
-    "patch-package": "8.0.1",
     "portfinder-sync": "^0.0.2",
     "postcss": "8.5.6",
     "postcss-scss": "4.0.9",
@@ -234,15 +231,15 @@
     "ts-jest": "29.4.6",
     "ts-node": "^10.2.1",
     "typescript-plugin-css-modules": "5.2.0",
+    "use-sync-external-store": "1.6.0",
     "vite-plugin-checker": "0.12.0",
     "vite-plugin-compression": "0.5.1",
     "vite-plugin-image-optimizer": "2.0.3",
-    "vite-tsconfig-paths": "6.1.1",
-    "vitest": "4.1.5"
+    "vite-tsconfig-paths": "6.1.1"
   },
   "lint-staged": {
     "*.(js|jsx|ts|tsx)": [
-      "oxlint --fix --quiet",
+      "oxlint --fix",
       "oxfmt --write",
       "sh -c tsgo --noEmit"
     ],

frontend/patches/@mswjs+interceptors+0.17.10.patch

@@ -1,46 +0,0 @@
-diff --git a/node_modules/@mswjs/interceptors/lib/interceptors/XMLHttpRequest/XMLHttpRequestOverride.js b/node_modules/@mswjs/interceptors/lib/interceptors/XMLHttpRequest/XMLHttpRequestOverride.js
-index 2480e76..67208c4 100644
---- a/node_modules/@mswjs/interceptors/lib/interceptors/XMLHttpRequest/XMLHttpRequestOverride.js
-+++ b/node_modules/@mswjs/interceptors/lib/interceptors/XMLHttpRequest/XMLHttpRequestOverride.js
-@@ -345,7 +345,14 @@ var createXMLHttpRequestOverride = function (options) {
-                 });
-             };
-             XMLHttpRequestOverride.prototype.abort = function () {
--                this.log('abort');
-+                if (typeof this.log === 'function') {
-+                    this.log('abort');
-+                }
-+                if (typeof this.setReadyState !== 'function' ||
-+                    typeof this.trigger !== 'function' ||
-+                    typeof this.readyState !== 'number') {
-+                    return;
-+                }
-                 if (this.readyState > this.UNSENT && this.readyState < this.DONE) {
-                     this.setReadyState(this.UNSENT);
-                     this.trigger('abort');
-@@ -459,14 +466,17 @@ var createXMLHttpRequestOverride = function (options) {
-                     }
-                     finally { if (e_2) throw e_2.error; }
-                 }
--                request.onabort = this.abort;
--                request.onerror = this.onerror;
--                request.ontimeout = this.ontimeout;
--                request.onload = this.onload;
--                request.onloadstart = this.onloadstart;
--                request.onloadend = this.onloadend;
--                request.onprogress = this.onprogress;
--                request.onreadystatechange = this.onreadystatechange;
-+                request.abort = this.abort.bind(this);
-+                request.onabort = this.abort.bind(this);
-+                request.onerror = this.onerror ? this.onerror.bind(this) : null;
-+                request.ontimeout = this.ontimeout ? this.ontimeout.bind(this) : null;
-+                request.onload = this.onload ? this.onload.bind(this) : null;
-+                request.onloadstart = this.onloadstart ? this.onloadstart.bind(this) : null;
-+                request.onloadend = this.onloadend ? this.onloadend.bind(this) : null;
-+                request.onprogress = this.onprogress ? this.onprogress.bind(this) : null;
-+                request.onreadystatechange = this.onreadystatechange
-+                    ? this.onreadystatechange.bind(this)
-+                    : null;
-             };
-             /**
-              * Propagates the mock XMLHttpRequest instance listeners

frontend/plugins/rules/no-antd-components.mjs

@@ -0,0 +1,66 @@
+/**
+ * Rule: no-antd-components
+ *
+ * Prevents importing specific components from antd.
+ *
+ * This rule catches patterns like:
+ *   import { Typography } from 'antd'
+ *   import { Typography, Button } from 'antd'
+ *   import Typography from 'antd/es/typography'
+ *   import { Text } from 'antd/es/typography'
+ *
+ * Add components to BANNED_COMPONENTS to ban them.
+ * Key should be PascalCase component name, will match lowercase path too.
+ */
+
+const BANNED_COMPONENTS = {
+	Typography: 'Use @signozhq/ui Typography instead of antd Typography.',
+};
+
+export default {
+	create(context) {
+		return {
+			ImportDeclaration(node) {
+				const source = node.source.value;
+
+				// Check direct antd import: import { Typography } from 'antd'
+				if (source === 'antd') {
+					for (const specifier of node.specifiers) {
+						if (specifier.type !== 'ImportSpecifier') {
+							continue;
+						}
+
+						const importedName = specifier.imported.name;
+						const message = BANNED_COMPONENTS[importedName];
+
+						if (message) {
+							context.report({
+								node: specifier,
+								message: `Do not import '${importedName}' from antd. ${message}`,
+							});
+						}
+					}
+					return;
+				}
+
+				// Check antd/es/<component> import: import Typography from 'antd/es/typography'
+				const match = source.match(/^antd\/es\/([^/]+)/);
+				if (!match) {
+					return;
+				}
+
+				const pathComponent = match[1].toLowerCase();
+
+				for (const [componentName, message] of Object.entries(BANNED_COMPONENTS)) {
+					if (pathComponent === componentName.toLowerCase()) {
+						context.report({
+							node,
+							message: `Do not import from '${source}'. ${message}`,
+						});
+						break;
+					}
+				}
+			},
+		};
+	},
+};

frontend/plugins/signoz.mjs

@@ -9,6 +9,7 @@ import noZustandGetStateInHooks from './rules/no-zustand-getstate-in-hooks.mjs';
 import noNavigatorClipboard from './rules/no-navigator-clipboard.mjs';
 import noUnsupportedAssetPattern from './rules/no-unsupported-asset-pattern.mjs';
 import noRawAbsolutePath from './rules/no-raw-absolute-path.mjs';
+import noAntdComponents from './rules/no-antd-components.mjs';
 
 export default {
 	meta: {
@@ -19,5 +20,6 @@ export default {
 		'no-navigator-clipboard': noNavigatorClipboard,
 		'no-unsupported-asset-pattern': noUnsupportedAssetPattern,
 		'no-raw-absolute-path': noRawAbsolutePath,
+		'no-antd-components': noAntdComponents,
 	},
 };

frontend/scripts/generate-permissions-type.cjs

@@ -1,199 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-const axios = require('axios');
-
-const PERMISSIONS_TYPE_FILE = path.join(
-	__dirname,
-	'../src/hooks/useAuthZ/permissions.type.ts',
-);
-
-const SIGNOZ_INTEGRATION_IMAGE = 'signoz:integration';
-const LOCAL_BACKEND_URL = 'http://localhost:8080';
-
-function log(message) {
-	console.log(`[generate-permissions-type] ${message}`);
-}
-
-function getBackendUrlFromDocker() {
-	try {
-		const output = execSync(
-			`docker ps --filter "ancestor=${SIGNOZ_INTEGRATION_IMAGE}" --format "{{.Ports}}"`,
-			{ encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] },
-		).trim();
-
-		if (!output) {
-			return null;
-		}
-
-		const portMatch = output.match(/0\.0\.0\.0:(\d+)->8080\/tcp/);
-		if (portMatch) {
-			return `http://localhost:${portMatch[1]}`;
-		}
-
-		const ipv6Match = output.match(/:::(\d+)->8080\/tcp/);
-		if (ipv6Match) {
-			return `http://localhost:${ipv6Match[1]}`;
-		}
-	} catch (err) {
-		log(`Warning: Could not get port from docker: ${err.message}`);
-	}
-	return null;
-}
-
-async function checkBackendHealth(url, maxAttempts = 3, delayMs = 1000) {
-	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-		try {
-			await axios.get(`${url}/api/v1/health`, {
-				timeout: 5000,
-				validateStatus: (status) => status === 200,
-			});
-			return true;
-		} catch (err) {
-			if (attempt < maxAttempts) {
-				await new Promise((r) => setTimeout(r, delayMs));
-			}
-		}
-	}
-	return false;
-}
-
-async function discoverBackendUrl() {
-	const dockerUrl = getBackendUrlFromDocker();
-	if (dockerUrl) {
-		log(`Found ${SIGNOZ_INTEGRATION_IMAGE} container, trying ${dockerUrl}...`);
-		if (await checkBackendHealth(dockerUrl)) {
-			log(`Backend found at ${dockerUrl} (from py-test-setup)`);
-			return dockerUrl;
-		}
-		log(`Backend at ${dockerUrl} is not responding`);
-	}
-
-	log(`Trying local backend at ${LOCAL_BACKEND_URL}...`);
-	if (await checkBackendHealth(LOCAL_BACKEND_URL)) {
-		log(`Backend found at ${LOCAL_BACKEND_URL}`);
-		return LOCAL_BACKEND_URL;
-	}
-
-	return null;
-}
-
-async function fetchResources(backendUrl) {
-	log('Fetching resources from API...');
-	const resourcesUrl = `${backendUrl}/api/v1/authz/resources`;
-
-	const { data: response } = await axios.get(resourcesUrl);
-
-	return response;
-}
-
-function transformResponse(apiResponse) {
-	if (!apiResponse.data) {
-		throw new Error('Invalid API response: missing data field');
-	}
-
-	const { resources, relations } = apiResponse.data;
-
-	return {
-		status: apiResponse.status || 'success',
-		data: {
-			resources: resources,
-			relations: relations,
-		},
-	};
-}
-
-function generateTypeScriptFile(data) {
-	const resourcesStr = data.data.resources
-		.map(
-			(r) =>
-				`\t\t\t{\n\t\t\t\tname: '${r.name}',\n\t\t\t\ttype: '${r.type}',\n\t\t\t},`,
-		)
-		.join('\n');
-
-	const relationsStr = Object.entries(data.data.relations)
-		.map(
-			([type, relations]) =>
-				`\t\t\t${type}: [${relations.map((r) => `'${r}'`).join(', ')}],`,
-		)
-		.join('\n');
-
-	return `// AUTO GENERATED FILE - DO NOT EDIT - GENERATED BY scripts/generate-permissions-type
-export default {
-\tstatus: '${data.status}',
-\tdata: {
-\t\tresources: [
-${resourcesStr}
-\t\t],
-\t\trelations: {
-${relationsStr}
-\t\t},
-\t},
-} as const;
-`;
-}
-
-async function main() {
-	try {
-		log('Starting permissions type generation...');
-
-		const backendUrl = await discoverBackendUrl();
-
-		if (!backendUrl) {
-			console.error('\n' + '='.repeat(80));
-			console.error('ERROR: No running SigNoz backend found!');
-			console.error('='.repeat(80));
-			console.error(
-				'\nThe permissions type generator requires a running SigNoz backend.',
-			);
-			console.error('\nFor local development, start the backend with:');
-			console.error('  make go-run-enterprise');
-			console.error(
-				'\nFor CI or integration testing, start the test environment with:',
-			);
-			console.error('  make py-test-setup');
-			console.error(
-				'\nIf running in CI and seeing this error, check that the py-test-setup',
-			);
-			console.error('step completed successfully before this step runs.');
-			console.error('='.repeat(80) + '\n');
-			process.exit(1);
-		}
-
-		log('Fetching resources...');
-		const apiResponse = await fetchResources(backendUrl);
-
-		log('Transforming response...');
-		const transformed = transformResponse(apiResponse);
-
-		log('Generating TypeScript file...');
-		const content = generateTypeScriptFile(transformed);
-
-		log(`Writing to ${PERMISSIONS_TYPE_FILE}...`);
-		fs.writeFileSync(PERMISSIONS_TYPE_FILE, content, 'utf8');
-
-		const rootDir = path.join(__dirname, '../..');
-		const relativePath = path.relative(
-			path.join(rootDir, 'frontend'),
-			PERMISSIONS_TYPE_FILE,
-		);
-		log('Linting generated file...');
-		execSync(`cd frontend && yarn oxlint ${relativePath}`, {
-			cwd: rootDir,
-			stdio: 'inherit',
-		});
-
-		log('Successfully generated permissions.type.ts');
-	} catch (error) {
-		log(`Error: ${error.message}`);
-		process.exit(1);
-	}
-}
-
-if (require.main === module) {
-	main();
-}
-
-module.exports = { main };

frontend/src/AppRoutes/__tests__/Private.test.tsx

@@ -1,4 +1,3 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ReactElement } from 'react';
 import { QueryClient, QueryClientProvider } from 'react-query';
 import { MemoryRouter, Route, Switch, useLocation } from 'react-router-dom';
@@ -23,13 +22,13 @@ import { ROLES, USER_ROLES } from 'types/roles';
 import PrivateRoute from '../Private';
 
 // Mock localStorage APIs
-const mockLocalStorage = vi.hoisted((): Record<string, string> => ({}));
-vi.mock('api/browser/localstorage/get', () => ({
+const mockLocalStorage: Record<string, string> = {};
+jest.mock('api/browser/localstorage/get', () => ({
 	__esModule: true,
 	default: (key: string): string | null => mockLocalStorage[key] || null,
 }));
 
-vi.mock('api/browser/localstorage/set', () => ({
+jest.mock('api/browser/localstorage/set', () => ({
 	__esModule: true,
 	default: (key: string, value: string): void => {
 		mockLocalStorage[key] = value;
@@ -37,29 +36,27 @@ vi.mock('api/browser/localstorage/set', () => ({
 }));
 
 // Mock useGetTenantLicense hook
-const mockTenantLicense = vi.hoisted(() => ({ isCloudUser: true }));
-vi.mock('hooks/useGetTenantLicense', () => ({
+let mockIsCloudUser = true;
+jest.mock('hooks/useGetTenantLicense', () => ({
 	useGetTenantLicense: (): {
 		isCloudUser: boolean;
 		isEnterpriseSelfHostedUser: boolean;
 		isCommunityUser: boolean;
 		isCommunityEnterpriseUser: boolean;
 	} => ({
-		isCloudUser: mockTenantLicense.isCloudUser,
-		isEnterpriseSelfHostedUser: !mockTenantLicense.isCloudUser,
+		isCloudUser: mockIsCloudUser,
+		isEnterpriseSelfHostedUser: !mockIsCloudUser,
 		isCommunityUser: false,
 		isCommunityEnterpriseUser: false,
 	}),
 }));
 
 // Mock react-query for users fetch
-const mockUsers = vi.hoisted((): { data: { email: string }[] } => ({
-	data: [],
-}));
-vi.mock('api/generated/services/users', async () => ({
-	...(await vi.importActual('api/generated/services/users')),
-	useListUsers: vi.fn(() => ({
-		data: { data: mockUsers.data },
+let mockUsersData: { email: string }[] = [];
+jest.mock('api/generated/services/users', () => ({
+	...jest.requireActual('api/generated/services/users'),
+	useListUsers: jest.fn(() => ({
+		data: { data: mockUsersData },
 		isFetching: false,
 	})),
 }));
@@ -179,13 +176,13 @@ function createMockAppContext(
 		orgPreferencesFetchError: null,
 		changelog: null,
 		showChangelogModal: false,
-		activeLicenseRefetch: vi.fn(),
-		updateUser: vi.fn(),
-		updateOrgPreferences: vi.fn(),
-		updateUserPreferenceInContext: vi.fn(),
-		updateOrg: vi.fn(),
-		updateChangelog: vi.fn(),
-		toggleChangelogModal: vi.fn(),
+		activeLicenseRefetch: jest.fn(),
+		updateUser: jest.fn(),
+		updateOrgPreferences: jest.fn(),
+		updateUserPreferenceInContext: jest.fn(),
+		updateOrg: jest.fn(),
+		updateChangelog: jest.fn(),
+		toggleChangelogModal: jest.fn(),
 		versionData: { version: '1.0.0', ee: 'Y', setupCompleted: true },
 		hasEditPermission: true,
 		...overrides,
@@ -205,7 +202,7 @@ function renderPrivateRoute(options: RenderPrivateRouteOptions = {}): void {
 		isCloudUser = true,
 	} = options;
 
-	mockTenantLicense.isCloudUser = isCloudUser;
+	mockIsCloudUser = isCloudUser;
 
 	const contextValue = createMockAppContext(appContext);
 
@@ -248,11 +245,11 @@ function assertRendersChildren(): void {
 
 describe('PrivateRoute', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 		queryClient.clear();
 		Object.keys(mockLocalStorage).forEach((key) => delete mockLocalStorage[key]);
-		mockTenantLicense.isCloudUser = true;
-		mockUsers.data = [];
+		mockIsCloudUser = true;
+		mockUsersData = [];
 	});
 
 	describe('Old Routes Handling', () => {
@@ -1017,7 +1014,7 @@ describe('PrivateRoute', () => {
 	describe('Onboarding Flow (Cloud Users)', () => {
 		it('should redirect to onboarding when first user has not completed onboarding', async () => {
 			// Set up exactly one user (not admin@signoz.cloud) to trigger first user check
-			mockUsers.data = [{ email: 'test@example.com' }];
+			mockUsersData = [{ email: 'test@example.com' }];
 
 			renderPrivateRoute({
 				initialRoute: ROUTES.HOME,
@@ -1056,7 +1053,7 @@ describe('PrivateRoute', () => {
 		it('should not redirect to onboarding when onboarding is already complete', async () => {
 			// Set up first user condition - this ensures the ONLY reason we don't redirect
 			// is because isOnboardingComplete is true
-			mockUsers.data = [{ email: 'test@example.com' }];
+			mockUsersData = [{ email: 'test@example.com' }];
 
 			renderPrivateRoute({
 				initialRoute: ROUTES.HOME,
@@ -1127,7 +1124,7 @@ describe('PrivateRoute', () => {
 		it('should not redirect to onboarding when workspace is blocked and accessing billing', async () => {
 			// This tests the scenario where admin tries to access billing to fix payment
 			// while workspace is blocked and onboarding is not complete
-			mockUsers.data = [{ email: 'test@example.com' }];
+			mockUsersData = [{ email: 'test@example.com' }];
 
 			renderPrivateRoute({
 				initialRoute: ROUTES.BILLING,
@@ -1152,7 +1149,7 @@ describe('PrivateRoute', () => {
 		});
 
 		it('should not redirect to onboarding when workspace is blocked and accessing settings', async () => {
-			mockUsers.data = [{ email: 'test@example.com' }];
+			mockUsersData = [{ email: 'test@example.com' }];
 
 			renderPrivateRoute({
 				initialRoute: ROUTES.SETTINGS,
@@ -1176,7 +1173,7 @@ describe('PrivateRoute', () => {
 		});
 
 		it('should not redirect to onboarding when workspace is suspended (DEFAULTED)', async () => {
-			mockUsers.data = [{ email: 'test@example.com' }];
+			mockUsersData = [{ email: 'test@example.com' }];
 
 			renderPrivateRoute({
 				initialRoute: ROUTES.HOME,
@@ -1203,7 +1200,7 @@ describe('PrivateRoute', () => {
 		});
 
 		it('should not redirect to onboarding when workspace is access restricted (TERMINATED)', async () => {
-			mockUsers.data = [{ email: 'test@example.com' }];
+			mockUsersData = [{ email: 'test@example.com' }];
 
 			renderPrivateRoute({
 				initialRoute: ROUTES.HOME,
@@ -1230,7 +1227,7 @@ describe('PrivateRoute', () => {
 		});
 
 		it('should not redirect to onboarding when workspace is access restricted (EXPIRED)', async () => {
-			mockUsers.data = [{ email: 'test@example.com' }];
+			mockUsersData = [{ email: 'test@example.com' }];
 
 			renderPrivateRoute({
 				initialRoute: ROUTES.HOME,

frontend/src/api/browser/localstorage/__tests__/get.test.ts

@@ -1,23 +1,22 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
 /**
  * localstorage/get — lazy migration tests.
  *
- * basePath is memoized at module init, so each test re-imports the module with
- * a fresh DOM state via vi.resetModules and dynamic import.
+ * basePath is memoized at module init, so each describe block re-imports the
+ * module with a fresh DOM state via jest.isolateModules.
  */
 
 type GetModule = typeof import('../get');
 
-async function loadGetModule(href: string): Promise<GetModule> {
+function loadGetModule(href: string): GetModule {
 	const base = document.createElement('base');
 	base.setAttribute('href', href);
 	document.head.append(base);
 
-	vi.resetModules();
-	const mod = await import('../get');
-	base.remove();
-
+	let mod!: GetModule;
+	jest.isolateModules(() => {
+		// oxlint-disable-next-line typescript-eslint/no-require-imports, typescript-eslint/no-var-requires
+		mod = require('../get');
+	});
 	return mod;
 }
 
@@ -29,19 +28,19 @@ afterEach(() => {
 });
 
 describe('get — root path "/"', () => {
-	it('reads the bare key', async () => {
-		const { default: get } = await loadGetModule('/');
+	it('reads the bare key', () => {
+		const { default: get } = loadGetModule('/');
 		localStorage.setItem('AUTH_TOKEN', 'tok');
 		expect(get('AUTH_TOKEN')).toBe('tok');
 	});
 
-	it('returns null when key is absent', async () => {
-		const { default: get } = await loadGetModule('/');
+	it('returns null when key is absent', () => {
+		const { default: get } = loadGetModule('/');
 		expect(get('MISSING')).toBeNull();
 	});
 
-	it('does NOT promote bare keys (no-op at root)', async () => {
-		const { default: get } = await loadGetModule('/');
+	it('does NOT promote bare keys (no-op at root)', () => {
+		const { default: get } = loadGetModule('/');
 		localStorage.setItem('THEME', 'light');
 		get('THEME');
 		// bare key must still be present — no migration at root
@@ -50,19 +49,19 @@ describe('get — root path "/"', () => {
 });
 
 describe('get — prefixed path "/signoz/"', () => {
-	it('reads an already-scoped key directly', async () => {
-		const { default: get } = await loadGetModule('/signoz/');
+	it('reads an already-scoped key directly', () => {
+		const { default: get } = loadGetModule('/signoz/');
 		localStorage.setItem('/signoz/AUTH_TOKEN', 'scoped-tok');
 		expect(get('AUTH_TOKEN')).toBe('scoped-tok');
 	});
 
-	it('returns null when neither scoped nor bare key exists', async () => {
-		const { default: get } = await loadGetModule('/signoz/');
+	it('returns null when neither scoped nor bare key exists', () => {
+		const { default: get } = loadGetModule('/signoz/');
 		expect(get('MISSING')).toBeNull();
 	});
 
-	it('lazy-migrates bare key to scoped key on first read', async () => {
-		const { default: get } = await loadGetModule('/signoz/');
+	it('lazy-migrates bare key to scoped key on first read', () => {
+		const { default: get } = loadGetModule('/signoz/');
 		localStorage.setItem('AUTH_TOKEN', 'old-tok');
 
 		const result = get('AUTH_TOKEN');
@@ -72,8 +71,8 @@ describe('get — prefixed path "/signoz/"', () => {
 		expect(localStorage.getItem('AUTH_TOKEN')).toBeNull();
 	});
 
-	it('scoped key takes precedence over bare key', async () => {
-		const { default: get } = await loadGetModule('/signoz/');
+	it('scoped key takes precedence over bare key', () => {
+		const { default: get } = loadGetModule('/signoz/');
 		localStorage.setItem('AUTH_TOKEN', 'bare-tok');
 		localStorage.setItem('/signoz/AUTH_TOKEN', 'scoped-tok');
 
@@ -82,8 +81,8 @@ describe('get — prefixed path "/signoz/"', () => {
 		expect(localStorage.getItem('AUTH_TOKEN')).toBe('bare-tok');
 	});
 
-	it('subsequent reads after migration use scoped key (no double-write)', async () => {
-		const { default: get } = await loadGetModule('/signoz/');
+	it('subsequent reads after migration use scoped key (no double-write)', () => {
+		const { default: get } = loadGetModule('/signoz/');
 		localStorage.setItem('THEME', 'dark');
 
 		get('THEME'); // triggers migration
@@ -95,15 +94,31 @@ describe('get — prefixed path "/signoz/"', () => {
 });
 
 describe('get — two-prefix isolation', () => {
-	it('/signoz/ and /testing/ do not share migrated values', async () => {
+	it('/signoz/ and /testing/ do not share migrated values', () => {
 		localStorage.setItem('THEME', 'light');
 
-		const { default: getSignoz } = await loadGetModule('/signoz/');
+		const base1 = document.createElement('base');
+		base1.setAttribute('href', '/signoz/');
+		document.head.append(base1);
+		let getSignoz!: GetModule['default'];
+		jest.isolateModules(() => {
+			// oxlint-disable-next-line typescript-eslint/no-require-imports, typescript-eslint/no-var-requires
+			getSignoz = require('../get').default;
+		});
+		base1.remove();
 
 		// migrate bare → /signoz/THEME
 		getSignoz('THEME');
 
-		const { default: getTesting } = await loadGetModule('/testing/');
+		const base2 = document.createElement('base');
+		base2.setAttribute('href', '/testing/');
+		document.head.append(base2);
+		let getTesting!: GetModule['default'];
+		jest.isolateModules(() => {
+			// oxlint-disable-next-line typescript-eslint/no-require-imports, typescript-eslint/no-var-requires
+			getTesting = require('../get').default;
+		});
+		base2.remove();
 
 		// /testing/ prefix: bare key already gone, scoped key does not exist
 		expect(getTesting('THEME')).toBeNull();

frontend/src/api/browser/sessionstorage/__tests__/get.test.ts

@@ -1,5 +1,3 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
 /**
  * sessionstorage/get — lazy migration tests.
  * Mirrors the localStorage get tests; same logic, different storage.
@@ -7,13 +5,17 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 
 type GetModule = typeof import('../get');
 
-async function loadGetModule(href: string): Promise<GetModule> {
+function loadGetModule(href: string): GetModule {
 	const base = document.createElement('base');
 	base.setAttribute('href', href);
 	document.head.append(base);
 
-	vi.resetModules();
-	return import('../get');
+	let mod!: GetModule;
+	jest.isolateModules(() => {
+		// oxlint-disable-next-line typescript-eslint/no-require-imports, typescript-eslint/no-var-requires
+		mod = require('../get');
+	});
+	return mod;
 }
 
 afterEach(() => {
@@ -24,19 +26,19 @@ afterEach(() => {
 });
 
 describe('get — root path "/"', () => {
-	it('reads the bare key', async () => {
-		const { default: get } = await loadGetModule('/');
+	it('reads the bare key', () => {
+		const { default: get } = loadGetModule('/');
 		sessionStorage.setItem('retry-lazy-refreshed', 'true');
 		expect(get('retry-lazy-refreshed')).toBe('true');
 	});
 
-	it('returns null when key is absent', async () => {
-		const { default: get } = await loadGetModule('/');
+	it('returns null when key is absent', () => {
+		const { default: get } = loadGetModule('/');
 		expect(get('MISSING')).toBeNull();
 	});
 
-	it('does NOT promote bare keys at root', async () => {
-		const { default: get } = await loadGetModule('/');
+	it('does NOT promote bare keys at root', () => {
+		const { default: get } = loadGetModule('/');
 		sessionStorage.setItem('retry-lazy-refreshed', 'true');
 		get('retry-lazy-refreshed');
 		expect(sessionStorage.getItem('retry-lazy-refreshed')).toBe('true');
@@ -44,19 +46,19 @@ describe('get — root path "/"', () => {
 });
 
 describe('get — prefixed path "/signoz/"', () => {
-	it('reads an already-scoped key directly', async () => {
-		const { default: get } = await loadGetModule('/signoz/');
+	it('reads an already-scoped key directly', () => {
+		const { default: get } = loadGetModule('/signoz/');
 		sessionStorage.setItem('/signoz/retry-lazy-refreshed', 'true');
 		expect(get('retry-lazy-refreshed')).toBe('true');
 	});
 
-	it('returns null when neither scoped nor bare key exists', async () => {
-		const { default: get } = await loadGetModule('/signoz/');
+	it('returns null when neither scoped nor bare key exists', () => {
+		const { default: get } = loadGetModule('/signoz/');
 		expect(get('MISSING')).toBeNull();
 	});
 
-	it('lazy-migrates bare key to scoped key on first read', async () => {
-		const { default: get } = await loadGetModule('/signoz/');
+	it('lazy-migrates bare key to scoped key on first read', () => {
+		const { default: get } = loadGetModule('/signoz/');
 		sessionStorage.setItem('retry-lazy-refreshed', 'true');
 
 		const result = get('retry-lazy-refreshed');
@@ -66,8 +68,8 @@ describe('get — prefixed path "/signoz/"', () => {
 		expect(sessionStorage.getItem('retry-lazy-refreshed')).toBeNull();
 	});
 
-	it('scoped key takes precedence over bare key', async () => {
-		const { default: get } = await loadGetModule('/signoz/');
+	it('scoped key takes precedence over bare key', () => {
+		const { default: get } = loadGetModule('/signoz/');
 		sessionStorage.setItem('retry-lazy-refreshed', 'bare');
 		sessionStorage.setItem('/signoz/retry-lazy-refreshed', 'scoped');
 

frontend/src/api/dynamicVariables/__tests__/getFieldKeys.test.ts

@@ -1,18 +1,15 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
 import axios from 'api';
 
 import { getFieldKeys } from '../getFieldKeys';
 
 // Mock the API instance
-vi.mock('api', () => ({
-	default: {
-		get: vi.fn(),
-	},
+jest.mock('api', () => ({
+	get: jest.fn(),
 }));
 
 describe('getFieldKeys API', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 	});
 
 	const mockSuccessResponse = {
@@ -31,7 +28,7 @@ describe('getFieldKeys API', () => {
 
 	it('should call API with correct parameters when no args provided', async () => {
 		// Mock successful API response
-		vi.mocked(axios.get).mockResolvedValueOnce(mockSuccessResponse);
+		(axios.get as jest.Mock).mockResolvedValueOnce(mockSuccessResponse);
 
 		// Call function with no parameters
 		await getFieldKeys();
@@ -44,7 +41,7 @@ describe('getFieldKeys API', () => {
 
 	it('should call API with signal parameter when provided', async () => {
 		// Mock successful API response
-		vi.mocked(axios.get).mockResolvedValueOnce(mockSuccessResponse);
+		(axios.get as jest.Mock).mockResolvedValueOnce(mockSuccessResponse);
 
 		// Call function with signal parameter
 		await getFieldKeys('traces');
@@ -57,7 +54,7 @@ describe('getFieldKeys API', () => {
 
 	it('should call API with name parameter when provided', async () => {
 		// Mock successful API response
-		vi.mocked(axios.get).mockResolvedValueOnce({
+		(axios.get as jest.Mock).mockResolvedValueOnce({
 			status: 200,
 			data: {
 				status: 'success',
@@ -79,7 +76,7 @@ describe('getFieldKeys API', () => {
 
 	it('should call API with both signal and name when provided', async () => {
 		// Mock successful API response
-		vi.mocked(axios.get).mockResolvedValueOnce({
+		(axios.get as jest.Mock).mockResolvedValueOnce({
 			status: 200,
 			data: {
 				status: 'success',
@@ -101,7 +98,7 @@ describe('getFieldKeys API', () => {
 
 	it('should return properly formatted response', async () => {
 		// Mock API to return our response
-		vi.mocked(axios.get).mockResolvedValueOnce(mockSuccessResponse);
+		(axios.get as jest.Mock).mockResolvedValueOnce(mockSuccessResponse);
 
 		// Call the function
 		const result = await getFieldKeys('traces');

frontend/src/api/dynamicVariables/__tests__/getFieldValues.test.ts

@@ -1,23 +1,20 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
 import axios from 'api';
 
 import { getFieldValues } from '../getFieldValues';
 
 // Mock the API instance
-vi.mock('api', () => ({
-	default: {
-		get: vi.fn(),
-	},
+jest.mock('api', () => ({
+	get: jest.fn(),
 }));
 
 describe('getFieldValues API', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 	});
 
 	it('should call the API with correct parameters (no options)', async () => {
 		// Mock API response
-		vi.mocked(axios.get).mockResolvedValueOnce({
+		(axios.get as jest.Mock).mockResolvedValueOnce({
 			status: 200,
 			data: {
 				status: 'success',
@@ -41,7 +38,7 @@ describe('getFieldValues API', () => {
 
 	it('should call the API with signal parameter', async () => {
 		// Mock API response
-		vi.mocked(axios.get).mockResolvedValueOnce({
+		(axios.get as jest.Mock).mockResolvedValueOnce({
 			status: 200,
 			data: {
 				status: 'success',
@@ -65,7 +62,7 @@ describe('getFieldValues API', () => {
 
 	it('should call the API with name parameter', async () => {
 		// Mock API response
-		vi.mocked(axios.get).mockResolvedValueOnce({
+		(axios.get as jest.Mock).mockResolvedValueOnce({
 			status: 200,
 			data: {
 				status: 'success',
@@ -89,7 +86,7 @@ describe('getFieldValues API', () => {
 
 	it('should call the API with value parameter', async () => {
 		// Mock API response
-		vi.mocked(axios.get).mockResolvedValueOnce({
+		(axios.get as jest.Mock).mockResolvedValueOnce({
 			status: 200,
 			data: {
 				status: 'success',
@@ -113,7 +110,7 @@ describe('getFieldValues API', () => {
 
 	it('should call the API with time range parameters', async () => {
 		// Mock API response
-		vi.mocked(axios.get).mockResolvedValueOnce({
+		(axios.get as jest.Mock).mockResolvedValueOnce({
 			status: 200,
 			data: {
 				status: 'success',
@@ -165,7 +162,7 @@ describe('getFieldValues API', () => {
 			},
 		};
 
-		vi.mocked(axios.get).mockResolvedValueOnce(mockResponse);
+		(axios.get as jest.Mock).mockResolvedValueOnce(mockResponse);
 
 		// Call the function
 		const result = await getFieldValues('traces', 'mixed.values');
@@ -196,7 +193,7 @@ describe('getFieldValues API', () => {
 		};
 
 		// Mock API to return our response
-		vi.mocked(axios.get).mockResolvedValueOnce(mockApiResponse);
+		(axios.get as jest.Mock).mockResolvedValueOnce(mockApiResponse);
 
 		// Call the function
 		const result = await getFieldValues('traces', 'service.name');

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

@@ -19,9 +19,11 @@ import type {
 
 import type {
 	AuthtypesPostableAuthDomainDTO,
-	AuthtypesUpdateableAuthDomainDTO,
-	CreateAuthDomain200,
+	AuthtypesUpdatableAuthDomainDTO,
+	CreateAuthDomain201,
 	DeleteAuthDomainPathParameters,
+	GetAuthDomain200,
+	GetAuthDomainPathParameters,
 	ListAuthDomains200,
 	RenderErrorResponseDTO,
 	UpdateAuthDomainPathParameters,
@@ -124,7 +126,7 @@ export const createAuthDomain = (
 	authtypesPostableAuthDomainDTO: BodyType<AuthtypesPostableAuthDomainDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<CreateAuthDomain200>({
+	return GeneratedAPIInstance<CreateAuthDomain201>({
 		url: `/api/v1/domains`,
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },
@@ -277,19 +279,122 @@ export const useDeleteAuthDomain = <
 
 	return useMutation(mutationOptions);
 };
+/**
+ * This endpoint returns an auth domain by ID
+ * @summary Get auth domain by ID
+ */
+export const getAuthDomain = (
+	{ id }: GetAuthDomainPathParameters,
+	signal?: AbortSignal,
+) => {
+	return GeneratedAPIInstance<GetAuthDomain200>({
+		url: `/api/v1/domains/${id}`,
+		method: 'GET',
+		signal,
+	});
+};
+
+export const getGetAuthDomainQueryKey = ({
+	id,
+}: GetAuthDomainPathParameters) => {
+	return [`/api/v1/domains/${id}`] as const;
+};
+
+export const getGetAuthDomainQueryOptions = <
+	TData = Awaited<ReturnType<typeof getAuthDomain>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	{ id }: GetAuthDomainPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getAuthDomain>>,
+			TError,
+			TData
+		>;
+	},
+) => {
+	const { query: queryOptions } = options ?? {};
+
+	const queryKey = queryOptions?.queryKey ?? getGetAuthDomainQueryKey({ id });
+
+	const queryFn: QueryFunction<Awaited<ReturnType<typeof getAuthDomain>>> = ({
+		signal,
+	}) => getAuthDomain({ id }, signal);
+
+	return {
+		queryKey,
+		queryFn,
+		enabled: !!id,
+		...queryOptions,
+	} as UseQueryOptions<
+		Awaited<ReturnType<typeof getAuthDomain>>,
+		TError,
+		TData
+	> & { queryKey: QueryKey };
+};
+
+export type GetAuthDomainQueryResult = NonNullable<
+	Awaited<ReturnType<typeof getAuthDomain>>
+>;
+export type GetAuthDomainQueryError = ErrorType<RenderErrorResponseDTO>;
+
+/**
+ * @summary Get auth domain by ID
+ */
+
+export function useGetAuthDomain<
+	TData = Awaited<ReturnType<typeof getAuthDomain>>,
+	TError = ErrorType<RenderErrorResponseDTO>,
+>(
+	{ id }: GetAuthDomainPathParameters,
+	options?: {
+		query?: UseQueryOptions<
+			Awaited<ReturnType<typeof getAuthDomain>>,
+			TError,
+			TData
+		>;
+	},
+): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+	const queryOptions = getGetAuthDomainQueryOptions({ id }, options);
+
+	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
+		queryKey: QueryKey;
+	};
+
+	query.queryKey = queryOptions.queryKey;
+
+	return query;
+}
+
+/**
+ * @summary Get auth domain by ID
+ */
+export const invalidateGetAuthDomain = async (
+	queryClient: QueryClient,
+	{ id }: GetAuthDomainPathParameters,
+	options?: InvalidateOptions,
+): Promise<QueryClient> => {
+	await queryClient.invalidateQueries(
+		{ queryKey: getGetAuthDomainQueryKey({ id }) },
+		options,
+	);
+
+	return queryClient;
+};
+
 /**
  * This endpoint updates an auth domain
  * @summary Update auth domain
  */
 export const updateAuthDomain = (
 	{ id }: UpdateAuthDomainPathParameters,
-	authtypesUpdateableAuthDomainDTO: BodyType<AuthtypesUpdateableAuthDomainDTO>,
+	authtypesUpdatableAuthDomainDTO: BodyType<AuthtypesUpdatableAuthDomainDTO>,
 ) => {
 	return GeneratedAPIInstance<void>({
 		url: `/api/v1/domains/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
-		data: authtypesUpdateableAuthDomainDTO,
+		data: authtypesUpdatableAuthDomainDTO,
 	});
 };
 
@@ -302,7 +407,7 @@ export const getUpdateAuthDomainMutationOptions = <
 		TError,
 		{
 			pathParams: UpdateAuthDomainPathParameters;
-			data: BodyType<AuthtypesUpdateableAuthDomainDTO>;
+			data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 		},
 		TContext
 	>;
@@ -311,7 +416,7 @@ export const getUpdateAuthDomainMutationOptions = <
 	TError,
 	{
 		pathParams: UpdateAuthDomainPathParameters;
-		data: BodyType<AuthtypesUpdateableAuthDomainDTO>;
+		data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 	},
 	TContext
 > => {
@@ -328,7 +433,7 @@ export const getUpdateAuthDomainMutationOptions = <
 		Awaited<ReturnType<typeof updateAuthDomain>>,
 		{
 			pathParams: UpdateAuthDomainPathParameters;
-			data: BodyType<AuthtypesUpdateableAuthDomainDTO>;
+			data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -343,7 +448,7 @@ export type UpdateAuthDomainMutationResult = NonNullable<
 	Awaited<ReturnType<typeof updateAuthDomain>>
 >;
 export type UpdateAuthDomainMutationBody =
-	BodyType<AuthtypesUpdateableAuthDomainDTO>;
+	BodyType<AuthtypesUpdatableAuthDomainDTO>;
 export type UpdateAuthDomainMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -358,7 +463,7 @@ export const useUpdateAuthDomain = <
 		TError,
 		{
 			pathParams: UpdateAuthDomainPathParameters;
-			data: BodyType<AuthtypesUpdateableAuthDomainDTO>;
+			data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 		},
 		TContext
 	>;
@@ -367,7 +472,7 @@ export const useUpdateAuthDomain = <
 	TError,
 	{
 		pathParams: UpdateAuthDomainPathParameters;
-		data: BodyType<AuthtypesUpdateableAuthDomainDTO>;
+		data: BodyType<AuthtypesUpdatableAuthDomainDTO>;
 	},
 	TContext
 > => {

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

@@ -4,23 +4,16 @@
  * * regenerate with 'yarn generate:api'
  * SigNoz
  */
-import { useMutation, useQuery } from 'react-query';
+import { useMutation } from 'react-query';
 import type {
-	InvalidateOptions,
 	MutationFunction,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
 	UseMutationOptions,
 	UseMutationResult,
-	UseQueryOptions,
-	UseQueryResult,
 } from 'react-query';
 
 import type {
 	AuthtypesTransactionDTO,
 	AuthzCheck200,
-	AuthzResources200,
 	RenderErrorResponseDTO,
 } from '../sigNoz.schemas';
 
@@ -110,88 +103,3 @@ export const useAuthzCheck = <
 
 	return useMutation(mutationOptions);
 };
-/**
- * Gets all the available resources
- * @summary Get resources
- */
-export const authzResources = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<AuthzResources200>({
-		url: `/api/v1/authz/resources`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getAuthzResourcesQueryKey = () => {
-	return [`/api/v1/authz/resources`] as const;
-};
-
-export const getAuthzResourcesQueryOptions = <
-	TData = Awaited<ReturnType<typeof authzResources>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof authzResources>>,
-		TError,
-		TData
-	>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getAuthzResourcesQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof authzResources>>> = ({
-		signal,
-	}) => authzResources(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof authzResources>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type AuthzResourcesQueryResult = NonNullable<
-	Awaited<ReturnType<typeof authzResources>>
->;
-export type AuthzResourcesQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get resources
- */
-
-export function useAuthzResources<
-	TData = Awaited<ReturnType<typeof authzResources>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<
-		Awaited<ReturnType<typeof authzResources>>,
-		TError,
-		TData
-	>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getAuthzResourcesQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	query.queryKey = queryOptions.queryKey;
-
-	return query;
-}
-
-/**
- * @summary Get resources
- */
-export const invalidateAuthzResources = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getAuthzResourcesQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};

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

@@ -18,6 +18,7 @@ import type {
 } from 'react-query';
 
 import type {
+	AlertmanagertypesPostableChannelDTO,
 	ConfigReceiverDTO,
 	CreateChannel201,
 	DeleteChannelByIDPathParameters,
@@ -122,14 +123,14 @@ export const invalidateListChannels = async (
  * @summary Create notification channel
  */
 export const createChannel = (
-	configReceiverDTO: BodyType<ConfigReceiverDTO>,
+	alertmanagertypesPostableChannelDTO: BodyType<AlertmanagertypesPostableChannelDTO>,
 	signal?: AbortSignal,
 ) => {
 	return GeneratedAPIInstance<CreateChannel201>({
 		url: `/api/v1/channels`,
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },
-		data: configReceiverDTO,
+		data: alertmanagertypesPostableChannelDTO,
 		signal,
 	});
 };
@@ -141,13 +142,13 @@ export const getCreateChannelMutationOptions = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createChannel>>,
 		TError,
-		{ data: BodyType<ConfigReceiverDTO> },
+		{ data: BodyType<AlertmanagertypesPostableChannelDTO> },
 		TContext
 	>;
 }): UseMutationOptions<
 	Awaited<ReturnType<typeof createChannel>>,
 	TError,
-	{ data: BodyType<ConfigReceiverDTO> },
+	{ data: BodyType<AlertmanagertypesPostableChannelDTO> },
 	TContext
 > => {
 	const mutationKey = ['createChannel'];
@@ -161,7 +162,7 @@ export const getCreateChannelMutationOptions = <
 
 	const mutationFn: MutationFunction<
 		Awaited<ReturnType<typeof createChannel>>,
-		{ data: BodyType<ConfigReceiverDTO> }
+		{ data: BodyType<AlertmanagertypesPostableChannelDTO> }
 	> = (props) => {
 		const { data } = props ?? {};
 
@@ -174,7 +175,8 @@ export const getCreateChannelMutationOptions = <
 export type CreateChannelMutationResult = NonNullable<
 	Awaited<ReturnType<typeof createChannel>>
 >;
-export type CreateChannelMutationBody = BodyType<ConfigReceiverDTO>;
+export type CreateChannelMutationBody =
+	BodyType<AlertmanagertypesPostableChannelDTO>;
 export type CreateChannelMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -187,13 +189,13 @@ export const useCreateChannel = <
 	mutation?: UseMutationOptions<
 		Awaited<ReturnType<typeof createChannel>>,
 		TError,
-		{ data: BodyType<ConfigReceiverDTO> },
+		{ data: BodyType<AlertmanagertypesPostableChannelDTO> },
 		TContext
 	>;
 }): UseMutationResult<
 	Awaited<ReturnType<typeof createChannel>>,
 	TError,
-	{ data: BodyType<ConfigReceiverDTO> },
+	{ data: BodyType<AlertmanagertypesPostableChannelDTO> },
 	TContext
 > => {
 	const mutationOptions = getCreateChannelMutationOptions(options);

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

@@ -18,9 +18,9 @@ import type {
 } from 'react-query';
 
 import type {
-	AuthtypesPatchableObjectsDTO,
 	AuthtypesPatchableRoleDTO,
 	AuthtypesPostableRoleDTO,
+	CoretypesPatchableObjectsDTO,
 	CreateRole201,
 	DeleteRolePathParameters,
 	GetObjects200,
@@ -571,13 +571,13 @@ export const invalidateGetObjects = async (
  */
 export const patchObjects = (
 	{ id, relation }: PatchObjectsPathParameters,
-	authtypesPatchableObjectsDTO: BodyType<AuthtypesPatchableObjectsDTO>,
+	coretypesPatchableObjectsDTO: BodyType<CoretypesPatchableObjectsDTO>,
 ) => {
 	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}/relations/${relation}/objects`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
-		data: authtypesPatchableObjectsDTO,
+		data: coretypesPatchableObjectsDTO,
 	});
 };
 
@@ -590,7 +590,7 @@ export const getPatchObjectsMutationOptions = <
 		TError,
 		{
 			pathParams: PatchObjectsPathParameters;
-			data: BodyType<AuthtypesPatchableObjectsDTO>;
+			data: BodyType<CoretypesPatchableObjectsDTO>;
 		},
 		TContext
 	>;
@@ -599,7 +599,7 @@ export const getPatchObjectsMutationOptions = <
 	TError,
 	{
 		pathParams: PatchObjectsPathParameters;
-		data: BodyType<AuthtypesPatchableObjectsDTO>;
+		data: BodyType<CoretypesPatchableObjectsDTO>;
 	},
 	TContext
 > => {
@@ -616,7 +616,7 @@ export const getPatchObjectsMutationOptions = <
 		Awaited<ReturnType<typeof patchObjects>>,
 		{
 			pathParams: PatchObjectsPathParameters;
-			data: BodyType<AuthtypesPatchableObjectsDTO>;
+			data: BodyType<CoretypesPatchableObjectsDTO>;
 		}
 	> = (props) => {
 		const { pathParams, data } = props ?? {};
@@ -630,7 +630,7 @@ export const getPatchObjectsMutationOptions = <
 export type PatchObjectsMutationResult = NonNullable<
 	Awaited<ReturnType<typeof patchObjects>>
 >;
-export type PatchObjectsMutationBody = BodyType<AuthtypesPatchableObjectsDTO>;
+export type PatchObjectsMutationBody = BodyType<CoretypesPatchableObjectsDTO>;
 export type PatchObjectsMutationError = ErrorType<RenderErrorResponseDTO>;
 
 /**
@@ -645,7 +645,7 @@ export const usePatchObjects = <
 		TError,
 		{
 			pathParams: PatchObjectsPathParameters;
-			data: BodyType<AuthtypesPatchableObjectsDTO>;
+			data: BodyType<CoretypesPatchableObjectsDTO>;
 		},
 		TContext
 	>;
@@ -654,7 +654,7 @@ export const usePatchObjects = <
 	TError,
 	{
 		pathParams: PatchObjectsPathParameters;
-		data: BodyType<AuthtypesPatchableObjectsDTO>;
+		data: BodyType<CoretypesPatchableObjectsDTO>;
 	},
 	TContext
 > => {

frontend/src/api/index.ts

@@ -15,7 +15,6 @@ import { getBasePath } from 'utils/basePath';
 import { eventEmitter } from 'utils/getEventEmitter';
 
 import apiV1, { apiAlertManager, apiV2, apiV3, apiV4, apiV5 } from './apiV1';
-import { retryRequestAfterAuth } from 'api/interceptors';
 import { Logout } from './utils';
 
 const RESPONSE_TIMEOUT_THRESHOLD = 5000; // 5 seconds
@@ -130,10 +129,13 @@ export const interceptorRejected = async (
 					afterLogin(response.data.accessToken, response.data.refreshToken, true);
 
 					try {
-						const reResponse = await retryRequestAfterAuth(
-							value.config,
-							response.data.accessToken,
-						);
+						const reResponse = await axios({
+							...value.config,
+							headers: {
+								...value.config.headers,
+								Authorization: `Bearer ${response.data.accessToken}`,
+							},
+						});
 
 						return await Promise.resolve(reResponse);
 					} catch (error) {

frontend/src/api/interceptors.test.ts

@@ -1,65 +1,46 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import axios, { AxiosHeaders, AxiosResponse } from 'axios';
 
-const { retryRequestMock, postRotateMock } = vi.hoisted(() => ({
-	retryRequestMock: vi.fn(),
-	postRotateMock: vi.fn(() =>
+import { interceptorRejected } from './index';
+
+jest.mock('api/browser/localstorage/get', () => ({
+	__esModule: true,
+	default: jest.fn(() => 'mock-token'),
+}));
+
+jest.mock('api/v2/sessions/rotate/post', () => ({
+	__esModule: true,
+	default: jest.fn(() =>
 		Promise.resolve({
 			data: { accessToken: 'new-token', refreshToken: 'new-refresh' },
 		}),
 	),
 }));
 
-vi.mock('api/interceptors', () => ({
+jest.mock('AppRoutes/utils', () => ({
 	__esModule: true,
-	retryRequestAfterAuth: retryRequestMock,
+	default: jest.fn(),
 }));
 
-vi.mock('api/browser/localstorage/get', () => ({
-	__esModule: true,
-	default: vi.fn(() => 'mock-token'),
-}));
+jest.mock('axios', () => {
+	const actualAxios = jest.requireActual('axios');
+	const mockAxios = jest.fn().mockResolvedValue({ data: 'success' });
 
-vi.mock('api/v2/sessions/rotate/post', () => ({
-	__esModule: true,
-	default: postRotateMock,
-}));
-
-vi.mock('AppRoutes/utils', () => ({
-	__esModule: true,
-	default: vi.fn(),
-}));
-
-vi.mock('axios', async () => {
-	const actual = await vi.importActual<typeof import('axios')>('axios');
 	return {
-		...actual,
-		default: Object.assign(actual.default, {
-			isAxiosError: vi.fn(() => true),
+		...actualAxios,
+		default: Object.assign(mockAxios, {
+			...actualAxios.default,
+			isAxiosError: jest.fn().mockReturnValue(true),
+			create: actualAxios.create,
 		}),
 		__esModule: true,
 	};
 });
 
 describe('interceptorRejected', () => {
-	let interceptorRejected: (value: AxiosResponse) => Promise<AxiosResponse>;
-
-	beforeAll(async () => {
-		vi.resetModules();
-		const mod = await import('./index');
-		interceptorRejected = mod.interceptorRejected;
-	});
-
 	beforeEach(() => {
-		vi.clearAllMocks();
-		retryRequestMock.mockResolvedValue({
-			data: 'success',
-		} as unknown as AxiosResponse<{ data: string }>);
-		(
-			axios.isAxiosError as unknown as {
-				mockReturnValue: (value: boolean) => void;
-			}
-		).mockReturnValue(true);
+		jest.clearAllMocks();
+		(axios as unknown as jest.Mock).mockResolvedValue({ data: 'success' });
+		(axios.isAxiosError as unknown as jest.Mock).mockReturnValue(true);
 	});
 
 	it('should preserve array payload structure when retrying a 401 request', async () => {
@@ -94,12 +75,11 @@ describe('interceptorRejected', () => {
 			// Expected to reject after retry
 		}
 
-		expect(retryRequestMock).toHaveBeenCalledTimes(1);
-		const retryCallConfig = retryRequestMock.mock.calls[0][0];
-		expect(Array.isArray(JSON.parse(retryCallConfig.data as string))).toBe(true);
-		expect(JSON.parse(retryCallConfig.data as string)).toStrictEqual(
-			arrayPayload,
-		);
+		const mockAxiosFn = axios as unknown as jest.Mock;
+		expect(mockAxiosFn.mock.calls).toHaveLength(1);
+		const retryCallConfig = mockAxiosFn.mock.calls[0][0];
+		expect(Array.isArray(JSON.parse(retryCallConfig.data))).toBe(true);
+		expect(JSON.parse(retryCallConfig.data)).toStrictEqual(arrayPayload);
 	});
 
 	it('should preserve object payload structure when retrying a 401 request', async () => {
@@ -131,11 +111,10 @@ describe('interceptorRejected', () => {
 			// Expected to reject after retry
 		}
 
-		expect(retryRequestMock).toHaveBeenCalledTimes(1);
-		const retryCallConfig = retryRequestMock.mock.calls[0][0];
-		expect(JSON.parse(retryCallConfig.data as string)).toStrictEqual(
-			objectPayload,
-		);
+		const mockAxiosFn = axios as unknown as jest.Mock;
+		expect(mockAxiosFn.mock.calls).toHaveLength(1);
+		const retryCallConfig = mockAxiosFn.mock.calls[0][0];
+		expect(JSON.parse(retryCallConfig.data)).toStrictEqual(objectPayload);
 	});
 
 	it('should handle undefined data gracefully when retrying', async () => {
@@ -165,8 +144,9 @@ describe('interceptorRejected', () => {
 			// Expected to reject after retry
 		}
 
-		expect(retryRequestMock).toHaveBeenCalledTimes(1);
-		const retryCallConfig = retryRequestMock.mock.calls[0][0];
+		const mockAxiosFn = axios as unknown as jest.Mock;
+		expect(mockAxiosFn.mock.calls).toHaveLength(1);
+		const retryCallConfig = mockAxiosFn.mock.calls[0][0];
 		expect(retryCallConfig.data).toBeUndefined();
 	});
 });

frontend/src/api/interceptors.ts

@@ -1,17 +0,0 @@
-import axios, {
-	AxiosHeaders,
-	AxiosResponse,
-	InternalAxiosRequestConfig,
-} from 'axios';
-
-export async function retryRequestAfterAuth(
-	valueConfig: InternalAxiosRequestConfig,
-	accessToken: string,
-): Promise<AxiosResponse> {
-	const headers = new AxiosHeaders(valueConfig.headers);
-	headers.set('Authorization', `Bearer ${accessToken}`);
-	return axios({
-		...valueConfig,
-		headers,
-	});
-}

frontend/src/api/v5/queryRange/convertV5Response.test.ts

@@ -1,4 +1,3 @@
-import { describe, expect, it } from 'vitest';
 import { SuccessResponse } from 'types/api';
 import {
 	MetricRangePayloadV5,

frontend/src/api/v5/queryRange/prepareQueryRangePayloadV5.test.ts

@@ -1,7 +1,5 @@
-import { describe, expect, it, vi } from 'vitest';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
-import getStartEndRangeTime from 'lib/getStartEndRangeTime';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import {
 	IBuilderFormula,
@@ -22,9 +20,9 @@ import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 
 import { prepareQueryRangePayloadV5 } from './prepareQueryRangePayloadV5';
 
-vi.mock('lib/getStartEndRangeTime', () => ({
+jest.mock('lib/getStartEndRangeTime', () => ({
 	__esModule: true,
-	default: vi.fn(() => ({ start: '100', end: '200' })),
+	default: jest.fn(() => ({ start: '100', end: '200' })),
 }));
 
 describe('prepareQueryRangePayloadV5', () => {
@@ -517,7 +515,9 @@ describe('prepareQueryRangePayloadV5', () => {
 	});
 
 	it('maps groupBy, order, having, aggregations and filter for logs builder query', () => {
-		vi.mocked(getStartEndRangeTime).mockReturnValueOnce({
+		const getStartEndRangeTime = jest.requireMock('lib/getStartEndRangeTime')
+			.default as jest.Mock;
+		getStartEndRangeTime.mockReturnValueOnce({
 			start: '1754623641',
 			end: '1754645241',
 		});

frontend/src/components/AppLoading/AppLoading.tsx

@@ -1,4 +1,4 @@
-import { Typography } from 'antd';
+import { Typography } from '@signozhq/ui';
 import get from 'api/browser/localstorage/get';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import { THEME_MODE } from 'hooks/useDarkMode/constant';

frontend/src/components/AppLoading/__tests__/AppLoading.test.tsx

@@ -1,16 +1,15 @@
 import { render, screen } from '@testing-library/react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import getLocal from '../../../api/browser/localstorage/get';
 import AppLoading from '../AppLoading';
 
-vi.mock('../../../api/browser/localstorage/get', () => ({
+jest.mock('../../../api/browser/localstorage/get', () => ({
 	__esModule: true,
-	default: vi.fn(),
+	default: jest.fn(),
 }));
 
 // Access the mocked function
-const mockGet = vi.mocked(getLocal);
+const mockGet = getLocal as unknown as jest.Mock;
 
 describe('AppLoading', () => {
 	const SIGNOZ_TEXT = 'SigNoz';
@@ -19,12 +18,12 @@ describe('AppLoading', () => {
 	const CONTAINER_SELECTOR = '.app-loading-container';
 
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 	});
 
 	it('should render loading screen with dark theme by default', () => {
 		// Mock localStorage to return dark theme (or undefined for default)
-		mockGet.mockReturnValue(null);
+		mockGet.mockReturnValue(undefined);
 
 		render(<AppLoading />);
 
@@ -41,17 +40,14 @@ describe('AppLoading', () => {
 
 	it('should have proper structure and content', () => {
 		// Mock localStorage to return dark theme
-		mockGet.mockReturnValue(null);
+		mockGet.mockReturnValue(undefined);
 
 		render(<AppLoading />);
 
 		// Check for brand logo
 		const logo = screen.getByAltText(SIGNOZ_TEXT);
 		expect(logo).toBeInTheDocument();
-		expect(logo).toHaveAttribute(
-			'src',
-			expect.stringContaining('data:image/svg+xml'),
-		);
+		expect(logo).toHaveAttribute('src', 'test-file-stub');
 
 		// Check for brand title
 		const title = screen.getByText(SIGNOZ_TEXT);

frontend/src/components/CeleryOverview/CeleryOverviewTable/CeleryOverviewTable.tsx

@@ -14,8 +14,8 @@ import {
 	TableColumnsType,
 	TableColumnType,
 	Tooltip,
-	Typography,
 } from 'antd';
+import { Typography } from '@signozhq/ui';
 import type { FilterDropdownProps } from 'antd/lib/table/interface';
 import logEvent from 'api/common/logEvent';
 import {

frontend/src/components/CeleryTask/CeleryTaskConfigOptions/CeleryTaskConfigOptions.tsx

@@ -1,5 +1,6 @@
 import { useHistory, useLocation } from 'react-router-dom';
-import { Select, Spin, Typography } from 'antd';
+import { Select, Spin } from 'antd';
+import { Typography } from '@signozhq/ui';
 import { SelectMaxTagPlaceholder } from 'components/MessagingQueues/MQCommon/MQCommon';
 import { QueryParams } from 'constants/query';
 import useUrlQuery from 'hooks/useUrlQuery';

frontend/src/components/CeleryTask/CeleryTaskDetail/CeleryTaskDetail.tsx

@@ -1,6 +1,7 @@
 import { useState } from 'react';
 import { Color, Spacing } from '@signozhq/design-tokens';
-import { Divider, Drawer, Typography } from 'antd';
+import { Divider, Drawer } from 'antd';
+import { Typography } from '@signozhq/ui';
 import logEvent from 'api/common/logEvent';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import dayjs from 'dayjs';

frontend/src/components/CeleryTask/CeleryTaskGraph/CeleryTaskGraphGrid.tsx

@@ -1,7 +1,8 @@
 import { useMemo, useState } from 'react';
 // eslint-disable-next-line no-restricted-imports
 import { useSelector } from 'react-redux';
-import { Card, Typography } from 'antd';
+import { Card } from 'antd';
+import { Typography } from '@signozhq/ui';
 import logEvent from 'api/common/logEvent';
 import { CardContainer } from 'container/GridCardLayout/styles';
 import { useIsDarkMode } from 'hooks/useDarkMode';

frontend/src/components/ChangelogModal/__test__/ChangelogModal.test.tsx

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 
 import { fireEvent, render, screen } from '@testing-library/react';
+import { USER_PREFERENCES } from 'constants/userPreferences';
 import MockQueryClientProvider from 'providers/test/MockQueryClientProvider';
 import {
 	ChangelogSchema,
 	DeploymentType,
 } from 'types/api/changelog/getChangelogByVersion';
-import { describe, expect, it, vi } from 'vitest';
 
 import ChangelogModal from '../ChangelogModal';
 
@@ -37,25 +37,27 @@ const mockChangelog: ChangelogSchema = {
 };
 
 // Mock react-markdown to just render children as plain text
-vi.mock('react-markdown', () => ({
-	default: function ReactMarkdown({ children }: any) {
-		return <div>{children}</div>;
-	},
-}));
+jest.mock(
+	'react-markdown',
+	() =>
+		function ReactMarkdown({ children }: any) {
+			return <div>{children}</div>;
+		},
+);
 // mock useAppContext
-vi.mock('providers/App/App', () => ({
-	useAppContext: vi.fn(() => ({
-		updateUserPreferenceInContext: vi.fn(),
+jest.mock('providers/App/App', () => ({
+	useAppContext: jest.fn(() => ({
+		updateUserPreferenceInContext: jest.fn(),
 		userPreferences: [
 			{
-				name: 'last_seen_changelog_version',
+				name: USER_PREFERENCES.LAST_SEEN_CHANGELOG_VERSION,
 				value: 'v1.0.0',
 			},
 		],
 	})),
 }));
 
-function renderChangelog(onClose: () => void = vi.fn()): void {
+function renderChangelog(onClose: () => void = jest.fn()): void {
 	render(
 		<MockQueryClientProvider>
 			<ChangelogModal changelog={mockChangelog} onClose={onClose} />
@@ -76,14 +78,14 @@ describe('ChangelogModal', () => {
 	});
 
 	it('calls onClose when Skip for now is clicked', () => {
-		const onClose = vi.fn();
+		const onClose = jest.fn();
 		renderChangelog(onClose);
 		fireEvent.click(screen.getByText('Skip for now'));
 		expect(onClose).toHaveBeenCalled();
 	});
 
 	it('opens migration docs when Update my workspace is clicked', () => {
-		window.open = vi.fn();
+		window.open = jest.fn();
 		renderChangelog();
 		fireEvent.click(screen.getByText('Update my workspace'));
 		expect(window.open).toHaveBeenCalledWith(
@@ -98,7 +100,7 @@ describe('ChangelogModal', () => {
 		const scrollBtn = screen.getByTestId('scroll-more-btn');
 		const contentDiv = screen.getByTestId('changelog-content');
 		if (contentDiv) {
-			contentDiv.scrollTo = vi.fn();
+			contentDiv.scrollTo = jest.fn();
 		}
 		fireEvent.click(scrollBtn);
 		if (contentDiv) {

frontend/src/components/ChangelogModal/__test__/ChangelogRenderer.test.tsx

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 
 import { render, screen } from '@testing-library/react';
-import { describe, expect, it, vi } from 'vitest';
 import {
 	ChangelogSchema,
 	DeploymentType,
@@ -10,11 +9,13 @@ import {
 import ChangelogRenderer from '../components/ChangelogRenderer';
 
 // Mock react-markdown to just render children as plain text
-vi.mock('react-markdown', () => ({
-	default: function ReactMarkdown({ children }: any) {
-		return <div>{children}</div>;
-	},
-}));
+jest.mock(
+	'react-markdown',
+	() =>
+		function ReactMarkdown({ children }: any) {
+			return <div>{children}</div>;
+		},
+);
 
 const mockChangelog: ChangelogSchema = {
 	id: 1,

frontend/src/components/ChatSupportGateway/ChatSupportGateway.tsx

@@ -1,7 +1,8 @@
 import { useState } from 'react';
 import { useMutation } from 'react-query';
 import { useLocation } from 'react-router-dom';
-import { Button, Modal, Typography } from 'antd';
+import { Button, Modal } from 'antd';
+import { Typography } from '@signozhq/ui';
 import logEvent from 'api/common/logEvent';
 import updateCreditCardApi from 'api/v1/checkout/create';
 import { useNotifications } from 'hooks/useNotifications';

frontend/src/components/ClientSideQBSearch/ClientSideQBSearch.tsx

@@ -554,10 +554,11 @@ function ClientSideQBSearch(
 				>
 					<Tooltip title={chipValue}>
 						<TypographyText
-							ellipsis
+							role="button"
+							tabIndex={0}
 							$isInNin={isInNin}
-							disabled={isDisabled}
 							$isEnabled={!!searchValue}
+							$disabled={isDisabled}
 							onClick={(): void => {
 								if (!isDisabled) {
 									tagEditHandler(value);

frontend/src/components/CodeBlock/CodeBlock.test.tsx

@@ -1,40 +1,16 @@
 import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import type { ReactNode } from 'react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import CodeBlock from './CodeBlock';
 
-const { mockCopyToClipboard } = vi.hoisted(() => ({
-	mockCopyToClipboard: vi.fn(),
-}));
+const mockCopyToClipboard = jest.fn();
 
-vi.mock('react-use', () => ({
+jest.mock('react-use', () => ({
 	useCopyToClipboard: (): [unknown, (text: string) => void] => [
 		undefined,
 		mockCopyToClipboard,
 	],
 }));
 
-vi.mock('@signozhq/icons', () => ({
-	Check: (): null => null,
-	Copy: (): null => null,
-}));
-
-vi.mock('@signozhq/ui', async () => {
-	const React = await vi.importActual<typeof import('react')>('react');
-
-	return {
-		Button: ({
-			prefix,
-			...props
-		}: {
-			prefix?: ReactNode;
-			[key: string]: unknown;
-		}): ReturnType<typeof React.createElement> =>
-			React.createElement('button', props, prefix),
-	};
-});
-
 describe('CodeBlock', () => {
 	beforeEach(() => {
 		mockCopyToClipboard.mockReset();
@@ -57,7 +33,7 @@ describe('CodeBlock', () => {
 	});
 
 	it('copies code and triggers callback', async () => {
-		const onCopy = vi.fn();
+		const onCopy = jest.fn();
 		render(<CodeBlock code="SELECT * FROM logs;" onCopy={onCopy} />);
 
 		fireEvent.click(screen.getByRole('button', { name: /copy code/i }));

frontend/src/components/CreateServiceAccountModal/__tests__/CreateServiceAccountModal.test.tsx

@@ -1,49 +1,28 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { toast } from '@signozhq/ui';
 import { rest, server } from 'mocks-server/server';
 import { NuqsTestingAdapter } from 'nuqs/adapters/testing';
-import { render, screen, userEvent, waitFor } from 'tests/test-utils';
+import {
+	render,
+	screen,
+	userEvent,
+	waitFor,
+	waitForElementToBeRemoved,
+} from 'tests/test-utils';
 
 import CreateServiceAccountModal from '../CreateServiceAccountModal';
 
-vi.mock('@signozhq/icons', () => ({
-	X: ({ size: _size }: any): JSX.Element => <span aria-hidden="true" />,
+jest.mock('@signozhq/ui', () => ({
+	...jest.requireActual('@signozhq/ui'),
+	toast: { success: jest.fn(), error: jest.fn() },
 }));
 
-vi.mock('@signozhq/ui', () => ({
-	Button: ({
-		children,
-		loading: _loading,
-		variant: _variant,
-		color: _color,
-		...props
-	}: any): JSX.Element => <button {...props}>{children}</button>,
-	DialogFooter: ({ children, ...props }: any): JSX.Element => (
-		<div {...props}>{children}</div>
-	),
-	DialogWrapper: ({ title, open, children }: any): JSX.Element | null =>
-		open ? (
-			<div role="dialog" aria-label={title}>
-				{children}
-			</div>
-		) : null,
-	Input: (props: any): JSX.Element => <input {...props} />,
-	toast: { success: vi.fn(), error: vi.fn() },
-}));
+const mockToast = jest.mocked(toast);
 
-vi.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: ReturnType<typeof vi.fn> } => ({
-		safeNavigate: vi.fn(),
-	}),
-}));
-
-const mockToast = vi.mocked(toast);
-
-const showErrorModal = vi.hoisted(() => vi.fn());
-vi.mock('providers/ErrorModalProvider', async () => ({
+const showErrorModal = jest.fn();
+jest.mock('providers/ErrorModalProvider', () => ({
 	__esModule: true,
-	...(await vi.importActual('providers/ErrorModalProvider')),
-	useErrorModal: vi.fn(() => ({
+	...jest.requireActual('providers/ErrorModalProvider'),
+	useErrorModal: jest.fn(() => ({
 		showErrorModal,
 		isErrorModalVisible: false,
 	})),
@@ -61,7 +40,7 @@ function renderModal(): ReturnType<typeof render> {
 
 describe('CreateServiceAccountModal', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 		server.use(
 			rest.post(SERVICE_ACCOUNTS_ENDPOINT, (_, res, ctx) =>
 				res(ctx.status(201), ctx.json({ status: 'success', data: {} })),
@@ -147,16 +126,12 @@ describe('CreateServiceAccountModal', () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 		renderModal();
 
-		await screen.findByRole('dialog', {
+		const dialog = await screen.findByRole('dialog', {
 			name: /New Service Account/i,
 		});
 		await user.click(screen.getByRole('button', { name: /Cancel/i }));
 
-		await waitFor(() => {
-			expect(
-				screen.queryByRole('dialog', { name: /New Service Account/i }),
-			).not.toBeInTheDocument();
-		});
+		await waitForElementToBeRemoved(dialog);
 	});
 
 	it('shows "Name is required" after clearing the name field', async () => {

frontend/src/components/CustomTimePicker/CustomTimePicker.test.tsx

@@ -1,37 +1,36 @@
 import { useState } from 'react';
 import { fireEvent, render, screen } from '@testing-library/react';
 import dayjs from 'dayjs';
-import { describe, expect, it, vi } from 'vitest';
 import * as timeUtils from 'utils/timeUtils';
 
 import CustomTimePicker from './CustomTimePicker';
 
-vi.mock('react-router-dom', async () => {
-	const actual = await vi.importActual('react-router-dom');
+jest.mock('react-router-dom', () => {
+	const actual = jest.requireActual('react-router-dom');
 
 	return {
 		...actual,
-		useLocation: vi.fn().mockReturnValue({
+		useLocation: jest.fn().mockReturnValue({
 			pathname: '/test-path',
 		}),
 	};
 });
 
-vi.mock('react-redux', async () => ({
-	...(await vi.importActual('react-redux')),
-	useDispatch: vi.fn(() => vi.fn()),
-	useSelector: vi.fn(() => ({
+jest.mock('react-redux', () => ({
+	...jest.requireActual('react-redux'),
+	useDispatch: jest.fn(() => jest.fn()),
+	useSelector: jest.fn(() => ({
 		minTime: 0,
 		maxTime: Date.now(),
 	})),
 }));
 
-vi.mock('providers/Timezone', async () => {
-	const actual = await vi.importActual('providers/Timezone');
+jest.mock('providers/Timezone', () => {
+	const actual = jest.requireActual('providers/Timezone');
 
 	return {
 		...actual,
-		useTimezone: vi.fn().mockReturnValue({
+		useTimezone: jest.fn().mockReturnValue({
 			timezone: {
 				value: 'UTC',
 				offset: '+00:00',
@@ -46,30 +45,6 @@ vi.mock('providers/Timezone', async () => {
 	};
 });
 
-vi.mock('@signozhq/ui', () => ({
-	Button: ({
-		children,
-		prefix,
-		variant: _variant,
-		color: _color,
-		...props
-	}: React.ButtonHTMLAttributes<HTMLButtonElement> & {
-		prefix?: React.ReactNode;
-		variant?: string;
-		color?: string;
-	}): JSX.Element => (
-		<button type="button" {...props}>
-			{prefix}
-			{children}
-		</button>
-	),
-	Calendar: (): JSX.Element => <div data-testid="mock-calendar" />,
-}));
-
-vi.mock('hooks/useZoomOut', () => ({
-	useZoomOut: vi.fn(() => vi.fn()),
-}));
-
 interface WrapperProps {
 	initialValue?: string;
 	showLiveLogs?: boolean;
@@ -148,8 +123,8 @@ describe('CustomTimePicker', () => {
 	});
 
 	it('applies valid shorthand on Enter', () => {
-		const onValid = vi.fn();
-		const onError = vi.fn();
+		const onValid = jest.fn();
+		const onError = jest.fn();
 
 		render(<Wrapper onValidCustomDateChange={onValid} onError={onError} />);
 
@@ -166,9 +141,9 @@ describe('CustomTimePicker', () => {
 	});
 
 	it('sets error and updates custom time status for invalid shorthand exceeding max allowed window', () => {
-		const onValid = vi.fn();
-		const onError = vi.fn();
-		const onCustomTimeStatusUpdate = vi.fn();
+		const onValid = jest.fn();
+		const onError = jest.fn();
+		const onCustomTimeStatusUpdate = jest.fn();
 
 		render(
 			<Wrapper
@@ -191,8 +166,8 @@ describe('CustomTimePicker', () => {
 	});
 
 	it('treats close after change like pressing Enter (blur + chevron)', () => {
-		const onValid = vi.fn();
-		const onError = vi.fn();
+		const onValid = jest.fn();
+		const onError = jest.fn();
 
 		render(<Wrapper onValidCustomDateChange={onValid} onError={onError} />);
 
@@ -216,8 +191,8 @@ describe('CustomTimePicker', () => {
 	});
 
 	it('applies epoch start/end range on Enter via onCustomDateHandler', () => {
-		const onCustomDateHandler = vi.fn();
-		const onError = vi.fn();
+		const onCustomDateHandler = jest.fn();
+		const onError = jest.fn();
 
 		render(
 			<Wrapper onCustomDateHandler={onCustomDateHandler} onError={onError} />,
@@ -238,9 +213,9 @@ describe('CustomTimePicker', () => {
 	});
 
 	it('uses validateTimeRange result for generic formatted ranges (valid case)', () => {
-		const validateTimeRangeSpy = vi.spyOn(timeUtils, 'validateTimeRange');
-		const onCustomDateHandler = vi.fn();
-		const onError = vi.fn();
+		const validateTimeRangeSpy = jest.spyOn(timeUtils, 'validateTimeRange');
+		const onCustomDateHandler = jest.fn();
+		const onError = jest.fn();
 
 		validateTimeRangeSpy.mockReturnValue({
 			isValid: true,
@@ -269,9 +244,9 @@ describe('CustomTimePicker', () => {
 	});
 
 	it('uses validateTimeRange result for generic formatted ranges (invalid case)', () => {
-		const validateTimeRangeSpy = vi.spyOn(timeUtils, 'validateTimeRange');
-		const onValid = vi.fn();
-		const onError = vi.fn();
+		const validateTimeRangeSpy = jest.spyOn(timeUtils, 'validateTimeRange');
+		const onValid = jest.fn();
+		const onError = jest.fn();
 
 		validateTimeRangeSpy.mockReturnValue({
 			isValid: false,

frontend/src/components/CustomTimePicker/__tests__/customTimePickerZoomOut.test.tsx

@@ -2,33 +2,23 @@ import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { QueryParams } from 'constants/query';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { Mock } from 'vitest';
 
 import CustomTimePicker from '../CustomTimePicker';
 
-const {
-	MS_PER_MIN,
-	NOW_MS,
-	mockDispatch,
-	mockSafeNavigate,
-	mockUrlQueryDelete,
-	mockUrlQuerySet,
-} = vi.hoisted(() => ({
-	MS_PER_MIN: 60 * 1000,
-	NOW_MS: 1705312800000,
-	mockDispatch: vi.fn(),
-	mockSafeNavigate: vi.fn(),
-	mockUrlQueryDelete: vi.fn(),
-	mockUrlQuerySet: vi.fn(),
-}));
+const MS_PER_MIN = 60 * 1000;
+const NOW_MS = 1705312800000;
+
+const mockDispatch = jest.fn();
+const mockSafeNavigate = jest.fn();
+const mockUrlQueryDelete = jest.fn();
+const mockUrlQuerySet = jest.fn();
 
 interface MockAppState {
 	globalTime: Pick<GlobalReducer, 'minTime' | 'maxTime'>;
 }
 
-vi.mock('react-redux', () => ({
-	useDispatch: (): Mock => mockDispatch,
+jest.mock('react-redux', () => ({
+	useDispatch: (): jest.Mock => mockDispatch,
 	useSelector: (selector: (state: MockAppState) => unknown): unknown => {
 		const mockState: MockAppState = {
 			globalTime: {
@@ -40,8 +30,8 @@ vi.mock('react-redux', () => ({
 	},
 }));
 
-vi.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: Mock } => ({
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): { safeNavigate: jest.Mock } => ({
 		safeNavigate: mockSafeNavigate,
 	}),
 }));
@@ -53,7 +43,7 @@ interface MockUrlQuery {
 	toString: () => string;
 }
 
-vi.mock('hooks/useUrlQuery', () => ({
+jest.mock('hooks/useUrlQuery', () => ({
 	__esModule: true,
 	default: (): MockUrlQuery => ({
 		delete: mockUrlQueryDelete,
@@ -63,46 +53,26 @@ vi.mock('hooks/useUrlQuery', () => ({
 	}),
 }));
 
-vi.mock('providers/Timezone', () => ({
+jest.mock('providers/Timezone', () => ({
 	useTimezone: (): { timezone: { value: string; offset: string } } => ({
 		timezone: { value: 'UTC', offset: 'UTC' },
 	}),
 }));
 
-vi.mock('react-router-dom', () => ({
+jest.mock('react-router-dom', () => ({
 	useLocation: (): { pathname: string } => ({ pathname: '/logs-explorer' }),
 }));
 
-vi.mock('@signozhq/ui', () => ({
-	Button: ({
-		children,
-		prefix,
-		variant: _variant,
-		color: _color,
-		...props
-	}: React.ButtonHTMLAttributes<HTMLButtonElement> & {
-		prefix?: React.ReactNode;
-		variant?: string;
-		color?: string;
-	}): JSX.Element => (
-		<button type="button" {...props}>
-			{prefix}
-			{children}
-		</button>
-	),
-	Calendar: (): JSX.Element => <div data-testid="mock-calendar" />,
-}));
-
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 const now = Date.now();
 const defaultProps = {
-	onSelect: vi.fn(),
-	onError: vi.fn(),
+	onSelect: jest.fn(),
+	onError: jest.fn(),
 	selectedValue: '15m',
 	selectedTime: '15m',
-	onValidCustomDateChange: vi.fn(),
+	onValidCustomDateChange: jest.fn(),
 	open: false,
-	setOpen: vi.fn(),
+	setOpen: jest.fn(),
 	items: [
 		{ value: '15m', label: 'Last 15 minutes' },
 		{ value: '1h', label: 'Last 1 hour' },
@@ -113,12 +83,12 @@ const defaultProps = {
 
 describe('CustomTimePicker - zoom out button', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
-		vi.spyOn(Date, 'now').mockReturnValue(NOW_MS);
+		jest.clearAllMocks();
+		jest.spyOn(Date, 'now').mockReturnValue(NOW_MS);
 	});
 
 	afterEach(() => {
-		vi.restoreAllMocks();
+		jest.restoreAllMocks();
 	});
 
 	it('should render zoom out button when showLiveLogs is false', () => {

frontend/src/components/DownloadOptionsMenu/DownloadOptionsMenu.test.tsx

@@ -1,6 +1,3 @@
-import type { Mock } from 'vitest';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
 // eslint-disable-next-line no-restricted-imports
 import { Provider } from 'react-redux';
 import { fireEvent, render, screen, waitFor } from '@testing-library/react';
@@ -16,28 +13,25 @@ import '@testing-library/jest-dom';
 import { DownloadFormats, DownloadRowCounts } from './constants';
 import DownloadOptionsMenu from './DownloadOptionsMenu';
 
-const { mockDownloadExportData, mockUseQueryBuilder } = vi.hoisted(() => ({
-	mockDownloadExportData: vi.fn().mockResolvedValue(undefined),
-	mockUseQueryBuilder: vi.fn(),
-}));
-
-vi.mock('api/v1/download/downloadExportData', () => ({
+const mockDownloadExportData = jest.fn().mockResolvedValue(undefined);
+jest.mock('api/v1/download/downloadExportData', () => ({
 	downloadExportData: (...args: any[]): any => mockDownloadExportData(...args),
 	default: (...args: any[]): any => mockDownloadExportData(...args),
 }));
 
-vi.mock('antd', async () => {
-	const actual = await vi.importActual<typeof import('antd')>('antd');
+jest.mock('antd', () => {
+	const actual = jest.requireActual('antd');
 	return {
 		...actual,
 		message: {
-			success: vi.fn(),
-			error: vi.fn(),
+			success: jest.fn(),
+			error: jest.fn(),
 		},
 	};
 });
 
-vi.mock('hooks/queryBuilder/useQueryBuilder', () => ({
+const mockUseQueryBuilder = jest.fn();
+jest.mock('hooks/queryBuilder/useQueryBuilder', () => ({
 	useQueryBuilder: (): any => mockUseQueryBuilder(),
 }));
 
@@ -101,8 +95,8 @@ describe.each([
 
 	beforeEach(() => {
 		mockDownloadExportData.mockReset().mockResolvedValue(undefined);
-		(message.success as Mock).mockReset();
-		(message.error as Mock).mockReset();
+		(message.success as jest.Mock).mockReset();
+		(message.error as jest.Mock).mockReset();
 		mockUseQueryBuilder.mockReturnValue({
 			stagedQuery: createMockStagedQuery(dataSource),
 		});
@@ -313,11 +307,7 @@ describe.each([
 		fireEvent.click(screen.getByText('Export'));
 
 		expect(screen.getByTestId(testId)).toBeDisabled();
-		await waitFor(() => {
-			expect(screen.getByRole('dialog').closest('.ant-popover')).toHaveStyle({
-				pointerEvents: 'none',
-			});
-		});
+		expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
 
 		resolveDownload!();
 
@@ -333,7 +323,7 @@ describe('DownloadOptionsMenu for traces with queryTraceOperator', () => {
 
 	beforeEach(() => {
 		mockDownloadExportData.mockReset().mockResolvedValue(undefined);
-		(message.success as Mock).mockReset();
+		(message.success as jest.Mock).mockReset();
 	});
 
 	it('applies limit and clears groupBy on queryTraceOperator entries', async () => {

frontend/src/components/DownloadOptionsMenu/DownloadOptionsMenu.tsx

@@ -1,5 +1,6 @@
 import { useCallback, useMemo, useState } from 'react';
-import { Button, Popover, Radio, Tooltip, Typography } from 'antd';
+import { Button, Popover, Radio, Tooltip } from 'antd';
+import { Typography } from '@signozhq/ui';
 import { TelemetryFieldKey } from 'api/v5/v5';
 import { useExportRawData } from 'hooks/useDownloadOptionsMenu/useDownloadOptionsMenu';
 import { Download, DownloadIcon, Loader2 } from 'lucide-react';

frontend/src/components/DraggableTableRow/tests/DraggableTableRow.test.tsx

@@ -1,28 +1,27 @@
 import { render } from '@testing-library/react';
 import { Table } from 'antd';
-import { beforeAll, describe, expect, it, vi } from 'vitest';
 
 import DraggableTableRow from '..';
 
 beforeAll(() => {
 	Object.defineProperty(window, 'matchMedia', {
 		writable: true,
-		value: vi.fn().mockImplementation((query) => ({
+		value: jest.fn().mockImplementation((query) => ({
 			matches: false,
 			media: query,
 			onchange: null,
-			addListener: vi.fn(),
-			removeListener: vi.fn(),
-			addEventListener: vi.fn(),
-			removeEventListener: vi.fn(),
-			dispatchEvent: vi.fn(),
+			addListener: jest.fn(),
+			removeListener: jest.fn(),
+			addEventListener: jest.fn(),
+			removeEventListener: jest.fn(),
+			dispatchEvent: jest.fn(),
 		})),
 	});
 });
 
-vi.mock('react-dnd', () => ({
-	useDrop: vi.fn().mockImplementation(() => [vi.fn(), vi.fn(), vi.fn()]),
-	useDrag: vi.fn().mockImplementation(() => [vi.fn(), vi.fn(), vi.fn()]),
+jest.mock('react-dnd', () => ({
+	useDrop: jest.fn().mockImplementation(() => [jest.fn(), jest.fn(), jest.fn()]),
+	useDrag: jest.fn().mockImplementation(() => [jest.fn(), jest.fn(), jest.fn()]),
 }));
 
 describe('DraggableTableRow Snapshot test', () => {

frontend/src/components/DraggableTableRow/tests/__snapshots__/DraggableTableRow.test.tsx.snap

@@ -1,6 +1,6 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
-exports[`DraggableTableRow Snapshot test > should render DraggableTableRow 1`] = `
+exports[`DraggableTableRow Snapshot test should render DraggableTableRow 1`] = `
 <DocumentFragment>
   <div
     class="ant-table-wrapper css-dev-only-do-not-override-2i2tap"

frontend/src/components/DraggableTableRow/tests/utils.test.ts

@@ -1,16 +1,14 @@
-import { describe, expect, it, vi } from 'vitest';
-
 import { dragHandler, dropHandler } from '../utils';
 
-vi.mock('react-dnd', () => ({
-	useDrop: vi.fn().mockImplementation(() => [vi.fn(), vi.fn(), vi.fn()]),
-	useDrag: vi.fn().mockImplementation(() => [vi.fn(), vi.fn(), vi.fn()]),
+jest.mock('react-dnd', () => ({
+	useDrop: jest.fn().mockImplementation(() => [jest.fn(), jest.fn(), jest.fn()]),
+	useDrag: jest.fn().mockImplementation(() => [jest.fn(), jest.fn(), jest.fn()]),
 }));
 
 describe('Utils testing of DraggableTableRow component', () => {
 	it('Should dropHandler return true', () => {
 		const monitor = {
-			isOver: vi.fn().mockReturnValueOnce(true),
+			isOver: jest.fn().mockReturnValueOnce(true),
 		} as never;
 		const dropDataTruthy = dropHandler(monitor);
 
@@ -19,7 +17,7 @@ describe('Utils testing of DraggableTableRow component', () => {
 
 	it('Should dropHandler return false', () => {
 		const monitor = {
-			isOver: vi.fn().mockReturnValueOnce(false),
+			isOver: jest.fn().mockReturnValueOnce(false),
 		} as never;
 		const dropDataFalsy = dropHandler(monitor);
 
@@ -28,7 +26,7 @@ describe('Utils testing of DraggableTableRow component', () => {
 
 	it('Should dragHandler return true', () => {
 		const monitor = {
-			isDragging: vi.fn().mockReturnValueOnce(true),
+			isDragging: jest.fn().mockReturnValueOnce(true),
 		} as never;
 		const dragDataTruthy = dragHandler(monitor);
 
@@ -37,7 +35,7 @@ describe('Utils testing of DraggableTableRow component', () => {
 
 	it('Should dragHandler return false', () => {
 		const monitor = {
-			isDragging: vi.fn().mockReturnValueOnce(false),
+			isDragging: jest.fn().mockReturnValueOnce(false),
 		} as never;
 		const dragDataFalsy = dragHandler(monitor);
 

frontend/src/components/EditMemberDrawer/__tests__/EditMemberDrawer.test.tsx

@@ -1,9 +1,6 @@
-import type { ChangeEventHandler, ReactNode } from 'react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { Mock } from 'vitest';
+import type { ReactNode } from 'react';
 import { toast } from '@signozhq/ui';
 import { convertToApiError } from 'api/ErrorResponseHandlerForGeneratedAPIs';
-import { useListRoles } from 'api/generated/services/role';
 import {
 	useCreateResetPasswordToken,
 	useDeleteUser,
@@ -18,138 +15,88 @@ import {
 	listRolesSuccessResponse,
 	managedRoles,
 } from 'mocks-server/__mockdata__/roles';
+import { rest, server } from 'mocks-server/server';
 import { render, screen, userEvent, waitFor } from 'tests/test-utils';
 
 import EditMemberDrawer, { EditMemberDrawerProps } from '../EditMemberDrawer';
 
-vi.mock('api/generated/services/role', async () => {
-	const actual = await vi.importActual<
-		typeof import('api/generated/services/role')
-	>('api/generated/services/role');
-	return {
-		...actual,
-		useListRoles: vi.fn(),
-	};
-});
-
-vi.mock('api/generated/services/users', () => ({
-	useDeleteUser: vi.fn(),
-	useGetUser: vi.fn(),
-	useUpdateUser: vi.fn(),
-	useUpdateMyUserV2: vi.fn(),
-	useSetRoleByUserID: vi.fn(),
-	useGetResetPasswordToken: vi.fn(),
-	useCreateResetPasswordToken: vi.fn(),
+jest.mock('api/generated/services/users', () => ({
+	useDeleteUser: jest.fn(),
+	useGetUser: jest.fn(),
+	useUpdateUser: jest.fn(),
+	useUpdateMyUserV2: jest.fn(),
+	useSetRoleByUserID: jest.fn(),
+	useGetResetPasswordToken: jest.fn(),
+	useCreateResetPasswordToken: jest.fn(),
 }));
 
-vi.mock('api/ErrorResponseHandlerForGeneratedAPIs', () => ({
-	convertToApiError: vi.fn(),
+jest.mock('api/ErrorResponseHandlerForGeneratedAPIs', () => ({
+	convertToApiError: jest.fn(),
 }));
 
-vi.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): Mock => vi.fn(),
+jest.mock('@signozhq/ui', () => ({
+	...jest.requireActual('@signozhq/ui'),
+	DrawerWrapper: ({
+		children,
+		footer,
+		open,
+	}: {
+		children?: ReactNode;
+		footer?: ReactNode;
+		open: boolean;
+	}): JSX.Element | null =>
+		open ? (
+			<div>
+				{children}
+				{footer}
+			</div>
+		) : null,
+	DialogWrapper: ({
+		children,
+		footer,
+		open,
+		title,
+	}: {
+		children?: ReactNode;
+		footer?: ReactNode;
+		open: boolean;
+		title?: string;
+	}): JSX.Element | null =>
+		open ? (
+			<div role="dialog" aria-label={title}>
+				{children}
+				{footer}
+			</div>
+		) : null,
+	DialogFooter: ({ children }: { children?: ReactNode }): JSX.Element => (
+		<div>{children}</div>
+	),
+	toast: {
+		success: jest.fn(),
+		error: jest.fn(),
+	},
 }));
 
-vi.mock('@signozhq/ui', async () => {
-	const React = await vi.importActual<typeof import('react')>('react');
+const mockCopyToClipboard = jest.fn();
+const mockCopyState = { value: undefined, error: undefined };
 
-	return {
-		Badge: ({ children }: { children?: ReactNode }): JSX.Element =>
-			React.createElement('span', null, children),
-		Button: ({
-			children,
-			disabled,
-			onClick,
-			prefix,
-		}: {
-			children?: ReactNode;
-			disabled?: boolean;
-			onClick?: () => void;
-			prefix?: ReactNode;
-		}): JSX.Element =>
-			React.createElement('button', { disabled, onClick }, prefix, children),
-		DrawerWrapper: ({
-			children,
-			footer,
-			open,
-		}: {
-			children?: ReactNode;
-			footer?: ReactNode;
-			open: boolean;
-		}): JSX.Element | null =>
-			open ? React.createElement('div', null, children, footer) : null,
-		DialogWrapper: ({
-			children,
-			footer,
-			open,
-			title,
-		}: {
-			children?: ReactNode;
-			footer?: ReactNode;
-			open: boolean;
-			title?: string;
-		}): JSX.Element | null =>
-			open
-				? React.createElement(
-						'div',
-						{ role: 'dialog', 'aria-label': title },
-						children,
-						footer,
-					)
-				: null,
-		DialogFooter: ({ children }: { children?: ReactNode }): JSX.Element =>
-			React.createElement('div', null, children),
-		Input: ({
-			disabled,
-			id,
-			onChange,
-			placeholder,
-			value,
-		}: {
-			disabled?: boolean;
-			id?: string;
-			onChange?: ChangeEventHandler<HTMLInputElement>;
-			placeholder?: string;
-			value?: string;
-		}): JSX.Element =>
-			React.createElement('input', {
-				disabled,
-				id,
-				onChange,
-				placeholder,
-				value,
-			}),
-		toast: {
-			success: vi.fn(),
-			error: vi.fn(),
-		},
-	};
-});
-
-const { mockCopyToClipboard, mockCopyState, showErrorModal } = vi.hoisted(
-	() => ({
-		mockCopyToClipboard: vi.fn(),
-		mockCopyState: { value: undefined, error: undefined },
-		showErrorModal: vi.fn(),
-	}),
-);
-
-vi.mock('react-use', () => ({
+jest.mock('react-use', () => ({
 	useCopyToClipboard: (): [typeof mockCopyState, typeof mockCopyToClipboard] => [
 		mockCopyState,
 		mockCopyToClipboard,
 	],
 }));
 
-const mockDeleteMutate = vi.fn();
-const mockCreateTokenMutateAsync = vi.fn();
+const ROLES_ENDPOINT = '*/api/v1/roles';
 
-vi.mock('providers/ErrorModalProvider', async () => ({
+const mockDeleteMutate = jest.fn();
+const mockCreateTokenMutateAsync = jest.fn();
+
+const showErrorModal = jest.fn();
+jest.mock('providers/ErrorModalProvider', () => ({
 	__esModule: true,
-	...(await vi.importActual<typeof import('providers/ErrorModalProvider')>(
-		'providers/ErrorModalProvider',
-	)),
-	useErrorModal: vi.fn(() => ({
+	...jest.requireActual('providers/ErrorModalProvider'),
+	useErrorModal: jest.fn(() => ({
 		showErrorModal,
 		isErrorModalVisible: false,
 	})),
@@ -208,8 +155,8 @@ function renderDrawer(
 		<EditMemberDrawer
 			member={activeMember}
 			open
-			onClose={vi.fn()}
-			onComplete={vi.fn()}
+			onClose={jest.fn()}
+			onComplete={jest.fn()}
 			{...props}
 		/>,
 	);
@@ -217,43 +164,38 @@ function renderDrawer(
 
 describe('EditMemberDrawer', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 		mockCopyState.value = undefined;
 		mockCopyState.error = undefined;
 		showErrorModal.mockClear();
-		(useListRoles as Mock).mockReturnValue({
-			data: listRolesSuccessResponse,
-			isLoading: false,
-			isError: false,
-			error: null,
-			refetch: vi.fn(),
-			isFetching: false,
-			isSuccess: true,
-			status: 'success',
-		});
-		(useGetUser as Mock).mockReturnValue({
+		server.use(
+			rest.get(ROLES_ENDPOINT, (_, res, ctx) =>
+				res(ctx.status(200), ctx.json(listRolesSuccessResponse)),
+			),
+		);
+		(useGetUser as jest.Mock).mockReturnValue({
 			data: mockFetchedUser,
 			isLoading: false,
-			refetch: vi.fn(),
+			refetch: jest.fn(),
 		});
-		(useUpdateUser as Mock).mockReturnValue({
-			mutateAsync: vi.fn().mockResolvedValue({}),
+		(useUpdateUser as jest.Mock).mockReturnValue({
+			mutateAsync: jest.fn().mockResolvedValue({}),
 			isLoading: false,
 		});
-		(useUpdateMyUserV2 as Mock).mockReturnValue({
-			mutateAsync: vi.fn().mockResolvedValue({}),
+		(useUpdateMyUserV2 as jest.Mock).mockReturnValue({
+			mutateAsync: jest.fn().mockResolvedValue({}),
 			isLoading: false,
 		});
-		(useSetRoleByUserID as Mock).mockReturnValue({
-			mutateAsync: vi.fn().mockResolvedValue({}),
+		(useSetRoleByUserID as jest.Mock).mockReturnValue({
+			mutateAsync: jest.fn().mockResolvedValue({}),
 			isLoading: false,
 		});
-		(useDeleteUser as Mock).mockReturnValue({
+		(useDeleteUser as jest.Mock).mockReturnValue({
 			mutate: mockDeleteMutate,
 			isLoading: false,
 		});
 		// Token query: valid token for invited members
-		(useGetResetPasswordToken as Mock).mockReturnValue({
+		(useGetResetPasswordToken as jest.Mock).mockReturnValue({
 			data: {
 				data: {
 					token: 'invite-tok-valid',
@@ -273,18 +215,20 @@ describe('EditMemberDrawer', () => {
 				expiresAt: new Date(Date.now() + 86400000).toISOString(),
 			},
 		});
-		(useCreateResetPasswordToken as Mock).mockReturnValue({
+		(useCreateResetPasswordToken as jest.Mock).mockReturnValue({
 			mutateAsync: mockCreateTokenMutateAsync,
 			isLoading: false,
 		});
 	});
 
-	it('renders active member details and disables Save when form is not dirty', async () => {
+	afterEach(() => {
+		server.resetHandlers();
+	});
+
+	it('renders active member details and disables Save when form is not dirty', () => {
 		renderDrawer();
 
-		await expect(
-			screen.findByDisplayValue('Alice Smith'),
-		).resolves.toBeInTheDocument();
+		expect(screen.getByDisplayValue('Alice Smith')).toBeInTheDocument();
 		expect(screen.getByText('alice@signoz.io')).toBeInTheDocument();
 		expect(screen.getByText('ACTIVE')).toBeInTheDocument();
 		expect(
@@ -293,11 +237,11 @@ describe('EditMemberDrawer', () => {
 	});
 
 	it('enables Save after editing name and calls updateUser on confirm', async () => {
-		const onComplete = vi.fn();
+		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const mockMutateAsync = vi.fn().mockResolvedValue({});
+		const mockMutateAsync = jest.fn().mockResolvedValue({});
 
-		(useUpdateUser as Mock).mockReturnValue({
+		(useUpdateUser as jest.Mock).mockReturnValue({
 			mutateAsync: mockMutateAsync,
 			isLoading: false,
 		});
@@ -323,7 +267,7 @@ describe('EditMemberDrawer', () => {
 	});
 
 	it('does not close the drawer after a successful save', async () => {
-		const onClose = vi.fn();
+		const onClose = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 		renderDrawer({ onClose });
@@ -345,18 +289,18 @@ describe('EditMemberDrawer', () => {
 	});
 
 	it('selecting a different role calls setRole with the new role name', async () => {
-		const onComplete = vi.fn();
+		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const mockSet = vi.fn().mockResolvedValue({});
+		const mockSet = jest.fn().mockResolvedValue({});
 
-		(useSetRoleByUserID as Mock).mockReturnValue({
+		(useSetRoleByUserID as jest.Mock).mockReturnValue({
 			mutateAsync: mockSet,
 			isLoading: false,
 		});
 
 		renderDrawer({ onComplete });
 
-		await screen.findByTitle('signoz-admin');
+		// Open the roles dropdown and select signoz-editor
 		await user.click(screen.getByLabelText('Roles'));
 		await user.click(await screen.findByTitle('signoz-editor'));
 
@@ -374,18 +318,18 @@ describe('EditMemberDrawer', () => {
 	});
 
 	it('does not call removeRole when the role is changed', async () => {
-		const onComplete = vi.fn();
+		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const mockSet = vi.fn().mockResolvedValue({});
+		const mockSet = jest.fn().mockResolvedValue({});
 
-		(useSetRoleByUserID as Mock).mockReturnValue({
+		(useSetRoleByUserID as jest.Mock).mockReturnValue({
 			mutateAsync: mockSet,
 			isLoading: false,
 		});
 
 		renderDrawer({ onComplete });
 
-		await screen.findByTitle('signoz-admin');
+		// Switch from signoz-admin to signoz-viewer using single-select
 		await user.click(screen.getByLabelText('Roles'));
 		await user.click(await screen.findByTitle('signoz-viewer'));
 
@@ -403,10 +347,10 @@ describe('EditMemberDrawer', () => {
 	});
 
 	it('shows delete confirm dialog and calls deleteUser for active members', async () => {
-		const onComplete = vi.fn();
+		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-		(useDeleteUser as Mock).mockImplementation((options) => ({
+		(useDeleteUser as jest.Mock).mockImplementation((options) => ({
 			mutate: mockDeleteMutate.mockImplementation(() => {
 				options?.mutation?.onSuccess?.();
 			}),
@@ -449,7 +393,7 @@ describe('EditMemberDrawer', () => {
 	});
 
 	it('shows "Regenerate Invite Link" when token is expired', () => {
-		(useGetResetPasswordToken as Mock).mockReturnValue({
+		(useGetResetPasswordToken as jest.Mock).mockReturnValue({
 			data: {
 				data: {
 					token: 'old-tok',
@@ -469,7 +413,7 @@ describe('EditMemberDrawer', () => {
 	});
 
 	it('shows "Generate Invite Link" when no token exists', () => {
-		(useGetResetPasswordToken as Mock).mockReturnValue({
+		(useGetResetPasswordToken as jest.Mock).mockReturnValue({
 			data: undefined,
 			isLoading: false,
 			isError: true,
@@ -483,10 +427,10 @@ describe('EditMemberDrawer', () => {
 	});
 
 	it('calls deleteUser after confirming revoke invite for invited members', async () => {
-		const onComplete = vi.fn();
+		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-		(useDeleteUser as Mock).mockImplementation((options) => ({
+		(useDeleteUser as jest.Mock).mockImplementation((options) => ({
 			mutate: mockDeleteMutate.mockImplementation(() => {
 				options?.mutation?.onSuccess?.();
 			}),
@@ -513,11 +457,11 @@ describe('EditMemberDrawer', () => {
 	});
 
 	it('calls updateUser when saving name change for an invited member', async () => {
-		const onComplete = vi.fn();
+		const onComplete = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const mockMutateAsync = vi.fn().mockResolvedValue({});
+		const mockMutateAsync = jest.fn().mockResolvedValue({});
 
-		(useGetUser as Mock).mockReturnValue({
+		(useGetUser as jest.Mock).mockReturnValue({
 			data: {
 				data: {
 					...mockFetchedUser.data,
@@ -533,9 +477,9 @@ describe('EditMemberDrawer', () => {
 				},
 			},
 			isLoading: false,
-			refetch: vi.fn(),
+			refetch: jest.fn(),
 		});
-		(useUpdateUser as Mock).mockReturnValue({
+		(useUpdateUser as jest.Mock).mockReturnValue({
 			mutateAsync: mockMutateAsync,
 			isLoading: false,
 		});
@@ -560,7 +504,7 @@ describe('EditMemberDrawer', () => {
 	});
 
 	describe('error handling', () => {
-		const mockConvertToApiError = vi.mocked(convertToApiError);
+		const mockConvertToApiError = jest.mocked(convertToApiError);
 
 		beforeEach(() => {
 			mockConvertToApiError.mockReturnValue({
@@ -571,8 +515,8 @@ describe('EditMemberDrawer', () => {
 		it('shows SaveErrorItem when updateUser fails for name change', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-			(useUpdateUser as Mock).mockReturnValue({
-				mutateAsync: vi.fn().mockRejectedValue(new Error('server error')),
+			(useUpdateUser as jest.Mock).mockReturnValue({
+				mutateAsync: jest.fn().mockRejectedValue(new Error('server error')),
 				isLoading: false,
 			});
 
@@ -596,7 +540,7 @@ describe('EditMemberDrawer', () => {
 		it('shows API error message when deleteUser fails for active member', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-			(useDeleteUser as Mock).mockImplementation((options) => ({
+			(useDeleteUser as jest.Mock).mockImplementation((options) => ({
 				mutate: mockDeleteMutate.mockImplementation(() => {
 					options?.mutation?.onError?.({});
 				}),
@@ -627,7 +571,7 @@ describe('EditMemberDrawer', () => {
 		it('shows API error message when deleteUser fails for invited member', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
 
-			(useDeleteUser as Mock).mockImplementation((options) => ({
+			(useDeleteUser as jest.Mock).mockImplementation((options) => ({
 				mutate: mockDeleteMutate.mockImplementation(() => {
 					options?.mutation?.onError?.({});
 				}),
@@ -690,10 +634,10 @@ describe('EditMemberDrawer', () => {
 
 	describe('root user', () => {
 		beforeEach(() => {
-			(useGetUser as Mock).mockReturnValue({
+			(useGetUser as jest.Mock).mockReturnValue({
 				data: rootMockFetchedUser,
 				isLoading: false,
-				refetch: vi.fn(),
+				refetch: jest.fn(),
 			});
 		});
 
@@ -773,7 +717,7 @@ describe('EditMemberDrawer', () => {
 
 		it('copies the link to clipboard and shows "Copied!" on the button', async () => {
 			const user = userEvent.setup({ pointerEventsCheck: 0 });
-			const mockToast = vi.mocked(toast);
+			const mockToast = jest.mocked(toast);
 
 			renderDrawer();
 

frontend/src/components/Editor/Editor.test.tsx

@@ -1,39 +1,10 @@
 import { render, screen } from '@testing-library/react';
 import { useIsDarkMode } from 'hooks/useDarkMode';
-import { describe, expect, it, vi } from 'vitest';
-import type { Mock } from 'vitest';
 
 import Editor from './index';
 
-vi.mock('hooks/useDarkMode', () => ({
-	useIsDarkMode: vi.fn(),
-}));
-
-vi.mock('@monaco-editor/react', () => ({
-	default: ({ height }: { height?: string }): JSX.Element => (
-		<section
-			style={{
-				display: 'flex',
-				position: 'relative',
-				textAlign: 'initial',
-				width: '100%',
-				height,
-			}}
-		>
-			<div
-				style={{
-					display: 'flex',
-					height: '100%',
-					width: '100%',
-					justifyContent: 'center',
-					alignItems: 'center',
-				}}
-			>
-				Loading...
-			</div>
-			<div style={{ width: '100%', display: 'none' }} />
-		</section>
-	),
+jest.mock('hooks/useDarkMode', () => ({
+	useIsDarkMode: jest.fn(),
 }));
 
 describe('Editor', () => {
@@ -63,7 +34,7 @@ describe('Editor', () => {
 	});
 
 	it('renders with dark mode theme', () => {
-		(useIsDarkMode as Mock).mockImplementation(() => true);
+		(useIsDarkMode as jest.Mock).mockImplementation(() => true);
 
 		const { container } = render(<Editor value="dark mode text" />);
 
@@ -71,7 +42,7 @@ describe('Editor', () => {
 	});
 
 	it('renders with light mode theme', () => {
-		(useIsDarkMode as Mock).mockImplementation(() => false);
+		(useIsDarkMode as jest.Mock).mockImplementation(() => false);
 
 		const { container } = render(<Editor value="light mode text" />);
 

frontend/src/components/Editor/__snapshots__/Editor.test.tsx.snap

@@ -1,6 +1,6 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
-exports[`Editor > renders correctly with custom props 1`] = `
+exports[`Editor renders correctly with custom props 1`] = `
 <div>
   <section
     style="display: flex; position: relative; text-align: initial; width: 100%; height: 50vh;"
@@ -17,7 +17,7 @@ exports[`Editor > renders correctly with custom props 1`] = `
 </div>
 `;
 
-exports[`Editor > renders correctly with default props 1`] = `
+exports[`Editor renders correctly with default props 1`] = `
 <div>
   <section
     style="display: flex; position: relative; text-align: initial; width: 100%; height: 40vh;"
@@ -34,7 +34,7 @@ exports[`Editor > renders correctly with default props 1`] = `
 </div>
 `;
 
-exports[`Editor > renders with dark mode theme 1`] = `
+exports[`Editor renders with dark mode theme 1`] = `
 <div>
   <section
     style="display: flex; position: relative; text-align: initial; width: 100%; height: 40vh;"
@@ -51,7 +51,7 @@ exports[`Editor > renders with dark mode theme 1`] = `
 </div>
 `;
 
-exports[`Editor > renders with light mode theme 1`] = `
+exports[`Editor renders with light mode theme 1`] = `
 <div>
   <section
     style="display: flex; position: relative; text-align: initial; width: 100%; height: 40vh;"

frontend/src/components/ErrorBoundaryHOC/__tests__/withErrorBoundary.test.tsx

@@ -1,22 +1,13 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
-import {
-	afterAll,
-	beforeAll,
-	beforeEach,
-	describe,
-	expect,
-	it,
-	vi,
-} from 'vitest';
 
 import withErrorBoundary, {
 	WithErrorBoundaryOptions,
 } from '../withErrorBoundary';
 
 // Mock dependencies before imports
-vi.mock('@sentry/react', async () => {
-	const ReactMock = await vi.importActual<typeof import('react')>('react');
+jest.mock('@sentry/react', () => {
+	const ReactMock = jest.requireActual('react');
 
 	class MockErrorBoundary extends ReactMock.Component<
 		{
@@ -43,8 +34,8 @@ vi.mock('@sentry/react', async () => {
 			const { beforeCapture, onError } = this.props;
 			if (beforeCapture) {
 				const mockScope = {
-					setTag: vi.fn(),
-					setLevel: vi.fn(),
+					setTag: jest.fn(),
+					setLevel: jest.fn(),
 				};
 				beforeCapture(mockScope);
 			}
@@ -73,11 +64,15 @@ vi.mock('@sentry/react', async () => {
 	};
 });
 
-vi.mock('../../../pages/ErrorBoundaryFallback/ErrorBoundaryFallback', () => ({
-	default: function MockErrorBoundaryFallback(): JSX.Element {
-		return <div data-testid="default-error-fallback">Default Error Fallback</div>;
-	},
-}));
+jest.mock(
+	'../../../pages/ErrorBoundaryFallback/ErrorBoundaryFallback',
+	() =>
+		function MockErrorBoundaryFallback(): JSX.Element {
+			return (
+				<div data-testid="default-error-fallback">Default Error Fallback</div>
+			);
+		},
+);
 
 // Test component that can throw errors
 interface TestComponentProps {
@@ -110,7 +105,7 @@ describe('withErrorBoundary', () => {
 	// Suppress console errors for cleaner test output
 	const originalError = console.error;
 	beforeAll(() => {
-		console.error = vi.fn();
+		console.error = jest.fn();
 	});
 
 	afterAll(() => {
@@ -118,7 +113,7 @@ describe('withErrorBoundary', () => {
 	});
 
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 	});
 
 	it('should wrap component with ErrorBoundary and render successfully', () => {
@@ -167,7 +162,7 @@ describe('withErrorBoundary', () => {
 
 	it('should call custom error handler when error occurs', () => {
 		// Arrange
-		const mockErrorHandler = vi.fn();
+		const mockErrorHandler = jest.fn();
 		const options: WithErrorBoundaryOptions = {
 			onError: mockErrorHandler,
 		};

frontend/src/components/ErrorModal/ErrorModal.test.tsx

@@ -1,26 +1,19 @@
-import { describe, expect, it, vi } from 'vitest';
 import { render, screen, userEvent, waitFor } from 'tests/test-utils';
 import APIError from 'types/api/error';
 
 import ErrorModal from './ErrorModal';
 
 // Mock the query client to return version data
-const mockVersionData = vi.hoisted(() => ({
+const mockVersionData = {
 	payload: {
 		ee: 'Y',
 		version: '1.0.0',
 	},
-}));
-vi.mock('react-query', async () => ({
-	...(await vi.importActual('react-query')),
+};
+jest.mock('react-query', () => ({
+	...jest.requireActual('react-query'),
 	useQueryClient: (): { getQueryData: () => typeof mockVersionData } => ({
-		getQueryData: vi.fn(() => mockVersionData),
-	}),
-}));
-
-vi.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: ReturnType<typeof vi.fn> } => ({
-		safeNavigate: vi.fn(),
+		getQueryData: jest.fn(() => mockVersionData),
 	}),
 }));
 const mockError: APIError = new APIError({
@@ -38,7 +31,7 @@ const mockError: APIError = new APIError({
 });
 describe('ErrorModal Component', () => {
 	it('should render the modal when open is true', () => {
-		render(<ErrorModal error={mockError} open onClose={vi.fn()} />);
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
 
 		// Check if the error message is displayed
 		expect(screen.getByText('An error occurred')).toBeInTheDocument();
@@ -48,14 +41,14 @@ describe('ErrorModal Component', () => {
 	});
 
 	it('should not render the modal when open is false', () => {
-		render(<ErrorModal error={mockError} open={false} onClose={vi.fn()} />);
+		render(<ErrorModal error={mockError} open={false} onClose={jest.fn()} />);
 
 		// Check that the modal content is not in the document
 		expect(screen.queryByText('An error occurred')).not.toBeInTheDocument();
 	});
 
 	it('should call onClose when the close button is clicked', async () => {
-		const onCloseMock = vi.fn();
+		const onCloseMock = jest.fn();
 		render(<ErrorModal error={mockError} open onClose={onCloseMock} />);
 
 		// Click the close button
@@ -68,14 +61,14 @@ describe('ErrorModal Component', () => {
 	});
 
 	it('should display version data if available', async () => {
-		render(<ErrorModal error={mockError} open onClose={vi.fn()} />);
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
 
 		// Check if the version data is displayed
 		expect(screen.getByText('ENTERPRISE')).toBeInTheDocument();
 		expect(screen.getByText('1.0.0')).toBeInTheDocument();
 	});
 	it('should render the messages count badge when there are multiple errors', () => {
-		render(<ErrorModal error={mockError} open onClose={vi.fn()} />);
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
 
 		// Check if the messages count badge is displayed
 		expect(screen.getByText('MESSAGES')).toBeInTheDocument();
@@ -89,7 +82,7 @@ describe('ErrorModal Component', () => {
 	});
 
 	it('should render the open docs button when URL is provided', async () => {
-		render(<ErrorModal error={mockError} open onClose={vi.fn()} />);
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
 
 		// Check if the open docs button is displayed
 		const openDocsButton = screen.getByTestId('error-docs-button');
@@ -102,7 +95,7 @@ describe('ErrorModal Component', () => {
 	});
 
 	it('should not display scroll for more if there are less than 10 messages', () => {
-		render(<ErrorModal error={mockError} open onClose={vi.fn()} />);
+		render(<ErrorModal error={mockError} open onClose={jest.fn()} />);
 
 		expect(screen.queryByText('Scroll for more')).not.toBeInTheDocument();
 	});
@@ -120,7 +113,7 @@ describe('ErrorModal Component', () => {
 			},
 		});
 
-		render(<ErrorModal error={longError} open onClose={vi.fn()} />);
+		render(<ErrorModal error={longError} open onClose={jest.fn()} />);
 
 		// Check if the scroll hint is displayed
 		expect(screen.getByText('Scroll for more')).toBeInTheDocument();
@@ -132,7 +125,7 @@ it('should render the trigger component if provided', () => {
 		<ErrorModal
 			error={mockError}
 			triggerComponent={mockTrigger}
-			onClose={vi.fn()}
+			onClose={jest.fn()}
 		/>,
 	);
 
@@ -146,7 +139,7 @@ it('should open the modal when the trigger component is clicked', async () => {
 		<ErrorModal
 			error={mockError}
 			triggerComponent={mockTrigger}
-			onClose={vi.fn()}
+			onClose={jest.fn()}
 		/>,
 	);
 
@@ -160,14 +153,14 @@ it('should open the modal when the trigger component is clicked', async () => {
 });
 
 it('should render the default trigger tag if no trigger component is provided', () => {
-	render(<ErrorModal error={mockError} onClose={vi.fn()} />);
+	render(<ErrorModal error={mockError} onClose={jest.fn()} />);
 
 	// Check if the default trigger tag is rendered
 	expect(screen.getByText('error')).toBeInTheDocument();
 });
 
 it('should close the modal when the onCancel event is triggered', async () => {
-	const onCloseMock = vi.fn();
+	const onCloseMock = jest.fn();
 	render(<ErrorModal error={mockError} onClose={onCloseMock} />);
 
 	// Click the trigger component
@@ -186,7 +179,9 @@ it('should close the modal when the onCancel event is triggered', async () => {
 	expect(onCloseMock).toHaveBeenCalledTimes(1);
 
 	await waitFor(() => {
+		// check if the modal is not visible
 		const modal = document.getElementsByClassName('ant-modal');
-		expect(modal[0]).toHaveClass('ant-zoom-leave');
+		const style = window.getComputedStyle(modal[0]);
+		expect(style.display).toBe('none');
 	});
 });

frontend/src/components/ExplorerCard/ExplorerCard.tsx

@@ -15,8 +15,8 @@ import {
 	Row,
 	Select,
 	Space,
-	Typography,
 } from 'antd';
+import { Typography } from '@signozhq/ui';
 import axios from 'axios';
 import TextToolTip from 'components/TextToolTip';
 import { SOMETHING_WENT_WRONG } from 'constants/api';

frontend/src/components/ExplorerCard/MenuItemGenerator.tsx

@@ -1,6 +1,7 @@
 import { MouseEvent, useCallback } from 'react';
 import { DeleteOutlined } from '@ant-design/icons';
-import { Col, Row, Tooltip, Typography } from 'antd';
+import { Col, Row, Tooltip } from 'antd';
+import { Typography } from '@signozhq/ui';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useDeleteView } from 'hooks/saveViews/useDeleteView';
 import { useHandleExplorerTabChange } from 'hooks/useHandleExplorerTabChange';
@@ -81,7 +82,7 @@ function MenuItemGenerator({
 						</Tooltip>
 					</Row>
 					<Row>
-						<Typography.Text type="secondary">Created by {createdBy}</Typography.Text>
+						<Typography.Text color="muted">Created by {createdBy}</Typography.Text>
 					</Row>
 				</Col>
 				<Col span={2}>

frontend/src/components/ExplorerCard/SaveViewWithName.tsx

@@ -1,5 +1,6 @@
 import { useTranslation } from 'react-i18next';
-import { Card, Form, Input, Typography } from 'antd';
+import { Card, Form, Input } from 'antd';
+import { Typography } from '@signozhq/ui';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
 import { useSaveView } from 'hooks/saveViews/useSaveView';

frontend/src/components/ExplorerCard/test/ExplorerCard.test.tsx

@@ -3,63 +3,57 @@ import ROUTES from 'constants/routes';
 import { PreferenceContextProvider } from 'providers/preferences/context/PreferenceContextProvider';
 import MockQueryClientProvider from 'providers/test/MockQueryClientProvider';
 import { DataSource } from 'types/common/queryBuilder';
-import { describe, expect, it, vi } from 'vitest';
 
 import { viewMockData } from '../__mock__/viewData';
 import ExplorerCard from '../ExplorerCard';
 
-const historyReplace = vi.hoisted(() => vi.fn());
+const historyReplace = jest.fn();
 
-vi.mock('react-router-dom', async () => {
-	const actual =
-		await vi.importActual<typeof import('react-router-dom')>('react-router-dom');
-
-	return {
-		...actual,
-		useLocation: (): { pathname: string } => ({
-			pathname: `${process.env.FRONTEND_API_ENDPOINT}/${ROUTES.TRACES_EXPLORER}/`,
-		}),
-		useHistory: (): any => ({
-			...actual.useHistory(),
-			replace: historyReplace,
-		}),
-	};
-});
-
-vi.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): any => ({
-		safeNavigate: vi.fn(),
+jest.mock('react-router-dom', () => ({
+	...jest.requireActual('react-router-dom'),
+	useLocation: (): { pathname: string } => ({
+		pathname: `${process.env.FRONTEND_API_ENDPOINT}/${ROUTES.TRACES_EXPLORER}/`,
+	}),
+	useHistory: (): any => ({
+		...jest.requireActual('react-router-dom').useHistory(),
+		replace: historyReplace,
 	}),
 }));
 
-vi.mock('hooks/queryBuilder/useGetPanelTypesQueryParam', () => ({
-	useGetPanelTypesQueryParam: vi.fn(() => 'mockedPanelType'),
+jest.mock('hooks/useSafeNavigate', () => ({
+	useSafeNavigate: (): any => ({
+		safeNavigate: jest.fn(),
+	}),
 }));
 
-vi.mock('hooks/saveViews/useGetAllViews', () => ({
-	useGetAllViews: vi.fn(() => ({
+jest.mock('hooks/queryBuilder/useGetPanelTypesQueryParam', () => ({
+	useGetPanelTypesQueryParam: jest.fn(() => 'mockedPanelType'),
+}));
+
+jest.mock('hooks/saveViews/useGetAllViews', () => ({
+	useGetAllViews: jest.fn(() => ({
 		data: { data: { data: viewMockData } },
 		isLoading: false,
 		error: null,
 		isRefetching: false,
-		refetch: vi.fn(),
+		refetch: jest.fn(),
 	})),
 }));
 
-vi.mock('hooks/saveViews/useUpdateView', () => ({
-	useUpdateView: vi.fn(() => ({
-		mutateAsync: vi.fn(),
+jest.mock('hooks/saveViews/useUpdateView', () => ({
+	useUpdateView: jest.fn(() => ({
+		mutateAsync: jest.fn(),
 	})),
 }));
 
-vi.mock('hooks/saveViews/useDeleteView', () => ({
-	useDeleteView: vi.fn(() => ({
-		mutateAsync: vi.fn(),
+jest.mock('hooks/saveViews/useDeleteView', () => ({
+	useDeleteView: jest.fn(() => ({
+		mutateAsync: jest.fn(),
 	})),
 }));
 
 // Mock usePreferenceSync
-vi.mock('providers/preferences/sync/usePreferenceSync', () => ({
+jest.mock('providers/preferences/sync/usePreferenceSync', () => ({
 	usePreferenceSync: (): any => ({
 		preferences: {
 			columns: [],
@@ -72,8 +66,8 @@ vi.mock('providers/preferences/sync/usePreferenceSync', () => ({
 		},
 		loading: false,
 		error: null,
-		updateColumns: vi.fn(),
-		updateFormatting: vi.fn(),
+		updateColumns: jest.fn(),
+		updateFormatting: jest.fn(),
 	}),
 }));
 

frontend/src/components/ExplorerCard/test/MenuItemGenerator.test.tsx

@@ -2,22 +2,21 @@ import { render, screen } from '@testing-library/react';
 import ROUTES from 'constants/routes';
 import MockQueryClientProvider from 'providers/test/MockQueryClientProvider';
 import { DataSource } from 'types/common/queryBuilder';
-import { describe, expect, it, vi } from 'vitest';
 
 import { viewMockData } from '../__mock__/viewData';
 import MenuItemGenerator from '../MenuItemGenerator';
 
-vi.mock('react-router-dom', async () => ({
-	...(await vi.importActual('react-router-dom')),
+jest.mock('react-router-dom', () => ({
+	...jest.requireActual('react-router-dom'),
 	useLocation: (): { pathname: string } => ({
 		pathname: `${process.env.FRONTEND_API_ENDPOINT}${ROUTES.APPLICATION}/`,
 	}),
 }));
 
-vi.mock('antd', async () => ({
-	...(await vi.importActual('antd')),
-	useForm: vi.fn().mockReturnValue({
-		onFinish: vi.fn(),
+jest.mock('antd', () => ({
+	...jest.requireActual('antd'),
+	useForm: jest.fn().mockReturnValue({
+		onFinish: jest.fn(),
 	}),
 }));
 
@@ -30,7 +29,7 @@ describe('MenuItemGenerator', () => {
 					viewKey={viewMockData[0].id}
 					createdBy={viewMockData[0].createdBy}
 					uuid={viewMockData[0].id}
-					refetchAllView={vi.fn()}
+					refetchAllView={jest.fn()}
 					viewData={viewMockData}
 					sourcePage={DataSource.TRACES}
 				/>
@@ -48,7 +47,7 @@ describe('MenuItemGenerator', () => {
 					viewKey={viewMockData[0].id}
 					createdBy={viewMockData[0].createdBy}
 					uuid={viewMockData[0].id}
-					refetchAllView={vi.fn()}
+					refetchAllView={jest.fn()}
 					viewData={viewMockData}
 					sourcePage={DataSource.TRACES}
 				/>

frontend/src/components/ExplorerCard/test/SaveViewWithName.test.tsx

@@ -1,16 +1,14 @@
-import { describe, expect, it, vi } from 'vitest';
 import { QueryClient, QueryClientProvider } from 'react-query';
 import { fireEvent, render } from '@testing-library/react';
+import ROUTES from 'constants/routes';
 import { DataSource } from 'types/common/queryBuilder';
 
 import SaveViewWithName from '../SaveViewWithName';
 
-vi.mock('react-router-dom', async () => ({
-	...(await vi.importActual<typeof import('react-router-dom')>(
-		'react-router-dom',
-	)),
+jest.mock('react-router-dom', () => ({
+	...jest.requireActual('react-router-dom'),
 	useLocation: (): { pathname: string } => ({
-		pathname: `${process.env.FRONTEND_API_ENDPOINT}/services/`,
+		pathname: `${process.env.FRONTEND_API_ENDPOINT}${ROUTES.APPLICATION}/`,
 	}),
 }));
 
@@ -22,13 +20,13 @@ const queryClient = new QueryClient({
 	},
 });
 
-vi.mock('hooks/queryBuilder/useGetPanelTypesQueryParam', () => ({
-	useGetPanelTypesQueryParam: vi.fn(() => 'mockedPanelType'),
+jest.mock('hooks/queryBuilder/useGetPanelTypesQueryParam', () => ({
+	useGetPanelTypesQueryParam: jest.fn(() => 'mockedPanelType'),
 }));
 
-vi.mock('hooks/saveViews/useSaveView', () => ({
-	useSaveView: vi.fn(() => ({
-		mutateAsync: vi.fn(),
+jest.mock('hooks/saveViews/useSaveView', () => ({
+	useSaveView: jest.fn(() => ({
+		mutateAsync: jest.fn(),
 	})),
 }));
 
@@ -38,8 +36,8 @@ describe('SaveViewWithName', () => {
 			<QueryClientProvider client={queryClient}>
 				<SaveViewWithName
 					sourcePage={DataSource.TRACES}
-					handlePopOverClose={vi.fn()}
-					refetchAllView={vi.fn()}
+					handlePopOverClose={jest.fn()}
+					refetchAllView={jest.fn()}
 				/>
 			</QueryClientProvider>,
 		);
@@ -52,8 +50,8 @@ describe('SaveViewWithName', () => {
 			<QueryClientProvider client={queryClient}>
 				<SaveViewWithName
 					sourcePage={DataSource.TRACES}
-					handlePopOverClose={vi.fn()}
-					refetchAllView={vi.fn()}
+					handlePopOverClose={jest.fn()}
+					refetchAllView={jest.fn()}
 				/>
 			</QueryClientProvider>,
 		);

frontend/src/components/GlobalTimeStoreAdapter/__tests__/GlobalTimeStoreAdapter.test.tsx

@@ -7,7 +7,6 @@ import { useGlobalTimeStore } from 'store/globalTime/globalTimeStore';
 import { createCustomTimeRange } from 'store/globalTime/utils';
 import { AppState } from 'store/reducers';
 import { GlobalReducer } from 'types/reducer/globalTime';
-import { beforeEach, describe, expect, it } from 'vitest';
 
 import { GlobalTimeStoreAdapter } from '../GlobalTimeStoreAdapter';
 

frontend/src/components/Graph/__tests__/xAxisConfig.test.ts

@@ -1,5 +1,3 @@
-import { describe, expect, it } from 'vitest';
-
 import dayjs from 'dayjs';
 
 import { convertTimeRange, TIME_UNITS } from '../xAxisConfig';

frontend/src/components/Graph/__tests__/yAxisConfig.test.ts

@@ -1,5 +1,3 @@
-import { describe, expect, it } from 'vitest';
-
 import { PrecisionOptionsEnum } from '../types';
 import { getYAxisFormattedValue } from '../yAxisConfig';
 

frontend/src/components/GuardAuthZ/GuardAuthZ.test.tsx

@@ -1,5 +1,4 @@
 import { ReactElement } from 'react';
-import { describe, expect, it, vi } from 'vitest';
 import {
 	AuthtypesGettableTransactionDTO,
 	AuthtypesTransactionDTO,
@@ -13,12 +12,6 @@ import { render, screen, waitFor } from 'tests/test-utils';
 
 import { GuardAuthZ } from './GuardAuthZ';
 
-vi.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: () => void } => ({
-		safeNavigate: (): void => {},
-	}),
-}));
-
 const BASE_URL = ENVIRONMENT.baseURL || '';
 const AUTHZ_CHECK_URL = `${BASE_URL}/api/v1/authz/check`;
 
@@ -62,7 +55,7 @@ describe('GuardAuthZ', () => {
 		);
 
 		render(
-			<GuardAuthZ relation="read" object="dashboard:*">
+			<GuardAuthZ relation="read" object="role:*">
 				<TestChild />
 			</GuardAuthZ>,
 		);
@@ -86,7 +79,7 @@ describe('GuardAuthZ', () => {
 		render(
 			<GuardAuthZ
 				relation="read"
-				object="dashboard:*"
+				object="role:*"
 				fallbackOnLoading={<LoadingFallback />}
 			>
 				<TestChild />
@@ -109,7 +102,7 @@ describe('GuardAuthZ', () => {
 		);
 
 		const { container } = render(
-			<GuardAuthZ relation="read" object="dashboard:*">
+			<GuardAuthZ relation="read" object="role:*">
 				<TestChild />
 			</GuardAuthZ>,
 		);
@@ -128,11 +121,7 @@ describe('GuardAuthZ', () => {
 		);
 
 		render(
-			<GuardAuthZ
-				relation="read"
-				object="dashboard:*"
-				fallbackOnError={ErrorFallback}
-			>
+			<GuardAuthZ relation="read" object="role:*" fallbackOnError={ErrorFallback}>
 				<TestChild />
 			</GuardAuthZ>,
 		);
@@ -162,7 +151,7 @@ describe('GuardAuthZ', () => {
 		render(
 			<GuardAuthZ
 				relation="read"
-				object="dashboard:*"
+				object="role:*"
 				fallbackOnError={errorFallbackWithCapture}
 			>
 				<TestChild />
@@ -185,7 +174,7 @@ describe('GuardAuthZ', () => {
 		);
 
 		const { container } = render(
-			<GuardAuthZ relation="read" object="dashboard:*">
+			<GuardAuthZ relation="read" object="role:*">
 				<TestChild />
 			</GuardAuthZ>,
 		);
@@ -208,7 +197,7 @@ describe('GuardAuthZ', () => {
 		render(
 			<GuardAuthZ
 				relation="update"
-				object="dashboard:123"
+				object="role:123"
 				fallbackOnNoPermissions={NoPermissionFallback}
 			>
 				<TestChild />
@@ -231,7 +220,7 @@ describe('GuardAuthZ', () => {
 		);
 
 		const { container } = render(
-			<GuardAuthZ relation="update" object="dashboard:123">
+			<GuardAuthZ relation="update" object="role:123">
 				<TestChild />
 			</GuardAuthZ>,
 		);
@@ -251,7 +240,7 @@ describe('GuardAuthZ', () => {
 		);
 
 		const { container } = render(
-			<GuardAuthZ relation="read" object="dashboard:*">
+			<GuardAuthZ relation="read" object="role:*">
 				<TestChild />
 			</GuardAuthZ>,
 		);
@@ -264,7 +253,7 @@ describe('GuardAuthZ', () => {
 	});
 
 	it('should pass requiredPermissionName to fallbackOnNoPermissions', async () => {
-		const permission = buildPermission('update', 'dashboard:123');
+		const permission = buildPermission('update', 'role:123');
 
 		server.use(
 			rest.post(AUTHZ_CHECK_URL, async (req, res, ctx) => {
@@ -276,7 +265,7 @@ describe('GuardAuthZ', () => {
 		render(
 			<GuardAuthZ
 				relation="update"
-				object="dashboard:123"
+				object="role:123"
 				fallbackOnNoPermissions={NoPermissionFallbackWithSuggestions}
 			>
 				<TestChild />
@@ -306,7 +295,7 @@ describe('GuardAuthZ', () => {
 		);
 
 		const { rerender } = render(
-			<GuardAuthZ relation="read" object="dashboard:*">
+			<GuardAuthZ relation="read" object="role:*">
 				<TestChild />
 			</GuardAuthZ>,
 		);
@@ -316,7 +305,7 @@ describe('GuardAuthZ', () => {
 		});
 
 		rerender(
-			<GuardAuthZ relation="delete" object="dashboard:456">
+			<GuardAuthZ relation="delete" object="role:456">
 				<TestChild />
 			</GuardAuthZ>,
 		);

frontend/src/components/HeaderRightSection/AnnouncementsModal.tsx

@@ -1,4 +1,4 @@
-import { Typography } from 'antd';
+import { Typography } from '@signozhq/ui';
 
 function AnnouncementsModal(): JSX.Element {
 	return (

frontend/src/components/HeaderRightSection/FeedbackModal.tsx

@@ -1,7 +1,8 @@
 import { useCallback, useEffect, useState } from 'react';
 import { useLocation } from 'react-router-dom';
 import { toast } from '@signozhq/ui';
-import { Button, Input, Radio, RadioChangeEvent, Typography } from 'antd';
+import { Button, Input, Radio, RadioChangeEvent } from 'antd';
+import { Typography } from '@signozhq/ui';
 import logEvent from 'api/common/logEvent';
 import { handleContactSupport } from 'container/Integrations/utils';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
@@ -135,12 +136,14 @@ function FeedbackModal({ onClose }: { onClose: () => void }): JSX.Element {
 				<div className="feedback-modal-content-footer-info-text">
 					<Typography.Text>
 						Have a specific issue?{' '}
-						<Typography.Link
+						<a
+							role="button"
+							tabIndex={0}
 							className="contact-support-link"
 							onClick={handleContactSupportClick}
 						>
 							Contact Support{' '}
-						</Typography.Link>
+						</a>
 						or{' '}
 						<a
 							href="https://signoz.io/docs/introduction/"

frontend/src/components/HeaderRightSection/ShareURLModal.tsx

@@ -4,7 +4,8 @@ import { useSelector } from 'react-redux';
 import { matchPath, useLocation } from 'react-router-dom';
 import { useCopyToClipboard } from 'react-use';
 import { Color } from '@signozhq/design-tokens';
-import { Button, Switch, Typography } from 'antd';
+import { Button, Switch } from 'antd';
+import { Typography } from '@signozhq/ui';
 import logEvent from 'api/common/logEvent';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';

frontend/src/components/HeaderRightSection/__tests__/AnnouncementsModal.test.tsx

@@ -1,4 +1,3 @@
-import { describe, expect, it } from 'vitest';
 import { render, screen } from '@testing-library/react';
 
 import AnnouncementsModal from '../AnnouncementsModal';

frontend/src/components/HeaderRightSection/__tests__/FeedbackModal.test.tsx

@@ -1,6 +1,4 @@
 // Mock dependencies before imports
-import { describe, expect, beforeEach, it, vi } from 'vitest';
-import type { Mock, Mocked, MockedFunction } from 'vitest';
 import { useLocation } from 'react-router-dom';
 import { toast } from '@signozhq/ui';
 import { render, screen } from '@testing-library/react';
@@ -11,38 +9,39 @@ import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 
 import FeedbackModal from '../FeedbackModal';
 
-vi.mock('api/common/logEvent', () => ({
+jest.mock('api/common/logEvent', () => ({
 	__esModule: true,
-	default: vi.fn(() => Promise.resolve()),
+	default: jest.fn(() => Promise.resolve()),
 }));
 
-vi.mock('react-router-dom', async () => ({
-	...(await vi.importActual('react-router-dom')),
-	useLocation: vi.fn(),
+jest.mock('react-router-dom', () => ({
+	...jest.requireActual('react-router-dom'),
+	useLocation: jest.fn(),
 }));
 
-vi.mock('@signozhq/ui', () => ({
+jest.mock('@signozhq/ui', () => ({
+	...jest.requireActual('@signozhq/ui'),
 	toast: {
-		success: vi.fn(),
-		error: vi.fn(),
+		success: jest.fn(),
+		error: jest.fn(),
 	},
 }));
 
-vi.mock('hooks/useGetTenantLicense', () => ({
-	useGetTenantLicense: vi.fn(),
+jest.mock('hooks/useGetTenantLicense', () => ({
+	useGetTenantLicense: jest.fn(),
 }));
 
-vi.mock('container/Integrations/utils', () => ({
-	handleContactSupport: vi.fn(),
+jest.mock('container/Integrations/utils', () => ({
+	handleContactSupport: jest.fn(),
 }));
 
-const mockLogEvent = logEvent as MockedFunction<typeof logEvent>;
-const mockUseLocation = useLocation as Mock;
-const mockUseGetTenantLicense = useGetTenantLicense as Mock;
-const mockHandleContactSupport = handleContactSupport as Mock;
-const mockToast = toast as Mocked<typeof toast>;
+const mockLogEvent = logEvent as jest.MockedFunction<typeof logEvent>;
+const mockUseLocation = useLocation as jest.Mock;
+const mockUseGetTenantLicense = useGetTenantLicense as jest.Mock;
+const mockHandleContactSupport = handleContactSupport as jest.Mock;
+const mockToast = toast as jest.Mocked<typeof toast>;
 
-const mockOnClose = vi.fn();
+const mockOnClose = jest.fn();
 
 const mockLocation = {
 	pathname: '/test-path',
@@ -50,7 +49,7 @@ const mockLocation = {
 
 describe('FeedbackModal', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 		mockUseLocation.mockReturnValue(mockLocation);
 		mockUseGetTenantLicense.mockReturnValue({
 			isCloudUser: false,

frontend/src/components/HeaderRightSection/__tests__/HeaderRightSection.test.tsx

@@ -1,47 +1,23 @@
 // Mock dependencies before imports
-import type { ReactNode } from 'react';
-import { beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
 import { useLocation } from 'react-router-dom';
-import { render, screen, waitFor } from '@testing-library/react';
+import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import logEvent from 'api/common/logEvent';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
 
 import HeaderRightSection from '../HeaderRightSection';
 
-vi.mock('api/common/logEvent', () => ({
+jest.mock('api/common/logEvent', () => ({
 	__esModule: true,
-	default: vi.fn(),
+	default: jest.fn(),
 }));
 
-vi.mock('react-router-dom', async () => ({
-	...(await vi.importActual('react-router-dom')),
-	useLocation: vi.fn(),
+jest.mock('react-router-dom', () => ({
+	...jest.requireActual('react-router-dom'),
+	useLocation: jest.fn(),
 }));
 
-vi.mock('antd', async () => {
-	const actual = await vi.importActual<typeof import('antd')>('antd');
-
-	return {
-		...actual,
-		Popover: ({
-			children,
-			content,
-			open,
-		}: {
-			children: ReactNode;
-			content: ReactNode;
-			open?: boolean;
-		}): JSX.Element => (
-			<>
-				{children}
-				{open ? content : null}
-			</>
-		),
-	};
-});
-
-vi.mock('../FeedbackModal', () => ({
+jest.mock('../FeedbackModal', () => ({
 	__esModule: true,
 	default: ({ onClose }: { onClose: () => void }): JSX.Element => (
 		<div data-testid="feedback-modal">
@@ -52,27 +28,27 @@ vi.mock('../FeedbackModal', () => ({
 	),
 }));
 
-vi.mock('../ShareURLModal', () => ({
+jest.mock('../ShareURLModal', () => ({
 	__esModule: true,
 	default: (): JSX.Element => (
 		<div data-testid="share-modal">Share URL Modal</div>
 	),
 }));
 
-vi.mock('../AnnouncementsModal', () => ({
+jest.mock('../AnnouncementsModal', () => ({
 	__esModule: true,
 	default: (): JSX.Element => (
 		<div data-testid="announcements-modal">Announcements Modal</div>
 	),
 }));
 
-vi.mock('hooks/useGetTenantLicense', () => ({
-	useGetTenantLicense: vi.fn(),
+jest.mock('hooks/useGetTenantLicense', () => ({
+	useGetTenantLicense: jest.fn(),
 }));
 
-const mockLogEvent = logEvent as Mock;
-const mockUseLocation = useLocation as Mock;
-const mockUseGetTenantLicense = useGetTenantLicense as Mock;
+const mockLogEvent = logEvent as jest.Mock;
+const mockUseLocation = useLocation as jest.Mock;
+const mockUseGetTenantLicense = useGetTenantLicense as jest.Mock;
 
 const defaultProps = {
 	enableAnnouncements: true,
@@ -86,7 +62,7 @@ const mockLocation = {
 
 describe('HeaderRightSection', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 		mockUseLocation.mockReturnValue(mockLocation);
 		// Default to licensed user (Enterprise or Cloud)
 		mockUseGetTenantLicense.mockReturnValue({
@@ -201,9 +177,7 @@ describe('HeaderRightSection', () => {
 		// Close feedback modal
 		const closeFeedbackButton = screen.getByText('Close Feedback');
 		await user.click(closeFeedbackButton);
-		await waitFor(() => {
-			expect(screen.queryByTestId('feedback-modal')).not.toBeInTheDocument();
-		});
+		expect(screen.queryByTestId('feedback-modal')).not.toBeInTheDocument();
 	});
 
 	it('should close other modals when opening feedback modal', async () => {
@@ -223,9 +197,7 @@ describe('HeaderRightSection', () => {
 
 		await user.click(feedbackButton!);
 		expect(screen.getByTestId('feedback-modal')).toBeInTheDocument();
-		await waitFor(() => {
-			expect(screen.queryByTestId('share-modal')).not.toBeInTheDocument();
-		});
+		expect(screen.queryByTestId('share-modal')).not.toBeInTheDocument();
 	});
 
 	it('should show feedback button for Cloud users when feedback is enabled', () => {

frontend/src/components/HeaderRightSection/__tests__/ShareURLModal.test.tsx

@@ -1,6 +1,6 @@
 // Mock dependencies before imports
-import { describe, expect, it, beforeEach, vi } from 'vitest';
-import type { Mock } from 'vitest';
+// eslint-disable-next-line no-restricted-imports
+import { useSelector } from 'react-redux';
 import { matchPath, useLocation } from 'react-router-dom';
 import { useCopyToClipboard } from 'react-use';
 import { render, screen } from '@testing-library/react';
@@ -12,39 +12,35 @@ import GetMinMax from 'lib/getMinMax';
 
 import ShareURLModal from '../ShareURLModal';
 
-const hoistedReduxMocks = vi.hoisted(() => ({
-	useSelectorMock: vi.fn(),
-}));
-
-vi.mock('api/common/logEvent', () => ({
+jest.mock('api/common/logEvent', () => ({
 	__esModule: true,
-	default: vi.fn(),
+	default: jest.fn(),
 }));
 
-vi.mock('react-router-dom', async () => ({
-	...(await vi.importActual('react-router-dom')),
-	useLocation: vi.fn(),
-	matchPath: vi.fn(),
+jest.mock('react-router-dom', () => ({
+	...jest.requireActual('react-router-dom'),
+	useLocation: jest.fn(),
+	matchPath: jest.fn(),
 }));
 
-vi.mock('hooks/useUrlQuery', () => ({
+jest.mock('hooks/useUrlQuery', () => ({
 	__esModule: true,
-	default: vi.fn(),
+	default: jest.fn(),
 }));
 
-vi.mock('react-redux', async () => ({
-	...(await vi.importActual<typeof import('react-redux')>('react-redux')),
-	useSelector: hoistedReduxMocks.useSelectorMock,
+jest.mock('react-redux', () => ({
+	...jest.requireActual('react-redux'),
+	useSelector: jest.fn(),
 }));
 
-vi.mock('lib/getMinMax', () => ({
+jest.mock('lib/getMinMax', () => ({
 	__esModule: true,
-	default: vi.fn(),
+	default: jest.fn(),
 }));
 
-vi.mock('react-use', async () => ({
-	...(await vi.importActual('react-use')),
-	useCopyToClipboard: vi.fn(),
+jest.mock('react-use', () => ({
+	...jest.requireActual('react-use'),
+	useCopyToClipboard: jest.fn(),
 }));
 
 // Mock window.location
@@ -57,29 +53,29 @@ Object.defineProperty(window, 'location', {
 	writable: true,
 });
 
-const mockLogEvent = logEvent as Mock;
-const mockUseLocation = useLocation as Mock;
-const mockUseUrlQuery = useUrlQuery as Mock;
-const mockUseSelector = hoistedReduxMocks.useSelectorMock as Mock;
-const mockGetMinMax = GetMinMax as Mock;
-const mockUseCopyToClipboard = useCopyToClipboard as Mock;
-const mockMatchPath = matchPath as Mock;
+const mockLogEvent = logEvent as jest.Mock;
+const mockUseLocation = useLocation as jest.Mock;
+const mockUseUrlQuery = useUrlQuery as jest.Mock;
+const mockUseSelector = useSelector as jest.Mock;
+const mockGetMinMax = GetMinMax as jest.Mock;
+const mockUseCopyToClipboard = useCopyToClipboard as jest.Mock;
+const mockMatchPath = matchPath as jest.Mock;
 
 const mockUrlQuery = {
-	get: vi.fn(),
-	set: vi.fn(),
-	delete: vi.fn(),
-	toString: vi.fn(() => 'param=value'),
+	get: jest.fn(),
+	set: jest.fn(),
+	delete: jest.fn(),
+	toString: jest.fn(() => 'param=value'),
 };
 
-const mockHandleCopyToClipboard = vi.fn();
+const mockHandleCopyToClipboard = jest.fn();
 
 const TEST_PATH = '/test-path';
 const ENABLE_ABSOLUTE_TIME_TEXT = 'Enable absolute time';
 
 describe('ShareURLModal', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 
 		mockUseLocation.mockReturnValue({
 			pathname: TEST_PATH,

frontend/src/components/HostMetricsDetail/WaitlistFragment/WaitlistFragment.tsx

@@ -1,7 +1,8 @@
 import { useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Color } from '@signozhq/design-tokens';
-import { Button, Typography } from 'antd';
+import { Button } from 'antd';
+import { Typography } from '@signozhq/ui';
 import logEvent from 'api/common/logEvent';
 import { useNotifications } from 'hooks/useNotifications';
 import { CheckCircle2, HandPlatter } from 'lucide-react';

frontend/src/components/InputWithLabel/InputWithLabel.tsx

@@ -1,5 +1,6 @@
 import { useState } from 'react';
-import { Button, Input, Typography } from 'antd';
+import { Button, Input } from 'antd';
+import { Typography } from '@signozhq/ui';
 import cx from 'classnames';
 import { X } from 'lucide-react';
 

frontend/src/components/InviteMembersModal/__tests__/InviteMembersModal.test.tsx

@@ -1,6 +1,3 @@
-import type { ChangeEventHandler, ReactNode } from 'react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
 import inviteUsers from 'api/v1/invite/bulk/create';
 import sendInvite from 'api/v1/invite/create';
 import { StatusCodes } from 'http-status-codes';
@@ -15,114 +12,38 @@ const makeApiError = (message: string, code = StatusCodes.CONFLICT): APIError =>
 		error: { code: 'already_exists', message, url: '', errors: [] },
 	});
 
-type MockButtonProps = {
-	children?: ReactNode;
-	disabled?: boolean;
-	onClick?: () => void;
-	type?: 'button' | 'submit' | 'reset';
-	'aria-label'?: string;
-};
-
-type MockInputProps = {
-	autoComplete?: string;
-	className?: string;
-	name?: string;
-	onChange?: ChangeEventHandler<HTMLInputElement>;
-	placeholder?: string;
-	type?: string;
-	value?: string;
-};
-
-type MockDialogProps = {
-	children?: ReactNode;
-	className?: string;
-	open?: boolean;
-};
-
-const showErrorModal = vi.hoisted(() => vi.fn());
-
-vi.mock('api/v1/invite/create');
-vi.mock('api/v1/invite/bulk/create');
-vi.mock('@signozhq/ui', async () => {
-	const React = await vi.importActual<typeof import('react')>('react');
-
-	return {
-		Button: ({
-			children,
-			disabled,
-			onClick,
-			type = 'button',
-			'aria-label': ariaLabel,
-		}: MockButtonProps): JSX.Element =>
-			React.createElement(
-				'button',
-				{ 'aria-label': ariaLabel, disabled, onClick, type },
-				children,
-			),
-		Callout: ({ title }: { title?: ReactNode }): JSX.Element =>
-			React.createElement('div', null, title),
-		DialogFooter: ({ children, className }: MockDialogProps): JSX.Element =>
-			React.createElement('div', { className }, children),
-		DialogWrapper: ({
-			children,
-			className,
-			open,
-		}: MockDialogProps): JSX.Element | null =>
-			open ? React.createElement('div', { className }, children) : null,
-		Input: ({
-			autoComplete,
-			className,
-			name,
-			onChange,
-			placeholder,
-			type,
-			value,
-		}: MockInputProps): JSX.Element =>
-			React.createElement('input', {
-				autoComplete,
-				className,
-				name,
-				onChange,
-				placeholder,
-				type,
-				value,
-			}),
-		toast: {
-			success: vi.fn(),
-			error: vi.fn(),
-		},
-	};
-});
-
-vi.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: ReturnType<typeof vi.fn> } => ({
-		safeNavigate: vi.fn(),
-	}),
+jest.mock('api/v1/invite/create');
+jest.mock('api/v1/invite/bulk/create');
+jest.mock('@signozhq/ui', () => ({
+	...jest.requireActual('@signozhq/ui'),
+	toast: {
+		success: jest.fn(),
+		error: jest.fn(),
+	},
 }));
 
-vi.mock('providers/ErrorModalProvider', async () => ({
+const showErrorModal = jest.fn();
+jest.mock('providers/ErrorModalProvider', () => ({
 	__esModule: true,
-	...(await vi.importActual<typeof import('providers/ErrorModalProvider')>(
-		'providers/ErrorModalProvider',
-	)),
-	useErrorModal: vi.fn(() => ({
+	...jest.requireActual('providers/ErrorModalProvider'),
+	useErrorModal: jest.fn(() => ({
 		showErrorModal,
 		isErrorModalVisible: false,
 	})),
 }));
 
-const mockSendInvite = vi.mocked(sendInvite);
-const mockInviteUsers = vi.mocked(inviteUsers);
+const mockSendInvite = jest.mocked(sendInvite);
+const mockInviteUsers = jest.mocked(inviteUsers);
 
 const defaultProps = {
 	open: true,
-	onClose: vi.fn(),
-	onComplete: vi.fn(),
+	onClose: jest.fn(),
+	onComplete: jest.fn(),
 };
 
 describe('InviteMembersModal', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 		showErrorModal.mockClear();
 		mockSendInvite.mockResolvedValue({
 			httpStatusCode: 200,
@@ -217,7 +138,7 @@ describe('InviteMembersModal', () => {
 
 	it('uses sendInvite (single) when only one row is filled', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const onComplete = vi.fn();
+		const onComplete = jest.fn();
 
 		render(<InviteMembersModal {...defaultProps} onComplete={onComplete} />);
 
@@ -322,7 +243,7 @@ describe('InviteMembersModal', () => {
 
 	it('uses inviteUsers (bulk) when multiple rows are filled', async () => {
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
-		const onComplete = vi.fn();
+		const onComplete = jest.fn();
 
 		render(<InviteMembersModal {...defaultProps} onComplete={onComplete} />);
 

frontend/src/components/LaunchChatSupport/LaunchChatSupport.tsx

@@ -1,7 +1,8 @@
 import { useMemo, useState } from 'react';
 import { useMutation } from 'react-query';
 import { useLocation } from 'react-router-dom';
-import { Button, Modal, Tooltip, Typography } from 'antd';
+import { Button, Modal, Tooltip } from 'antd';
+import { Typography } from '@signozhq/ui';
 import logEvent from 'api/common/logEvent';
 import updateCreditCardApi from 'api/v1/checkout/create';
 import cx from 'classnames';

frontend/src/components/Loadable/Loadable.test.tsx

@@ -1,5 +1,4 @@
-import { ComponentType, lazy as reactLazy, Suspense } from 'react';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import React, { ComponentType, Suspense } from 'react';
 import {
 	render,
 	screen,
@@ -8,16 +7,6 @@ import {
 
 import Loadable from './index';
 
-vi.mock('react', async (importOriginal) => {
-	const actual = await importOriginal<typeof import('react')>();
-	const lazy = vi.fn(actual.lazy);
-
-	return {
-		...actual,
-		lazy,
-	};
-});
-
 // Sample component to be loaded lazily
 function SampleComponent(): JSX.Element {
 	return <div>Sample Component</div>;
@@ -33,10 +22,6 @@ const loadSampleComponent = (): Promise<{
 	});
 
 describe('Loadable', () => {
-	afterEach(() => {
-		vi.clearAllMocks();
-	});
-
 	it('should render the lazily loaded component', async () => {
 		const LoadableSampleComponent = Loadable(loadSampleComponent);
 
@@ -53,9 +38,12 @@ describe('Loadable', () => {
 	});
 
 	it('should call lazy with the provided import path', () => {
+		const reactLazySpy = jest.spyOn(React, 'lazy');
 		Loadable(loadSampleComponent);
 
-		expect(vi.mocked(reactLazy)).toHaveBeenCalledTimes(1);
-		expect(vi.mocked(reactLazy)).toHaveBeenCalledWith(expect.any(Function));
+		expect(reactLazySpy).toHaveBeenCalledTimes(1);
+		expect(reactLazySpy).toHaveBeenCalledWith(expect.any(Function));
+
+		reactLazySpy.mockRestore();
 	});
 });

frontend/src/components/LogDetail/index.tsx

@@ -4,7 +4,8 @@ import { useSelector } from 'react-redux'; // old code, TODO: fix this correctly
 import { useCopyToClipboard, useLocation } from 'react-use';
 import { Color, Spacing } from '@signozhq/design-tokens';
 import { Button } from '@signozhq/ui';
-import { Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
+import { Divider, Drawer, Radio, Tooltip } from 'antd';
+import { Typography } from '@signozhq/ui';
 import type { RadioChangeEvent } from 'antd/lib';
 import cx from 'classnames';
 import { LogType } from 'components/Logs/LogStateIndicator/LogStateIndicator';
@@ -587,7 +588,7 @@ function LogDetailInner({
 					<div className="log-detail-drawer__footer-hint">
 						<div className="log-detail-drawer__footer-hint-content">
 							<Typography.Text
-								type="secondary"
+								color="muted"
 								className="log-detail-drawer__footer-hint-text"
 							>
 								Use
@@ -596,7 +597,7 @@ function LogDetailInner({
 							<span>/</span>
 							<ArrowDown size={14} className="log-detail-drawer__footer-hint-icon" />
 							<Typography.Text
-								type="secondary"
+								color="muted"
 								className="log-detail-drawer__footer-hint-text"
 							>
 								to view previous/next log

frontend/src/components/Logs/CategoryHeading/index.tsx

@@ -6,7 +6,7 @@ interface ICategoryHeadingProps {
 	children: ReactNode;
 }
 function CategoryHeading({ children }: ICategoryHeadingProps): JSX.Element {
-	return <CategoryHeadingText type="secondary">{children}</CategoryHeadingText>;
+	return <CategoryHeadingText color="muted">{children}</CategoryHeadingText>;
 }
 
 export default CategoryHeading;

frontend/src/components/Logs/CategoryHeading/styles.ts

@@ -1,4 +1,4 @@
-import { Typography } from 'antd';
+import { Typography } from '@signozhq/ui';
 import styled from 'styled-components';
 
 export const CategoryHeadingText = styled(Typography.Text)`

frontend/src/components/Logs/ListLogView/index.tsx

@@ -1,6 +1,6 @@
 import { memo, useCallback, useMemo } from 'react';
 import { blue } from '@ant-design/colors';
-import { Typography } from 'antd';
+import { Typography } from '@signozhq/ui';
 import cx from 'classnames';
 import { VIEW_TYPES } from 'components/LogDetail/constants';
 import { DATE_TIME_FORMATS } from 'constants/dateTimeFormats';
@@ -89,7 +89,7 @@ function LogSelectedField({
 					</span>
 				</Typography.Text>
 			</AddToQueryHOC>
-			<Typography.Text ellipsis className={cx('selected-log-kv', fontSize)}>
+			<Typography.Text truncate={1} className={cx('selected-log-kv', fontSize)}>
 				<span className={cx('selected-log-field-key', fontSize)}>{': '}</span>
 				<span className={cx('selected-log-value', fontSize)}>
 					{fieldValue || "''"}

frontend/src/components/Logs/LogStateIndicator/LogStateIndicator.test.tsx

@@ -1,6 +1,5 @@
 import { render } from '@testing-library/react';
 import { FontSize } from 'container/OptionsMenu/types';
-import { describe, expect, it } from 'vitest';
 
 import LogStateIndicator from './LogStateIndicator';
 

frontend/src/components/Logs/LogStateIndicator/utils.test.ts

@@ -1,5 +1,3 @@
-import { describe, expect, it } from 'vitest';
-
 import { ILog } from 'types/api/logs/log';
 
 import { getLogIndicatorType, getLogIndicatorTypeForTable } from './utils';

frontend/src/components/LogsFormatOptionsMenu/LogsFormatOptionsMenu.tsx

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { Button, Input, InputNumber, Popover, Tooltip, Typography } from 'antd';
+import { Button, Input, InputNumber, Popover, Tooltip } from 'antd';
+import { Typography } from '@signozhq/ui';
 import type { DefaultOptionType } from 'antd/es/select';
 import cx from 'classnames';
 import { LogViewMode } from 'container/LogsTable';

frontend/src/components/LogsFormatOptionsMenu/__tests__/LogsFormatOptionsMenu.test.tsx

@@ -1,13 +1,11 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
 import { FontSize } from 'container/OptionsMenu/types';
 import { fireEvent, render, waitFor } from 'tests/test-utils';
 
 import LogsFormatOptionsMenu from '../LogsFormatOptionsMenu';
 
-const mockUpdateFormatting = vi.hoisted(() => vi.fn());
+const mockUpdateFormatting = jest.fn();
 
-vi.mock('providers/preferences/sync/usePreferenceSync', () => ({
+jest.mock('providers/preferences/sync/usePreferenceSync', () => ({
 	usePreferenceSync: (): any => ({
 		preferences: {
 			columns: [],
@@ -20,17 +18,11 @@ vi.mock('providers/preferences/sync/usePreferenceSync', () => ({
 		},
 		loading: false,
 		error: null,
-		updateColumns: vi.fn(),
+		updateColumns: jest.fn(),
 		updateFormatting: mockUpdateFormatting,
 	}),
 }));
 
-vi.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: ReturnType<typeof vi.fn> } => ({
-		safeNavigate: vi.fn(),
-	}),
-}));
-
 describe('LogsFormatOptionsMenu (unit)', () => {
 	beforeEach(() => {
 		mockUpdateFormatting.mockClear();
@@ -39,9 +31,9 @@ describe('LogsFormatOptionsMenu (unit)', () => {
 	function setup(): {
 		getByTestId: ReturnType<typeof render>['getByTestId'];
 		findItemByLabel: (label: string) => Element | undefined;
-		formatOnChange: ReturnType<typeof vi.fn>;
-		maxLinesOnChange: ReturnType<typeof vi.fn>;
-		fontSizeOnChange: ReturnType<typeof vi.fn>;
+		formatOnChange: jest.Mock<any, any>;
+		maxLinesOnChange: jest.Mock<any, any>;
+		fontSizeOnChange: jest.Mock<any, any>;
 	} {
 		const items = [
 			{ key: 'raw', label: 'Raw', data: { title: 'max lines per row' } },
@@ -49,9 +41,9 @@ describe('LogsFormatOptionsMenu (unit)', () => {
 			{ key: 'table', label: 'Column', data: { title: 'columns' } },
 		];
 
-		const formatOnChange = vi.fn();
-		const maxLinesOnChange = vi.fn();
-		const fontSizeOnChange = vi.fn();
+		const formatOnChange = jest.fn();
+		const maxLinesOnChange = jest.fn();
+		const fontSizeOnChange = jest.fn();
 
 		const { getByTestId } = render(
 			<LogsFormatOptionsMenu
@@ -65,11 +57,11 @@ describe('LogsFormatOptionsMenu (unit)', () => {
 						isFetching: false,
 						value: [],
 						options: [],
-						onFocus: vi.fn(),
-						onBlur: vi.fn(),
-						onSearch: vi.fn(),
-						onSelect: vi.fn(),
-						onRemove: vi.fn(),
+						onFocus: jest.fn(),
+						onBlur: jest.fn(),
+						onSearch: jest.fn(),
+						onSelect: jest.fn(),
+						onRemove: jest.fn(),
 					},
 				}}
 			/>,

frontend/src/components/MembersTable/__tests__/MembersTable.test.tsx

@@ -1,27 +1,8 @@
-import type { ReactNode } from 'react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { MockedFunction } from 'vitest';
-
 import { MemberStatus } from 'container/MembersSettings/utils';
 import { render, screen, userEvent } from 'tests/test-utils';
 
 import MembersTable, { MemberRow } from '../MembersTable';
 
-vi.mock('@signozhq/ui', async () => {
-	const React = await vi.importActual<typeof import('react')>('react');
-
-	return {
-		Badge: ({ children }: { children?: ReactNode }): JSX.Element =>
-			React.createElement('span', null, children),
-	};
-});
-
-vi.mock('hooks/useSafeNavigate', () => ({
-	useSafeNavigate: (): { safeNavigate: ReturnType<typeof vi.fn> } => ({
-		safeNavigate: vi.fn(),
-	}),
-}));
-
 const mockActiveMembers: MemberRow[] = [
 	{
 		id: 'user-1',
@@ -53,13 +34,13 @@ const defaultProps = {
 	currentPage: 1,
 	pageSize: 20,
 	searchQuery: '',
-	onPageChange: vi.fn(),
-	onRowClick: vi.fn(),
+	onPageChange: jest.fn(),
+	onRowClick: jest.fn(),
 };
 
 describe('MembersTable', () => {
 	beforeEach(() => {
-		vi.clearAllMocks();
+		jest.clearAllMocks();
 	});
 
 	it('renders member rows with name, email, and ACTIVE status', () => {
@@ -84,7 +65,9 @@ describe('MembersTable', () => {
 	});
 
 	it('calls onRowClick with the member data when a row is clicked', async () => {
-		const onRowClick = vi.fn() as MockedFunction<(member: MemberRow) => void>;
+		const onRowClick = jest.fn() as jest.MockedFunction<
+			(member: MemberRow) => void
+		>;
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 
 		render(
@@ -104,7 +87,7 @@ describe('MembersTable', () => {
 	});
 
 	it('renders DELETED badge and calls onRowClick when a deleted member row is clicked', async () => {
-		const onRowClick = vi.fn();
+		const onRowClick = jest.fn();
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 		const deletedMember: MemberRow = {
 			id: 'user-del',

frontend/src/components/MessageTip/MessageTip.test.tsx

@@ -1,4 +1,3 @@
-import { describe, expect, it } from 'vitest';
 import { render, screen } from '@testing-library/react';
 
 import MessageTip from './index';

frontend/src/components/MessageTip/__snapshots__/MessageTip.test.tsx.snap

@@ -1,8 +1,15 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`MessageTip custom action 1`] = `
+.c0 {
+  -webkit-align-items: center;
+  -webkit-box-align: center;
+  -ms-flex-align: center;
+  align-items: center;
+}
 
-exports[`MessageTip > custom action 1`] = `
 <div
-  class="ant-alert ant-alert-info ant-alert-with-description sc-aXZVg bzzGSj css-dev-only-do-not-override-2i2tap"
+  class="ant-alert ant-alert-info ant-alert-with-description c0 css-dev-only-do-not-override-2i2tap"
   data-show="true"
   role="alert"
 >

frontend/src/components/MessagingQueueHealthCheck/AttributeCheckList.tsx

@@ -1,15 +1,8 @@
+import { Typography } from '@signozhq/ui';
 import { ReactNode, useEffect, useState } from 'react';
 import { useHistory } from 'react-router-dom';
 import { CaretDownOutlined, LoadingOutlined } from '@ant-design/icons';
-import {
-	Modal,
-	Select,
-	Spin,
-	Tooltip,
-	Tree,
-	TreeDataNode,
-	Typography,
-} from 'antd';
+import { Modal, Select, Spin, Tooltip, Tree, TreeDataNode } from 'antd';
 import { OnboardingStatusResponse } from 'api/messagingQueues/onboarding/getOnboardingStatus';
 import { QueryParams } from 'constants/query';
 import ROUTES from 'constants/routes';
@@ -84,9 +77,11 @@ function ErrorTitleAndKey({
 		key: `${title}-key-${uuid()}`,
 		title: (
 			<div className="attribute-error-title">
-				<Typography.Text className="tree-text" ellipsis={{ tooltip: title }}>
-					{title}
-				</Typography.Text>
+				<Tooltip title={title}>
+					<Typography.Text className="tree-text" truncate={1}>
+						{title}
+					</Typography.Text>
+				</Tooltip>
 				<Tooltip title={errorMsg}>
 					<div
 						className="attribute-error-warning"
@@ -125,9 +120,11 @@ function treeTitleAndKey({
 		key: `${title}-key-${uuid()}`,
 		title: (
 			<div className="attribute-success-title">
-				<Typography.Text className="tree-text" ellipsis={{ tooltip: title }}>
-					{title}
-				</Typography.Text>
+				<Tooltip title={title}>
+					<Typography.Text className="tree-text" truncate={1}>
+						{title}
+					</Typography.Text>
+				</Tooltip>
 				{isLeaf && (
 					<div className="success-attribute-icon">
 						<Tooltip title="Success">

frontend/src/components/NewSelect/CustomMultiSelect.tsx

@@ -13,7 +13,8 @@ import {
 	ReloadOutlined,
 } from '@ant-design/icons';
 import { Color } from '@signozhq/design-tokens';
-import { Button, Checkbox, Select, Typography } from 'antd';
+import { Button, Checkbox, Select } from 'antd';
+import { Typography } from '@signozhq/ui';
 import cx from 'classnames';
 import TextToolTip from 'components/TextToolTip/TextToolTip';
 import { SOMETHING_WENT_WRONG } from 'constants/api';
@@ -755,15 +756,7 @@ const CustomMultiSelect: React.FC<CustomMultiSelectProps> = ({
 						}}
 					>
 						<div className="option-content">
-							<Typography.Text
-								ellipsis={{
-									tooltip: {
-										placement: 'right',
-										autoAdjustOverflow: true,
-									},
-								}}
-								className="option-label-text"
-							>
+							<Typography.Text truncate={1} className="option-label-text">
 								{highlightMatchedText(String(option.label || ''), searchText)}
 							</Typography.Text>
 							{(option.type === 'custom' || option.type === 'regex') && (

frontend/src/components/NewSelect/__test__/CustomMultiSelect.comprehensive.test.tsx

@@ -1,14 +1,11 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { VirtuosoMockContext } from 'react-virtuoso';
 import { render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 
 import CustomMultiSelect from '../CustomMultiSelect';
-import type { CustomMultiSelectProps } from '../types';
-import type { MockedFunction } from 'vitest';
 
 // Mock scrollIntoView which isn't available in JSDOM
-window.HTMLElement.prototype.scrollIntoView = vi.fn();
+window.HTMLElement.prototype.scrollIntoView = jest.fn();
 
 // Helper function to render with VirtuosoMockContext
 const renderWithVirtuoso = (
@@ -20,18 +17,10 @@ const renderWithVirtuoso = (
 		</VirtuosoMockContext.Provider>,
 	);
 
-const expectDropdownToBeClosingOrHidden = (dropdown: Element | null): void => {
-	expect(dropdown).toBeInTheDocument();
-	expect(dropdown?.className).toMatch(
-		/ant-select-dropdown-hidden|ant-slide-up-leave/,
-	);
-};
-
 // Mock clipboard API
-Object.defineProperty(navigator, 'clipboard', {
-	configurable: true,
-	value: {
-		writeText: vi.fn(() => Promise.resolve()),
+Object.assign(navigator, {
+	clipboard: {
+		writeText: jest.fn(() => Promise.resolve()),
 	},
 });
 
@@ -62,18 +51,12 @@ const mockGroupedOptions = [
 
 describe('CustomMultiSelect - Comprehensive Tests', () => {
 	let user: ReturnType<typeof userEvent.setup>;
-	let mockOnChange: MockedFunction<
-		NonNullable<CustomMultiSelectProps['onChange']>
-	>;
+	let mockOnChange: jest.Mock;
 
 	beforeEach(() => {
 		user = userEvent.setup();
-		mockOnChange = vi.fn();
-		vi.clearAllMocks();
-	});
-
-	afterEach(() => {
-		vi.clearAllMocks();
+		mockOnChange = jest.fn();
+		jest.clearAllMocks();
 	});
 
 	// ===== 1. CUSTOM VALUES SUPPORT =====
@@ -822,7 +805,7 @@ describe('CustomMultiSelect - Comprehensive Tests', () => {
 	// ===== 7. SAVE AND SELECTION TRIGGERS =====
 	describe('Save and Selection Triggers (ST)', () => {
 		it('ST-01: ESC triggers save action', async () => {
-			const mockDropdownChange = vi.fn();
+			const mockDropdownChange = jest.fn();
 
 			renderWithVirtuoso(
 				<CustomMultiSelect
@@ -849,7 +832,8 @@ describe('CustomMultiSelect - Comprehensive Tests', () => {
 			await waitFor(() => {
 				// Dropdown should be hidden (not completely removed from DOM)
 				const dropdown = document.querySelector('.ant-select-dropdown');
-				expectDropdownToBeClosingOrHidden(dropdown);
+				expect(dropdown).toHaveClass('ant-select-dropdown-hidden');
+				expect(dropdown).toHaveStyle('pointer-events: none');
 			});
 		});
 
@@ -940,7 +924,7 @@ describe('CustomMultiSelect - Comprehensive Tests', () => {
 			// Dropdown should close and search text should be cleared
 			await waitFor(() => {
 				const dropdown = document.querySelector('.ant-select-dropdown');
-				expectDropdownToBeClosingOrHidden(dropdown);
+				expect(dropdown).toHaveClass('ant-select-dropdown-hidden');
 				expect(searchInput).toHaveValue('');
 			});
 		});
@@ -1173,7 +1157,7 @@ describe('CustomMultiSelect - Comprehensive Tests', () => {
 			await waitFor(() => {
 				const dropdown = document.querySelector('.ant-select-dropdown');
 				// The dropdown should be hidden with the hidden class
-				expectDropdownToBeClosingOrHidden(dropdown);
+				expect(dropdown).toHaveClass('ant-select-dropdown-hidden');
 			});
 		});
 	});
@@ -1284,7 +1268,7 @@ describe('CustomMultiSelect - Comprehensive Tests', () => {
 	// ===== 11. ADVANCED CLEAR ACTIONS =====
 	describe('Advanced Clear Actions (ACA)', () => {
 		it('ACA-01: Clear action waiting behavior', async () => {
-			const mockOnChangeWithDelay = vi.fn().mockImplementation(
+			const mockOnChangeWithDelay = jest.fn().mockImplementation(
 				() =>
 					new Promise<void>((resolve) => {
 						setTimeout(() => resolve(), 100);
@@ -1507,7 +1491,7 @@ describe('CustomMultiSelect - Comprehensive Tests', () => {
 
 			await waitFor(() => {
 				const dropdown = document.querySelector('.ant-select-dropdown');
-				expectDropdownToBeClosingOrHidden(dropdown);
+				expect(dropdown).toHaveClass('ant-select-dropdown-hidden');
 			});
 		});
 	});